Context Navigation

Back to Ticket #6814

Ticket #6814: signals_8156-2.diff

File signals_8156-2.diff, 68.0 KB (added by Jacob, 16 years ago)
Jeremy's latest patch

django/test/client.py

 from django.core.handlers.base import BaseHandler
 from django.core.handlers.wsgi import WSGIRequest
 from django.core.signals import got_request_exception
-from django.dispatch import dispatcher
 from django.http import SimpleCookie, HttpRequest
 from django.template import TemplateDoesNotExist
 from django.test import signals
 …
         if self._request_middleware is None:
             self.load_middleware()
         dispatcher.send(signal=signals.request_started)
+        signals.request_started.send(sender=self.__class__)
         try:
             request = WSGIRequest(environ)
             response = self.get_response(request)
 …
                 response = middleware_method(request, response)
             response = self.apply_response_fixes(request, response)
         finally:
             dispatcher.send(signal=signals.request_finished)
+            signals.request_finished.send(sender=self.__class__)
         return response
 def store_rendered_templates(store, signal, sender, template, context):
+def store_rendered_templates(store, signal, sender, template, context, **kwargs):
     """
     Stores templates and contexts that are rendered.
     """
 …
         self.cookies = SimpleCookie()
         self.exc_info = None
     def store_exc_info(self, *args, **kwargs):
+    def store_exc_info(self, **kwargs):
         """
         Stores exceptions when they are generated by a view.
         """
 …
         # callback function.
         data = {}
         on_template_render = curry(store_rendered_templates, data)
         dispatcher.connect(on_template_render, signal=signals.template_rendered)
+        signals.template_rendered.connect(on_template_render)
         # Capture exceptions created by the handler.
         dispatcher.connect(self.store_exc_info, signal=got_request_exception)
+        got_request_exception.connect(self.store_exc_info)
         try:
             response = self.handler(environ)

django/test/signals.py


1		template_rendered = object()
2		No newline at end of file
	1	from django.dispatch.dispatcher import Signal
	2
	3	template_rendered = Signal(providing_args=["template", "context"])

django/test/utils.py

 from django.db import connection, get_creation_module
 from django.core import mail
 from django.core.management import call_command
-from django.dispatch import dispatcher
 from django.test import signals
 from django.template import Template
 from django.utils.translation import deactivate
 …
     An instrumented Template render method, providing a signal
     that can be intercepted by the test system Client
     """
     dispatcher.send(signal=signals.template_rendered, sender=self, template=self, context=context)
+    signals.template_rendered.send(sender=self, template=self, context=context)
     return self.nodelist.render(context)
 class TestSMTPConnection(object):

django/db/models/sql/query.py

 from django.utils.tree import Node
 from django.utils.datastructures import SortedDict
-from django.dispatch import dispatcher
 from django.db import connection
 from django.db.models import signals
 from django.db.models.fields import FieldDoesNotExist
 …
             sentinel):
         yield [r[:-trim] for r in rows]
 def setup_join_cache(sender):
+def setup_join_cache(sender, **kwargs):
     """
     The information needed to join between model fields is something that is
     invariant over the life of the model, so we cache it in the model's Options
 …
     """
     sender._meta._join_cache = {}
 dispatcher.connect(setup_join_cache, signal=signals.class_prepared)
+signals.class_prepared.connect(setup_join_cache)

django/db/models/base.py

 from django.db import connection, transaction
 from django.db.models import signals
 from django.db.models.loading import register_models, get_model
-from django.dispatch import dispatcher
 from django.utils.functional import curry
 from django.utils.encoding import smart_str, force_unicode, smart_unicode
 from django.core.files.move import file_move_safe
 …
         if hasattr(cls, 'get_absolute_url'):
             cls.get_absolute_url = curry(get_absolute_url, opts, cls.get_absolute_url)
         dispatcher.send(signal=signals.class_prepared, sender=cls)
+        signals.class_prepared.send(sender=cls)
 class Model(object):
     __metaclass__ = ModelBase
     def __init__(self, *args, **kwargs):
         dispatcher.send(signal=signals.pre_init, sender=self.__class__, args=args, kwargs=kwargs)
+        signals.pre_init.send(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
 …
                     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)
+        signals.post_init.send(sender=self.__class__, instance=self)
     def __repr__(self):
         return smart_str(u'<%s: %s>' % (self.__class__.__name__, unicode(self)))
 …
             cls = self.__class__
             meta = self._meta
             signal = True
+            dispatcher.send(signal=signals.pre_save, sender=self.__class__,
+                    instance=self, raw=raw)
+            signals.pre_save.send(sender=self.__class__, instance=self, raw=raw)
         else:
             meta = cls._meta
             signal = False
 …
         transaction.commit_unless_managed()
         if signal:
             dispatcher.send(signal=signals.post_save, sender=self.__class__,
                     instance=self, created=(not record_exists), raw=raw)
+            signals.post_save.send(sender=self.__class__, instance=self,
+                created=(not record_exists), raw=raw)
     save_base.alters_data = True

django/db/models/manager.py

 import copy
 from django.db.models.query import QuerySet, EmptyQuerySet, insert_query
-from django.dispatch import dispatcher
 from django.db.models import signals
 from django.db.models.fields import FieldDoesNotExist
 def ensure_default_manager(sender):
+def ensure_default_manager(sender, **kwargs):
     cls = sender
     if not getattr(cls, '_default_manager', None) and not cls._meta.abstract:
         # Create the default manager, if needed.
 …
             pass
         cls.add_to_class('objects', Manager())
 dispatcher.connect(ensure_default_manager, signal=signals.class_prepared)
+signals.class_prepared.connect(ensure_default_manager)
 class Manager(object):
     # Tracks each time a Manager instance is created. Used to retain order.

django/db/models/manipulators.py

 from django import oldforms
 from django.core import validators
 from django.db.models.fields import FileField, AutoField
-from django.dispatch import dispatcher
 from django.db.models import signals
 from django.utils.functional import curry
 from django.utils.datastructures import DotExpandedDict
 …
 from django.utils.translation import ugettext as _
 from django.utils import datetime_safe
 def add_manipulators(sender):
+def add_manipulators(sender, **kwargs):
     cls = sender
     cls.add_to_class('AddManipulator', AutomaticAddManipulator)
     cls.add_to_class('ChangeManipulator', AutomaticChangeManipulator)
 dispatcher.connect(add_manipulators, signal=signals.class_prepared)
+signals.class_prepared.connect(add_manipulators)
 class ManipulatorDescriptor(object):
     # This class provides the functionality that makes the default model

django/db/models/fields/init.py

 from django.db import connection, get_creation_module
 from django.db.models import signals
 from django.db.models.query_utils import QueryWrapper
-from django.dispatch import dispatcher
 from django.conf import settings
 from django.core import validators
 from django import oldforms
 …
         setattr(cls, 'get_%s_url' % self.name, curry(cls._get_FIELD_url, field=self))
         setattr(cls, 'get_%s_size' % self.name, curry(cls._get_FIELD_size, field=self))
         setattr(cls, 'save_%s_file' % self.name, lambda instance, filename, raw_field, save=True: instance._save_FIELD_file(self, filename, raw_field, save))
         dispatcher.connect(self.delete_file, signal=signals.post_delete, sender=cls)
+        signals.post_delete.connect(self.delete_file, sender=cls)
     def delete_file(self, instance):
+    def delete_file(self, instance, **kwargs):
         if getattr(instance, self.attname):
             file_name = getattr(instance, 'get_%s_filename' % self.name)()
             # If the file exists and no other object of this type references it,

django/db/models/fields/related.py

 from django.core import validators
 from django import oldforms
 from django import forms
-from django.dispatch import dispatcher
 try:
     set
 …
         value = (cls, field, operation)
         pending_lookups.setdefault(key, []).append(value)
 def do_pending_lookups(sender):
+def do_pending_lookups(sender, **kwargs):
     """
     Handle any pending relations to the sending model. Sent from class_prepared.
     """
 …
     for cls, field, operation in pending_lookups.pop(key, []):
         operation(field, sender, cls)
 dispatcher.connect(do_pending_lookups, signal=signals.class_prepared)
+signals.class_prepared.connect(do_pending_lookups)
 def manipulator_valid_rel_key(f, self, field_data, all_data):
     "Validates that the value is a valid foreign key"

django/db/models/signals.py

+class_prepared = object()
+from django.dispatch.dispatcher import Signal
+pre_init= object()
+post_init = object()
+class_prepared = Signal(providing_args=["class"])
 pre_save = object()
 post_save = object()
+pre_init = Signal(providing_args=["instance", "args", "kwargs"])
+post_init = Signal(providing_args=["instance"])
 pre_delete = object()
 post_delete = object()
+pre_save = Signal(providing_args=["instance", "raw"])
+post_save = Signal(providing_args=["instance", "raw", "created"])
+post_syncdb = object()
+pre_delete = Signal(providing_args=["instance"])
+post_delete = Signal(providing_args=["instance"])
+post_syncdb = Signal(providing_args=["class", "app", "created_models", "verbosity", "interactive"])

django/db/models/query.py

 from django.db.models.fields import DateField
 from django.db.models.query_utils import Q, select_related_descend
 from django.db.models import signals, sql
-from django.dispatch import dispatcher
 from django.utils.datastructures import SortedDict
 …
         # Pre-notify all instances to be deleted.
         for pk_val, instance in items:
+            dispatcher.send(signal=signals.pre_delete, sender=cls,
+                    instance=instance)
+            signals.pre_delete.send(sender=cls, instance=instance)
         pk_list = [pk for pk,instance in items]
         del_query = sql.DeleteQuery(cls, connection)
 …
                 if field.rel and field.null and field.rel.to in seen_objs:
                     setattr(instance, field.attname, None)
+            dispatcher.send(signal=signals.post_delete, sender=cls,
+                    instance=instance)
+            signals.post_delete.send(sender=cls, instance=instance)
             setattr(instance, cls._meta.pk.attname, None)
     transaction.commit_unless_managed()

django/db/init.py

 from django.conf import settings
 from django.core import signals
 from django.core.exceptions import ImproperlyConfigured
-from django.dispatch import dispatcher
 from django.utils.functional import curry
 __all__ = ('backend', 'connection', 'DatabaseError', 'IntegrityError')
 …
 # Register an event that closes the database connection
 # when a Django request is finished.
+dispatcher.connect(connection.close, signal=signals.request_finished)
+def close_connection(**kwargs):
+    connection.close()
+signals.request_finished.connect(close_connection)
 # Register an event that resets connection.queries
 # when a Django request is started.
 def reset_queries():
+def reset_queries(**kwargs):
     connection.queries = []
 dispatcher.connect(reset_queries, signal=signals.request_started)
+signals.request_started.connect(reset_queries)
 # Register an event that rolls back the connection
 # when a Django request has an exception.
 def _rollback_on_exception():
+def _rollback_on_exception(**kwargs):
     from django.db import transaction
     transaction.rollback_unless_managed()
 dispatcher.connect(_rollback_on_exception, signal=signals.got_request_exception)
+signals.got_request_exception.connect(_rollback_on_exception)

django/core/signals.py

+request_started = object()
+request_finished = object()
+got_request_exception = object()
+from django.dispatch.dispatcher import Signal
+request_started = Signal()
+request_finished = Signal()
+got_request_exception = Signal(providing_args=["request"])

django/core/handlers/wsgi.py

 from django.core import signals
 from django.core.handlers import base
 from django.core.urlresolvers import set_script_prefix
-from django.dispatch import dispatcher
 from django.utils import datastructures
 from django.utils.encoding import force_unicode
 …
             self.initLock.release()
         set_script_prefix(base.get_script_name(environ))
         dispatcher.send(signal=signals.request_started)
+        signals.request_started.send(sender=self.__class__)
         try:
             try:
                 request = self.request_class(environ)
 …
                     response = middleware_method(request, response)
                 response = self.apply_response_fixes(request, response)
         finally:
             dispatcher.send(signal=signals.request_finished)
+            signals.request_finished.send(sender=self.__class__)
         try:
             status_text = STATUS_CODE_TEXT[response.status_code]

django/core/handlers/base.py

 from django import http
 from django.core import signals
-from django.dispatch import dispatcher
 from django.utils.encoding import force_unicode
 class BaseHandler(object):
 …
         except: # Handle everything else, including SuspiciousOperation, etc.
             # Get the exception info now, in case another exception is thrown later.
             exc_info = sys.exc_info()
             receivers = dispatcher.send(signal=signals.got_request_exception, request=request)
+            receivers = signals.got_request_exception.send(sender=self.__class__, request=request)
             return self.handle_uncaught_exception(request, resolver, exc_info)
     def handle_uncaught_exception(self, request, resolver, exc_info):

django/core/handlers/modpython.py

 from django.core import signals
 from django.core.handlers.base import BaseHandler
 from django.core.urlresolvers import set_script_prefix
-from django.dispatch import dispatcher
 from django.utils import datastructures
 from django.utils.encoding import force_unicode, smart_str
 …
             self.load_middleware()
         set_script_prefix(req.get_options().get('django.root', ''))
         dispatcher.send(signal=signals.request_started)
+        signals.request_started.send(sender=self.__class__)
         try:
             try:
                 request = self.request_class(req)
 …
                     response = middleware_method(request, response)
                 response = self.apply_response_fixes(request, response)
         finally:
             dispatcher.send(signal=signals.request_finished)
+            signals.request_finished.send(sender=self.__class__)
         # Convert our custom HttpResponse object back into the mod_python req.
         req.content_type = response['Content-Type']

django/core/management/commands/flush.py

     def handle_noargs(self, **options):
         from django.conf import settings
         from django.db import connection, transaction, models
-        from django.dispatch import dispatcher
         from django.core.management.sql import sql_flush, emit_post_sync_signal
         verbosity = int(options.get('verbosity', 1))

django/core/management/sql.py

         app_name = app.__name__.split('.')[-2]
         if verbosity >= 2:
             print "Running post-sync handlers for application", app_name
         dispatcher.send(signal=models.signals.post_syncdb, sender=app,
             app=app, created_models=created_models,
             verbosity=verbosity, interactive=interactive)
+        models.signals.post_syncdb.send(sender=app, app=app,
+            created_models=created_models, verbosity=verbosity,
+            interactive=interactive)

django/dispatch/errors.py

-"""Error types for dispatcher mechanism
-"""
-class DispatcherError(Exception):
-    """Base class for all Dispatcher errors"""
-class DispatcherKeyError(KeyError, DispatcherError):
-    """Error raised when unknown (sender,signal) set specified"""
-class DispatcherTypeError(TypeError, DispatcherError):
-    """Error raised when inappropriate signal-type specified (None)"""

django/dispatch/robust.py

-"""Module implementing error-catching version of send (sendRobust)"""
-from django.dispatch.dispatcher import Any, Anonymous, liveReceivers, getAllReceivers
-from django.dispatch.robustapply import robustApply
-def sendRobust(
-    signal=Any,
-    sender=Anonymous,
-    *arguments, **named
-):
-    """Send signal from sender to all connected receivers catching errors
-    signal -- (hashable) signal value, see connect for details
-    sender -- the sender of the signal
-        if Any, only receivers registered for Any will receive
-        the message.
-        if Anonymous, only receivers registered to receive
-        messages from Anonymous or Any will receive the message
-        Otherwise can be any python object (normally one
-        registered with a connect if you actually want
-        something to occur).
-    arguments -- positional arguments which will be passed to
-        *all* receivers. Note that this may raise TypeErrors
-        if the receivers do not allow the particular arguments.
-        Note also that arguments are applied before named
-        arguments, so they should be used with care.
-    named -- named arguments which will be filtered according
-        to the parameters of the receivers to only provide those
-        acceptable to the receiver.
-    Return a list of tuple pairs [(receiver, response), ... ]
-    if any receiver raises an error (specifically any subclass of Exception),
-    the error instance is returned as the result for that receiver.
-    """
-    # Call each receiver with whatever arguments it can accept.
-    # Return a list of tuple pairs [(receiver, response), ... ].
-    responses = []
-    for receiver in liveReceivers(getAllReceivers(sender, signal)):
-        try:
-            response = robustApply(
-                receiver,
-                signal=signal,
-                sender=sender,
-                *arguments,
-                **named
+            )
-        except Exception, err:
-            responses.append((receiver, err))
-        else:
-            responses.append((receiver, response))
-    return responses

django/dispatch/init.py

 """Multi-consumer multi-producer dispatching mechanism
+Originally based on pydispatch (BSD) http://pypi.python.org/pypi/PyDispatcher/2.0.1
+See license.txt for original license.
+Heavily modified for Django's purposes.
 """
-__version__ = "1.0.0"
-__author__ = "Patrick K. O'Brien"
-__license__ = "BSD-style, see license.txt for details"

django/dispatch/robustapply.py

-"""Robust apply mechanism
-Provides a function "call", which can sort out
-what arguments a given callable object can take,
-and subset the given arguments to match only
-those which are acceptable.
-"""
-def function( receiver ):
-    """Get function-like callable object for given receiver
-    returns (function_or_method, codeObject, fromMethod)
-    If fromMethod is true, then the callable already
-    has its first argument bound
-    """
-    if hasattr(receiver, '__call__'):
-        # receiver is a class instance; assume it is callable.
-        # Reassign receiver to the actual method that will be called.
-        if hasattr( receiver.__call__, 'im_func') or hasattr( receiver.__call__, 'im_code'):
-            receiver = receiver.__call__
-    if hasattr( receiver, 'im_func' ):
-        # an instance-method...
-        return receiver, receiver.im_func.func_code, 1
-    elif not hasattr( receiver, 'func_code'):
-        raise ValueError('unknown reciever type %s %s'%(receiver, type(receiver)))
-    return receiver, receiver.func_code, 0
-def robustApply(receiver, *arguments, **named):
-    """Call receiver with arguments and an appropriate subset of named
-    """
-    receiver, codeObject, startIndex = function( receiver )
-    acceptable = codeObject.co_varnames[startIndex+len(arguments):codeObject.co_argcount]
-    for name in codeObject.co_varnames[startIndex:startIndex+len(arguments)]:
-        if named.has_key( name ):
-            raise TypeError(
-                """Argument %r specified both positionally and as a keyword for calling %r"""% (
-                    name, receiver,
+                )
+            )
-    if not (codeObject.co_flags & 8):
-        # fc does not have a **kwds type parameter, therefore
-        # remove unacceptable arguments.
-        for arg in named.keys():
-            if arg not in acceptable:
-                del named[arg]
-    return receiver(*arguments, **named)

django/dispatch/dispatcher.py

-"""Multiple-producer-multiple-consumer signal-dispatching
-dispatcher is the core of the PyDispatcher system,
-providing the primary API and the core logic for the
-system.
-Module attributes of note:
-    Any -- Singleton used to signal either "Any Sender" or
-        "Any Signal".  See documentation of the _Any class.
-    Anonymous -- Singleton used to signal "Anonymous Sender"
-        See documentation of the _Anonymous class.
-Internal attributes:
-    WEAKREF_TYPES -- tuple of types/classes which represent
-        weak references to receivers, and thus must be de-
-        referenced on retrieval to retrieve the callable
-        object
-    connections -- { senderkey (id) : { signal : [receivers...]}}
-    senders -- { senderkey (id) : weakref(sender) }
-        used for cleaning up sender references on sender
-        deletion
-    sendersBack -- { receiverkey (id) : [senderkey (id)...] }
-        used for cleaning up receiver references on receiver
-        deletion, (considerably speeds up the cleanup process
-        vs. the original code.)
-"""
 import weakref
+from django.dispatch import saferef, robustapply, errors
+try:
+    set
+except NameError:
+    from sets import Set as set # Python 2.3 fallback
+__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]
+from django.dispatch import saferef
-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):
-    """Singleton used to signal "Anonymous Sender"
-    The Anonymous object is used to signal that the sender
-    of a message is not specified (as distinct from being
-    "any sender").  Registering callbacks for Anonymous
-    will only receive messages sent without senders.  Sending
-    with anonymous will only send messages to those receivers
-    registered for Any or Anonymous.
-    Note:
-        The default sender for connect is Any, while the
-        default sender for send is Anonymous.  This has
-        the effect that if you do not specify any senders
-        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)
+connections = {}
+senders = {}
+sendersBack = {}
+def _make_id(target):
+    if hasattr(target, 'im_func'):
+        return (id(target.im_self), id(target.im_func))
+    return id(target)
+def connect(receiver, signal=Any, sender=Any, weak=True):
+    """Connect receiver to sender for signal
+    receiver -- a callable Python object which is to receive
+        messages/signals/events.  Receivers must be hashable
+        objects.
+        if weak is True, then receiver must be weak-referencable
+        (more precisely saferef.safeRef() must be able to create
+        a reference to the receiver).
+class Signal(object):
+    """Base class for all signals
+        Receivers are fairly flexible in their specification,
+        as the machinery in the robustApply module takes care
+        of most of the details regarding figuring out appropriate
+        subsets of the sent arguments to apply to a given
+        receiver.
+        Note:
+            if receiver is itself a weak reference (a callable),
+            it will be de-referenced by the system's machinery,
+            so *generally* weak references are not suitable as
+            receivers, though some use might be found for the
+            facility whereby a higher-level library passes in
+            pre-weakrefed receiver references.
+    signal -- the signal to which the receiver should respond
+    Internal attributes:
+        receivers -- { receriverkey (id) : weakref(receiver) }
+    """
+        if Any, receiver will receive any signal from the
+        indicated sender (which might also be Any, but is not
+        necessarily Any).
+    def __init__(self, providing_args=[]):
+        """providing_args -- A list of the arguments this signal can pass along in
+                       a send() call.
+        """
+        self.registered_uids = set()
+        self.receivers = []
+        self.providing_args = set(providing_args)
+    def connect(self, receiver, sender=None, weak=True):
+        """Connect receiver to sender for signal
+        receiver -- a function or an instance method which is to
+            receive signals.  Receivers must be
+            hashable objects.
+            if weak is True, then receiver must be weak-referencable
+            (more precisely saferef.safeRef() must be able to create
+            a reference to the receiver).
+        Otherwise must be a hashable Python object other than
+        None (DispatcherError raised on None).
+    sender -- the sender to which the receiver should respond
+            Receivers must be able to accept keyword arguments.
+            If receivers have a dispatch_uid attribute, the receiver will
+              not be added if another receiver already exists with that
+              dispatch_uid.
+        sender -- the sender to which the receiver should respond
+            Must either be of type Signal, or None to receive events
+            from any sender.
+        weak -- whether to use weak references to the receiver
+            By default, the module will attempt to use weak
+            references to the receiver objects.  If this parameter
+            is false, then strong references will be used.
+        if Any, receiver will receive the indicated signals
+        from any sender.
+        returns None
+        """
+        from django.conf import settings
+        if Anonymous, receiver will only receive indicated
+        signals from send/sendExact which do not specify a
+        sender, or specify Anonymous explicitly as the sender.
+        Otherwise can be any python object.
+        if settings.DEBUG:
+            import inspect
+            assert inspect.getargspec(receiver)[2] is not None, \
+                "Signal receivers should accept keyword arguments (**kwargs)."
+    weak -- whether to use weak references to the receiver
+        By default, the module will attempt to use weak
+        references to the receiver objects.  If this parameter
+        is false, then strong references will be used.
+        uid = getattr(receiver, 'dispatch_uid', None)
+        if uid and uid in self.registered_uids:
+            return
+    returns None, may raise DispatcherTypeError
+    """
+    if signal is None:
+        raise errors.DispatcherTypeError(
+            'Signal cannot be None (receiver=%r sender=%r)' % (receiver, sender)
+        )
+    if weak:
+        receiver = saferef.safeRef(receiver, onDelete=_removeReceiver)
+    senderkey = id(sender)
+        lookup_key = (_make_id(receiver), _make_id(sender))
+    signals = connections.setdefault(senderkey, {})
+        if weak:
+            receiver = saferef.safeRef(receiver, onDelete=self._remove_receiver)
+    # Keep track of senders for cleanup.
+    # Is Anonymous something we want to clean up?
+    if sender not in (None, Anonymous, Any):
+        def remove(object, senderkey=senderkey):
+            _removeSender(senderkey=senderkey)
+        # Skip objects that can not be weakly referenced, which means
+        # they won't be automatically cleaned up, but that's too bad.
+        try:
+            weakSender = weakref.ref(sender, remove)
+            senders[senderkey] = weakSender
+        except:
+            pass
+    receiverID = id(receiver)
+    # get current set, remove any current references to
+    # this receiver in the set, including back-references
+    if signals.has_key(signal):
+        receivers = signals[signal]
+        _removeOldBackRefs(senderkey, signal, receiver, receivers)
+    else:
+        receivers = signals[signal] = []
+    try:
+        current = sendersBack.get(receiverID)
+        if current is None:
+            sendersBack[ receiverID ] = current = []
+        if senderkey not in current:
+            current.append(senderkey)
+    except:
+        pass
+        for r_key, _ in self.receivers:
+            if r_key == lookup_key:
+                break
+        else:
+            self.receivers.append((lookup_key, receiver))
+            if uid:
+                self.registered_uids.add(uid)
+    receivers.append(receiver)
+    def disconnect(self, receiver, sender=None, weak=True):
+        """Disconnect receiver from sender for signal
+        receiver -- the registered receiver to disconnect
+        sender -- the registered sender to disconnect
+        weak -- the weakref state to disconnect
+        disconnect reverses the process of connect.
+        If weak references are used, disconnect need not be called.
+          The receiver will be remove from dispatch automatically.
+        returns None
+        """
+        lookup_key = (_make_id(receiver), _make_id(sender))
+        uid = getattr(receiver, 'dispatch_uid', None)
+        for idx, (r_key, _) in enumerate(self.receivers):
+            if r_key == lookup_key:
+                del self.receivers[idx]
+                if uid:
+                    self.registered_uids.remove(uid)
+    def send(self, sender, **named):
+        """Send signal from sender to all connected receivers.
+        sender -- the sender of the signal
+            Either a specific object or None.
+        named -- named arguments which will be passed to receivers.
+def disconnect(receiver, signal=Any, sender=Any, weak=True):
+    """Disconnect receiver from sender for signal
+    receiver -- the registered receiver to disconnect
+    signal -- the registered signal to disconnect
+    sender -- the registered sender to disconnect
+    weak -- the weakref state to disconnect
+    disconnect reverses the process of connect,
+    the semantics for the individual elements are
+    logically equivalent to a tuple of
+    (receiver, signal, sender, weak) used as a key
+    to be deleted from the internal routing tables.
+    (The actual process is slightly more complex
+    but the semantics are basically the same).
+    Note:
+        Using disconnect is not required to cleanup
+        routing when an object is deleted, the framework
+        will remove routes for deleted objects
+        automatically.  It's only necessary to disconnect
+        if you want to stop routing to a live object.
+        Returns a list of tuple pairs [(receiver, response), ... ].
+    returns None, may raise DispatcherTypeError or
+        DispatcherKeyError
+    """
+    if signal is None:
+        raise errors.DispatcherTypeError(
+            'Signal cannot be None (receiver=%r sender=%r)' % (receiver, sender)
+        )
+    if weak: receiver = saferef.safeRef(receiver)
+    senderkey = id(sender)
+    try:
+        signals = connections[senderkey]
+        receivers = signals[signal]
+    except KeyError:
+        raise errors.DispatcherKeyError(
+            """No receivers found for signal %r from sender %r""" %(
+                signal,
+                sender
+            )
+        )
+    try:
+        # also removes from receivers
+        _removeOldBackRefs(senderkey, signal, receiver, receivers)
+    except ValueError:
+        raise errors.DispatcherKeyError(
+            """No connection to receiver %s for signal %s from sender %s""" %(
+                receiver,
+                signal,
+                sender
+            )
+        )
+    _cleanupConnections(senderkey, signal)
+        If any receiver raises an error, the error propagates back
+        through send, terminating the dispatch loop, so it is quite
+        possible to not have all receivers called if a raises an
+        error.
+        """
+def getReceivers(sender=Any, signal=Any):
+    """Get list of receivers from global tables
+        responses = []
+        if not self.receivers:
+            return responses
+    This utility function allows you to retrieve the
+    raw list of receivers from the connections table
+    for the given sender and signal pair.
+        for receiver in self._live_receivers(_make_id(sender)):
+            response = receiver(signal=self, sender=sender, **named)
+            responses.append((receiver, response))
+        return responses
+    Note:
+        there is no guarantee that this is the actual list
+        stored in the connections table, so the value
+        should be treated as a simple iterable/truth value
+        rather than, for instance a list to which you
+        might append new records.
+    def send_robust(self, sender, **named):
+        """Send signal from sender to all connected receivers catching errors
+    Normally you would use liveReceivers(getReceivers(...))
+    to retrieve the actual receiver objects as an iterable
+    object.
+    """
+    existing = connections.get(id(sender))
+    if existing is not None:
+        return existing.get(signal, [])
+    return []
+        sender -- the sender of the signal
+            Can be any python object (normally one registered with
+            a connect if you actually want something to occur).
+def liveReceivers(receivers):
+    """Filter sequence of receivers to get resolved, live receivers
+        named -- named arguments which will be passed to receivers.
+            These arguments must be a subset of the argument names
+            defined in providing_args, or a DispatcherTypeError will be
+            raised.
+    This is a generator which will iterate over
+    the passed sequence, checking for weak references
+    and resolving them, then returning all live
+    receivers.
+    """
+    for receiver in receivers:
+        if isinstance(receiver, WEAKREF_TYPES):
+            # Dereference the weak reference.
+            receiver = receiver()
+            if receiver is not None:
+                yield receiver
+        else:
+            yield receiver
+        Return a list of tuple pairs [(receiver, response), ... ],
+        may raise DispatcherKeyError
+        if any receiver raises an error (specifically any subclass of Exception),
+        the error instance is returned as the result for that receiver.
+        """
+        responses = []
+        if not self.receivers:
+            return responses
+def getAllReceivers(sender=Any, signal=Any):
+    """Get list of all receivers from global tables
+        # Call each receiver with whatever arguments it can accept.
+        # Return a list of tuple pairs [(receiver, response), ... ].
+        for receiver in self._live_receivers(_make_id(sender)):
+            try:
+                response = receiver(signal=self, sender=sender, **named)
+            except Exception, err:
+                responses.append((receiver, err))
+            else:
+                responses.append((receiver, response))
+        return responses
-    This gets all dereferenced receivers which should receive
-    the given signal from sender, each receiver should
-    be produced only once by the resulting generator
-    """
-    receivers = {}
-    # Get receivers that receive *this* signal from *this* sender.
-    # Add receivers that receive *any* signal from *this* sender.
-    # Add receivers that receive *this* signal from *any* sender.
-    # Add receivers that receive *any* signal from *any* sender.
-    l = []
-    i = id(sender)
-    if i in connections:
-        sender_receivers = connections[i]
-        if signal in sender_receivers:
-            l.extend(sender_receivers[signal])
-        if signal is not Any and Any in sender_receivers:
-            l.extend(sender_receivers[Any])
+    if sender is not Any:
+        i = id(Any)
+        if i in connections:
+            sender_receivers = connections[i]
+            if sender_receivers is not None:
+                if signal in sender_receivers:
+                    l.extend(sender_receivers[signal])
+                if signal is not Any and Any in sender_receivers:
+                    l.extend(sender_receivers[Any])
+    for receiver in l:
+        try:
+            if not receiver in receivers:
+    def _live_receivers(self, senderkey):
+        """Filter sequence of receivers to get resolved, live receivers
+        This checks for weak references
+        and resolves them, then returning only live
+        receivers.
+        """
+        none_senderkey = _make_id(None)
+        for (receiverkey, r_senderkey), receiver in self.receivers:
+            if r_senderkey == none_senderkey or r_senderkey == senderkey:
                 if isinstance(receiver, WEAKREF_TYPES):
+                    # Dereference the weak reference.
                     receiver = receiver()
+                    # this should only (rough guess) be possible if somehow, deref'ing
+                    # triggered a wipe.
+                    if receiver is None:
+                        continue
+                receivers[receiver] = 1
+                yield receiver
+        except TypeError:
+            # dead weakrefs raise TypeError on hash...
+            pass
+                    if receiver is not None:
+                        yield receiver
+                else:
+                    yield receiver
 def send(signal=Any, sender=Anonymous, *arguments, **named):
     """Send signal from sender to all connected receivers.
     signal -- (hashable) signal value, see connect for details
+    def _remove_receiver(self, receiver):
+        """Remove dead receivers from connections."""
+        uid = getattr(receiver, 'dispatch_uid', None)
+    sender -- the sender of the signal
+        if Any, only receivers registered for Any will receive
+        the message.
+        to_remove = []
+        for key, connected_receiver in self.receivers:
+            if connected_receiver == receiver:
+                to_remove.append(key)
+        for key in to_remove:
+            for idx, (r_key, _) in enumerate(self.receivers):
+                if r_key == key:
+                    del self.receivers[idx]
+                    if uid:
+                        self.registered_uids.remove(uid)
+        if Anonymous, only receivers registered to receive
+        messages from Anonymous or Any will receive the message
+def connect(receiver, signal, sender=None, weak=True):
+    """For backward compatibility only. See Signal.connect()
+    """
+    return signal.connect(receiver, sender, weak)
+        Otherwise can be any python object (normally one
+        registered with a connect if you actually want
+        something to occur).
+    arguments -- positional arguments which will be passed to
+        *all* receivers. Note that this may raise TypeErrors
+        if the receivers do not allow the particular arguments.
+        Note also that arguments are applied before named
+        arguments, so they should be used with care.
+    named -- named arguments which will be filtered according
+        to the parameters of the receivers to only provide those
+        acceptable to the receiver.
+    Return a list of tuple pairs [(receiver, response), ... ]
+    if any receiver raises an error, the error propagates back
+    through send, terminating the dispatch loop, so it is quite
+    possible to not have all receivers called if a raises an
+    error.
+def disconnect(receiver, signal, sender=None, weak=True):
+    """For backward compatibility only. See Signal.disconnect()
     """
+    # Call each receiver with whatever arguments it can accept.
+    # Return a list of tuple pairs [(receiver, response), ... ].
+    responses = []
+    for receiver in getAllReceivers(sender, signal):
+        response = robustapply.robustApply(
+            receiver,
+            signal=signal,
+            sender=sender,
+            *arguments,
+            **named
+        )
+        responses.append((receiver, response))
+    return responses
+    signal.disconnect(receiver, sender, weak)
+def sendExact(signal=Any, sender=Anonymous, *arguments, **named ):
+    """Send signal only to those receivers registered for exact message
+    sendExact allows for avoiding Any/Anonymous registered
+    handlers, sending only to those receivers explicitly
+    registered for a particular signal on a particular
+    sender.
+def send(signal, sender=None, **named):
+    """For backward compatibility only. See Signal.send()
     """
