Cherry pick Python3.6 support from master branch

Author: jmoldow

HISTORY.rst

@@ -14,6 +14,8 @@ Upcoming
   ((access token), (refresh token or None)), instead of just the access token).
   In particular, this fixes an exception in ``BoxSession`` that always occurred
   when it tried to refresh any ``JWTAuth`` object.
+- Fixed an exception that was being raised from ``ExtendableEnumMeta.__dir__()``.
+- CPython 3.6 support.
 
 1.5.3 (2016-05-26)
 ++++++++++++++++++

boxsdk/object/events.py

@@ -1,14 +1,13 @@
 # coding: utf-8
 
-from __future__ import unicode_literals
-
+from __future__ import unicode_literals, absolute_import
 from requests.exceptions import Timeout
-from six import with_metaclass
 
-from boxsdk.object.base_endpoint import BaseEndpoint
-from boxsdk.util.enum import ExtendableEnumMeta
-from boxsdk.util.lru_cache import LRUCache
-from boxsdk.util.text_enum import TextEnum
+from .base_endpoint import BaseEndpoint
+from ..util.compat import with_metaclass
+from ..util.enum import ExtendableEnumMeta
+from ..util.lru_cache import LRUCache
+from ..util.text_enum import TextEnum
 
 
 # pylint:disable=too-many-ancestors
@@ -55,6 +54,7 @@ class Events(BaseEndpoint):
 
     def get_url(self, *args):
         """Base class override."""
+        # pylint:disable=arguments-differ
         return super(Events, self).get_url('events', *args)
 
     def get_events(self, limit=100, stream_position=0, stream_type=UserEventsStreamType.ALL):

boxsdk/util/compat.py

@@ -1,10 +1,12 @@
 # coding: utf-8
 
-from __future__ import division, unicode_literals
-
+from __future__ import absolute_import, division, unicode_literals
 
 from datetime import timedelta
 
+import six
+
+
 if not hasattr(timedelta, 'total_seconds'):
     def total_seconds(delta):
         """
@@ -15,3 +17,61 @@ def total_seconds(delta):
 else:
     def total_seconds(delta):
         return delta.total_seconds()
+
+
+def with_metaclass(meta, *bases, **with_metaclass_kwargs):
+    """Extends the behavior of six.with_metaclass.
+
+    The normal usage (expanded to include temporaries, to make the illustration
+    easier) is:
+
+    .. code-block:: python
+
+        temporary_class = six.with_metaclass(meta, *bases)
+        temporary_metaclass = type(temporary_class)
+
+        class Subclass(temporary_class):
+            ...
+
+        SubclassMeta = type(Subclass)
+
+    In this example:
+
+    - ``temporary_class`` is a class with ``(object,)`` as its bases.
+    - ``temporary_metaclass`` is a metaclass with ``(meta,)`` as its bases.
+    - ``Subclass`` is a class with ``bases`` as its bases.
+    - ``SubclassMeta`` is ``meta``.
+
+    ``six.with_metaclass()`` is defined in such a way that it can make sure
+    that ``Subclass`` has the correct metaclass and bases, while only using
+    syntax which is common to both Python 2 and Python 3.
+    ``temporary_metaclass()`` returns an instance of ``meta``, rather than an
+    instance of itself / a subclass of ``temporary_class``, which is how
+    ``SubclassMeta`` ends up being ``meta``, and how the temporaries don't
+    appear anywhere in the final subclass.
+
+    There are two problems with the current (as of six==1.10.0) implementation
+    of ``six.with_metaclass()``, which this function solves.
+
+    ``six.with_metaclass()`` does not define ``__prepare__()`` on the temporary
+    metaclass. This means that ``meta.__prepare__()`` gets called directly,
+    with bases set to ``(object,)``. If it needed to actually receive
+    ``bases``, then errors might occur. For example, this was a problem when
+    used with ``enum.EnumMeta`` in Python 3.6. Here we make sure that
+    ``__prepare__()`` is defined on the temporary metaclass, and pass ``bases``
+    to ``meta.__prepare__()``.
+
+    Since ``temporary_class`` doesn't have the correct bases, in theory this
+    could cause other problems, besides the previous one, in certain edge
+    cases. To make sure that doesn't become a problem, we make sure that
+    ``temporary_class`` has ``bases`` as its bases, just like the final class.
+    """
+    temporary_class = six.with_metaclass(meta, *bases, **with_metaclass_kwargs)
+    temporary_metaclass = type(temporary_class)
+
+    class TemporaryMetaSubclass(temporary_metaclass):
+        @classmethod
+        def __prepare__(cls, name, this_bases, **kwds):  # pylint:disable=unused-argument
+            return meta.__prepare__(name, bases, **kwds)
+
+    return type.__new__(TemporaryMetaSubclass, str('temporary_class'), bases, {})

boxsdk/util/enum.py

@@ -1,4 +1,5 @@
 # coding: utf-8
+# pylint:disable=no-value-for-parameter
 
 from __future__ import absolute_import, unicode_literals
 
@@ -20,7 +21,9 @@ class ExtendableEnumMeta(EnumMeta):
 
     This allows you to define hierarchies such as this:
 
-        class EnumBase(six.with_metaclass(ExtendableEnumMeta, Enum)): pass
+        from box.util.compat import with_metaclass
+
+        class EnumBase(with_metaclass(ExtendableEnumMeta, Enum)): pass
 
         class Enum1(EnumBase):
             A = 'A'
@@ -99,7 +102,7 @@ def in_(subclass):
         return any(map(in_, cls.__subclasses__()))
 
     def __dir__(cls):
-        return list(set(super(ExtendableEnumMeta, cls).__dir__()).union(set(map(dir, cls.__subclasses__()))))
+        return list(set(super(ExtendableEnumMeta, cls).__dir__()).union(*map(dir, cls.__subclasses__())))
 
     def __getitem__(cls, name):
         try:
@@ -129,7 +132,7 @@ def __getattr__(cls, name):
                 # and __getitem__ have the same behavior. And __getitem__ has
                 # the advantage of never grabbing anything other than enum
                 # members.
-                return cls[name]
+                return cls[name]  # pylint:disable=unsubscriptable-object
             except KeyError:
                 pass
             # This needs to be `reraise()`, and not just `raise`. Otherwise,

test/functional/mock_box/util/chaos_utils.py

@@ -1,15 +1,35 @@
 # coding: utf-8
 
-from __future__ import unicode_literals
-from bottle import template
+from __future__ import absolute_import, unicode_literals
+
 from functools import wraps
 import json
-import jsonpatch
 from time import sleep
+
+from bottle import template
 import six
+
 from test.functional.mock_box.util.http_utils import abort
 
 
+try:
+    import jsonpatch
+except ValueError:
+    # jsonpatch==1.14 on Python 3.6 cannot be imported.
+    # It fails with the following stacktrace:
+    #
+    #       .tox/py/lib/python3.6/site-packages/jsonpatch.py:114: in <module>
+    #           json.load = get_loadjson()
+    #       .tox/py/lib/python3.6/site-packages/jsonpatch.py:108: in get_loadjson
+    #           argspec = inspect.getargspec(json.load)
+    #       lib/python3.6/inspect.py:1039: in getargspec
+    #           raise ValueError("Function has keyword-only arguments or annotations"
+    #       E   ValueError: Function has keyword-only arguments or annotations, use getfullargspec() API which can support them
+    #
+    # Until jsonpatch fixes this issue, we cannot use jsonpatch on Python >=3.6.
+    jsonpatch = None
+
+
 def allow_chaos(method):
     """Decorator for a method to allow erroneous operation."""
     method.call_number = 0
@@ -63,10 +83,19 @@ def xml(method):
 
 
 def patch(operations):
-    json_patch = jsonpatch.JsonPatch(operations)
+    if jsonpatch:
+        json_patch = jsonpatch.JsonPatch(operations)
+
+        def patcher(doc):
+            return json_patch.apply(doc)
+
+    else:
 
-    def patcher(doc):
-        return json_patch.apply(doc)
+        def patcher(doc):
+            # If jsonpatch could not be imported, then `@chaos_utils.patch()`
+            # will be disabled, and will silently return values unmodified,
+            # without applying the JSON patch operations.
+            return doc
 
     def inner(patched_function):
         def patched_inner(*args, **kwargs):

test/unit/util/test_compat.py

@@ -3,7 +3,7 @@
 from __future__ import unicode_literals
 from datetime import datetime, timedelta
 import pytest
-from boxsdk.util.compat import total_seconds
+from boxsdk.util.compat import total_seconds, with_metaclass
 
 
 @pytest.fixture(params=(
@@ -19,3 +19,34 @@ def test_total_seconds(total_seconds_data):
     # pylint:disable=redefined-outer-name
     delta, seconds = total_seconds_data
     assert total_seconds(delta) == seconds
+
+
+def test_with_metaclass():
+
+    class Class1(object):
+        pass
+
+    class Class2(object):
+        pass
+
+    bases = (Class1, Class2)
+
+    class Meta(type):
+        @classmethod
+        def __prepare__(metacls, name, this_bases, **kwds):   # pylint:disable=unused-argument
+            assert this_bases == bases
+            return {}
+
+        def __new__(metacls, name, this_bases, namespace, **kwds):
+            assert this_bases == bases
+            return super(Meta, metacls).__new__(metacls, name, this_bases, namespace, **kwds)
+
+    temporary_class = with_metaclass(Meta, *bases)
+    assert isinstance(temporary_class, Meta)
+    assert temporary_class.__bases__ == bases
+
+    class Subclass(temporary_class):
+        pass
+
+    assert type(Subclass) is Meta   # pylint:disable=unidiomatic-typecheck
+    assert Subclass.__bases__ == bases

test/unit/util/test_enum.py

@@ -4,8 +4,8 @@
 
 from enum import Enum
 import pytest
-from six import with_metaclass
 
+from boxsdk.util.compat import with_metaclass
 from boxsdk.util.enum import ExtendableEnumMeta
 from boxsdk.util.ordered_dict import OrderedDict
 
@@ -169,3 +169,7 @@ def test_len(EnumBaseWithSubclassesDefined, enum_members):
 def test_reversed(EnumBaseWithSubclassesDefined):
     EnumBase = EnumBaseWithSubclassesDefined
     assert list(reversed(list(reversed(EnumBase)))) == list(EnumBase)
+
+
+def test_dir(EnumBaseWithSubclassesDefined):
+    assert set(enum_member_names).issubset(dir(EnumBaseWithSubclassesDefined))