Python 2.4 compatability.

2 files changed, 56 insertions, 3 deletions

diff --git a/blinker/_utilities.py b/blinker/_utilities.py
index 8ed1c3d..9890194 100644
--- a/blinker/_utilities.py
+++ b/blinker/_utilities.py
@@ -10,6 +10,53 @@ except NameError:
         return hasattr(object, '__call__')
 
 
+try:
+    from collections import defaultdict
+except:
+    class defaultdict(dict):
+
+        def __init__(self, default_factory=None, *a, **kw):
+            if (default_factory is not None and
+                not hasattr(default_factory, '__call__')):
+                raise TypeError('first argument must be callable')
+            dict.__init__(self, *a, **kw)
+            self.default_factory = default_factory
+
+        def __getitem__(self, key):
+            try:
+                return dict.__getitem__(self, key)
+            except KeyError:
+                return self.__missing__(key)
+
+        def __missing__(self, key):
+            if self.default_factory is None:
+                raise KeyError(key)
+            self[key] = value = self.default_factory()
+            return value
+
+        def __reduce__(self):
+            if self.default_factory is None:
+                args = tuple()
+            else:
+                args = self.default_factory,
+            return type(self), args, None, None, self.items()
+
+        def copy(self):
+            return self.__copy__()
+
+        def __copy__(self):
+            return type(self)(self.default_factory, self)
+
+        def __deepcopy__(self, memo):
+            import copy
+            return type(self)(self.default_factory,
+                              copy.deepcopy(self.items()))
+
+        def __repr__(self):
+            return 'defaultdict(%s, %s)' % (self.default_factory,
+                                            dict.__repr__(self))
+
+
 class _symbol(object):
 
     def __init__(self, name):
diff --git a/blinker/base.py b/blinker/base.py
index 310c1b6..14ee6d9 100644
--- a/blinker/base.py
+++ b/blinker/base.py
@@ -8,11 +8,11 @@ each manages its own receivers and message emission.
 The :func:`signal` function provides singleton behavior for named signals.
 
 """
-from collections import defaultdict
 from weakref import WeakValueDictionary
 
 from blinker._utilities import (
     WeakTypes,
+    defaultdict,
     hashable_identity,
     reference,
     symbol,
@@ -61,7 +61,10 @@ class Signal(object):
             receiver_ref.receiver_id = receiver_id
         else:
             receiver_ref = receiver
-        sender_id = ANY_ID if sender is ANY else hashable_identity(sender)
+        if sender is ANY:
+            sender_id = ANY_ID
+        else:
+            sender_id = hashable_identity(sender)
 
         self.receivers.setdefault(receiver_id, receiver_ref)
         self._by_sender[sender_id].add(receiver_id)
@@ -159,7 +162,10 @@ class Signal(object):
 
     def disconnect(self, receiver, sender=ANY):
         """Disconnect *receiver* from this signal's events."""
-        sender_id = ANY_ID if sender is ANY else hashable_identity(sender)
+        if sender is ANY:
+            sender_id = ANY_ID
+        else:
+            sender_id = hashable_identity(sender)
         receiver_id = hashable_identity(receiver)
         self._disconnect(receiver_id, sender_id)