Renames Result.serializable()/from_serializable -> Result.as_tuple()/result_from_tuple

celery/app/builtins.py

@@ -66,7 +66,7 @@ def add_unlock_chord_task(app):
     """
     from celery.canvas import signature
     from celery.exceptions import ChordError
-    from celery.result import from_serializable
+    from celery.result import result_from_tuple
 
     default_propagate = app.conf.CELERY_CHORD_PROPAGATES
 
@@ -75,7 +75,7 @@ def add_unlock_chord_task(app):
     def unlock_chord(group_id, callback, interval=None, propagate=None,
                      max_retries=None, result=None,
                      Result=app.AsyncResult, GroupResult=app.GroupResult,
-                     from_serializable=from_serializable):
+                     result_from_tuple=result_from_tuple):
         # if propagate is disabled exceptions raised by chord tasks
         # will be sent as part of the result list to the chord callback.
         # Since 3.1 propagate will be enabled by default, and instead
@@ -88,7 +88,7 @@ def add_unlock_chord_task(app):
         # check if the task group is ready, and if so apply the callback.
         deps = GroupResult(
             group_id,
-            [from_serializable(r, app=app) for r in result],
+            [result_from_tuple(r, app=app) for r in result],
         )
         j = deps.join_native if deps.supports_native_join else deps.join
 
@@ -158,7 +158,7 @@ def add_chunk_task(app):
 def add_group_task(app):
     _app = app
     from celery.canvas import maybe_signature, signature
-    from celery.result import from_serializable
+    from celery.result import result_from_tuple
 
     class Group(app.Task):
         app = _app
@@ -168,7 +168,7 @@ def add_group_task(app):
 
         def run(self, tasks, result, group_id, partial_args):
             app = self.app
-            result = from_serializable(result, app)
+            result = result_from_tuple(result, app)
             # any partial args are added to all tasks in the group
             taskit = (signature(task, app=app).clone(partial_args)
                       for i, task in enumerate(tasks))
@@ -209,7 +209,7 @@ def add_group_task(app):
                 options, args=partial_args, **kwargs
             )
             super(Group, self).apply_async((
-                list(tasks), result.serializable(), gid, args), **options
+                list(tasks), result.as_tuple(), gid, args), **options
             )
             return result
 

celery/backends/base.py

@@ -29,7 +29,7 @@ from celery import states
 from celery.app import current_task
 from celery.exceptions import ChordError, TimeoutError, TaskRevokedError
 from celery.five import items
-from celery.result import from_serializable, GroupResult
+from celery.result import result_from_tuple, GroupResult
 from celery.utils import timeutils
 from celery.utils.functional import LRUCache
 from celery.utils.serialization import (
@@ -139,7 +139,7 @@ class BaseBackend(object):
     def prepare_value(self, result):
         """Prepare value for storage."""
         if isinstance(result, GroupResult):
-            return result.serializable()
+            return result.as_tuple()
         return result
 
     def encode(self, data):
@@ -307,7 +307,7 @@ class BaseBackend(object):
 
     def fallback_chord_unlock(self, group_id, body, result=None,
                               countdown=1, **kwargs):
-        kwargs['result'] = [r.serializable() for r in result]
+        kwargs['result'] = [r.as_tuple() for r in result]
         self.app.tasks['celery.chord_unlock'].apply_async(
             (group_id, body, ), kwargs, countdown=countdown,
         )
@@ -316,7 +316,7 @@ class BaseBackend(object):
     def current_task_children(self, request=None):
         request = request or getattr(current_task(), 'request', None)
         if request:
-            return [r.serializable() for r in getattr(request, 'children', [])]
+            return [r.as_tuple() for r in getattr(request, 'children', [])]
 
     def __reduce__(self, args=(), kwargs={}):
         return (unpickle_backend, (self.__class__, args, kwargs))
@@ -422,7 +422,7 @@ class KeyValueStoreBackend(BaseBackend):
 
     def _save_group(self, group_id, result):
         self.set(self.get_key_for_group(group_id),
-                 self.encode({'result': result.serializable()}))
+                 self.encode({'result': result.as_tuple()}))
         return result
 
     def _delete_group(self, group_id):
@@ -444,7 +444,7 @@ class KeyValueStoreBackend(BaseBackend):
         if meta:
             meta = self.decode(meta)
             result = meta['result']
-            meta['result'] = from_serializable(result, self.app)
+            meta['result'] = result_from_tuple(result, self.app)
             return meta
 
     def on_chord_apply(self, group_id, body, result=None, **kwargs):

celery/result.py

@@ -24,7 +24,7 @@ from .exceptions import IncompleteStream, TimeoutError
 from .five import items, range, string_t, monotonic
 
 __all__ = ['ResultBase', 'AsyncResult', 'ResultSet', 'GroupResult',
-           'EagerResult', 'from_serializable']
+           'EagerResult', 'result_from_tuple']
 
 
 class ResultBase(object):
@@ -60,8 +60,10 @@ class AsyncResult(ResultBase):
         self.task_name = task_name
         self.parent = parent
 
-    def serializable(self):
-        return [self.id, self.parent and self.parent.serializable()], None
+    def as_tuple(self):
+        parent = self.parent
+        return (self.id, parent and parent.as_tuple()), None
+    serializable = as_tuple   # XXX compat
 
     def forget(self):
         """Forget about (and possibly remove the result of) this task."""
@@ -249,7 +251,7 @@ class AsyncResult(ResultBase):
     def children(self):
         children = self.backend.get_children(self.id)
         if children:
-            return [from_serializable(child, self.app) for child in children]
+            return [result_from_tuple(child, self.app) for child in children]
 
     @property
     def result(self):
@@ -669,8 +671,9 @@ class GroupResult(ResultSet):
         return '<{0}: {1} [{2}]>'.format(type(self).__name__, self.id,
                                          ', '.join(r.id for r in self.results))
 
-    def serializable(self):
-        return self.id, [r.serializable() for r in self.results]
+    def as_tuple(self):
+        return self.id, [r.as_tuple() for r in self.results]
+    serializable = as_tuple   # XXX compat
 
     @property
     def children(self):
@@ -775,7 +778,7 @@ class EagerResult(AsyncResult):
         return False
 
 
-def from_serializable(r, app=None):
+def result_from_tuple(r, app=None):
     # earlier backends may just pickle, so check if
     # result is already prepared.
     app = app_or_default(app)
@@ -784,11 +787,12 @@ def from_serializable(r, app=None):
         res, nodes = r
         if nodes:
             return app.GroupResult(
-                res, [from_serializable(child, app) for child in nodes],
+                res, [result_from_tuple(child, app) for child in nodes],
             )
         # previously did not include parent
         id, parent = res if isinstance(res, (list, tuple)) else (res, None)
         if parent:
-            parent = from_serializable(parent, app)
+            parent = result_from_tuple(parent, app)
         return Result(id, parent=parent)
     return r
+from_serializable = result_from_tuple  # XXX compat

celery/tests/tasks/test_result.py

@@ -10,7 +10,7 @@ from celery.result import (
     AsyncResult,
     EagerResult,
     TaskSetResult,
-    from_serializable,
+    result_from_tuple,
 )
 from celery.utils import uuid
 from celery.utils.serialization import pickle
@@ -88,7 +88,7 @@ class test_AsyncResult(AppCase):
     def test_get_children(self):
         tid = uuid()
         x = self.app.AsyncResult(tid)
-        child = [self.app.AsyncResult(uuid()).serializable()
+        child = [self.app.AsyncResult(uuid()).as_tuple()
                  for i in range(10)]
         x.backend._cache[tid] = {'children': child}
         self.assertTrue(x.children)
@@ -686,29 +686,29 @@ class test_EagerResult(AppCase):
         self.assertFalse(res.revoke())
 
 
-class test_serializable(AppCase):
+class test_tuples(AppCase):
 
     def test_AsyncResult(self):
         x = self.app.AsyncResult(uuid())
-        self.assertEqual(x, from_serializable(x.serializable(), self.app))
-        self.assertEqual(x, from_serializable(x, self.app))
+        self.assertEqual(x, result_from_tuple(x.as_tuple(), self.app))
+        self.assertEqual(x, result_from_tuple(x, self.app))
 
     def test_with_parent(self):
         x = self.app.AsyncResult(uuid())
         x.parent = self.app.AsyncResult(uuid())
-        y = from_serializable(x.serializable(), self.app)
+        y = result_from_tuple(x.as_tuple(), self.app)
         self.assertEqual(y, x)
         self.assertEqual(y.parent, x.parent)
         self.assertIsInstance(y.parent, AsyncResult)
 
     def test_compat(self):
         uid = uuid()
-        x = from_serializable([uid, []], app=self.app)
+        x = result_from_tuple([uid, []], app=self.app)
         self.assertEqual(x.id, uid)
 
     def test_GroupResult(self):
         x = self.app.GroupResult(
             uuid(), [self.app.AsyncResult(uuid()) for _ in range(10)],
         )
-        self.assertEqual(x, from_serializable(x.serializable(), self.app))
-        self.assertEqual(x, from_serializable(x, self.app))
+        self.assertEqual(x, result_from_tuple(x.as_tuple(), self.app))
+        self.assertEqual(x, result_from_tuple(x, self.app))