numba-cuda 0.8.1__py3-none-any.whl → 0.9.0__py3-none-any.whl

numba_cuda/numba/cuda/tests/cudapy/test_sm.py

@@ -8,8 +8,7 @@ from numba.np import numpy_support as nps
 
 from .extensions_usecases import test_struct_model_type, TestStruct
 
-recordwith2darray = np.dtype([('i', np.int32),
-                              ('j', np.float32, (3, 2))])
+recordwith2darray = np.dtype([("i", np.int32), ("j", np.float32, (3, 2))])
 
 
 class TestSharedMemoryIssue(CUDATestCase):
@@ -42,7 +41,6 @@ class TestSharedMemoryIssue(CUDATestCase):
         self._check_shared_array_size((2, 3), 6)
 
     def test_issue_1051_shared_size_broken_3d(self):
-
         self._check_shared_array_size((2, 3, 4), 24)
 
     def _check_shared_array_size_fp16(self, shape, expected, ty):
@@ -71,8 +69,9 @@ class TestSharedMemoryIssue(CUDATestCase):
 
         @cuda.jit
         def costs_func(d_block_costs):
-            s_features = cuda.shared.array((examples_per_block, num_weights),
-                                           float64)
+            s_features = cuda.shared.array(
+                (examples_per_block, num_weights), float64
+            )
             s_initialcost = cuda.shared.array(7, float64)  # Bug
 
             threadIdx = cuda.threadIdx.x
@@ -364,7 +363,7 @@ class TestSharedMemory(CUDATestCase):
         def sm_slice_copy(x, y, chunksize):
             dynsmem = cuda.shared.array(0, dtype=dt)
             sm1 = dynsmem[0:chunksize]
-            sm2 = dynsmem[chunksize:chunksize * 2]
+            sm2 = dynsmem[chunksize : chunksize * 2]
 
             tx = cuda.threadIdx.x
             bx = cuda.blockIdx.x
@@ -396,14 +395,16 @@ class TestSharedMemory(CUDATestCase):
         rgx = ".*Cannot infer the type of variable 'arr'.*"
 
         def unsupported_type():
-            arr = cuda.shared.array(10, dtype=np.dtype('O')) # noqa: F841
+            arr = cuda.shared.array(10, dtype=np.dtype("O"))  # noqa: F841
+
         with self.assertRaisesRegex(TypingError, rgx):
             cuda.jit(void())(unsupported_type)
 
         rgx = ".*Invalid NumPy dtype specified: 'int33'.*"
 
         def invalid_string_type():
-            arr = cuda.shared.array(10, dtype='int33') # noqa: F841
+            arr = cuda.shared.array(10, dtype="int33")  # noqa: F841
+
         with self.assertRaisesRegex(TypingError, rgx):
             cuda.jit(void())(invalid_string_type)
 
@@ -440,5 +441,5 @@ class TestSharedMemory(CUDATestCase):
             self.assertEqual(y, (nthreads - i - 1) * 2)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/cudapy/test_sm_creation.py

@@ -17,15 +17,17 @@ def udt_global_constants(A):
 
 
 def udt_global_build_tuple(A):
-    sa = cuda.shared.array(shape=(GLOBAL_CONSTANT, GLOBAL_CONSTANT_2),
-                           dtype=float32)
+    sa = cuda.shared.array(
+        shape=(GLOBAL_CONSTANT, GLOBAL_CONSTANT_2), dtype=float32
+    )
     i, j = cuda.grid(2)
     A[i, j] = sa[i, j]
 
 
 def udt_global_build_list(A):
-    sa = cuda.shared.array(shape=[GLOBAL_CONSTANT, GLOBAL_CONSTANT_2],
-                           dtype=float32)
+    sa = cuda.shared.array(
+        shape=[GLOBAL_CONSTANT, GLOBAL_CONSTANT_2], dtype=float32
+    )
     i, j = cuda.grid(2)
     A[i, j] = sa[i, j]
 
