Use Python properties for Cython descriptors

Author: kkraus14

cuda_core/cuda/core/_context.pyx

@@ -77,8 +77,7 @@ cdef class Context:
             return False
         return get_context_green_ctx(self._h_context).get() != NULL
 
-    @property
-    def resources(self) -> DeviceResources:
+    def _get_resources(self) -> DeviceResources:
         """Query the hardware resources provisioned for this context.
 
         For green contexts, returns the resources this context was created
@@ -91,6 +90,8 @@ cdef class Context:
             raise RuntimeError("Cannot query resources on a closed context")
         return DeviceResources._init_from_ctx(self._h_context, self._device_id)
 
+    resources = property(_get_resources)
+
     def create_stream(self, options: StreamOptions | None = None):
         """Create a new stream bound to this green context.
 

cuda_core/cuda/core/_device_resources.pyx

@@ -622,8 +622,7 @@ cdef class DeviceResources:
             self._query_sm(&res)
         return SMResource._from_dev_resource(res, self._device_id)
 
-    @property
-    def workqueue(self) -> WorkqueueResource:
+    def _get_workqueue(self) -> WorkqueueResource:
         """Return the :obj:`WorkqueueResource` for this device or context."""
         _check_green_ctx_support()
         _check_workqueue_support()
@@ -678,3 +677,5 @@ cdef class DeviceResources:
             raise RuntimeError(
                 "WorkqueueResource requires cuda.core to be built with CUDA 13.x bindings"
             )
+
+    workqueue = property(_get_workqueue)

cuda_core/cuda/core/_event.pyx

@@ -197,8 +197,7 @@ cdef class Event:
     def __repr__(self) -> str:
         return f"<Event handle={as_intptr(self._h_event):#x}>"
 
-    @property
-    def ipc_descriptor(self) -> IPCEventDescriptor:
+    def _get_ipc_descriptor(self) -> IPCEventDescriptor:
         """Descriptor for sharing this event with other processes."""
         if self._ipc_descriptor is not None:
             return self._ipc_descriptor
@@ -211,6 +210,8 @@ cdef class Event:
         self._ipc_descriptor = IPCEventDescriptor._init(data_b, get_event_is_blocking_sync(self._h_event))
         return self._ipc_descriptor
 
+    ipc_descriptor = property(_get_ipc_descriptor)
+
     @classmethod
     def from_ipc_descriptor(cls, ipc_descriptor: IPCEventDescriptor) -> Event:
         """Import an event that was exported from another process.

cuda_core/cuda/core/_memory/_buffer.pyx

@@ -190,13 +190,14 @@ cdef class Buffer:
         """
         return _ipc.Buffer_from_ipc_descriptor(cls, mr, ipc_descriptor, stream)
 
-    @property
-    def ipc_descriptor(self) -> IPCBufferDescriptor:
+    def _get_ipc_descriptor(self) -> IPCBufferDescriptor:
         """Descriptor for sharing this buffer with other processes."""
         if self._ipc_data is None:
             self._ipc_data = IPCDataForBuffer(_ipc.Buffer_get_ipc_descriptor(self), False)
         return self._ipc_data.ipc_descriptor
 
+    ipc_descriptor = property(_get_ipc_descriptor)
+
     def close(self, stream: Stream | GraphBuilder | None = None):
         """Deallocate this buffer asynchronously on the given stream.
 

cuda_core/cuda/core/_memory/_device_memory_resource.pyx

@@ -190,8 +190,7 @@ cdef class DeviceMemoryResource(_MemPool):
         mr._dev_id = Device(device_id).device_id
         return mr
 
-    @property
-    def allocation_handle(self) -> IPCAllocationHandle:
+    def _get_allocation_handle(self) -> IPCAllocationHandle:
         """Shareable handle for this memory pool (requires IPC).
 
         The handle can be used to share the memory pool with other processes.
@@ -201,6 +200,8 @@ cdef class DeviceMemoryResource(_MemPool):
             raise RuntimeError("Memory resource is not IPC-enabled")
         return self._ipc_data._alloc_handle
 
+    allocation_handle = property(_get_allocation_handle)
+
     @property
     def device_id(self) -> int:
         """The associated device ordinal."""

cuda_core/cuda/core/_memory/_pinned_memory_resource.pyx

@@ -148,8 +148,7 @@ cdef class PinnedMemoryResource(_MemPool):
             _ipc.MP_from_allocation_handle(cls, alloc_handle))
         return mr
 
-    @property
-    def allocation_handle(self) -> IPCAllocationHandle:
+    def _get_allocation_handle(self) -> IPCAllocationHandle:
         """Shareable handle for this memory pool (requires IPC).
 
         The handle can be used to share the memory pool with other processes.
@@ -159,6 +158,8 @@ cdef class PinnedMemoryResource(_MemPool):
             raise RuntimeError("Memory resource is not IPC-enabled")
         return self._ipc_data._alloc_handle
 
+    allocation_handle = property(_get_allocation_handle)
+
     @property
     def device_id(self) -> int:
         """Return -1. Pinned memory is host memory and is not associated with a specific device."""

cuda_core/cuda/core/graph/_graph_builder.pyx

@@ -300,8 +300,7 @@ class GraphBuilder:
             handle_return(driver.cuStreamBeginCapture(self._mnff.stream.handle, capture_mode))
         return self
 
-    @property
-    def is_building(self) -> bool:
+    def _get_is_building(self) -> bool:
         """Returns True if the graph builder is currently building."""
         capture_status = handle_return(driver.cuStreamGetCaptureInfo(self._mnff.stream.handle))[0]
         if capture_status == driver.CUstreamCaptureStatus.CU_STREAM_CAPTURE_STATUS_NONE:
@@ -315,6 +314,8 @@ class GraphBuilder:
         else:
             raise NotImplementedError(f"Unsupported capture status type received: {capture_status}")
 
+    is_building = property(_get_is_building)
+
     def end_building(self) -> GraphBuilder:
         """Ends the building process."""
         if not self.is_building:

cuda_core/cuda/core/system/_device.pyx

@@ -259,15 +259,16 @@ cdef class Device:
         """
         return self.pci_info.bus_id
 
-    @property
-    def numa_node_id(self) -> int:
+    def _get_numa_node_id(self) -> int:
         """
         The NUMA node of the given GPU device.
 
         This only applies to platforms where the GPUs are NUMA nodes.
         """
         return nvml.device_get_numa_node_id(self._handle)
 
+    numa_node_id = property(_get_numa_node_id)
+
     @property
     def arch(self) -> DeviceArch:
         """
@@ -332,13 +333,14 @@ cdef class Device:
         """
         return nvml.device_get_minor_number(self._handle)
 
-    @property
-    def is_c2c_enabled(self) -> bool:
+    def _get_is_c2c_enabled(self) -> bool:
         """
         Whether the C2C (Chip-to-Chip) mode is enabled for this device.
         """
         return bool(nvml.device_get_c2c_mode_info_v(self._handle).is_c2c_enabled)
 
+    is_c2c_enabled = property(_get_is_c2c_enabled)
+
     @property
     def is_persistence_mode_enabled(self) -> bool:
         """
@@ -575,8 +577,7 @@ cdef class Device:
         """
         return ClockInfo(self._handle, clock_type)
 
-    @property
-    def is_auto_boosted_clocks_enabled(self) -> tuple[bool, bool]:
+    def _get_is_auto_boosted_clocks_enabled(self) -> tuple[bool, bool]:
         """
         Retrieve the current state of auto boosted clocks on a device.
 
@@ -601,8 +602,9 @@ cdef class Device:
         current, default = nvml.device_get_auto_boosted_clocks_enabled(self._handle)
         return current == nvml.EnableState.FEATURE_ENABLED, default == nvml.EnableState.FEATURE_ENABLED
 
-    @property
-    def current_clock_event_reasons(self) -> list[ClocksEventReasons]:
+    is_auto_boosted_clocks_enabled = property(_get_is_auto_boosted_clocks_enabled)
+
+    def _get_current_clock_event_reasons(self) -> list[ClocksEventReasons]:
         """
         Retrieves the current :obj:`~ClocksEventReasons`.
 
@@ -619,8 +621,9 @@ cdef class Device:
             output_reasons.append(output_reason)
         return output_reasons
 
-    @property
-    def supported_clock_event_reasons(self) -> list[ClocksEventReasons]:
+    current_clock_event_reasons = property(_get_current_clock_event_reasons)
+
+    def _get_supported_clock_event_reasons(self) -> list[ClocksEventReasons]:
         """
         Retrieves supported :obj:`~ClocksEventReasons` that can be returned by
         :meth:`get_current_clock_event_reasons`.
@@ -640,6 +643,8 @@ cdef class Device:
             output_reasons.append(output_reason)
         return output_reasons
 
+    supported_clock_event_reasons = property(_get_supported_clock_event_reasons)
+
     ##########################################################################
     # COOLER
     # See external class definitions in _cooler.pxi
@@ -655,8 +660,7 @@ cdef class Device:
     # DEVICE ATTRIBUTES
     # See external class definitions in _device_attributes.pxi
 
-    @property
-    def attributes(self) -> DeviceAttributes:
+    def _get_attributes(self) -> DeviceAttributes:
         """
         :obj:`~_device.DeviceAttributes` object with various device attributes.
 
@@ -665,6 +669,8 @@ cdef class Device:
         """
         return DeviceAttributes(nvml.device_get_attributes_v2(self._handle))
 
+    attributes = property(_get_attributes)
+
     #########################################################################
     # DISPLAY
 

cuda_core/pixi.toml

@@ -186,9 +186,6 @@ numpy = "*"
 cuda-bindings = "*"
 cuda-pathfinder = "*"
 
-[package.target.'python_version < "3.11"'.run-dependencies]
-"backports.strenum" = "*"
-
 [target.linux.tasks.build-cython-tests]
 cmd = ["$PIXI_PROJECT_ROOT/tests/cython/build_tests.sh"]
 

cuda_core/tests/test_cython_property_descriptors.py

@@ -0,0 +1,59 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import inspect
+import types
+
+import pytest
+
+from cuda.core import (
+    Buffer,
+    Context,
+    DeviceMemoryResource,
+    DeviceResources,
+    Event,
+    PinnedMemoryResource,
+)
+from cuda.core.graph import GraphBuilder
+from cuda.core.system import CUDA_BINDINGS_NVML_IS_COMPATIBLE
+
+_PYTHON_PROPERTIES = [
+    pytest.param(DeviceMemoryResource, "allocation_handle", id="DeviceMemoryResource.allocation_handle"),
+    pytest.param(PinnedMemoryResource, "allocation_handle", id="PinnedMemoryResource.allocation_handle"),
+    pytest.param(Event, "ipc_descriptor", id="Event.ipc_descriptor"),
+    pytest.param(Buffer, "ipc_descriptor", id="Buffer.ipc_descriptor"),
+    pytest.param(Context, "resources", id="Context.resources"),
+    pytest.param(DeviceResources, "workqueue", id="DeviceResources.workqueue"),
+    pytest.param(GraphBuilder, "is_building", id="GraphBuilder.is_building"),
+]
+
+if CUDA_BINDINGS_NVML_IS_COMPATIBLE:
+    from cuda.core.system import Device as SystemDevice
+
+    _PYTHON_PROPERTIES.extend(
+        [
+            pytest.param(SystemDevice, "attributes", id="system.Device.attributes"),
+            pytest.param(
+                SystemDevice,
+                "is_auto_boosted_clocks_enabled",
+                id="system.Device.is_auto_boosted_clocks_enabled",
+            ),
+            pytest.param(SystemDevice, "is_c2c_enabled", id="system.Device.is_c2c_enabled"),
+            pytest.param(SystemDevice, "numa_node_id", id="system.Device.numa_node_id"),
+            pytest.param(SystemDevice, "current_clock_event_reasons", id="system.Device.current_clock_event_reasons"),
+            pytest.param(
+                SystemDevice,
+                "supported_clock_event_reasons",
+                id="system.Device.supported_clock_event_reasons",
+            ),
+        ]
+    )
+
+
+@pytest.mark.parametrize("cls, name", _PYTHON_PROPERTIES)
+def test_known_public_cython_properties_are_python_properties(cls, name):
+    descriptor = inspect.getattr_static(cls, name)
+
+    assert isinstance(descriptor, property)
+    assert not isinstance(descriptor, types.GetSetDescriptorType)