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

numba_cuda/numba/cuda/simulator/api.py

@@ -1,6 +1,6 @@
-'''
+"""
 Contains CUDA API functions
-'''
+"""
 
 # Imports here bring together parts of the API from other modules, so some of
 # them appear unused.
@@ -15,7 +15,7 @@ from ..args import In, Out, InOut  # noqa: F401
 
 
 def select_device(dev=0):
-    assert dev == 0, 'Only a single device supported by the simulator'
+    assert dev == 0, "Only a single device supported by the simulator"
 
 
 def is_float16_supported():
@@ -23,10 +23,11 @@ def is_float16_supported():
 
 
 class stream(object):
-    '''
+    """
     The stream API is supported in the simulator - however, all execution
     occurs synchronously, so synchronization requires no operation.
-    '''
+    """
+
     @contextmanager
     def auto_synchronize(self):
         yield
@@ -62,9 +63,9 @@ def declare_device(*args, **kwargs):
 
 
 def detect():
-    print('Found 1 CUDA devices')
-    print('id %d    %20s %40s' % (0, 'SIMULATOR', '[SUPPORTED]'))
-    print('%40s: 5.0' % 'compute capability')
+    print("Found 1 CUDA devices")
+    print("id %d    %20s %40s" % (0, "SIMULATOR", "[SUPPORTED]"))
+    print("%40s: 5.0" % "compute capability")
 
 
 def list_devices():
@@ -73,11 +74,13 @@ def list_devices():
 
 # Events
 
+
 class Event(object):
-    '''
+    """
     The simulator supports the event API, but they do not record timing info,
     and all simulation is synchronous. Execution time is not recorded.
-    '''
+    """
+
     def record(self, stream=0):
         pass
 
@@ -88,35 +91,48 @@ class Event(object):
         pass
 
     def elapsed_time(self, event):
-        warn('Simulator timings are bogus')
+        warn("Simulator timings are bogus")
         return 0.0
 
 
 event = Event
 
 
-def jit(func_or_sig=None, device=False, debug=None, argtypes=None,
-        inline=False, restype=None, fastmath=False, link=None,
-        boundscheck=None, opt=None, cache=None
-        ):
+def jit(
+    func_or_sig=None,
+    device=False,
+    debug=None,
+    argtypes=None,
+    inline=False,
+    restype=None,
+    fastmath=False,
+    link=None,
+    boundscheck=None,
+    opt=None,
+    cache=None,
+):
     # Here for API compatibility
     if boundscheck:
         raise NotImplementedError("bounds checking is not supported for CUDA")
 
     if link is not None:
-        raise NotImplementedError('Cannot link PTX in the simulator')
+        raise NotImplementedError("Cannot link PTX in the simulator")
 
     debug = config.CUDA_DEBUGINFO_DEFAULT if debug is None else debug
 
     # Check for first argument specifying types - in that case the
     # decorator is not being passed a function
-    if (func_or_sig is None or is_signature(func_or_sig)
-            or isinstance(func_or_sig, list)):
+    if (
+        func_or_sig is None
+        or is_signature(func_or_sig)
+        or isinstance(func_or_sig, list)
+    ):
+
         def jitwrapper(fn):
-            return FakeCUDAKernel(fn,
-                                  device=device,
-                                  fastmath=fastmath,
-                                  debug=debug)
+            return FakeCUDAKernel(
+                fn, device=device, fastmath=fastmath, debug=debug
+            )
+
         return jitwrapper
     return FakeCUDAKernel(func_or_sig, device=device, debug=debug)
 

numba_cuda/numba/cuda/simulator/compiler.py

@@ -1,7 +1,7 @@
-'''
+"""
 The compiler is not implemented in the simulator. This module provides a stub
 to allow tests to import successfully.
-'''
+"""
 
 compile = None
 compile_for_current_device = None

numba_cuda/numba/cuda/simulator/cudadrv/__init__.py

@@ -1,2 +1,8 @@
-from numba.cuda.simulator.cudadrv import (devicearray, devices, driver, drvapi,
-                                          error, nvvm)
+from numba.cuda.simulator.cudadrv import (
+    devicearray,
+    devices,
+    driver,
+    drvapi,
+    error,
+    nvvm,
+)

numba_cuda/numba/cuda/simulator/cudadrv/devicearray.py

@@ -1,7 +1,8 @@
-'''
+"""
 The Device Array API is not implemented in the simulator. This module provides
 stubs to allow tests to import correctly.
-'''
+"""
+
 from contextlib import contextmanager
 from numba.np.numpy_support import numpy_version
 
@@ -12,37 +13,39 @@ DeviceRecord = None
 from_record_like = None
 
 
-errmsg_contiguous_buffer = ("Array contains non-contiguous buffer and cannot "
-                            "be transferred as a single memory region. Please "
-                            "ensure contiguous buffer with numpy "
-                            ".ascontiguousarray()")
+errmsg_contiguous_buffer = (
+    "Array contains non-contiguous buffer and cannot "
+    "be transferred as a single memory region. Please "
+    "ensure contiguous buffer with numpy "
+    ".ascontiguousarray()"
+)
 
 
 class FakeShape(tuple):
-    '''
+    """
     The FakeShape class is used to provide a shape which does not allow negative
     indexing, similar to the shape in CUDA Python. (Numpy shape arrays allow
     negative indexing)
-    '''
+    """
 
     def __getitem__(self, k):
         if isinstance(k, int) and k < 0:
-            raise IndexError('tuple index out of range')
+            raise IndexError("tuple index out of range")
         return super(FakeShape, self).__getitem__(k)
 
 
 class FakeWithinKernelCUDAArray(object):
-    '''
+    """
     Created to emulate the behavior of arrays within kernels, where either
     array.item or array['item'] is valid (that is, give all structured
     arrays `numpy.recarray`-like semantics). This behaviour does not follow
     the semantics of Python and NumPy with non-jitted code, and will be
     deprecated and removed.
-    '''
+    """
 
     def __init__(self, item):
         assert isinstance(item, FakeCUDAArray)
-        self.__dict__['_item'] = item
+        self.__dict__["_item"] = item
 
     def __wrap_if_fake(self, item):
         if isinstance(item, FakeCUDAArray):
@@ -84,18 +87,18 @@ class FakeWithinKernelCUDAArray(object):
 
             return obj
 
-        out = kwargs.get('out')
+        out = kwargs.get("out")
         if out:
-            kwargs['out'] = tuple(convert_fakes(o) for o in out)
+            kwargs["out"] = tuple(convert_fakes(o) for o in out)
         args = tuple(convert_fakes(a) for a in args)
         return call(*args, **kwargs)
 
 
 class FakeCUDAArray(object):
-    '''
+    """
     Implements the interface of a DeviceArray/DeviceRecord, but mostly just
     wraps a NumPy array.
-    '''
+    """
 
     __cuda_ndarray__ = True  # There must be gpu_data attribute
 
@@ -149,13 +152,13 @@ class FakeCUDAArray(object):
         return ary
 
     def copy_to_device(self, ary, stream=0):
-        '''
+        """
         Copy from the provided array into this array.
 
         This may be less forgiving than the CUDA Python implementation, which
         will copy data up to the length of the smallest of the two arrays,
         whereas this expects the size of the arrays to be equal.
-        '''
+        """
         sentry_contiguous(self)
         self_core, ary_core = array_core(self), array_core(ary)
         if isinstance(ary, FakeCUDAArray):
@@ -164,9 +167,10 @@ class FakeCUDAArray(object):
         else:
             ary_core = np.array(
                 ary_core,
-                order='C' if self_core.flags['C_CONTIGUOUS'] else 'F',
+                order="C" if self_core.flags["C_CONTIGUOUS"] else "F",
                 subok=True,
-                copy=False if numpy_version < (2, 0) else None)
+                copy=False if numpy_version < (2, 0) else None,
+            )
             check_array_compatibility(self_core, ary_core)
         np.copyto(self_core._ary, ary_core)
 
@@ -237,7 +241,7 @@ class FakeCUDAArray(object):
         return FakeCUDAArray(self._ary % other)
 
     def __pow__(self, other):
-        return FakeCUDAArray(self._ary ** other)
+        return FakeCUDAArray(self._ary**other)
 
     def split(self, section, stream=0):
         return [
@@ -282,30 +286,33 @@ def is_contiguous(ary):
 
 def sentry_contiguous(ary):
     core = array_core(ary)
-    if not core.flags['C_CONTIGUOUS'] and not core.flags['F_CONTIGUOUS']:
+    if not core.flags["C_CONTIGUOUS"] and not core.flags["F_CONTIGUOUS"]:
         raise ValueError(errmsg_contiguous_buffer)
 
 
 def check_array_compatibility(ary1, ary2):
     ary1sq, ary2sq = ary1.squeeze(), ary2.squeeze()
     if ary1.dtype != ary2.dtype:
-        raise TypeError('incompatible dtype: %s vs. %s' %
-                        (ary1.dtype, ary2.dtype))
+        raise TypeError(
+            "incompatible dtype: %s vs. %s" % (ary1.dtype, ary2.dtype)
+        )
     if ary1sq.shape != ary2sq.shape:
-        raise ValueError('incompatible shape: %s vs. %s' %
-                         (ary1.shape, ary2.shape))
+        raise ValueError(
+            "incompatible shape: %s vs. %s" % (ary1.shape, ary2.shape)
+        )
     if ary1sq.strides != ary2sq.strides:
-        raise ValueError('incompatible strides: %s vs. %s' %
-                         (ary1.strides, ary2.strides))
+        raise ValueError(
+            "incompatible strides: %s vs. %s" % (ary1.strides, ary2.strides)
+        )
 
 
 def to_device(ary, stream=0, copy=True, to=None):
-    ary = np.array(ary,
-                   copy=False if numpy_version < (2, 0) else None,
-                   subok=True)
+    ary = np.array(
+        ary, copy=False if numpy_version < (2, 0) else None, subok=True
+    )
     sentry_contiguous(ary)
     if to is None:
-        buffer_dtype = np.int64 if ary.dtype.char in 'Mm' else ary.dtype
+        buffer_dtype = np.int64 if ary.dtype.char in "Mm" else ary.dtype
         return FakeCUDAArray(
             np.ndarray(
                 buffer=np.copy(array_core(ary)).view(buffer_dtype),
@@ -324,22 +331,22 @@ def pinned(arg):
 
 
 def mapped_array(*args, **kwargs):
-    for unused_arg in ('portable', 'wc'):
+    for unused_arg in ("portable", "wc"):
         if unused_arg in kwargs:
             kwargs.pop(unused_arg)
     return device_array(*args, **kwargs)
 
 
-def pinned_array(shape, dtype=np.float64, strides=None, order='C'):
+def pinned_array(shape, dtype=np.float64, strides=None, order="C"):
     return np.ndarray(shape=shape, strides=strides, dtype=dtype, order=order)
 
 
-def managed_array(shape, dtype=np.float64, strides=None, order='C'):
+def managed_array(shape, dtype=np.float64, strides=None, order="C"):
     return np.ndarray(shape=shape, strides=strides, dtype=dtype, order=order)
 
 
 def device_array(*args, **kwargs):
-    stream = kwargs.pop('stream') if 'stream' in kwargs else 0
+    stream = kwargs.pop("stream") if "stream" in kwargs else 0
     return FakeCUDAArray(np.ndarray(*args, **kwargs), stream=stream)
 
 
@@ -350,7 +357,7 @@ def _contiguous_strides_like_array(ary):
     """
     # Don't recompute strides if the default strides will be sufficient to
     # create a contiguous array.
-    if ary.flags['C_CONTIGUOUS'] or ary.flags['F_CONTIGUOUS'] or ary.ndim <= 1:
+    if ary.flags["C_CONTIGUOUS"] or ary.flags["F_CONTIGUOUS"] or ary.ndim <= 1:
         return None
 
     # Otherwise, we need to compute new strides using an algorithm adapted from
@@ -360,7 +367,7 @@ def _contiguous_strides_like_array(ary):
 
     # Stride permutation. E.g. a stride array (4, -2, 12) becomes
     # [(1, -2), (0, 4), (2, 12)]
-    strideperm = [ x for x in enumerate(ary.strides) ]
+    strideperm = [x for x in enumerate(ary.strides)]
     strideperm.sort(key=lambda x: x[1])
 
     # Compute new strides using permutation
@@ -373,24 +380,26 @@ def _contiguous_strides_like_array(ary):
 
 
 def _order_like_array(ary):
-    if ary.flags['F_CONTIGUOUS'] and not ary.flags['C_CONTIGUOUS']:
-        return 'F'
+    if ary.flags["F_CONTIGUOUS"] and not ary.flags["C_CONTIGUOUS"]:
+        return "F"
     else:
-        return 'C'
+        return "C"
 
 
 def device_array_like(ary, stream=0):
     strides = _contiguous_strides_like_array(ary)
     order = _order_like_array(ary)
-    return device_array(shape=ary.shape, dtype=ary.dtype, strides=strides,
-                        order=order)
+    return device_array(
+        shape=ary.shape, dtype=ary.dtype, strides=strides, order=order
+    )
 
 
 def pinned_array_like(ary):
     strides = _contiguous_strides_like_array(ary)
     order = _order_like_array(ary)
-    return pinned_array(shape=ary.shape, dtype=ary.dtype, strides=strides,
-                        order=order)
+    return pinned_array(
+        shape=ary.shape, dtype=ary.dtype, strides=strides, order=order
+    )
 
 
 def auto_device(ary, stream=0, copy=True):
@@ -399,15 +408,14 @@ def auto_device(ary, stream=0, copy=True):
 
     if not isinstance(ary, np.void):
         ary = np.array(
-            ary,
-            copy=False if numpy_version < (2, 0) else None,
-            subok=True)
+            ary, copy=False if numpy_version < (2, 0) else None, subok=True
+        )
     return to_device(ary, stream, copy), True
 
 
 def is_cuda_ndarray(obj):
     "Check if an object is a CUDA ndarray"
-    return getattr(obj, '__cuda_ndarray__', False)
+    return getattr(obj, "__cuda_ndarray__", False)
 
 
 def verify_cuda_ndarray_interface(obj):
@@ -418,15 +426,15 @@ def verify_cuda_ndarray_interface(obj):
         if not hasattr(obj, attr):
             raise AttributeError(attr)
         if not isinstance(getattr(obj, attr), typ):
-            raise AttributeError('%s must be of type %s' % (attr, typ))
+            raise AttributeError("%s must be of type %s" % (attr, typ))
 
-    requires_attr('shape', tuple)
-    requires_attr('strides', tuple)
-    requires_attr('dtype', np.dtype)
-    requires_attr('size', int)
+    requires_attr("shape", tuple)
+    requires_attr("strides", tuple)
+    requires_attr("dtype", np.dtype)
+    requires_attr("size", int)
 
 
 def require_cuda_ndarray(obj):
     "Raises ValueError is is_cuda_ndarray(obj) evaluates False"
     if not is_cuda_ndarray(obj):
-        raise ValueError('require an cuda ndarray object')
+        raise ValueError("require an cuda ndarray object")

numba_cuda/numba/cuda/simulator/cudadrv/devices.py

@@ -8,7 +8,7 @@ _SIMULATOR_CC = (5, 2)
 
 class FakeCUDADevice:
     def __init__(self):
-        self.uuid = 'GPU-00000000-0000-0000-0000-000000000000'
+        self.uuid = "GPU-00000000-0000-0000-0000-000000000000"
 
     @property
     def compute_capability(self):
@@ -16,10 +16,11 @@ class FakeCUDADevice:
 
 
 class FakeCUDAContext:
-    '''
+    """
     This stub implements functionality only for simulating a single GPU
     at the moment.
-    '''
+    """
+
     def __init__(self, device_id):
         self._device_id = device_id
         self._device = FakeCUDADevice()
@@ -54,7 +55,7 @@ class FakeCUDAContext:
         dependencies, e.g. `psutil` - so return infinite memory to maintain API
         type compatibility
         """
-        return _MemoryInfo(float('inf'), float('inf'))
+        return _MemoryInfo(float("inf"), float("inf"))
 
     def memalloc(self, sz):
         """
@@ -62,19 +63,20 @@ class FakeCUDAContext:
         At present, there is no division between simulated
         host memory and simulated device memory.
         """
-        return np.ndarray(sz, dtype='u1')
+        return np.ndarray(sz, dtype="u1")
 
     def memhostalloc(self, sz, mapped=False, portable=False, wc=False):
-        '''Allocates memory on the host'''
+        """Allocates memory on the host"""
         return self.memalloc(sz)
 
 
 class FakeDeviceList:
-    '''
+    """
     This stub implements a device list containing a single GPU. It also
     keeps track of the GPU status, i.e. whether the context is closed or not,
     which may have been set by the user calling reset()
-    '''
+    """
+
     def __init__(self):
         self.lst = (FakeCUDAContext(0),)
         self.closed = False
@@ -84,7 +86,7 @@ class FakeDeviceList:
         return self.lst[devnum]
 
     def __str__(self):
-        return ', '.join([str(d) for d in self.lst])
+        return ", ".join([str(d) for d in self.lst])
 
     def __iter__(self):
         return iter(self.lst)
@@ -111,7 +113,7 @@ def get_context(devnum=0):
 
 
 def require_context(func):
-    '''
+    """
     In the simulator, a context is always "available", so this is a no-op.
-    '''
+    """
     return func

numba_cuda/numba/cuda/simulator/cudadrv/driver.py

@@ -1,15 +1,15 @@
-'''
+"""
 Most of the driver API is unsupported in the simulator, but some stubs are
 provided to allow tests to import correctly.
-'''
+"""
 
 
 def device_memset(dst, val, size, stream=0):
-    dst.view('u1')[:size].fill(bytes([val])[0])
+    dst.view("u1")[:size].fill(bytes([val])[0])
 
 
 def host_to_device(dst, src, size, stream=0):
-    dst.view('u1')[:size] = src.view('u1')[:size]
+    dst.view("u1")[:size] = src.view("u1")[:size]
 
 
 def device_to_host(dst, src, size, stream=0):
@@ -55,7 +55,7 @@ class CudaAPIError(RuntimeError):
 
 
 def launch_kernel(*args, **kwargs):
-    msg = 'Launching kernels directly is not supported in the simulator'
+    msg = "Launching kernels directly is not supported in the simulator"
     raise RuntimeError(msg)
 
 

numba_cuda/numba/cuda/simulator/cudadrv/drvapi.py

@@ -1,4 +1,4 @@
-'''
+"""
 drvapi is not implemented in the simulator, but this module exists to allow
 tests to import correctly.
-'''
+"""

numba_cuda/numba/cuda/simulator/cudadrv/libs.py

@@ -1,2 +1,2 @@
 def check_static_lib(lib):
-    raise FileNotFoundError('Linking libraries not supported by cudasim')
+    raise FileNotFoundError("Linking libraries not supported by cudasim")

numba_cuda/numba/cuda/simulator/cudadrv/nvvm.py

@@ -1,7 +1,7 @@
-'''
+"""
 NVVM is not supported in the simulator, but stubs are provided to allow tests
 to import correctly.
-'''
+"""
 
 
 class NvvmSupportError(ImportError):
@@ -10,7 +10,7 @@ class NvvmSupportError(ImportError):
 
 class NVVM(object):
     def __init__(self):
-        raise NvvmSupportError('NVVM not supported in the simulator')
+        raise NvvmSupportError("NVVM not supported in the simulator")
 
 
 CompilationUnit = None

numba_cuda/numba/cuda/simulator/cudadrv/runtime.py

@@ -1,7 +1,7 @@
-'''
+"""
 The runtime API is unsupported in the simulator, but some stubs are
 provided to allow tests to import correctly.
-'''
+"""
 
 
 class FakeRuntime(object):
@@ -13,7 +13,7 @@ class FakeRuntime(object):
 
     @property
     def supported_versions(self):
-        return (-1, -1),
+        return ((-1, -1),)
 
 
 runtime = FakeRuntime()