@@ -59,7 +61,7 @@ class TestSharedMemoryCreation(CUDATestCase):
         return np.array(100, dtype=np.float32, ndmin=1)
 
     def getarg2(self):
-        return self.getarg().reshape(1,1)
+        return self.getarg().reshape(1, 1)
 
     def test_global_constants(self):
         udt = cuda.jit((float32[:],))(udt_global_constants)
@@ -69,18 +71,21 @@ class TestSharedMemoryCreation(CUDATestCase):
         udt = cuda.jit((float32[:, :],))(udt_global_build_tuple)
         udt[1, 1](self.getarg2())
 
-    @skip_on_cudasim('Simulator does not prohibit lists for shared array shape')
+    @skip_on_cudasim("Simulator does not prohibit lists for shared array shape")
     def test_global_build_list(self):
         with self.assertRaises(TypingError) as raises:
             cuda.jit((float32[:, :],))(udt_global_build_list)
 
-        self.assertIn("No implementation of function "
-                      "Function(<function shared.array",
-                      str(raises.exception))
-        self.assertIn("found for signature:\n \n "
-                      ">>> array(shape=list(int64)<iv=[5, 6]>, "
-                      "dtype=class(float32)",
-                      str(raises.exception))
+        self.assertIn(
+            "No implementation of function Function(<function shared.array",
+            str(raises.exception),
+        )
+        self.assertIn(
+            "found for signature:\n \n "
+            ">>> array(shape=list(int64)<iv=[5, 6]>, "
+            "dtype=class(float32)",
+            str(raises.exception),
+        )
 
     def test_global_constant_tuple(self):
         udt = cuda.jit((float32[:, :],))(udt_global_constant_tuple)
@@ -92,12 +97,15 @@ class TestSharedMemoryCreation(CUDATestCase):
         with self.assertRaises(TypingError) as raises:
             cuda.jit((float32[:],))(udt_invalid_1)
 
-        self.assertIn("No implementation of function "
-                      "Function(<function shared.array",
-                      str(raises.exception))
-        self.assertIn("found for signature:\n \n "
-                      ">>> array(shape=float32, dtype=class(float32))",
-                      str(raises.exception))
+        self.assertIn(
+            "No implementation of function Function(<function shared.array",
+            str(raises.exception),
+        )
+        self.assertIn(
+            "found for signature:\n \n "
+            ">>> array(shape=float32, dtype=class(float32))",
+            str(raises.exception),
+        )
 
     @skip_on_cudasim("Can't check for constants in simulator")
     def test_invalid_2(self):
@@ -105,13 +113,16 @@ class TestSharedMemoryCreation(CUDATestCase):
         with self.assertRaises(TypingError) as raises:
             cuda.jit((float32[:, :],))(udt_invalid_2)
 
-        self.assertIn("No implementation of function "
-                      "Function(<function shared.array",
-                      str(raises.exception))
-        self.assertIn("found for signature:\n \n "
-                      ">>> array(shape=Tuple(Literal[int](1), "
-                      "array(float32, 1d, A)), dtype=class(float32))",
-                      str(raises.exception))
+        self.assertIn(
+            "No implementation of function Function(<function shared.array",
+            str(raises.exception),
+        )
+        self.assertIn(
+            "found for signature:\n \n "
+            ">>> array(shape=Tuple(Literal[int](1), "
+            "array(float32, 1d, A)), dtype=class(float32))",
+            str(raises.exception),
+        )
 
     @skip_on_cudasim("Can't check for constants in simulator")
     def test_invalid_3(self):
@@ -119,12 +130,15 @@ class TestSharedMemoryCreation(CUDATestCase):
         with self.assertRaises(TypingError) as raises:
             cuda.jit((int32[:],))(udt_invalid_1)
 
-        self.assertIn("No implementation of function "
-                      "Function(<function shared.array",
-                      str(raises.exception))
-        self.assertIn("found for signature:\n \n "
-                      ">>> array(shape=int32, dtype=class(float32))",
-                      str(raises.exception))
+        self.assertIn(
+            "No implementation of function Function(<function shared.array",
+            str(raises.exception),
+        )
+        self.assertIn(
+            "found for signature:\n \n "
+            ">>> array(shape=int32, dtype=class(float32))",
+            str(raises.exception),
+        )
 
     @skip_on_cudasim("Can't check for constants in simulator")
     def test_invalid_4(self):
@@ -132,18 +146,21 @@ class TestSharedMemoryCreation(CUDATestCase):
         with self.assertRaises(TypingError) as raises:
             cuda.jit((int32[:],))(udt_invalid_3)
 
-        self.assertIn("No implementation of function "
-                      "Function(<function shared.array",
-                      str(raises.exception))
-        self.assertIn("found for signature:\n \n "
-                      ">>> array(shape=Tuple(Literal[int](1), int32), "
-                      "dtype=class(float32))",
-                      str(raises.exception))
+        self.assertIn(
+            "No implementation of function Function(<function shared.array",
+            str(raises.exception),
+        )
+        self.assertIn(
+            "found for signature:\n \n "
+            ">>> array(shape=Tuple(Literal[int](1), int32), "
+            "dtype=class(float32))",
+            str(raises.exception),
+        )
 
     def check_dtype(self, f, dtype):
         # Find the typing of the dtype argument to cuda.shared.array
         annotation = next(iter(f.overloads.values()))._type_annotation
-        l_dtype = annotation.typemap['s'].dtype
+        l_dtype = annotation.typemap["s"].dtype
         # Ensure that the typing is correct
         self.assertEqual(l_dtype, dtype)
 
@@ -174,7 +191,7 @@ class TestSharedMemoryCreation(CUDATestCase):
         # Check that strings can be used to specify the dtype of a shared array
         @cuda.jit(void(int32[::1]))
         def f(x):
-            s = cuda.shared.array(10, dtype='int32')
+            s = cuda.shared.array(10, dtype="int32")
             s[0] = x[0]
             x[0] = s[0]
 
@@ -185,9 +202,10 @@ class TestSharedMemoryCreation(CUDATestCase):
         # Check that strings of invalid dtypes cause a typing error
         re = ".*Invalid NumPy dtype specified: 'int33'.*"
         with self.assertRaisesRegex(TypingError, re):
+
             @cuda.jit(void(int32[::1]))
             def f(x):
-                s = cuda.shared.array(10, dtype='int33')
+                s = cuda.shared.array(10, dtype="int33")
                 s[0] = x[0]
                 x[0] = s[0]
 
@@ -198,8 +216,9 @@ class TestSharedMemoryCreation(CUDATestCase):
             s = cuda.shared.array(10, dtype=test_struct_model_type)
             s[0] = x[0]
             x[0] = s[0]
+
         self.check_dtype(f, test_struct_model_type)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/cudapy/test_stream_api.py

@@ -1,5 +1,9 @@
-from numba.cuda.testing import (skip_on_cudasim, skip_unless_cudasim, unittest,
-                                CUDATestCase)
+from numba.cuda.testing import (
+    skip_on_cudasim,
+    skip_unless_cudasim,
+    unittest,
+    CUDATestCase,
+)
 from numba import config, cuda
 
 # Basic tests that stream APIs execute on the hardware and in the simulator.
@@ -48,5 +52,5 @@ class TestStreamAPI(CUDATestCase):
             cuda.external_stream(ptr)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/cudapy/test_sync.py

@@ -133,14 +133,16 @@ class TestCudaSync(CUDATestCase):
         self._test_useless(useless_syncwarp)
 
     @skip_on_cudasim("syncwarp not implemented on cudasim")
-    @unittest.skipUnless(_safe_cc_check((7, 0)),
-                         "Partial masks require CC 7.0 or greater")
+    @unittest.skipUnless(
+        _safe_cc_check((7, 0)), "Partial masks require CC 7.0 or greater"
+    )
     def test_useless_syncwarp_with_mask(self):
         self._test_useless(useless_syncwarp_with_mask)
 
     @skip_on_cudasim("syncwarp not implemented on cudasim")
-    @unittest.skipUnless(_safe_cc_check((7, 0)),
-                         "Partial masks require CC 7.0 or greater")
+    @unittest.skipUnless(
+        _safe_cc_check((7, 0)), "Partial masks require CC 7.0 or greater"
+    )
     def test_coop_syncwarp(self):
         # coop_syncwarp computes the sum of all integers from 0 to 31 (496)
         # using a single warp
@@ -267,5 +269,5 @@ class TestCudaSync(CUDATestCase):
         self._test_syncthreads_or(np.int64)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/cudapy/test_transpose.py

@@ -5,17 +5,17 @@ from numba.cuda.testing import unittest
 from numba.cuda.testing import skip_on_cudasim, CUDATestCase
 
 
-recordwith2darray = np.dtype([('i', np.int32),
-                              ('j', np.float32, (3, 2))])
+recordwith2darray = np.dtype([("i", np.int32), ("j", np.float32, (3, 2))])
 
 
-@skip_on_cudasim('Device Array API unsupported in the simulator')
+@skip_on_cudasim("Device Array API unsupported in the simulator")
 class TestTranspose(CUDATestCase):
-
     def test_transpose(self):
-        variants = ((5, 6, np.float64),
-                    (128, 128, np.complex128),
-                    (1025, 512, np.float64))
+        variants = (
+            (5, 6, np.float64),
+            (128, 128, np.complex128),
+            (1025, 512, np.float64),
+        )
 
         for rows, cols, dtype in variants:
             with self.subTest(rows=rows, cols=cols, dtype=dtype):
@@ -27,8 +27,15 @@ class TestTranspose(CUDATestCase):
                 dy.copy_to_host(y)
                 np.testing.assert_array_equal(x.transpose(), y)
 
-    small_variants = ((2, 3), (16, 16), (16, 17), (17, 16), (14, 15), (15, 14),
-                      (14, 14))
+    small_variants = (
+        (2, 3),
+        (16, 16),
+        (16, 17),
+        (17, 16),
+        (14, 15),
+        (15, 14),
+        (14, 14),
+    )
 
     def test_transpose_record(self):
         for rows, cols in self.small_variants:
@@ -36,7 +43,7 @@ class TestTranspose(CUDATestCase):
                 arr = np.recarray((rows, cols), dtype=recordwith2darray)
                 for x in range(rows):
                     for y in range(cols):
-                        arr[x, y].i = x ** 2 + y
+                        arr[x, y].i = x**2 + y
                         j = np.arange(3 * 2, dtype=np.float32)
                         arr[x, y].j = j.reshape(3, 2) * x + y
 
@@ -76,5 +83,5 @@ class TestTranspose(CUDATestCase):
         np.testing.assert_array_equal(a_view_t, h_a_view_t)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/cudapy/test_ufuncs.py

@@ -9,11 +9,11 @@ from numba.tests.test_ufuncs import BasicUFuncTest
 
 def _make_ufunc_usecase(ufunc):
     ldict = {}
-    arg_str = ','.join(['a{0}'.format(i) for i in range(ufunc.nargs)])
-    func_str = f'def fn({arg_str}):\n    np.{ufunc.__name__}({arg_str})'
+    arg_str = ",".join(["a{0}".format(i) for i in range(ufunc.nargs)])
+    func_str = f"def fn({arg_str}):\n    np.{ufunc.__name__}({arg_str})"
     exec(func_str, globals(), ldict)
-    fn = ldict['fn']
-    fn.__name__ = '{0}_usecase'.format(ufunc.__name__)
+    fn = ldict["fn"]
+    fn.__name__ = "{0}_usecase".format(ufunc.__name__)
     return fn
 
 
@@ -32,58 +32,75 @@ class TestUFuncs(BasicUFuncTest, TestCase):
 
         # The basic ufunc test does not set up complex inputs, so we'll add
         # some here for testing with CUDA.
-        self.inputs.extend([
-            (np.complex64(-0.5 - 0.5j), types.complex64),
-            (np.complex64(0.0), types.complex64),
-            (np.complex64(0.5 + 0.5j), types.complex64),
-
-            (np.complex128(-0.5 - 0.5j), types.complex128),
-            (np.complex128(0.0), types.complex128),
-            (np.complex128(0.5 + 0.5j), types.complex128),
-
-            (np.array([-0.5 - 0.5j, 0.0, 0.5 + 0.5j], dtype='c8'),
-             types.Array(types.complex64, 1, 'C')),
-            (np.array([-0.5 - 0.5j, 0.0, 0.5 + 0.5j], dtype='c16'),
-             types.Array(types.complex128, 1, 'C')),
-        ])
+        self.inputs.extend(
+            [
+                (np.complex64(-0.5 - 0.5j), types.complex64),
+                (np.complex64(0.0), types.complex64),
+                (np.complex64(0.5 + 0.5j), types.complex64),
+                (np.complex128(-0.5 - 0.5j), types.complex128),
+                (np.complex128(0.0), types.complex128),
+                (np.complex128(0.5 + 0.5j), types.complex128),
+                (
+                    np.array([-0.5 - 0.5j, 0.0, 0.5 + 0.5j], dtype="c8"),
+                    types.Array(types.complex64, 1, "C"),
+                ),
+                (
+                    np.array([-0.5 - 0.5j, 0.0, 0.5 + 0.5j], dtype="c16"),
+                    types.Array(types.complex128, 1, "C"),
+                ),
+            ]
+        )
 
         # Test with multiple dimensions
-        self.inputs.extend([
-            # Basic 2D and 3D arrays
-            (np.linspace(0, 1).reshape((5, -1)),
-             types.Array(types.float64, 2, 'C')),
-            (np.linspace(0, 1).reshape((2, 5, -1)),
-             types.Array(types.float64, 3, 'C')),
-            # Complex data (i.e. interleaved)
-            (np.linspace(0, 1 + 1j).reshape(5, -1),
-             types.Array(types.complex128, 2, 'C')),
-            # F-ordered
-            (np.asfortranarray(np.linspace(0, 1).reshape((5, -1))),
-             types.Array(types.float64, 2, 'F')),
-        ])
+        self.inputs.extend(
+            [
+                # Basic 2D and 3D arrays
+                (
+                    np.linspace(0, 1).reshape((5, -1)),
+                    types.Array(types.float64, 2, "C"),
+                ),
+                (
+                    np.linspace(0, 1).reshape((2, 5, -1)),
+                    types.Array(types.float64, 3, "C"),
+                ),
+                # Complex data (i.e. interleaved)
+                (
+                    np.linspace(0, 1 + 1j).reshape(5, -1),
+                    types.Array(types.complex128, 2, "C"),
+                ),
+                # F-ordered
+                (
+                    np.asfortranarray(np.linspace(0, 1).reshape((5, -1))),
+                    types.Array(types.float64, 2, "F"),
+                ),
+            ]
+        )
 
         # Add tests for other integer types
-        self.inputs.extend([
-            (np.uint8(0), types.uint8),
-            (np.uint8(1), types.uint8),
-            (np.int8(-1), types.int8),
-            (np.int8(0), types.int8),
-
-            (np.uint16(0), types.uint16),
-            (np.uint16(1), types.uint16),
-            (np.int16(-1), types.int16),
-            (np.int16(0), types.int16),
-
-            (np.ulonglong(0), types.ulonglong),
-            (np.ulonglong(1), types.ulonglong),
-            (np.longlong(-1), types.longlong),
-            (np.longlong(0), types.longlong),
-
-            (np.array([0,1], dtype=np.ulonglong),
-             types.Array(types.ulonglong, 1, 'C')),
-            (np.array([0,1], dtype=np.longlong),
-             types.Array(types.longlong, 1, 'C')),
-        ])
+        self.inputs.extend(
+            [
+                (np.uint8(0), types.uint8),
+                (np.uint8(1), types.uint8),
+                (np.int8(-1), types.int8),
+                (np.int8(0), types.int8),
+                (np.uint16(0), types.uint16),
+                (np.uint16(1), types.uint16),
+                (np.int16(-1), types.int16),
+                (np.int16(0), types.int16),
+                (np.ulonglong(0), types.ulonglong),
+                (np.ulonglong(1), types.ulonglong),
+                (np.longlong(-1), types.longlong),
+                (np.longlong(0), types.longlong),
+                (
+                    np.array([0, 1], dtype=np.ulonglong),
+                    types.Array(types.ulonglong, 1, "C"),
+                ),
+                (
+                    np.array([0, 1], dtype=np.longlong),
+                    types.Array(types.longlong, 1, "C"),
+                ),
+            ]
+        )
 
         self._low_occupancy_warnings = config.CUDA_LOW_OCCUPANCY_WARNINGS
         self._warn_on_implicit_copy = config.CUDA_WARN_ON_IMPLICIT_COPY
@@ -111,18 +128,18 @@ class TestUFuncs(BasicUFuncTest, TestCase):
         skip_inputs = [
             types.float32,
             types.float64,
-            types.Array(types.float32, 1, 'C'),
-            types.Array(types.float32, 2, 'C'),
-            types.Array(types.float64, 1, 'C'),
-            types.Array(types.float64, 2, 'C'),
-            types.Array(types.float64, 3, 'C'),
-            types.Array(types.float64, 2, 'F'),
+            types.Array(types.float32, 1, "C"),
+            types.Array(types.float32, 2, "C"),
+            types.Array(types.float64, 1, "C"),
+            types.Array(types.float64, 2, "C"),
+            types.Array(types.float64, 3, "C"),
+            types.Array(types.float64, 2, "F"),
             types.complex64,
             types.complex128,
-            types.Array(types.complex64, 1, 'C'),
-            types.Array(types.complex64, 2, 'C'),
-            types.Array(types.complex128, 1, 'C'),
-            types.Array(types.complex128, 2, 'C'),
+            types.Array(types.complex64, 1, "C"),
+            types.Array(types.complex64, 2, "C"),
+            types.Array(types.complex128, 1, "C"),
+            types.Array(types.complex128, 2, "C"),
         ]
         self.basic_ufunc_test(name, skip_inputs=skip_inputs)
 
@@ -130,43 +147,43 @@ class TestUFuncs(BasicUFuncTest, TestCase):
     # Trigonometric Functions
 
     def test_sin_ufunc(self):
-        self.basic_ufunc_test(np.sin, kinds='cf')
+        self.basic_ufunc_test(np.sin, kinds="cf")
 
     def test_cos_ufunc(self):
-        self.basic_ufunc_test(np.cos, kinds='cf')
+        self.basic_ufunc_test(np.cos, kinds="cf")
 
     def test_tan_ufunc(self):
-        self.basic_ufunc_test(np.tan, kinds='cf')
+        self.basic_ufunc_test(np.tan, kinds="cf")
 
     def test_arcsin_ufunc(self):
-        self.basic_ufunc_test(np.arcsin, kinds='cf')
+        self.basic_ufunc_test(np.arcsin, kinds="cf")
 
     def test_arccos_ufunc(self):
-        self.basic_ufunc_test(np.arccos, kinds='cf')
+        self.basic_ufunc_test(np.arccos, kinds="cf")
 
     def test_arctan_ufunc(self):
-        self.basic_ufunc_test(np.arctan, kinds='cf')
+        self.basic_ufunc_test(np.arctan, kinds="cf")
 
     def test_arctan2_ufunc(self):
-        self.basic_ufunc_test(np.arctan2, kinds='f')
+        self.basic_ufunc_test(np.arctan2, kinds="f")
 
     def test_hypot_ufunc(self):
-        self.basic_ufunc_test(np.hypot, kinds='f')
+        self.basic_ufunc_test(np.hypot, kinds="f")
 
     def test_sinh_ufunc(self):
-        self.basic_ufunc_test(np.sinh, kinds='cf')
+        self.basic_ufunc_test(np.sinh, kinds="cf")
 
     def test_cosh_ufunc(self):
-        self.basic_ufunc_test(np.cosh, kinds='cf')
+        self.basic_ufunc_test(np.cosh, kinds="cf")
 
     def test_tanh_ufunc(self):
-        self.basic_ufunc_test(np.tanh, kinds='cf')
+        self.basic_ufunc_test(np.tanh, kinds="cf")
 
     def test_arcsinh_ufunc(self):
-        self.basic_ufunc_test(np.arcsinh, kinds='cf')
+        self.basic_ufunc_test(np.arcsinh, kinds="cf")
 
     def test_arccosh_ufunc(self):
-        self.basic_ufunc_test(np.arccosh, kinds='cf')
+        self.basic_ufunc_test(np.arccosh, kinds="cf")
 
     def test_arctanh_ufunc(self):
         # arctanh is only valid is only finite in the range ]-1, 1[
@@ -177,24 +194,30 @@ class TestUFuncs(BasicUFuncTest, TestCase):
         # used to compile NumPy may differ from the result generated by
         # llvm. Skipping the integer types in this test avoids failed
         # tests because of this.
-        to_skip = [types.Array(types.uint32, 1, 'C'), types.uint32,
-                   types.Array(types.int32, 1, 'C'), types.int32,
-                   types.Array(types.uint64, 1, 'C'), types.uint64,
-                   types.Array(types.int64, 1, 'C'), types.int64]
+        to_skip = [
+            types.Array(types.uint32, 1, "C"),
+            types.uint32,
+            types.Array(types.int32, 1, "C"),
+            types.int32,
+            types.Array(types.uint64, 1, "C"),
+            types.uint64,
+            types.Array(types.int64, 1, "C"),
+            types.int64,
+        ]
 
-        self.basic_ufunc_test(np.arctanh, skip_inputs=to_skip, kinds='cf')
+        self.basic_ufunc_test(np.arctanh, skip_inputs=to_skip, kinds="cf")
 
     def test_deg2rad_ufunc(self):
-        self.basic_ufunc_test(np.deg2rad, kinds='f')
+        self.basic_ufunc_test(np.deg2rad, kinds="f")
 
     def test_rad2deg_ufunc(self):
-        self.basic_ufunc_test(np.rad2deg, kinds='f')
+        self.basic_ufunc_test(np.rad2deg, kinds="f")
 
     def test_degrees_ufunc(self):
-        self.basic_ufunc_test(np.degrees, kinds='f')
+        self.basic_ufunc_test(np.degrees, kinds="f")
 
     def test_radians_ufunc(self):
-        self.basic_ufunc_test(np.radians, kinds='f')
+        self.basic_ufunc_test(np.radians, kinds="f")
 
     ############################################################################
     # Comparison functions
@@ -264,14 +287,14 @@ class TestUFuncs(BasicUFuncTest, TestCase):
     # Mathematical Functions
 
     def test_log_ufunc(self):
-        self.basic_ufunc_test(np.log, kinds='cf')
+        self.basic_ufunc_test(np.log, kinds="cf")
 
     def test_log2_ufunc(self):
-        self.basic_ufunc_test(np.log2, kinds='cf')
+        self.basic_ufunc_test(np.log2, kinds="cf")
 
     def test_log10_ufunc(self):
-        self.basic_ufunc_test(np.log10, kinds='cf')
+        self.basic_ufunc_test(np.log10, kinds="cf")
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()