Run (selective) black on the array_api submodule

I've omitted a few changes from black that messed up the readability of some
complicated if statements that were organized logically line-by-line, and some
changes that use unnecessary operator spacing.

3 files changed, 212 insertions, 144 deletions

diff --git a/numpy/array_api/tests/test_array_object.py b/numpy/array_api/tests/test_array_object.py
index 22078bbee..088e09b9f 100644
--- a/numpy/array_api/tests/test_array_object.py
+++ b/numpy/array_api/tests/test_array_object.py
@@ -2,9 +2,20 @@ from numpy.testing import assert_raises
 import numpy as np
 
 from .. import ones, asarray, result_type
-from .._dtypes import (_all_dtypes, _boolean_dtypes, _floating_dtypes,
-                       _integer_dtypes, _integer_or_boolean_dtypes,
-                       _numeric_dtypes, int8, int16, int32, int64, uint64)
+from .._dtypes import (
+    _all_dtypes,
+    _boolean_dtypes,
+    _floating_dtypes,
+    _integer_dtypes,
+    _integer_or_boolean_dtypes,
+    _numeric_dtypes,
+    int8,
+    int16,
+    int32,
+    int64,
+    uint64,
+)
+
 
 def test_validate_index():
     # The indexing tests in the official array API test suite test that the
@@ -61,28 +72,29 @@ def test_validate_index():
     assert_raises(IndexError, lambda: a[None, ...])
     assert_raises(IndexError, lambda: a[..., None])
 
+
 def test_operators():
     # For every operator, we test that it works for the required type
     # combinations and raises TypeError otherwise
-    binary_op_dtypes ={
-        '__add__': 'numeric',
-        '__and__': 'integer_or_boolean',
-        '__eq__': 'all',
-        '__floordiv__': 'numeric',
-        '__ge__': 'numeric',
-        '__gt__': 'numeric',
-        '__le__': 'numeric',
-        '__lshift__': 'integer',
-        '__lt__': 'numeric',
-        '__mod__': 'numeric',
-        '__mul__': 'numeric',
-        '__ne__': 'all',
-        '__or__': 'integer_or_boolean',
-        '__pow__': 'floating',
-        '__rshift__': 'integer',
-        '__sub__': 'numeric',
-        '__truediv__': 'floating',
-        '__xor__': 'integer_or_boolean',
+    binary_op_dtypes = {
+        "__add__": "numeric",
+        "__and__": "integer_or_boolean",
+        "__eq__": "all",
+        "__floordiv__": "numeric",
+        "__ge__": "numeric",
+        "__gt__": "numeric",
+        "__le__": "numeric",
+        "__lshift__": "integer",
+        "__lt__": "numeric",
+        "__mod__": "numeric",
+        "__mul__": "numeric",
+        "__ne__": "all",
+        "__or__": "integer_or_boolean",
+        "__pow__": "floating",
+        "__rshift__": "integer",
+        "__sub__": "numeric",
+        "__truediv__": "floating",
+        "__xor__": "integer_or_boolean",
     }
 
     # Recompute each time because of in-place ops
@@ -92,15 +104,15 @@ def test_operators():
         for d in _boolean_dtypes:
             yield asarray(False, dtype=d)
         for d in _floating_dtypes:
-            yield asarray(1., dtype=d)
+            yield asarray(1.0, dtype=d)
 
     for op, dtypes in binary_op_dtypes.items():
         ops = [op]
-        if op not in ['__eq__', '__ne__', '__le__', '__ge__', '__lt__', '__gt__']:
-            rop = '__r' + op[2:]
-            iop = '__i' + op[2:]
+        if op not in ["__eq__", "__ne__", "__le__", "__ge__", "__lt__", "__gt__"]:
+            rop = "__r" + op[2:]
+            iop = "__i" + op[2:]
             ops += [rop, iop]
-        for s in [1, 1., False]:
+        for s in [1, 1.0, False]:
             for _op in ops:
                 for a in _array_vals():
                     # Test array op scalar. From the spec, the following combinations
@@ -149,7 +161,10 @@ def test_operators():
                                 ):
                                 assert_raises(TypeError, lambda: getattr(x, _op)(y))
                             # Ensure in-place operators only promote to the same dtype as the left operand.
-                            elif _op.startswith('__i') and result_type(x.dtype, y.dtype) != x.dtype:
+                            elif (
+                                _op.startswith("__i")
+                                and result_type(x.dtype, y.dtype) != x.dtype
+                            ):
                                 assert_raises(TypeError, lambda: getattr(x, _op)(y))
                             # Ensure only those dtypes that are required for every operator are allowed.
                             elif (dtypes == "all" and (x.dtype in _boolean_dtypes and y.dtype in _boolean_dtypes
@@ -165,17 +180,20 @@ def test_operators():
                             else:
                                 assert_raises(TypeError, lambda: getattr(x, _op)(y))
 
-    unary_op_dtypes ={
-        '__abs__': 'numeric',
-        '__invert__': 'integer_or_boolean',
-        '__neg__': 'numeric',
-        '__pos__': 'numeric',
+    unary_op_dtypes = {
+        "__abs__": "numeric",
+        "__invert__": "integer_or_boolean",
+        "__neg__": "numeric",
+        "__pos__": "numeric",
     }
     for op, dtypes in unary_op_dtypes.items():
         for a in _array_vals():
-            if (dtypes == "numeric" and a.dtype in _numeric_dtypes
-                or dtypes == "integer_or_boolean" and a.dtype in _integer_or_boolean_dtypes
-                ):
+            if (
+                dtypes == "numeric"
+                and a.dtype in _numeric_dtypes
+                or dtypes == "integer_or_boolean"
+                and a.dtype in _integer_or_boolean_dtypes
+            ):
                 # Only test for no error
                 getattr(a, op)()
             else:
@@ -192,8 +210,8 @@ def test_operators():
             yield ones((4, 4), dtype=d)
 
     # Scalars always error
-    for _op in ['__matmul__', '__rmatmul__', '__imatmul__']:
-        for s in [1, 1., False]:
+    for _op in ["__matmul__", "__rmatmul__", "__imatmul__"]:
+        for s in [1, 1.0, False]:
             for a in _matmul_array_vals():
                 if (type(s) in [float, int] and a.dtype in _floating_dtypes
                     or type(s) == int and a.dtype in _integer_dtypes):
@@ -235,16 +253,17 @@ def test_operators():
                 else:
                     x.__imatmul__(y)
 
+
 def test_python_scalar_construtors():
     a = asarray(False)
     b = asarray(0)
-    c = asarray(0.)
+    c = asarray(0.0)
 
     assert bool(a) == bool(b) == bool(c) == False
     assert int(a) == int(b) == int(c) == 0
-    assert float(a) == float(b) == float(c) == 0.
+    assert float(a) == float(b) == float(c) == 0.0
 
     # bool/int/float should only be allowed on 0-D arrays.
     assert_raises(TypeError, lambda: bool(asarray([False])))
     assert_raises(TypeError, lambda: int(asarray([0])))
-    assert_raises(TypeError, lambda: float(asarray([0.])))
+    assert_raises(TypeError, lambda: float(asarray([0.0])))
diff --git a/numpy/array_api/tests/test_creation_functions.py b/numpy/array_api/tests/test_creation_functions.py
index 654f1d9b3..3cb8865cd 100644
--- a/numpy/array_api/tests/test_creation_functions.py
+++ b/numpy/array_api/tests/test_creation_functions.py
@@ -2,26 +2,53 @@ from numpy.testing import assert_raises
 import numpy as np
 
 from .. import all
-from .._creation_functions import (asarray, arange, empty, empty_like, eye, from_dlpack, full, full_like, linspace, meshgrid, ones, ones_like, zeros, zeros_like)
+from .._creation_functions import (
+    asarray,
+    arange,
+    empty,
+    empty_like,
+    eye,
+    from_dlpack,
+    full,
+    full_like,
+    linspace,
+    meshgrid,
+    ones,
+    ones_like,
+    zeros,
+    zeros_like,
+)
 from .._array_object import Array
-from .._dtypes import (_all_dtypes, _boolean_dtypes, _floating_dtypes,
-                       _integer_dtypes, _integer_or_boolean_dtypes,
-                       _numeric_dtypes, int8, int16, int32, int64, uint64)
+from .._dtypes import (
+    _all_dtypes,
+    _boolean_dtypes,
+    _floating_dtypes,
+    _integer_dtypes,
+    _integer_or_boolean_dtypes,
+    _numeric_dtypes,
+    int8,
+    int16,
+    int32,
+    int64,
+    uint64,
+)
+
 
 def test_asarray_errors():
     # Test various protections against incorrect usage
     assert_raises(TypeError, lambda: Array([1]))
-    assert_raises(TypeError, lambda: asarray(['a']))
-    assert_raises(ValueError, lambda: asarray([1.], dtype=np.float16))
+    assert_raises(TypeError, lambda: asarray(["a"]))
+    assert_raises(ValueError, lambda: asarray([1.0], dtype=np.float16))
     assert_raises(OverflowError, lambda: asarray(2**100))
     # Preferably this would be OverflowError
     # assert_raises(OverflowError, lambda: asarray([2**100]))
     assert_raises(TypeError, lambda: asarray([2**100]))
-    asarray([1], device='cpu') # Doesn't error
-    assert_raises(ValueError, lambda: asarray([1], device='gpu'))
+    asarray([1], device="cpu")  # Doesn't error
+    assert_raises(ValueError, lambda: asarray([1], device="gpu"))
 
     assert_raises(ValueError, lambda: asarray([1], dtype=int))
-    assert_raises(ValueError, lambda: asarray([1], dtype='i'))
+    assert_raises(ValueError, lambda: asarray([1], dtype="i"))
+
 
 def test_asarray_copy():
     a = asarray([1])
@@ -36,68 +63,79 @@ def test_asarray_copy():
     # assert all(b[0] == 0)
     assert_raises(NotImplementedError, lambda: asarray(a, copy=False))
 
+
 def test_arange_errors():
-    arange(1, device='cpu') # Doesn't error
-    assert_raises(ValueError, lambda: arange(1, device='gpu'))
+    arange(1, device="cpu")  # Doesn't error
+    assert_raises(ValueError, lambda: arange(1, device="gpu"))
     assert_raises(ValueError, lambda: arange(1, dtype=int))
-    assert_raises(ValueError, lambda: arange(1, dtype='i'))
+    assert_raises(ValueError, lambda: arange(1, dtype="i"))
+
 
 def test_empty_errors():
-    empty((1,), device='cpu') # Doesn't error
-    assert_raises(ValueError, lambda: empty((1,), device='gpu'))
+    empty((1,), device="cpu")  # Doesn't error
+    assert_raises(ValueError, lambda: empty((1,), device="gpu"))
     assert_raises(ValueError, lambda: empty((1,), dtype=int))
-    assert_raises(ValueError, lambda: empty((1,), dtype='i'))
+    assert_raises(ValueError, lambda: empty((1,), dtype="i"))
+
 
 def test_empty_like_errors():
-    empty_like(asarray(1), device='cpu') # Doesn't error
-    assert_raises(ValueError, lambda: empty_like(asarray(1), device='gpu'))
+    empty_like(asarray(1), device="cpu")  # Doesn't error
+    assert_raises(ValueError, lambda: empty_like(asarray(1), device="gpu"))
     assert_raises(ValueError, lambda: empty_like(asarray(1), dtype=int))
-    assert_raises(ValueError, lambda: empty_like(asarray(1), dtype='i'))
+    assert_raises(ValueError, lambda: empty_like(asarray(1), dtype="i"))
+
 
 def test_eye_errors():
-    eye(1, device='cpu') # Doesn't error
-    assert_raises(ValueError, lambda: eye(1, device='gpu'))
+    eye(1, device="cpu")  # Doesn't error
+    assert_raises(ValueError, lambda: eye(1, device="gpu"))
     assert_raises(ValueError, lambda: eye(1, dtype=int))
-    assert_raises(ValueError, lambda: eye(1, dtype='i'))
+    assert_raises(ValueError, lambda: eye(1, dtype="i"))
+
 
 def test_full_errors():
-    full((1,), 0, device='cpu') # Doesn't error
-    assert_raises(ValueError, lambda: full((1,), 0, device='gpu'))
+    full((1,), 0, device="cpu")  # Doesn't error
+    assert_raises(ValueError, lambda: full((1,), 0, device="gpu"))
     assert_raises(ValueError, lambda: full((1,), 0, dtype=int))
-    assert_raises(ValueError, lambda: full((1,), 0, dtype='i'))
+    assert_raises(ValueError, lambda: full((1,), 0, dtype="i"))
+
 
 def test_full_like_errors():
-    full_like(asarray(1), 0, device='cpu') # Doesn't error
-    assert_raises(ValueError, lambda: full_like(asarray(1), 0, device='gpu'))
+    full_like(asarray(1), 0, device="cpu")  # Doesn't error
+    assert_raises(ValueError, lambda: full_like(asarray(1), 0, device="gpu"))
     assert_raises(ValueError, lambda: full_like(asarray(1), 0, dtype=int))
-    assert_raises(ValueError, lambda: full_like(asarray(1), 0, dtype='i'))
+    assert_raises(ValueError, lambda: full_like(asarray(1), 0, dtype="i"))
+
 
 def test_linspace_errors():
-    linspace(0, 1, 10, device='cpu') # Doesn't error
-    assert_raises(ValueError, lambda: linspace(0, 1, 10, device='gpu'))
+    linspace(0, 1, 10, device="cpu")  # Doesn't error
+    assert_raises(ValueError, lambda: linspace(0, 1, 10, device="gpu"))
     assert_raises(ValueError, lambda: linspace(0, 1, 10, dtype=float))
-    assert_raises(ValueError, lambda: linspace(0, 1, 10, dtype='f'))
+    assert_raises(ValueError, lambda: linspace(0, 1, 10, dtype="f"))
+
 
 def test_ones_errors():
-    ones((1,), device='cpu') # Doesn't error
-    assert_raises(ValueError, lambda: ones((1,), device='gpu'))
+    ones((1,), device="cpu")  # Doesn't error
+    assert_raises(ValueError, lambda: ones((1,), device="gpu"))
     assert_raises(ValueError, lambda: ones((1,), dtype=int))
-    assert_raises(ValueError, lambda: ones((1,), dtype='i'))
+    assert_raises(ValueError, lambda: ones((1,), dtype="i"))
+
 
 def test_ones_like_errors():
-    ones_like(asarray(1), device='cpu') # Doesn't error
-    assert_raises(ValueError, lambda: ones_like(asarray(1), device='gpu'))
+    ones_like(asarray(1), device="cpu")  # Doesn't error
+    assert_raises(ValueError, lambda: ones_like(asarray(1), device="gpu"))
     assert_raises(ValueError, lambda: ones_like(asarray(1), dtype=int))
-    assert_raises(ValueError, lambda: ones_like(asarray(1), dtype='i'))
+    assert_raises(ValueError, lambda: ones_like(asarray(1), dtype="i"))
+
 
 def test_zeros_errors():
-    zeros((1,), device='cpu') # Doesn't error
-    assert_raises(ValueError, lambda: zeros((1,), device='gpu'))
+    zeros((1,), device="cpu")  # Doesn't error
+    assert_raises(ValueError, lambda: zeros((1,), device="gpu"))
     assert_raises(ValueError, lambda: zeros((1,), dtype=int))
-    assert_raises(ValueError, lambda: zeros((1,), dtype='i'))
+    assert_raises(ValueError, lambda: zeros((1,), dtype="i"))
+
 
 def test_zeros_like_errors():
-    zeros_like(asarray(1), device='cpu') # Doesn't error
-    assert_raises(ValueError, lambda: zeros_like(asarray(1), device='gpu'))
+    zeros_like(asarray(1), device="cpu")  # Doesn't error
+    assert_raises(ValueError, lambda: zeros_like(asarray(1), device="gpu"))
     assert_raises(ValueError, lambda: zeros_like(asarray(1), dtype=int))
-    assert_raises(ValueError, lambda: zeros_like(asarray(1), dtype='i'))
+    assert_raises(ValueError, lambda: zeros_like(asarray(1), dtype="i"))
diff --git a/numpy/array_api/tests/test_elementwise_functions.py b/numpy/array_api/tests/test_elementwise_functions.py
index ec76cb7a7..a9274aec9 100644
--- a/numpy/array_api/tests/test_elementwise_functions.py
+++ b/numpy/array_api/tests/test_elementwise_functions.py
@@ -4,74 +4,80 @@ from numpy.testing import assert_raises
 
 from .. import asarray, _elementwise_functions
 from .._elementwise_functions import bitwise_left_shift, bitwise_right_shift
-from .._dtypes import (_dtype_categories, _boolean_dtypes, _floating_dtypes,
-                       _integer_dtypes)
+from .._dtypes import (
+    _dtype_categories,
+    _boolean_dtypes,
+    _floating_dtypes,
+    _integer_dtypes,
+)
+
 
 def nargs(func):
     return len(getfullargspec(func).args)
 
+
 def test_function_types():
     # Test that every function accepts only the required input types. We only
     # test the negative cases here (error). The positive cases are tested in
     # the array API test suite.
 
     elementwise_function_input_types = {
-        'abs': 'numeric',
-        'acos': 'floating-point',
-        'acosh': 'floating-point',
-        'add': 'numeric',
-        'asin': 'floating-point',
-        'asinh': 'floating-point',
-        'atan': 'floating-point',
-        'atan2': 'floating-point',
-        'atanh': 'floating-point',
-        'bitwise_and': 'integer or boolean',
-        'bitwise_invert': 'integer or boolean',
-        'bitwise_left_shift': 'integer',
-        'bitwise_or': 'integer or boolean',
-        'bitwise_right_shift': 'integer',
-        'bitwise_xor': 'integer or boolean',
-        'ceil': 'numeric',
-        'cos': 'floating-point',
-        'cosh': 'floating-point',
-        'divide': 'floating-point',
-        'equal': 'all',
-        'exp': 'floating-point',
-        'expm1': 'floating-point',
-        'floor': 'numeric',
-        'floor_divide': 'numeric',
-        'greater': 'numeric',
-        'greater_equal': 'numeric',
-        'isfinite': 'numeric',
-        'isinf': 'numeric',
-        'isnan': 'numeric',
-        'less': 'numeric',
-        'less_equal': 'numeric',
-        'log': 'floating-point',
-        'logaddexp': 'floating-point',
-        'log10': 'floating-point',
-        'log1p': 'floating-point',
-        'log2': 'floating-point',
-        'logical_and': 'boolean',
-        'logical_not': 'boolean',
-        'logical_or': 'boolean',
-        'logical_xor': 'boolean',
-        'multiply': 'numeric',
-        'negative': 'numeric',
-        'not_equal': 'all',
-        'positive': 'numeric',
-        'pow': 'floating-point',
-        'remainder': 'numeric',
-        'round': 'numeric',
-        'sign': 'numeric',
-        'sin': 'floating-point',
-        'sinh': 'floating-point',
-        'sqrt': 'floating-point',
-        'square': 'numeric',
-        'subtract': 'numeric',
-        'tan': 'floating-point',
-        'tanh': 'floating-point',
-        'trunc': 'numeric',
+        "abs": "numeric",
+        "acos": "floating-point",
+        "acosh": "floating-point",
+        "add": "numeric",
+        "asin": "floating-point",
+        "asinh": "floating-point",
+        "atan": "floating-point",
+        "atan2": "floating-point",
+        "atanh": "floating-point",
+        "bitwise_and": "integer or boolean",
+        "bitwise_invert": "integer or boolean",
+        "bitwise_left_shift": "integer",
+        "bitwise_or": "integer or boolean",
+        "bitwise_right_shift": "integer",
+        "bitwise_xor": "integer or boolean",
+        "ceil": "numeric",
+        "cos": "floating-point",
+        "cosh": "floating-point",
+        "divide": "floating-point",
+        "equal": "all",
+        "exp": "floating-point",
+        "expm1": "floating-point",
+        "floor": "numeric",
+        "floor_divide": "numeric",
+        "greater": "numeric",
+        "greater_equal": "numeric",
+        "isfinite": "numeric",
+        "isinf": "numeric",
+        "isnan": "numeric",
+        "less": "numeric",
+        "less_equal": "numeric",
+        "log": "floating-point",
+        "logaddexp": "floating-point",
+        "log10": "floating-point",
+        "log1p": "floating-point",
+        "log2": "floating-point",
+        "logical_and": "boolean",
+        "logical_not": "boolean",
+        "logical_or": "boolean",
+        "logical_xor": "boolean",
+        "multiply": "numeric",
+        "negative": "numeric",
+        "not_equal": "all",
+        "positive": "numeric",
+        "pow": "floating-point",
+        "remainder": "numeric",
+        "round": "numeric",
+        "sign": "numeric",
+        "sin": "floating-point",
+        "sinh": "floating-point",
+        "sqrt": "floating-point",
+        "square": "numeric",
+        "subtract": "numeric",
+        "tan": "floating-point",
+        "tanh": "floating-point",
+        "trunc": "numeric",
     }
 
     def _array_vals():
@@ -80,7 +86,7 @@ def test_function_types():
         for d in _boolean_dtypes:
             yield asarray(False, dtype=d)
         for d in _floating_dtypes:
-            yield asarray(1., dtype=d)
+            yield asarray(1.0, dtype=d)
 
     for x in _array_vals():
         for func_name, types in elementwise_function_input_types.items():
@@ -94,7 +100,12 @@ def test_function_types():
                 if x.dtype not in dtypes:
                     assert_raises(TypeError, lambda: func(x))
 
+
 def test_bitwise_shift_error():
     # bitwise shift functions should raise when the second argument is negative
-    assert_raises(ValueError, lambda: bitwise_left_shift(asarray([1, 1]), asarray([1, -1])))
-    assert_raises(ValueError, lambda: bitwise_right_shift(asarray([1, 1]), asarray([1, -1])))
+    assert_raises(
+        ValueError, lambda: bitwise_left_shift(asarray([1, 1]), asarray([1, -1]))
+    )
+    assert_raises(
+        ValueError, lambda: bitwise_right_shift(asarray([1, 1]), asarray([1, -1]))
+    )