=== added file 'django/dispatch/weaksets.py' --- django/dispatch/weaksets.py 1970-01-01 00:00:00 +0000 +++ django/dispatch/weaksets.py 2007-06-14 14:00:56 +0000 @@ -0,0 +1,33 @@ +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 === added file 'tests/regressiontests/dispatch/tests/test_new_signals.py' --- tests/regressiontests/dispatch/tests/test_new_signals.py 1970-01-01 00:00:00 +0000 +++ tests/regressiontests/dispatch/tests/test_new_signals.py 2007-06-14 13:58:54 +0000 @@ -0,0 +1,160 @@ +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), "" % 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)]) === added file 'tests/regressiontests/dispatch/tests/test_weakset.py' --- tests/regressiontests/dispatch/tests/test_weakset.py 1970-01-01 00:00:00 +0000 +++ tests/regressiontests/dispatch/tests/test_weakset.py 2007-06-14 14:00:51 +0000 @@ -0,0 +1,57 @@ +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) === modified file 'django/db/models/base.py' --- django/db/models/base.py 2007-06-11 10:24:01 +0000 +++ django/db/models/base.py 2007-06-13 22:28:21 +0000 @@ -69,6 +69,12 @@ 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 @@ -95,7 +101,6 @@ 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 @@ -164,7 +169,6 @@ 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': @@ -199,8 +203,6 @@ _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() @@ -252,7 +254,6 @@ transaction.commit_unless_managed() # Run any post-save hooks. - dispatcher.send(signal=signals.post_save, sender=self.__class__, instance=self) save.alters_data = True === modified file 'django/db/models/signals.py' --- django/db/models/signals.py 2007-06-10 12:53:32 +0000 +++ django/db/models/signals.py 2007-06-13 22:51:45 +0000 @@ -1,12 +1,67 @@ -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') === modified file 'django/dispatch/__init__.py' --- django/dispatch/__init__.py 2007-06-10 12:53:32 +0000 +++ django/dispatch/__init__.py 2007-06-14 13:11:56 +0000 @@ -4,3 +4,210 @@ __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 "" % (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 === modified file 'django/dispatch/dispatcher.py' --- django/dispatch/dispatcher.py 2007-06-10 12:53:32 +0000 +++ django/dispatch/dispatcher.py 2007-06-13 21:48:20 +0000 @@ -26,29 +26,14 @@ 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 " __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,8 +50,7 @@ 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,6 +121,9 @@ 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,6 +190,9 @@ ) 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] === modified file 'tests/regressiontests/dispatch/tests/__init__.py' --- tests/regressiontests/dispatch/tests/__init__.py 2007-06-02 04:54:31 +0000 +++ tests/regressiontests/dispatch/tests/__init__.py 2007-06-14 13:48:43 +0000 @@ -5,3 +5,5 @@ from test_dispatcher import * from test_robustapply import * from test_saferef import * +from test_new_signals import * +from test_weakset import *