Privatize the Python-imported symbols in utils.pxi.in

Author: mdboom

cuda_bindings/cuda/bindings/_lib/utils.pxi.in

@@ -6,11 +6,10 @@ from libc.stdlib cimport calloc, free
 from libc.stdint cimport int32_t, uint32_t, int64_t, uint64_t
 from libc.stddef cimport wchar_t
 from libc.string cimport memcpy
-from enum import Enum
-from typing import List, Tuple
-import ctypes
+from enum import Enum as _Enum
+import ctypes as _ctypes
 cimport cuda.bindings.cydriver as cydriver
-import cuda.bindings.driver as driver
+import cuda.bindings.driver as _driver
 cimport cuda.bindings._lib.param_packer as param_packer
 
 cdef void* _callocWrapper(length, size):
@@ -21,25 +20,25 @@ cdef void* _callocWrapper(length, size):
 
 cdef class _HelperKernelParams:
     supported_types = { # excluding void_p and None, which are handled specially
-        ctypes.c_bool,
-        ctypes.c_char,
-        ctypes.c_wchar,
-        ctypes.c_byte,
-        ctypes.c_ubyte,
-        ctypes.c_short,
-        ctypes.c_ushort,
-        ctypes.c_int,
-        ctypes.c_uint,
-        ctypes.c_long,
-        ctypes.c_ulong,
-        ctypes.c_longlong,
-        ctypes.c_ulonglong,
-        ctypes.c_size_t,
-        ctypes.c_float,
-        ctypes.c_double
+        _ctypes.c_bool,
+        _ctypes.c_char,
+        _ctypes.c_wchar,
+        _ctypes.c_byte,
+        _ctypes.c_ubyte,
+        _ctypes.c_short,
+        _ctypes.c_ushort,
+        _ctypes.c_int,
+        _ctypes.c_uint,
+        _ctypes.c_long,
+        _ctypes.c_ulong,
+        _ctypes.c_longlong,
+        _ctypes.c_ulonglong,
+        _ctypes.c_size_t,
+        _ctypes.c_float,
+        _ctypes.c_double
     }
 
-    max_param_size = max(ctypes.sizeof(max(_HelperKernelParams.supported_types, key=lambda t:ctypes.sizeof(t))), sizeof(void_ptr))
+    max_param_size = max(_ctypes.sizeof(max(_HelperKernelParams.supported_types, key=lambda t:_ctypes.sizeof(t))), sizeof(void_ptr))
 
     def __cinit__(self, kernelParams):
         self._pyobj_acquired = False
@@ -56,7 +55,7 @@ cdef class _HelperKernelParams:
                 raise RuntimeError("Argument 'kernelParams' failed to retrieve buffer through Buffer Protocol")
             self._pyobj_acquired = True
             self._ckernelParams = <void**><void_ptr>self._pybuffer.buf
-        elif isinstance(kernelParams, (Tuple)) and len(kernelParams) == 2 and isinstance(kernelParams[0], (Tuple)) and isinstance(kernelParams[1], (Tuple)):
+        elif isinstance(kernelParams, (tuple)) and len(kernelParams) == 2 and isinstance(kernelParams[0], (tuple)) and isinstance(kernelParams[1], (tuple)):
             # Hard run, construct and fill out contigues memory using provided kernel values and types based
             if len(kernelParams[0]) != len(kernelParams[1]):
                 raise TypeError("Argument 'kernelParams' has tuples with different length")
@@ -73,44 +72,44 @@ cdef class _HelperKernelParams:
                     # special cases for None
                     if callable(getattr(value, 'getPtr', None)):
                         self._ckernelParams[idx] = <void*><void_ptr>value.getPtr()
-                    elif isinstance(value, (ctypes.Structure)):
-                        self._ckernelParams[idx] = <void*><void_ptr>ctypes.addressof(value)
-                    elif isinstance(value, (Enum)):
+                    elif isinstance(value, (_ctypes.Structure)):
+                        self._ckernelParams[idx] = <void*><void_ptr>_ctypes.addressof(value)
+                    elif isinstance(value, (_Enum)):
                         self._ckernelParams[idx] = &(self._ckernelParamsData[data_idx])
                         (<int*>self._ckernelParams[idx])[0] = value.value
                         data_idx += sizeof(int)
                     else:
-                        raise TypeError("Provided argument is of type {} but expected Type {}, {} or CUDA Binding structure with getPtr() attribute".format(type(value), type(ctypes.Structure), type(ctypes.c_void_p)))
+                        raise TypeError("Provided argument is of type {} but expected Type {}, {} or CUDA Binding structure with getPtr() attribute".format(type(value), type(_ctypes.Structure), type(_ctypes.c_void_p)))
                 elif ctype in _HelperKernelParams.supported_types:
                     self._ckernelParams[idx] = &(self._ckernelParamsData[data_idx])
 
                     # handle case where a float is passed as a double
-                    if ctype == ctypes.c_double and isinstance(value, ctypes.c_float):
+                    if ctype == _ctypes.c_double and isinstance(value, _ctypes.c_float):
                         value = ctype(value.value)
                     if not isinstance(value, ctype): # make it a ctype
                         size = param_packer.feed(self._ckernelParams[idx], value, ctype)
                         if size == 0: # feed failed
                             value = ctype(value)
-                            size = ctypes.sizeof(ctype)
-                            addr = <void*>(<void_ptr>ctypes.addressof(value))
+                            size = _ctypes.sizeof(ctype)
+                            addr = <void*>(<void_ptr>_ctypes.addressof(value))
                             memcpy(self._ckernelParams[idx], addr, size)
                     else:
-                        size = ctypes.sizeof(ctype)
-                        addr = <void*>(<void_ptr>ctypes.addressof(value))
+                        size = _ctypes.sizeof(ctype)
+                        addr = <void*>(<void_ptr>_ctypes.addressof(value))
                         memcpy(self._ckernelParams[idx], addr, size)
                     data_idx += size
-                elif ctype == ctypes.c_void_p:
+                elif ctype == _ctypes.c_void_p:
                     # special cases for void_p
-                    if isinstance(value, (int, ctypes.c_void_p)):
+                    if isinstance(value, (int, _ctypes.c_void_p)):
                         self._ckernelParams[idx] = &(self._ckernelParamsData[data_idx])
-                        (<void_ptr*>self._ckernelParams[idx])[0] = value.value if isinstance(value, (ctypes.c_void_p)) else value
+                        (<void_ptr*>self._ckernelParams[idx])[0] = value.value if isinstance(value, (_ctypes.c_void_p)) else value
                         data_idx += sizeof(void_ptr)
                     elif callable(getattr(value, 'getPtr', None)):
                         self._ckernelParams[idx] = &(self._ckernelParamsData[data_idx])
                         (<void_ptr*>self._ckernelParams[idx])[0] = value.getPtr()
                         data_idx += sizeof(void_ptr)
                     else:
-                        raise TypeError("Provided argument is of type {} but expected Type {}, {} or CUDA Binding structure with getPtr() attribute".format(type(value), type(int), type(ctypes.c_void_p)))
+                        raise TypeError("Provided argument is of type {} but expected Type {}, {} or CUDA Binding structure with getPtr() attribute".format(type(value), type(int), type(_ctypes.c_void_p)))
                 else:
                     raise TypeError("Unsupported type: " + str(type(ctype)))
                 idx += 1
@@ -136,7 +135,7 @@ cdef class _HelperInputVoidPtr:
         elif isinstance(ptr, (int)):
             # Easy run, user gave us an already configured void** address
             self._cptr = <void*><void_ptr>ptr
-        elif isinstance(ptr, (driver.CUdeviceptr)):
+        elif isinstance(ptr, (_driver.CUdeviceptr)):
             self._cptr = <void*><void_ptr>int(ptr)
         elif PyObject_CheckBuffer(ptr):
             # Easy run, get address from Python Buffer Protocol
@@ -173,7 +172,7 @@ cdef class _HelperCUmemPool_attribute:
                             {{if 'CU_MEMPOOL_ATTR_USED_MEM_CURRENT'}}cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_CURRENT,{{endif}}
                             {{if 'CU_MEMPOOL_ATTR_USED_MEM_HIGH'}}cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_HIGH,{{endif}}):
             if self._is_getter:
-                self._cuuint64_t_val = driver.cuuint64_t()
+                self._cuuint64_t_val = _driver.cuuint64_t()
                 self._cptr = <void*><void_ptr>self._cuuint64_t_val.getPtr()
             else:
                 self._cptr = <void*><void_ptr>init_value.getPtr()
@@ -244,7 +243,7 @@ cdef class _HelperCUpointer_attribute:
         self._attr = attr.value
         if self._attr in ({{if 'CU_POINTER_ATTRIBUTE_CONTEXT'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_CONTEXT,{{endif}}):
             if self._is_getter:
-                self._ctx = driver.CUcontext()
+                self._ctx = _driver.CUcontext()
                 self._cptr = <void*><void_ptr>self._ctx.getPtr()
             else:
                 self._cptr = <void*><void_ptr>init_value.getPtr()
@@ -258,7 +257,7 @@ cdef class _HelperCUpointer_attribute:
         elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_DEVICE_POINTER'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_DEVICE_POINTER,{{endif}}
                             {{if 'CU_POINTER_ATTRIBUTE_RANGE_START_ADDR'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_RANGE_START_ADDR,{{endif}}):
             if self._is_getter:
-                self._devptr = driver.CUdeviceptr()
+                self._devptr = _driver.CUdeviceptr()
                 self._cptr = <void*><void_ptr>self._devptr.getPtr()
             else:
                 self._cptr = <void*><void_ptr>init_value.getPtr()
@@ -267,7 +266,7 @@ cdef class _HelperCUpointer_attribute:
             self._cptr = <void*>&self._void
         elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_P2P_TOKENS'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_P2P_TOKENS,{{endif}}):
             if self._is_getter:
-                self._token = driver.CUDA_POINTER_ATTRIBUTE_P2P_TOKENS()
+                self._token = _driver.CUDA_POINTER_ATTRIBUTE_P2P_TOKENS()
                 self._cptr = <void*><void_ptr>self._token.getPtr()
             else:
                 self._cptr = <void*><void_ptr>init_value.getPtr()
@@ -285,7 +284,7 @@ cdef class _HelperCUpointer_attribute:
             self._cptr = <void*>&self._size
         elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_MEMPOOL_HANDLE'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MEMPOOL_HANDLE,{{endif}}):
             if self._is_getter:
-                self._mempool = driver.CUmemoryPool()
+                self._mempool = _driver.CUmemoryPool()
                 self._cptr = <void*><void_ptr>self._mempool.getPtr()
             else:
                 self._cptr = <void*><void_ptr>init_value.getPtr()
@@ -341,7 +340,7 @@ cdef class _HelperCUgraphMem_attribute:
                           {{if 'CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT' in found_values}}cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT,{{endif}}
                           {{if 'CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH' in found_values}}cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH,{{endif}}):
             if self._is_getter:
-                self._cuuint64_t_val = driver.cuuint64_t()
+                self._cuuint64_t_val = _driver.cuuint64_t()
                 self._cptr = <void*><void_ptr>self._cuuint64_t_val.getPtr()
             else:
                 self._cptr = <void*><void_ptr>init_value.getPtr()
@@ -554,7 +553,7 @@ cdef class _HelperCUmemAllocationHandleType:
         {{endif}}
         {{if 'CU_MEM_HANDLE_TYPE_FABRIC' in found_values}}
         elif self._type in (cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_FABRIC,):
-            self._mem_fabric_handle = driver.CUmemFabricHandle()
+            self._mem_fabric_handle = _driver.CUmemFabricHandle()
             self._cptr = <void*><void_ptr>self._mem_fabric_handle.getPtr()
         {{endif}}
         else: