centralize check_or_create_options

Author: leofang

cuda_core/cuda/core/experimental/_event.pyx

@@ -4,6 +4,11 @@
 
 from __future__ import annotations
 
+from cuda.core.experimental._utils.cuda_utils cimport (
+    _check_driver_error as raise_if_driver_error,
+    check_or_create_options,
+)
+
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Optional
 
@@ -13,9 +18,6 @@ from cuda.core.experimental._utils.cuda_utils import (
     driver,
     handle_return,
 )
-from cuda.core.experimental._utils.cuda_utils import (
-    _check_driver_error as raise_if_driver_error,
-)
 
 if TYPE_CHECKING:
     import cuda.bindings
@@ -47,26 +49,6 @@ cdef class EventOptions:
     support_ipc: Optional[bool] = False
 
 
-cdef inline EventOptions check_or_create_options(options, str options_description):
-    """
-    Create the specified options dataclass from a dictionary of options or None.
-    """
-    cdef EventOptions opts
-    if options is None:
-        opts = EventOptions()
-    elif isinstance(options, dict):
-        opts = EventOptions(**options)
-    elif not isinstance(options, EventOptions):
-        raise TypeError(
-            f"The {options_description} must be provided as an object "
-            f"of type {EventOptions.__name__} or as a dict with valid {options_description}. "
-            f"The provided object is '{options}'."
-        )
-
-    return opts
-
-
-
 cdef class Event:
     """Represent a record at a specific point of execution within a CUDA stream.
 
@@ -108,7 +90,7 @@ cdef class Event:
     @classmethod
     def _init(cls, device_id: int, ctx_handle: Context, opts=None):
         cdef Event self = Event.__new__(Event)
-        cdef EventOptions options = check_or_create_options(opts, "Event options")
+        cdef EventOptions options = check_or_create_options(EventOptions, opts, "Event options")
         flags = 0x0
         self._timing_disabled = False
         self._busy_waited = False

cuda_core/cuda/core/experimental/_utils/cuda_utils.pxd

@@ -0,0 +1,8 @@
+# Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. ALL RIGHTS RESERVED.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+cpdef int _check_driver_error(error) except?-1
+cpdef int _check_runtime_error(error) except?-1
+cpdef int _check_nvrtc_error(error) except?-1
+cpdef check_or_create_options(type cls, options, str options_description=*, bint keep_none=*)

cuda_core/cuda/core/experimental/_utils/cuda_utils.pyx

@@ -1,12 +1,12 @@
 # Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. ALL RIGHTS RESERVED.
 #
-# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
+# SPDX-License-Identifier: Apache-2.0
 
 import functools
 import importlib.metadata
 from collections import namedtuple
 from collections.abc import Sequence
-from typing import Callable, Dict
+from typing import Callable
 
 try:
     from cuda.bindings import driver, nvrtc, runtime
@@ -123,27 +123,25 @@ def handle_return(tuple result, handle=None):
         return result[1:]
 
 
-def check_or_create_options(cls, options, options_description, *, keep_none=False):
+cpdef check_or_create_options(type cls, options, str options_description="", bint keep_none=False):
     """
     Create the specified options dataclass from a dictionary of options or None.
     """
-
     if options is None:
         if keep_none:
             return options
-        options = cls()
-    elif isinstance(options, Dict):
-        options = cls(**options)
-
-    if not isinstance(options, cls):
+        return cls()
+    elif isinstance(options, cls):
+        return options
+    elif isinstance(options, dict):
+        return cls(**options)
+    else:
         raise TypeError(
             f"The {options_description} must be provided as an object "
             f"of type {cls.__name__} or as a dict with valid {options_description}. "
             f"The provided object is '{options}'."
         )
 
-    return options
-
 
 def _handle_boolean_option(option: bool) -> str:
     """