Ticket #4561: dispatch-smart-signals-fix-bitrot.patch

django/dispatch/weaksets.py

@@ +1 @@
+from weakref import WeakKeyDictionary
+
+class WeakSet(object):
+    def __init__(self, initial_vals=None):
+        self._map = WeakKeyDictionary()
+        if initial_vals is not None:
+            self.update(initial_vals)
+        self.remove = self._map.__delitem__
+        self.add = self._map.setdefault
+
+    def update(self, iterable):
+        map(self._map.setdefault, iterable)
+
+    def __len__(self):
+        return len(self._map)
+
+    def __iter__(self):
+        return iter(self._map)
+
+    def discard(self, key):
+        self._map.pop(key, None)
+
+    def __nonzero__(self):
+        return bool(self._map)
+
+    def __repr__(self):
+        return "WeakSet(%r)" % self._map.keys()
+
+    def __str__(self):
+        return "WeakSet(%s)" % self._map.keys()
+
+    def __contains__(self, key):
+        return key in self._map

tests/regressiontests/dispatch/tests/test_new_signals.py

@@ +1 @@
+from django import dispatch
+from django.dispatch import dispatcher
+from unittest import TestCase
+
+class base(TestCase):
+
+    def assertIn(self, needle, haystack, msg=None):
+        if msg is None:
+            msg = "%s wasn't in %s" % (needle, haystack)
+        self.assertTrue((needle in haystack), msg=msg)
+
+class test_signal(base):
+
+    kls = staticmethod(dispatch.signal)
+
+    def test_str(self):
+        self.assertEqual(str(self.kls("asdf")), "asdf")
+
+    def test_repr(self):
+        o = self.kls("foon")
+        self.assertEqual(repr(o), "<signal signal='foon' @#%x>" % id(o))
+
+class test_mk_signal(base):
+
+    func = staticmethod(dispatch.mk_signal)
+
+    def test_it(self):
+        o = self.func("sig1")
+        self.assertEqual(o.__doc__, dispatch.signal.__doc__)
+        self.assertEqual(o.signal_name, "sig1")
+        docstring="mr. super-happy docstring says gimme candy"
+        o = self.func("sig2", docstring=docstring)
+        self.assertEqual(o.__doc__, docstring)
+        self.assertEqual(o.signal_name, 'sig2')
+        class dar(dispatch.signal):pass
+        self.assertEqual(self.func('sig3', signal_kls=dar).__class__, dar)
+
+class protect_signals_state_mixin(object):
+
+    """mixin basically wiping the smart_signals state information clean after backing
+    up a copy; upon completion of a fixture, restores the state.
+    
+    Note you cannot rely on existing connections/listeners in any tests using this mixin-
+    as said, the state is reset, then restored around the fixture
+    """
+
+    def setUp(self):
+        self._known_sigs = dispatch.smart_signal.known_signals.items()
+        self._any_any = dispatch.smart_signal.any_any_count
+        self._all_known_senders = dispatch.smart_signal.all_known_senders.items()
+        dispatch.smart_signal.known_signals.clear()
+        dispatch.smart_signal.any_any_count = 0
+        dispatch.smart_signal.all_known_senders.clear()
+
+    def tearDown(self):
+        dispatch.smart_signal.known_signals.clear()
+        dispatch.smart_signal.known_signals.update(self._known_sigs)
+        dispatch.smart_signal.any_any_count = self._any_any
+        dispatch.smart_signal.all_known_senders.clear()
+        dispatch.smart_signal.all_known_senders.update(self._all_known_senders)
+
+class smart_signals_mixin(protect_signals_state_mixin):
+
+    def mk_signal(self, name="test-signal"):
+        class tracking_sig(dispatch.smart_signal):
+            def __init__(self, *args):
+                dispatch.smart_signal.__init__(self, *args)
+                self.enables, self.disables = [], []
+
+            def _enable_sender(self, sender, incr):
+                self.enables.append((sender, incr))
+
+            def _disable_sender(self, sender, incr):
+                self.disables.append((sender, incr))
+
+        return tracking_sig(name)
+
+    def mk_kls(self):
+        class foo(object):
+            def __init__(self, *args):
+                self.args = args
+
+        return foo
+
+class test_smart_signal(smart_signals_mixin, base):
+
+    def test_behaviour(self):
+        kls, sig = self.mk_kls(), self.mk_signal()
+        self.assertEqual([], list(sig.known_senders))
+        obj = kls()
+        sig.register_sender(obj)
+        self.assertEqual([obj], list(sig.known_senders))
+        del obj
+        # assert weakref'd; jython probably won't like this, but oh well
+        self.assertEqual([], list(sig.known_senders))
+        self.assertFalse(sig.enables)
+        self.assertFalse(sig.disables)
+        
+        # force an Any in to force enables to track that it gets properly enabled, and that
+        # _enable_sender is invoked once with the higher incr count
+        obj = kls()
+        sig.enable_sender(dispatch.Any)
+        sig.register_sender(obj)
+        self.assertEqual([(obj, 1)], sig.enables)
+        obj2 = kls()
+        del obj
+        sig.enables = []
+        sig.enable_sender(dispatch.Any)
+
+        # register a new instance; should be a single _enable_sender call, incr=2 due to
+        # 2 Any senders register.
+        
+        sig.register_sender(obj2)
+        self.assertEqual([(obj2, 2)], sig.enables)
+        self.assertFalse(sig.disables)
+
+class test_Any(smart_signals_mixin, base):
+
+    def test_register_sender(self):
+        self.assertRaises(TypeError, dispatch.Any.register_sender, self.mk_kls()())
+
+    def test_enable_disable_sender(self):
+        kls = self.mk_kls()
+        obj1, obj2 = kls(), kls()
+        sig1, sig2 = self.mk_signal("sig1"), self.mk_signal("sig2")
+        sig1.register_sender(obj1)
+        sig2.register_sender(obj2)
+
+        self.assertFalse(sig1.enables)
+        self.assertFalse(sig2.enables)
+
+        # first test it's behaviour for a signal=Any, sender=specific
+        dispatch.Any.enable_sender(obj1)
+        self.assertEqual(sig1.enables, [(obj1, 1)])
+        self.assertFalse(sig2.enables), self.assertFalse(sig2.disables)
+        dispatch.Any.disable_sender(obj1)
+        self.assertEqual(sig1.enables, [(obj1, 1)])
+        self.assertEqual(sig1.disables, [(obj1, 1)])
+        self.assertFalse(sig2.enables), self.assertFalse(sig2.disables)
+
+        dispatch.Any.enable_sender(obj2)
+        self.assertEqual(sig2.enables, [(obj2, 1)])        
+        dispatch.Any.disable_sender(obj2)
+        self.assertEqual(sig2.disables, [(obj2, 1)])        
+        sig1.enables, sig1.disables = [], []
+        sig2.enables, sig2.disables = [], []
+
+        # now test signal=Any, sender=Any behaviour.
+        dispatch.Any.enable_sender(dispatch.Any)
+        self.assertEqual(sig1.enables, [(obj1, 1)])
+        self.assertEqual(sig2.enables, [(obj2, 1)])
+        self.assertFalse(sig1.disables), self.assertFalse(sig2.disables)
+
+        dispatch.Any.enable_sender(dispatch.Any)
+        self.assertEqual(sig1.enables, [(obj1, 1)]*2)
+        self.assertEqual(sig2.enables, [(obj2, 1)]*2)
+
+        dispatch.Any.disable_sender(dispatch.Any, 2)
+        self.assertEqual(sig1.disables, [(obj1, 2)])
+        self.assertEqual(sig2.disables, [(obj2, 2)])

tests/regressiontests/dispatch/tests/test_weakset.py

@@ +1 @@
+from django.dispatch.weaksets import WeakSet
+from unittest import TestCase
+
+if not hasattr(__builtins__, 'set'):
+    from sets import Set as set
+
+class test_WeakSet(TestCase):
+
+    def mk_obj(self):
+        # can't weakref base object instances, hence subclassing
+        class foon(object):
+            pass
+        return foon()
+
+    def test_basics(self):
+        ws = WeakSet()
+        self.assertEqual(len(ws), 0)
+        ws.add(self.mk_obj())
+        # should've gone out of scope immediately, since the only referant would be ws,
+        # which *better* be weakref'ing it.
+        self.assertEqual(len(ws), 0)
+        self.assertFalse(ws)
+        obj = self.mk_obj()
+        ws.add(obj)
+        self.assertEqual(len(ws), 1)
+        self.assertTrue(ws)
+        self.assertEqual(list(ws), [obj])
+        obj2 = self.mk_obj()
+        ws.add(obj2)
+        self.assertEqual(set(ws), set([obj, obj2]))
+        
+        del obj
+        self.assertEqual(list(ws), [obj2])
+        del obj2
+        self.assertFalse(ws)
+
+        obj = self.mk_obj()
+        # check that it accepts an iterable
+        self.assertEqual(list(WeakSet([obj])), [obj])
+        ws.discard(obj)
+        self.assertFalse(ws)
+        # no exception
+        ws.discard(obj)
+        ws.add(obj)
+        self.assertTrue(obj)
+        ws.remove(obj)
+        self.assertFalse(ws)
+        # keyerror
+        self.assertRaises(KeyError, ws.remove, obj)
+
+        # finally, update
+        objs = [self.mk_obj() for x in xrange(3)]
+        ws.update(objs)
+        self.assertEqual(set(ws), set(objs))
+
+        self.assertTrue(objs[0] in ws)
+        self.assertFalse(self in ws)

django/db/models/base.py

@@ -70 +70 @@
 
         new_class._prepare()
 
+        # now we register the class with the signals it can have turned on;
+        signals.pre_init.register_sender(new_class)
+        signals.post_init.register_sender(new_class)
+        signals.pre_save.register_sender(new_class)
+        signals.post_save.register_sender(new_class)
+
         register_models(new_class._meta.app_label, new_class)
         # Because of the way imports happen (recursively), we may or may not be
         # the first class for this model to register with the framework. There
@@ -98 +104 @@
         return not self.__eq__(other)
 
     def __init__(self, *args, **kwargs):
-        dispatcher.send(signal=signals.pre_init, sender=self.__class__, args=args, kwargs=kwargs)
-
         # There is a rather weird disparity here; if kwargs, it's set, then args
         # overrides it. It should be one or the other; don't duplicate the work
         # The reason for the kwargs check is that standard iterator passes in by
@@ -167 +171 @@
                     pass
             if kwargs:
                 raise TypeError, "'%s' is an invalid keyword argument for this function" % kwargs.keys()[0]
-        dispatcher.send(signal=signals.post_init, sender=self.__class__, instance=self)
 
     def add_to_class(cls, name, value):
         if name == 'Admin':
@@ -202 +205 @@
     _prepare = classmethod(_prepare)
 
     def save(self):
-        dispatcher.send(signal=signals.pre_save, sender=self.__class__, instance=self)
-
         non_pks = [f for f in self._meta.fields if not f.primary_key]
         cursor = connection.cursor()
 
@@ -256 +257 @@
         transaction.commit_unless_managed()
 
         # Run any post-save hooks.
-        dispatcher.send(signal=signals.post_save, sender=self.__class__, instance=self)
 
     save.alters_data = True
 

django/db/models/signals.py

