datahold 4.0.0.dev27__tar.gz → 4.0.0.dev28__tar.gz

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

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

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

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

@@ -9,6 +9,7 @@ __all__: list[str] = [
     "FrozenDictSlot",
     "FrozenListLike",
     "FrozenListSlot",
+    "FrozenObjectSlot",
     "FrozenSetLike",
     "FrozenSetSlot",
     "ListLike",
@@ -18,16 +19,20 @@ __all__: list[str] = [
     "MutableListLike",
     "MutableListSlot",
     "MutableMapping",
+    "MutableObject",
+    "MutableObjectLike",
     "MutableSequence",
     "MutableSet",
     "MutableSetLike",
     "MutableSetSlot",
+    "Object",
+    "ObjectSlot",
     "Sequence",
     "Set",
     "SetLike",
 ]
 
-from abc import abstractmethod
+from abc import ABCMeta, abstractmethod
 from collections import abc
 from contextlib import contextmanager
 from types import NotImplementedType, TracebackType
@@ -164,15 +169,82 @@ class MutableSequence_Mutable[Item](Protocol):
 
 ### TYPE ALIASES ###
 
+type Dict[Key, Value] = dict[Key | str, Optional[Value]]
 
 type DictInit[Key, Value] = (
     SupportsKeysAndGetitem[Key | str, Optional[Value]]
     | abc.Iterable[tuple[Key | str, Optional[Value]]]
 )
 
+type FrozenDict[Key, Value] = frozendict[Key | str, Optional[Value]]
+
 type Slice[Index] = slice[Optional[Index], Optional[Index], Optional[Index]]
 
 
+### OBJECT ###
+class Object[Frozen](metaclass=ABCMeta):
+    """Provide abc for custom object."""
+
+    __slots__ = ()
+
+    @abstractmethod
+    @setdoc.basic
+    def __frozen__(self: Self, /) -> Frozen: ...
+
+
+class MutableObject[Frozen, Mutable](Object[Frozen]):
+    """Provide abc for custom mutable object."""
+
+    __slots__ = ()
+
+    @abstractmethod
+    @setdoc.basic
+    def __mutate__(self: Self, /) -> ContextManager[Mutable]: ...
+
+
+### OBJECT-LIKE ###
+
+
+class MutableObjectLike[Frozen, Mutable](
+    MutableObject[Frozen, Mutable],
+):
+    """Provide abc for custom mutable object-like."""
+
+    __slots__ = ()
+
+    @abstractmethod
+    @setdoc.basic
+    def __init__(self: Self, other: Self, /) -> None: ...
+    @setdoc.basic
+    def copy(self: Self, /) -> Self:
+        return type(self)(self)
+
+
+### OBJECT-HOLD ###
+
+
+class ObjectSlot[Frozen](
+    Object[Frozen],
+):
+    """Provide slotted abc for custom object-like."""
+
+    __slots__ = ("_slot",)
+    _slot: Frozen
+
+
+class FrozenObjectSlot[Frozen](
+    ObjectSlot[Frozen],
+):
+    """Provide slotted abc for custom frozen object-like."""
+
+    __slots__ = ()
+    _slot: Frozen
+
+    @setdoc.basic
+    def __frozen__(self: Self, /) -> Frozen:
+        return self._slot
+
+
 ### COLLECTION ###
 
 
@@ -180,11 +252,10 @@ class Collection[Item](
     abc.Sized,
     abc.Iterable[Item],
     abc.Container[object],
+    Object[Collection_Frozen[Item]],
 ):
     """Provide abc for custom collection."""
 
-    type __Frozen__[Item_] = Collection_Frozen[Item_]
-
     @setdoc.basic
     def __contains__(self: Self, other: object, /) -> bool:
         try:
@@ -192,10 +263,6 @@ class Collection[Item](
         except TypeError:
             return other in (x for x in self)  # type: ignore[operator]
 
-    @abstractmethod
-    @setdoc.basic
-    def __frozen__(self: Self, /) -> Collection_Frozen[Item]: ...
-
     @setdoc.basic
     def __iter__(self: Self, /) -> abc.Iterator[Item]:
         return iter(self.__frozen__())
@@ -214,15 +281,15 @@ class Set[Item: abc.Hashable](Collection[Item], abc.Set[Item]):
     __slots__ = ()
 
 
-class MutableSet[Item: abc.Hashable](Set[Item], abc.MutableSet[Item]):
+class MutableSet[Item: abc.Hashable](
+    Set[Item],
+    abc.MutableSet[Item],
+    MutableObject[Collection_Frozen[Item], MutableSet_Mutable[Item]],
+):
     """Provide abc for custom mutable set."""
 
     __slots__ = ()
-    type __Mutable__[Item_] = MutableSet_Mutable[Item_]
 
-    @abstractmethod
-    @setdoc.basic
-    def __mutate__(self: Self) -> ContextManager[MutableSet_Mutable[Item]]: ...
     @setdoc.basic
     def add(self: Self, item: Item, /) -> None:
         with self.__mutate__() as mutable:
@@ -241,11 +308,10 @@ class SetLike[Item: abc.Hashable](Set[Item]):
     """Provide abc for custom set-like."""
 
     __slots__ = ()
-    type __Frozen__[Item_] = frozenset[Item_]
 
     @abstractmethod
     @setdoc.basic
-    def __frozen__(self: Self, /) -> __Frozen__[Item]: ...
+    def __frozen__(self: Self, /) -> frozenset[Item]: ...
     @abstractmethod
     @setdoc.basic
     def __init__(self: Self, data: abc.Iterable[Item] = (), /) -> None: ...
@@ -286,14 +352,17 @@ class FrozenSetLike[Item: abc.Hashable](SetLike[Item], abc.Hashable):
         return hash(self.__frozen__())
 
 
-class MutableSetLike[Item: abc.Hashable](SetLike[Item], MutableSet[Item]):
+class MutableSetLike[Item: abc.Hashable](
+    SetLike[Item],
+    MutableObjectLike[frozenset[Item], set[Item]],
+    MutableSet[Item],
+):
     """Provide abc for custom mutable set-like."""
 
     __slots__ = ()
-    type __Mutable__[Item_] = set[Item_]
 
     @setdoc.basic
-    def __frozen__(self: Self, /) -> MutableSetLike.__Frozen__[Item]:
+    def __frozen__(self: Self, /) -> frozenset[Item]:
         with self.__mutate__() as mutable:
             return frozenset(mutable)
 
@@ -302,14 +371,6 @@ class MutableSetLike[Item: abc.Hashable](SetLike[Item], MutableSet[Item]):
         with self.__mutate__() as mutable:
             mutable.update(data)
 
-    @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]
@@ -340,36 +401,34 @@ class MutableSetLike[Item: abc.Hashable](SetLike[Item], MutableSet[Item]):
 ### SET-SLOT ###
 
 
-class FrozenSetSlot[Item](FrozenSetLike[Item]):
+class FrozenSetSlot[Item](
+    FrozenObjectSlot[frozenset[Item]],
+    FrozenSetLike[Item],
+):
     """Provide slotted frozen set-like."""
 
-    __slots__ = ("_slot",)
-
-    _slot: FrozenSetSlot.__Frozen__[Item]
-
-    @setdoc.basic
-    def __frozen__(self: Self, /) -> FrozenSetSlot.__Frozen__[Item]:
-        return self._slot
+    __slots__ = ()
 
     @setdoc.basic
     def __init__(self: Self, data: abc.Iterable[Item] = (), /) -> None:
         self._slot = frozenset(data)
 
 
-class MutableSetSlot[Item](MutableSetLike[Item]):
+class MutableSetSlot[Item](
+    MutableSetLike[Item],
+    ObjectSlot[frozenset[Item]],
+):
     """Provide slotted mutable set-like."""
 
-    __slots__ = ("_slot",)
-
-    _slot: FrozenSetSlot.__Frozen__[Item]
+    __slots__ = ()
 
     @contextmanager
     @setdoc.basic
     def __mutate__(
         self: Self,
         /,
-    ) -> abc.Generator[MutableSetSlot.__Mutable__[Item], None, None]:
-        slot: MutableSetSlot.__Mutable__[Item]
+    ) -> abc.Generator[set[Item], None, None]:
+        slot: set[Item]
         slot = set(getattr(self, "_slot", ()))
         yield slot
         self._slot = frozenset(slot)
@@ -386,11 +445,9 @@ class Mapping[Key: abc.Hashable, Value](
 
     __slots__ = ()
 
-    type __Frozen__[Key_, Value_] = Mapping_Frozen[Key_, Value_]
-
     @abstractmethod
     @setdoc.basic
-    def __frozen__(self: Self, /) -> __Frozen__[Key, Value]: ...
+    def __frozen__(self: Self, /) -> Mapping_Frozen[Key, Value]: ...
     @setdoc.basic
     def __getitem__(self: Self, key: abc.Hashable, /) -> Value:
         return self.__frozen__()[key]
@@ -399,21 +456,17 @@ class Mapping[Key: abc.Hashable, Value](
 class MutableMapping[Key: abc.Hashable, Value](
     Mapping[Key, Value],
     abc.MutableMapping[Key | str, Optional[Value]],
+    MutableObject[FrozenDict[Key, Value], Dict[Key, Value]],
 ):
     """Provide abc for custom mutable mapping."""
 
     __slots__ = ()
 
-    type __Mutable__[Key_, Value_] = MutableMapping_Mutable[Key_, Value_]
-
     @setdoc.basic
     def __delitem__(self: Self, key: Key | str, /) -> None:
         with self.__mutate__() as mutable:
             del mutable[key]
 
-    @abstractmethod
-    @setdoc.basic
-    def __mutate__(self: Self) -> ContextManager[__Mutable__[Key, Value]]: ...
     @setdoc.basic
     def __setitem__(
         self: Self, key: Key | str, value: Optional[Value], /
@@ -431,11 +484,12 @@ class DictLike[Key: abc.Hashable, Value](
     """Provide abc for custom dict-like."""
 
     __slots__ = ()
-    type __Frozen__[Key_, Value_] = frozendict[Key_ | str, Optional[Value_]]
 
     @abstractmethod
     @setdoc.basic
-    def __frozen__(self: Self, /) -> __Frozen__[Key, Value]: ...  # type: ignore[override]
+    def __frozen__(self: Self, /) -> FrozenDict[Key, Value]:  # type: ignore[override]
+        ...
+
     @abstractmethod
     @setdoc.basic
     def __init__(
@@ -450,13 +504,13 @@ class DictLike[Key: abc.Hashable, Value](
         other: DictInit[Key_, Value_],
         /,
     ) -> DictLike[Key | Key_, Value | Value_]:
-        data: DictLike.__Frozen__[Key_, Value_]
+        data: FrozenDict[Key, Value]
         try:
             data = frozendict(other)  # type: ignore[arg-type]
         except TypeError:
             return NotImplemented
         return type(self)(  # type: ignore[return-value]
-            self.__frozen__() | data  # type: ignore[operator]
+            self.__frozen__() | data
         )
 
     @classmethod
@@ -485,20 +539,18 @@ class FrozenDictLike[Key: abc.Hashable, Value](
 
 class MutableDictLike[Key: abc.Hashable, Value](
     DictLike[Key, Value],
+    MutableObjectLike[FrozenDict[Key, Value], Dict[Key, Value]],
     MutableMapping[Key, Value],
 ):
     """Provide abc for custom mutable dict-like."""
 
     __slots__ = ()
-    type __Mutable__[Key_: abc.Hashable, Value_] = dict[
-        Key_ | str, Optional[Value_]
-    ]
 
     @setdoc.basic
     def __frozen__(  # type: ignore[override]
         self: Self,
         /,
-    ) -> MutableDictLike.__Frozen__[Key, Value]:
+    ) -> FrozenDict[Key, Value]:
         with self.__mutate__() as mutable:
             return frozendict(mutable)
 
@@ -521,15 +573,6 @@ class MutableDictLike[Key: abc.Hashable, Value](
             mutable |= other
         return self
 
-    @abstractmethod
-    @setdoc.basic
-    def __mutate__(
-        self: Self, /
-    ) -> ContextManager[__Mutable__[Key, Value]]: ...
-    @setdoc.basic
-    def copy(self: Self, /) -> Self:
-        return type(self)(self)
-
     @setdoc.basic
     def popitem(self: Self, /) -> tuple[Key | str, Optional[Value]]:
         # for most dict d
@@ -542,19 +585,13 @@ class MutableDictLike[Key: abc.Hashable, Value](
 ### DICT-SLOT ###
 
 
-class FrozenDictSlot[Key: abc.Hashable, Value](
+class FrozenDictSlot[Key: abc.Hashable, Value](  # type: ignore[misc]
+    FrozenObjectSlot[FrozenDict[Key, Value]],
     FrozenDictLike[Key, Value],
 ):
     """Provide slotted frozen dict-like."""
 
-    __slots__ = ("_slot",)
-    _slot: FrozenDictSlot.__Frozen__[Key, Value]
-
-    @setdoc.basic
-    def __frozen__(  # type: ignore[override]
-        self: Self,
-    ) -> FrozenDictSlot.__Frozen__[Key, Value]:
-        return self._slot
+    __slots__ = ()
 
     @setdoc.basic
     def __init__(
@@ -568,19 +605,19 @@ class FrozenDictSlot[Key: abc.Hashable, Value](
 
 class MutableDictSlot[Key: abc.Hashable, Value](
     MutableDictLike[Key, Value],
+    ObjectSlot[FrozenDict[Key, Value]],
 ):
     """Provide slotted mutable dict-like."""
 
-    __slots__ = ("_slot",)
-    _slot: FrozenDictSlot.__Frozen__[Key, Value]
+    __slots__ = ()
 
     @contextmanager
     @setdoc.basic
     def __mutate__(
         self: Self,
         /,
-    ) -> abc.Generator[MutableDictSlot.__Mutable__[Key, Value], None, None]:
-        slot: MutableDictSlot.__Mutable__[Key, Value]
+    ) -> abc.Generator[Dict[Key, Value], None, None]:
+        slot: Dict[Key, Value]
         slot = dict(getattr(self, "_slot", ()))
         yield slot
         self._slot = frozendict(slot)
@@ -593,11 +630,10 @@ class Sequence[Item](Collection[Item], abc.Sequence[Item]):
     """Provide abc for customized sequence."""
 
     __slots__ = ()
-    type __Frozen__[Item_] = Sequence_Frozen[Item_]
 
     @abstractmethod
     @setdoc.basic
-    def __frozen__(self: Self, /) -> __Frozen__[Item]: ...
+    def __frozen__(self: Self, /) -> Sequence_Frozen[Item]: ...
     @overload
     @setdoc.basic
     def __getitem__(self: Self, key: int, /) -> Item: ...
@@ -611,11 +647,14 @@ class Sequence[Item](Collection[Item], abc.Sequence[Item]):
         return self.__frozen__()[key]
 
 
-class MutableSequence[Item](Sequence[Item], abc.MutableSequence[Item]):
+class MutableSequence[Item](
+    Sequence[Item],
+    abc.MutableSequence[Item],
+    MutableObject[Sequence_Frozen[Item], MutableSequence_Mutable[Item]],
+):
     """Provide abc for custom mutable sequence."""
 
     __slots__ = ()
-    type __Mutable__[Item_] = MutableSequence_Mutable[Item_]
 
     @overload
     @setdoc.basic
@@ -643,10 +682,6 @@ class MutableSequence[Item](Sequence[Item], abc.MutableSequence[Item]):
         with self.__mutate__() as mutable:
             return mutable[key]
 
-    @abstractmethod
-    @setdoc.basic
-    def __mutate__(self: Self, /) -> ContextManager[__Mutable__[Item]]: ...
-
     @overload
     @setdoc.basic
     def __setitem__(self: Self, key: int, value: Item, /) -> None: ...
@@ -677,9 +712,6 @@ class ListLike[Item](Sequence[Item]):
 
     __slots__ = ()
 
-    type __Frozen__[Item_] = tuple[Item_, ...]
-    # Frozen has to be tuple to allow covariance
-
     @setdoc.basic
     def __add__[Item_](
         self: Self, other: ListLike[Item_], /
@@ -698,7 +730,9 @@ class ListLike[Item](Sequence[Item]):
 
     @abstractmethod
     @setdoc.basic
-    def __frozen__(self: Self, /) -> __Frozen__[Item]: ...
+    def __frozen__(self: Self, /) -> tuple[Item, ...]:
+        # __frozen__ has to be tuple to allow covariance
+        ...
 
     @setdoc.basic
     def __ge__(self: Self, other: ListLike[Any], /) -> bool:
@@ -771,17 +805,19 @@ class FrozenListLike[Item](ListLike[Item], abc.Hashable):
     __slots__ = ()
 
     @setdoc.basic
-    def __hash__(self: Self) -> int:
+    def __hash__(self: Self, /) -> int:
         return hash(self.__frozen__())
 
 
-class MutableListLike[Item](ListLike[Item], MutableSequence[Item]):
+class MutableListLike[Item](
+    ListLike[Item],
+    MutableObjectLike[tuple[Item, ...], list[Item]],
+    MutableSequence[Item],
+):
     """Provide abc for custom mutable list-like."""
 
     __slots__ = ()
 
-    type __Mutable__[Item_] = list[Item_]
-
     @overload
     @setdoc.basic
     def __delitem__(self: Self, key: SupportsIndex, /) -> None: ...
@@ -796,7 +832,7 @@ class MutableListLike[Item](ListLike[Item], MutableSequence[Item]):
             del mutable[key]
 
     @setdoc.basic
-    def __frozen__(self: Self) -> MutableListLike.__Frozen__[Item]:
+    def __frozen__(self: Self) -> tuple[Item, ...]:
         with self.__mutate__() as mutable:
             return tuple(mutable)
 
@@ -811,10 +847,6 @@ class MutableListLike[Item](ListLike[Item], MutableSequence[Item]):
         with self.__mutate__() as mutable:
             mutable.extend(data)
 
-    @abstractmethod
-    @setdoc.basic
-    def __mutate__(self: Self, /) -> ContextManager[__Mutable__[Item]]: ...
-
     @overload
     @setdoc.basic
     def __setitem__(
@@ -835,10 +867,6 @@ class MutableListLike[Item](ListLike[Item], MutableSequence[Item]):
         with self.__mutate__() as mutable:
             mutable[key] = value  # type: ignore
 
-    @setdoc.basic
-    def copy(self: Self) -> Self:
-        return type(self)(self)
-
     @setdoc.basic
     def insert(self: Self, index: SupportsIndex, item: Item, /) -> None:
         with self.__mutate__() as mutable:
@@ -857,26 +885,26 @@ class MutableListLike[Item](ListLike[Item], MutableSequence[Item]):
 ### LIST-SLOT ###
 
 
-class FrozenListSlot[Item](FrozenListLike[Item]):
+class FrozenListSlot[Item](
+    FrozenObjectSlot[tuple[Item, ...]],
+    FrozenListLike[Item],
+):
     """Provide slotted frozen list-like."""
 
-    __slots__ = ("_slot",)
-    _slot: FrozenListSlot.__Frozen__[Item]
-
-    @setdoc.basic
-    def __frozen__(self: Self) -> FrozenListSlot.__Frozen__[Item]:
-        return self._slot
+    __slots__ = ()
 
     @setdoc.basic
     def __init__(self: Self, data: abc.Iterable[Item] = (), /) -> None:
         self._slot = tuple(data)
 
 
-class MutableListSlot[Item](MutableListLike[Item]):
+class MutableListSlot[Item](
+    MutableListLike[Item],
+    ObjectSlot[tuple[Item, ...]],
+):
     """Provide slotted mutable list-like."""
 
-    __slots__ = ("_slot",)
-    _slot: MutableListSlot.__Frozen__[Item]
+    __slots__ = ()
 
     @contextmanager
     @setdoc.basic

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

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

@@ -20,6 +20,7 @@ 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_FrozenSetSlot.py
 tests/test_MutableDictSlot.py
 tests/test_MutableListSlot.py
 tests/test_MutableSetSlot.py
@@ -28,8 +29,8 @@ tests/test_all.py
 tests/test_attributes.py
 tests/test_docs.py
 tests/test_generic.py
-tests/test_internal_comparison.py
 tests/test_issubclass.py
+tests/test_metaclass.py
 tests/test_name.py
 tests/test_nested.py
 tests/test_sorted.py

datahold-4.0.0.dev28/tests/test_FrozenSetSlot.py

@@ -0,0 +1,233 @@
+import unittest
+from typing import Self
+
+from datahold import FrozenSetSlot
+
+
+class TestUnionOperator(unittest.TestCase):
+    def test_union_with_overlap(self: Self) -> None:
+        self.assertEqual(
+            FrozenSetSlot({1, 2, 3}) | FrozenSetSlot({3, 4}),
+            frozenset({1, 2, 3, 4}),
+        )
+
+    def test_union_with_disjoint_sets(self: Self) -> None:
+        self.assertEqual(
+            FrozenSetSlot({1, 2}) | FrozenSetSlot({3, 4}),
+            frozenset({1, 2, 3, 4}),
+        )
+
+    def test_union_with_empty_set(self: Self) -> None:
+        self.assertEqual(
+            FrozenSetSlot({1, 2}) | FrozenSetSlot(),
+            frozenset({1, 2}),
+        )
+
+    def test_union_with_builtin_frozenset(self: Self) -> None:
+        self.assertEqual(
+            FrozenSetSlot({1, 2}) | frozenset({2, 3}),
+            frozenset({1, 2, 3}),
+        )
+
+
+class TestIntersectionOperator(unittest.TestCase):
+    def test_intersection_with_overlap(self: Self) -> None:
+        self.assertEqual(
+            FrozenSetSlot({1, 2, 3}) & FrozenSetSlot({2, 3, 4}),
+            frozenset({2, 3}),
+        )
+
+    def test_intersection_with_disjoint_sets(self: Self) -> None:
+        self.assertEqual(
+            FrozenSetSlot({1, 2}) & FrozenSetSlot({3, 4}),
+            frozenset(),
+        )
+
+    def test_intersection_with_empty_set(self: Self) -> None:
+        self.assertEqual(
+            FrozenSetSlot({1, 2}) & FrozenSetSlot(),
+            frozenset(),
+        )
+
+    def test_intersection_with_builtin_set(self: Self) -> None:
+        self.assertEqual(
+            FrozenSetSlot({1, 2, 3}) & {2, 3, 4},
+            frozenset({2, 3}),
+        )
+
+
+class TestDifferenceOperator(unittest.TestCase):
+    def test_difference_with_overlap(self: Self) -> None:
+        self.assertEqual(
+            FrozenSetSlot({1, 2, 3}) - FrozenSetSlot({2, 3, 4}),
+            frozenset({1}),
+        )
+
+    def test_difference_with_disjoint_sets(self: Self) -> None:
+        self.assertEqual(
+            FrozenSetSlot({1, 2}) - FrozenSetSlot({3, 4}),
+            frozenset({1, 2}),
+        )
+
+    def test_difference_with_identical_sets(self: Self) -> None:
+        self.assertEqual(
+            FrozenSetSlot({1, 2}) - FrozenSetSlot({1, 2}),
+            frozenset(),
+        )
+
+    def test_difference_with_empty_set(self: Self) -> None:
+        self.assertEqual(
+            FrozenSetSlot({1, 2}) - FrozenSetSlot(),
+            frozenset({1, 2}),
+        )
+
+
+class TestSymmetricDifferenceOperator(unittest.TestCase):
+    def test_symmetric_difference_with_overlap(self: Self) -> None:
+        self.assertEqual(
+            FrozenSetSlot({1, 2, 3}) ^ FrozenSetSlot({3, 4}),
+            frozenset({1, 2, 4}),
+        )
+
+    def test_symmetric_difference_with_disjoint_sets(self: Self) -> None:
+        self.assertEqual(
+            FrozenSetSlot({1, 2}) ^ FrozenSetSlot({3, 4}),
+            frozenset({1, 2, 3, 4}),
+        )
+
+    def test_symmetric_difference_with_identical_sets(self: Self) -> None:
+        self.assertEqual(
+            FrozenSetSlot({1, 2}) ^ FrozenSetSlot({1, 2}),
+            frozenset(),
+        )
+
+    def test_symmetric_difference_with_empty_set(self: Self) -> None:
+        self.assertEqual(
+            FrozenSetSlot({1, 2}) ^ FrozenSetSlot(),
+            frozenset({1, 2}),
+        )
+
+
+class TestSubsetOperator(unittest.TestCase):
+    def test_equal_sets_are_subsets(self: Self) -> None:
+        self.assertTrue(FrozenSetSlot({1, 2}) <= FrozenSetSlot({1, 2}))
+
+    def test_proper_subset_is_subset(self: Self) -> None:
+        self.assertTrue(FrozenSetSlot({1, 2}) <= FrozenSetSlot({1, 2, 3}))
+
+    def test_larger_set_is_not_subset(self: Self) -> None:
+        self.assertFalse(FrozenSetSlot({1, 2, 3}) <= FrozenSetSlot({1, 2}))
+
+    def test_empty_set_is_subset(self: Self) -> None:
+        self.assertTrue(FrozenSetSlot() <= FrozenSetSlot({1}))
+
+
+class TestProperSubsetOperator(unittest.TestCase):
+    def test_proper_subset(self: Self) -> None:
+        self.assertTrue(FrozenSetSlot({1, 2}) < FrozenSetSlot({1, 2, 3}))
+
+    def test_equal_sets_are_not_proper_subsets(self: Self) -> None:
+        self.assertFalse(FrozenSetSlot({1, 2}) < FrozenSetSlot({1, 2}))
+
+    def test_larger_set_is_not_proper_subset(self: Self) -> None:
+        self.assertFalse(FrozenSetSlot({1, 2, 3}) < FrozenSetSlot({1, 2}))
+
+    def test_empty_set_is_proper_subset_of_nonempty_set(self: Self) -> None:
+        self.assertTrue(FrozenSetSlot() < FrozenSetSlot({1}))
+
+
+class TestSupersetOperator(unittest.TestCase):
+    def test_equal_sets_are_supersets(self: Self) -> None:
+        self.assertTrue(FrozenSetSlot({1, 2}) >= FrozenSetSlot({1, 2}))
+
+    def test_larger_set_is_superset(self: Self) -> None:
+        self.assertTrue(FrozenSetSlot({1, 2, 3}) >= FrozenSetSlot({1, 2}))
+
+    def test_smaller_set_is_not_superset(self: Self) -> None:
+        self.assertFalse(FrozenSetSlot({1, 2}) >= FrozenSetSlot({1, 2, 3}))
+
+    def test_every_set_is_superset_of_empty_set(self: Self) -> None:
+        self.assertTrue(FrozenSetSlot({1}) >= FrozenSetSlot())
+
+
+class TestProperSupersetOperator(unittest.TestCase):
+    def test_proper_superset(self: Self) -> None:
+        self.assertTrue(FrozenSetSlot({1, 2, 3}) > FrozenSetSlot({1, 2}))
+
+    def test_equal_sets_are_not_proper_supersets(self: Self) -> None:
+        self.assertFalse(FrozenSetSlot({1, 2}) > FrozenSetSlot({1, 2}))
+
+    def test_smaller_set_is_not_proper_superset(self: Self) -> None:
+        self.assertFalse(FrozenSetSlot({1, 2}) > FrozenSetSlot({1, 2, 3}))
+
+    def test_nonempty_set_is_proper_superset_of_empty_set(self: Self) -> None:
+        self.assertTrue(FrozenSetSlot({1}) > FrozenSetSlot())
+
+
+class TestEqualityOperator(unittest.TestCase):
+    def test_equal_instances(self: Self) -> None:
+        self.assertTrue(FrozenSetSlot({1, 2, 3}) == FrozenSetSlot({3, 2, 1}))
+
+    def test_equal_to_builtin_frozenset(self: Self) -> None:
+        self.assertTrue(FrozenSetSlot({1, 2}) == frozenset({1, 2}))  # type: ignore[comparison-overlap]
+
+    def test_equal_to_builtin_set(self: Self) -> None:
+        self.assertTrue(FrozenSetSlot({1, 2}) == {1, 2})  # type: ignore[comparison-overlap]
+
+    def test_unequal_values(self: Self) -> None:
+        self.assertFalse(FrozenSetSlot({1, 2}) == FrozenSetSlot({1, 3}))
+
+    def test_not_equal_to_non_set_object(self: Self) -> None:
+        self.assertFalse(FrozenSetSlot({1, 2}) == [1, 2])  # type: ignore[comparison-overlap]
+
+
+class TestInequalityOperator(unittest.TestCase):
+    def test_different_instances_are_unequal(self: Self) -> None:
+        self.assertTrue(FrozenSetSlot({1, 2}) != FrozenSetSlot({1, 3}))
+
+    def test_equal_instances_are_not_unequal(self: Self) -> None:
+        self.assertFalse(FrozenSetSlot({1, 2}) != FrozenSetSlot({2, 1}))
+
+    def test_equal_builtin_frozenset_is_not_unequal(self: Self) -> None:
+        self.assertFalse(FrozenSetSlot({1, 2}) != frozenset({1, 2}))  # type: ignore[comparison-overlap]
+
+    def test_different_builtin_set_is_unequal(self: Self) -> None:
+        self.assertTrue(FrozenSetSlot({1, 2}) != {1, 2, 3})  # type: ignore[comparison-overlap]
+
+    def test_non_set_object_is_unequal(self: Self) -> None:
+        self.assertTrue(FrozenSetSlot({1, 2}) != [1, 2])  # type: ignore[comparison-overlap]
+
+
+class TestMembershipOperator(unittest.TestCase):
+    def test_existing_element_is_member(self: Self) -> None:
+        self.assertTrue(2 in FrozenSetSlot({1, 2, 3}))
+
+    def test_missing_element_is_not_member(self: Self) -> None:
+        self.assertFalse(4 in FrozenSetSlot({1, 2, 3}))
+
+    def test_nested_frozenset_is_member(self: Self) -> None:
+        nested = frozenset({1, 2})
+        self.assertTrue(nested in FrozenSetSlot({nested, frozenset({3})}))
+
+    def test_equivalent_set_matches_nested_frozenset(self: Self) -> None:
+        self.assertTrue({1, 2} in FrozenSetSlot({frozenset({1, 2})}))
+
+
+class TestNonMembershipOperator(unittest.TestCase):
+    def test_missing_element_is_not_member(self: Self) -> None:
+        self.assertTrue(4 not in FrozenSetSlot({1, 2, 3}))
+
+    def test_existing_element_is_member(self: Self) -> None:
+        self.assertFalse(2 not in FrozenSetSlot({1, 2, 3}))
+
+    def test_missing_nested_frozenset_is_not_member(self: Self) -> None:
+        self.assertTrue(
+            frozenset({3, 4}) not in FrozenSetSlot({frozenset({1, 2})})
+        )
+
+    def test_equivalent_set_is_considered_a_member(self: Self) -> None:
+        self.assertFalse({1, 2} not in FrozenSetSlot({frozenset({1, 2})}))
+
+
+if __name__ == "__main__":
+    unittest.main()

{datahold-4.0.0.dev27 → datahold-4.0.0.dev28}/tests/test_abstractmethods.py

@@ -4,7 +4,7 @@ __all__: list[str] = ["TestAbstractmethods"]
 
 import inspect as ins
 import unittest
-from typing import Any, Optional, Self
+from typing import Any, Self
 
 from Lazy import Lazy
 
@@ -22,6 +22,8 @@ class TestAbstractmethods(unittest.TestCase):
     def test_abstractmethods(self: Self, /) -> None:
         name: Any
         for name in Lazy.lazy.datatypes.keys():
+            if "Object" in name:
+                continue
             with self.subTest(datatype=name):
                 self._test(name, Lazy.get_abstractmethods(name))
 

datahold-4.0.0.dev28/tests/test_metaclass.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+__all__: list[str] = ["TestMetaclass"]
+
+import unittest
+from abc import ABCMeta
+from typing import Any, Self
+
+from Lazy import Lazy
+
+import datahold
+
+
+class TestMetaclass(unittest.TestCase):
+
+    def test_metaclass(self: Self, /) -> None:
+        datatype: type[Any]
+        for name in Lazy.lazy.datatypes.keys():
+            with self.subTest(datatype=name):
+                datatype = getattr(datahold, name)
+                self.assertIs(type(datatype), ABCMeta)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

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

@@ -31,28 +31,28 @@ class TestName(unittest.TestCase):
         # all
         datatype = getattr(datahold, name)
         self.assertEqual(datatype.__name__, name)
-        self.assertTrue(hasattr(datatype, "__Frozen__"))
-        self.assertTrue(hasattr(datatype, "__frozen__"))
+        self.assertTrue(issubclass(datatype, datahold.Object))
+        if "Object" in name:
+            return
         self.assertTrue(issubclass(datatype, datahold.Collection))
+        self.assertTrue(hasattr(datatype, "__frozen__"))
         # frozen
         if prefix == "Frozen":
             self.assertIsNot(datatype.__hash__, object.__hash__)
             self.assertTrue(issubclass(datatype, abc.Hashable))
-            self.assertFalse(hasattr(datatype, "__Mutable__"))
             self.assertFalse(hasattr(datatype, "__mutate__"))
             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, datahold.MutableObject))
             ancestor = getattr(datahold, name[7:], object)
             self.assertTrue(issubclass(datatype, ancestor))
         # no prefix
         if prefix == "":
             self.assertIn(datatype.__hash__, [None, object.__hash__])
-            self.assertFalse(hasattr(datatype, "__Mutable__"))
             self.assertFalse(hasattr(datatype, "__mutate__"))
         # like
         if suffix == "Like":
@@ -60,6 +60,7 @@ class TestName(unittest.TestCase):
         # slot
         if suffix == "Slot":
             self.assertTrue(hasattr(datatype, "__init__"))
+            self.assertTrue(issubclass(datatype, datahold.ObjectSlot))
             ancestor = getattr(datahold, name[:-4] + "Like")
             self.assertTrue(issubclass(datatype, ancestor))
         # no suffix

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

@@ -1,4 +1,5 @@
-[datatypes.Collection]
+[datatypes.Collection.issubclass]
+"datahold.Object" = true
 
 [datatypes.DictLike.attributes]
 __or__ = "datahold.DictLike"
@@ -27,8 +28,6 @@ __init__ = "datahold.ListLike"
 "collections.abc.Sequence" = true
 
 [datatypes.FrozenListLike.nested]
-__Frozen__ = "builtins.tuple"
-__Mutable__ = ""
 
 [datatypes.FrozenListLike.varia]
 generic = 1
@@ -138,12 +137,16 @@ args = [
 ]
 
 [datatypes.FrozenListSlot.nested]
-__Frozen__ = "builtins.tuple"
-__Mutable__ = ""
 
 [datatypes.FrozenListSlot.varia]
 generic = 1
 
+[datatypes.FrozenObjectSlot.issubclass]
+"datahold.ObjectSlot" = true
+
+[datatypes.FrozenObjectSlot.varia]
+generic = 1
+
 [datatypes.FrozenSetLike.issubclass]
 "collections.abc.Hashable" = true
 "collections.abc.Set" = true
@@ -172,8 +175,6 @@ index = "collections.abc.Sequence"
 "datahold.MutableSequence" = false
 
 [datatypes.ListLike.nested]
-__Frozen__ = "builtins.tuple"
-__Mutable__ = ""
 
 [datatypes.ListLike.varia]
 generic = 1
@@ -185,11 +186,13 @@ generic = 1
 [datatypes.MutableDictLike.attributes]
 __ior__ = "datahold.MutableDictLike"
 __or__ = "datahold.DictLike"
+copy = "datahold.MutableObjectLike"
 
 [datatypes.MutableDictLike.issubclass]
 "collections.abc.Mapping" = true
 "collections.abc.MutableMapping" = true
 "datahold.MutableMapping" = true
+"datahold.MutableObjectLike" = true
 
 [datatypes.MutableDictSlot.issubclass]
 "collections.abc.Mapping" = true
@@ -207,6 +210,7 @@ __mutate__ = "datahold.MutableListLike"
 __reversed__ = "collections.abc.Sequence"
 append = "collections.abc.MutableSequence"
 clear = "collections.abc.MutableSequence"
+copy = "datahold.MutableObjectLike"
 count = "collections.abc.Sequence"
 extend = "collections.abc.MutableSequence"
 foo = ""
@@ -221,10 +225,10 @@ reverse = "collections.abc.MutableSequence"
 "collections.abc.Hashable" = false
 "collections.abc.MutableMapping" = false
 "collections.abc.MutableSequence" = true
+"datahold.MutableObjectLike" = true
 "datahold.MutableSequence" = true
 
 [datatypes.MutableListLike.nested]
-__Frozen__ = "builtins.tuple"
 __hash__ = ""
 
 [datatypes.MutableListLike.varia]
@@ -237,7 +241,6 @@ generic = 1
 "datahold.MutableListSlot" = true
 
 [datatypes.MutableListSlot.nested]
-__Frozen__ = "builtins.tuple"
 __hash__ = ""
 
 [datatypes.MutableListSlot.varia]
@@ -247,9 +250,17 @@ generic = 1
 "collections.abc.MutableMapping" = true
 "datahold.Mapping" = true
 
+[datatypes.MutableObject.issubclass]
+"datahold.Object" = true
+
+[datatypes.MutableObjectLike.attributes]
+__init__ = "datahold.MutableObjectLike"
+copy = "datahold.MutableObjectLike"
+
+[datatypes.MutableObjectLike.issubclass]
+"datahold.Object" = true
+
 [datatypes.MutableSequence.attributes]
-__Frozen__ = "datahold.Sequence"
-__Mutable__ = "datahold.MutableSequence"
 __delitem__ = "datahold.MutableSequence"
 __frozen__ = "datahold.Sequence"
 __getitem__ = "datahold.MutableSequence"
@@ -263,11 +274,15 @@ sort = ""
 "collections.abc.Set" = true
 "datahold.Collection" = true
 
+[datatypes.MutableSetLike.attributes]
+copy = "datahold.MutableObjectLike"
+
 [datatypes.MutableSetLike.issubclass]
 "collections.abc.Hashable" = false
 "collections.abc.MutableSet" = true
 "collections.abc.Set" = true
 "datahold.Collection" = true
+"datahold.MutableObjectLike" = true
 "datahold.MutableSet" = true
 "datahold.SetLike" = true
 
@@ -278,6 +293,15 @@ sort = ""
 "datahold.MutableSet" = true
 "datahold.MutableSetLike" = true
 
+[datatypes.Object.varia]
+generic = 1
+
+[datatypes.ObjectSlot.issubclass]
+"datahold.Object" = true
+
+[datatypes.ObjectSlot.varia]
+generic = 1
+
 [datatypes.Sequence]
 
 [datatypes.Set.issubclass]

datahold-4.0.0.dev27/tests/test_internal_comparison.py

@@ -1,50 +0,0 @@
-import operator
-import unittest
-from typing import Any, Self
-
-from Lazy import Lazy
-
-
-class TestInternalComparsion(unittest.TestCase):
-    def _test_typename(self: Self, typename: str, /, **kwargs: Any) -> None:
-        for opername, info in kwargs.items():
-            oper = getattr(operator, opername)
-            with self.subTest(operator=opername):
-                self._test_operator(typename, oper, **info)
-
-    def _test_operator(self: Self, *args: Any, **kwargs: Any) -> None:
-        for testname, testinfo in kwargs.items():
-            with self.subTest(testname=testname):
-                self._test_vars(*args, **testinfo)
-
-    def _test_vars(
-        self: Self,
-        typename: str,
-        oper: Any,
-        /,
-        *,
-        a: str,
-        b: str,
-        valid: bool = True,
-    ) -> None:
-        example_a = Lazy.get_example(typename, a)
-        example_b = Lazy.get_example(typename, b)
-        builtin_a = Lazy.get_builtin_example(typename, a)
-        builtin_b = Lazy.get_builtin_example(typename, b)
-        if valid:
-            answer = oper(example_a, example_b)
-            solution = oper(builtin_a, builtin_b)
-            self.assertEqual(answer, solution)
-            return
-        with self.assertRaises(Exception):
-            answer = oper(example_a, example_b)
-        with self.assertRaises(Exception):
-            solution = oper(builtin_a, builtin_b)
-
-    def test_internal_comparison(self: Self) -> None:
-        for typename, info in Lazy.lazy.datatypes.items():
-            with self.subTest(typename=typename):
-                self._test_typename(
-                    typename,
-                    **info.get("TestInternalComparsion", {}),
-                )