kombu renamed promise -> lazy

celery/app/annotations.py

@@ -13,7 +13,7 @@
 from __future__ import absolute_import
 
 from celery.five import string_t
-from celery.utils.functional import firstmethod, mpromise
+from celery.utils.functional import firstmethod, mlazy
 from celery.utils.imports import instantiate
 
 _first_match = firstmethod('annotate')
@@ -46,7 +46,7 @@ def prepare(annotations):
         if isinstance(annotation, dict):
             return MapAnnotation(annotation)
         elif isinstance(annotation, string_t):
-            return mpromise(instantiate, annotation)
+            return mlazy(instantiate, annotation)
         return annotation
 
     if annotations is None:

celery/app/routes.py

@@ -12,7 +12,7 @@ from __future__ import absolute_import
 from celery.exceptions import QueueNotFound
 from celery.five import string_t
 from celery.utils import lpmerge
-from celery.utils.functional import firstmethod, mpromise
+from celery.utils.functional import firstmethod, mlazy
 from celery.utils.imports import instantiate
 
 _first_route = firstmethod('route_for_task')
@@ -80,7 +80,7 @@ def prepare(routes):
         if isinstance(route, dict):
             return MapRoute(route)
         if isinstance(route, string_t):
-            return mpromise(instantiate, route)
+            return mlazy(instantiate, route)
         return route
 
     if routes is None:

celery/beat.py

@@ -19,7 +19,7 @@ from threading import Event, Thread
 
 from billiard import Process, ensure_multiprocessing
 from kombu.utils import cached_property, reprcall
-from kombu.utils.functional import maybe_promise
+from kombu.utils.functional import maybe_evaluate
 
 from . import __version__
 from . import platforms
@@ -152,7 +152,7 @@ class Scheduler(object):
     def __init__(self, app, schedule=None, max_interval=None,
                  Publisher=None, lazy=False, **kwargs):
         self.app = app
-        self.data = maybe_promise({} if schedule is None else schedule)
+        self.data = maybe_evaluate({} if schedule is None else schedule)
         self.max_interval = (max_interval
                              or app.conf.CELERYBEAT_MAX_LOOP_INTERVAL
                              or self.max_interval)

celery/tests/app/test_routes.py

@@ -3,7 +3,7 @@ from __future__ import absolute_import
 from contextlib import contextmanager
 
 from kombu import Exchange
-from kombu.utils.functional import maybe_promise
+from kombu.utils.functional import maybe_evaluate
 
 from celery.app import routes
 from celery.exceptions import QueueNotFound
@@ -156,7 +156,7 @@ class test_prepare(AppCase):
              'celery.utils.functional.LRUCache', o]
         p = routes.prepare(R)
         self.assertIsInstance(p[0], routes.MapRoute)
-        self.assertIsInstance(maybe_promise(p[1]), LRUCache)
+        self.assertIsInstance(maybe_evaluate(p[1]), LRUCache)
         self.assertIs(p[2], o)
 
         self.assertEqual(routes.prepare(o), [o])

celery/tests/utils/test_functional.py

@@ -2,14 +2,14 @@ from __future__ import absolute_import
 
 import pickle
 
-from kombu.utils.functional import promise
+from kombu.utils.functional import lazy
 
 from celery.five import THREAD_TIMEOUT_MAX, items, range, nextfun
 from celery.utils.functional import (
     LRUCache,
     firstmethod,
     first,
-    mpromise,
+    mlazy,
     padlist,
     maybe_list,
 )
@@ -131,7 +131,7 @@ class test_utils(Case):
     def test_firstmethod_AttributeError(self):
         self.assertIsNone(firstmethod('foo')([object()]))
 
-    def test_firstmethod_promises(self):
+    def test_firstmethod_handles_lazy(self):
 
         class A(object):
 
@@ -144,7 +144,7 @@ class test_utils(Case):
         self.assertEqual('four', firstmethod('m')([
             A(), A(), A(), A('four'), A('five')]))
         self.assertEqual('four', firstmethod('m')([
-            A(), A(), A(), promise(lambda: A('four')), A('five')]))
+            A(), A(), A(), lazy(lambda: A('four')), A('five')]))
 
     def test_first(self):
         iterations = [0]
@@ -168,12 +168,12 @@ class test_utils(Case):
         self.assertIsNone(maybe_list(None))
 
 
-class test_mpromise(Case):
+class test_mlazy(Case):
 
     def test_is_memoized(self):
 
         it = iter(range(20, 30))
-        p = mpromise(nextfun(it))
+        p = mlazy(nextfun(it))
         self.assertEqual(p(), 20)
         self.assertTrue(p.evaluated)
         self.assertEqual(p(), 20)

celery/utils/functional.py

@@ -15,7 +15,7 @@ from functools import wraps
 from itertools import islice
 
 from kombu.utils import cached_property
-from kombu.utils.functional import promise, maybe_promise
+from kombu.utils.functional import lazy, maybe_evaluate
 from kombu.utils.compat import OrderedDict
 
 from celery.five import UserDict, UserList, items, keys, string_t
@@ -161,15 +161,15 @@ def memoize(maxsize=None, Cache=LRUCache):
     return _memoize
 
 
-class mpromise(promise):
-    """Memoized promise.
+class mlazy(lazy):
+    """Memoized lazy evaluation.
 
     The function is only evaluated once, every subsequent access
     will return the same value.
 
     .. attribute:: evaluated
 
-        Set to to :const:`True` after the promise has been evaluated.
+        Set to to :const:`True` after the object has been evaluated.
 
     """
     evaluated = False
@@ -177,7 +177,7 @@ class mpromise(promise):
 
     def evaluate(self):
         if not self.evaluated:
-            self._value = super(mpromise, self).evaluate()
+            self._value = super(mlazy, self).evaluate()
             self.evaluated = True
         return self._value
 
@@ -208,14 +208,15 @@ def firstmethod(method):
     """Returns a function that with a list of instances,
     finds the first instance that returns a value for the given method.
 
-    The list can also contain promises (:class:`promise`.)
+    The list can also contain lazy instances
+    (:class:`~kombu.utils.functional.lazy`.)
 
     """
 
     def _matcher(it, *args, **kwargs):
         for obj in it:
             try:
-                answer = getattr(maybe_promise(obj), method)(*args, **kwargs)
+                answer = getattr(maybe_evaluate(obj), method)(*args, **kwargs)
             except AttributeError:
                 pass
             else: