datahold 4.0.0.dev5__tar.gz → 4.0.0.dev7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datahold
-Version: 4.0.0.dev5
+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.dev5 → 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.dev5"
+version = "4.0.0.dev7"
 
 [project.urls]
 Download = "https://pypi.org/project/datahold/#files"

{datahold-4.0.0.dev5 → 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 ###
 
 
@@ -134,7 +144,7 @@ class BaseDataSet[Item: abc.Hashable](BaseDataAbstractSet[Item]):
 
     @abstractmethod
     @setdoc.basic
-    def __fget__(self: Self) -> set[Item]: ...
+    def __fget__(self: Self) -> Data[Item]: ...
 
     @abstractmethod
     @setdoc.basic
@@ -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],
@@ -214,18 +207,6 @@ class DataSet[Item: abc.Hashable](
 
     __slots__ = ()
 
-    @abstractmethod
-    @setdoc.basic
-    def __fget__(self: Self) -> DataSet.Data[Item]: ...
-
-    @abstractmethod
-    @setdoc.basic
-    def __fset__(
-        self: Self,
-        value: DataSet.Data[Item],
-        /,
-    ) -> None: ...
-
     @setdoc.basic
     def add(self: Self, item: Item, /) -> None:
         self.__fset__(self.__fget__() | {item})
@@ -241,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]
@@ -337,6 +301,10 @@ class BaseDataDict[Key: abc.Hashable, Value](
         | abc.Iterable[tuple[DataKey | str, Optional[DataValue]]]
     )
 
+    @abstractmethod
+    @setdoc.basic
+    def __fget__(self: Self) -> Data[Key, Value]: ...
+
     @abstractmethod
     @setdoc.basic
     def __fset__(self: Self, data: Data[Key, Value], /) -> None: ...
@@ -369,10 +337,6 @@ class BaseDataDict[Key: abc.Hashable, Value](
 
     # __ror__ is unnecessary because of how __or__ is defined
 
-    @abstractmethod
-    @setdoc.basic
-    def __fget__(self: Self) -> Data[Key, Value]: ...
-
     @classmethod
     @setdoc.basic
     def fromkeys(
@@ -397,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]],
@@ -429,14 +376,6 @@ class DataDict[Key: abc.Hashable, Value](
         del data[key]
         self.__fset__(data)
 
-    @abstractmethod
-    @setdoc.basic
-    def __fget__(self: Self) -> DataDict.Data[Key, Value]: ...
-
-    @abstractmethod
-    @setdoc.basic
-    def __fset__(self: Self, data: DataDict.Data[Key, Value], /) -> None: ...
-
     @setdoc.basic
     def __ior__(
         self: Self,
@@ -464,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 ###
 
 
@@ -568,7 +486,11 @@ class BaseDataList[Item](BaseDataSequence[Item]):
 
     @abstractmethod
     @setdoc.basic
-    def __fset__(self: Self, value: list[Item], /) -> None: ...
+    def __fget__(self: Self) -> Data[Item]: ...
+
+    @abstractmethod
+    @setdoc.basic
+    def __fset__(self: Self, data: Data[Item], /) -> None: ...
 
     @setdoc.basic
     def __ge__(self: Self, other: object, /) -> NotImplementedType | bool:
@@ -629,10 +551,6 @@ class BaseDataList[Item](BaseDataSequence[Item]):
 
     __rmul__ = __mul__
 
-    @abstractmethod
-    @setdoc.basic
-    def __fget__(self: Self) -> Data[Item]: ...
-
 
 class FrozenDataList[Item](
     BaseDataList[Item],
@@ -647,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],
@@ -681,18 +582,6 @@ class DataList[Item](
         del data[other]
         self.__fset__(data)
 
-    @abstractmethod
-    @setdoc.basic
-    def __fget__(self: Self) -> DataList.Data[Item]: ...
-
-    @abstractmethod
-    @setdoc.basic
-    def __fset__(
-        self: Self,
-        value: DataList.Data[Item],
-        /,
-    ) -> None: ...
-
     @setdoc.basic
     def __imul__(self: Self, other: SupportsIndex, /) -> Self:
         self.__fset__(self.__fget__() * other)
@@ -742,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.dev5 → 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.dev5
+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.dev5 → 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.dev5 → 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.dev5 → 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.dev5 → 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.dev5 → 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()