refactor(cuda.core): rename AccessedBySet -> AccessedBySetProxy

Align with the graph module's AdjacencySetProxy: rename the class and
inherit from collections.abc.MutableSet so the full set interface
(remove, pop, clear, |=, &=, -=, ^=, isdisjoint, subset/superset
operators, etc.) is filled in automatically from the existing add /
discard / __contains__ / __iter__ / __len__ primitives.

Add classmethod _from_iterable so binary set operators (&|^) produce
plain sets rather than constructing a buffer-less proxy. Tighten add
to TypeError on non-Device/Host inputs and discard / __contains__ to
silently ignore them, matching MutableSet contracts. The hand-rolled
__eq__ (set/frozenset comparison) is dropped: Set ABC's default
implementation handles it correctly.

Resolves PR #1775 review (Andy-Jost, 2026-05-04): naming consistency
with AdjacencySetProxy and full MutableSet conformance.

Author: rparolin

cuda_core/cuda/core/_memory/_managed_buffer.py

@@ -3,6 +3,7 @@
 
 from __future__ import annotations
 
+from collections.abc import MutableSet
 from typing import TYPE_CHECKING
 
 from cuda.core._device import Device
@@ -56,7 +57,7 @@ def _query_accessed_by(buf: Buffer) -> list[Device | Host]:
     return [Host() if v == -1 else Device(v) for v in raw if v != -2]
 
 
-class AccessedBySet:
+class AccessedBySetProxy(MutableSet):
     """Live driver-backed view of ``set_accessed_by`` advice for a managed buffer.
 
     Reads (``__contains__``, ``__iter__``, ``len(...)``) call
@@ -76,7 +77,16 @@ class AccessedBySet:
     def __init__(self, buf: ManagedBuffer):
         self._buf = buf
 
+    # Operators such as &|^ produce a plain set, not another proxy.
+    @classmethod
+    def _from_iterable(cls, it):
+        return set(it)
+
+    # --- abstract methods required by MutableSet ---
+
     def __contains__(self, location) -> bool:
+        if not isinstance(location, (Device, Host)):
+            return False
         return location in _query_accessed_by(self._buf)
 
     def __iter__(self):
@@ -85,24 +95,21 @@ def __iter__(self):
     def __len__(self) -> int:
         return len(_query_accessed_by(self._buf))
 
-    def __eq__(self, other) -> bool:
-        if isinstance(other, AccessedBySet):
-            return set(_query_accessed_by(self._buf)) == set(_query_accessed_by(other._buf))
-        if isinstance(other, (set, frozenset)):
-            return set(_query_accessed_by(self._buf)) == other
-        return NotImplemented
-
-    def __repr__(self) -> str:
-        return f"AccessedBySet({set(_query_accessed_by(self._buf))!r})"
-
     def add(self, location: Device | Host) -> None:
         """Apply ``set_accessed_by`` advice for ``location``."""
+        if not isinstance(location, (Device, Host)):
+            raise TypeError(f"expected Device or Host, got {type(location).__name__}")
         _advise_one(self._buf, _SET_ACCESSED_BY, location)
 
     def discard(self, location: Device | Host) -> None:
         """Apply ``unset_accessed_by`` advice for ``location``."""
+        if not isinstance(location, (Device, Host)):
+            return
         _advise_one(self._buf, _UNSET_ACCESSED_BY, location)
 
+    def __repr__(self) -> str:
+        return f"AccessedBySetProxy({set(_query_accessed_by(self._buf))!r})"
+
 
 class ManagedBuffer(Buffer):
     """Managed (unified) memory buffer with a property-style advice API.
@@ -194,9 +201,9 @@ def preferred_location(self, value: Device | Host | None) -> None:
             _advise_one(self, _SET_PREFERRED, value)
 
     @property
-    def accessed_by(self) -> AccessedBySet:
+    def accessed_by(self) -> AccessedBySetProxy:
         """Live set-like view of ``set_accessed_by`` locations."""
-        return AccessedBySet(self)
+        return AccessedBySetProxy(self)
 
     @accessed_by.setter
     def accessed_by(self, locations) -> None:

cuda_core/docs/source/api_private.rst

@@ -32,7 +32,7 @@ CUDA runtime
    _device.DeviceProperties
    _memory._ipc.IPCAllocationHandle
    _memory._ipc.IPCBufferDescriptor
-   _memory._managed_buffer.AccessedBySet
+   _memory._managed_buffer.AccessedBySetProxy
 
 
 CUDA graphs

cuda_core/tests/memory/test_managed_ops.py

@@ -619,7 +619,7 @@ def test_accessed_by_add_discard(self, init_cuda):
             plain.close()
 
     def test_accessed_by_read_methods(self, init_cuda):
-        """Cover __iter__, __len__, __eq__, __repr__ on AccessedBySet."""
+        """Cover __iter__, __len__, __eq__, __repr__ on AccessedBySetProxy."""
         device = Device()
         _skip_if_managed_location_ops_unsupported(device)
         device.set_current()
@@ -631,7 +631,7 @@ def test_accessed_by_read_methods(self, init_cuda):
             assert len(buf.accessed_by) == 0
             assert list(buf.accessed_by) == []
             assert buf.accessed_by == set()
-            assert "AccessedBySet" in repr(buf.accessed_by)
+            assert "AccessedBySetProxy" in repr(buf.accessed_by)
 
             # After add
             buf.accessed_by.add(device)
@@ -640,7 +640,7 @@ def test_accessed_by_read_methods(self, init_cuda):
             assert buf.accessed_by == {device}
             assert buf.accessed_by != frozenset()
 
-            # __eq__ vs another AccessedBySet on the same buffer
+            # __eq__ vs another AccessedBySetProxy on the same buffer
             assert buf.accessed_by == buf.accessed_by
         finally:
             plain.close()