promise + maybe_promise has been moved to Kombu2

celery/tests/test_utils/__init__.py

@@ -4,7 +4,7 @@ from __future__ import with_statement
 import pickle
 
 from celery import utils
-from celery.utils import promise, mpromise, maybe_promise
+from celery.utils import promise, mpromise
 from celery.utils.threads import bgThread
 from celery.tests.utils import unittest
 
@@ -129,39 +129,6 @@ class test_utils(unittest.TestCase):
         self.assertIs(x.__delete__(None), x)
 
 
-class test_promise(unittest.TestCase):
-
-    def test__str__(self):
-        self.assertEqual(str(promise(lambda: "the quick brown fox")),
-                "the quick brown fox")
-
-    def test__repr__(self):
-        self.assertEqual(repr(promise(lambda: "fi fa fo")),
-                "'fi fa fo'")
-
-    def test_evaluate(self):
-        self.assertEqual(promise(lambda: 2 + 2)(), 4)
-        self.assertEqual(promise(lambda x: x * 4, 2), 8)
-        self.assertEqual(promise(lambda x: x * 8, 2)(), 16)
-
-    def test_cmp(self):
-        self.assertEqual(promise(lambda: 10), promise(lambda: 10))
-        self.assertNotEqual(promise(lambda: 10), promise(lambda: 20))
-
-    def test__reduce__(self):
-        x = promise(double, 4)
-        y = pickle.loads(pickle.dumps(x))
-        self.assertEqual(x(), y())
-
-    def test__deepcopy__(self):
-        from copy import deepcopy
-        x = promise(double, 4)
-        y = deepcopy(x)
-        self.assertEqual(x._fun, y._fun)
-        self.assertEqual(x._args, y._args)
-        self.assertEqual(x(), y())
-
-
 class test_mpromise(unittest.TestCase):
 
     def test_is_memoized(self):
@@ -172,10 +139,3 @@ class test_mpromise(unittest.TestCase):
         self.assertTrue(p.evaluated)
         self.assertEqual(p(), 20)
         self.assertEqual(repr(p), "20")
-
-
-class test_maybe_promise(unittest.TestCase):
-
-    def test_evaluates(self):
-        self.assertEqual(maybe_promise(promise(lambda: 10)), 10)
-        self.assertEqual(maybe_promise(20), 20)

celery/utils/__init__.py

@@ -28,7 +28,9 @@ from inspect import getargspec
 from itertools import islice
 from pprint import pprint
 
-from kombu.utils import cached_property, gen_unique_id  # noqa
+from kombu.utils import cached_property, gen_unique_id, kwdict  # noqa
+from kombu.utils import reprcall, reprkwargs                    # noqa
+from kombu.utils.functional import promise, maybe_promise       # noqa
 uuid = gen_unique_id
 
 from ..exceptions import CPendingDeprecationWarning, CDeprecationWarning
@@ -86,52 +88,6 @@ def lpmerge(L, R):
     return dict(L, **dict((k, v) for k, v in R.iteritems() if v is not None))
 
 
-class promise(object):
-    """A promise.
-
-    Evaluated when called or if the :meth:`evaluate` method is called.
-    The function is evaluated on every access, so the value is not
-    memoized (see :class:`mpromise`).
-
-    Overloaded operations that will evaluate the promise:
-        :meth:`__str__`, :meth:`__repr__`, :meth:`__cmp__`.
-
-    """
-
-    def __init__(self, fun, *args, **kwargs):
-        self._fun = fun
-        self._args = args
-        self._kwargs = kwargs
-
-    def __call__(self):
-        return self.evaluate()
-
-    def evaluate(self):
-        return self._fun(*self._args, **self._kwargs)
-
-    def __str__(self):
-        return str(self())
-
-    def __repr__(self):
-        return repr(self())
-
-    def __cmp__(self, rhs):
-        if isinstance(rhs, self.__class__):
-            return -cmp(rhs, self())
-        return cmp(self(), rhs)
-
-    def __eq__(self, rhs):
-        return self() == rhs
-
-    def __deepcopy__(self, memo):
-        memo[id(self)] = self
-        return self
-
-    def __reduce__(self):
-        return (self.__class__, (self._fun, ), {"_args": self._args,
-                                                "_kwargs": self._kwargs})
-
-
 class mpromise(promise):
     """Memoized promise.
 
@@ -153,13 +109,6 @@ class mpromise(promise):
         return self._value
 
 
-def maybe_promise(value):
-    """Evaluates if the value is a promise."""
-    if isinstance(value, promise):
-        return value.evaluate()
-    return value
-
-
 def noop(*args, **kwargs):
     """No operation.
 
@@ -169,22 +118,6 @@ def noop(*args, **kwargs):
     pass
 
 
-if sys.version_info >= (2, 6):
-
-    def kwdict(kwargs):
-        return kwargs
-else:
-    def kwdict(kwargs):  # noqa
-        """Make sure keyword arguments are not in unicode.
-
-        This should be fixed in newer Python versions,
-        see: http://bugs.python.org/issue4978.
-
-        """
-        return dict((key.encode("utf-8"), value)
-                        for key, value in kwargs.items())
-
-
 def first(predicate, iterable):
     """Returns the first element in `iterable` that `predicate` returns a
     :const:`True` value for."""
@@ -486,16 +419,6 @@ def cry():  # pragma: no cover
     return out.getvalue()
 
 
-def reprkwargs(kwargs, sep=', ', fmt="%s=%s"):
-    return sep.join(fmt % (k, _safe_repr(v)) for k, v in kwargs.iteritems())
-
-
-def reprcall(name, args=(), kwargs=(), sep=', '):
-    return "%s(%s%s%s)" % (name, sep.join(map(_safe_repr, args)),
-                           (args and kwargs) and sep or "",
-                           reprkwargs(kwargs, sep))
-
-
 def uniq(it):
     seen = set()
     for obj in it: