Removes more Py2 compatibility stuff

celery/app/amqp.py

@@ -3,7 +3,6 @@
 from __future__ import absolute_import, unicode_literals
 
 import numbers
-import sys
 
 from collections import Mapping, namedtuple
 from datetime import timedelta
@@ -16,7 +15,6 @@ from kombu.utils import cached_property
 from kombu.utils.functional import maybe_list
 
 from celery import signals
-from celery.local import try_import
 from celery.utils.nodenames import anon_nodename
 from celery.utils.saferepr import saferepr
 from celery.utils.text import indent as textindent
@@ -26,14 +24,9 @@ from . import routes as _routes
 
 __all__ = ['AMQP', 'Queues', 'task_message']
 
-PY3 = sys.version_info[0] == 3
-
 #: earliest date supported by time.mktime.
 INT_MIN = -2147483648
 
-# json in Python 2.7 borks if dict contains byte keys.
-JSON_NEEDS_UNICODE_KEYS = not PY3 and not try_import('simplejson')
-
 #: Human readable queue declaration.
 QUEUE_FORMAT = """
 .> {0.name:<16} exchange={0.exchange.name}({0.exchange.type}) \
@@ -329,14 +322,6 @@ class AMQP:
         if kwargsrepr is None:
             kwargsrepr = saferepr(kwargs, self.kwargsrepr_maxsize)
 
-        if JSON_NEEDS_UNICODE_KEYS:  # pragma: no cover
-            if callbacks:
-                callbacks = [utf8dict(callback) for callback in callbacks]
-            if errbacks:
-                errbacks = [utf8dict(errback) for errback in errbacks]
-            if chord:
-                chord = utf8dict(chord)
-
         return task_message(
             headers={
                 'lang': 'py',
@@ -409,14 +394,6 @@ class AMQP:
         eta = eta and eta.isoformat()
         expires = expires and expires.isoformat()
 
-        if JSON_NEEDS_UNICODE_KEYS:  # pragma: no cover
-            if callbacks:
-                callbacks = [utf8dict(callback) for callback in callbacks]
-            if errbacks:
-                errbacks = [utf8dict(errback) for errback in errbacks]
-            if chord:
-                chord = utf8dict(chord)
-
         return task_message(
             headers={},
             properties={

celery/backends/base.py

@@ -42,7 +42,6 @@ from celery.utils.serialization import (
 __all__ = ['BaseBackend', 'KeyValueStoreBackend', 'DisabledBackend']
 
 EXCEPTION_ABLE_CODECS = frozenset({'pickle'})
-PY3 = sys.version_info >= (3, 0)
 
 logger = get_logger(__name__)
 
@@ -244,7 +243,6 @@ class Backend:
         return self.meta_from_decoded(self.decode(payload))
 
     def decode(self, payload):
-        payload = PY3 and payload or str(payload)
         return loads(payload,
                      content_type=self.content_type,
                      content_encoding=self.content_encoding,

celery/backends/cache.py

@@ -2,8 +2,6 @@
 """Memcached and in-memory cache result backend."""
 from __future__ import absolute_import, unicode_literals
 
-import sys
-
 from kombu.utils import cached_property
 from kombu.utils.encoding import bytes_to_str, ensure_bytes
 
@@ -16,8 +14,6 @@ __all__ = ['CacheBackend']
 
 _imp = [None]
 
-PY3 = sys.version_info[0] == 3
-
 REQUIRES_BACKEND = """\
 The Memcached backend requires either pylibmc or python-memcached.\
 """
@@ -30,7 +26,7 @@ Please use one of the following backends instead: {1}\
 
 def import_best_memcache():
     if _imp[0] is None:
-        is_pylibmc, memcache_key_t = False, ensure_bytes
+        is_pylibmc = False
         try:
             import pylibmc as memcache
             is_pylibmc = True
@@ -39,9 +35,7 @@ def import_best_memcache():
                 import memcache  # noqa
             except ImportError:
                 raise ImproperlyConfigured(REQUIRES_BACKEND)
-        if PY3:  # pragma: no cover
-            memcache_key_t = bytes_to_str
-        _imp[0] = (is_pylibmc, memcache, memcache_key_t)
+        _imp[0] = (is_pylibmc, memcache, bytes_to_str)
     return _imp[0]
 
 

celery/backends/cassandra.py

@@ -2,7 +2,6 @@
 """Apache Cassandra result store backend using the DataStax driver."""
 from __future__ import absolute_import, unicode_literals
 
-import sys
 try:  # pragma: no cover
     import cassandra
     import cassandra.auth
@@ -58,11 +57,9 @@ Q_EXPIRES = """
     USING TTL {0}
 """
 
-if sys.version_info[0] == 3:
-    def buf_t(x):
-        return bytes(x, 'utf8')
-else:
-    buf_t = buffer  # noqa
+
+def buf_t(x):
+    return bytes(x, 'utf8')
 
 
 class CassandraBackend(BaseBackend):

celery/backends/riak.py

@@ -2,8 +2,6 @@
 """Riak result store backend."""
 from __future__ import absolute_import, unicode_literals
 
-import sys
-
 try:
     import riak
     from riak import RiakClient
@@ -21,18 +19,13 @@ E_BUCKET_NAME = """\
 Riak bucket names must be composed of ASCII characters only, not: {0!r}\
 """
 
-if sys.version_info[0] == 3:
-
-    def to_bytes(s):
-        return s.encode() if isinstance(s, str) else s
 
-    def str_decode(s, encoding):
-        return to_bytes(s).decode(encoding)
+def to_bytes(s):
+    return s.encode() if isinstance(s, str) else s
 
-else:
 
-    def str_decode(s, encoding):
-        return s.decode('ascii')
+def str_decode(s, encoding):
+    return to_bytes(s).decode(encoding)
 
 
 def is_ascii(s):

celery/bin/multi.py

@@ -467,7 +467,7 @@ def _args_for_node(p, name, prefix, suffix, cmd, append, options):
 
     argv = ([expand(cmd)] +
             [format_opt(opt, expand(value))
-                for opt, value in p.optmerge(ns, options).items())] +
+                for opt, value in p.optmerge(ns, options).items()] +
             [p.passthrough])
     if append:
         argv.append(expand(append))

celery/canvas.py

@@ -7,8 +7,6 @@
 """
 from __future__ import absolute_import, unicode_literals
 
-import sys
-
 from collections import MutableSequence, deque
 from copy import deepcopy
 from functools import partial as _partial, reduce
@@ -19,7 +17,6 @@ from kombu.utils import cached_property, fxrange, reprcall, uuid
 from vine import barrier
 
 from celery._state import current_app
-from celery.local import try_import
 from celery.result import GroupResult
 from celery.utils import abstract
 from celery.utils.functional import (
@@ -32,11 +29,6 @@ __all__ = [
     'group', 'chord', 'signature', 'maybe_signature',
 ]
 
-PY3 = sys.version_info[0] == 3
-
-# json in Python 2.7 borks if dict contains byte keys.
-JSON_NEEDS_UNICODE_KEYS = PY3 and not try_import('simplejson')
-
 
 class _getitem_property:
     """Attribute -> dict key descriptor.
@@ -455,11 +447,6 @@ class Signature(dict):
     def __repr__(self):
         return self.reprcall()
 
-    if JSON_NEEDS_UNICODE_KEYS:  # pragma: no cover
-        def items(self):
-            for k, v in dict.items(self):
-                yield k.decode() if isinstance(k, bytes) else k, v
-
     @property
     def name(self):
         # for duck typing compatibility with Task.name

celery/concurrency/asynpool.py

@@ -21,7 +21,6 @@ import os
 import select
 import socket
 import struct
-import sys
 import time
 
 from collections import Counter, deque, namedtuple
@@ -50,14 +49,7 @@ try:
     from struct import unpack_from as _unpack_from
     memoryview = memoryview
     readcanbuf = True
-
-    if sys.version_info[0] == 2 and sys.version_info < (2, 7, 6):
-
-        def unpack_from(fmt, view, _unpack_from=_unpack_from):  # noqa
-            return _unpack_from(fmt, view.tobytes())  # <- memoryview
-    else:
-        # unpack_from supports memoryview in 2.7.6 and 3.3+
-        unpack_from = _unpack_from  # noqa
+    unpack_from = _unpack_from  # noqa
 
 except (ImportError, NameError):  # pragma: no cover
 

celery/five.py

@@ -15,7 +15,6 @@ from vine.five import __all__ as _all_five
 
 # bloody flake8
 items = five.items
-bytes_if_py2 = five.bytes_if_py2
 string_t = five.string_t
 
 try:
@@ -43,15 +42,6 @@ The module %s is deprecated and will be removed in a future version.
 
 DEFAULT_ATTRS = {'__file__', '__path__', '__doc__', '__all__'}
 
-# im_func is no longer available in Py3.
-# instead the unbound method itself can be used.
-if sys.version_info[0] == 3:  # pragma: no cover
-    def fun_of_method(method):
-        return method
-else:
-    def fun_of_method(method):  # noqa
-        return method.im_func
-
 
 def getappattr(path):
     """Gets attribute from the current_app recursively,
@@ -134,7 +124,7 @@ class class_property:
 
 
 def reclassmethod(method):
-    return classmethod(fun_of_method(method))
+    return classmethod(method)
 
 
 class LazyModule(ModuleType):
@@ -173,8 +163,7 @@ def create_module(name, attrs, cls_attrs=None, pkg=None,
         attr_name: (prepare_attr(attr) if prepare_attr else attr)
         for attr_name, attr in items(attrs)
     }
-    module = sys.modules[fqdn] = type(
-        bytes_if_py2(modname), (base,), cls_attrs)(bytes_if_py2(name))
+    module = sys.modules[fqdn] = type(modname, (base,), cls_attrs)(name)
     module.__dict__.update(attrs)
     return module
 
@@ -189,8 +178,6 @@ def recreate_module(name, compat_modules=(), by_module={}, direct={},
         operator.add,
         [tuple(v) for v in [compat_modules, origins, direct, attrs]],
     )))
