Moves .utils.jsonify to .utils.serialization

celery/tests/utils/test_serialization.py

@@ -1,13 +1,19 @@
 from __future__ import absolute_import, unicode_literals
 
+import pytz
 import sys
 
+from datetime import datetime, date, time, timedelta
+
+from kombu import Queue
+
 from celery.utils.serialization import (
     UnpickleableExceptionWrapper,
     get_pickleable_etype,
+    jsonify,
 )
 
-from celery.tests.case import Case, mock
+from celery.tests.case import Case, Mock, mock
 
 
 class test_AAPickle(Case):
@@ -40,3 +46,32 @@ class test_get_pickleable_etype(Case):
                 raise ValueError('foo')
 
         self.assertIs(get_pickleable_etype(Unpickleable), Exception)
+
+
+class test_jsonify(Case):
+
+    def test_simple(self):
+        self.assertTrue(jsonify(Queue('foo')))
+        self.assertTrue(jsonify(['foo', 'bar', 'baz']))
+        self.assertTrue(jsonify({'foo': 'bar'}))
+        self.assertTrue(jsonify(datetime.utcnow()))
+        self.assertTrue(jsonify(datetime.utcnow().replace(tzinfo=pytz.utc)))
+        self.assertTrue(jsonify(datetime.utcnow().replace(microsecond=0)))
+        self.assertTrue(jsonify(date(2012, 1, 1)))
+        self.assertTrue(jsonify(time(hour=1, minute=30)))
+        self.assertTrue(jsonify(time(hour=1, minute=30, microsecond=3)))
+        self.assertTrue(jsonify(timedelta(seconds=30)))
+        self.assertTrue(jsonify(10))
+        self.assertTrue(jsonify(10.3))
+        self.assertTrue(jsonify('hello'))
+
+        unknown_type_filter = Mock()
+        obj = object()
+        self.assertIs(
+            jsonify(obj, unknown_type_filter=unknown_type_filter),
+            unknown_type_filter.return_value,
+        )
+        unknown_type_filter.assert_called_with(obj)
+
+        with self.assertRaises(ValueError):
+            jsonify(obj)

celery/tests/utils/test_utils.py

@@ -1,46 +1,10 @@
 from __future__ import absolute_import, unicode_literals
 
-import pytz
-
-from datetime import datetime, date, time, timedelta
-
-from kombu import Queue
-
 from celery.utils import (
     chunks,
     cached_property,
-    jsonify,
 )
-from celery.tests.case import Case, Mock
-
-
-class test_jsonify(Case):
-
-    def test_simple(self):
-        self.assertTrue(jsonify(Queue('foo')))
-        self.assertTrue(jsonify(['foo', 'bar', 'baz']))
-        self.assertTrue(jsonify({'foo': 'bar'}))
-        self.assertTrue(jsonify(datetime.utcnow()))
-        self.assertTrue(jsonify(datetime.utcnow().replace(tzinfo=pytz.utc)))
-        self.assertTrue(jsonify(datetime.utcnow().replace(microsecond=0)))
-        self.assertTrue(jsonify(date(2012, 1, 1)))
-        self.assertTrue(jsonify(time(hour=1, minute=30)))
-        self.assertTrue(jsonify(time(hour=1, minute=30, microsecond=3)))
-        self.assertTrue(jsonify(timedelta(seconds=30)))
-        self.assertTrue(jsonify(10))
-        self.assertTrue(jsonify(10.3))
-        self.assertTrue(jsonify('hello'))
-
-        unknown_type_filter = Mock()
-        obj = object()
-        self.assertIs(
-            jsonify(obj, unknown_type_filter=unknown_type_filter),
-            unknown_type_filter.return_value,
-        )
-        unknown_type_filter.assert_called_with(obj)
-
-        with self.assertRaises(ValueError):
-            jsonify(obj)
+from celery.tests.case import Case
 
 
 class test_chunks(Case):

celery/utils/__init__.py

@@ -8,13 +8,9 @@
 """
 from __future__ import absolute_import, print_function, unicode_literals
 
-import numbers
 import sys
-import datetime
 
-from functools import partial
-
-from celery.five import items, reraise, string_t
+from celery.five import reraise
 
 from .functional import memoize  # noqa
 
@@ -22,7 +18,7 @@ from .nodenames import worker_direct, nodename, nodesplit
 
 __all__ = ['worker_direct',
            'maybe_reraise',
-           'jsonify', 'gen_task_name', 'nodename', 'nodesplit',
+           'gen_task_name', 'nodename', 'nodesplit',
            'cached_property']
 
 PY3 = sys.version_info[0] == 3
@@ -40,53 +36,6 @@ def maybe_reraise():
         del(exc_info)
 
 
-def jsonify(obj,
-            builtin_types=(numbers.Real, string_t), key=None,
-            keyfilter=None,
-            unknown_type_filter=None):
-    """Transforms object making it suitable for json serialization"""
-    from kombu.abstract import Object as KombuDictType
-    _jsonify = partial(jsonify, builtin_types=builtin_types, key=key,
-                       keyfilter=keyfilter,
-                       unknown_type_filter=unknown_type_filter)
-
-    if isinstance(obj, KombuDictType):
-        obj = obj.as_dict(recurse=True)
-
-    if obj is None or isinstance(obj, builtin_types):
-        return obj
-    elif isinstance(obj, (tuple, list)):
-        return [_jsonify(v) for v in obj]
-    elif isinstance(obj, dict):
-        return {
-            k: _jsonify(v, key=k) for k, v in items(obj)
-            if (keyfilter(k) if keyfilter else 1)
-        }
-    elif isinstance(obj, datetime.datetime):
-        # See "Date Time String Format" in the ECMA-262 specification.
-        r = obj.isoformat()
-        if obj.microsecond:
-            r = r[:23] + r[26:]
-        if r.endswith('+00:00'):
-            r = r[:-6] + 'Z'
-        return r
-    elif isinstance(obj, datetime.date):
-        return obj.isoformat()
-    elif isinstance(obj, datetime.time):
-        r = obj.isoformat()
-        if obj.microsecond:
-            r = r[:12]
-        return r
-    elif isinstance(obj, datetime.timedelta):
-        return str(obj)
-    else:
-        if unknown_type_filter is None:
-            raise ValueError(
-                'Unsupported type: {0!r} {1!r} (parent: {2})'.format(
-                    type(obj), obj, key))
-        return unknown_type_filter(obj)
-
-
 # ------------------------------------------------------------------------ #
 # > XXX Compat
 from .log import LOG_LEVELS     # noqa

celery/utils/serialization.py

@@ -8,21 +8,27 @@
 """
 from __future__ import absolute_import, unicode_literals
 
-from celery.five import bytes_if_py2, python_2_unicode_compatible, string_t
+import datetime
+import numbers
 
 from base64 import b64encode as base64encode, b64decode as base64decode
+from functools import partial
 from inspect import getmro
 from itertools import takewhile
 
+from kombu.utils.encoding import bytes_to_str, str_to_bytes
+
+from celery.five import (
+    bytes_if_py2, python_2_unicode_compatible, items, string_t,
+)
+
+from .encoding import safe_repr
+
 try:
     import cPickle as pickle
 except ImportError:
     import pickle  # noqa
 
-from kombu.utils.encoding import bytes_to_str, str_to_bytes
-
-from .encoding import safe_repr
-
 __all__ = ['UnpickleableExceptionWrapper', 'subclass_exception',
            'find_pickleable_exception', 'create_exception_cls',
            'get_pickleable_exception', 'get_pickleable_etype',
@@ -191,3 +197,50 @@ def strtobool(term, table={'false': False, 'no': False, '0': False,
         except KeyError:
             raise TypeError('Cannot coerce {0!r} to type bool'.format(term))
     return term
+
+
+def jsonify(obj,
+            builtin_types=(numbers.Real, string_t), key=None,
+            keyfilter=None,
+            unknown_type_filter=None):
+    """Transforms object making it suitable for json serialization"""
+    from kombu.abstract import Object as KombuDictType
+    _jsonify = partial(jsonify, builtin_types=builtin_types, key=key,
+                       keyfilter=keyfilter,
+                       unknown_type_filter=unknown_type_filter)
+
+    if isinstance(obj, KombuDictType):
+        obj = obj.as_dict(recurse=True)
+
+    if obj is None or isinstance(obj, builtin_types):
+        return obj
+    elif isinstance(obj, (tuple, list)):
+        return [_jsonify(v) for v in obj]
+    elif isinstance(obj, dict):
+        return {
+            k: _jsonify(v, key=k) for k, v in items(obj)
+            if (keyfilter(k) if keyfilter else 1)
+        }
+    elif isinstance(obj, datetime.datetime):
+        # See "Date Time String Format" in the ECMA-262 specification.
+        r = obj.isoformat()
+        if obj.microsecond:
+            r = r[:23] + r[26:]
+        if r.endswith('+00:00'):
+            r = r[:-6] + 'Z'
+        return r
+    elif isinstance(obj, datetime.date):
+        return obj.isoformat()
+    elif isinstance(obj, datetime.time):
+        r = obj.isoformat()
+        if obj.microsecond:
+            r = r[:12]
+        return r
+    elif isinstance(obj, datetime.timedelta):
+        return str(obj)
+    else:
+        if unknown_type_filter is None:
+            raise ValueError(
+                'Unsupported type: {0!r} {1!r} (parent: {2})'.format(
+                    type(obj), obj, key))
+        return unknown_type_filter(obj)

celery/worker/control.py

@@ -20,7 +20,7 @@ from celery.platforms import signals as _signals
 from celery.utils import timeutils
 from celery.utils.functional import maybe_list
 from celery.utils.log import get_logger
-from celery.utils import jsonify
+from celery.utils.serialization import jsonify
 
 from . import state as worker_state
 from .request import Request