datahold 4.0.0.dev28__tar.gz → 4.0.0.dev29__tar.gz

{datahold-4.0.0.dev28 → datahold-4.0.0.dev29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datahold
-Version: 4.0.0.dev28
+Version: 4.0.0.dev29
 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.dev28 → datahold-4.0.0.dev29}/pyproject.toml

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

{datahold-4.0.0.dev28 → datahold-4.0.0.dev29}/src/datahold/__init__.py

@@ -9,6 +9,7 @@ __all__: list[str] = [
     "FrozenDictSlot",
     "FrozenListLike",
     "FrozenListSlot",
+    "FrozenObjectLike",
     "FrozenObjectSlot",
     "FrozenSetLike",
     "FrozenSetSlot",
@@ -95,7 +96,7 @@ class MutableSet_Mutable[Item: abc.Hashable](Protocol):
 
 class Mapping_Frozen[Key, Value](Collection_Frozen[Key], Protocol):
     @setdoc.basic
-    def __getitem__(self: Self, key: abc.Hashable, /) -> Value: ...
+    def __getitem__(self: Self, key: Never, /) -> Value: ...
 class MutableMapping_Mutable[Key_, Value_](
     Protocol,
 ):
@@ -171,7 +172,7 @@ class MutableSequence_Mutable[Item](Protocol):
 
 type Dict[Key, Value] = dict[Key | str, Optional[Value]]
 
-type DictInit[Key, Value] = (
+type Dict_Init[Key, Value] = (
     SupportsKeysAndGetitem[Key | str, Optional[Value]]
     | abc.Iterable[tuple[Key | str, Optional[Value]]]
 )
@@ -205,6 +206,19 @@ class MutableObject[Frozen, Mutable](Object[Frozen]):
 ### OBJECT-LIKE ###
 
 
+class FrozenObjectLike[Frozen: abc.Hashable](
+    Object[Frozen],
+    abc.Hashable,
+):
+    """Provide abc for custom frozen object-like."""
+
+    __slots__ = ()
+
+    @setdoc.basic
+    def __hash__(self: Self, /) -> int:
+        return hash(self.__frozen__())
+
+
 class MutableObjectLike[Frozen, Mutable](
     MutableObject[Frozen, Mutable],
 ):
@@ -232,7 +246,8 @@ class ObjectSlot[Frozen](
     _slot: Frozen
 
 
-class FrozenObjectSlot[Frozen](
+class FrozenObjectSlot[Frozen: abc.Hashable](
+    FrozenObjectLike[Frozen],
     ObjectSlot[Frozen],
 ):
     """Provide slotted abc for custom frozen object-like."""
@@ -314,7 +329,7 @@ class SetLike[Item: abc.Hashable](Set[Item]):
     def __frozen__(self: Self, /) -> frozenset[Item]: ...
     @abstractmethod
     @setdoc.basic
-    def __init__(self: Self, data: abc.Iterable[Item] = (), /) -> None: ...
+    def __init__(self: Self, other: abc.Iterable[Item] = (), /) -> None: ...
     @setdoc.basic
     def difference(self: Self, /, *others: abc.Iterable[abc.Hashable]) -> Self:
         return type(self)(self.__frozen__().difference(*others))
@@ -342,15 +357,14 @@ class SetLike[Item: abc.Hashable](Set[Item]):
         return type(self)(self.__frozen__().union(*others))
 
 
-class FrozenSetLike[Item: abc.Hashable](SetLike[Item], abc.Hashable):
+class FrozenSetLike[Item: abc.Hashable](
+    FrozenObjectLike[frozenset[Item]],
+    SetLike[Item],
+):
     """Provide abc for custom frozen set-like."""
 
     __slots__ = ()
 
-    @setdoc.basic
-    def __hash__(self: Self, /) -> int:
-        return hash(self.__frozen__())
-
 
 class MutableSetLike[Item: abc.Hashable](
     SetLike[Item],
@@ -367,9 +381,9 @@ class MutableSetLike[Item: abc.Hashable](
             return frozenset(mutable)
 
     @setdoc.basic
-    def __init__(self: Self, data: abc.Iterable[Item] = (), /) -> None:
+    def __init__(self: Self, other: abc.Iterable[Item] = (), /) -> None:
         with self.__mutate__() as mutable:
-            mutable.update(data)
+            mutable.update(other)
 
     @setdoc.basic
     def difference_update(
@@ -410,8 +424,8 @@ class FrozenSetSlot[Item](
     __slots__ = ()
 
     @setdoc.basic
-    def __init__(self: Self, data: abc.Iterable[Item] = (), /) -> None:
-        self._slot = frozenset(data)
+    def __init__(self: Self, other: abc.Iterable[Item] = (), /) -> None:
+        self._slot = frozenset(other)
 
 
 class MutableSetSlot[Item](
@@ -428,10 +442,10 @@ class MutableSetSlot[Item](
         self: Self,
         /,
     ) -> abc.Generator[set[Item], None, None]:
-        slot: set[Item]
-        slot = set(getattr(self, "_slot", ()))
-        yield slot
-        self._slot = frozenset(slot)
+        mutable: set[Item]
+        mutable = set(getattr(self, "_slot", ()))
+        yield mutable
+        self._slot = frozenset(mutable)
 
 
 ### MAPPING ###
@@ -449,8 +463,26 @@ class Mapping[Key: abc.Hashable, Value](
     @setdoc.basic
     def __frozen__(self: Self, /) -> Mapping_Frozen[Key, Value]: ...
     @setdoc.basic
-    def __getitem__(self: Self, key: abc.Hashable, /) -> Value:
-        return self.__frozen__()[key]
+    def __getitem__(self: Self, key: object, /) -> Value:
+        try:
+            return self.__frozen__()[key]  # type: ignore[index]
+        except TypeError:
+            raise KeyError(key) from None
+
+    @overload
+    def get(self, key: object) -> Optional[Value]: ...
+    @overload
+    def get[Value_](self, key: object, default: Value_) -> Value | Value_: ...
+    @setdoc.basic
+    def get[Value_](
+        self: Self, key: object, default: Optional[Value_] = None
+    ) -> Optional[Value | Value_]:
+        # this method is just as Mapping.get
+        # with the signature corrected
+        try:
+            return self[key]
+        except KeyError:
+            return default
 
 
 class MutableMapping[Key: abc.Hashable, Value](
@@ -487,21 +519,20 @@ class DictLike[Key: abc.Hashable, Value](
 
     @abstractmethod
     @setdoc.basic
-    def __frozen__(self: Self, /) -> FrozenDict[Key, Value]:  # type: ignore[override]
-        ...
+    def __frozen__(self: Self, /) -> FrozenDict[Key, Value]: ...
 
     @abstractmethod
     @setdoc.basic
     def __init__(
         self: Self,
-        data: DictInit[Key, Value] = (),
+        other: Dict_Init[Key, Value] = (),
         /,
         **kwargs: Value,
     ): ...
     @setdoc.basic
     def __or__[Key_, Value_](
         self: Self,
-        other: DictInit[Key_, Value_],
+        other: Dict_Init[Key_, Value_],
         /,
     ) -> DictLike[Key | Key_, Value | Value_]:
         data: FrozenDict[Key, Value]
@@ -525,17 +556,13 @@ class DictLike[Key: abc.Hashable, Value](
 
 
 class FrozenDictLike[Key: abc.Hashable, Value](
+    FrozenObjectLike[FrozenDict[Key, Value]],
     DictLike[Key, Value],
-    abc.Hashable,
 ):
     """Provide abc for custom frozen dict-like."""
 
     __slots__ = ()
 
-    @setdoc.basic
-    def __hash__(self: Self, /) -> int:
-        return hash(self.__frozen__())
-
 
 class MutableDictLike[Key: abc.Hashable, Value](
     DictLike[Key, Value],
@@ -547,7 +574,7 @@ class MutableDictLike[Key: abc.Hashable, Value](
     __slots__ = ()
 
     @setdoc.basic
-    def __frozen__(  # type: ignore[override]
+    def __frozen__(
         self: Self,
         /,
     ) -> FrozenDict[Key, Value]:
@@ -557,16 +584,16 @@ class MutableDictLike[Key: abc.Hashable, Value](
     @setdoc.basic
     def __init__(
         self: Self,
-        data: DictInit[Key, Value] = (),
+        other: Dict_Init[Key, Value] = (),
         /,
         **kwargs: Optional[Value],
     ):
-        self.update(data, **kwargs)
+        self.update(other, **kwargs)
 
     @setdoc.basic
     def __ior__(  # type: ignore[override]
         self: Self,
-        other: DictInit[Key, Value],
+        other: Dict_Init[Key, Value],
         /,
     ) -> Self:
         with self.__mutate__() as mutable:
@@ -585,7 +612,7 @@ class MutableDictLike[Key: abc.Hashable, Value](
 ### DICT-SLOT ###
 
 
-class FrozenDictSlot[Key: abc.Hashable, Value](  # type: ignore[misc]
+class FrozenDictSlot[Key: abc.Hashable, Value](
     FrozenObjectSlot[FrozenDict[Key, Value]],
     FrozenDictLike[Key, Value],
 ):
@@ -596,11 +623,11 @@ class FrozenDictSlot[Key: abc.Hashable, Value](  # type: ignore[misc]
     @setdoc.basic
     def __init__(
         self: Self,
-        data: DictInit[Key, Value] = (),
+        other: Dict_Init[Key, Value] = (),
         /,
         **kwargs: Optional[Value],
     ) -> None:
-        self._slot = frozendict(data, **kwargs)  # type: ignore[arg-type]
+        self._slot = frozendict(other, **kwargs)  # type: ignore[arg-type]
 
 
 class MutableDictSlot[Key: abc.Hashable, Value](
@@ -617,10 +644,10 @@ class MutableDictSlot[Key: abc.Hashable, Value](
         self: Self,
         /,
     ) -> abc.Generator[Dict[Key, Value], None, None]:
-        slot: Dict[Key, Value]
-        slot = dict(getattr(self, "_slot", ()))
-        yield slot
-        self._slot = frozendict(slot)
+        mutable: Dict[Key, Value]
+        mutable = dict(getattr(self, "_slot", ()))
+        yield mutable
+        self._slot = frozendict(mutable)
 
 
 ### SEQUENCE ###
@@ -769,7 +796,7 @@ class ListLike[Item](Sequence[Item]):
 
     @abstractmethod
     @setdoc.basic
-    def __init__(self: Self, data: abc.Iterable[Item] = (), /) -> None: ...
+    def __init__(self: Self, other: abc.Iterable[Item] = (), /) -> None: ...
 
     @setdoc.basic
     def __le__(self: Self, other: ListLike[Any], /) -> bool:
@@ -799,7 +826,10 @@ class ListLike[Item](Sequence[Item]):
         return f"{type(self).__name__}({list(self)!r})"
 
 
-class FrozenListLike[Item](ListLike[Item], abc.Hashable):
+class FrozenListLike[Item](
+    FrozenObjectLike[tuple[Item, ...]],
+    ListLike[Item],
+):
     """Provide abc for custom frozen list-like."""
 
     __slots__ = ()
@@ -843,9 +873,9 @@ class MutableListLike[Item](
         return self
 
     @setdoc.basic
-    def __init__(self: Self, data: abc.Iterable[Item] = (), /) -> None:
+    def __init__(self: Self, other: abc.Iterable[Item] = (), /) -> None:
         with self.__mutate__() as mutable:
-            mutable.extend(data)
+            mutable.extend(other)
 
     @overload
     @setdoc.basic
@@ -894,8 +924,8 @@ class FrozenListSlot[Item](
     __slots__ = ()
 
     @setdoc.basic
-    def __init__(self: Self, data: abc.Iterable[Item] = (), /) -> None:
-        self._slot = tuple(data)
+    def __init__(self: Self, other: abc.Iterable[Item] = (), /) -> None:
+        self._slot = tuple(other)
 
 
 class MutableListSlot[Item](
@@ -909,6 +939,7 @@ class MutableListSlot[Item](
     @contextmanager
     @setdoc.basic
     def __mutate__(self: Self, /) -> abc.Generator[list[Item], None, None]:
-        slot = list(getattr(self, "_slot", ()))
-        yield slot
-        self._slot = tuple(slot)
+        mutable: list[Item]
+        mutable = list(getattr(self, "_slot", ()))
+        yield mutable
+        self._slot = tuple(mutable)

{datahold-4.0.0.dev28 → datahold-4.0.0.dev29}/src/datahold.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datahold
-Version: 4.0.0.dev28
+Version: 4.0.0.dev29
 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.dev28 → datahold-4.0.0.dev29}/src/datahold.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ src/datahold.egg-info/SOURCES.txt
 src/datahold.egg-info/dependency_links.txt
 src/datahold.egg-info/requires.txt
 src/datahold.egg-info/top_level.txt
+tests/test_FrozenDictSlot.py
 tests/test_FrozenListSlot.py
 tests/test_FrozenSetSlot.py
 tests/test_MutableDictSlot.py

datahold-4.0.0.dev29/tests/test_FrozenDictSlot.py

@@ -0,0 +1,271 @@
+import unittest
+from collections import abc
+from typing import Any, Self
+
+from datahold import FrozenDictSlot
+
+
+class TestFromKeysMethod(unittest.TestCase):
+    def test_fromkeys_uses_none_by_default(self: Self) -> None:
+        result: Any = FrozenDictSlot.fromkeys(["a", "b", "c"])
+
+        self.assertEqual(result, {"a": None, "b": None, "c": None})
+
+    def test_fromkeys_uses_provided_value(self: Self) -> None:
+        result: Any = FrozenDictSlot.fromkeys(["a", "b"], 10)
+
+        self.assertEqual(result, {"a": 10, "b": 10})
+
+    def test_fromkeys_uses_same_value_object_for_every_key(self: Self) -> None:
+        value: Any = []
+        result: Any = FrozenDictSlot.fromkeys(["a", "b"], value)
+
+        self.assertIs(result["a"], value)
+        self.assertIs(result["b"], value)
+
+    def test_fromkeys_removes_duplicate_keys(self: Self) -> None:
+        result: Any = FrozenDictSlot.fromkeys(
+            ["a", "b", "a", "c", "b"],
+            1,
+        )
+
+        self.assertEqual(list(result.keys()), ["a", "b", "c"])
+        self.assertEqual(result, {"a": 1, "b": 1, "c": 1})
+
+    def test_fromkeys_accepts_generator(self: Self) -> None:
+        keys: Any = (str(number) for number in range(3))
+        result: Any = FrozenDictSlot.fromkeys(keys, "value")
+
+        self.assertEqual(
+            result,
+            {"0": "value", "1": "value", "2": "value"},
+        )
+
+    def test_fromkeys_accepts_empty_iterable(self: Self) -> None:
+        self.assertEqual(FrozenDictSlot.fromkeys([], 1), {})
+
+    def test_fromkeys_returns_frozen_dict_slot(self: Self) -> None:
+        result: Any = FrozenDictSlot.fromkeys(["a"], 1)
+
+        self.assertIsInstance(result, FrozenDictSlot)
+
+    def test_fromkeys_rejects_unhashable_keys(self: Self) -> None:
+        with self.assertRaises(TypeError):
+            FrozenDictSlot.fromkeys([["unhashable"]], 1)  # type: ignore
+
+
+class TestGetMethod(unittest.TestCase):
+    def test_get_returns_existing_value(self: Self) -> None:
+        mapping: Any = FrozenDictSlot({"a": 1, "b": 2})
+
+        self.assertEqual(mapping.get("a"), 1)
+
+    def test_get_returns_none_for_missing_key(self: Self) -> None:
+        mapping: Any = FrozenDictSlot({"a": 1})
+
+        self.assertIsNone(mapping.get("missing"))
+
+    def test_get_returns_default_for_missing_key(self: Self) -> None:
+        mapping: Any = FrozenDictSlot({"a": 1})
+
+        self.assertEqual(mapping.get("missing", 20), 20)
+
+    def test_get_returns_existing_value_instead_of_default(self: Self) -> None:
+        mapping: Any = FrozenDictSlot({"a": 1})
+
+        self.assertEqual(mapping.get("a", 20), 1)
+
+    def test_get_returns_exact_default_object(self: Self) -> None:
+        default: Any = []
+        mapping: Any = FrozenDictSlot()
+
+        self.assertIs(mapping.get("missing", default), default)
+
+    def test_get_accepts_different_hashable_key_types(self: Self) -> None:
+        mapping: FrozenDictSlot[abc.Hashable, str]
+        mapping = FrozenDictSlot(
+            {  # type: ignore
+                1: "integer",
+                (2, 3): "tuple",
+                None: "none",
+            }
+        )
+
+        self.assertEqual(mapping.get(1), "integer")
+        self.assertEqual(mapping.get((2, 3)), "tuple")
+        self.assertEqual(mapping.get(None), "none")
+
+    def test_get_rejects_unhashable_key(self: Self) -> None:
+        self.assertIsNone(FrozenDictSlot().get([]))
+
+    def test_get_rejects_too_many_arguments(self: Self) -> None:
+        with self.assertRaises(TypeError):
+            FrozenDictSlot().get("a", 1, 2)  # type: ignore[call-overload]
+
+
+class TestItemsMethod(unittest.TestCase):
+    def test_items_contains_all_key_value_pairs(self: Self) -> None:
+        mapping: Any = FrozenDictSlot({"a": 1, "b": 2})
+
+        self.assertEqual(
+            set(mapping.items()),
+            {("a", 1), ("b", 2)},
+        )
+
+    def test_items_of_empty_mapping_is_empty(self: Self) -> None:
+        self.assertEqual(list(FrozenDictSlot().items()), [])
+
+    def test_items_preserves_insertion_order(self: Self) -> None:
+        mapping: Any = FrozenDictSlot(
+            [
+                ("third", 3),
+                ("first", 1),
+                ("second", 2),
+            ]
+        )
+
+        self.assertEqual(
+            list(mapping.items()),
+            [("third", 3), ("first", 1), ("second", 2)],
+        )
+
+    def test_items_supports_membership_testing(self: Self) -> None:
+        items: Any = FrozenDictSlot({"a": 1, "b": 2}).items()
+
+        self.assertIn(("a", 1), items)
+        self.assertNotIn(("a", 2), items)
+
+    def test_items_has_correct_length(self: Self) -> None:
+        items: Any = FrozenDictSlot(
+            {
+                "a": 1,
+                "b": 2,
+                "c": 3,
+            }
+        ).items()
+
+        self.assertEqual(len(items), 3)
+
+    def test_items_can_be_iterated_multiple_times(self: Self) -> None:
+        items: Any = FrozenDictSlot({"a": 1, "b": 2}).items()
+
+        self.assertEqual(list(items), [("a", 1), ("b", 2)])
+        self.assertEqual(list(items), [("a", 1), ("b", 2)])
+
+    def test_items_rejects_arguments(self: Self) -> None:
+        with self.assertRaises(TypeError):
+            FrozenDictSlot({"a": 1}).items("unexpected")  # type: ignore[call-arg]
+
+
+class TestKeysMethod(unittest.TestCase):
+    def test_keys_contains_all_keys(self: Self) -> None:
+        mapping: Any = FrozenDictSlot({"a": 1, "b": 2, "c": 3})
+
+        self.assertEqual(set(mapping.keys()), {"a", "b", "c"})
+
+    def test_keys_of_empty_mapping_is_empty(self: Self) -> None:
+        self.assertEqual(list(FrozenDictSlot().keys()), [])
+
+    def test_keys_preserves_insertion_order(self: Self) -> None:
+        mapping: Any = FrozenDictSlot(
+            [
+                ("third", 3),
+                ("first", 1),
+                ("second", 2),
+            ]
+        )
+
+        self.assertEqual(
+            list(mapping.keys()),
+            ["third", "first", "second"],
+        )
+
+    def test_keys_supports_membership_testing(self: Self) -> None:
+        keys: Any = FrozenDictSlot({"a": 1, "b": 2}).keys()
+
+        self.assertIn("a", keys)
+        self.assertNotIn("missing", keys)
+
+    def test_keys_has_correct_length(self: Self) -> None:
+        keys: Any = FrozenDictSlot(
+            {
+                "a": 1,
+                "b": 2,
+                "c": 3,
+            }
+        ).keys()
+
+        self.assertEqual(len(keys), 3)
+
+    def test_keys_supports_set_operations(self: Self) -> None:
+        keys: Any = FrozenDictSlot({"a": 1, "b": 2}).keys()
+
+        self.assertEqual(keys & {"b", "c"}, {"b"})
+        self.assertEqual(keys | {"c"}, {"a", "b", "c"})
+
+    def test_keys_rejects_arguments(self: Self) -> None:
+        with self.assertRaises(TypeError):
+            FrozenDictSlot({"a": 1}).keys("unexpected")  # type: ignore[call-arg]
+
+
+class TestValuesMethod(unittest.TestCase):
+    def test_values_contains_all_values(self: Self) -> None:
+        mapping: Any = FrozenDictSlot({"a": 1, "b": 2, "c": 3})
+
+        self.assertEqual(list(mapping.values()), [1, 2, 3])
+
+    def test_values_of_empty_mapping_is_empty(self: Self) -> None:
+        self.assertEqual(list(FrozenDictSlot().values()), [])
+
+    def test_values_preserves_insertion_order(self: Self) -> None:
+        mapping: Any = FrozenDictSlot(
+            [
+                ("third", 3),
+                ("first", 1),
+                ("second", 2),
+            ]
+        )
+
+        self.assertEqual(list(mapping.values()), [3, 1, 2])
+
+    def test_values_preserves_duplicates(self: Self) -> None:
+        mapping: Any = FrozenDictSlot(
+            {
+                "a": 1,
+                "b": 1,
+                "c": 2,
+            }
+        )
+
+        self.assertEqual(list(mapping.values()), [1, 1, 2])
+
+    def test_values_supports_membership_testing(self: Self) -> None:
+        values: Any = FrozenDictSlot({"a": 1, "b": 2}).values()
+
+        self.assertIn(1, values)
+        self.assertNotIn(3, values)
+
+    def test_values_has_correct_length(self: Self) -> None:
+        values: Any = FrozenDictSlot(
+            {
+                "a": 1,
+                "b": 2,
+                "c": 3,
+            }
+        ).values()
+
+        self.assertEqual(len(values), 3)
+
+    def test_values_can_be_iterated_multiple_times(self: Self) -> None:
+        values: Any = FrozenDictSlot({"a": 1, "b": 2}).values()
+
+        self.assertEqual(list(values), [1, 2])
+        self.assertEqual(list(values), [1, 2])
+
+    def test_values_rejects_arguments(self: Self) -> None:
+        with self.assertRaises(TypeError):
+            FrozenDictSlot({"a": 1}).values("unexpected")  # type: ignore[call-arg]
+
+
+if __name__ == "__main__":
+    unittest.main()

{datahold-4.0.0.dev28 → datahold-4.0.0.dev29}/tests/test_FrozenSetSlot.py

@@ -229,5 +229,248 @@ class TestNonMembershipOperator(unittest.TestCase):
         self.assertFalse({1, 2} not in FrozenSetSlot({frozenset({1, 2})}))
 
 
+class TestDifferenceMethod(unittest.TestCase):
+    def test_difference_with_overlapping_values(self: Self) -> None:
+        result = FrozenSetSlot({1, 2, 3}).difference({2, 3, 4})
+
+        self.assertEqual(result, frozenset({1}))
+
+    def test_difference_with_disjoint_values(self: Self) -> None:
+        result = FrozenSetSlot({1, 2}).difference({3, 4})
+
+        self.assertEqual(result, frozenset({1, 2}))
+
+    def test_difference_with_multiple_iterables(self: Self) -> None:
+        result = FrozenSetSlot({1, 2, 3, 4, 5}).difference(
+            {2, 3},
+            [4],
+            (5, 6),
+        )
+
+        self.assertEqual(result, frozenset({1}))
+
+    def test_difference_without_arguments(self: Self) -> None:
+        result = FrozenSetSlot({1, 2}).difference()
+
+        self.assertEqual(result, frozenset({1, 2}))
+
+    def test_difference_returns_frozen_set_slot(self: Self) -> None:
+        result = FrozenSetSlot({1, 2, 3}).difference({3})
+
+        self.assertIsInstance(result, FrozenSetSlot)
+
+    def test_difference_rejects_non_iterable(self: Self) -> None:
+        with self.assertRaises(TypeError):
+            FrozenSetSlot({1, 2}).difference(3)  # type: ignore[arg-type]
+
+
+class TestIntersectionMethod(unittest.TestCase):
+    def test_intersection_with_overlapping_values(self: Self) -> None:
+        result = FrozenSetSlot({1, 2, 3}).intersection({2, 3, 4})
+
+        self.assertEqual(result, frozenset({2, 3}))
+
+    def test_intersection_with_disjoint_values(self: Self) -> None:
+        result = FrozenSetSlot({1, 2}).intersection({3, 4})
+
+        self.assertEqual(result, frozenset())
+
+    def test_intersection_with_multiple_iterables(self: Self) -> None:
+        result = FrozenSetSlot({1, 2, 3, 4}).intersection(
+            [2, 3, 4, 5],
+            (3, 4, 6),
+        )
+
+        self.assertEqual(result, frozenset({3, 4}))
+
+    def test_intersection_without_arguments(self: Self) -> None:
+        result = FrozenSetSlot({1, 2}).intersection()
+
+        self.assertEqual(result, frozenset({1, 2}))
+
+    def test_intersection_returns_frozen_set_slot(self: Self) -> None:
+        result = FrozenSetSlot({1, 2, 3}).intersection({2, 3})
+
+        self.assertIsInstance(result, FrozenSetSlot)
+
+    def test_intersection_accepts_generator(self: Self) -> None:
+        values = (value for value in range(2, 5))
+        result = FrozenSetSlot({1, 2, 3}).intersection(values)
+
+        self.assertEqual(result, frozenset({2, 3}))
+
+
+class TestIsDisjointMethod(unittest.TestCase):
+    def test_disjoint_iterables(self: Self) -> None:
+        result = FrozenSetSlot({1, 2}).isdisjoint({3, 4})
+
+        self.assertTrue(result)
+
+    def test_overlapping_iterables(self: Self) -> None:
+        result = FrozenSetSlot({1, 2, 3}).isdisjoint({3, 4})
+
+        self.assertFalse(result)
+
+    def test_empty_instance_is_disjoint(self: Self) -> None:
+        result = FrozenSetSlot().isdisjoint({1, 2})
+
+        self.assertTrue(result)
+
+    def test_is_disjoint_with_empty_iterable(self: Self) -> None:
+        result = FrozenSetSlot({1, 2}).isdisjoint([])
+
+        self.assertTrue(result)
+
+    def test_is_disjoint_accepts_generator(self: Self) -> None:
+        values = (value for value in range(3, 6))
+        result = FrozenSetSlot({1, 2, 3}).isdisjoint(values)
+
+        self.assertFalse(result)
+
+    def test_is_disjoint_rejects_non_iterable(self: Self) -> None:
+        with self.assertRaises(TypeError):
+            FrozenSetSlot({1, 2}).isdisjoint(3)  # type: ignore[arg-type]
+
+
+class TestIsSubsetMethod(unittest.TestCase):
+    def test_proper_subset(self: Self) -> None:
+        result = FrozenSetSlot({1, 2}).issubset({1, 2, 3})
+
+        self.assertTrue(result)
+
+    def test_equal_set_is_subset(self: Self) -> None:
+        result = FrozenSetSlot({1, 2}).issubset([2, 1])
+
+        self.assertTrue(result)
+
+    def test_non_subset(self: Self) -> None:
+        result = FrozenSetSlot({1, 2, 4}).issubset({1, 2, 3})
+
+        self.assertFalse(result)
+
+    def test_empty_instance_is_subset(self: Self) -> None:
+        result = FrozenSetSlot().issubset({1, 2})
+
+        self.assertTrue(result)
+
+    def test_nonempty_instance_is_not_subset_of_empty_iterable(
+        self: Self,
+    ) -> None:
+        result = FrozenSetSlot({1}).issubset([])
+
+        self.assertFalse(result)
+
+    def test_is_subset_accepts_generator(self: Self) -> None:
+        values = (value for value in range(1, 4))
+        result = FrozenSetSlot({1, 2}).issubset(values)
+
+        self.assertTrue(result)
+
+
+class TestIsSupersetMethod(unittest.TestCase):
+    def test_proper_superset(self: Self) -> None:
+        result = FrozenSetSlot({1, 2, 3}).issuperset({1, 2})
+
+        self.assertTrue(result)
+
+    def test_equal_set_is_superset(self: Self) -> None:
+        result = FrozenSetSlot({1, 2}).issuperset([2, 1])
+
+        self.assertTrue(result)
+
+    def test_non_superset(self: Self) -> None:
+        result = FrozenSetSlot({1, 2}).issuperset({1, 2, 3})
+
+        self.assertFalse(result)
+
+    def test_every_instance_is_superset_of_empty_iterable(self: Self) -> None:
+        result = FrozenSetSlot({1, 2}).issuperset([])
+
+        self.assertTrue(result)
+
+    def test_empty_instance_is_not_superset_of_nonempty_iterable(
+        self: Self,
+    ) -> None:
+        result = FrozenSetSlot().issuperset({1})
+
+        self.assertFalse(result)
+
+    def test_is_superset_accepts_generator(self: Self) -> None:
+        values = (value for value in range(1, 3))
+        result = FrozenSetSlot({1, 2, 3}).issuperset(values)
+
+        self.assertTrue(result)
+
+
+class TestSymmetricDifferenceMethod(unittest.TestCase):
+    def test_symmetric_difference_with_overlap(self: Self) -> None:
+        result = FrozenSetSlot({1, 2, 3}).symmetric_difference({3, 4})
+
+        self.assertEqual(result, frozenset({1, 2, 4}))
+
+    def test_symmetric_difference_with_disjoint_values(self: Self) -> None:
+        result = FrozenSetSlot({1, 2}).symmetric_difference([3, 4])
+
+        self.assertEqual(result, frozenset({1, 2, 3, 4}))
+
+    def test_symmetric_difference_with_equal_values(self: Self) -> None:
+        result = FrozenSetSlot({1, 2}).symmetric_difference((2, 1))
+
+        self.assertEqual(result, frozenset())
+
+    def test_symmetric_difference_with_empty_iterable(self: Self) -> None:
+        result = FrozenSetSlot({1, 2}).symmetric_difference([])
+
+        self.assertEqual(result, frozenset({1, 2}))
+
+    def test_symmetric_difference_returns_frozen_set_slot(self: Self) -> None:
+        result = FrozenSetSlot({1, 2}).symmetric_difference({2, 3})
+
+        self.assertIsInstance(result, FrozenSetSlot)
+
+    def test_symmetric_difference_rejects_multiple_arguments(
+        self: Self,
+    ) -> None:
+        with self.assertRaises(TypeError):
+            FrozenSetSlot({1, 2}).symmetric_difference({2}, {3})  # type: ignore[call-arg]
+
+
+class TestUnionMethod(unittest.TestCase):
+    def test_union_with_overlapping_values(self: Self) -> None:
+        result = FrozenSetSlot({1, 2, 3}).union({3, 4})
+
+        self.assertEqual(result, frozenset({1, 2, 3, 4}))
+
+    def test_union_with_disjoint_values(self: Self) -> None:
+        result = FrozenSetSlot({1, 2}).union([3, 4])
+
+        self.assertEqual(result, frozenset({1, 2, 3, 4}))
+
+    def test_union_with_multiple_iterables(self: Self) -> None:
+        result = FrozenSetSlot({1}).union(
+            [2, 3],
+            (3, 4),
+            frozenset({5}),
+        )
+
+        self.assertEqual(result, frozenset({1, 2, 3, 4, 5}))
+
+    def test_union_without_arguments(self: Self) -> None:
+        result = FrozenSetSlot({1, 2}).union()
+
+        self.assertEqual(result, frozenset({1, 2}))
+
+    def test_union_returns_frozen_set_slot(self: Self) -> None:
+        result = FrozenSetSlot({1, 2}).union({3})
+
+        self.assertIsInstance(result, FrozenSetSlot)
+
+    def test_union_accepts_generator(self: Self) -> None:
+        values = (value for value in range(2, 5))
+        result = FrozenSetSlot({1, 2}).union(values)
+
+        self.assertEqual(result, frozenset({1, 2, 3, 4}))
+
+
 if __name__ == "__main__":
     unittest.main()

{datahold-4.0.0.dev28 → datahold-4.0.0.dev29}/tests/test_MutableDictSlot.py

@@ -136,8 +136,7 @@ class TestGet(unittest.TestCase):
     def test_get_rejects_unhashable_key(self: Self) -> None:
         value: MutableDictSlot[Any, Any]
         value = MutableDictSlot({"a": 1})
-        with self.assertRaises(TypeError):
-            value.get([])
+        self.assertIsNone(value.get([]))
         self.assertEqual(value, {"a": 1})
 
 

{datahold-4.0.0.dev28 → datahold-4.0.0.dev29}/tests/testdata.toml

@@ -141,6 +141,10 @@ args = [
 [datatypes.FrozenListSlot.varia]
 generic = 1
 
+[datatypes.FrozenObjectLike.issubclass]
+"collections.abc.Hashable" = true
+"datahold.Object" = true
+
 [datatypes.FrozenObjectSlot.issubclass]
 "datahold.ObjectSlot" = true