@@ -1 @@
-class_prepared = object()
-
-pre_init= object()
-post_init = object()
-
-pre_save = object()
-post_save = object()
-
-pre_delete = object()
-post_delete = object()
-
-post_syncdb = object()
+from django.dispatch import mk_signal, mk_pre_post_signals
+from django.dispatch.dispatcher import send
+
+class_prepared = mk_signal('class_prepared')
+
+class _init_mixin(object):
+    """one of two signals fired when a new model instance is created
+
+    pre_init is fired when the instance is being created, and is passed two keyword args:
+      @param args: positional args passed to __init__
+      @param kwargs: dictionary of keyword args passed to __init__
+   
+    post_init is fired after the instance is fully created, and is passed a signal keyword arg:
+      @param instance: newly created instance
+    """
+
+    def _pre_replacement(self, func, sender):
+        def wrapped(internal_self, *args, **kwargs):
+            send(signal=pre_init, sender=internal_self.__class__, args=args, kwargs=kwargs)
+            func(internal_self, *args, **kwargs)
+        return wrapped
+
+    def _post_replacement(self, func, sender):
+        def wrapped(internal_self, *args, **kwargs):
+            func(internal_self, *args, **kwargs)
+            send(signal=post_init, sender=internal_self.__class__, instance=internal_self)
+        return wrapped
+        
+    def _both_replacement(self, func, sender):
+        def wrapped(internal_self, *args, **kwargs):
+            send(signal=pre_init, sender=internal_self.__class__, args=args, kwargs=kwargs)
+            func(internal_self, *args, **kwargs)
+            send(signal=post_init, sender=internal_self.__class__, instance=internal_self)
+        return wrapped
+
+pre_init, post_init = mk_pre_post_signals('__init__', 'pre_init', 'post_init', _init_mixin)
+
+class _save_mixin(object):
+
+    def _pre_replacement(self, func, sender):
+        def wrapped(internal_self, *args, **kwargs):
+            send(signal=pre_save, sender=internal_self.__class__, instance=internal_self)
+            func(internal_self, *args, **kwargs)
+        wrapped.alters_data = True
+        return wrapped
+
+    def _post_replacement(self, func, sender):
+        def wrapped(internal_self, *args, **kwargs):
+            func(internal_self, *args, **kwargs)
+            send(signal=post_save, sender=internal_self.__class__, instance=internal_self)
+        wrapped.alters_data = True
+        return wrapped
+
+    def _both_replacement(self, func, sender):
+        def wrapped(internal_self, *args, **kwargs):
+            send(signal=pre_save, sender=internal_self.__class__, instance=internal_self)
+            func(internal_self, *args, **kwargs)
+            send(signal=post_save, sender=internal_self.__class__, instance=internal_self)
+        wrapped.alters_data = True
+        return wrapped
+
+pre_save, post_save = mk_pre_post_signals('save', 'pre_save', 'post_save', _save_mixin)
+
+pre_delete = mk_signal('pre_delete')
+post_delete = mk_signal('post_delete')
+
+post_syncdb = mk_signal('post_syncdb')

django/dispatch/__init__.py

@@ -4 +4 @@
 __author__ = "Patrick K. O'Brien"
 __license__ = "BSD-style, see license.txt for details"
 
