[doc-only] cuda.core: add docstrings to Host properties and public StrEnum types (#2134)

* cuda.core: add docstrings to all public StrEnum types in typing.py

Each StrEnum class in cuda.core.typing now has a class-level docstring
that states its purpose and briefly describes every member value.
Sphinx and help() now show meaningful descriptions for CompilerBackendType,
GraphConditionalType, GraphMemoryType, ManagedMemoryLocationType,
ObjectCodeFormatType, PCHStatusType, SourceCodeType, VirtualMemory*.

No logic changes.

* cuda.core: add property docstrings to Host.numa_id and Host.is_numa_current

Host is a new 1.1.0 API. The class-level docstring is complete but the two
public properties had no docstrings, leaving them blank in generated API docs
and in help().

* cuda.core: fix is_numa_current phrasing and WIN32_KMT description

- is_numa_current: lead with return type (``True`` if ...) to match
  bool-property docstring convention; keep :meth:`numa_current` cross-ref
- WIN32_KMT: drop "D3DKMT" (DirectX-specific); CU_MEM_HANDLE_TYPE_WIN32_KMT
  maps to a general WDDM kernel-mode handle, not a D3D handle

* docs(typing): fix RST bullet format, accuracy issues, and version notes in StrEnum docstrings

- Convert all enum member descriptions to RST bullet list format
  (* ``MEMBER`` -- description) so Sphinx renders them as a list
  rather than a run-on paragraph
- Fix VirtualMemoryAllocationType.PINNED: remove incorrect
  "page-locked host memory" wording; backing location is
  device by default and controlled by VirtualMemoryLocationType
- Fix CompilerBackendType class summary: backend is inferred from
  Program.code_type and exposed on Program.backend, not selected
  via ProgramOptions
- Move CUDA 13+ version note from ManagedMemoryLocationType.HOST_NUMA
  to VirtualMemoryAllocationType.MANAGED (the actual 13+-gated member;
  ManagedMemoryResource already requires CUDA 13 so the HOST_NUMA note
  was misleading)
- Fix ObjectCodeFormatType summary to mention Linker.link and
  Program.as_bytes alongside Program.compile

Author: aryanputta

cuda_core/cuda/core/_host.py

@@ -62,10 +62,12 @@ def _get_or_create(cls, numa_id: int | None, is_numa_current: bool) -> Host:
 
     @property
     def numa_id(self) -> int | None:
+        """NUMA node ID, or ``None`` if not pinned to a specific NUMA node."""
         return self._numa_id
 
     @property
     def is_numa_current(self) -> bool:
+        """``True`` if this ``Host`` represents the calling thread's NUMA node (constructed via :meth:`numa_current`)."""
         return self._is_numa_current
 
     @classmethod

cuda_core/cuda/core/typing.py

@@ -43,12 +43,29 @@
 
 
 class SourceCodeType(StrEnum):
+    """Source language passed to :class:`~cuda.core.Program`.
+
+    * ``CXX`` — CUDA C++ source.
+    * ``PTX`` — PTX assembly text.
+    * ``NVVM`` — NVVM IR (LLVM bitcode).
+    """
+
     CXX = "c++"
     PTX = "ptx"
     NVVM = "nvvm"
 
 
 class ObjectCodeFormatType(StrEnum):
+    """Output format for :meth:`~cuda.core.Program.compile`, :meth:`~cuda.core.Linker.link`, and :meth:`~cuda.core.Program.as_bytes`.
+
+    * ``PTX`` — PTX assembly text.
+    * ``CUBIN`` — device-native CUDA binary.
+    * ``LTOIR`` — LTO (link-time optimization) IR for later linking.
+    * ``FATBIN`` — fat binary bundling multiple device images.
+    * ``OBJECT`` — relocatable device object.
+    * ``LIBRARY`` — device code library.
+    """
+
     PTX = "ptx"
     CUBIN = "cubin"
     LTOIR = "ltoir"
@@ -58,60 +75,129 @@ class ObjectCodeFormatType(StrEnum):
 
 
 class CompilerBackendType(StrEnum):
+    """Compiler backend inferred from the program's code type and exposed on :attr:`~cuda.core.Program.backend`.
+
+    * ``NVRTC`` — NVIDIA Runtime Compilation.
+    * ``NVVM`` — NVVM LLVM backend.
+    * ``NVJITLINK`` — nvJitLink device-side linker.
+    * ``DRIVER`` — CUDA driver PTX JIT compiler.
+    """
+
     NVRTC = "NVRTC"
     NVVM = "NVVM"
     NVJITLINK = "nvJitLink"
     DRIVER = "driver"
 
 
 class PCHStatusType(StrEnum):
+    """Precompiled-header (PCH) outcome reported by :meth:`~cuda.core.Program.compile`.
+
+    * ``CREATED`` — PCH was successfully written.
+    * ``NOT_ATTEMPTED`` — PCH creation was skipped (backend does not support it or the option was not requested).
+    * ``FAILED`` — PCH creation was attempted but failed.
+    """
+
     CREATED = "created"
     NOT_ATTEMPTED = "not_attempted"
     FAILED = "failed"
 
 
 class GraphConditionalType(StrEnum):
+    """Conditional node flavor for :class:`~cuda.core.graph.GraphBuilder`.
+
+    * ``IF`` — body graph executes at most once based on a condition.
+    * ``WHILE`` — body graph loops while the condition is true.
+    * ``SWITCH`` — selects one child graph by an integer index.
+    """
+
     IF = "if"
     WHILE = "while"
     SWITCH = "switch"
 
 
 class GraphMemoryType(StrEnum):
+    """Memory space for a graph memory-allocation or free node.
+
+    * ``DEVICE`` — GPU device memory.
+    * ``HOST`` — pinned host memory.
+    * ``MANAGED`` — CUDA managed (unified) memory.
+    """
+
     DEVICE = "device"
     HOST = "host"
     MANAGED = "managed"
 
 
 class ManagedMemoryLocationType(StrEnum):
+    """Destination type for managed-memory prefetch and advise operations.
+
+    * ``DEVICE`` — target a GPU device.
+    * ``HOST`` — target the CPU host (any NUMA node).
+    * ``HOST_NUMA`` — target a specific host NUMA node.
+    """
+
     DEVICE = "device"
     HOST = "host"
     HOST_NUMA = "host_numa"
 
 
 class VirtualMemoryHandleType(StrEnum):
+    """OS handle type for exporting virtual memory allocations across processes.
+
+    * ``POSIX_FD`` — POSIX file descriptor (Linux).
+    * ``WIN32_KMT`` — Win32 kernel-mode handle (Windows).
+    * ``FABRIC`` — NVLink/NVSwitch fabric handle for multi-node topologies.
+    """
+
     POSIX_FD = "posix_fd"
     WIN32_KMT = "win32_kmt"
     FABRIC = "fabric"
 
 
 class VirtualMemoryLocationType(StrEnum):
+    """Physical backing location for a virtual memory allocation.
+
+    * ``DEVICE`` — GPU device memory.
+    * ``HOST`` — pinned host memory.
+    * ``HOST_NUMA`` — host memory pinned to a specific NUMA node.
+    * ``HOST_NUMA_CURRENT`` — host memory on the calling thread's NUMA node.
+    """
+
     DEVICE = "device"
     HOST = "host"
     HOST_NUMA = "host_numa"
     HOST_NUMA_CURRENT = "host_numa_current"
 
 
 class VirtualMemoryGranularityType(StrEnum):
+    """Granularity query type for virtual memory allocations.
+
+    * ``MINIMUM`` — smallest allocation size supported by the device.
+    * ``RECOMMENDED`` — granularity that yields best performance on the device.
+    """
+
     MINIMUM = "minimum"
     RECOMMENDED = "recommended"
 
 
 class VirtualMemoryAccessType(StrEnum):
+    """Access permissions for a virtual memory mapping.
+
+    * ``READ_WRITE`` — both read and write access.
+    * ``READ`` — read-only access.
+    """
+
     READ_WRITE = "rw"
     READ = "r"
 
 
 class VirtualMemoryAllocationType(StrEnum):
+    """Physical memory type for a virtual memory backing allocation.
+
+    * ``PINNED`` — pinned/non-migratable physical allocation (placement via :class:`VirtualMemoryLocationType`).
+    * ``MANAGED`` — CUDA managed (unified) memory (CUDA 13+ only).
+    """
+
     PINNED = "pinned"
     MANAGED = "managed"