datahold 4.0.0.dev25__tar.gz → 4.0.0.dev27__tar.gz

{datahold-4.0.0.dev25 → datahold-4.0.0.dev27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datahold
-Version: 4.0.0.dev25
+Version: 4.0.0.dev27
 Summary: This project wraps common mutable datastructures for inheritance with modification.
 Author-email: Johannes <johannes.programming@gmail.com>
 License-Expression: MIT

{datahold-4.0.0.dev25 → datahold-4.0.0.dev27}/pyproject.toml

@@ -31,7 +31,7 @@ license-files = [
 name = "datahold"
 readme = "README.rst"
 requires-python = ">=3.11"
-version = "4.0.0.dev25"
+version = "4.0.0.dev27"
 
 [project.urls]
 Download = "https://pypi.org/project/datahold/#files"

{datahold-4.0.0.dev25 → datahold-4.0.0.dev27}/src/datahold/__init__.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 __all__: list[str] = [
     "Collection",
     "DictLike",
-    "DictSlot",
     "FrozenDictLike",
     "FrozenDictSlot",
     "FrozenListLike",
@@ -13,7 +12,6 @@ __all__: list[str] = [
     "FrozenSetLike",
     "FrozenSetSlot",
     "ListLike",
-    "ListSlot",
     "Mapping",
     "MutableDictLike",
     "MutableDictSlot",
@@ -27,7 +25,6 @@ __all__: list[str] = [
     "Sequence",
     "Set",
     "SetLike",
-    "SetSlot",
 ]
 
 from abc import abstractmethod
@@ -263,12 +260,12 @@ class SetLike[Item: abc.Hashable](Set[Item]):
         return type(self)(self.__frozen__().intersection(*others))
 
     @setdoc.basic
-    def issubset(self: Self, other: abc.Iterable[abc.Hashable], /) -> Self:
-        return type(self)(self.__frozen__().issubset(other))  # type: ignore
+    def issubset(self: Self, other: abc.Iterable[abc.Hashable], /) -> bool:
+        return self.__frozen__().issubset(other)
 
     @setdoc.basic
-    def issuperset(self: Self, other: abc.Iterable[abc.Hashable], /) -> Self:
-        return type(self)(self.__frozen__().issuperset(other))  # type: ignore
+    def issuperset(self: Self, other: abc.Iterable[abc.Hashable], /) -> bool:
+        return self.__frozen__().issuperset(other)
 
     @setdoc.basic
     def symmetric_difference(self: Self, other: abc.Iterable[Item], /) -> Self:
@@ -276,7 +273,7 @@ class SetLike[Item: abc.Hashable](Set[Item]):
 
     @setdoc.basic
     def union(self: Self, /, *others: abc.Iterable[Item]) -> Self:
-        return type(self)(self.__frozen__().union(others))  # type: ignore
+        return type(self)(self.__frozen__().union(*others))
 
 
 class FrozenSetLike[Item: abc.Hashable](SetLike[Item], abc.Hashable):
@@ -308,6 +305,11 @@ class MutableSetLike[Item: abc.Hashable](SetLike[Item], MutableSet[Item]):
     @abstractmethod
     @setdoc.basic
     def __mutate__(self: Self) -> ContextManager[__Mutable__[Item]]: ...
+
+    @setdoc.basic
+    def copy(self: Self, /) -> Self:
+        return type(self)(self)
+
     @setdoc.basic
     def difference_update(
         self: Self, /, *others: abc.Iterable[abc.Hashable]
@@ -338,32 +340,28 @@ class MutableSetLike[Item: abc.Hashable](SetLike[Item], MutableSet[Item]):
 ### SET-SLOT ###
 
 
-class SetSlot[Item: abc.Hashable](SetLike[Item]):
-    """Provide slotted set-like."""
+class FrozenSetSlot[Item](FrozenSetLike[Item]):
+    """Provide slotted frozen set-like."""
 
     __slots__ = ("_slot",)
 
-    _slot: SetSlot.__Frozen__[Item]
+    _slot: FrozenSetSlot.__Frozen__[Item]
 
     @setdoc.basic
-    def __frozen__(self: Self, /) -> SetSlot.__Frozen__[Item]:
+    def __frozen__(self: Self, /) -> FrozenSetSlot.__Frozen__[Item]:
         return self._slot
 
-
-class FrozenSetSlot[Item](SetSlot[Item], FrozenSetLike[Item]):
-    """Provide slotted frozen set-like."""
-
-    __slots__ = ()
-
     @setdoc.basic
     def __init__(self: Self, data: abc.Iterable[Item] = (), /) -> None:
         self._slot = frozenset(data)
 
 
-class MutableSetSlot[Item](SetSlot[Item], MutableSetLike[Item]):
+class MutableSetSlot[Item](MutableSetLike[Item]):
     """Provide slotted mutable set-like."""
 
-    __slots__ = ()
+    __slots__ = ("_slot",)
+
+    _slot: FrozenSetSlot.__Frozen__[Item]
 
     @contextmanager
     @setdoc.basic
@@ -433,9 +431,7 @@ class DictLike[Key: abc.Hashable, Value](
     """Provide abc for custom dict-like."""
 
     __slots__ = ()
-    type __Frozen__[FrozenKey, FrozenValue] = frozendict[
-        FrozenKey | str, Optional[FrozenValue]
-    ]
+    type __Frozen__[Key_, Value_] = frozendict[Key_ | str, Optional[Value_]]
 
     @abstractmethod
     @setdoc.basic
@@ -534,31 +530,32 @@ class MutableDictLike[Key: abc.Hashable, Value](
     def copy(self: Self, /) -> Self:
         return type(self)(self)
 
+    @setdoc.basic
+    def popitem(self: Self, /) -> tuple[Key | str, Optional[Value]]:
+        # for most dict d
+        # dict.popitem(d) and collections.abc.MutableMapping.popitem(d)
+        # behave differently
+        with self.__mutate__() as mutable:
+            return mutable.popitem()
+
 
 ### DICT-SLOT ###
 
 
-class DictSlot[Key: abc.Hashable, Value](DictLike[Key, Value]):
-    """Provide slotted dict-like."""
+class FrozenDictSlot[Key: abc.Hashable, Value](
+    FrozenDictLike[Key, Value],
+):
+    """Provide slotted frozen dict-like."""
 
     __slots__ = ("_slot",)
-    _slot: DictSlot.__Frozen__[Key, Value]
+    _slot: FrozenDictSlot.__Frozen__[Key, Value]
 
     @setdoc.basic
     def __frozen__(  # type: ignore[override]
         self: Self,
-    ) -> DictSlot.__Frozen__[Key, Value]:
+    ) -> FrozenDictSlot.__Frozen__[Key, Value]:
         return self._slot
 
-
-class FrozenDictSlot[Key: abc.Hashable, Value](
-    DictSlot[Key, Value],
-    FrozenDictLike[Key, Value],
-):
-    """Provide slotted frozen dict-like."""
-
-    __slots__ = ()
-
     @setdoc.basic
     def __init__(
         self: Self,
@@ -566,16 +563,16 @@ class FrozenDictSlot[Key: abc.Hashable, Value](
         /,
         **kwargs: Optional[Value],
     ) -> None:
-        self._slot = frozendict(data)  # type: ignore[arg-type]
+        self._slot = frozendict(data, **kwargs)  # type: ignore[arg-type]
 
 
 class MutableDictSlot[Key: abc.Hashable, Value](
-    DictSlot[Key, Value],
     MutableDictLike[Key, Value],
 ):
     """Provide slotted mutable dict-like."""
 
-    __slots__ = ()
+    __slots__ = ("_slot",)
+    _slot: FrozenDictSlot.__Frozen__[Key, Value]
 
     @contextmanager
     @setdoc.basic
@@ -860,31 +857,26 @@ class MutableListLike[Item](ListLike[Item], MutableSequence[Item]):
 ### LIST-SLOT ###
 
 
-class ListSlot[Item](ListLike[Item]):
-    """Provide slotted list-like class."""
+class FrozenListSlot[Item](FrozenListLike[Item]):
+    """Provide slotted frozen list-like."""
 
     __slots__ = ("_slot",)
-    _slot: ListSlot.__Frozen__[Item]
+    _slot: FrozenListSlot.__Frozen__[Item]
 
     @setdoc.basic
-    def __frozen__(self: Self) -> ListSlot.__Frozen__[Item]:
+    def __frozen__(self: Self) -> FrozenListSlot.__Frozen__[Item]:
         return self._slot
 
-
-class FrozenListSlot[Item](ListSlot[Item], FrozenListLike[Item]):
-    """Provide slotted frozen list-like."""
-
-    __slots__ = ()
-
     @setdoc.basic
     def __init__(self: Self, data: abc.Iterable[Item] = (), /) -> None:
         self._slot = tuple(data)
 
 
-class MutableListSlot[Item](ListSlot[Item], MutableListLike[Item]):
+class MutableListSlot[Item](MutableListLike[Item]):
     """Provide slotted mutable list-like."""
 
-    __slots__ = ()
+    __slots__ = ("_slot",)
+    _slot: MutableListSlot.__Frozen__[Item]
 
     @contextmanager
     @setdoc.basic

{datahold-4.0.0.dev25 → datahold-4.0.0.dev27}/src/datahold.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datahold
-Version: 4.0.0.dev25
+Version: 4.0.0.dev27
 Summary: This project wraps common mutable datastructures for inheritance with modification.
 Author-email: Johannes <johannes.programming@gmail.com>
 License-Expression: MIT

{datahold-4.0.0.dev25 → datahold-4.0.0.dev27}/src/datahold.egg-info/SOURCES.txt

@@ -20,7 +20,9 @@ src/datahold.egg-info/dependency_links.txt
 src/datahold.egg-info/requires.txt
 src/datahold.egg-info/top_level.txt
 tests/test_FrozenListSlot.py
+tests/test_MutableDictSlot.py
 tests/test_MutableListSlot.py
+tests/test_MutableSetSlot.py
 tests/test_abstractmethods.py
 tests/test_all.py
 tests/test_attributes.py

datahold-4.0.0.dev27/tests/test_MutableDictSlot.py

@@ -0,0 +1,403 @@
+import unittest
+from collections import abc
+from typing import Any, Self
+
+from datahold import MutableDictSlot
+
+
+class TestClear(unittest.TestCase):
+    def test_clear_removes_all_entries(self: Self) -> None:
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1, "b": 2})
+        value.clear()
+        self.assertEqual(value, {})
+        self.assertEqual(len(value), 0)
+
+    def test_clear_empty_mapping(self: Self) -> None:
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot()
+        value.clear()
+        self.assertEqual(value, {})
+        self.assertFalse(value)
+
+    def test_clear_returns_none(self: Self) -> None:
+        result: Any
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1})
+        result = value.clear()  # type: ignore[func-returns-value]
+        self.assertIsNone(result)
+        self.assertEqual(value, {})
+
+    def test_clear_updates_existing_views(self: Self) -> None:
+        items_view: abc.Collection[Any]
+        keys_view: abc.Collection[Any]
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1, "b": 2})
+        keys_view = value.keys()
+        items_view = value.items()
+        value.clear()
+        self.assertEqual(list(keys_view), [])
+        self.assertEqual(list(items_view), [])
+
+
+class TestCopy(unittest.TestCase):
+    def test_copy_has_equal_contents(self: Self) -> None:
+        copied: MutableDictSlot[Any, Any]
+        original: MutableDictSlot[Any, Any]
+        original = MutableDictSlot({"a": 1, "b": 2})
+        copied = original.copy()
+        self.assertEqual(copied, original)
+        self.assertIsNot(copied, original)
+
+    def test_copy_of_empty_mapping(self: Self) -> None:
+        copied: MutableDictSlot[Any, Any]
+        original: MutableDictSlot[Any, Any]
+        original = MutableDictSlot()
+        copied = original.copy()
+        self.assertEqual(copied, {})
+        self.assertIsNot(copied, original)
+
+    def test_copy_is_shallow(self: Self) -> None:
+        copied: MutableDictSlot[Any, Any]
+        nested: list[int]
+        original: MutableDictSlot[Any, Any]
+        nested = [1, 2]
+        original = MutableDictSlot({"nested": nested})
+        copied = original.copy()
+        copied["nested"].append(3)  # type: ignore
+        self.assertIs(copied["nested"], original["nested"])
+        self.assertEqual(original["nested"], [1, 2, 3])
+
+    def test_copy_has_independent_top_level_entries(self: Self) -> None:
+        copied: MutableDictSlot[Any, Any]
+        original: MutableDictSlot[Any, Any]
+        original = MutableDictSlot({"a": 1})
+        copied = original.copy()
+        copied["a"] = 2
+        copied["b"] = 3
+        self.assertEqual(original, {"a": 1})
+        self.assertEqual(copied, {"a": 2, "b": 3})
+
+
+class TestFromKeys(unittest.TestCase):
+    def test_fromkeys_uses_none_by_default(self: Self) -> None:
+        result: MutableDictSlot[Any, Any]
+        result = MutableDictSlot.fromkeys(["a", "b", "c"])
+        self.assertEqual(result, {"a": None, "b": None, "c": None})
+        self.assertEqual(list(result), ["a", "b", "c"])
+
+    def test_fromkeys_uses_supplied_value(self: Self) -> None:
+        result: MutableDictSlot[Any, Any]
+        result = MutableDictSlot.fromkeys(["a", "b"], 10)
+        self.assertEqual(result, {"a": 10, "b": 10})
+        self.assertEqual(result["a"], 10)
+
+    def test_fromkeys_ignores_duplicate_keys(self: Self) -> None:
+        result: MutableDictSlot[Any, Any]
+        result = MutableDictSlot.fromkeys(["a", "b", "a", "c", "b"], 0)
+        self.assertEqual(result, {"a": 0, "b": 0, "c": 0})
+        self.assertEqual(list(result), ["a", "b", "c"])
+
+    def test_fromkeys_reuses_same_mutable_value(self: Self) -> None:
+        result: MutableDictSlot[Any, Any]
+        shared: list[Any]
+        shared = []
+        result = MutableDictSlot.fromkeys(["a", "b"], shared)
+        result["a"].append(1)  # type: ignore
+        self.assertIs(result["a"], shared)
+        self.assertIs(result["b"], shared)
+        self.assertEqual(result["b"], [1])
+
+
+class TestGet(unittest.TestCase):
+    def test_get_returns_existing_value(self: Self) -> None:
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1})
+        self.assertEqual(value.get("a"), 1)
+        self.assertEqual(value, {"a": 1})
+
+    def test_get_returns_none_for_missing_key(self: Self) -> None:
+        result: Any
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1})
+        result = value.get("missing")
+        self.assertIsNone(result)
+        self.assertNotIn("missing", value)
+
+    def test_get_returns_custom_default(self: Self) -> None:
+        default: object
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot()
+        default = object()
+        result = value.get("missing", default)
+        self.assertIs(result, default)
+        self.assertEqual(value, {})
+
+    def test_get_rejects_unhashable_key(self: Self) -> None:
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1})
+        with self.assertRaises(TypeError):
+            value.get([])
+        self.assertEqual(value, {"a": 1})
+
+
+class TestItems(unittest.TestCase):
+    def test_items_contains_key_value_pairs(self: Self) -> None:
+        result: abc.Collection[Any]
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1, "b": 2})
+        result = value.items()
+        self.assertEqual(set(result), {("a", 1), ("b", 2)})
+        self.assertEqual(len(result), 2)
+
+    def test_items_preserves_iteration_order(self: Self) -> None:
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot()
+        value["first"] = 1
+        value["second"] = 2
+        value["third"] = 3
+        self.assertEqual(
+            list(value.items()),
+            [("first", 1), ("second", 2), ("third", 3)],
+        )
+
+    def test_items_view_is_dynamic(self: Self) -> None:
+        result: abc.Collection[Any]
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1})
+        result = value.items()
+        value["a"] = 2
+        value["b"] = 3
+        self.assertEqual(list(result), [("a", 2), ("b", 3)])
+
+    def test_items_supports_pair_membership(self: Self) -> None:
+        result: abc.Collection[Any]
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1, "b": 2})
+        result = value.items()
+        self.assertIn(("a", 1), result)
+        self.assertIn(("b", 2), result)
+        self.assertNotIn(("a", 2), result)
+        self.assertNotIn(("missing", 1), result)
+
+
+class TestKeys(unittest.TestCase):
+    def test_keys_contains_all_keys(self: Self) -> None:
+        result: abc.Collection[Any]
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1, "b": 2})
+        result = value.keys()
+        self.assertEqual(set(result), {"a", "b"})
+        self.assertEqual(len(result), 2)
+
+    def test_keys_preserves_iteration_order(self: Self) -> None:
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot()
+        value["first"] = 1
+        value["second"] = 2
+        value["third"] = 3
+        self.assertEqual(
+            list(value.keys()),
+            ["first", "second", "third"],
+        )
+
+    def test_keys_view_is_dynamic(self: Self) -> None:
+        result: abc.Collection[Any]
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1, "b": 2})
+        result = value.keys()
+        del value["a"]
+        value["c"] = 3
+        self.assertEqual(list(result), ["b", "c"])
+
+    def test_keys_supports_membership(self: Self) -> None:
+        result: abc.Collection[Any]
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1, "b": 2})
+        result = value.keys()
+        self.assertIn("a", result)
+        self.assertIn("b", result)
+        self.assertNotIn("missing", result)
+        self.assertNotIn(1, result)
+
+
+class TestPop(unittest.TestCase):
+    def test_pop_returns_and_removes_existing_value(self: Self) -> None:
+        result: Any
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1, "b": 2})
+        result = value.pop("a")
+        self.assertEqual(result, 1)
+        self.assertEqual(value, {"b": 2})
+
+    def test_pop_missing_key_raises_key_error(self: Self) -> None:
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1})
+        with self.assertRaises(KeyError) as context:
+            value.pop("missing")
+        self.assertEqual(context.exception.args, ("missing",))
+        self.assertEqual(value, {"a": 1})
+
+    def test_pop_missing_key_returns_default(self: Self) -> None:
+        default: object
+        result: Any
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1})
+        default = object()
+        result = value.pop("missing", default)
+        self.assertIs(result, default)
+        self.assertEqual(value, {"a": 1})
+
+    def test_pop_handles_none_as_explicit_default(self: Self) -> None:
+        result: Any
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot()
+        result = value.pop("missing", None)
+        self.assertIsNone(result)
+        self.assertEqual(value, {})
+
+
+class TestPopItem(unittest.TestCase):
+    def test_popitem_removes_last_inserted_pair(self: Self) -> None:
+        result: tuple[Any, Any]
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1, "b": 2, "c": 3})
+        result = value.popitem()
+        self.assertEqual(result, ("c", 3))
+        self.assertEqual(value, {"a": 1, "b": 2})
+
+    def test_popitem_uses_lifo_order_repeatedly(self: Self) -> None:
+        first: tuple[Any, Any]
+        second: tuple[Any, Any]
+        third: tuple[Any, Any]
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1, "b": 2, "c": 3})
+        first = value.popitem()
+        second = value.popitem()
+        third = value.popitem()
+        self.assertEqual(first, ("c", 3))
+        self.assertEqual(second, ("b", 2))
+        self.assertEqual(third, ("a", 1))
+        self.assertEqual(len(value), 0)
+
+    def test_popitem_removes_only_entry(self: Self) -> None:
+        result: tuple[Any, Any]
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1})
+        result = value.popitem()
+        self.assertEqual(result, ("a", 1))
+        self.assertEqual(value, {})
+
+    def test_popitem_empty_mapping_raises_key_error(self: Self) -> None:
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot()
+        with self.assertRaises(KeyError):
+            value.popitem()
+        self.assertEqual(value, {})
+
+
+class TestSetDefault(unittest.TestCase):
+    def test_setdefault_returns_existing_value(self: Self) -> None:
+        result: Any
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1})
+        result = value.setdefault("a", 2)
+        self.assertEqual(result, 1)
+        self.assertEqual(value, {"a": 1})
+
+    def test_setdefault_inserts_supplied_default(self: Self) -> None:
+        result: Any
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1})
+        result = value.setdefault("b", 2)
+        self.assertEqual(result, 2)
+        self.assertEqual(value, {"a": 1, "b": 2})
+
+    def test_setdefault_inserts_none_by_default(self: Self) -> None:
+        result: Any
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot()
+        result = value.setdefault("a")
+        self.assertIsNone(result)
+        self.assertEqual(value, {"a": None})
+
+    def test_setdefault_preserves_mutable_default_identity(self: Self) -> None:
+        default: list[Any]
+        result: Any
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot()
+        default = []
+        result = value.setdefault("a", default)
+        result.append(1)
+        self.assertIs(result, default)
+        self.assertIs(value["a"], default)
+        self.assertEqual(value["a"], [1])
+
+
+class TestUpdate(unittest.TestCase):
+    def test_update_from_mapping(self: Self) -> None:
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1})
+        value.update({"b": 2, "c": 3})
+        self.assertEqual(value, {"a": 1, "b": 2, "c": 3})
+
+    def test_update_from_iterable_of_pairs(self: Self) -> None:
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1})
+        value.update([("b", 2), ("c", 3)])
+        self.assertEqual(value, {"a": 1, "b": 2, "c": 3})
+
+    def test_update_from_keyword_arguments(self: Self) -> None:
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1})
+        value.update(b=2, c=3)
+        self.assertEqual(value, {"a": 1, "b": 2, "c": 3})
+
+    def test_update_overwrites_values_and_returns_none(self: Self) -> None:
+        result: Any
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1, "b": 2})
+        result = value.update({"a": 10}, b=20, c=30)
+        self.assertIsNone(result)
+        self.assertEqual(value, {"a": 10, "b": 20, "c": 30})
+
+
+class TestValues(unittest.TestCase):
+    def test_values_contains_all_values(self: Self) -> None:
+        result: Any
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1, "b": 2, "c": 3})
+        result = value.values()
+        self.assertEqual(list(result), [1, 2, 3])
+        self.assertEqual(len(result), 3)
+
+    def test_values_preserves_iteration_order(self: Self) -> None:
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot()
+        value["first"] = 10
+        value["second"] = 20
+        value["third"] = 30
+
+        self.assertEqual(list(value.values()), [10, 20, 30])
+
+    def test_values_view_is_dynamic(self: Self) -> None:
+        result: abc.Collection[Any]
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1, "b": 2})
+        result = value.values()
+        value["a"] = 10
+        del value["b"]
+        value["c"] = 3
+        self.assertEqual(list(result), [10, 3])
+
+    def test_values_preserves_duplicate_values(self: Self) -> None:
+        result: list[Any]
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1, "b": 1, "c": 2})
+        result = list(value.values())
+        self.assertEqual(result, [1, 1, 2])
+        self.assertEqual(result.count(1), 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

datahold-4.0.0.dev27/tests/test_MutableSetSlot.py

@@ -0,0 +1,477 @@
+import unittest
+from typing import Any, Self
+
+from datahold import MutableSetSlot
+
+
+class TestAdd(unittest.TestCase):
+    def test_adds_new_element(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        value.add(3)
+        self.assertEqual(set(value), {1, 2, 3})
+
+    def test_adding_duplicate_does_not_change_set(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        value.add(2)
+        self.assertEqual(set(value), {1, 2})
+
+    def test_adds_hashable_tuple(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot()
+        value.add((1, 2))
+        self.assertEqual(set(value), {(1, 2)})
+
+    def test_adding_unhashable_element_raises_type_error(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1})
+        with self.assertRaises(TypeError):
+            value.add([2])
+        self.assertEqual(set(value), {1})
+
+
+class TestClear(unittest.TestCase):
+    def test_clears_populated_set(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        value.clear()
+        self.assertEqual(set(value), set())
+
+    def test_clearing_empty_set_keeps_it_empty(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot()
+        value.clear()
+        self.assertEqual(set(value), set())
+
+    def test_clear_returns_none(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        self.assertIsNone(value.clear())  # type: ignore[func-returns-value]
+
+    def test_set_can_be_reused_after_clear(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        value.clear()
+        value.add(3)
+        self.assertEqual(set(value), {3})
+
+
+class TestCopy(unittest.TestCase):
+    def test_copy_has_same_contents(self: Self) -> None:
+        copied: MutableSetSlot[Any]
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        copied = value.copy()
+        self.assertEqual(set(copied), {1, 2, 3})
+
+    def test_copy_is_a_different_object(self: Self) -> None:
+        copied: MutableSetSlot[Any]
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        copied = value.copy()
+        self.assertIsNot(copied, value)
+
+    def test_copy_is_independent_of_original(self: Self) -> None:
+        copied: MutableSetSlot[Any]
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        copied = value.copy()
+        copied.add(3)
+        self.assertEqual(set(value), {1, 2})
+        self.assertEqual(set(copied), {1, 2, 3})
+
+    def test_copy_of_empty_set_is_empty(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot()
+        copied = value.copy()
+        self.assertEqual(set(copied), set())
+
+
+class TestDifference(unittest.TestCase):
+    def test_difference_removes_shared_elements(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        result = value.difference({2, 3, 4})
+        self.assertEqual(set(result), {1})
+
+    def test_difference_accepts_multiple_iterables(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3, 4})
+        result = value.difference({1}, [2, 5])
+        self.assertEqual(set(result), {3, 4})
+
+    def test_difference_with_disjoint_set_is_unchanged(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        result = value.difference({3, 4})
+        self.assertEqual(set(result), {1, 2})
+
+    def test_difference_does_not_modify_original(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        value.difference({2})
+        self.assertEqual(set(value), {1, 2, 3})
+
+
+class TestDifferenceUpdate(unittest.TestCase):
+    def test_difference_update_removes_shared_elements(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        value.difference_update({2, 4})
+        self.assertEqual(set(value), {1, 3})
+
+    def test_difference_update_accepts_multiple_iterables(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3, 4})
+        value.difference_update({1}, [2, 5])
+        self.assertEqual(set(value), {3, 4})
+
+    def test_difference_update_with_disjoint_set_is_unchanged(
+        self: Self,
+    ) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        value.difference_update({3, 4})
+        self.assertEqual(set(value), {1, 2})
+
+    def test_difference_update_with_self_empties_set(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        value.difference_update(value)
+        self.assertEqual(set(value), set())
+
+
+class TestDiscard(unittest.TestCase):
+    def test_discards_existing_element(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        value.discard(2)
+        self.assertEqual(set(value), {1, 3})
+
+    def test_discarding_missing_element_does_not_raise(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        value.discard(3)
+        self.assertEqual(set(value), {1, 2})
+
+    def test_discard_returns_none(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        self.assertIsNone(value.discard(1))
+
+    def test_discarding_unhashable_element_raises_type_error(
+        self: Self,
+    ) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        with self.assertRaises(TypeError):
+            value.discard([1])  # type: ignore
+        self.assertEqual(set(value), {1, 2})
+
+
+class TestIntersection(unittest.TestCase):
+    def test_intersection_returns_shared_elements(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        result = value.intersection({2, 3, 4})
+        self.assertEqual(set(result), {2, 3})
+
+    def test_intersection_accepts_multiple_iterables(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3, 4})
+        result = value.intersection({2, 3, 4}, [3, 4, 5])
+        self.assertEqual(set(result), {3, 4})
+
+    def test_intersection_with_disjoint_set_is_empty(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        result = value.intersection({3, 4})
+        self.assertEqual(set(result), set())
+
+    def test_intersection_does_not_modify_original(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        value.intersection({2})
+        self.assertEqual(set(value), {1, 2, 3})
+
+
+class TestIntersectionUpdate(unittest.TestCase):
+    def test_intersection_update_keeps_shared_elements(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        value.intersection_update({2, 3, 4})
+        self.assertEqual(set(value), {2, 3})
+
+    def test_intersection_update_accepts_multiple_iterables(
+        self: Self,
+    ) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3, 4})
+        value.intersection_update({2, 3, 4}, [3, 4, 5])
+        self.assertEqual(set(value), {3, 4})
+
+    def test_intersection_update_with_disjoint_set_empties_set(
+        self: Self,
+    ) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        value.intersection_update({3, 4})
+        self.assertEqual(set(value), set())
+
+    def test_intersection_update_with_self_is_unchanged(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        value.intersection_update(value)
+        self.assertEqual(set(value), {1, 2, 3})
+
+
+class TestIsDisjoint(unittest.TestCase):
+    def test_disjoint_sets_return_true(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        self.assertTrue(value.isdisjoint({3, 4}))
+
+    def test_overlapping_sets_return_false(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        self.assertFalse(value.isdisjoint({2, 3}))
+
+    def test_empty_set_is_disjoint_from_populated_set(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot()
+        self.assertTrue(value.isdisjoint({1, 2}))
+
+    def test_isdisjoint_accepts_generator(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        other = (number for number in (3, 4))
+        self.assertTrue(value.isdisjoint(other))
+
+
+class TestIsSubset(unittest.TestCase):
+    def test_proper_subset_returns_true(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        self.assertTrue(value.issubset({1, 2, 3}))
+
+    def test_equal_set_is_subset(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        self.assertTrue(value.issubset({1, 2}))
+
+    def test_non_subset_returns_false(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 4})
+        self.assertFalse(value.issubset({1, 2, 3}))
+
+    def test_empty_set_is_subset_of_any_set(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot()
+        self.assertTrue(value.issubset({1, 2}))
+
+
+class TestIsSuperset(unittest.TestCase):
+    def test_proper_superset_returns_true(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        self.assertTrue(value.issuperset({1, 2}))
+
+    def test_equal_set_is_superset(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        self.assertTrue(value.issuperset({1, 2}))
+
+    def test_non_superset_returns_false(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        self.assertFalse(value.issuperset({1, 3}))
+
+    def test_every_set_is_superset_of_empty_set(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        self.assertTrue(value.issuperset(set()))
+
+
+class TestPop(unittest.TestCase):
+    def test_pop_returns_and_removes_only_element(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1})
+        result = value.pop()
+        self.assertEqual(result, 1)
+        self.assertEqual(set(value), set())
+
+    def test_pop_from_empty_set_raises_key_error(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot()
+        with self.assertRaises(KeyError):
+            value.pop()
+
+    def test_pop_removes_one_element_from_populated_set(self: Self) -> None:
+        original: set[int]
+        result: Any
+        value: MutableSetSlot[Any]
+        original = {1, 2, 3}
+        value = MutableSetSlot(original)
+        result = value.pop()
+        self.assertIn(result, original)
+        self.assertEqual(set(value), original - {result})
+
+    def test_repeated_pop_exhausts_set(self: Self) -> None:
+        popped: set[Any]
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        popped = {value.pop(), value.pop(), value.pop()}
+        self.assertEqual(popped, {1, 2, 3})
+        self.assertEqual(set(value), set())
+
+
+class TestRemove(unittest.TestCase):
+    def test_removes_existing_element(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        value.remove(2)
+        self.assertEqual(set(value), {1, 3})
+
+    def test_removing_missing_element_raises_key_error(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        with self.assertRaises(KeyError):
+            value.remove(3)
+        self.assertEqual(set(value), {1, 2})
+
+    def test_remove_returns_none(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        self.assertIsNone(value.remove(1))  # type: ignore[func-returns-value]
+
+    def test_removing_unhashable_element_raises_type_error(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        with self.assertRaises(Exception):
+            # in general you should not rely upon
+            # a TypeError or an AttributeError occuring
+            value.remove([1])
+        self.assertEqual(set(value), {1, 2})
+
+
+class TestSymmetricDifference(unittest.TestCase):
+    def test_symmetric_difference_excludes_shared_elements(self: Self) -> None:
+        result: Any
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        result = value.symmetric_difference({3, 4, 5})
+        self.assertEqual(set(result), {1, 2, 4, 5})
+
+    def test_symmetric_difference_of_disjoint_sets_is_union(
+        self: Self,
+    ) -> None:
+        result: Any
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        result = value.symmetric_difference({3, 4})
+        self.assertEqual(set(result), {1, 2, 3, 4})
+
+    def test_symmetric_difference_of_equal_sets_is_empty(self: Self) -> None:
+        result: Any
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        result = value.symmetric_difference({1, 2})
+        self.assertEqual(set(result), set())
+
+    def test_symmetric_difference_does_not_modify_original(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        value.symmetric_difference({3, 4})
+        self.assertEqual(set(value), {1, 2, 3})
+
+
+class TestSymmetricDifferenceUpdate(unittest.TestCase):
+    def test_symmetric_difference_update_excludes_shared_elements(
+        self: Self,
+    ) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        value.symmetric_difference_update({3, 4, 5})
+        self.assertEqual(set(value), {1, 2, 4, 5})
+
+    def test_symmetric_difference_update_of_disjoint_sets_is_union(
+        self: Self,
+    ) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        value.symmetric_difference_update({3, 4})
+        self.assertEqual(set(value), {1, 2, 3, 4})
+
+    def test_symmetric_difference_update_with_equal_set_empties_set(
+        self: Self,
+    ) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        value.symmetric_difference_update({1, 2})
+        self.assertEqual(set(value), set())
+
+    def test_symmetric_difference_update_returns_none(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        result = value.symmetric_difference_update({2, 3})
+        self.assertIsNone(result)
+        self.assertEqual(set(value), {1, 3})
+
+
+class TestUnion(unittest.TestCase):
+    def test_union_combines_elements(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        result = value.union({2, 3})
+        self.assertEqual(set(result), {1, 2, 3})
+
+    def test_union_accepts_multiple_iterables(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1})
+        result = value.union({2}, [3, 4])
+        self.assertEqual(set(result), {1, 2, 3, 4})
+
+    def test_union_without_arguments_returns_same_contents(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        result = value.union()
+        self.assertEqual(set(result), {1, 2})
+        self.assertIsNot(result, value)
+
+    def test_union_does_not_modify_original(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        value.union({3, 4})
+        self.assertEqual(set(value), {1, 2})
+
+
+class TestUpdate(unittest.TestCase):
+    def test_update_adds_elements_from_iterable(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        value.update({2, 3, 4})
+        self.assertEqual(set(value), {1, 2, 3, 4})
+
+    def test_update_accepts_multiple_iterables(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1})
+        value.update({2}, [3, 4])
+        self.assertEqual(set(value), {1, 2, 3, 4})
+
+    def test_update_ignores_duplicate_elements(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        value.update([1, 1, 2, 2])
+        self.assertEqual(set(value), {1, 2})
+
+    def test_update_returns_none(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1})
+        result = value.update({2, 3})
+        self.assertIsNone(result)
+        self.assertEqual(set(value), {1, 2, 3})
+
+
+if __name__ == "__main__":
+    unittest.main()

{datahold-4.0.0.dev25 → datahold-4.0.0.dev27}/tests/test_name.py

@@ -40,17 +40,15 @@ class TestName(unittest.TestCase):
             self.assertTrue(issubclass(datatype, abc.Hashable))
             self.assertFalse(hasattr(datatype, "__Mutable__"))
             self.assertFalse(hasattr(datatype, "__mutate__"))
-            self.assertTrue(
-                issubclass(datatype, Lazy.get_import("datahold." + name[6:]))
-            )
+            ancestor = getattr(datahold, name[6:], object)
+            self.assertTrue(issubclass(datatype, ancestor))
         # mutable
         if prefix == "Mutable":
             self.assertIn(datatype.__hash__, [None, object.__hash__])
             self.assertTrue(hasattr(datatype, "__Mutable__"))
             self.assertTrue(hasattr(datatype, "__mutate__"))
-            self.assertTrue(
-                issubclass(datatype, Lazy.get_import("datahold." + name[7:]))
-            )
+            ancestor = getattr(datahold, name[7:], object)
+            self.assertTrue(issubclass(datatype, ancestor))
         # no prefix
         if prefix == "":
             self.assertIn(datatype.__hash__, [None, object.__hash__])
@@ -62,11 +60,8 @@ class TestName(unittest.TestCase):
         # slot
         if suffix == "Slot":
             self.assertTrue(hasattr(datatype, "__init__"))
-            self.assertTrue(
-                issubclass(
-                    datatype, Lazy.get_import("datahold." + name[:-4] + "Like")
-                )
-            )
+            ancestor = getattr(datahold, name[:-4] + "Like")
+            self.assertTrue(issubclass(datatype, ancestor))
         # no suffix
         if suffix == "":
             self.assertIs(datatype.__init__, object.__init__)

{datahold-4.0.0.dev25 → datahold-4.0.0.dev27}/tests/test_variance.py

@@ -2,7 +2,7 @@
 
 import unittest
 
-from datahold import FrozenListLike, FrozenListSlot, ListLike, ListSlot
+from datahold import FrozenListLike, FrozenListSlot, ListLike
 
 
 class Animal:
@@ -26,12 +26,6 @@ def cast_FrozenListLikeAnimal(
     return x
 
 
-def cast_ListSlotAnimal(
-    x: ListSlot[Bear],
-) -> ListSlot[Animal]:
-    return x
-
-
 def cast_FrozenListSlotAnimal(
     x: FrozenListSlot[Bear],
 ) -> FrozenListSlot[Animal]:

{datahold-4.0.0.dev25 → datahold-4.0.0.dev27}/tests/testdata.toml

@@ -7,10 +7,6 @@ __or__ = "datahold.DictLike"
 "collections.abc.Mapping" = true
 "datahold.Mapping" = true
 
-[datatypes.DictSlot.issubclass]
-"collections.abc.Mapping" = true
-"datahold.DictLike" = true
-
 [datatypes.FrozenDictLike.issubclass]
 "collections.abc.Hashable" = true
 "datahold.Mapping" = true
@@ -182,13 +178,6 @@ __Mutable__ = ""
 [datatypes.ListLike.varia]
 generic = 1
 
-[datatypes.ListSlot.nested]
-__Frozen__ = "builtins.tuple"
-__Mutable__ = ""
-
-[datatypes.ListSlot.varia]
-generic = 1
-
 [datatypes.Mapping.issubclass]
 "collections.abc.Mapping" = true
 "datahold.Collection" = true
@@ -288,7 +277,6 @@ sort = ""
 "datahold.Collection" = true
 "datahold.MutableSet" = true
 "datahold.MutableSetLike" = true
-"datahold.SetSlot" = true
 
 [datatypes.Sequence]
 
@@ -302,9 +290,4 @@ sort = ""
 "datahold.Set" = true
 "datahold.SetLike" = true
 
-[datatypes.SetSlot.issubclass]
-"collections.abc.Set" = true
-"datahold.Collection" = true
-"datahold.SetLike" = true
-
 [non_datatypes]