pre-commit changes

Author: rparolin

cuda_core/cuda/core/_module.py

@@ -2,7 +2,6 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-import sys
 import threading
 import weakref
 from collections import namedtuple
@@ -19,7 +18,6 @@
 )
 from cuda.core._utils.cuda_utils import driver, get_binding_version, handle_return, precondition
 
-
 # Lazy initialization state and synchronization
 # For Python 3.13t (free-threaded builds), we use a lock to ensure thread-safe initialization.
 # For regular Python builds with GIL, the lock overhead is minimal and the code remains safe.
@@ -37,14 +35,15 @@
     },
 }
 
+
 def _lazy_init():
     """
     Initialize module-level state in a thread-safe manner.
-    
+
     This function is thread-safe and suitable for both:
     - Regular Python builds (with GIL)
     - Python 3.13t free-threaded builds (without GIL)
-    
+
     Uses double-checked locking pattern for performance:
     - Fast path: check without lock if already initialized
     - Slow path: acquire lock and initialize if needed
@@ -76,7 +75,7 @@ def _lazy_init():
         _driver_ver = handle_return(driver.cuDriverGetVersion())
         if _py_major_ver >= 12 and _driver_ver >= 12040:
             _backend["new"]["paraminfo"] = driver.cuKernelGetParamInfo
-        
+
         # Mark as initialized (must be last to ensure all state is set)
         _inited = True
 
@@ -102,7 +101,7 @@ def _get_kernel_ctypes():
 
 def _get_backend_version():
     """Get the backend version ("new" or "old") based on CUDA version.
-    
+
     Returns "new" for CUDA 12.0+ (uses cuLibrary API), "old" otherwise (uses cuModule API).
     """
     return "new" if (_get_py_major_ver() >= 12 and _get_driver_ver() >= 12000) else "old"
@@ -493,7 +492,7 @@ def occupancy(self) -> KernelOccupancy:
     def from_handle(handle: int, mod: "ObjectCode" = None) -> "Kernel":
         """Creates a new :obj:`Kernel` object from a foreign kernel handle.
 
-        Uses a CUfunction or CUkernel pointer address to create a new :obj:`Kernel` object. 
+        Uses a CUfunction or CUkernel pointer address to create a new :obj:`Kernel` object.
 
         Parameters
         ----------
@@ -505,26 +504,26 @@ def from_handle(handle: int, mod: "ObjectCode" = None) -> "Kernel":
             a placeholder ObjectCode will be created. Note that without a proper
             ObjectCode, certain operations may be limited.
         """
-        
+
         # Validate that handle is an integer
         if not isinstance(handle, int):
             raise TypeError(f"handle must be an integer, got {type(handle).__name__}")
-        
+
         # Convert the integer handle to the appropriate driver type
         if _get_py_major_ver() >= 12 and _get_driver_ver() >= 12000:
             # Try CUkernel first for newer CUDA versions
             kernel_obj = driver.CUkernel(handle)
         else:
             # Use CUfunction for older versions
             kernel_obj = driver.CUfunction(handle)
-        
+
         # If no module provided, create a placeholder
         if mod is None:
             # Create a placeholder ObjectCode that won't try to load anything
             mod = ObjectCode._init(b"", "cubin")
             # Set a dummy handle to prevent lazy loading
             mod._handle = 1  # Non-null placeholder
-        
+
         return Kernel._from_obj(kernel_obj, mod)
 
 
@@ -694,7 +693,9 @@ def from_library(module: Union[bytes, str], *, name: str = "", symbol_mapping: d
         return ObjectCode._init(module, "library", name=name, symbol_mapping=symbol_mapping)
 
     @staticmethod
-    def from_handle(handle: int, code_type: str = "cubin", *, name: str = "", symbol_mapping: dict | None = None) -> "ObjectCode":
+    def from_handle(
+        handle: int, code_type: str = "cubin", *, name: str = "", symbol_mapping: dict | None = None
+    ) -> "ObjectCode":
         """Create a new :obj:`ObjectCode` object from a foreign module handle.
 
         Uses a CUmodule or CUlibrary pointer address to create a new :obj:`ObjectCode` object.
@@ -718,13 +719,13 @@ def from_handle(handle: int, code_type: str = "cubin", *, name: str = "", symbol
         # Create an ObjectCode instance with a placeholder module
         # The handle will be set directly, bypassing the lazy loading
         obj = ObjectCode._init(b"", code_type, name=name, symbol_mapping=symbol_mapping)
-        
+
         # Set the handle directly from the foreign handle
         if obj._backend_version == "new":
             obj._handle = driver.CUlibrary(handle)
         else:
             obj._handle = driver.CUmodule(handle)
-        
+
         return obj
 
     # TODO: do we want to unload in a finalizer? Probably not..

cuda_core/cuda/core/_program.py

@@ -902,32 +902,29 @@ def from_handle(handle: int, backend: str, options: ProgramOptions = None) -> Pr
         backend = backend.upper()
         if backend not in ("NVRTC", "NVVM"):
             raise ValueError(f"Unsupported backend '{backend}'. Must be 'NVRTC' or 'NVVM'")
-        
+
         # Create a new Program instance without going through __init__
         prog = object.__new__(Program)
-        
+
         # Initialize the members needed for finalization
         # Note: We pass None as the program_obj to avoid finalization since
         # we don't own the handle
-        prog._mnff = Program._MembersNeededForFinalize.__new__(
-            Program._MembersNeededForFinalize
-        )
+        prog._mnff = Program._MembersNeededForFinalize.__new__(Program._MembersNeededForFinalize)
         prog._mnff.handle = None  # Don't manage the foreign handle
         prog._mnff.backend = backend
-        
+
         # Store the backend and options
         prog._backend = backend
         prog._options = check_or_create_options(ProgramOptions, options, "Program options")
         prog._linker = None
-        
+
         # Store the handle directly without taking ownership
         # This means the finalizer won't destroy it
         if backend == "NVRTC":
             prog._mnff.handle = nvrtc.nvrtcProgram(handle)
         elif backend == "NVVM":
-            nvvm_module = _get_nvvm_module()
             # For NVVM, we just store the handle as-is
             # The actual NVVM program handle is opaque
             prog._mnff.handle = handle
-        
+
         return prog

cuda_core/tests/test_module.py

@@ -492,6 +492,7 @@ def test_kernel_from_handle_no_module(get_saxpy_kernel_cubin):
 
 # Edge case tests for from_handle methods
 
+
 @pytest.mark.parametrize(
     "invalid_code_type,expected_error",
     [
@@ -536,11 +537,7 @@ def test_object_code_from_handle_symbol_mapping_with_valid_handle(get_saxpy_kern
     original_handle = int(original_objcode.handle)
 
     # Create ObjectCode with correct symbol mapping
-    objcode_with_map = ObjectCode.from_handle(
-        original_handle,
-        "cubin",
-        symbol_mapping=original_objcode._sym_map
-    )
+    objcode_with_map = ObjectCode.from_handle(original_handle, "cubin", symbol_mapping=original_objcode._sym_map)
 
     # Should successfully get kernel using unmangled name from symbol_mapping
     kernel = objcode_with_map.get_kernel("saxpy<float>")
@@ -616,7 +613,7 @@ def test_object_code_from_handle_multiple_instances(get_saxpy_kernel_cubin):
         pytest.param({"handle": 123}, id="dict"),
         pytest.param([456], id="list"),
         pytest.param((789,), id="tuple"),
-        pytest.param(3+4j, id="complex"),
+        pytest.param(3 + 4j, id="complex"),
         pytest.param(b"\xde\xad\xbe\xef", id="bytes"),
         pytest.param({999}, id="set"),
         pytest.param(object(), id="object"),