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

numba_cuda/numba/cuda/tests/cudadrv/test_cuda_array_slicing.py

@@ -11,7 +11,7 @@ class CudaArrayIndexing(CUDATestCase):
     def test_index_1d(self):
         arr = np.arange(10)
         darr = cuda.to_device(arr)
-        x, = arr.shape
+        (x,) = arr.shape
         for i in range(-x, x):
             self.assertEqual(arr[i], darr[i])
         with self.assertRaises(IndexError):
@@ -58,7 +58,6 @@ class CudaArrayIndexing(CUDATestCase):
 
 
 class CudaArrayStridedSlice(CUDATestCase):
-
     def test_strided_index_1d(self):
         arr = np.arange(10)
         darr = cuda.to_device(arr)
@@ -71,8 +70,9 @@ class CudaArrayStridedSlice(CUDATestCase):
 
         for i in range(arr.shape[0]):
             for j in range(arr.shape[1]):
-                np.testing.assert_equal(arr[i::2, j::2],
-                                        darr[i::2, j::2].copy_to_host())
+                np.testing.assert_equal(
+                    arr[i::2, j::2], darr[i::2, j::2].copy_to_host()
+                )
 
     def test_strided_index_3d(self):
         arr = np.arange(6 * 7 * 8).reshape(6, 7, 8)
@@ -83,7 +83,8 @@ class CudaArrayStridedSlice(CUDATestCase):
                 for k in range(arr.shape[2]):
                     np.testing.assert_equal(
                         arr[i::2, j::2, k::2],
-                        darr[i::2, j::2, k::2].copy_to_host())
+                        darr[i::2, j::2, k::2].copy_to_host(),
+                    )
 
 
 class CudaArraySlicing(CUDATestCase):
@@ -96,7 +97,7 @@ class CudaArraySlicing(CUDATestCase):
             self.assertTrue(np.all(expect == got))
 
     def test_prefix_2d(self):
-        arr = np.arange(3 ** 2).reshape(3, 3)
+        arr = np.arange(3**2).reshape(3, 3)
         darr = cuda.to_device(arr)
         for i in range(arr.shape[0]):
             for j in range(arr.shape[1]):
@@ -129,39 +130,45 @@ class CudaArraySlicing(CUDATestCase):
                 self.assertTrue(np.all(expect == got))
 
     def test_select_f(self):
-        a = np.arange(5 * 6 * 7).reshape(5, 6, 7, order='F')
+        a = np.arange(5 * 6 * 7).reshape(5, 6, 7, order="F")
         da = cuda.to_device(a)
 
         for i in range(a.shape[0]):
             for j in range(a.shape[1]):
-                self.assertTrue(np.array_equal(da[i, j, :].copy_to_host(),
-                                               a[i, j, :]))
+                self.assertTrue(
+                    np.array_equal(da[i, j, :].copy_to_host(), a[i, j, :])
+                )
             for j in range(a.shape[2]):
-                self.assertTrue(np.array_equal(da[i, :, j].copy_to_host(),
-                                               a[i, :, j]))
+                self.assertTrue(
+                    np.array_equal(da[i, :, j].copy_to_host(), a[i, :, j])
+                )
         for i in range(a.shape[1]):
             for j in range(a.shape[2]):
-                self.assertTrue(np.array_equal(da[:, i, j].copy_to_host(),
-                                               a[:, i, j]))
+                self.assertTrue(
+                    np.array_equal(da[:, i, j].copy_to_host(), a[:, i, j])
+                )
 
     def test_select_c(self):
-        a = np.arange(5 * 6 * 7).reshape(5, 6, 7, order='C')
+        a = np.arange(5 * 6 * 7).reshape(5, 6, 7, order="C")
         da = cuda.to_device(a)
 
         for i in range(a.shape[0]):
             for j in range(a.shape[1]):
-                self.assertTrue(np.array_equal(da[i, j, :].copy_to_host(),
-                                               a[i, j, :]))
+                self.assertTrue(
+                    np.array_equal(da[i, j, :].copy_to_host(), a[i, j, :])
+                )
             for j in range(a.shape[2]):
-                self.assertTrue(np.array_equal(da[i, :, j].copy_to_host(),
-                                               a[i, :, j]))
+                self.assertTrue(
+                    np.array_equal(da[i, :, j].copy_to_host(), a[i, :, j])
+                )
         for i in range(a.shape[1]):
             for j in range(a.shape[2]):
-                self.assertTrue(np.array_equal(da[:, i, j].copy_to_host(),
-                                               a[:, i, j]))
+                self.assertTrue(
+                    np.array_equal(da[:, i, j].copy_to_host(), a[:, i, j])
+                )
 
     def test_prefix_select(self):
-        arr = np.arange(5 * 7).reshape(5, 7, order='F')
+        arr = np.arange(5 * 7).reshape(5, 7, order="F")
 
         darr = cuda.to_device(arr)
         self.assertTrue(np.all(darr[:1, 1].copy_to_host() == arr[:1, 1]))
@@ -170,15 +177,15 @@ class CudaArraySlicing(CUDATestCase):
         arr = np.arange(10)
         darr = cuda.to_device(arr)
         for i, j in product(range(-10, 10), repeat=2):
-            np.testing.assert_array_equal(arr[i:j],
-                                          darr[i:j].copy_to_host())
+            np.testing.assert_array_equal(arr[i:j], darr[i:j].copy_to_host())
 
     def test_negative_slicing_2d(self):
         arr = np.arange(12).reshape(3, 4)
         darr = cuda.to_device(arr)
         for x, y, w, s in product(range(-4, 4), repeat=4):
-            np.testing.assert_array_equal(arr[x:y, w:s],
-                                          darr[x:y, w:s].copy_to_host())
+            np.testing.assert_array_equal(
+                arr[x:y, w:s], darr[x:y, w:s].copy_to_host()
+            )
 
     def test_empty_slice_1d(self):
         arr = np.arange(5)
@@ -186,12 +193,12 @@ class CudaArraySlicing(CUDATestCase):
         for i in range(darr.shape[0]):
             np.testing.assert_array_equal(darr[i:i].copy_to_host(), arr[i:i])
         # empty slice of empty slice
-        self.assertFalse(darr[:0][:0].copy_to_host())
+        self.assertFalse(darr[:0][:0].copy_to_host().size > 0)
         # out-of-bound slice just produces empty slices
-        np.testing.assert_array_equal(darr[:0][:1].copy_to_host(),
-                                      arr[:0][:1])
-        np.testing.assert_array_equal(darr[:0][-1:].copy_to_host(),
-                                      arr[:0][-1:])
+        np.testing.assert_array_equal(darr[:0][:1].copy_to_host(), arr[:0][:1])
+        np.testing.assert_array_equal(
+            darr[:0][-1:].copy_to_host(), arr[:0][-1:]
+        )
 
     def test_empty_slice_2d(self):
         arr = np.arange(5 * 7).reshape(5, 7)
@@ -199,11 +206,12 @@ class CudaArraySlicing(CUDATestCase):
         np.testing.assert_array_equal(darr[:0].copy_to_host(), arr[:0])
         np.testing.assert_array_equal(darr[3, :0].copy_to_host(), arr[3, :0])
         # empty slice of empty slice
-        self.assertFalse(darr[:0][:0].copy_to_host())
+        self.assertFalse(darr[:0][:0].copy_to_host().size > 0)
         # out-of-bound slice just produces empty slices
         np.testing.assert_array_equal(darr[:0][:1].copy_to_host(), arr[:0][:1])
-        np.testing.assert_array_equal(darr[:0][-1:].copy_to_host(),
-                                      arr[:0][-1:])
+        np.testing.assert_array_equal(
+            darr[:0][-1:].copy_to_host(), arr[:0][-1:]
+        )
 
 
 class CudaArraySetting(CUDATestCase):
@@ -292,7 +300,8 @@ class CudaArraySetting(CUDATestCase):
                 "Can't assign 3-D array to 1-D self",  # device
                 "could not broadcast input array from shape (2,3) "
                 "into shape (35,)",  # simulator, NP >= 1.20
-            ])
+            ],
+        )
 
     def test_incompatible_shape(self):
         darr = cuda.to_device(np.arange(5))
@@ -306,57 +315,67 @@ class CudaArraySetting(CUDATestCase):
                 "Can't copy sequence with size 2 to array axis 0 with "
                 "dimension 5",  # device
                 "could not broadcast input array from shape (2,) into "
-                "shape (5,)",   # simulator, NP >= 1.20
-            ])
+                "shape (5,)",  # simulator, NP >= 1.20
+            ],
+        )
 
-    @skip_on_cudasim('cudasim does not use streams and operates synchronously')
+    @skip_on_cudasim("cudasim does not use streams and operates synchronously")
     def test_sync(self):
         # There should be a synchronization when no stream is supplied
         darr = cuda.to_device(np.arange(5))
 
-        with patch.object(cuda.cudadrv.driver.Stream, 'synchronize',
-                          return_value=None) as mock_sync:
+        with patch.object(
+            cuda.cudadrv.driver.Stream, "synchronize", return_value=None
+        ) as mock_sync:
             darr[0] = 10
 
         mock_sync.assert_called_once()
 
-    @skip_on_cudasim('cudasim does not use streams and operates synchronously')
+    @skip_on_cudasim("cudasim does not use streams and operates synchronously")
     def test_no_sync_default_stream(self):
         # There should not be a synchronization when the array has a default
         # stream, whether it is the default stream, the legacy default stream,
         # the per-thread default stream, or another stream.
-        streams = (cuda.stream(), cuda.default_stream(),
-                   cuda.legacy_default_stream(),
-                   cuda.per_thread_default_stream())
+        streams = (
+            cuda.stream(),
+            cuda.default_stream(),
+            cuda.legacy_default_stream(),
+            cuda.per_thread_default_stream(),
+        )
 
         for stream in streams:
             darr = cuda.to_device(np.arange(5), stream=stream)
 
-            with patch.object(cuda.cudadrv.driver.Stream, 'synchronize',
-                              return_value=None) as mock_sync:
+            with patch.object(
+                cuda.cudadrv.driver.Stream, "synchronize", return_value=None
+            ) as mock_sync:
                 darr[0] = 10
 
             mock_sync.assert_not_called()
 
-    @skip_on_cudasim('cudasim does not use streams and operates synchronously')
+    @skip_on_cudasim("cudasim does not use streams and operates synchronously")
     def test_no_sync_supplied_stream(self):
         # There should not be a synchronization when a stream is supplied for
         # the setitem call, whether it is the default stream, the legacy default
         # stream, the per-thread default stream, or another stream.
-        streams = (cuda.stream(), cuda.default_stream(),
-                   cuda.legacy_default_stream(),
-                   cuda.per_thread_default_stream())
+        streams = (
+            cuda.stream(),
+            cuda.default_stream(),
+            cuda.legacy_default_stream(),
+            cuda.per_thread_default_stream(),
+        )
 
         for stream in streams:
             darr = cuda.to_device(np.arange(5))
 
-            with patch.object(cuda.cudadrv.driver.Stream, 'synchronize',
-                              return_value=None) as mock_sync:
+            with patch.object(
+                cuda.cudadrv.driver.Stream, "synchronize", return_value=None
+            ) as mock_sync:
                 darr.setitem(0, 10, stream=stream)
 
             mock_sync.assert_not_called()
 
-    @unittest.skip('Requires PR #6367')
+    @unittest.skip("Requires PR #6367")
     def test_issue_6505(self):
         # On Windows, the writes to ary_v would not be visible prior to the
         # assertion, due to the assignment being done with a kernel launch that
@@ -365,11 +384,11 @@ class CudaArraySetting(CUDATestCase):
         ary = cuda.mapped_array(2, dtype=np.int32)
         ary[:] = 0
 
-        ary_v = ary.view('u1')
+        ary_v = ary.view("u1")
         ary_v[1] = 1
         ary_v[5] = 1
         self.assertEqual(sum(ary), 512)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/cudadrv/test_cuda_auto_context.py

@@ -17,5 +17,5 @@ class TestCudaAutoContext(CUDATestCase):
         self.assertTrue(np.allclose(A, newA))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/cudadrv/test_cuda_devicerecord.py

@@ -1,7 +1,10 @@
 import numpy as np
 import ctypes
-from numba.cuda.cudadrv.devicearray import (DeviceRecord, from_record_like,
-                                            auto_device)
+from numba.cuda.cudadrv.devicearray import (
+    DeviceRecord,
+    from_record_like,
+    auto_device,
+)
 from numba.cuda.testing import unittest, CUDATestCase
 from numba.cuda.testing import skip_on_cudasim
 from numba.np import numpy_support
@@ -11,43 +14,37 @@ N_CHARS = 5
 
 recordtype = np.dtype(
     [
-        ('a', np.float64),
-        ('b', np.int32),
-        ('c', np.complex64),
-        ('d', (np.str_, N_CHARS))
+        ("a", np.float64),
+        ("b", np.int32),
+        ("c", np.complex64),
+        ("d", (np.str_, N_CHARS)),
     ],
-    align=True
+    align=True,
 )
 
-recordwitharray = np.dtype(
-    [
-        ('g', np.int32),
-        ('h', np.float32, 2)
-    ],
-    align=True
-)
+recordwitharray = np.dtype([("g", np.int32), ("h", np.float32, 2)], align=True)
 
-recwithmat = np.dtype([('i', np.int32),
-                       ('j', np.float32, (3, 3))])
+recwithmat = np.dtype([("i", np.int32), ("j", np.float32, (3, 3))])
 
-recwithrecwithmat = np.dtype([('x', np.int32), ('y', recwithmat)])
+recwithrecwithmat = np.dtype([("x", np.int32), ("y", recwithmat)])
 
 
-@skip_on_cudasim('Device Record API unsupported in the simulator')
+@skip_on_cudasim("Device Record API unsupported in the simulator")
 class TestCudaDeviceRecord(CUDATestCase):
     """
     Tests the DeviceRecord class with np.void host types.
     """
+
     def setUp(self):
         super().setUp()
         self._create_data(np.zeros)
 
     def _create_data(self, array_ctor):
-        self.dtype = np.dtype([('a', np.int32), ('b', np.float32)], align=True)
+        self.dtype = np.dtype([("a", np.int32), ("b", np.float32)], align=True)
         self.hostz = array_ctor(1, self.dtype)[0]
         self.hostnz = array_ctor(1, self.dtype)[0]
-        self.hostnz['a'] = 10
-        self.hostnz['b'] = 11.0
+        self.hostnz["a"] = 10
+        self.hostnz["b"] = 11.0
 
     def _check_device_record(self, reference, rec):
         self.assertEqual(rec.shape, tuple())
@@ -111,21 +108,22 @@ class TestCudaDeviceRecordWithRecord(TestCudaDeviceRecord):
     """
     Tests the DeviceRecord class with np.record host types
     """
+
     def setUp(self):
         CUDATestCase.setUp(self)
         self._create_data(np.recarray)
 
 
-@skip_on_cudasim('Structured array attr access not supported in simulator')
+@skip_on_cudasim("Structured array attr access not supported in simulator")
 class TestRecordDtypeWithStructArrays(CUDATestCase):
-    '''
+    """
     Test operation of device arrays on structured arrays.
-    '''
+    """
 
     def _createSampleArrays(self):
         self.sample1d = cuda.device_array(3, dtype=recordtype)
         self.samplerec1darr = cuda.device_array(1, dtype=recordwitharray)[0]
-        self.samplerecmat = cuda.device_array(1,dtype=recwithmat)[0]
+        self.samplerecmat = cuda.device_array(1, dtype=recwithmat)[0]
 
     def setUp(self):
         super().setUp()
@@ -134,46 +132,46 @@ class TestRecordDtypeWithStructArrays(CUDATestCase):
         ary = self.sample1d
         for i in range(ary.size):
             x = i + 1
-            ary[i]['a'] = x / 2
-            ary[i]['b'] = x
-            ary[i]['c'] = x * 1j
-            ary[i]['d'] = str(x) * N_CHARS
+            ary[i]["a"] = x / 2
+            ary[i]["b"] = x
+            ary[i]["c"] = x * 1j
+            ary[i]["d"] = str(x) * N_CHARS
 
     def test_structured_array1(self):
         ary = self.sample1d
         for i in range(self.sample1d.size):
             x = i + 1
-            self.assertEqual(ary[i]['a'], x / 2)
-            self.assertEqual(ary[i]['b'], x)
-            self.assertEqual(ary[i]['c'], x * 1j)
-            self.assertEqual(ary[i]['d'], str(x) * N_CHARS)
+            self.assertEqual(ary[i]["a"], x / 2)
+            self.assertEqual(ary[i]["b"], x)
+            self.assertEqual(ary[i]["c"], x * 1j)
+            self.assertEqual(ary[i]["d"], str(x) * N_CHARS)
 
     def test_structured_array2(self):
         ary = self.samplerec1darr
-        ary['g'] = 2
-        ary['h'][0] = 3.0
-        ary['h'][1] = 4.0
-        self.assertEqual(ary['g'], 2)
-        self.assertEqual(ary['h'][0], 3.0)
-        self.assertEqual(ary['h'][1], 4.0)
+        ary["g"] = 2
+        ary["h"][0] = 3.0
+        ary["h"][1] = 4.0
+        self.assertEqual(ary["g"], 2)
+        self.assertEqual(ary["h"][0], 3.0)
+        self.assertEqual(ary["h"][1], 4.0)
 
     def test_structured_array3(self):
         ary = self.samplerecmat
-        mat = np.array([[5.0, 10.0, 15.0],
-                       [20.0, 25.0, 30.0],
-                       [35.0, 40.0, 45.0]],
-                       dtype=np.float32).reshape(3,3)
-        ary['j'][:] = mat
-        np.testing.assert_equal(ary['j'], mat)
+        mat = np.array(
+            [[5.0, 10.0, 15.0], [20.0, 25.0, 30.0], [35.0, 40.0, 45.0]],
+            dtype=np.float32,
+        ).reshape(3, 3)
+        ary["j"][:] = mat
+        np.testing.assert_equal(ary["j"], mat)
 
     def test_structured_array4(self):
         arr = np.zeros(1, dtype=recwithrecwithmat)
         d_arr = cuda.to_device(arr)
-        d_arr[0]['y']['i'] = 1
-        self.assertEqual(d_arr[0]['y']['i'], 1)
-        d_arr[0]['y']['j'][0, 0] = 2.0
-        self.assertEqual(d_arr[0]['y']['j'][0, 0], 2.0)
+        d_arr[0]["y"]["i"] = 1
+        self.assertEqual(d_arr[0]["y"]["i"], 1)
+        d_arr[0]["y"]["j"][0, 0] = 2.0
+        self.assertEqual(d_arr[0]["y"]["j"][0, 0], 2.0)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/cudadrv/test_cuda_driver.py

@@ -1,13 +1,17 @@
 from ctypes import byref, c_int, c_void_p, sizeof
 
-from numba.cuda.cudadrv.driver import (host_to_device, device_to_host, driver,
-                                       launch_kernel)
+from numba.cuda.cudadrv.driver import (
+    host_to_device,
+    device_to_host,
+    driver,
+    launch_kernel,
+)
 from numba.cuda.cudadrv import devices, drvapi, driver as _driver
 from numba.cuda.testing import unittest, CUDATestCase
 from numba.cuda.testing import skip_on_cudasim
 
 
-ptx1 = '''
+ptx1 = """
     .version 1.4
     .target sm_10, map_f64_to_f32
 
@@ -29,9 +33,9 @@ $LDWbegin__Z10helloworldPi:
     exit;
 $LDWend__Z10helloworldPi:
     } // _Z10helloworldPi
-'''
+"""
 
-ptx2 = '''
+ptx2 = """
 .version 3.0
 .target sm_20
 .address_size 64
@@ -57,10 +61,10 @@ ptx2 = '''
     .loc 2 7 2
     ret;
 }
-'''
+"""
 
 
-@skip_on_cudasim('CUDA Driver API unsupported in the simulator')
+@skip_on_cudasim("CUDA Driver API unsupported in the simulator")
 class TestCudaDriver(CUDATestCase):
     def setUp(self):
         super().setUp()
@@ -79,7 +83,7 @@ class TestCudaDriver(CUDATestCase):
 
     def test_cuda_driver_basic(self):
         module = self.context.create_module_ptx(self.ptx)
-        function = module.get_function('_Z10helloworldPi')
+        function = module.get_function("_Z10helloworldPi")
 
         array = (c_int * 100)()
 
@@ -93,12 +97,18 @@ class TestCudaDriver(CUDATestCase):
             ptr = c_void_p(int(ptr))
             stream = _driver.binding.CUstream(stream)
 
-        launch_kernel(function.handle,  # Kernel
-                      1,   1, 1,        # gx, gy, gz
-                      100, 1, 1,        # bx, by, bz
-                      0,                # dynamic shared mem
-                      stream,           # stream
-                      [ptr])            # arguments
+        launch_kernel(
+            function.handle,  # Kernel
+            1,
+            1,
+            1,  # gx, gy, gz
+            100,
+            1,
+            1,  # bx, by, bz
+            0,  # dynamic shared mem
+            stream,  # stream
+            [ptr],
+        )  # arguments
 
         device_to_host(array, memory, sizeof(array))
         for i, v in enumerate(array):
@@ -108,7 +118,7 @@ class TestCudaDriver(CUDATestCase):
 
     def test_cuda_driver_stream_operations(self):
         module = self.context.create_module_ptx(self.ptx)
-        function = module.get_function('_Z10helloworldPi')
+        function = module.get_function("_Z10helloworldPi")
 
         array = (c_int * 100)()
 
@@ -122,12 +132,18 @@ class TestCudaDriver(CUDATestCase):
             if _driver.USE_NV_BINDING:
                 ptr = c_void_p(int(ptr))
 
-            launch_kernel(function.handle,  # Kernel
-                          1,   1, 1,        # gx, gy, gz
-                          100, 1, 1,        # bx, by, bz
-                          0,                # dynamic shared mem
-                          stream.handle,    # stream
-                          [ptr])            # arguments
+            launch_kernel(
+                function.handle,  # Kernel
+                1,
+                1,
+                1,  # gx, gy, gz
+                100,
+                1,
+                1,  # bx, by, bz
+                0,  # dynamic shared mem
+                stream.handle,  # stream
+                [ptr],
+            )  # arguments
 
         device_to_host(array, memory, sizeof(array), stream=stream)
 
@@ -193,17 +209,19 @@ class TestCudaDriver(CUDATestCase):
 
     def test_cuda_driver_occupancy(self):
         module = self.context.create_module_ptx(self.ptx)
-        function = module.get_function('_Z10helloworldPi')
+        function = module.get_function("_Z10helloworldPi")
 
-        value = self.context.get_active_blocks_per_multiprocessor(function,
-                                                                  128, 128)
+        value = self.context.get_active_blocks_per_multiprocessor(
+            function, 128, 128
+        )
         self.assertTrue(value > 0)
 
         def b2d(bs):
             return bs
 
-        grid, block = self.context.get_max_potential_block_size(function, b2d,
-                                                                128, 128)
+        grid, block = self.context.get_max_potential_block_size(
+            function, b2d, 128, 128
+        )
         self.assertTrue(grid > 0)
         self.assertTrue(block > 0)
 
@@ -221,15 +239,15 @@ class TestDevice(CUDATestCase):
         # 4122) pertaining to versions and variants, so we do not extract and
         # validate the values of these bits.
 
-        h = '[0-9a-f]{%d}'
+        h = "[0-9a-f]{%d}"
         h4 = h % 4
         h8 = h % 8
         h12 = h % 12
-        uuid_format = f'^GPU-{h8}-{h4}-{h4}-{h4}-{h12}$'
+        uuid_format = f"^GPU-{h8}-{h4}-{h4}-{h4}-{h12}$"
 
         dev = devices.get_context().device
         self.assertRegex(dev.uuid, uuid_format)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/cudadrv/test_cuda_libraries.py

@@ -3,7 +3,7 @@ from numba.cuda.testing import skip_on_cudasim, skip_unless_conda_cudatoolkit
 from numba.misc.findlib import find_lib
 
 
-@skip_on_cudasim('Library detection unsupported in the simulator')
+@skip_on_cudasim("Library detection unsupported in the simulator")
 @skip_unless_conda_cudatoolkit
 class TestLibraryDetection(unittest.TestCase):
     def test_detect(self):
@@ -13,10 +13,10 @@ class TestLibraryDetection(unittest.TestCase):
         PyCulib (and potentially others) rely on Numba's library finding
         capacity to find and subsequently load these libraries.
         """
-        core_libs = ['nvvm']
+        core_libs = ["nvvm"]
         for l in core_libs:
             self.assertNotEqual(find_lib(l), [])
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()