+    responses = []
+    for receiver in liveReceivers(getReceivers(sender, signal)):
+        response = robustapply.robustApply(
+            receiver,
+            signal=signal,
+            sender=sender,
+            *arguments,
+            **named
+        )
+        responses.append((receiver, response))
+    return responses
+    return signal.send(sender=sender, **named)
+def _removeReceiver(receiver):
+    """Remove receiver from connections."""
+    if not sendersBack:
+        # During module cleanup the mapping will be replaced with None
+        return False
+    backKey = id(receiver)
+    for senderkey in sendersBack.get(backKey,()):
+        try:
+            signals = connections[senderkey].keys()
+        except KeyError,err:
+            pass
+        else:
+            for signal in signals:
+                try:
+                    receivers = connections[senderkey][signal]
+                except KeyError:
+                    pass
+                else:
+                    try:
+                        receivers.remove(receiver)
+                    except Exception, err:
+                        pass
+                _cleanupConnections(senderkey, signal)
+    try:
+        del sendersBack[ backKey ]
+    except KeyError:
+        pass
+def _cleanupConnections(senderkey, signal):
+    """Delete any empty signals for senderkey. Delete senderkey if empty."""
+    try:
+        receivers = connections[senderkey][signal]
+    except:
+        pass
+    else:
+        if not receivers:
+            # No more connected receivers. Therefore, remove the signal.
+            try:
+                signals = connections[senderkey]
+            except KeyError:
+                pass
+            else:
+                del signals[signal]
+                if not signals:
+                    # No more signal connections. Therefore, remove the sender.
+                    _removeSender(senderkey)
+def _removeSender(senderkey):
+    """Remove senderkey from connections."""
+    _removeBackrefs(senderkey)
+    connections.pop(senderkey, None)
+    senders.pop(senderkey, None)
+def _removeBackrefs(senderkey):
+    """Remove all back-references to this senderkey"""
+    for receiver_list in connections.pop(senderkey, {}).values():
+        for receiver in receiver_list:
+            _killBackref(receiver, senderkey)
+def _removeOldBackRefs(senderkey, signal, receiver, receivers):
+    """Kill old sendersBack references from receiver
+    This guards against multiple registration of the same
+    receiver for a given signal and sender leaking memory
+    as old back reference records build up.
+    Also removes old receiver instance from receivers
+def sendExact(signal, sender, **named ):
+    """This function is deprecated, as it now has the same
+    meaning as send.
     """
+    try:
+        index = receivers.index(receiver)
+        # need to scan back references here and remove senderkey
+    except ValueError:
+        return False
+    else:
+        oldReceiver = receivers[index]
+        del receivers[index]
+        found = 0
+        signals = connections.get(signal)
+        if signals is not None:
+            for sig,recs in connections.get(signal,{}).iteritems():
+                if sig != signal:
+                    for rec in recs:
+                        if rec is oldReceiver:
+                            found = 1
+                            break
+        if not found:
+            _killBackref(oldReceiver, senderkey)
+            return True
+        return False
+def _killBackref(receiver, senderkey):
+    """Do the actual removal of back reference from receiver to senderkey"""
+    receiverkey = id(receiver)
+    receivers_list = sendersBack.get(receiverkey, ())
+    while senderkey in receivers_list:
+        try:
+            receivers_list.remove(senderkey)
+        except:
+            break
+    if not receivers_list:
+        try:
+            del sendersBack[ receiverkey ]
+        except KeyError:
+            pass
+    return True
+    return signal.send(sender=sender, **named)

django/contrib/sites/management.py

 Creates the default Site object.
 """
