lint

Author: ev-br

autogen/numpy_api_dump.py

@@ -774,7 +774,6 @@ def product(*args, **kwargs):
     raise NotImplementedError
 
 
-
 def put(a, ind, v, mode="raise"):
     raise NotImplementedError
 

torch_np/__init__.py

@@ -13,6 +13,5 @@
 alltrue = all
 sometrue = any
 
-inf = float('inf')
-nan = float('nan')
-
+inf = float("inf")
+nan = float("nan")

torch_np/_decorators.py

@@ -122,9 +122,11 @@ def axis_none_ravel_wrapper(func):
     similar logic.
 
     """
+
     @functools.wraps(func)
     def wrapped(a, axis=None, *args, **kwds):
-        from ._ndarray import ndarray, asarray
+        from ._ndarray import asarray, ndarray
+
         tensor = asarray(a).get()
 
         # standardize the axis argument

torch_np/_detail/_reductions.py

@@ -172,11 +172,12 @@ def var(tensor, axis=None, dtype=None, ddof=0, *, where=NoValue):
 #   1. no keepdims
 #   2. axis=None ravels (cf concatenate)
 
+
 def cumprod(tensor, axis=None, dtype=None):
     if dtype == torch.bool:
         dtype = _scalar_types.default_int_type.dtype
     if dtype is None:
-        dtype=tensor.dtype
+        dtype = tensor.dtype
 
     result = tensor.cumprod(axis=axis, dtype=dtype)
 
@@ -187,7 +188,7 @@ def cumsum(tensor, axis=None, dtype=None):
     if dtype == torch.bool:
         dtype = _scalar_types.default_int_type.dtype
     if dtype is None:
-        dtype=tensor.dtype
+        dtype = tensor.dtype
 
     result = tensor.cumsum(axis=axis, dtype=dtype)
 
@@ -205,23 +206,25 @@ def average(a_tensor, axis, w_tensor):
 
     # axis
     if axis is None:
-        (a_tensor, w_tensor), axis = _util.axis_none_ravel(a_tensor, w_tensor, axis=axis)
+        (a_tensor, w_tensor), axis = _util.axis_none_ravel(
+            a_tensor, w_tensor, axis=axis
+        )
 
     # axis & weights
     if a_tensor.shape != w_tensor.shape:
         if axis is None:
             raise TypeError(
-                "Axis must be specified when shapes of a and weights "
-                "differ.")
+                "Axis must be specified when shapes of a and weights " "differ."
+            )
         if w_tensor.ndim != 1:
-            raise TypeError(
-                "1D weights expected when shapes of a and weights differ.")
+            raise TypeError("1D weights expected when shapes of a and weights differ.")
         if w_tensor.shape[0] != a_tensor.shape[axis]:
-            raise ValueError(
-                "Length of weights not compatible with specified axis.")
+            raise ValueError("Length of weights not compatible with specified axis.")
 
         # setup weight to broadcast along axis
-        w_tensor = torch.broadcast_to(w_tensor, (a_tensor.ndim-1)*(1,) + w_tensor.shape)
+        w_tensor = torch.broadcast_to(
+            w_tensor, (a_tensor.ndim - 1) * (1,) + w_tensor.shape
+        )
         w_tensor = w_tensor.swapaxes(-1, axis)
 
     # do the work
@@ -232,7 +235,6 @@ def average(a_tensor, axis, w_tensor):
     return result, denominator
 
 
-
 def quantile(a_tensor, q_tensor, axis, method):
 
     if (0 > q_tensor).any() or (q_tensor > 1).any():

torch_np/_ndarray.py

@@ -2,17 +2,15 @@
 
 import torch
 
-from ._detail import _util
-from ._detail import _reductions
-from . import _helpers
-from . import _dtypes
-from . import _unary_ufuncs
-from . import _binary_ufuncs
-
-from ._decorators import (emulate_out_arg, axis_keepdims_wrapper,
-                          dtype_to_torch, axis_none_ravel_wrapper)
-
-from ._decorators import NoValue
+from . import _binary_ufuncs, _dtypes, _helpers, _unary_ufuncs
+from ._decorators import (
+    NoValue,
+    axis_keepdims_wrapper,
+    axis_none_ravel_wrapper,
+    dtype_to_torch,
+    emulate_out_arg,
+)
+from ._detail import _reductions, _util
 
 newaxis = None
 
@@ -290,8 +288,12 @@ def nonzero(self):
     var = emulate_out_arg(axis_keepdims_wrapper(dtype_to_torch(_reductions.var)))
     std = emulate_out_arg(axis_keepdims_wrapper(dtype_to_torch(_reductions.std)))
 
-    cumprod = emulate_out_arg(axis_none_ravel_wrapper(dtype_to_torch(_reductions.cumprod)))
-    cumsum = emulate_out_arg(axis_none_ravel_wrapper(dtype_to_torch(_reductions.cumsum)))
+    cumprod = emulate_out_arg(
+        axis_none_ravel_wrapper(dtype_to_torch(_reductions.cumprod))
+    )
+    cumsum = emulate_out_arg(
+        axis_none_ravel_wrapper(dtype_to_torch(_reductions.cumsum))
+    )
 
     ### indexing ###
     def __getitem__(self, *args, **kwds):

torch_np/_wrapper.py

@@ -645,7 +645,6 @@ def prod(
     )
 
 
-
 def cumprod(a, axis=None, dtype=None, out=None):
     arr = asarray(a)
     return arr.cumprod(axis=axis, dtype=dtype, out=out)
@@ -658,7 +657,9 @@ def cumsum(a, axis=None, dtype=None, out=None):
     arr = asarray(a)
     return arr.cumsum(axis=axis, dtype=dtype, out=out)
 
-#YYY: pattern : ddof
+
+# YYY: pattern : ddof
+
 
 def std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=NoValue, *, where=NoValue):
     arr = asarray(a)
@@ -679,7 +680,7 @@ def average(a, axis=None, weights=None, returned=False, *, keepdims=NoValue):
     if weights is None:
         result = mean(a, axis=axis, keepdims=keepdims)
         if returned:
-            scl = result.dtype.type(a.size/result.size)
+            scl = result.dtype.type(a.size / result.size)
             return result, scl
         return result
 
@@ -713,8 +714,9 @@ def percentile(
     *,
     interpolation=None,
 ):
-    return quantile(a, asarray(q) / 100., axis, out, overwrite_input, method,
-                    keepdims=keepdims)
+    return quantile(
+        a, asarray(q) / 100.0, axis, out, overwrite_input, method, keepdims=keepdims
+    )
 
 
 def quantile(
@@ -736,13 +738,14 @@ def quantile(
 
     # keepdims
     if keepdims:
-        result = _util.apply_keepdims(result, axis, a_tensor.ndim)    
+        result = _util.apply_keepdims(result, axis, a_tensor.ndim)
     return _helpers.result_or_out(result, out, promote_scalar=True)
 
 
 def median(a, axis=None, out=None, overwrite_input=False, keepdims=False):
-    return quantile(a, 0.5, axis=axis, overwrite_input=overwrite_input,
-                    out=out, keepdims=keepdims)
+    return quantile(
+        a, 0.5, axis=axis, overwrite_input=overwrite_input, out=out, keepdims=keepdims
+    )
 
 
 @asarray_replacer()

torch_np/tests/test_reductions.py

@@ -608,6 +608,7 @@ def setup_method(self):
         self.func = np.mean
         self.allowed_axes = [0, 1, 2, -1, -2, (0, 1), (1, 0), (0, 1, 2), (1, -1, 0)]
 
+
 class TestSumGeneric(_GenericReductionsTestMixin, _GenericHasOutTestMixin):
     def setup_method(self):
         self.func = np.sum
@@ -635,8 +636,7 @@ def setup_method(self):
 class TestVarGeneric(_GenericReductionsTestMixin, _GenericHasOutTestMixin):
     def setup_method(self):
         self.func = np.var
-        self.allowed_axes =  [0, 1, 2, -1, -2,
-                              (0, 1), (1, 0), (0, 1, 2), (1, -1, 0)]
+        self.allowed_axes = [0, 1, 2, -1, -2, (0, 1), (1, 0), (0, 1, 2), (1, -1, 0)]
 
 
 class _GenericCumSumProdTestMixin:
@@ -648,36 +648,34 @@ class _GenericCumSumProdTestMixin:
 
     To use: subclass, define self.func and self.allowed_axes.
     """
+
     def test_bad_axis(self):
         # Basic check of functionality
         m = np.array([[0, 1, 7, 0, 0], [3, 0, 0, 2, 19]])
 
-        assert_raises(TypeError, self.func, m, axis='foo')
+        assert_raises(TypeError, self.func, m, axis="foo")
         assert_raises(np.AxisError, self.func, m, axis=3)
-        assert_raises(TypeError, self.func,
-                      m, axis=np.array([[1], [2]]))
+        assert_raises(TypeError, self.func, m, axis=np.array([[1], [2]]))
         assert_raises(TypeError, self.func, m, axis=1.5)
 
         # TODO: add tests with np.int32(3) etc, when implemented
 
     def test_array_axis(self):
         a = np.array([[0, 1, 7, 0, 0], [3, 0, 0, 2, 19]])
-        assert_equal(self.func(a, axis=np.array(-1)),
-                     self.func(a, axis=-1))
+        assert_equal(self.func(a, axis=np.array(-1)), self.func(a, axis=-1))
 
         with assert_raises(TypeError):
             self.func(a, axis=np.array([1, 2]))
 
     def test_axis_empty_generic(self):
         a = np.array([[0, 0, 1], [1, 0, 1]])
-        assert_array_equal(self.func(a, axis=None),
-                           self.func(a.ravel(), axis=0))
+        assert_array_equal(self.func(a, axis=None), self.func(a.ravel(), axis=0))
 
     def test_axis_bad_tuple(self):
         # Basic check of functionality
         m = np.array([[0, 1, 7, 0, 0], [3, 0, 0, 2, 19]])
         with assert_raises(TypeError):
-             self.func(m, axis=(1, 1))
+            self.func(m, axis=(1, 1))
 
 
 class TestCumProdGeneric(_GenericCumSumProdTestMixin):
@@ -688,4 +686,3 @@ def setup_method(self):
 class TestCumSumGeneric(_GenericCumSumProdTestMixin):
     def setup_method(self):
         self.func = np.cumsum
-