sqlalchemy.orm.events.InstrumentationEvents

class documentation

class InstrumentationEvents(event.Events[InstrumentationFactory]): (source)

View In Hierarchy

Events related to class instrumentation events. The listeners here support being established against any new style class, that is any object that is a subclass of 'type'. Events will then be fired off for events against that class. If the "propagate=True" flag is passed to event.listen(), the event will fire off for subclasses of that class as well. The Python ``type`` builtin is also accepted as a target, which when used has the effect of events being emitted for all classes. Note the "propagate" flag here is defaulted to ``True``, unlike the other class level events where it defaults to ``False``. This means that new subclasses will also be the subject of these events, when a listener is established on a superclass.

Method attribute_instrument Called when an attribute is instrumented.
Method class_instrument Called after the given class is instrumented.
Method class_uninstrument Called before the given class is uninstrumented.
Class Method _accept_with Undocumented
Class Method _clear Undocumented
Class Method _listen Undocumented
Class Variable _target_class_doc Undocumented

Inherited from Events:

Class Method _remove Undocumented

Inherited from _HasEventsDispatch (via Events):

Method __getattr__ Undocumented
Method __init_subclass__ Intercept new Event subclasses and create associated _Dispatch classes.
Class Variable dispatch reference back to the _Dispatch class.
Class Method _create_dispatcher_class Create a :class:`._Dispatch` class corresponding to an :class:`.Events` class.
Static Method _set_dispatch Undocumented
Class Variable _dispatch_target class which will receive the .dispatch collection
def attribute_instrument(self, cls: ClassManager[_O], key: _KT, inst: _O): (source)

Called when an attribute is instrumented.

def class_instrument(self, cls: ClassManager[_O]): (source)

Called after the given class is instrumented. To get at the :class:`.ClassManager`, use :func:`.manager_of_class`.

def class_uninstrument(self, cls: ClassManager[_O]): (source)

Called before the given class is uninstrumented. To get at the :class:`.ClassManager`, use :func:`.manager_of_class`.

@classmethod
def _accept_with(cls, target: Union[InstrumentationFactory, Type[InstrumentationFactory]], identifier: str) -> Optional[Union[InstrumentationFactory, Type[InstrumentationFactory]]]: (source)
overrides sqlalchemy.event.base.Events._accept_with

Undocumented

@classmethod
def _clear(cls): (source)
overrides sqlalchemy.event.base.Events._clear

Undocumented

@classmethod
def _listen(cls, event_key: _EventKey[_T], propagate: bool = True, **kw: Any): (source)
overrides sqlalchemy.event.base.Events._listen

Undocumented

_target_class_doc: str = (source)

Undocumented