-from django.dispatch import dispatcher
 from django.db.models import signals
 from django.contrib.sites.models import Site
 from django.contrib.sites import models as site_app
 def create_default_site(app, created_models, verbosity):
+def create_default_site(app, created_models, verbosity, **kwargs):
     if Site in created_models:
         if verbosity >= 2:
             print "Creating example.com Site object"
 …
         s.save()
     Site.objects.clear_cache()
 dispatcher.connect(create_default_site, sender=site_app, signal=signals.post_syncdb)
+signals.post_syncdb.connect(create_default_site, sender=site_app)

django/contrib/contenttypes/management.py

 from django.contrib.contenttypes.models import ContentType
-from django.dispatch import dispatcher
 from django.db.models import get_apps, get_models, signals
 from django.utils.encoding import smart_unicode
 def update_contenttypes(app, created_models, verbosity=2):
+def update_contenttypes(app, created_models, verbosity=2, **kwargs):
     """
     Creates content types for models in the given app, removing any model
     entries that no longer have a matching model class.
 …
     for app in get_apps():
         update_contenttypes(app, None, verbosity)
 dispatcher.connect(update_contenttypes, signal=signals.post_syncdb)
+signals.post_syncdb.connect(update_contenttypes)
 if __name__ == "__main__":
     update_all_contenttypes()

django/contrib/contenttypes/generic.py

 from django.db.models import signals
 from django.db.models.fields.related import RelatedField, Field, ManyToManyRel
 from django.db.models.loading import get_model
-from django.dispatch import dispatcher
 from django.utils.functional import curry
 class GenericForeignKey(object):
 …
         self.cache_attr = "_%s_cache" % name
         # For some reason I don't totally understand, using weakrefs here doesn't work.
         dispatcher.connect(self.instance_pre_init, signal=signals.pre_init, sender=cls, weak=False)
+        signals.pre_init.connect(self.instance_pre_init, sender=cls, weak=False)
         # Connect myself as the descriptor for this field
         setattr(cls, name, self)
     def instance_pre_init(self, signal, sender, args, kwargs):
+    def instance_pre_init(self, signal, sender, args, kwargs, **_kwargs):
         """
         Handles initializing an object with the generic FK instaed of
         content-type/object-id fields.

django/contrib/auth/management/init.py

 Creates permissions for all installed apps that need permissions.
 """
-from django.dispatch import dispatcher
 from django.db.models import get_models, signals
 from django.contrib.auth import models as auth_app
 …
         perms.append((_get_permission_codename(action, opts), u'Can %s %s' % (action, opts.verbose_name_raw)))
     return perms + list(opts.permissions)
 def create_permissions(app, created_models, verbosity):
+def create_permissions(app, created_models, verbosity, **kwargs):
     from django.contrib.contenttypes.models import ContentType
     from django.contrib.auth.models import Permission
     app_models = get_models(app)
 …
                 defaults={'name': name, 'content_type': ctype})
             if created and verbosity >= 2:
                 print "Adding permission '%s'" % p
+create_permissions.dispatch_uid = "django.contrib.auth.management.create_permissions"
 def create_superuser(app, created_models, verbosity, **kwargs):
     from django.contrib.auth.models import User
 …
             if confirm == 'yes':
                 call_command("createsuperuser", interactive=True)
             break
+create_superuser.dispatch_uid = "django.contrib.auth.management.create_superuser"
+if 'create_permissions' not in [i.__name__ for i in dispatcher.getAllReceivers(signal=signals.post_syncdb)]:
+    dispatcher.connect(create_permissions, signal=signals.post_syncdb)
+if 'create_superuser' not in [i.__name__ for i in dispatcher.getAllReceivers(signal=signals.post_syncdb, sender=auth_app)]:
+    dispatcher.connect(create_superuser, sender=auth_app, signal=signals.post_syncdb)
+ No newline at end of file
+signals.post_syncdb.connect(create_permissions)
+signals.post_syncdb.connect(create_superuser, sender=auth_app)
+ No newline at end of file

tests/modeltests/signals/models.py

 """
 from django.db import models
-from django.dispatch import dispatcher
 class Person(models.Model):
     first_name = models.CharField(max_length=20)
 …
     def __unicode__(self):
         return u"%s %s" % (self.first_name, self.last_name)
+def pre_save_nokwargs_test(sender, instance):
+    print 'pre_save_nokwargs signal'
+def post_save_nokwargs_test(sender, instance):
+    print 'post_save_nokwargs signal'
+def pre_save_test(sender, instance, **kwargs):
+def pre_save_test(signal, sender, instance, **kwargs):
     print 'pre_save signal,', instance
     if kwargs.get('raw'):
         print 'Is raw'
 def post_save_test(sender, instance, **kwargs):
+def post_save_test(signal, sender, instance, **kwargs):
     print 'post_save signal,', instance
     if 'created' in kwargs:
         if kwargs['created']:
 …
     if kwargs.get('raw'):
         print 'Is raw'
 def pre_delete_test(sender, instance, **kwargs):
+def pre_delete_test(signal, sender, instance, **kwargs):
     print 'pre_delete signal,', instance
     print 'instance.id is not None: %s' % (instance.id != None)
 def post_delete_test(sender, instance, **kwargs):
+def post_delete_test(signal, sender, instance, **kwargs):
     print 'post_delete signal,', instance
     print 'instance.id is None: %s' % (instance.id == None)
 __test__ = {'API_TESTS':"""
+>>> dispatcher.connect(pre_save_nokwargs_test, signal=models.signals.pre_save)
+>>> dispatcher.connect(post_save_nokwargs_test, signal=models.signals.post_save)
+>>> dispatcher.connect(pre_save_test, signal=models.signals.pre_save)
+>>> dispatcher.connect(post_save_test, signal=models.signals.post_save)
+>>> dispatcher.connect(pre_delete_test, signal=models.signals.pre_delete)
+>>> dispatcher.connect(post_delete_test, signal=models.signals.post_delete)
+>>> models.signals.pre_save.connect(pre_save_test)
+>>> models.signals.post_save.connect(post_save_test)
+>>> models.signals.pre_delete.connect(pre_delete_test)
+>>> models.signals.post_delete.connect(post_delete_test)
 >>> p1 = Person(first_name='John', last_name='Smith')
 >>> p1.save()
-pre_save_nokwargs signal
 pre_save signal, John Smith
-post_save_nokwargs signal
 post_save signal, John Smith
 Is created
 >>> p1.first_name = 'Tom'
 >>> p1.save()
-pre_save_nokwargs signal
 pre_save signal, Tom Smith
-post_save_nokwargs signal
 post_save signal, Tom Smith
 Is updated
 # Calling an internal method purely so that we can trigger a "raw" save.
 >>> p1.save_base(raw=True)
-pre_save_nokwargs signal
 pre_save signal, Tom Smith
 Is raw
-post_save_nokwargs signal
 post_save signal, Tom Smith
 Is updated
 Is raw
 …
 >>> p2 = Person(first_name='James', last_name='Jones')
 >>> p2.id = 99999
 >>> p2.save()
-pre_save_nokwargs signal
 pre_save signal, James Jones
-post_save_nokwargs signal
 post_save signal, James Jones
 Is created
 >>> p2.id = 99998
 >>> p2.save()
-pre_save_nokwargs signal
 pre_save signal, James Jones
-post_save_nokwargs signal
 post_save signal, James Jones
 Is created
 …
 >>> Person.objects.all()
 [<Person: James Jones>]
+>>> dispatcher.disconnect(pre_save_nokwargs_test, signal=models.signals.pre_save)
+>>> dispatcher.disconnect(post_save_nokwargs_test, signal=models.signals.post_save)
+>>> dispatcher.disconnect(post_delete_test, signal=models.signals.post_delete)
+>>> dispatcher.disconnect(pre_delete_test, signal=models.signals.pre_delete)
+>>> dispatcher.disconnect(post_save_test, signal=models.signals.post_save)
+>>> dispatcher.disconnect(pre_save_test, signal=models.signals.pre_save)
+>>> models.signals.post_delete.disconnect(post_delete_test)
+>>> models.signals.pre_delete.disconnect(pre_delete_test)
+>>> models.signals.post_save.disconnect(post_save_test)
+>>> models.signals.pre_save.disconnect(pre_save_test)
 """}

tests/regressiontests/dispatch/tests/init.py

 Unit-tests for the dispatch project
 """
-from test_dispatcher import *
-from test_robustapply import *
 from test_saferef import *
+from test_dispatcher import *
+ No newline at end of file

tests/regressiontests/dispatch/tests/test_robustapply.py

-from django.dispatch.robustapply import *
-import unittest
-def noArgument():
-    pass
-def oneArgument(blah):
-    pass
-def twoArgument(blah, other):
-    pass
-class TestCases(unittest.TestCase):
-    def test01(self):
-        robustApply(noArgument)
-    def test02(self):
-        self.assertRaises(TypeError, robustApply, noArgument, "this")
-    def test03(self):
-        self.assertRaises(TypeError, robustApply, oneArgument)
-    def test04(self):
-        """Raise error on duplication of a particular argument"""
-        self.assertRaises(TypeError, robustApply, oneArgument, "this", blah = "that")
-def getSuite():
-    return unittest.makeSuite(TestCases,'test')
-if __name__ == "__main__":
-    unittest.main()

tests/regressiontests/dispatch/tests/test_dispatcher.py

+from django.dispatch.dispatcher import *
+from django.dispatch import dispatcher, robust
+from django.dispatch.dispatcher import Signal
 import unittest
 import copy
 import sys
 …
     def garbage_collect():
         gc.collect()
 def x(a):
     return a
+def receiver_1_arg(val, **kwargs):
+    return val
-class Dummy(object):
-    pass
 class Callable(object):
     def __call__(self, a):
         return a
+    def __call__(self, val, **kwargs):
+        return val
     def a(self, a):
         return a
+    def a(self, val, **kwargs):
+        return val
+a_signal = Signal(providing_args=["val"])
 class DispatcherTests(unittest.TestCase):
     """Test suite for dispatcher (barely started)"""
+    def setUp(self):
+        # track the initial state, since it's possible that others have bleed receivers in
+        garbage_collect()
+        self.sendersBack = copy.copy(dispatcher.sendersBack)
+        self.connections = copy.copy(dispatcher.connections)
+        self.senders = copy.copy(dispatcher.senders)
+    def _testIsClean(self):
+    def _testIsClean(self, signal):
         """Assert that everything has been cleaned up automatically"""
+        self.assertEqual(dispatcher.sendersBack, self.sendersBack)
+        self.assertEqual(dispatcher.connections, self.connections)
+        self.assertEqual(dispatcher.senders, self.senders)
+        self.assertEqual(signal.receivers, [])
+        self.assertEqual(signal.registered_uids, set())
+        # force cleanup just in case
+        signal.receivers = []
+        signal.registered_uids = set()
     def testExact(self):
+        a = Dummy()
+        signal = 'this'
+        connect(x, signal, a)
+        expected = [(x,a)]
+        result = send('this',a, a=a)
+        a_signal.connect(receiver_1_arg, sender=self)
+        expected = [(receiver_1_arg,"test")]
+        result = a_signal.send(sender=self, val="test")
         self.assertEqual(result, expected)
+        disconnect(x, signal, a)
+        self.assertEqual(list(getAllReceivers(a,signal)), [])
+        self._testIsClean()
+    def testAnonymousSend(self):
+        a = Dummy()
+        signal = 'this'
+        connect(x, signal)
+        expected = [(x,a)]
+        result = send(signal,None, a=a)
+        a_signal.disconnect(receiver_1_arg, sender=self)
+        self._testIsClean(a_signal)
+    def testIgnoredSender(self):
+        a_signal.connect(receiver_1_arg)
+        expected = [(receiver_1_arg,"test")]
+        result = a_signal.send(sender=self, val="test")
         self.assertEqual(result, expected)
+        disconnect(x, signal)
+        self.assertEqual(list(getAllReceivers(None,signal)), [])
+        self._testIsClean()
+        a_signal.disconnect(receiver_1_arg)
+        self._testIsClean(a_signal)
-    def testAnyRegistration(self):
-        a = Dummy()
-        signal = 'this'
-        connect(x, signal, Any)
-        expected = [(x,a)]
-        result = send('this',object(), a=a)
-        self.assertEqual(result, expected)
-        disconnect(x, signal, Any)
-        expected = []
-        result = send('this',object(), a=a)
-        self.assertEqual(result, expected)
-        self.assertEqual(list(getAllReceivers(Any,signal)), [])
-        self._testIsClean()
-    def testAnyRegistration2(self):
-        a = Dummy()
-        signal = 'this'
-        connect(x, Any, a)
-        expected = [(x,a)]
-        result = send('this',a, a=a)
-        self.assertEqual(result, expected)
-        disconnect(x, Any, a)
-        self.assertEqual(list(getAllReceivers(a,Any)), [])
-        self._testIsClean()
     def testGarbageCollected(self):
         a = Callable()
+        b = Dummy()
+        signal = 'this'
+        connect(a.a, signal, b)
+        a_signal.connect(a.a, sender=self)
         expected = []
         del a
         garbage_collect()
         result = send('this',b, a=b)
+        result = a_signal.send(sender=self, val="test")
         self.assertEqual(result, expected)
+        self.assertEqual(list(getAllReceivers(b,signal)), [])
+        self._testIsClean()
+        self._testIsClean(a_signal)
-    def testGarbageCollectedObj(self):
-        class x:
-            def __call__(self, a):
-                return a
-        a = Callable()
-        b = Dummy()
-        signal = 'this'
-        connect(a, signal, b)
-        expected = []
-        del a
-        garbage_collect()
-        result = send('this',b, a=b)
-        self.assertEqual(result, expected)
-        self.assertEqual(list(getAllReceivers(b,signal)), [])
-        self._testIsClean()
     def testMultipleRegistration(self):
         a = Callable()
+        b = Dummy()
+        signal = 'this'
+        connect(a, signal, b)
+        connect(a, signal, b)
+        connect(a, signal, b)
+        connect(a, signal, b)
+        connect(a, signal, b)
+        connect(a, signal, b)
+        result = send('this',b, a=b)
+        a_signal.connect(a)
+        a_signal.connect(a)
+        a_signal.connect(a)
+        a_signal.connect(a)
+        a_signal.connect(a)
+        a_signal.connect(a)
+        result = a_signal.send(sender=self, val="test")
         self.assertEqual(len(result), 1)
         self.assertEqual(len(list(getAllReceivers(b,signal))), 1)
+        self.assertEqual(len(a_signal.receivers), 1)
         del a
-        del b
         del result
         garbage_collect()
+        self._testIsClean()
+        self._testIsClean(a_signal)
+    def testUidRegistration(self):
+        def uid_based_receiver_1(**kwargs):
+            pass
+        uid_based_receiver_1.dispatch_uid = "uid"
+        def uid_based_receiver_2(**kwargs):
+            pass
+        uid_based_receiver_2.dispatch_uid = "uid"
+        a_signal.connect(uid_based_receiver_1)
+        a_signal.connect(uid_based_receiver_2)
+        self.assertEqual(len(a_signal.receivers), 1)
+        a_signal.disconnect(uid_based_receiver_1)
+        self._testIsClean(a_signal)
     def testRobust(self):
         """Test the sendRobust function"""
         def fails():
+        def fails(val, **kwargs):
             raise ValueError('this')
+        a = object()
+        signal = 'this'
+        connect(fails, Any, a)
+        result = robust.sendRobust('this',a, a=a)
+        a_signal.connect(fails)
+        result = a_signal.send_robust(sender=self, val="test")
         err = result[0][1]
         self.assert_(isinstance(err, ValueError))
         self.assertEqual(err.args, ('this',))
+        a_signal.disconnect(fails)
+        self._testIsClean(a_signal)
 def getSuite():
     return unittest.makeSuite(DispatcherTests,'test')

Download in other formats:

Original Format

Issues

Context Navigation

Ticket #6814: signals_8156-2.diff

Download in other formats: