Merge pull request #1681 from leftaroundabout/cleanup/remove-python2

Python 3 has been ubiquitous for a long while now, and most of the newer developments around ODL cannot possibly be backported to Python 2. Yet, the ODL codebase still had some small special-case handling for Python 2 (which never trigger anymore) and mentioned distinctions between versions 2 and 3 in the documentation. Both provides at this point only useless clutter, so we should get rid of it.

Author: leftaroundabout

.travis.yml

@@ -95,30 +95,8 @@ def _function_signature(func):
     sig : string
         Signature of the function.
     """
-    if sys.version_info.major > 2:
-        # Python 3 already implements this functionality
-        return func.__name__ + str(inspect.signature(func))
-
-    # In Python 2 we have to do it manually, unfortunately
-    spec = inspect.getargspec(func)
-    posargs = spec.args
-    defaults = spec.defaults if spec.defaults is not None else []
-    varargs = spec.varargs
-    kwargs = spec.keywords
-    deflen = 0 if defaults is None else len(defaults)
-    nodeflen = 0 if posargs is None else len(posargs) - deflen
-
-    args = ['{}'.format(arg) for arg in posargs[:nodeflen]]
-    args.extend('{}={}'.format(arg, dval)
-                for arg, dval in zip(posargs[nodeflen:], defaults))
-    if varargs:
-        args.append('*{}'.format(varargs))
-    if kwargs:
-        args.append('**{}'.format(kwargs))
-
-    argstr = ', '.join(args)
-
-    return '{}({})'.format(func.__name__, argstr)
+    assert (sys.version_info.major > 2)
+    return func.__name__ + str(inspect.signature(func))
 
 
 def _dispatch_call_args(cls=None, bound_call=None, unbound_call=None,
@@ -128,12 +106,9 @@ def _dispatch_call_args(cls=None, bound_call=None, unbound_call=None,
     The ``_call()`` method of `Operator` is allowed to have the
     following signatures:
 
-    Python 2 and 3:
         - ``_call(self, x)``
         - ``_call(self, vec, out)``
         - ``_call(self, x, out=None)``
-
-    Python 3 only:
         - ``_call(self, x, *, out=None)`` (``out`` as keyword-only
           argument)
 
@@ -144,7 +119,7 @@ def _dispatch_call_args(cls=None, bound_call=None, unbound_call=None,
     argument may have any name.
 
     Additional variable ``**kwargs`` and keyword-only arguments
-    (Python 3 only) are also allowed.
+    are also allowed.
 
     Not allowed:
         - ``_call(self)`` -- No arguments except instance:
@@ -491,12 +466,9 @@ def _call(self, x, out=None, **kwargs):
 
         The following signatures are allowed:
 
-        Python 2 and 3:
             - ``_call(self, x)``  -->  out-of-place evaluation
             - ``_call(self, vec, out)``  -->  in-place evaluation
             - ``_call(self, x, out=None)``   --> both
-
-        Python 3 only:
             - ``_call(self, x, *, out=None)`` (``out`` as keyword-only
               argument)  --> both
 
@@ -507,7 +479,7 @@ def _call(self, x, out=None, **kwargs):
         argument may have any name.
 
         Additional variable ``**kwargs`` and keyword-only arguments
-        (Python 3 only) are also allowed.
+        are also allowed.
 
         Notes
         -----

odl/operator/operator.py

@@ -122,12 +122,6 @@ def __ne__(self, other):
         """Return ``self != other``."""
         return not self.__eq__(other)
 
-    def __cmp__(self, other):
-        """Comparsion not implemented."""
-        # Stops python 2 from allowing comparsion of arbitrary objects
-        raise TypeError('unorderable types: {}, {}'
-                        ''.format(self.__class__.__name__, type(other)))
-
     def element(self, inp=None):
         """Return an element from ``inp`` or from scratch.
 

odl/set/sets.py

@@ -918,12 +918,6 @@ def __pos__(self):
         """Return ``+self``."""
         return self.copy()
 
-    def __cmp__(self, other):
-        """Comparsion not implemented."""
-        # Stops python 2 from allowing comparsion of arbitrary objects
-        raise TypeError('unorderable types: {}, {}'
-                        ''.format(self.__class__.__name__, type(other)))
-
     # Metric space method
     def __eq__(self, other):
         """Return ``self == other``.

odl/set/space.py

@@ -1426,13 +1426,6 @@ def __int__(self):
         """Return ``int(self)``."""
         return int(self.data)
 
-    def __long__(self):
-        """Return ``long(self)``.
-
-        This method is only useful in Python 2.
-        """
-        return long(self.data)
-
     def __float__(self):
         """Return ``float(self)``."""
         return float(self.data)

odl/space/npy_tensors.py

@@ -164,12 +164,10 @@ def simple_func(x):
     assert simple_func(val_1) == 0
     assert simple_func(val_2) == 1
 
-    # Python 2 really swallows this stuff in comparisons...
     bogus_input = [lambda x: x, object, Exception]
-    if sys.version_info.major > 2:
-        for b in bogus_input:
-            with pytest.raises(TypeError):
-                simple_func(b)
+    for b in bogus_input:
+        with pytest.raises(TypeError):
+            simple_func(b)
 
     # In-place
     out = np.empty(5, dtype='int')

odl/test/util/vectorization_test.py

@@ -15,6 +15,7 @@
 from collections import OrderedDict
 from contextlib import contextmanager
 from itertools import product
+from functools import lru_cache
 
 import numpy as np
 
@@ -26,7 +27,6 @@
     'array_str',
     'dtype_repr',
     'dtype_str',
-    'cache_arguments',
     'is_numeric_dtype',
     'is_int_dtype',
     'is_floating_dtype',
@@ -320,58 +320,41 @@ def dtype_str(dtype):
         return '{}'.format(dtype)
 
 
-def cache_arguments(function):
-    """Decorate function to cache the result with given arguments.
 
-    This is equivalent to `functools.lru_cache` with Python 3, and currently
-    does nothing with Python 2 but this may change at some later point.
-
-    Parameters
-    ----------
-    function : `callable`
-        Function that should be wrapped.
-    """
-    try:
-        from functools import lru_cache
-        return lru_cache()(function)
-    except ImportError:
-        return function
-
-
-@cache_arguments
+@lru_cache
 def is_numeric_dtype(dtype):
     """Return ``True`` if ``dtype`` is a numeric type."""
     dtype = np.dtype(dtype)
     return np.issubdtype(getattr(dtype, 'base', None), np.number)
 
 
-@cache_arguments
+@lru_cache
 def is_int_dtype(dtype):
     """Return ``True`` if ``dtype`` is an integer type."""
     dtype = np.dtype(dtype)
     return np.issubdtype(getattr(dtype, 'base', None), np.integer)
 
 
-@cache_arguments
+@lru_cache
 def is_floating_dtype(dtype):
     """Return ``True`` if ``dtype`` is a floating point type."""
     return is_real_floating_dtype(dtype) or is_complex_floating_dtype(dtype)
 
 
-@cache_arguments
+@lru_cache
 def is_real_dtype(dtype):
     """Return ``True`` if ``dtype`` is a real (including integer) type."""
     return is_numeric_dtype(dtype) and not is_complex_floating_dtype(dtype)
 
 
-@cache_arguments
+@lru_cache
 def is_real_floating_dtype(dtype):
     """Return ``True`` if ``dtype`` is a real floating point type."""
     dtype = np.dtype(dtype)
     return np.issubdtype(getattr(dtype, 'base', None), np.floating)
 
 
-@cache_arguments
+@lru_cache
 def is_complex_floating_dtype(dtype):
     """Return ``True`` if ``dtype`` is a complex floating point type."""
     dtype = np.dtype(dtype)