- wip - start factoring events so that we aren't using descriptors for dispatch,

allowing us to move to __slots__

1 files changed, 98 insertions, 48 deletions

diff --git a/lib/sqlalchemy/event/base.py b/lib/sqlalchemy/event/base.py
index 37bd2c49e..962d850c2 100644
--- a/lib/sqlalchemy/event/base.py
+++ b/lib/sqlalchemy/event/base.py
@@ -17,9 +17,11 @@ instances of ``_Dispatch``.
 """
 from __future__ import absolute_import
 
+import weakref
+
 from .. import util
-from .attr import _JoinedDispatchDescriptor, \
-    _EmptyListener, _DispatchDescriptor
+from .attr import _JoinedListener, \
+    _EmptyListener, _ClsLevelDispatch
 
 _registrars = util.defaultdict(list)
 
@@ -34,10 +36,11 @@ class _UnpickleDispatch(object):
 
     """
 
-    def __call__(self, _parent_cls):
-        for cls in _parent_cls.__mro__:
+    def __call__(self, _instance_cls):
+        for cls in _instance_cls.__mro__:
             if 'dispatch' in cls.__dict__:
-                return cls.__dict__['dispatch'].dispatch_cls(_parent_cls)
+                return cls.__dict__['dispatch'].\
+                    dispatch_cls._for_class(_instance_cls)
         else:
             raise AttributeError("No class with a 'dispatch' member present.")
 
@@ -62,16 +65,41 @@ class _Dispatch(object):
 
     """
 
-    _events = None
-    """reference the :class:`.Events` class which this
-        :class:`._Dispatch` is created for."""
-
-    def __init__(self, _parent_cls):
-        self._parent_cls = _parent_cls
-
-    @util.classproperty
-    def _listen(cls):
-        return cls._events._listen
+    # in one ORM edge case, an attribute is added to _Dispatch,
+    # so __dict__ is used in just that case and potentially others.
+    __slots__ = '_parent', '_instance_cls', '__dict__'
+
+    _empty_listeners = weakref.WeakKeyDictionary()
+
+    def __init__(self, parent, instance_cls=None):
+        self._parent = parent
+        self._instance_cls = instance_cls
+        if instance_cls:
+            try:
+                _empty_listeners = self._empty_listeners[instance_cls]
+            except KeyError:
+                _empty_listeners = self._empty_listeners[instance_cls] = [
+                    _EmptyListener(ls, instance_cls)
+                    for ls in parent._event_descriptors
+                ]
+            for ls in _empty_listeners:
+                setattr(self, ls.name, ls)
+
+    @property
+    def _event_descriptors(self):
+        for k in self._event_names:
+            yield getattr(self, k)
+
+    def _for_class(self, instance_cls):
+        return self.__class__(self, instance_cls)
+
+    def _for_instance(self, instance):
+        instance_cls = instance.__class__
+        return self._for_class(instance_cls)
+
+    @property
+    def _listen(self):
+        return self._events._listen
 
     def _join(self, other):
         """Create a 'join' of this :class:`._Dispatch` and another.
@@ -83,36 +111,27 @@ class _Dispatch(object):
         if '_joined_dispatch_cls' not in self.__class__.__dict__:
             cls = type(
                 "Joined%s" % self.__class__.__name__,
-                (_JoinedDispatcher, self.__class__), {}
+                (_JoinedDispatcher, ), {'__slots__': self._event_names}
             )
-            for ls in _event_descriptors(self):
-                setattr(cls, ls.name, _JoinedDispatchDescriptor(ls.name))
 
             self.__class__._joined_dispatch_cls = cls
         return self._joined_dispatch_cls(self, other)
 
     def __reduce__(self):
-        return _UnpickleDispatch(), (self._parent_cls, )
+        return _UnpickleDispatch(), (self._instance_cls, )
 
     def _update(self, other, only_propagate=True):
         """Populate from the listeners in another :class:`_Dispatch`
             object."""
-
-        for ls in _event_descriptors(other):
+        for ls in other._event_descriptors:
             if isinstance(ls, _EmptyListener):
                 continue
             getattr(self, ls.name).\
                 for_modify(self)._update(ls, only_propagate=only_propagate)
 
-    @util.hybridmethod
     def _clear(self):
-        for attr in dir(self):
-            if _is_event_name(attr):
-                getattr(self, attr).for_modify(self).clear()
-
-
-def _event_descriptors(target):
-    return [getattr(target, k) for k in dir(target) if _is_event_name(k)]
+        for ls in self._event_descriptors:
+            ls.for_modify(self).clear()
 
 
 class _EventMeta(type):
@@ -131,26 +150,37 @@ def _create_dispatcher_class(cls, classname, bases, dict_):
     # there's all kinds of ways to do this,
     # i.e. make a Dispatch class that shares the '_listen' method
     # of the Event class, this is the straight monkeypatch.
-    dispatch_base = getattr(cls, 'dispatch', _Dispatch)
+    if hasattr(cls, 'dispatch'):
+        dispatch_base = cls.dispatch.__class__
+    else:
+        dispatch_base = _Dispatch
+
+    event_names = [k for k in dict_ if _is_event_name(k)]
     dispatch_cls = type("%sDispatch" % classname,
-                        (dispatch_base, ), {})
-    cls._set_dispatch(cls, dispatch_cls)
+                        (dispatch_base, ), {'__slots__': event_names})
+
+    dispatch_cls._event_names = event_names
 
-    for k in dict_:
-        if _is_event_name(k):
-            setattr(dispatch_cls, k, _DispatchDescriptor(cls, dict_[k]))
-            _registrars[k].append(cls)
+    dispatch_inst = cls._set_dispatch(cls, dispatch_cls)
+    for k in dispatch_cls._event_names:
+        setattr(dispatch_inst, k, _ClsLevelDispatch(cls, dict_[k]))
+        _registrars[k].append(cls)
+
+    for super_ in dispatch_cls.__bases__:
+        if issubclass(super_, _Dispatch) and super_ is not _Dispatch:
+            for ls in super_._events.dispatch._event_descriptors:
+                setattr(dispatch_inst, ls.name, ls)
+                dispatch_cls._event_names.append(ls.name)
 
     if getattr(cls, '_dispatch_target', None):
         cls._dispatch_target.dispatch = dispatcher(cls)
 
 
 def _remove_dispatcher(cls):
-    for k in dir(cls):
-        if _is_event_name(k):
-            _registrars[k].remove(cls)
-            if not _registrars[k]:
-                del _registrars[k]
+    for k in cls.dispatch._event_names:
+        _registrars[k].remove(cls)
+        if not _registrars[k]:
+            del _registrars[k]
 
 
 class Events(util.with_metaclass(_EventMeta, object)):
@@ -163,17 +193,30 @@ class Events(util.with_metaclass(_EventMeta, object)):
         # "self.dispatch._events.<utilitymethod>"
         # @staticemethod to allow easy "super" calls while in a metaclass
         # constructor.
-        cls.dispatch = dispatch_cls
+        cls.dispatch = dispatch_cls(None)
         dispatch_cls._events = cls
+        return cls.dispatch
 
     @classmethod
     def _accept_with(cls, target):
         # Mapper, ClassManager, Session override this to
         # also accept classes, scoped_sessions, sessionmakers, etc.
         if hasattr(target, 'dispatch') and (
-            isinstance(target.dispatch, cls.dispatch) or
-            isinstance(target.dispatch, type) and
-            issubclass(target.dispatch, cls.dispatch)
+
+                isinstance(target.dispatch, cls.dispatch.__class__) or
+
+
+                (
+                    isinstance(target.dispatch, type) and
+                    isinstance(target.dispatch, cls.dispatch.__class__)
+                ) or
+
+                (
+                    isinstance(target.dispatch, _JoinedDispatcher) and
+                    isinstance(target.dispatch.parent, cls.dispatch.__class__)
+                )
+
+
         ):
             return target
         else:
@@ -195,12 +238,19 @@ class Events(util.with_metaclass(_EventMeta, object)):
 class _JoinedDispatcher(object):
     """Represent a connection between two _Dispatch objects."""
 
-    __slots__ = 'local', 'parent', '_parent_cls'
+    __slots__ = 'local', 'parent', '_instance_cls'
 
     def __init__(self, local, parent):
         self.local = local
         self.parent = parent
-        self._parent_cls = local._parent_cls
+        self._instance_cls = self.local._instance_cls
+        for ls in local._event_descriptors:
+            setattr(self, ls.name, _JoinedListener(
+                parent, ls.name, ls))
+
+    @property
+    def _listen(self):
+        return self.parent._listen
 
 
 class dispatcher(object):
@@ -218,5 +268,5 @@ class dispatcher(object):
     def __get__(self, obj, cls):
         if obj is None:
             return self.dispatch_cls
-        obj.__dict__['dispatch'] = disp = self.dispatch_cls(cls)
+        obj.__dict__['dispatch'] = disp = self.dispatch_cls._for_instance(obj)
         return disp