datahold 4.0.0.dev6__tar.gz → 4.0.0.dev7__tar.gz

{datahold-4.0.0.dev6 → datahold-4.0.0.dev7}/PKG-INFO

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

@@ -34,7 +34,7 @@ license-files = [
 name = "datahold"
 readme = "README.rst"
 requires-python = ">=3.12"
-version = "4.0.0.dev6"
+version = "4.0.0.dev7"
 
 [project.urls]
 Download = "https://pypi.org/project/datahold/#files"

{datahold-4.0.0.dev6 → datahold-4.0.0.dev7}/src/datahold/__init__.py

@@ -10,19 +10,13 @@ __all__: list[str] = [
     "BaseDataMapping",
     "BaseDataSequence",
     "BaseDataSet",
-    "BaseHoldCollection",
+    "BaseHoldObject",
     "DataDict",
     "DataList",
     "DataSet",
     "FrozenDataDict",
     "FrozenDataList",
     "FrozenDataSet",
-    "FrozenHoldDict",
-    "FrozenHoldList",
-    "FrozenHoldSet",
-    "HoldDict",
-    "HoldList",
-    "HoldSet",
 ]
 
 import enum
@@ -45,6 +39,11 @@ from frozendict import frozendict
 ### UTILS ###
 
 
+class Copyable(Protocol):
+    @setdoc.basic
+    def copy(self: Self) -> Self: ...
+
+
 class Missing(enum.Enum):
     missing = None
 
@@ -61,6 +60,23 @@ class SupportsKeysAndGetitem[Key, Value](Protocol):
     def keys(self: Self) -> abc.Iterable[Key]: ...
 
 
+### OBJECT ###
+
+
+class BaseHoldObject[HoldData: Copyable]:
+    """Provide abc for usable classes with slots."""
+
+    __slots__ = ("_data",)
+
+    @setdoc.basic
+    def __fget__(self: Self) -> HoldData:
+        return self._data.copy()
+
+    @setdoc.basic
+    def __fset__(self: Self, data: HoldData, /) -> None:
+        self._data: HoldData = data
+
+
 ### COLLECTION ###
 
 
@@ -103,12 +119,6 @@ class BaseDataCollection[Item](
     def __fget__(self: Self) -> Data[Item]: ...
 
 
-class BaseHoldCollection[Item](BaseDataCollection[Item]):
-    """Provide abc for usable classes with slots."""
-
-    __slots__ = ("_data",)
-
-
 ### ABSTRACT SET ###
 
 
@@ -189,23 +199,6 @@ class FrozenDataSet[Item: abc.Hashable](BaseDataSet[Item], abc.Hashable):
         return hash(frozenset(self.__fget__()))
 
 
-class FrozenHoldSet[Item: abc.Hashable](
-    FrozenDataSet[Item],
-    BaseHoldCollection[Item],
-):
-    """Provide usable frozen set-like with slots."""
-
-    __slots__ = ()
-
-    @setdoc.basic
-    def __fget__(self: Self) -> FrozenHoldSet.Data[Item]:
-        return set(self._data)
-
-    @setdoc.basic
-    def __fset__(self: Self, data: FrozenHoldSet.Data[Item], /) -> None:
-        self._data: FrozenHoldSet.Data[Item] = data
-
-
 class DataSet[Item: abc.Hashable](
     BaseDataSet[Item],
     abc.MutableSet[Item],
@@ -229,57 +222,40 @@ class DataSet[Item: abc.Hashable](
         *others: abc.Iterable[abc.Hashable],
     ) -> None:
         data: set[Item]
-        data = set(self.__fget__())
+        data = self.__fget__()
         data.difference_update(*others)
-        self.__fset__(set(data))
+        self.__fset__(data)
 
     @setdoc.basic
     def discard(self: Self, item: abc.Hashable, /) -> None:
         data: set[Item]
-        data = set(self.__fget__())
+        data = self.__fget__()
         data.discard(item)
-        self.__fset__(set(data))
+        self.__fset__(data)
 
     @setdoc.basic
     def intersection_update(
         self: Self, /, *others: abc.Iterable[abc.Hashable]
     ) -> None:
         data: set[Item]
-        data = set(self.__fget__())
+        data = self.__fget__()
         data.intersection_update(*others)
-        self.__fset__(set(data))
+        self.__fset__(data)
 
     @setdoc.basic
     def symmetric_difference_update(
         self: Self, other: abc.Iterable[Item], /
     ) -> None:
         data: set[Item]
-        data = set(self.__fget__())
+        data = self.__fget__()
         data.symmetric_difference_update(other)
-        self.__fset__(set(data))
+        self.__fset__(data)
 
     @setdoc.basic
     def update(self: Self, /, *others: abc.Iterable[Item]) -> None:
         self.__fset__(self.__fget__().union(*others))
 
 
-class HoldSet[Item: abc.Hashable](
-    DataSet[Item],
-    BaseHoldCollection[Item],
-):
-    """Provide usable mutable set-like with slots."""
-
-    __slots__ = ()
-
-    @setdoc.basic
-    def __fget__(self: Self) -> HoldSet.Data[Item]:
-        return set(self._data)
-
-    @setdoc.basic
-    def __fset__(self: Self, value: HoldSet.Data[Item], /) -> None:
-        self._data: HoldSet.Data[Item] = value
-
-
 ### MAPPING ###
 class BaseDataMapping[Key, Value](
     BaseDataCollection[Key], abc.Mapping[Key, Value]
@@ -385,23 +361,6 @@ class FrozenDataDict[Key: abc.Hashable, Value](
         return hash(frozendict(self.__fget__()))
 
 
-class FrozenHoldDict[Key: abc.Hashable, Value](
-    FrozenDataDict[Key, Value],
-    BaseHoldCollection[Key | str],
-):
-    """Provide usable frozen dict-like with slots."""
-
-    __slots__ = ()
-
-    @setdoc.basic
-    def __fget__(self: Self) -> FrozenHoldDict.Data[Key, Value]:
-        return dict(self._data)
-
-    @setdoc.basic
-    def __fset__(self: Self, data: FrozenHoldDict.Data[Key, Value], /) -> None:
-        self._data: FrozenHoldDict.Data[Key, Value] = data
-
-
 class DataDict[Key: abc.Hashable, Value](
     BaseDataDict[Key, Value],
     abc.MutableMapping[Key | str, Optional[Value]],
@@ -444,27 +403,6 @@ class DataDict[Key: abc.Hashable, Value](
         return type(self)(self)
 
 
-class HoldDict[Key: abc.Hashable, Value](
-    DataDict[Key, Value],
-    BaseHoldCollection[Key | str],
-):
-    """Provide usable mutable dict-like with slots."""
-
-    __slots__ = ()
-
-    @setdoc.basic
-    def __fget__(self: Self) -> HoldDict.Data[Key, Value]:
-        return dict(self._data)
-
-    @setdoc.basic
-    def __fset__(
-        self: Self,
-        value: HoldDict.Data[Key, Value],
-        /,
-    ) -> None:
-        self._data: HoldDict.Data[Key, Value] = value
-
-
 ### SEQUENCE ###
 
 
@@ -627,23 +565,6 @@ class FrozenDataList[Item](
         return hash(tuple(self.__fget__()))
 
 
-class FrozenHoldList[Item](
-    FrozenDataList[Item],
-    BaseHoldCollection[Item],
-):
-    """Provide usable frozen list-like with slots."""
-
-    __slots__ = ()
-
-    @setdoc.basic
-    def __fget__(self: Self) -> FrozenHoldList.Data[Item]:
-        return list(self._data)
-
-    @setdoc.basic
-    def __fset__(self: Self, data: FrozenHoldList.Data[Item], /) -> None:
-        self._data: FrozenHoldList.Data[Item] = data
-
-
 class DataList[Item](
     BaseDataList[Item],
     abc.MutableSequence[Item],
@@ -710,20 +631,3 @@ class DataList[Item](
         data = self.__fget__()
         data.sort(key=key, reverse=reverse)
         self.__fset__(data)
-
-
-class HoldList[Item](
-    DataList[Item],
-    BaseHoldCollection[Item],
-):
-    """Provide usable mutable list-like with slots."""
-
-    __slots__ = ()
-
-    @setdoc.basic
-    def __fget__(self: Self) -> HoldList.Data[Item]:
-        return list(self._data)
-
-    @setdoc.basic
-    def __fset__(self: Self, value: HoldList.Data[Item], /) -> None:
-        self._data: HoldList.Data[Item] = value

{datahold-4.0.0.dev6 → datahold-4.0.0.dev7}/src/datahold.egg-info/PKG-INFO

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

@@ -25,9 +25,5 @@ tests/test_FrozenHoldSet.py
 tests/test_HoldDict.py
 tests/test_HoldList.py
 tests/test_HoldSet.py
-tests/test_datahold_TestCopy.py
-tests/test_datahold_TestDataAttribute.py
-tests/test_datahold_TestFrozenMutability.py
-tests/test_datahold_TestMutableBehavior.py
 tests/test_testdata.py
 tests/testdata.toml

{datahold-4.0.0.dev6 → datahold-4.0.0.dev7}/tests/test_FrozenHoldDict.py

@@ -1,11 +1,55 @@
-__all__: list[str] = ["TestFrozenHoldDict"]
+__all__: list[str] = [
+    "TestCopy",
+    "TestDataAttribute",
+    "TestFrozenHoldDict",
+    "TestFrozenMutability",
+]
 
 import unittest
+from collections import abc
 from typing import Any, Self
 
 from frozendict import frozendict
 
-from datahold import FrozenHoldDict
+from datahold import BaseHoldObject, FrozenDataDict
+
+
+class FrozenHoldDict[Key: abc.Hashable, Value](
+    BaseHoldObject[FrozenDataDict.Data[Key, Value]],
+    FrozenDataDict[Key, Value],
+):
+    """Provide usable frozen dict-like with slots."""
+
+    __slots__ = ()
+
+
+class TestCopy(unittest.TestCase):
+
+    def test_frozen_have_no_copy_2(self: Self) -> None:
+        """
+        Frozen classes should not define their own copy method.
+        (If a parent class or wrapped object exposes one, we ignore that.)
+        """
+        args: Any
+        cls: Any
+        copy_obj: Any
+        obj: Any
+        cls, args = (FrozenHoldDict, ({"a": 1},))
+        # They must not *define* copy themselves
+        self.assertNotIn("copy", cls.__dict__)
+        # Optional: if they *do* expose copy on the instance, it should not
+        # create a mutable variant; you can drop this if you prefer.
+        obj = cls(*args)
+        if hasattr(obj, "copy"):
+            copy_obj = obj.copy()
+            self.assertIsInstance(copy_obj, cls)
+
+
+class TestDataAttribute(unittest.TestCase):
+    def test_dict_data_is_immutable_mapping(self: Self) -> None:
+        f: FrozenHoldDict[Any, Any]
+        f = FrozenHoldDict({"a": 1})
+        self.assertIsInstance(f.__fget__(), dict)
 
 
 class TestFrozenHoldDict(unittest.TestCase):
@@ -127,5 +171,15 @@ class TestFrozenHoldDict(unittest.TestCase):
         )
 
 
+class TestFrozenMutability(unittest.TestCase):
+    def test_frozen_dict_cannot_mutate(self: Self) -> None:
+        f: Any
+        f = FrozenHoldDict({"a": 1})
+        with self.assertRaises((TypeError, AttributeError)):
+            f["b"] = 2
+        with self.assertRaises((TypeError, AttributeError)):
+            f.pop("a", None)
+
+
 if __name__ == "__main__":
     unittest.main()

{datahold-4.0.0.dev6 → datahold-4.0.0.dev7}/tests/test_FrozenHoldList.py

@@ -1,8 +1,51 @@
-__all__: list[str] = ["TestFrozenHoldLists"]
+__all__: list[str] = [
+    "TestCopy",
+    "TestDataAttribute",
+    "TestFrozenHoldLists",
+    "TestFrozenMutability",
+]
 import unittest
 from typing import Any, Self
 
-from datahold import FrozenHoldList
+from datahold import BaseHoldObject, FrozenDataList
+
+
+class FrozenHoldList[Item](
+    BaseHoldObject[FrozenDataList.Data[Item]],
+    FrozenDataList[Item],
+):
+    """Provide usable frozen list-like with slots."""
+
+    __slots__ = ()
+
+
+class TestCopy(unittest.TestCase):
+
+    def test_frozen_have_no_copy_2(self: Self) -> None:
+        """
+        Frozen classes should not define their own copy method.
+        (If a parent class or wrapped object exposes one, we ignore that.)
+        """
+        args: Any
+        cls: Any
+        copy_obj: Any
+        obj: Any
+        cls, args = (FrozenHoldList, ([1, 2],))
+        # They must not *define* copy themselves
+        self.assertNotIn("copy", cls.__dict__)
+        # Optional: if they *do* expose copy on the instance, it should not
+        # create a mutable variant; you can drop this if you prefer.
+        obj = cls(*args)
+        if hasattr(obj, "copy"):
+            copy_obj = obj.copy()
+            self.assertIsInstance(copy_obj, cls)
+
+
+class TestDataAttribute(unittest.TestCase):
+    def test_list_data_is_tuple(self: Self) -> None:
+        f: FrozenHoldList[Any]
+        f = FrozenHoldList([1, 2, 3])
+        self.assertIsInstance(f.__fget__(), list)
 
 
 class TestFrozenHoldList(unittest.TestCase):
@@ -144,5 +187,15 @@ class TestFrozenHoldList(unittest.TestCase):
             self.obj.index(99)
 
 
+class TestFrozenMutability(unittest.TestCase):
+    def test_frozen_list_cannot_mutate(self: Self) -> None:
+        f: Any
+        f = FrozenHoldList([1, 2, 3])
+        with self.assertRaises((TypeError, AttributeError)):
+            f.append(4)
+        with self.assertRaises((TypeError, AttributeError)):
+            f.pop()
+
+
 if __name__ == "__main__":
     unittest.main()

{datahold-4.0.0.dev6 → datahold-4.0.0.dev7}/tests/test_FrozenHoldSet.py

@@ -1,8 +1,54 @@
-__all__: list[str] = ["TestFrozenHoldSet"]
+__all__: list[str] = [
+    "TestCopy",
+    "TestDataAttribute",
+    "TestFrozenHoldSet",
+    "TestFrozenMutability",
+]
 import unittest
-from typing import Self
+from collections import abc
+from typing import Any, Self
 
-from datahold import FrozenHoldSet
+from datahold import BaseHoldObject, FrozenDataSet
+
+
+class FrozenHoldSet[Item: abc.Hashable](
+    BaseHoldObject[FrozenDataSet.Data[Item]],
+    FrozenDataSet[Item],
+):
+    """Provide usable frozen set-like with slots."""
+
+    __slots__ = ()
+
+
+class TestCopy(unittest.TestCase):
+
+    def test_frozen_have_no_copy_2(self: Self) -> None:
+        """
+        Frozen classes should not define their own copy method.
+        (If a parent class or wrapped object exposes one, we ignore that.)
+        """
+        args: Any
+        cls: Any
+        copy_obj: Any
+        obj: Any
+        cls = FrozenHoldSet
+        args = ({1, 2},)
+        # They must not *define* copy themselves
+        self.assertNotIn("copy", cls.__dict__)
+
+        # Optional: if they *do* expose copy on the instance, it should not
+        # create a mutable variant; you can drop this if you prefer.
+        obj = cls(*args)
+        if hasattr(obj, "copy"):
+            copy_obj = obj.copy()
+            self.assertIsInstance(copy_obj, cls)
+
+
+class TestDataAttribute(unittest.TestCase):
+    def test_set_data_is_frozenset(self: Self) -> None:
+        f: FrozenHoldSet[Any]
+        f = FrozenHoldSet({1, 2, 3})
+        self.assertIsInstance(f.__fget__(), set)
 
 
 class TestFrozenHoldSet(unittest.TestCase):
@@ -185,5 +231,16 @@ class TestFrozenHoldSet(unittest.TestCase):
         )
 
 
+class TestFrozenMutability(unittest.TestCase):
+
+    def test_frozen_set_cannot_mutate(self: Self) -> None:
+        f: Any
+        f = FrozenHoldSet({1, 2, 3})
+        with self.assertRaises((TypeError, AttributeError)):
+            f.add(4)
+        with self.assertRaises((TypeError, AttributeError)):
+            f.remove(1)
+
+
 if __name__ == "__main__":
     unittest.main()

{datahold-4.0.0.dev6 → datahold-4.0.0.dev7}/tests/test_HoldDict.py

@@ -1,8 +1,45 @@
-__all__: list[str] = ["TestHoldDict"]
+__all__: list[str] = [
+    "TestDataAttribute",
+    "TestHoldDict",
+    "TestMutableBehavior",
+    "TestCopy",
+]
 import unittest
-from typing import Any, Self
+from collections import abc
+from typing import Any, Self, cast
 
-from datahold import HoldDict
+from datahold import BaseHoldObject, DataDict
+
+
+class HoldDict[Key: abc.Hashable, Value](
+    BaseHoldObject[DataDict.Data[Key, Value]],
+    DataDict[Key, Value],
+):
+    """Provide usable mutable dict-like with slots."""
+
+    __slots__ = ()
+
+
+class TestCopy(unittest.TestCase):
+    def test_mutable_copy_returns_same_type_and_is_shallow(self: Self) -> None:
+        d: HoldDict[str, dict[str, int]]
+        d_copy: HoldDict[str, dict[str, int]]
+        d = HoldDict({"a": {"x": 1}})
+        d_copy = d.copy()
+        self.assertIsInstance(d_copy, type(d))
+        self.assertIsNot(d_copy, d)
+        self.assertEqual(dict(d_copy), dict(d))
+
+        # shallow: inner object is shared
+        cast(dict[str, int], d["a"])["x"] = 2
+        self.assertEqual(cast(dict[str, int], d_copy["a"])["x"], 2)
+
+
+class TestDataAttribute(unittest.TestCase):
+    def test_dict_data_is_immutable_mapping(self: Self) -> None:
+        m: HoldDict[Any, Any]
+        m = HoldDict({"a": 1})
+        self.assertIsInstance(m.__fget__(), dict)
 
 
 class TestHoldDict(unittest.TestCase):
@@ -164,5 +201,14 @@ class TestHoldDict(unittest.TestCase):
         self.assertIsNot(result, self.obj)
 
 
+class TestMutableBehavior(unittest.TestCase):
+    def test_hold_dict_mutates_and_syncs_data(self: Self) -> None:
+        x: HoldDict[Any, Any]
+        x = HoldDict({"a": 1})
+        x["b"] = 2
+        self.assertEqual(x["b"], 2)
+        self.assertEqual(x.__fget__()["b"], 2)
+
+
 if __name__ == "__main__":
     unittest.main()

{datahold-4.0.0.dev6 → datahold-4.0.0.dev7}/tests/test_HoldList.py

@@ -1,8 +1,44 @@
-__all__: list[str] = ["TestHoldList"]
+__all__: list[str] = [
+    "TestCopy",
+    "TestDataAttribute",
+    "TestHoldList",
+    "TestMutableBehavior",
+]
 import unittest
 from typing import Any, Self
 
-from datahold import HoldList
+from datahold import BaseHoldObject, DataList
+
+
+class HoldList[Item](
+    BaseHoldObject[DataList.Data[Item]],
+    DataList[Item],
+):
+    """Provide usable mutable list-like with slots."""
+
+    __slots__ = ()
+
+
+class TestCopy(unittest.TestCase):
+
+    def test_list_copy(self: Self) -> None:
+        lst: HoldList[Any]
+        lst_copy: HoldList[Any]
+        lst = HoldList([[1], [2]])
+        lst_copy = lst.copy()
+        self.assertIsInstance(lst_copy, type(lst))
+        self.assertIsNot(lst_copy, lst)
+        self.assertEqual(list(lst_copy), list(lst))
+
+        lst[0].append(99)
+        self.assertEqual(lst_copy[0], [1, 99])
+
+
+class TestDataAttribute(unittest.TestCase):
+    def test_list_data_is_tuple(self: Self) -> None:
+        m: HoldList[Any]
+        m = HoldList([1, 2, 3])
+        self.assertIsInstance(m.__fget__(), list)
 
 
 class TestHoldList(unittest.TestCase):
@@ -212,5 +248,15 @@ class TestHoldList(unittest.TestCase):
         )
 
 
+class TestMutableBehavior(unittest.TestCase):
+
+    def test_hold_list_mutates_and_syncs_data(self: Self) -> None:
+        x: HoldList[Any]
+        x = HoldList([1, 2])
+        x.append(3)
+        self.assertEqual(list(x), [1, 2, 3])
+        self.assertEqual(x.__fget__(), [1, 2, 3])
+
+
 if __name__ == "__main__":
     unittest.main()

{datahold-4.0.0.dev6 → datahold-4.0.0.dev7}/tests/test_HoldSet.py

@@ -1,7 +1,45 @@
+__all__: list[str] = [
+    "TestCopy",
+    "TestDataAttribute",
+    "TestHoldSet",
+    "TestMutableBehavior",
+]
 import unittest
+from collections import abc
 from typing import Any, Self
 
-from datahold import HoldSet
+from datahold import BaseHoldObject, DataSet
+
+
+class HoldSet[Item: abc.Hashable](
+    BaseHoldObject[DataSet.Data[Item]],
+    DataSet[Item],
+):
+    """Provide usable mutable set-like with slots."""
+
+    __slots__ = ()
+
+
+class TestCopy(unittest.TestCase):
+
+    def test_set_copy(self: Self) -> None:
+        s: HoldSet[Any]
+        s_copy: HoldSet[Any]
+        s = HoldSet({1, 2, 3})
+        s_copy = s.copy()
+        self.assertIsInstance(s_copy, type(s))
+        self.assertIsNot(s_copy, s)
+        self.assertEqual(set(s_copy), set(s))
+
+        s.add(4)
+        self.assertNotIn(4, s_copy)
+
+
+class TestDataAttribute(unittest.TestCase):
+    def test_set_data_is_frozenset(self: Self) -> None:
+        m: HoldSet[Any]
+        m = HoldSet({1, 2, 3})
+        self.assertIsInstance(m.__fget__(), set)
 
 
 class TestHoldSet(unittest.TestCase):
@@ -234,5 +272,14 @@ class TestHoldSet(unittest.TestCase):
         )
 
 
+class TestMutableBehavior(unittest.TestCase):
+    def test_hold_set_mutates_and_syncs_data(self: Self) -> None:
+        s: HoldSet[Any]
+        s = HoldSet({1, 2})
+        s.add(3)
+        self.assertTrue(3 in s)
+        self.assertTrue(3 in s.__fget__())
+
+
 if __name__ == "__main__":
     unittest.main()

{datahold-4.0.0.dev6 → datahold-4.0.0.dev7}/tests/test_testdata.py

@@ -1,5 +1,6 @@
 __all__: list[str] = [
     "TestAbstractness",
+    "TestAll",
     "TestCollection",
     "TestConstructor",
     "TestData",
@@ -25,6 +26,10 @@ import datahold
 class Lazy(enum.Enum):
     lazy = None
 
+    @cached_property
+    def HOLD_TYPES(self: Self) -> list[str]:
+        return cast(list[str], self.varia["HOLD_TYPES"])
+
     @cached_property
     def METHODS(self: Self) -> tuple[str, ...]:
         return cast(tuple[str, ...], self.test_object["METHODS"])
@@ -54,6 +59,10 @@ class Lazy(enum.Enum):
     def types(self: Self) -> dict[str, dict[str, Any]]:
         return cast(dict[str, dict[str, Any]], self.data["types"])
 
+    @cached_property
+    def varia(self: Self) -> dict[str, Any]:
+        return cast(dict[str, Any], self.data["varia"])
+
 
 class TestAbstractness(unittest.TestCase):
 
@@ -69,6 +78,18 @@ class TestAbstractness(unittest.TestCase):
                 self.go_types(typename, **kwargs)
 
 
+class TestAll(unittest.TestCase):
+    def test_all(self: Self) -> None:
+        self.assertLessEqual(
+            set(datahold.__all__),
+            Lazy.lazy.types.keys() | Lazy.lazy.HOLD_TYPES,
+        )
+        self.assertListEqual(
+            datahold.__all__,
+            list(sorted(datahold.__all__)),
+        )
+
+
 class TestCollection(unittest.TestCase):
     def _test_cls(self: Self, cls: type) -> None:
         method: Any
@@ -182,10 +203,8 @@ class TestDirData(unittest.TestCase):
     def go_init(self: Self, x: str, /) -> None:
         cls: Any
         cls = getattr(datahold, x)
-        self.assertEqual(
-            "__fget__" in cls.__dict__,
-            "Data" in cls.__dict__ or not ins.isabstract(cls),
-        )
+        if "__fget__" in cls.__dict__:
+            self.assertTrue("Data" in cls.__dict__ or not ins.isabstract(cls))
         if "__fset__" in cls.__dict__:
             self.assertIn("__fget__", cls.__dict__)
         self.assertEqual(

{datahold-4.0.0.dev6 → datahold-4.0.0.dev7}/tests/testdata.toml

@@ -48,7 +48,12 @@ BaseDataCollection = true
 Hashable = false
 
 [types.BaseDataSequence]
-dirData = []
+dirData = [
+    "__contains__",
+    "__getitem__",
+    "__iter__",
+    "__len__",
+]
 
 [types.BaseDataSequence.parents]
 BaseDataCollection = true
@@ -58,16 +63,10 @@ Hashable = true
 dirData = []
 
 [types.BaseDataSet.parents]
+BaseDataAbstractSet = true
 Hashable = false
 Set = true
 
-[types.BaseHoldCollection]
-dirData = []
-
-[types.BaseHoldCollection.parents]
-BaseDataCollection = true
-Hashable = true
-
 [types.DataDict]
 Data = "frozendict"
 dirData = []
@@ -79,6 +78,7 @@ valid = false
 
 [types.DataDict.parents]
 BaseDataDict = true
+BaseDataMapping = true
 MutableMapping = true
 
 [types.DataList]
@@ -130,130 +130,7 @@ isabstract = true
 
 [types.FrozenDataSet.parents]
 
-[types.FrozenHoldDict]
-dirData = []
-
-[types.FrozenHoldDict.constructor.concrete]
-args = [
-    { a = 1 },
-]
-
-[types.FrozenHoldDict.constructor.concrete-1.kwargs]
-a = 1
-
-[types.FrozenHoldDict.parents]
-Mapping = true
-MutableMapping = false
-
-[types.FrozenHoldList]
-dirData = []
-
-[types.FrozenHoldList.constructor.concrete]
-args = [
-    [
-        1,
-        2,
-    ],
-]
-repr = "FrozenHoldList([1, 2])"
-
-[types.FrozenHoldList.parents]
-FrozenDataList = true
-MutableSequence = false
-Sequence = true
-
-[types.FrozenHoldSet]
-dirData = []
-
-[types.FrozenHoldSet.constructor.concrete]
-args = [
-    [
-        1,
-        2,
-    ],
-]
-valid = true
-
-[types.FrozenHoldSet.parents]
-MutableSet = false
-Set = true
-
-[types.HoldDict]
-Data = "frozendict"
-dirData = []
-n_type_params = 2
-
-[types.HoldDict.constructor.concrete.kwargs]
-a = 1
-
-[types.HoldDict.constructor.empty]
-args = []
-
-[types.HoldDict.parents]
-BaseDataDict = true
-DataDict = true
-Mapping = true
-MutableMapping = true
-
-[types.HoldList]
-Data = "tuple"
-dirData = []
-n_type_params = 1
-
-[types.HoldList.constructor.empty]
-args = []
-
-[types.HoldList.constructor.concrete]
-args = [
-    [
-        1,
-        2,
-    ],
-]
-
-[types.HoldList.constructor.protocols]
-args = [
-    [
-        1,
-        2,
-        3,
-    ],
-]
-
-[types.HoldList.parents]
-DataList = true
-MutableSequence = true
-Sequence = true
-
-[types.HoldSet]
-Date = "frozenset"
-dirData = []
-n_type_params = 1
-
-[types.HoldSet.constructor.empty]
-args = []
-
-[types.HoldSet.constructor.concrete]
-args = [
-    [
-        1,
-        2,
-    ],
-]
-
-[types.HoldSet.constructor.protocols]
-args = [
-    [
-        1,
-        2,
-        3,
-    ],
-]
-
-[types.HoldSet.parents]
-BaseDataSet = true
-DataSet = true
-MutableSet = true
-Set = true
-
 [varia]
+HOLD_TYPES = [
+    "BaseHoldObject",
+]

datahold-4.0.0.dev6/tests/test_datahold_TestCopy.py

@@ -1,81 +0,0 @@
-__all__: list[str] = ["TestCopy"]
-
-import unittest
-from typing import Any, Self, cast
-
-from datahold import (
-    FrozenHoldDict,
-    FrozenHoldList,
-    FrozenHoldSet,
-    HoldDict,
-    HoldList,
-    HoldSet,
-)
-
-
-class TestCopy(unittest.TestCase):
-
-    def test_frozen_have_no_copy_2(self: Self) -> None:
-        """
-        Frozen classes should not define their own copy method.
-        (If a parent class or wrapped object exposes one, we ignore that.)
-        """
-        args: Any
-        cls: Any
-        copy_obj: Any
-        obj: Any
-        for cls, args in (
-            (FrozenHoldDict, ({"a": 1},)),
-            (FrozenHoldList, ([1, 2],)),
-            (FrozenHoldSet, ({1, 2},)),
-        ):
-            # They must not *define* copy themselves
-            self.assertNotIn("copy", cls.__dict__)
-
-            # Optional: if they *do* expose copy on the instance, it should not
-            # create a mutable variant; you can drop this if you prefer.
-            obj = cls(*args)
-            if hasattr(obj, "copy"):
-                copy_obj = obj.copy()
-                self.assertIsInstance(copy_obj, cls)
-
-    def test_mutable_copy_returns_same_type_and_is_shallow(self: Self) -> None:
-        d: HoldDict[str, dict[str, int]]
-        d_copy: HoldDict[str, dict[str, int]]
-        d = HoldDict({"a": {"x": 1}})
-        d_copy = d.copy()
-        self.assertIsInstance(d_copy, type(d))
-        self.assertIsNot(d_copy, d)
-        self.assertEqual(dict(d_copy), dict(d))
-
-        # shallow: inner object is shared
-        cast(dict[str, int], d["a"])["x"] = 2
-        self.assertEqual(cast(dict[str, int], d_copy["a"])["x"], 2)
-
-    def test_list_copy(self: Self) -> None:
-        lst: HoldList[Any]
-        lst_copy: HoldList[Any]
-        lst = HoldList([[1], [2]])
-        lst_copy = lst.copy()
-        self.assertIsInstance(lst_copy, type(lst))
-        self.assertIsNot(lst_copy, lst)
-        self.assertEqual(list(lst_copy), list(lst))
-
-        lst[0].append(99)
-        self.assertEqual(lst_copy[0], [1, 99])
-
-    def test_set_copy(self: Self) -> None:
-        s: HoldSet[Any]
-        s_copy: HoldSet[Any]
-        s = HoldSet({1, 2, 3})
-        s_copy = s.copy()
-        self.assertIsInstance(s_copy, type(s))
-        self.assertIsNot(s_copy, s)
-        self.assertEqual(set(s_copy), set(s))
-
-        s.add(4)
-        self.assertNotIn(4, s_copy)
-
-
-if __name__ == "__main__":
-    unittest.main()

datahold-4.0.0.dev6/tests/test_datahold_TestDataAttribute.py

@@ -1,46 +0,0 @@
-__all__: list[str] = ["TestDataAttribute"]
-
-import unittest
-from typing import Any, Self
-
-from datahold import (
-    FrozenHoldDict,
-    FrozenHoldList,
-    FrozenHoldSet,
-    HoldDict,
-    HoldList,
-    HoldSet,
-)
-
-
-class TestDataAttribute(unittest.TestCase):
-    def test_dict_data_is_immutable_mapping(self: Self) -> None:
-        f: FrozenHoldDict[Any, Any]
-        m: HoldDict[Any, Any]
-        obj: Any
-        f = FrozenHoldDict({"a": 1})
-        m = HoldDict({"a": 1})
-        for obj in (f, m):
-            self.assertIsInstance(obj.__fget__(), dict)
-
-    def test_list_data_is_tuple(self: Self) -> None:
-        f: FrozenHoldList[Any]
-        m: HoldList[Any]
-        o: Any
-        f = FrozenHoldList([1, 2, 3])
-        m = HoldList([1, 2, 3])
-        for o in (f, m):
-            self.assertIsInstance(o.__fget__(), list)
-
-    def test_set_data_is_frozenset(self: Self) -> None:
-        f: FrozenHoldSet[Any]
-        m: HoldSet[Any]
-        obj: Any
-        f = FrozenHoldSet({1, 2, 3})
-        m = HoldSet({1, 2, 3})
-        for obj in (f, m):
-            self.assertIsInstance(obj.__fget__(), set)
-
-
-if __name__ == "__main__":
-    unittest.main()

datahold-4.0.0.dev6/tests/test_datahold_TestFrozenMutability.py

@@ -1,36 +0,0 @@
-__all__: list[str] = ["TestFrozenMutability"]
-
-import unittest
-from typing import Any, Self
-
-from datahold import FrozenHoldDict, FrozenHoldList, FrozenHoldSet
-
-
-class TestFrozenMutability(unittest.TestCase):
-    def test_frozen_dict_cannot_mutate(self: Self) -> None:
-        f: Any
-        f = FrozenHoldDict({"a": 1})
-        with self.assertRaises((TypeError, AttributeError)):
-            f["b"] = 2
-        with self.assertRaises((TypeError, AttributeError)):
-            f.pop("a", None)
-
-    def test_frozen_list_cannot_mutate(self: Self) -> None:
-        f: Any
-        f = FrozenHoldList([1, 2, 3])
-        with self.assertRaises((TypeError, AttributeError)):
-            f.append(4)
-        with self.assertRaises((TypeError, AttributeError)):
-            f.pop()
-
-    def test_frozen_set_cannot_mutate(self: Self) -> None:
-        f: Any
-        f = FrozenHoldSet({1, 2, 3})
-        with self.assertRaises((TypeError, AttributeError)):
-            f.add(4)
-        with self.assertRaises((TypeError, AttributeError)):
-            f.remove(1)
-
-
-if __name__ == "__main__":
-    unittest.main()

datahold-4.0.0.dev6/tests/test_datahold_TestMutableBehavior.py

@@ -1,33 +0,0 @@
-__all__: list[str] = ["TestMutableBehavior"]
-
-import unittest
-from typing import Any, Self
-
-from datahold import HoldDict, HoldList, HoldSet
-
-
-class TestMutableBehavior(unittest.TestCase):
-    def test_hold_dict_mutates_and_syncs_data(self: Self) -> None:
-        x: HoldDict[Any, Any]
-        x = HoldDict({"a": 1})
-        x["b"] = 2
-        self.assertEqual(x["b"], 2)
-        self.assertEqual(x.__fget__()["b"], 2)
-
-    def test_hold_list_mutates_and_syncs_data(self: Self) -> None:
-        x: HoldList[Any]
-        x = HoldList([1, 2])
-        x.append(3)
-        self.assertEqual(list(x), [1, 2, 3])
-        self.assertEqual(x.__fget__(), [1, 2, 3])
-
-    def test_hold_set_mutates_and_syncs_data(self: Self) -> None:
-        s: HoldSet[Any]
-        s = HoldSet({1, 2})
-        s.add(3)
-        self.assertTrue(3 in s)
-        self.assertTrue(3 in s.__fget__())
-
-
-if __name__ == "__main__":
-    unittest.main()