Compat implementation of all(), any() and collections.defaultdict

celery/result.py

@@ -6,6 +6,7 @@ Asynchronous result types.
 import time
 from itertools import imap
 
+from celery.utils import any, all
 from celery.backends import default_backend
 from celery.exceptions import TimeoutError
 from celery.datastructures import PositionQueue

celery/task/rest.py

@@ -1,5 +1,8 @@
 import urllib2
-from cgi import parse_qsl
+try:
+    from urlparse import parse_qsl
+except ImportError:
+    from cgi import parse_qsl
 from urllib import urlencode
 from urlparse import urlparse
 

celery/utils.py

@@ -9,7 +9,11 @@ try:
     import ctypes
 except ImportError:
     ctypes = None
-from uuid import UUID, uuid4, _uuid_generate_random
+from uuid import UUID, uuid4
+try:
+    from uuid import _uuid_generate_random
+except ImportError:
+    _uuid_generate_random = None
 from inspect import getargspec
 from itertools import repeat
 
@@ -57,10 +61,10 @@ def gen_unique_id():
     return str(uuid4())
 
 
-def mitemgetter(*keys):
-    """Like :func:`operator.itemgetter` but returns `None` on missing keys
+def mitemgetter(*items):
+    """Like :func:`operator.itemgetter` but returns ``None`` on missing items
     instead of raising :exc:`KeyError`."""
-    return lambda dict_: map(dict_.get, keys)
+    return lambda container: map(container.get, items)
 
 
 def get_full_cls_name(cls):
@@ -148,3 +152,71 @@ def fun_takes_kwargs(fun, kwlist=[]):
     if keywords != None:
         return kwlist
     return filter(curry(operator.contains, args), kwlist)
+
+
+try:
+    from collections import defaultdict
+except ImportError:
+    # Written by Jason Kirtland, taken from Python Cookbook:
+    # <http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/523034>
+    class defaultdict(dict):
+
+        def __init__(self, default_factory=None, *args, **kwargs):
+            dict.__init__(self, *args, **kwargs)
+            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):
+            f = self.default_factory
+            args = f is None and tuple() or f
+            return type(self), args, None, None, self.iteritems()
+
+        def copy(self):
+            return self.__copy__()
+
+        def __copy__(self):
+            return type(self)(self.default_factory, self)
+
+        def __deepcopy__(self):
+            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))
+    import collections
+    collections.defaultdict = defaultdict # Pickle needs this.
+
+
+try:
+    all([True])
+    all = all
+except NameError:
+    def all(iterable):
+        for item in iterable:
+            if not item:
+                return False
+        return True
+
+
+try:
+    any([True])
+    any = any
+except NameError:
+    def any(iterable):
+        for item in iterable:
+            if item:
+                return True
+        return False

celery/worker/buckets.py

@@ -3,6 +3,8 @@ from Queue import Queue, Empty as QueueEmpty
 
 from carrot.utils import partition
 
+from celery.utils import all
+
 RATE_MODIFIER_MAP = {"s": lambda n: n,
                      "m": lambda n: n / 60.0,
                      "h": lambda n: n / 60.0 / 60.0}