cuda.core: accept dict for XyzOptions that are extension types

cuda_core/cuda/core/_context.pyx

@@ -8,6 +8,8 @@ from collections.abc import Sequence
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
+import cython
+
 from cuda.bindings cimport cydriver
 from cuda.core._device_resources cimport DeviceResources, SMResource, WorkqueueResource
 from cuda.core._device_resources import SMResource, WorkqueueResource
@@ -99,6 +101,7 @@ cdef class Context:
         Context_check_open(self)
         return DeviceResources._init_from_ctx(self._h_context, self._device_id)
 
+    @cython.annotation_typing(False)
     def create_stream(self, options: StreamOptions | None = None) -> Stream:
         """Create a new stream bound to this green context.
 

cuda_core/cuda/core/_memory/_device_memory_resource.pyx

@@ -20,6 +20,8 @@ from cuda.core._utils.cuda_utils cimport (
     check_or_create_options,
     HANDLE_RETURN,
 )
+
+import cython
 from dataclasses import dataclass
 import multiprocessing
 import platform  # no-cython-lint
@@ -146,6 +148,7 @@ cdef class DeviceMemoryResource(_MemPool):
     def __cinit__(self, *args, **kwargs) -> None:
         self._dev_id = cydriver.CU_DEVICE_INVALID
 
+    @cython.annotation_typing(False)
     def __init__(
         self,
         device_id: Device | int,

cuda_core/cuda/core/_memory/_managed_memory_resource.pyx

@@ -13,6 +13,7 @@ from cuda.core._utils.cuda_utils cimport HANDLE_RETURN
 from cuda.core._utils.cuda_utils cimport check_or_create_options  # no-cython-lint
 from cuda.core._utils.cuda_utils import CUDAError  # no-cython-lint
 
+import cython
 from dataclasses import dataclass
 import threading
 from typing import TYPE_CHECKING
@@ -97,6 +98,7 @@ cdef class ManagedMemoryResource(_MemPool):
     memory pools.
     """
 
+    @cython.annotation_typing(False)
     def __init__(self, options: ManagedMemoryResourceOptions | None = None) -> None:
         _MMR_init(self, options)
 

cuda_core/cuda/core/_memory/_pinned_memory_resource.pyx

@@ -21,6 +21,7 @@ from cuda.core._utils.cuda_utils cimport (
     HANDLE_RETURN,
 )
 
+import cython
 from dataclasses import dataclass
 import multiprocessing
 import platform  # no-cython-lint
@@ -109,6 +110,7 @@ cdef class PinnedMemoryResource(_MemPool):
     See :class:`DeviceMemoryResource` for more details on IPC usage patterns.
     """
 
+    @cython.annotation_typing(False)
     def __init__(self, options: PinnedMemoryResourceOptions | None = None) -> None:
         _PMR_init(self, options)
 

cuda_core/cuda/core/_stream.pyx

@@ -123,6 +123,7 @@ cdef class Stream:
         return Stream._from_handle(cls, get_per_thread_stream())
 
     @classmethod
+    @cython.annotation_typing(False)
     def _init(cls, obj: IsStreamType | None = None, options: StreamOptions | None = None,
               device_id: int | None = None, ctx: Context | None = None) -> Stream:
         cdef StreamHandle h_stream

cuda_core/tests/memory/test_backward_compatibility.py

@@ -0,0 +1,49 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Backward-compatibility checks for undocumented dict options in MR constructors."""
+
+import pytest
+from helpers.constants import POOL_SIZE
+from helpers.memory import (
+    create_managed_memory_resource_or_skip,
+    create_pinned_memory_resource_or_xfail,
+    skip_if_managed_memory_unsupported,
+    skip_if_pinned_memory_unsupported,
+)
+
+from cuda.core import Device, DeviceMemoryResource
+
+
+@pytest.mark.agent_authored(model="gpt-5.3-codex")
+def test_device_mr_accepts_dict_keyword(init_cuda):
+    device = Device()
+    if not device.properties.memory_pools_supported:
+        pytest.skip("Device does not support memory pool operations")
+    device.set_current()
+    mr = DeviceMemoryResource(device, options={"max_size": POOL_SIZE})
+    buf = mr.allocate(64, stream=device.default_stream)
+    buf.close(stream=device.default_stream)
+    mr.close()
+
+
+@pytest.mark.agent_authored(model="gpt-5.3-codex")
+def test_pinned_mr_accepts_dict_keyword(init_cuda):
+    device = Device()
+    skip_if_pinned_memory_unsupported(device)
+    device.set_current()
+    mr = create_pinned_memory_resource_or_xfail(options={"max_size": POOL_SIZE}, xfail_device=device)
+    buf = mr.allocate(64, stream=device.default_stream)
+    buf.close(stream=device.default_stream)
+    mr.close()
+
+
+@pytest.mark.agent_authored(model="gpt-5.3-codex")
+def test_managed_mr_accepts_dict_keyword(init_cuda):
+    device = Device()
+    skip_if_managed_memory_unsupported(device)
+    device.set_current()
+    mr = create_managed_memory_resource_or_skip(options={})
+    buf = mr.allocate(64, stream=device.default_stream)
+    buf.close(stream=device.default_stream)
+    mr.close()

cuda_core/tests/test_stream.py

@@ -28,6 +28,14 @@ def test_stream_init_with_options(init_cuda):
     assert stream.priority == 0
 
 
+@pytest.mark.agent_authored(model="glm-5.2")
+def test_stream_init_with_dict_options(init_cuda):
+    """Device.create_stream accepts a plain dict for options (backward compat)."""
+    stream = Device().create_stream(options={"nonblocking": True, "priority": 0})
+    assert stream.is_nonblocking is True
+    assert stream.priority == 0
+
+
 def test_stream_handle(init_cuda):
     stream = Device().create_stream(options=StreamOptions())
     assert isinstance(stream.handle, driver.CUstream)