+from weakref import WeakKeyDictionary
+from weaksets import WeakSet
+
+class signal(object):
+
+    def __init__(self, signal_name):
+        self.signal_name = signal_name
+
+    def __str__(self):
+        return self.signal_name
+
+    def __repr__(self):
+        return "<signal signal=%r @#%x>" % (self.signal_name, id(self))
+
+def mk_signal(signal_name, *args, **kwargs):
+    docstring = kwargs.pop("docstring", None)
+    signal_kls = kwargs.pop("signal_kls", signal)
+    if docstring is not None:
+        class signal_kls(signal_kls):
+            __doc__ = docstring
+    return signal_kls(signal_name, *args, **kwargs)
+
+
+class smart_signal(signal):
+
+    # tracks known senders (keys), and the 'Any signal' count per sender
+    # signal=Any, sender=sender
+    all_known_senders = WeakKeyDictionary()
+    
+    # 'Any signal, Any sender' count; tracked for new signal/sender initialization
+    any_any_count = 0
+
+    # tracks known signals, and the # of signal=signal, sender=Any
+    # one exemption to this; Any is left out of known_signals.
+    known_signals = WeakKeyDictionary()
+    
+    # note per instance, there is a 'known_senders'; tracks the known senders
+    # of a specific signal (just that).  This is required to be tracked so
+    # that a sender can't be registered twice (will trash the ref cnts)
+
+    def __init__(self, signal_name):
+        signal.__init__(self, signal_name)
+        self.known_senders = WeakSet()
+        # set the # of sender=any, signal=self count.
+        self.known_signals[self] = self.any_any_count
+
+    def register_sender(self, sender):
+        if sender in self.known_senders:
+            # already known; can occur for instances that have a shared known_senders.
+            return
+        self.known_senders.add(sender)
+
+        # find the incref count from the misc Any currently listening
+        count = self.all_known_senders.setdefault(sender, 0) + self.known_signals[self]
+        if count:
+            self.enable_sender(sender, incr=count)
+
+    def enable_sender(self, sender, incr=1):
+        if sender is Any:
+            self.known_signals[self] += 1
+            for sender in self.known_senders:
+                self._enable_sender(sender, incr)
+            return
+        self._enable_sender(sender, incr)
+
+    def disable_sender(self, sender, decr=1):
+        if sender is Any:
+            self.known_signals[self] -= 1
+            # on the offchance a sender goes away when nothing is listening.
+            # *probably* not sanely possible
+            for sender in tuple(self.known_senders):
+                self._disable_sender(sender, decr)
+            return
+
+        self._disable_sender(sender, decr)
+
+    def _enable_sender(self, sender, incr):
+        raise NotImplementedError(self, '_enable_sender')
+
+    def _disable_sender(self, sender, decr):
+        raise NotImplementedError(self, '_disable_sender')
+
+class Any(smart_signal):
+
+    """Singleton used to signal either "Any Sender" or "Any Signal"
+    
+    The Any object can be used with connect, disconnect,
+    send, or sendExact to signal that the parameter given
+    Any should react to all senders/signals, not just
+    a particular sender/signal.
+    """
+
+    def __init__(self):
+        signal.__init__(self, "Any")
+        self.known_senders = smart_signal.all_known_senders
+
+    def register_sender(self, sender):
+        raise TypeError("you cannot register a sender for Any")
+
+    def enable_sender(self, sender, incr=1):
+        if sender is self:
+            for signal in self.known_signals.iterkeys():
+                signal.enable_sender(self, incr=incr)
+            smart_signal.any_any_count += incr
+        else:
+            for signal in self.known_signals.iterkeys():
+                if sender in signal.known_senders:
+                    signal.enable_sender(sender, incr=incr)
+            
+    def disable_sender(self, sender, decr=1):
+        if sender is self:
+            for signal in self.known_signals.iterkeys():
+                signal.disable_sender(self, decr=decr)
+            smart_signal.any_any_count -= decr
+            assert smart_signal.any_any_count >= 0
+        else:
+            for signal in self.known_signals.iterkeys():
+                if sender in signal.known_senders:
+                    signal.disable_sender(sender, decr=decr)
+
+Any = Any()
+
+class _pre_post_signal(smart_signal):
+
+    def __init__(self, signal_name, method_name, is_pre, known_senders=None):
+        smart_signal.__init__(self, signal_name)
+        self._method_name = method_name
+        if known_senders is not None:
+            self.known_senders = known_senders
+        self.is_pre = is_pre
+
+    def _enable_sender(self, sender, incr):
+        original_func = func = getattr(sender, self._method_name)
+        precount = getattr(original_func, "_listening_pre_refcnt", 0)
+        postcount = getattr(original_func, "_listening_post_refcnt", 0)
+
+        if self.is_pre:
+            if postcount:
+                if not precount:
+                    func = self._both_replacement(func._listening_wrapped, sender)
+                    original_func = original_func._listening_wrapped
+            elif not precount:
+                func = self._pre_replacement(func, sender)
+            precount += incr
+        else:
+            if precount:
+                if not postcount:
+                    func = self._both_replacement(func._listening_wrapped, sender)
+                    original_func = original_func._listening_wrapped
+            elif not postcount:
+                func = self._post_replacement(func, sender)
+            postcount += incr
+
+        func._listening_pre_refcnt = precount
+        func._listening_post_refcnt = postcount
+        func._listening_refcnt = precount + postcount
+
+        if func is not original_func:
+            setattr(sender, self._method_name, func)
+            func._listening_wrapped = original_func
+
+    def _disable_sender(self, sender, decr):
+        func = original_func = getattr(sender, self._method_name)
+
+        # shortcut to simplify logic.
+        if func._listening_refcnt <= decr:
+            setattr(sender, self._method_name, func._listening_wrapped)
+            return
+        
+        precount = func._listening_pre_refcnt
+        postcount = func._listening_post_refcnt
+        
+        if self.is_pre:
+            precount -= decr
+            if not precount:
+                func = self._post_replacement(func, sender)
+                func._listening_refcnt = func._listening_post_refcnt = postcount
+            func._listening_pre_refcnt = precount
+        else:
+            postcount -= decr
+            if not postcount:
+                func = self._pre_replacement(func, sender)
+                func._listening_refcnt = func._listening_pre_refcnt = precount
+            func._listening_post_refcnt = postcount
+
+        if func is not original_func:
+            seattr(sender, self._method_name, func)
+            func._listening_func = original_func._listening_wrapped
+
+    def _pre_replacement(self, original_func, sender):
+        raise NotImplementedError(self, "_pre_replacement")
+
+    def _post_replacement(self, original_func, sender):
+        raise NotImplementedError(self, "_post_replacement")
+
+    def _both_replacement(self, original_func, sender):
+        raise NotImplementedError(self, "_both_replacement")
+
+def mk_pre_post_signals(method_name, pre_signal_name, post_signal_name, mixin_kls):
+    class mixin(mixin_kls, _pre_post_signal):
+        __doc__ = mixin_kls.__doc__
+        pass
+    pre = mixin(pre_signal_name, method_name, True)
+    pre.__name__ = pre_signal_name
+    post = mixin(post_signal_name, method_name, False)#
+    post.__name__ = post_signal_name
+    return pre, post

django/dispatch/dispatcher.py

@@ -26 +26 @@
         vs. the original code.)
 """
 import types, weakref
-from django.dispatch import saferef, robustapply, errors
+# Any is imported for backwards compatibility API wise
+from django.dispatch import saferef, robustapply, errors, mk_signal, Any
 
 __author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
 __cvsid__ = "$Id: dispatcher.py,v 1.9 2005/09/17 04:55:57 mcfletch Exp $"
 __version__ = "$Revision: 1.9 $"[11:-2]
 
-
-class _Parameter:
-    """Used to represent default parameter values."""
-    def __repr__(self):
-        return self.__class__.__name__
-
-class _Any(_Parameter):
-    """Singleton used to signal either "Any Sender" or "Any Signal"
-
-    The Any object can be used with connect, disconnect,
-    send, or sendExact to signal that the parameter given
-    Any should react to all senders/signals, not just
-    a particular sender/signal.
-    """
-Any = _Any()
-
-class _Anonymous(_Parameter):
+Anonymous = mk_signal('Anonymous', docstring=
     """Singleton used to signal "Anonymous Sender"
 
     The Anonymous object is used to signal that the sender
@@ -65 +50 @@
         in either function then all messages are routed
         as though there was a single sender (Anonymous)
         being used everywhere.
-    """
-Anonymous = _Anonymous()
+    """)
 
 WEAKREF_TYPES = (weakref.ReferenceType, saferef.BoundMethodWeakref)
 
@@ -137 +121 @@
 
     signals = connections.setdefault(senderkey, {})
 
+    enabler = getattr(signal, 'enable_sender', None)
+    if enabler is not None:
+        enabler(sender)
     # Keep track of senders for cleanup.
     # Is Anonymous something we want to clean up?
     if sender not in (None, Anonymous, Any):
@@ -203 +190 @@
         )
     if weak: receiver = saferef.safeRef(receiver)
     senderkey = id(sender)
+    disabler = getattr(signal, 'disable_sender', None)
+    if disabler is not None:
+        disabler(sender)
     try:
         signals = connections[senderkey]
         receivers = signals[signal]

tests/regressiontests/dispatch/tests/__init__.py

@@ -5 +5 @@
 from test_dispatcher import *
 from test_robustapply import *
 from test_saferef import *
+from test_new_signals import *
+from test_weakset import *