class_docstr: Define event listeners for schema objects,
  that is, :class:`.SchemaItem` and other :class:`.SchemaEventTarget`
  subclasses, including :class:`_schema.MetaData`, :class:`_schema.Table`,
  :class:`_schema.Column`, etc.
  
  **Create / Drop Events**
  
  Events emitted when CREATE and DROP commands are emitted to the database.
  The event hooks in this category include :meth:`.DDLEvents.before_create`,
  :meth:`.DDLEvents.after_create`, :meth:`.DDLEvents.before_drop`, and
  :meth:`.DDLEvents.after_drop`.
  
  These events are emitted when using schema-level methods such as
  :meth:`.MetaData.create_all` and :meth:`.MetaData.drop_all`. Per-object
  create/drop methods such as :meth:`.Table.create`, :meth:`.Table.drop`,
  :meth:`.Index.create` are also included, as well as dialect-specific
  methods such as :meth:`_postgresql.ENUM.create`.
  
  .. versionadded:: 2.0 :class:`.DDLEvents` event hooks now take place
     for non-table objects including constraints, indexes, and
     dialect-specific schema types.
  
  Event hooks may be attached directly to a :class:`_schema.Table` object or
  to a :class:`_schema.MetaData` collection, as well as to any
  :class:`.SchemaItem` class or object that can be individually created and
  dropped using a distinct SQL command. Such classes include :class:`.Index`,
  :class:`.Sequence`, and dialect-specific classes such as
  :class:`_postgresql.ENUM`.
  
  Example using the :meth:`.DDLEvents.after_create` event, where a custom
  event hook will emit an ``ALTER TABLE`` command on the current connection,
  after ``CREATE TABLE`` is emitted::
  
      from sqlalchemy import create_engine
      from sqlalchemy import event
      from sqlalchemy import Table, Column, Metadata, Integer
  
      m = MetaData()
      some_table = Table('some_table', m, Column('data', Integer))
  
      @event.listens_for(some_table, "after_create")
      def after_create(target, connection, **kw):
          connection.execute(text(
              "ALTER TABLE %s SET name=foo_%s" % (target.name, target.name)
          ))
  
  
      some_engine = create_engine("postgresql://scott:tiger@host/test")
  
      # will emit "CREATE TABLE some_table" as well as the above
      # "ALTER TABLE" statement afterwards
      m.create_all(some_engine)
  
  Constraint objects such as :class:`.ForeignKeyConstraint`,
  :class:`.UniqueConstraint`, :class:`.CheckConstraint` may also be
  subscribed to these events, however they will **not** normally produce
  events as these objects are usually rendered inline within an
  enclosing ``CREATE TABLE`` statement and implicitly dropped from a
  ``DROP TABLE`` statement.
  
  For the :class:`.Index` construct, the event hook will be emitted
  for ``CREATE INDEX``, however SQLAlchemy does not normally emit
  ``DROP INDEX`` when dropping tables as this is again implicit within the
  ``DROP TABLE`` statement.
  
  .. versionadded:: 2.0 Support for :class:`.SchemaItem` objects
     for create/drop events was expanded from its previous support for
     :class:`.MetaData` and :class:`.Table` to also include
     :class:`.Constraint` and all subclasses, :class:`.Index`,
     :class:`.Sequence` and some type-related constructs such as
     :class:`_postgresql.ENUM`.
  
  .. note:: These event hooks are only emitted within the scope of
     SQLAlchemy's create/drop methods; they are not necessarily supported
     by tools such as `alembic <https://alembic.sqlalchemy.org>`_.
  
  
  **Attachment Events**
  
  Attachment events are provided to customize
  behavior whenever a child schema element is associated
  with a parent, such as when a :class:`_schema.Column` is associated
  with its :class:`_schema.Table`, when a
  :class:`_schema.ForeignKeyConstraint`
  is associated with a :class:`_schema.Table`, etc.  These events include
  :meth:`.DDLEvents.before_parent_attach` and
  :meth:`.DDLEvents.after_parent_attach`.
  
  **Reflection Events**
  
  The :meth:`.DDLEvents.column_reflect` event is used to intercept
  and modify the in-Python definition of database columns when
  :term:`reflection` of database tables proceeds.
  
  **Use with Generic DDL**
  
  DDL events integrate closely with the
  :class:`.DDL` class and the :class:`.ExecutableDDLElement` hierarchy
  of DDL clause constructs, which are themselves appropriate
  as listener callables::
  
      from sqlalchemy import DDL
      event.listen(
          some_table,
          "after_create",
          DDL("ALTER TABLE %(table)s SET name=foo_%(table)s")
      )
  
  **Event Propagation to MetaData Copies**
  
  For all :class:`.DDLEvent` events, the ``propagate=True`` keyword argument
  will ensure that a given event handler is propagated to copies of the
  object, which are made when using the :meth:`_schema.Table.to_metadata`
  method::
  
      from sqlalchemy import DDL
  
      metadata = MetaData()
      some_table = Table("some_table", metadata, Column("data", Integer))
  
      event.listen(
          some_table,
          "after_create",
          DDL("ALTER TABLE %(table)s SET name=foo_%(table)s"),
          propagate=True
      )
  
      new_metadata = MetaData()
      new_table = some_table.to_metadata(new_metadata)
  
  The above :class:`.DDL` object will be associated with the
  :meth:`.DDLEvents.after_create` event for both the ``some_table`` and
  the ``new_table`` :class:`.Table` objects.
  
  .. seealso::
  
      :ref:`event_toplevel`
  
      :class:`.ExecutableDDLElement`
  
      :class:`.DDL`
  
      :ref:`schema_ddl_sequences`
docstr: Called after a :class:`.SchemaItem` is associated with
  a parent :class:`.SchemaItem`.
  
  :param target: the target object
  :param parent: the parent to which the target is being attached.
  
  :func:`.event.listen` also accepts the ``propagate=True``
  modifier for this event; when True, the listener function will
  be established for any copies made of the target object,
  i.e. those copies that are generated when
  :meth:`_schema.Table.to_metadata` is used.
docstr_tok: ["Called","after","a",":","class",":","`",".SchemaItem","`","is","associated","with","a","parent",":","class",":","`",".SchemaItem","`",".",":","param","target",":","the","target","object",":","param","parent",":","the","parent","to","which","the","target","is","being","attached",".",":","func",":","`",".event.listen","`","also","accepts","the","``","propagate=True","``","modifier","for","this","event",";","when","True",",","the","listener","function","will","be","established","for","any","copies","made","of","the","target","object",",","i.e",".","those","copies","that","are","generated","when",":","meth",":","`","_schema.Table.to_metadata","`","is","used","."]
code: def after_parent_attach(
      self, target: SchemaEventTarget, parent: SchemaItem
  ) -> None:
      """Called after a :class:`.SchemaItem` is associated with
      a parent :class:`.SchemaItem`.
  
      :param target: the target object
      :param parent: the parent to which the target is being attached.
  
      :func:`.event.listen` also accepts the ``propagate=True``
      modifier for this event; when True, the listener function will
      be established for any copies made of the target object,
      i.e. those copies that are generated when
      :meth:`_schema.Table.to_metadata` is used.
  
      """
  
file_path: sqlalchemy/lib/sqlalchemy/sql/events.py
imports: from __future__ import annotations
  from typing import Any
  from typing import TYPE_CHECKING
  from .base import SchemaEventTarget
  from ..None import event
label_desc: Use image node_id 6 for calling the DDLEvents obj's underlying member method code with example usage: obj.after_parent_attach(target, parent) without return types