-    if sys.version_info[0] < 3:
-        _all = [s.encode() for s in _all]
     cattrs = dict(
         _compat_modules=compat_modules,
         _all_by_module=by_module, _direct=direct,

celery/fixups/django.py

@@ -9,17 +9,12 @@ from kombu.utils import cached_property, symbol_by_name
 
 from datetime import datetime
 from importlib import import_module
+from io import StringIO
 
 from celery import signals
 from celery.app import default_app
 from celery.exceptions import FixupWarning
 
-if sys.version_info[0] < 3 and not hasattr(sys, 'pypy_version_info'):
-    from StringIO import StringIO
-else:  # pragma: no cover
-    from io import StringIO
-
-
 __all__ = ['DjangoFixup', 'fixup']
 
 ERR_NOT_INSTALLED = """\

celery/loaders/base.py

@@ -158,8 +158,9 @@ class BaseLoader:
             self.find_module(name)
         except NotAPackage:
             if name.endswith('.py'):
-                 raise NotAPackage(CONFIG_WITH_SUFFIX.format(
-                    module=name, suggest=name[:-3])).with_traceback(sys.exc_info()[2])
+                raise NotAPackage(CONFIG_WITH_SUFFIX.format(
+                    module=name, suggest=name[:-3])
+                ).with_traceback(sys.exc_info()[2])
             raise NotAPackage(CONFIG_INVALID_NAME.format(
                 module=name)).with_traceback(sys.exc_info()[2])
         else:

celery/local.py

@@ -9,14 +9,11 @@ Parts of this module is Copyright by Werkzeug Team.
 from __future__ import absolute_import, unicode_literals
 
 import importlib
-import sys
 
 __all__ = ['Proxy', 'PromiseProxy', 'try_import', 'maybe_evaluate']
 
 __module__ = __name__  # used by Proxy class body
 
-PY3 = sys.version_info[0] == 3
-
 
 def _default_cls_attr(name, type_, cls_value):
     # Proxy uses properties to forward the standard
@@ -124,7 +121,6 @@ class Proxy:
             return bool(self._get_current_object())
         except RuntimeError:  # pragma: no cover
             return False
-    __nonzero__ = __bool__  # Py2
 
     def __dir__(self):
         try:
@@ -281,19 +277,6 @@ class Proxy:
     def __reduce__(self):
         return self._get_current_object().__reduce__()
 
-    if not PY3:  # pragma: no cover
-        def __cmp__(self, other):
-            return cmp(self._get_current_object(), other)  # noqa
-
-        def __long__(self):
-            return long(self._get_current_object())  # noqa
-
-        def __unicode__(self):
-            try:
-                return str(self._get_current_object())
-            except RuntimeError:  # pragma: no cover
-                return repr(self)
-
 
 class PromiseProxy(Proxy):
     """This is a proxy to an object that has not yet been evaulated.

celery/result.py

@@ -827,7 +827,6 @@ class GroupResult(ResultSet):
 
     def __bool__(self):
         return bool(self.id or self.results)
-    __nonzero__ = __bool__  # Included for Py2 backwards compatibility
 
     def __eq__(self, other):
         if isinstance(other, GroupResult):

celery/security/serialization.py

@@ -2,8 +2,6 @@
 """Secure serializer."""
 from __future__ import absolute_import, unicode_literals
 
-import sys
-
 from kombu.serialization import registry, dumps, loads
 from kombu.utils.encoding import bytes_to_str, str_to_bytes, ensure_bytes
 
@@ -15,8 +13,6 @@ from .utils import reraise_errors
 
 __all__ = ['SecureSerializer', 'register_auth']
 
-PY3 = sys.version_info[0] == 3
-
 
 class SecureSerializer:
 
@@ -25,7 +21,7 @@ class SecureSerializer:
         self._key = key
         self._cert = cert
         self._cert_store = cert_store
-        self._digest = str_to_bytes(digest) if not PY3 else digest
+        self._digest = digest
         self._serializer = serializer
 
     def serialize(self, data):

celery/tests/__init__.py

@@ -7,7 +7,7 @@ import warnings
 
 from importlib import import_module
 
-PYPY3 = getattr(sys, 'pypy_version_info', None) and sys.version_info[0] > 3
+PYPY3 = getattr(sys, 'pypy_version_info', None)
 
 try:
     WindowsError = WindowsError  # noqa

celery/tests/app/test_defaults.py

@@ -45,8 +45,10 @@ class test_defaults(AppCase):
         self.assertFalse(any(key.islower() for key in _TO_NEW_KEY))
         self.assertFalse(any(key.isupper() for key in SETTING_KEYS))
         self.assertFalse(any(key.islower() for key in _OLD_SETTING_KEYS))
-        self.assertFalse(any(value.isupper() for value in _TO_NEW_KEY.values()))
-        self.assertFalse(any(value.islower() for value in _TO_OLD_KEY.values()))
+        self.assertFalse(any(
+            value.isupper() for value in _TO_NEW_KEY.values()))
+        self.assertFalse(
+            any(value.islower() for value in _TO_OLD_KEY.values()))
 
         for key in _TO_NEW_KEY:
             self.assertIn(key, _OLD_SETTING_KEYS)

celery/tests/app/test_log.py

@@ -22,7 +22,7 @@ from celery.utils.log import (
 )
 
 from case.utils import get_logger_handlers
-from celery.tests.case import AppCase, Mock, mock, patch, skip
+from celery.tests.case import AppCase, Mock, mock, patch
 
 
 class test_TaskFormatter(AppCase):
@@ -111,8 +111,6 @@ class test_ColorFormatter(AppCase):
             raise Exception()
         except Exception:
             self.assertTrue(x.formatException(sys.exc_info()))
-        if sys.version_info[0] == 2:
-            safe_str.assert_called()
 
     @patch('logging.Formatter.format')
     def test_format_object(self, _format):
@@ -154,17 +152,6 @@ class test_ColorFormatter(AppCase):
         self.assertIn('<Unrepresentable', msg)
         self.assertEqual(safe_str.call_count, 1)
 
-    @skip.if_python3()
-    @patch('celery.utils.log.safe_str')
-    def test_format_raises_no_color(self, safe_str):
-        x = ColorFormatter(use_color=False)
-        record = Mock()
-        record.levelname = 'ERROR'
-        record.msg = 'HELLO'
-        record.exc_text = 'error text'
-        x.format(record)
-        self.assertEqual(safe_str.call_count, 1)
-
 
 class test_default_logger(AppCase):
 
@@ -252,9 +239,7 @@ class test_default_logger(AppCase):
     @patch('os.fstat')
     def test_setup_logger_no_handlers_file(self, *args):
         tempfile = mktemp(suffix='unittest', prefix='celery')
-        _open = ('builtins.open' if sys.version_info[0] == 3
-                 else '__builtin__.open')
-        with patch(_open) as osopen:
+        with patch('builtins.open') as osopen:
             with mock.restore_logging():
                 files = defaultdict(StringIO)
 

celery/tests/backends/test_base.py

@@ -1,8 +1,5 @@
 from __future__ import absolute_import, unicode_literals
 
-import sys
-import types
-
 from contextlib import contextmanager
 
 from celery.exceptions import ChordError, TimeoutError
@@ -23,7 +20,7 @@ from celery.backends.base import (
 from celery.result import result_from_tuple
 from celery.utils.functional import pass1
 
-from celery.tests.case import ANY, AppCase, Case, Mock, call, patch, skip
+from celery.tests.case import ANY, AppCase, Case, Mock, call, patch
 
 
 class wrapobject:
@@ -111,10 +108,7 @@ class test_prepare_exception(AppCase):
         self.assertTrue(str(x))
         y = self.b.exception_to_python(x)
         self.assertEqual(y.__class__.__name__, 'Impossible')
-        if sys.version_info < (2, 5):
-            self.assertTrue(y.__class__.__module__)
-        else:
-            self.assertEqual(y.__class__.__module__, 'foo.module')
+        self.assertEqual(y.__class__.__module__, 'foo.module')
 
     def test_regular(self):
         self.b.serializer = 'pickle'

celery/tests/backends/test_cache.py

@@ -14,8 +14,6 @@ from celery.exceptions import ImproperlyConfigured
 
 from celery.tests.case import AppCase, Mock, mock, patch, skip
 
-PY3 = sys.version_info[0] == 3
-
 
 class SomeClass:
 
@@ -149,10 +147,7 @@ class MyMemcachedStringEncodingError(Exception):
 class MemcachedClient(DummyClient):
 
     def set(self, key, value, *args, **kwargs):
-        if PY3:
-            key_t, must_be, not_be, cod = bytes, 'string', 'bytes', 'decode'
-        else:
-            key_t, must_be, not_be, cod = str, 'bytes', 'string', 'encode'
+        key_t, must_be, not_be, cod = bytes, 'string', 'bytes', 'decode'
         if isinstance(key, key_t):
             raise MyMemcachedStringEncodingError(
                 'Keys must be {0}, not {1}.  Convert your '

celery/tests/events/test_state.py

@@ -20,15 +20,6 @@ from celery.events.state import (
 )
 from celery.tests.case import AppCase, Mock, patch, skip
 
-try:
-    Decimal(2.6)
-except TypeError:  # pragma: no cover
-    # Py2.6: Must first convert float to str
-    _float_to_decimal = str
-else:
-    def _float_to_decimal(f):  # noqa
-        return f
-
 
 class replay:
 
@@ -196,12 +187,12 @@ class test_Worker(AppCase):
 
     def test_compatible_with_Decimal(self):
         w = Worker('george@vandelay.com')
-        timestamp, local_received = Decimal(_float_to_decimal(time())), time()
+        timestamp, local_received = Decimal(time()), time()
         w.event('worker-online', timestamp, local_received, fields={
             'hostname': 'george@vandelay.com',
             'timestamp': timestamp,
             'local_received': local_received,
-            'freq': Decimal(_float_to_decimal(5.6335431)),
+            'freq': Decimal(5.6335431),
         })
         self.assertTrue(w.alive)
 

celery/tests/utils/test_local.py

@@ -1,16 +1,12 @@
 from __future__ import absolute_import, unicode_literals
 
-import sys
-
 from celery.local import (
     Proxy,
     PromiseProxy,
     maybe_evaluate,
     try_import,
 )
-from celery.tests.case import Case, Mock, skip
-
-PY3 = sys.version_info[0] == 3
+from celery.tests.case import Case, Mock
 
 
 class test_try_import(Case):
@@ -80,24 +76,6 @@ class test_Proxy(Case):
         with self.assertRaises(AttributeError):
             x.__dict__
 
-    @skip.if_python3()
-    def test_unicode(self):
-
-        class X:
-
-            def __unicode__(self):
-                return 'UNICODE'
-            __str__ = __unicode__
-
-            def __repr__(self):
-                return 'REPR'
-
-        x = Proxy(lambda: X())
-        self.assertEqual(str(x), 'UNICODE')
-        del(X.__unicode__)
-        del(X.__str__)
-        self.assertEqual(str(x), 'REPR')
-
     def test_dir(self):
 
         class X:
@@ -168,8 +146,6 @@ class test_Proxy(Case):
         x[0:2] = [1, 2]
         del(x[0:2])
         self.assertTrue(str(x))
-        if sys.version_info[0] < 3:
-            self.assertEqual(x.__cmp__(object()), -1)
 
     def test_complex_cast(self):
 

celery/tests/worker/test_consumer.py

@@ -8,16 +8,14 @@ from collections import deque
 from billiard.exceptions import RestartFreqExceeded
 
 from celery.worker.consumer.agent import Agent
-from celery.worker.consumer.consumer import CLOSE, Consumer, dump_body
+from celery.worker.consumer.consumer import CLOSE, Consumer
 from celery.worker.consumer.gossip import Gossip
 from celery.worker.consumer.heart import Heart
 from celery.worker.consumer.mingle import Mingle
 from celery.worker.consumer.tasks import Tasks
 from celery.utils.collections import LimitedSet
 
-from celery.tests.case import (
-    AppCase, ContextMock, Mock, call, patch, skip,
-)
+from celery.tests.case import AppCase, ContextMock, Mock, call, patch
 
 
 class test_Consumer(AppCase):
@@ -47,12 +45,6 @@ class test_Consumer(AppCase):
         c = self.get_consumer()
         self.assertIsNone(c.task_buckets['fooxasdwx.wewe'])
 
-    @skip.if_python3(reason='buffer type not available')
-    def test_dump_body_buffer(self):
-        msg = Mock()
-        msg.body = 'str'
-        self.assertTrue(dump_body(msg, buffer(msg.body)))
-
     def test_sets_heartbeat(self):
         c = self.get_consumer(amqheartbeat=10)
         self.assertEqual(c.amqheartbeat, 10)

celery/tests/worker/test_request.py

@@ -5,14 +5,13 @@ import numbers
 import os
 import signal
 import socket
-import sys
 
 from datetime import datetime, timedelta
 from time import monotonic
 
 from billiard.einfo import ExceptionInfo
 from kombu.utils import uuid
-from kombu.utils.encoding import default_encode, from_utf8, safe_str, safe_repr
+from kombu.utils.encoding import from_utf8, safe_str, safe_repr
 
 from celery import states
 from celery.app.trace import (
@@ -48,7 +47,6 @@ from celery.tests.case import (
     TaskMessage,
     task_message_from_sig,
     patch,
-    skip,
 )
 
 
@@ -123,29 +121,6 @@ def jail(app, task_id, name, args, kwargs):
     ).retval
 
 
-@skip.if_python3()
-class test_default_encode(AppCase):
-
-    def test_jython(self):
-        prev, sys.platform = sys.platform, 'java 1.6.1'
-        try:
-            self.assertEqual(default_encode(bytes('foo')), 'foo')
-        finally:
-            sys.platform = prev
-
-    def test_cpython(self):
-        prev, sys.platform = sys.platform, 'darwin'
-        gfe, sys.getfilesystemencoding = (
-            sys.getfilesystemencoding,
-            lambda: 'utf-8',
-        )
-        try:
-            self.assertEqual(default_encode(bytes('foo')), 'foo')
-        finally:
-            sys.platform = prev
-            sys.getfilesystemencoding = gfe
-
-
 class test_Retry(AppCase):
 
     def test_retry_semipredicate(self):

celery/utils/__init__.py

@@ -6,8 +6,6 @@ here for backwards compatibility.
 """
 from __future__ import absolute_import, print_function, unicode_literals
 
-import sys
-
 from .functional import memoize  # noqa
 
 from .nodenames import worker_direct, nodename, nodesplit
@@ -15,9 +13,6 @@ from .nodenames import worker_direct, nodename, nodesplit
 __all__ = ['worker_direct', 'gen_task_name', 'nodename', 'nodesplit',
            'cached_property', 'uuid']
 
-PY3 = sys.version_info[0] == 3
-
-
 # ------------------------------------------------------------------------ #
 # > XXX Compat
 from .log import LOG_LEVELS     # noqa

celery/utils/abstract.py

@@ -12,7 +12,7 @@ def _hasattr(C, attr):
     return any(attr in B.__dict__ for B in C.__mro__)
 
 
-class _AbstractClass(metaclass=ABCMeta)
+class _AbstractClass(metaclass=ABCMeta):
     __required_attributes__ = frozenset()
 
     @classmethod

celery/utils/collections.py

@@ -2,7 +2,6 @@
 """Custom maps, sets, sequences and other data structures."""
 from __future__ import absolute_import, unicode_literals
 
-import sys
 import time
 
 from collections import (
@@ -36,8 +35,6 @@ __all__ = [
     'force_mapping', 'lpmerge',
 ]
 
-PY3 = sys.version_info[0] >= 3
-
 REPR_LIMITED_SET = """\
 <{name}({size}): maxlen={0.maxlen}, expires={0.expires}, minlen={0.minlen}>\
 """
@@ -61,50 +58,10 @@ def lpmerge(L, R):
 
 class OrderedDict(_OrderedDict):
 
-    if PY3:  # pragma: no cover
-        def _LRUkey(self):
-            # return value of od.keys does not support __next__,
-            # but this version will also not create a copy of the list.
-            return next(iter(self.keys()))
-    else:
-        if _dict_is_ordered:  # pragma: no cover
-            def _LRUkey(self):
-                # iterkeys is iterable.
-                return next(self.iterkeys())
-        else:
-            def _LRUkey(self):
-                return self._OrderedDict__root[1][2]
-
-    if not hasattr(_OrderedDict, 'move_to_end'):
-        if _dict_is_ordered:  # pragma: no cover
-
-            def move_to_end(self, key, last=True):
-                if not last:
-                    # we don't use this argument, and the only way to
-                    # implement this on PyPy seems to be O(n): creating a
-                    # copy with the order changed, so we just raise.
-                    raise NotImplementedError('no last=True on PyPy')
-                self[key] = self.pop(key)
-
-        else:
-
-            def move_to_end(self, key, last=True):
-                link = self._OrderedDict__map[key]
-                link_prev = link[0]
-                link_next = link[1]
-                link_prev[1] = link_next
-                link_next[0] = link_prev
-                root = self._OrderedDict__root
-                if last:
-                    last = root[0]
-                    link[0] = last
-                    link[1] = root
-                    last[1] = root[0] = link
-                else:
-                    first = root[1]
-                    link[0] = root
-                    link[1] = first
-                    root[1] = first[0] = link
+    def _LRUkey(self):
+        # return value of od.keys does not support __next__,
+        # but this version will also not create a copy of the list.
+        return next(iter(self.keys()))
 
 
 class AttributeDictMixin:
@@ -260,7 +217,6 @@ class ChainMap(MutableMapping):
 
     def __bool__(self):
         return any(self.maps)
-    __nonzero__ = __bool__  # Py2
 
     def setdefault(self, key, default):
         key = self._key(key)
@@ -283,7 +239,6 @@ class ChainMap(MutableMapping):
         """New ChainMap or subclass with a new copy of maps[0] and
         refs to maps[1:]."""
         return self.__class__(self.maps[0].copy(), *self.maps[1:])
-    __copy__ = copy  # Py2
 
     def _iter(self, op):
         # defaults must be first in the stream, so values in
@@ -585,7 +540,6 @@ class LimitedSet:
 
     def __bool__(self):
         return bool(self._data)
-    __nonzero__ = __bool__  # Py2
 
     @property
     def _heap_overload(self):

celery/utils/dispatch/saferef.py

@@ -6,14 +6,11 @@ aren't handled by the core weakref module).
 """
 from __future__ import absolute_import, unicode_literals
 
-import sys
 import traceback
 import weakref
 
 __all__ = ['safe_ref']
 
-PY3 = sys.version_info[0] == 3
-
 
 def safe_ref(target, on_delete=None):  # pragma: no cover
     """Return a *safe* weak reference to a callable target
@@ -175,13 +172,6 @@ class BoundMethodWeakref:  # pragma: no cover
         return self() is not None
     __nonzero__ = __bool__  # py2
 
-    if not PY3:
-        def __cmp__(self, other):
-            """Compare with another reference"""
-            if not isinstance(other, self.__class__):
-                return cmp(self.__class__, type(other))  # noqa
-            return cmp(self.key, other.key)              # noqa
-
     def __call__(self):
         """Return a strong reference to the bound method
 

celery/utils/functional.py

@@ -21,8 +21,6 @@ __all__ = [
     'regen', 'dictfilter', 'lazy', 'maybe_evaluate', 'head_from_fun',
 ]
 
-IS_PY3 = sys.version_info[0] == 3
-
 FUNHEAD_TEMPLATE = """
 def {fun_name}({fun_args}):
     return {fun_value}

celery/utils/imports.py

@@ -29,19 +29,13 @@ class NotAPackage(Exception):
     pass
 
 
-if sys.version_info > (3, 3):  # pragma: no cover
-    def qualname(obj):
-        if not hasattr(obj, '__name__') and hasattr(obj, '__class__'):
-            obj = obj.__class__
-        q = getattr(obj, '__qualname__', None)
-        if '.' not in q:
-            q = '.'.join((obj.__module__, q))
-        return q
-else:
-    def qualname(obj):  # noqa
-        if not hasattr(obj, '__name__') and hasattr(obj, '__class__'):
-            obj = obj.__class__
-        return '.'.join((obj.__module__, obj.__name__))
+def qualname(obj):
+    if not hasattr(obj, '__name__') and hasattr(obj, '__class__'):
+        obj = obj.__class__
+    q = getattr(obj, '__qualname__', None)
+    if '.' not in q:
+        q = '.'.join((obj.__module__, q))
+    return q
 
 
 def instantiate(name, *args, **kwargs):

celery/utils/log.py

@@ -24,7 +24,6 @@ __all__ = [
 
 _process_aware = False
 _in_sighandler = False
-PY3 = sys.version_info[0] == 3
 
 MP_LOG = os.environ.get('MP_LOG', False)
 
@@ -126,10 +125,7 @@ class ColorFormatter(logging.Formatter):
     def formatException(self, ei):
         if ei and not isinstance(ei, tuple):
             ei = sys.exc_info()
-        r = logging.Formatter.formatException(self, ei)
-        if isinstance(r, str) and not PY3:
-            return safe_str(r)
-        return r
+        return logging.Formatter.formatException(self, ei)
 
     def format(self, record):
         msg = logging.Formatter.format(self, record)

celery/utils/saferepr.py

@@ -13,8 +13,6 @@ Very slow with no limits, super quick with limits.
 """
 from __future__ import absolute_import, unicode_literals
 
-import sys
-
 from collections import Iterable, Mapping, deque, namedtuple
 
 from decimal import Decimal
@@ -28,14 +26,6 @@ from .text import truncate, truncate_bytes
 
 __all__ = ['saferepr', 'reprstream']
 
-IS_PY3 = sys.version_info[0] == 3
-
-if IS_PY3:  # pragma: no cover
-    range_t = (range, )
-else:
-    class range_t:  # noqa
-        pass
-
 _literal = namedtuple('_literal', ('value', 'truncate', 'direction'))
 _key = namedtuple('_key', ('value',))
 _quoted = namedtuple('_quoted', ('value',))
@@ -103,10 +93,8 @@ def _saferepr(o, maxlen=None, maxlevels=3, seen=None):
             val = saferepr(token.value, maxlen, maxlevels)
         elif isinstance(token, _quoted):
             val = token.value
-            if IS_PY3 and isinstance(val, bytes):  # pragma: no cover
+            if isinstance(val, bytes):
                 val = "b'%s'" % (bytes_to_str(truncate_bytes(val, maxlen)),)
-            else:
-                val = "'%s'" % (truncate(val, maxlen),)
         else:
             val = truncate(token, maxlen)
         yield val
@@ -156,7 +144,7 @@ def reprstream(stack, seen=None, maxlevels=3, level=0, isinstance=isinstance):
                 yield str(val), it
             elif isinstance(val, chars_t):
                 yield _quoted(val), it
-            elif isinstance(val, range_t):  # pragma: no cover
+            elif isinstance(val, range):  # pragma: no cover
                 yield repr(val), it
             else:
                 if isinstance(val, set_t):

celery/utils/threads.py

@@ -33,7 +33,6 @@ __all__ = [
 ]
 
 USE_FAST_LOCALS = os.environ.get('USE_FAST_LOCALS')
-PY3 = sys.version_info[0] == 3
 
 
 @contextmanager

celery/utils/timeutils.py

@@ -4,7 +4,6 @@ from __future__ import absolute_import, print_function, unicode_literals
 
 import numbers
 import os
-import sys
 import time as _time
 
 from calendar import monthrange
@@ -26,9 +25,6 @@ __all__ = [
     'adjust_timestamp', 'maybe_s_to_ms',
 ]
 
-PY3 = sys.version_info[0] == 3
-PY33 = sys.version_info >= (3, 3)
-
 C_REMDEBUG = os.environ.get('C_REMDEBUG', False)
 
 DAYNAMES = 'sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'
@@ -84,20 +80,18 @@ class LocalTimezone(tzinfo):
     def tzname(self, dt):
         return _time.tzname[self._isdst(dt)]
 
-    if PY3:  # pragma: no cover
-
-        def fromutc(self, dt):
-            # The base tzinfo class no longer implements a DST
-            # offset aware .fromutc() in Python 3 (Issue #2306).
+    def fromutc(self, dt):
+        # The base tzinfo class no longer implements a DST
+        # offset aware .fromutc() in Python 3 (Issue #2306).
 
-            # I'd rather rely on pytz to do this, than port
-            # the C code from cpython's fromutc [asksol]
-            offset = int(self.utcoffset(dt).seconds / 60.0)
-            try:
-                tz = self._offset_cache[offset]
-            except KeyError:
-                tz = self._offset_cache[offset] = FixedOffset(offset)
-            return tz.fromutc(dt.replace(tzinfo=tz))
+        # I'd rather rely on pytz to do this, than port
+        # the C code from cpython's fromutc [asksol]
+        offset = int(self.utcoffset(dt).seconds / 60.0)
+        try:
+            tz = self._offset_cache[offset]
+        except KeyError:
+            tz = self._offset_cache[offset] = FixedOffset(offset)
+        return tz.fromutc(dt.replace(tzinfo=tz))
 
     def _isdst(self, dt):
         tt = (dt.year, dt.month, dt.day,
@@ -120,17 +114,10 @@ class _Zone:
             dt = make_aware(dt, orig or self.utc)
         return localize(dt, self.tz_or_local(local))
 
-    if PY33:  # pragma: no cover
-
-        def to_system(self, dt):
-            # tz=None is a special case since Python 3.3, and will
-            # convert to the current local timezone (Issue #2306).
-            return dt.astimezone(tz=None)
-
-    else:
-
-        def to_system(self, dt):  # noqa
-            return localize(dt, self.local)
+    def to_system(self, dt):
+        # tz=None is a special case since Python 3.3, and will
+        # convert to the current local timezone (Issue #2306).
+        return dt.astimezone(tz=None)
 
     def to_local_fallback(self, dt):
         if is_naive(dt):

docs/_ext/celerydocs.py

@@ -54,16 +54,6 @@ ABBR_EMPTY = {
 DEFAULT_EMPTY = 'celery.Celery'
 
 
-if sys.version_info[0] < 3:
-    def bytes_if_py2(s):
-        if isinstance(s, unicode):
-            return s.encode()
-        return s
-else:
-    def bytes_if_py2(s):  # noqa
-        return s
-
-
 def typeify(S, type):
     if type in ('meth', 'func'):
         return S + '()'
@@ -152,28 +142,25 @@ def maybe_resolve_abbreviations(app, env, node, contnode):
 
 
 def setup(app):
-    app.connect(
-        bytes_if_py2('missing-reference'),
-        maybe_resolve_abbreviations,
-    )
+    app.connect('missing-reference', maybe_resolve_abbreviations)
 
     app.add_crossref_type(
-        directivename=bytes_if_py2('sig'),
-        rolename=bytes_if_py2('sig'),
-        indextemplate=bytes_if_py2('pair: %s; sig'),
+        directivename='sig',
+        rolename='sig',
+        indextemplate='pair: %s; sig',
     )
     app.add_crossref_type(
-        directivename=bytes_if_py2('state'),
-        rolename=bytes_if_py2('state'),
-        indextemplate=bytes_if_py2('pair: %s; state'),
+        directivename='state',
+        rolename='state',
+        indextemplate='pair: %s; state',
     )
     app.add_crossref_type(
-        directivename=bytes_if_py2('control'),
-        rolename=bytes_if_py2('control'),
-        indextemplate=bytes_if_py2('pair: %s; control'),
+        directivename='control',
+        rolename='control',
+        indextemplate='pair: %s; control',
     )
     app.add_crossref_type(
-        directivename=bytes_if_py2('event'),
-        rolename=bytes_if_py2('event'),
-        indextemplate=bytes_if_py2('pair: %s; event'),
+        directivename='event',
+        rolename='event',
+        indextemplate='pair: %s; event',
     )