fix(core): validate Host(is_numa_current=...) as a bool

`Host.__new__` validates `numa_id` carefully -- including an explicit bool
rejection whose comment spells out why:

    # bool is an int subclass; reject explicitly so Host(True) doesn't
    # alias Host(1) (and vice versa) in the singleton cache.

`is_numa_current` gets no validation at all, even though it lands in the
same process-wide singleton cache key and is stored verbatim as the
`is_numa_current` property. The same aliasing hazard applies from the other
side:

    >>> Host(is_numa_current=1)          # int, not True
    >>> h = Host.numa_current()
    >>> h.is_numa_current
    1
    >>> h.is_numa_current is True
    False

`(None, 1)` and `(None, True)` are the same dict key, so whichever call runs
first wins for the lifetime of the process -- and `test_host.py` already
asserts `Host.numa_current().is_numa_current is True`, which that first call
turns into an order-dependent failure.

Non-int truthy values are worse: they mint a second singleton instead of
poisoning the first.

    >>> dup = Host(is_numa_current="yes")
    >>> repr(dup)
    'Host.numa_current()'
    >>> dup is Host.numa_current(), dup == Host.numa_current()
    (False, False)

Both coerce to the same `_LocSpec(kind="host_numa_current")`, so they name
one physical location while breaking the documented "constructor calls with
the same arguments return the same instance" contract and the identity-based
set arithmetic in `ManagedBuffer.accessed_by`.

`is_numa_current=0` and `=None` are equally unhandled: they are falsy, so
they seed the *generic* `Host()` singleton with a non-bool
`is_numa_current`. And an unhashable value reaches the cache lookup and
raises `TypeError: unhashable type` out of the constructor.

Require a real bool, mirroring the numa_id check.

Author: LeSingh1

cuda_core/cuda/core/_host.py

@@ -47,6 +47,15 @@ def __new__(cls, numa_id: int | None = None, *, is_numa_current: bool = False) -
             raise ValueError("numa_id and is_numa_current are mutually exclusive")
         if numa_id is not None and (isinstance(numa_id, bool) or not isinstance(numa_id, int) or numa_id < 0):
             raise ValueError(f"numa_id must be a non-negative int, got {numa_id!r}")
+        # Require a real bool for the same reason numa_id rejects one: the
+        # value goes straight into the singleton cache key and into the
+        # is_numa_current property. `1` and `True` are the same dict key, so
+        # `Host(is_numa_current=1)` would hand `Host.numa_current()` an
+        # instance whose is_numa_current is the int 1 for the rest of the
+        # process, and any other truthy value would create a second,
+        # non-identical "numa_current" singleton.
+        if not isinstance(is_numa_current, bool):
+            raise ValueError(f"is_numa_current must be a bool, got {is_numa_current!r}")
         return cls._get_or_create(numa_id, is_numa_current)
 
     @classmethod

cuda_core/docs/source/release/1.2.0-notes.rst

@@ -73,6 +73,14 @@ Fixes and enhancements
   Windows, both ``ctypes.CFUNCTYPE`` and ``ctypes.WINFUNCTYPE`` are accepted.
   (`#2439 <https://github.com/NVIDIA/cuda-python/issues/2439>`__)
 
+- :class:`Host` now requires ``is_numa_current`` to be a ``bool``, matching the
+  existing ``numa_id`` validation. The value was stored verbatim in the
+  process-wide singleton cache and in :attr:`Host.is_numa_current`, so
+  ``Host(is_numa_current=1)`` made :meth:`Host.numa_current` return an instance
+  whose ``is_numa_current`` was the int ``1``, and any other truthy value
+  created a second ``Host.numa_current()`` that compared unequal to the real
+  one while sharing its ``repr``.
+
 Deprecation Notices
 -------------------
 

cuda_core/tests/test_host.py

@@ -34,6 +34,29 @@ def test_numa_id_rejects_bool(self):
         with pytest.raises(ValueError, match="numa_id must be a non-negative int"):
             Host(numa_id=False)
 
+    @pytest.mark.agent_authored(model="claude-opus-5")
+    @pytest.mark.parametrize("value", [1, 0, "yes", None, []], ids=["int-1", "int-0", "str", "none", "list"])
+    def test_is_numa_current_rejects_non_bool(self, value):
+        # Same hazard as test_numa_id_rejects_bool, from the other side: the
+        # value lands in the singleton cache key and in the is_numa_current
+        # property untouched. `1` and `True` hash and compare equal, so
+        # Host(is_numa_current=1) would seed the numa_current singleton with
+        # an instance whose is_numa_current is the int 1 -- process-wide, and
+        # for whichever call happens to come first. Any other truthy value
+        # would mint a second "numa_current" that is neither `is` nor `==` the
+        # real one while sharing its repr.
+        with pytest.raises(ValueError, match="is_numa_current must be a bool"):
+            Host(is_numa_current=value)
+
+    @pytest.mark.agent_authored(model="claude-opus-5")
+    def test_numa_current_singleton_survives_a_rejected_construction(self):
+        with pytest.raises(ValueError, match="is_numa_current must be a bool"):
+            Host(is_numa_current=1)
+
+        h = Host.numa_current()
+        assert h.is_numa_current is True
+        assert h is Host(is_numa_current=True)
+
     def test_numa_current_constructor_and_classmethod_agree(self):
         # Host(is_numa_current=True) and Host.numa_current() return the same singleton.
         assert Host(is_numa_current=True) is Host.numa_current()