datahold 4.0.0.dev3__tar.gz → 4.0.0.dev5__tar.gz

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

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

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

{datahold-4.0.0.dev3 → datahold-4.0.0.dev5}/src/datahold/__init__.py

@@ -52,6 +52,15 @@ class Missing(enum.Enum):
 type Slice[Index] = slice[Optional[Index], Optional[Index], Optional[Index]]
 
 
+class SupportsKeysAndGetitem[Key, Value](Protocol):
+
+    @setdoc.basic
+    def __getitem__(self: Self, key: Never, /) -> Value: ...
+
+    @setdoc.basic
+    def keys(self: Self) -> abc.Iterable[Key]: ...
+
+
 ### COLLECTION ###
 
 
@@ -70,7 +79,6 @@ class BaseDataCollection[Item](
         abc.Sized,
         abc.Iterable[DataItem],
         abc.Container[Never],
-        abc.Hashable,
         Protocol,
     ):
         """Provide collection data protocol."""
@@ -113,25 +121,32 @@ class BaseDataAbstractSet[Item](
     __slots__ = ()
 
 
+### SET ###
+
+
 class BaseDataSet[Item: abc.Hashable](BaseDataAbstractSet[Item]):
     """Provide an easy abc for custom set-like."""
 
     __slots__ = ()
 
-    type Data[DataItem] = frozenset[DataItem]
+    type Data[DataItem] = set[DataItem]
     type Init[InitItem] = abc.Iterable[InitItem]
 
     @abstractmethod
     @setdoc.basic
-    def __init__(self: Self, data: Init[Item] = (), /) -> None: ...
+    def __fget__(self: Self) -> set[Item]: ...
 
+    @abstractmethod
     @setdoc.basic
-    def __repr__(self: Self, /) -> str:
-        return f"{type(self).__name__}({set(self.__fget__())!r})"
+    def __fset__(self: Self, data: Data[Item], /) -> None: ...
+
+    @setdoc.basic
+    def __init__(self: Self, data: Init[Item] = (), /) -> None:
+        self.__fset__(set(data))
 
-    @abstractmethod
     @setdoc.basic
-    def __fget__(self: Self) -> frozenset[Item]: ...
+    def __repr__(self: Self, /) -> str:
+        return f"{type(self).__name__}({set(self.__fget__())!r})"
 
     @setdoc.basic
     def difference(self: Self, /, *others: abc.Iterable[abc.Hashable]) -> Self:
@@ -171,7 +186,7 @@ class FrozenDataSet[Item: abc.Hashable](BaseDataSet[Item], abc.Hashable):
 
     @setdoc.basic
     def __hash__(self: Self) -> int:
-        return hash(self.__fget__())
+        return hash(frozenset(self.__fget__()))
 
 
 class FrozenHoldSet[Item: abc.Hashable](
@@ -184,16 +199,12 @@ class FrozenHoldSet[Item: abc.Hashable](
 
     @setdoc.basic
     def __fget__(self: Self) -> FrozenHoldSet.Data[Item]:
-        return self._data
+        return set(self._data)
 
     @setdoc.basic
     def __fset__(self: Self, data: FrozenHoldSet.Data[Item], /) -> None:
         self._data: FrozenHoldSet.Data[Item] = data
 
-    @setdoc.basic
-    def __init__(self: Self, data: FrozenHoldSet.Init[Item] = (), /) -> None:
-        self.__fset__(frozenset(data))
-
 
 class DataSet[Item: abc.Hashable](
     BaseDataSet[Item],
@@ -211,14 +222,10 @@ class DataSet[Item: abc.Hashable](
     @setdoc.basic
     def __fset__(
         self: Self,
-        value: DataSet.Init[Item],
+        value: DataSet.Data[Item],
         /,
     ) -> None: ...
 
-    @setdoc.basic
-    def __init__(self: Self, data: abc.Iterable[Item] = (), /) -> None:
-        self.__fset__(frozenset(data))
-
     @setdoc.basic
     def add(self: Self, item: Item, /) -> None:
         self.__fset__(self.__fget__() | {item})
@@ -236,14 +243,14 @@ class DataSet[Item: abc.Hashable](
         data: set[Item]
         data = set(self.__fget__())
         data.difference_update(*others)
-        self.__fset__(frozenset(data))
+        self.__fset__(set(data))
 
     @setdoc.basic
     def discard(self: Self, item: abc.Hashable, /) -> None:
         data: set[Item]
         data = set(self.__fget__())
         data.discard(item)
-        self.__fset__(frozenset(data))
+        self.__fset__(set(data))
 
     @setdoc.basic
     def intersection_update(
@@ -252,7 +259,7 @@ class DataSet[Item: abc.Hashable](
         data: set[Item]
         data = set(self.__fget__())
         data.intersection_update(*others)
-        self.__fset__(frozenset(data))
+        self.__fset__(set(data))
 
     @setdoc.basic
     def symmetric_difference_update(
@@ -261,7 +268,7 @@ class DataSet[Item: abc.Hashable](
         data: set[Item]
         data = set(self.__fget__())
         data.symmetric_difference_update(other)
-        self.__fset__(frozenset(data))
+        self.__fset__(set(data))
 
     @setdoc.basic
     def update(self: Self, /, *others: abc.Iterable[Item]) -> None:
@@ -278,11 +285,11 @@ class HoldSet[Item: abc.Hashable](
 
     @setdoc.basic
     def __fget__(self: Self) -> HoldSet.Data[Item]:
-        return self._data
+        return set(self._data)
 
     @setdoc.basic
-    def __fset__(self: Self, value: abc.Iterable[Item], /) -> None:
-        self._data: HoldSet.Data[Item] = frozenset(value)
+    def __fset__(self: Self, value: HoldSet.Data[Item], /) -> None:
+        self._data: HoldSet.Data[Item] = value
 
 
 ### MAPPING ###
@@ -314,13 +321,7 @@ class BaseDataMapping[Key, Value](
     def __fget__(self: Self) -> Data[Key, Value]: ...
 
 
-class SupportsKeysAndGetitem[Key, Value](Protocol):
-
-    @setdoc.basic
-    def __getitem__(self: Self, key: Never, /) -> Value: ...
-
-    @setdoc.basic
-    def keys(self: Self) -> abc.Iterable[Key]: ...
+### DICT ###
 
 
 class BaseDataDict[Key: abc.Hashable, Value](
@@ -330,22 +331,29 @@ class BaseDataDict[Key: abc.Hashable, Value](
 
     __slots__ = ()
 
-    type Data[DataKey, DataValue] = frozendict[
-        DataKey | str, Optional[DataValue]
-    ]
+    type Data[DataKey, DataValue] = dict[DataKey | str, Optional[DataValue]]
     type Init[DataKey, DataValue] = (
         SupportsKeysAndGetitem[DataKey | str, Optional[DataValue]]
         | abc.Iterable[tuple[DataKey | str, Optional[DataValue]]]
     )
 
     @abstractmethod
+    @setdoc.basic
+    def __fset__(self: Self, data: Data[Key, Value], /) -> None: ...
+
     @setdoc.basic
     def __init__(
         self: Self,
         data: Init[Key, Value] = (),
         /,
         **kwargs: Optional[Value],
-    ) -> None: ...
+    ) -> None:
+        data_: BaseDataDict.Data[Key, Value]
+        data_ = dict(  # type: ignore[assignment]
+            data,  # type: ignore[arg-type]
+            **kwargs,
+        )
+        self.__fset__(data_)
 
     @setdoc.basic
     def __or__(
@@ -386,7 +394,7 @@ class FrozenDataDict[Key: abc.Hashable, Value](
 
     @setdoc.basic
     def __hash__(self: Self) -> int:
-        return hash(self.__fget__())
+        return hash(frozendict(self.__fget__()))
 
 
 class FrozenHoldDict[Key: abc.Hashable, Value](
@@ -397,23 +405,9 @@ class FrozenHoldDict[Key: abc.Hashable, Value](
 
     __slots__ = ()
 
-    @setdoc.basic
-    def __init__(
-        self: Self,
-        data: FrozenHoldDict.Init[Key, Value] = (),
-        /,
-        **kwargs: Optional[Value],
-    ) -> None:
-        self.__fset__(
-            frozendict(
-                data,  # type: ignore[arg-type]
-                **kwargs,
-            )
-        )
-
     @setdoc.basic
     def __fget__(self: Self) -> FrozenHoldDict.Data[Key, Value]:
-        return self._data
+        return dict(self._data)
 
     @setdoc.basic
     def __fset__(self: Self, data: FrozenHoldDict.Data[Key, Value], /) -> None:
@@ -430,7 +424,10 @@ class DataDict[Key: abc.Hashable, Value](
 
     @setdoc.basic
     def __delitem__(self: Self, key: Key | str, /) -> None:
-        self.__fset__(self.__fget__().delete(key))
+        data: DataDict.Data[Key, Value]
+        data = self.__fget__()
+        del data[key]
+        self.__fset__(data)
 
     @abstractmethod
     @setdoc.basic
@@ -440,15 +437,6 @@ class DataDict[Key: abc.Hashable, Value](
     @setdoc.basic
     def __fset__(self: Self, data: DataDict.Data[Key, Value], /) -> None: ...
 
-    @setdoc.basic
-    def __init__(
-        self: Self,
-        data: BaseDataDict.Init[Key, Value] = (),
-        /,
-        **kwargs: Optional[Value],
-    ) -> None:
-        self.__fset__(frozendict(data, **kwargs))  # type: ignore[arg-type]
-
     @setdoc.basic
     def __ior__(
         self: Self,
@@ -466,7 +454,10 @@ class DataDict[Key: abc.Hashable, Value](
         /,
     ) -> None:
         # what to do if Key includes unhashable types?
-        self.__fset__(self.__fget__().set(key, value))
+        data: DataDict.Data[Key, Value]
+        data = self.__fget__()
+        data[key] = value
+        self.__fset__(data)
 
     @setdoc.basic
     def copy(self: Self) -> Self:
@@ -483,15 +474,15 @@ class HoldDict[Key: abc.Hashable, Value](
 
     @setdoc.basic
     def __fget__(self: Self) -> HoldDict.Data[Key, Value]:
-        return self._data
+        return dict(self._data)
 
     @setdoc.basic
     def __fset__(
         self: Self,
-        value: HoldDict.Init[Key, Value],
+        value: HoldDict.Data[Key, Value],
         /,
     ) -> None:
-        self._data: HoldDict.Data[Key, Value] = frozendict(value)  # type: ignore[arg-type]
+        self._data: HoldDict.Data[Key, Value] = value
 
 
 ### SEQUENCE ###
@@ -542,12 +533,15 @@ class BaseDataSequence[Item](
     def __fget__(self: Self) -> Data[Item]: ...
 
 
+### LIST ###
+
+
 class BaseDataList[Item](BaseDataSequence[Item]):
     """Provide an easy abc for custom list-like."""
 
     __slots__ = ()
 
-    type Data[DataItem] = tuple[DataItem, ...]
+    type Data[DataItem] = list[DataItem]
     type Init[InitItem] = abc.Iterable[InitItem]
 
     @setdoc.basic
@@ -572,6 +566,10 @@ class BaseDataList[Item](BaseDataSequence[Item]):
         else:
             return NotImplemented
 
+    @abstractmethod
+    @setdoc.basic
+    def __fset__(self: Self, value: list[Item], /) -> None: ...
+
     @setdoc.basic
     def __ge__(self: Self, other: object, /) -> NotImplementedType | bool:
         if isinstance(other, BaseDataList):
@@ -603,9 +601,9 @@ class BaseDataList[Item](BaseDataSequence[Item]):
         else:
             return NotImplemented
 
-    @abstractmethod
     @setdoc.basic
-    def __init__(self: Self, data: Init[Item] = (), /) -> None: ...
+    def __init__(self: Self, data: Init[Item] = (), /) -> None:
+        self.__fset__(list(data))
 
     @setdoc.basic
     def __le__(self: Self, other: object, /) -> NotImplementedType | bool:
@@ -646,7 +644,7 @@ class FrozenDataList[Item](
 
     @setdoc.basic
     def __hash__(self: Self) -> int:
-        return hash(self.__fget__())
+        return hash(tuple(self.__fget__()))
 
 
 class FrozenHoldList[Item](
@@ -659,16 +657,12 @@ class FrozenHoldList[Item](
 
     @setdoc.basic
     def __fget__(self: Self) -> FrozenHoldList.Data[Item]:
-        return self._data
+        return list(self._data)
 
     @setdoc.basic
     def __fset__(self: Self, data: FrozenHoldList.Data[Item], /) -> None:
         self._data: FrozenHoldList.Data[Item] = data
 
-    @setdoc.basic
-    def __init__(self: Self, data: FrozenHoldList.Init[Item] = (), /) -> None:
-        self.__fset__(tuple(data))
-
 
 class DataList[Item](
     BaseDataList[Item],
@@ -683,9 +677,9 @@ class DataList[Item](
         self: Self, other: SupportsIndex | Slice[SupportsIndex], /
     ) -> None:
         data: list[Item]
-        data = list(self.__fget__())
+        data = self.__fget__()
         del data[other]
-        self.__fset__(tuple(data))
+        self.__fset__(data)
 
     @abstractmethod
     @setdoc.basic
@@ -695,7 +689,7 @@ class DataList[Item](
     @setdoc.basic
     def __fset__(
         self: Self,
-        value: DataList.Init[Item],
+        value: DataList.Data[Item],
         /,
     ) -> None: ...
 
@@ -704,14 +698,6 @@ class DataList[Item](
         self.__fset__(self.__fget__() * other)
         return self
 
-    @setdoc.basic
-    def __init__(
-        self: Self,
-        data: abc.Iterable[Item] = (),
-        /,
-    ) -> None:
-        self.__fset__(tuple(data))
-
     @overload
     @setdoc.basic
     def __setitem__(
@@ -734,10 +720,10 @@ class DataList[Item](
         value: Item | abc.Iterable[Item],
         /,
     ) -> None:
-        data: Any
-        data = list(self.__fget__())
-        data[key] = value
-        self.__fset__(tuple(data))
+        data: list[Item]
+        data = self.__fget__()
+        data[key] = value  # type: ignore[index, assignment]
+        self.__fset__(data)
 
     @setdoc.basic
     def copy(self: Self) -> Self:
@@ -746,16 +732,16 @@ class DataList[Item](
     @setdoc.basic
     def insert(self: Self, index: SupportsIndex, item: Item, /) -> None:
         data: list[Item]
-        data = list(self.__fget__())
+        data = self.__fget__()
         data.insert(index, item)
-        self.__fset__(tuple(data))
+        self.__fset__(data)
 
     @setdoc.basic
     def sort(self: Self, *, key: Any = None, reverse: bool = False) -> None:
         data: list[Item]
-        data = list(self.__fget__())
+        data = self.__fget__()
         data.sort(key=key, reverse=reverse)
-        self.__fset__(tuple(data))
+        self.__fset__(data)
 
 
 class HoldList[Item](
@@ -768,8 +754,8 @@ class HoldList[Item](
 
     @setdoc.basic
     def __fget__(self: Self) -> HoldList.Data[Item]:
-        return self._data
+        return list(self._data)
 
     @setdoc.basic
-    def __fset__(self: Self, value: abc.Iterable[Item], /) -> None:
-        self._data: HoldList.Data[Item] = tuple(value)
+    def __fset__(self: Self, value: HoldList.Data[Item], /) -> None:
+        self._data: HoldList.Data[Item] = value

{datahold-4.0.0.dev3 → datahold-4.0.0.dev5}/src/datahold.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datahold
-Version: 4.0.0.dev3
+Version: 4.0.0.dev5
 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.dev3 → datahold-4.0.0.dev5}/tests/test_FrozenHoldDict.py

@@ -19,12 +19,12 @@ class TestFrozenHoldDict(unittest.TestCase):
     def test_init(self: Self) -> None:
         obj: Any
         obj = FrozenHoldDict({"x": 42})
-        self.assertEqual(obj.__fget__(), frozendict({"x": 42}))
+        self.assertEqual(obj.__fget__(), dict({"x": 42}))
 
     # data property
     def test_data(self: Self) -> None:
-        self.assertIsInstance(self.obj.__fget__(), frozendict)
-        self.assertEqual(self.obj.__fget__(), frozendict({"a": 1, "b": 2}))
+        self.assertIsInstance(self.obj.__fget__(), dict)
+        self.assertEqual(self.obj.__fget__(), dict({"a": 1, "b": 2}))
 
     # __contains__
     def test_contains(self: Self) -> None:
@@ -55,7 +55,7 @@ class TestFrozenHoldDict(unittest.TestCase):
 
     # __hash__
     def test_hash(self: Self) -> None:
-        self.assertEqual(hash(self.obj), hash(self.obj.__fget__()))
+        self.assertEqual(hash(self.obj), hash(frozendict(self.obj.__fget__())))
         self.assertEqual(hash(self.obj), hash(self.same))
 
     # __or__

{datahold-4.0.0.dev3 → datahold-4.0.0.dev5}/tests/test_FrozenHoldList.py

@@ -1,6 +1,6 @@
 __all__: list[str] = ["TestFrozenHoldLists"]
 import unittest
-from typing import Self
+from typing import Any, Self
 
 from datahold import FrozenHoldList
 
@@ -14,13 +14,14 @@ class TestFrozenHoldList(unittest.TestCase):
 
     # __init__
     def test_init(self: Self) -> None:
+        obj: FrozenHoldList[int]
         obj = FrozenHoldList([42])
-        self.assertEqual(obj.__fget__(), (42,))
+        self.assertEqual(obj.__fget__(), [42])
 
     # data property
     def test_data(self: Self) -> None:
-        self.assertIsInstance(self.obj.__fget__(), tuple)
-        self.assertEqual(self.obj.__fget__(), (1, 2, 3))
+        self.assertIsInstance(self.obj.__fget__(), list)
+        self.assertEqual(self.obj.__fget__(), [1, 2, 3])
 
     # __contains__
     def test_contains(self: Self) -> None:
@@ -33,6 +34,7 @@ class TestFrozenHoldList(unittest.TestCase):
         self.assertEqual(self.obj[-1], 3)
 
     def test_getitem_slice(self: Self) -> None:
+        result: Any
         result = self.obj[1:]
         self.assertEqual(result, FrozenHoldList([2, 3]))
         self.assertEqual(list(result), [2, 3])
@@ -57,33 +59,37 @@ class TestFrozenHoldList(unittest.TestCase):
 
     # __lt__
     def test_lt(self: Self) -> None:
+        expected: bool
         expected = self.obj.__fget__() < self.other.__fget__()
         self.assertEqual(self.obj < self.other, expected)
 
     # __le__
     def test_le(self: Self) -> None:
+        expected: bool
         expected = self.obj.__fget__() <= self.same.__fget__()
         self.assertEqual(self.obj <= self.same, expected)
 
     # __gt__
     def test_gt(self: Self) -> None:
+        expected: bool
         expected = self.other.__fget__() > self.obj.__fget__()
         self.assertEqual(self.other > self.obj, expected)
 
     # __ge__
     def test_ge(self: Self) -> None:
+        expected: bool
         expected = self.obj.__fget__() >= self.same.__fget__()
         self.assertEqual(self.obj >= self.same, expected)
 
     # __hash__
     def test_hash(self: Self) -> None:
-        self.assertEqual(hash(self.obj), hash(self.obj.__fget__()))
+        self.assertEqual(hash(self.obj), hash(tuple(self.obj.__fget__())))
         self.assertEqual(hash(self.obj), hash(self.same))
 
     # __add__
     def test_add(self: Self) -> None:
+        result: Any
         result = self.obj + FrozenHoldList([4, 5])
-
         self.assertIsInstance(result, FrozenHoldList)
         self.assertEqual(
             result,
@@ -92,8 +98,8 @@ class TestFrozenHoldList(unittest.TestCase):
 
     # __mul__
     def test_mul(self: Self) -> None:
+        result: Any
         result = self.obj * 2
-
         self.assertIsInstance(result, FrozenHoldList)
         self.assertEqual(
             result,
@@ -102,8 +108,8 @@ class TestFrozenHoldList(unittest.TestCase):
 
     # __rmul__
     def test_rmul(self: Self) -> None:
+        result: Any
         result = 2 * self.obj
-
         self.assertIsInstance(result, FrozenHoldList)
         self.assertEqual(
             result,
@@ -126,15 +132,14 @@ class TestFrozenHoldList(unittest.TestCase):
 
     # count
     def test_count(self: Self) -> None:
+        obj: FrozenHoldList[int]
         obj = FrozenHoldList([1, 2, 1, 3, 1])
-
         self.assertEqual(obj.count(1), 3)
         self.assertEqual(obj.count(99), 0)
 
     # index
     def test_index(self: Self) -> None:
         self.assertEqual(self.obj.index(2), 1)
-
         with self.assertRaises(ValueError):
             self.obj.index(99)
 

{datahold-4.0.0.dev3 → datahold-4.0.0.dev5}/tests/test_FrozenHoldSet.py

@@ -15,12 +15,12 @@ class TestFrozenHoldSet(unittest.TestCase):
     # __init__
     def test_init(self: Self) -> None:
         obj = FrozenHoldSet([1, 2, 3])
-        self.assertEqual(obj.__fget__(), frozenset({1, 2, 3}))
+        self.assertEqual(obj.__fget__(), {1, 2, 3})
 
     # data property
     def test_data(self: Self) -> None:
-        self.assertIsInstance(self.obj.__fget__(), frozenset)
-        self.assertEqual(self.obj.__fget__(), frozenset({1, 2, 3}))
+        self.assertIsInstance(self.obj.__fget__(), set)
+        self.assertEqual(self.obj.__fget__(), {1, 2, 3})
 
     # __contains__
     def test_contains(self: Self) -> None:
@@ -66,12 +66,11 @@ class TestFrozenHoldSet(unittest.TestCase):
     # __hash__
     def test_hash(self: Self) -> None:
         self.assertEqual(hash(self.obj), hash(self.same))
-        self.assertEqual(hash(self.obj), hash(self.obj.__fget__()))
+        self.assertEqual(hash(self.obj), hash(frozenset(self.obj.__fget__())))
 
     # __or__
     def test_or(self: Self) -> None:
         result = FrozenHoldSet({1, 2}) | FrozenHoldSet({2, 3})
-
         self.assertIsInstance(result, FrozenHoldSet)
         self.assertEqual(
             result,
@@ -88,7 +87,6 @@ class TestFrozenHoldSet(unittest.TestCase):
     # union
     def test_union(self: Self) -> None:
         result = self.obj.union({4, 5})
-
         self.assertIsInstance(result, FrozenHoldSet)
         self.assertEqual(
             result,
@@ -98,7 +96,6 @@ class TestFrozenHoldSet(unittest.TestCase):
     # intersection
     def test_intersection(self: Self) -> None:
         result = self.obj.intersection({2, 3, 4})
-
         self.assertEqual(
             result,
             FrozenHoldSet({2, 3}),
@@ -107,7 +104,6 @@ class TestFrozenHoldSet(unittest.TestCase):
     # difference
     def test_difference(self: Self) -> None:
         result = self.obj.difference({2})
-
         self.assertEqual(
             result,
             FrozenHoldSet({1, 3}),
@@ -116,7 +112,6 @@ class TestFrozenHoldSet(unittest.TestCase):
     # symmetric_difference
     def test_symmetric_difference(self: Self) -> None:
         result = self.obj.symmetric_difference({3, 4})
-
         self.assertEqual(
             result,
             FrozenHoldSet({1, 2, 4}),
@@ -146,7 +141,6 @@ class TestFrozenHoldSet(unittest.TestCase):
     # __and__
     def test_and(self: Self) -> None:
         result = FrozenHoldSet({1, 2, 3}) & FrozenHoldSet({2, 3, 4})
-
         self.assertEqual(
             result,
             FrozenHoldSet({2, 3}),
@@ -155,7 +149,6 @@ class TestFrozenHoldSet(unittest.TestCase):
     # __sub__
     def test_sub(self: Self) -> None:
         result = FrozenHoldSet({1, 2, 3}) - FrozenHoldSet({2})
-
         self.assertEqual(
             result,
             FrozenHoldSet({1, 3}),
@@ -164,7 +157,6 @@ class TestFrozenHoldSet(unittest.TestCase):
     # __xor__
     def test_xor(self: Self) -> None:
         result = FrozenHoldSet({1, 2, 3}) ^ FrozenHoldSet({3, 4})
-
         self.assertEqual(
             result,
             FrozenHoldSet({1, 2, 4}),

{datahold-4.0.0.dev3 → datahold-4.0.0.dev5}/tests/test_HoldDict.py

@@ -8,13 +8,17 @@ from datahold import HoldDict
 class TestHoldDict(unittest.TestCase):
 
     def setUp(self: Self) -> None:
-        self.obj: Any = HoldDict({"a": 1, "b": 2})
-        self.same: Any = HoldDict({"a": 1, "b": 2})
-        self.other: Any = HoldDict({"a": 1, "b": 3})
+        self.obj: Any
+        self.other: Any
+        self.same: Any
+        self.obj = HoldDict({"a": 1, "b": 2})
+        self.same = HoldDict({"a": 1, "b": 2})
+        self.other = HoldDict({"a": 1, "b": 3})
 
     # __init__
     def test_init(self: Self) -> None:
-        obj: Any = HoldDict({"x": 42})
+        obj: Any
+        obj = HoldDict({"x": 42})
         self.assertEqual(obj.__fget__(), {"x": 42})
 
     # data property
@@ -61,8 +65,8 @@ class TestHoldDict(unittest.TestCase):
 
     # __or__
     def test_or(self: Self) -> None:
-        result: Any = HoldDict({"a": 1}) | HoldDict({"b": 2})
-
+        result: Any
+        result = HoldDict({"a": 1}) | HoldDict({"b": 2})
         self.assertIsInstance(result, HoldDict)
         self.assertEqual(
             result,
@@ -78,8 +82,8 @@ class TestHoldDict(unittest.TestCase):
 
     # fromkeys
     def test_fromkeys(self: Self) -> None:
-        result: Any = HoldDict.fromkeys(["x", "y"], 123)
-
+        result: Any
+        result = HoldDict.fromkeys(["x", "y"], 123)
         self.assertIsInstance(result, HoldDict)
         self.assertEqual(
             result,
@@ -126,7 +130,8 @@ class TestHoldDict(unittest.TestCase):
 
     # setdefault
     def test_setdefault(self: Self) -> None:
-        value: Any = self.obj.setdefault("c", 3)
+        value: Any
+        value = self.obj.setdefault("c", 3)
         self.assertEqual(value, 3)
         self.assertEqual(self.obj["c"], 3)
 

{datahold-4.0.0.dev3 → datahold-4.0.0.dev5}/tests/test_HoldList.py

@@ -1,6 +1,6 @@
 __all__: list[str] = ["TestHoldList"]
 import unittest
-from typing import Self
+from typing import Any, Self
 
 from datahold import HoldList
 
@@ -8,19 +8,23 @@ from datahold import HoldList
 class TestHoldList(unittest.TestCase):
 
     def setUp(self: Self) -> None:
+        self.obj: HoldList[int]
+        self.other: HoldList[int]
+        self.same: HoldList[int]
         self.obj = HoldList([1, 2, 3])
         self.same = HoldList([1, 2, 3])
         self.other = HoldList([1, 2, 4])
 
     # __init__
     def test_init(self: Self) -> None:
+        obj: HoldList[int]
         obj = HoldList([42])
-        self.assertEqual(obj.__fget__(), (42,))
+        self.assertEqual(obj.__fget__(), [42])
 
     # data property
     def test_data(self: Self) -> None:
-        self.assertIsInstance(self.obj.__fget__(), tuple)
-        self.assertEqual(self.obj.__fget__(), (1, 2, 3))
+        self.assertIsInstance(self.obj.__fget__(), list)
+        self.assertEqual(self.obj.__fget__(), [1, 2, 3])
 
     # __contains__
     def test_contains(self: Self) -> None:
@@ -40,7 +44,7 @@ class TestHoldList(unittest.TestCase):
     # __delitem__
     def test_delitem(self: Self) -> None:
         del self.obj[1]
-        self.assertEqual(self.obj.__fget__(), (1, 3))
+        self.assertEqual(self.obj.__fget__(), [1, 3])
 
     # __iter__
     def test_iter(self: Self) -> None:
@@ -62,21 +66,25 @@ class TestHoldList(unittest.TestCase):
 
     # __lt__
     def test_lt(self: Self) -> None:
+        expected: bool
         expected = self.obj.__fget__() < self.other.__fget__()
         self.assertEqual(self.obj < self.other, expected)
 
     # __le__
     def test_le(self: Self) -> None:
+        expected: bool
         expected = self.obj.__fget__() <= self.same.__fget__()
         self.assertEqual(self.obj <= self.same, expected)
 
     # __gt__
     def test_gt(self: Self) -> None:
+        expected: bool
         expected = self.other.__fget__() > self.obj.__fget__()
         self.assertEqual(self.other > self.obj, expected)
 
     # __ge__
     def test_ge(self: Self) -> None:
+        expected: bool
         expected = self.same.__fget__() >= self.obj.__fget__()
         self.assertEqual(self.same >= self.obj, expected)
 
@@ -90,7 +98,6 @@ class TestHoldList(unittest.TestCase):
     # append
     def test_append(self: Self) -> None:
         self.obj.append(4)
-
         self.assertEqual(
             self.obj,
             HoldList([1, 2, 3, 4]),
@@ -99,7 +106,6 @@ class TestHoldList(unittest.TestCase):
     # extend
     def test_extend(self: Self) -> None:
         self.obj.extend([4, 5])
-
         self.assertEqual(
             self.obj,
             HoldList([1, 2, 3, 4, 5]),
@@ -108,7 +114,6 @@ class TestHoldList(unittest.TestCase):
     # insert
     def test_insert(self: Self) -> None:
         self.obj.insert(1, 99)
-
         self.assertEqual(
             self.obj,
             HoldList([1, 99, 2, 3]),
@@ -117,7 +122,6 @@ class TestHoldList(unittest.TestCase):
     # remove
     def test_remove(self: Self) -> None:
         self.obj.remove(2)
-
         self.assertEqual(
             self.obj,
             HoldList([1, 3]),
@@ -125,8 +129,8 @@ class TestHoldList(unittest.TestCase):
 
     # pop
     def test_pop(self: Self) -> None:
+        value: Any
         value = self.obj.pop()
-
         self.assertEqual(value, 3)
         self.assertEqual(
             self.obj,
@@ -136,7 +140,6 @@ class TestHoldList(unittest.TestCase):
     # clear
     def test_clear(self: Self) -> None:
         self.obj.clear()
-
         self.assertEqual(len(self.obj), 0)
 
     # index
@@ -148,8 +151,8 @@ class TestHoldList(unittest.TestCase):
 
     # count
     def test_count(self: Self) -> None:
+        obj: HoldList[int]
         obj = HoldList([1, 2, 2, 3])
-
         self.assertEqual(
             obj.count(2),
             2,
@@ -158,7 +161,6 @@ class TestHoldList(unittest.TestCase):
     # reverse
     def test_reverse(self: Self) -> None:
         self.obj.reverse()
-
         self.assertEqual(
             self.obj,
             HoldList([3, 2, 1]),
@@ -166,10 +168,9 @@ class TestHoldList(unittest.TestCase):
 
     # sort
     def test_sort(self: Self) -> None:
+        obj: HoldList[int]
         obj = HoldList([3, 1, 2])
-
         obj.sort()
-
         self.assertEqual(
             obj,
             HoldList([1, 2, 3]),
@@ -177,14 +178,15 @@ class TestHoldList(unittest.TestCase):
 
     # copy
     def test_copy(self: Self) -> None:
+        result: HoldList[Any]
         result = self.obj.copy()
-
         self.assertIsInstance(result, HoldList)
         self.assertEqual(result, self.obj)
         self.assertIsNot(result, self.obj)
 
     # __add__
     def test_add(self: Self) -> None:
+        result: HoldList[int]
         result = HoldList([1, 2]) + HoldList([3, 4])
         self.assertEqual(
             result,
@@ -193,6 +195,7 @@ class TestHoldList(unittest.TestCase):
 
     # __mul__
     def test_mul(self: Self) -> None:
+        result: HoldList[int]
         result = HoldList([1, 2]) * 2
         self.assertEqual(
             result,
@@ -201,6 +204,7 @@ class TestHoldList(unittest.TestCase):
 
     # __rmul__
     def test_rmul(self: Self) -> None:
+        result: HoldList[int]
         result = 2 * HoldList([1, 2])
         self.assertEqual(
             result,

{datahold-4.0.0.dev3 → datahold-4.0.0.dev5}/tests/test_HoldSet.py

@@ -7,19 +7,23 @@ from datahold import HoldSet
 class TestHoldSet(unittest.TestCase):
 
     def setUp(self: Self) -> None:
-        self.obj: Any = HoldSet({1, 2, 3})
-        self.same: Any = HoldSet({1, 2, 3})
-        self.other: Any = HoldSet({3, 4, 5})
+        self.obj: Any
+        self.other: Any
+        self.same: Any
+        self.obj = HoldSet({1, 2, 3})
+        self.other = HoldSet({3, 4, 5})
+        self.same = HoldSet({1, 2, 3})
 
     # __init__
     def test_init(self: Self) -> None:
-        obj: Any = HoldSet([1, 2, 3])
-        self.assertEqual(obj.__fget__(), frozenset({1, 2, 3}))
+        obj: Any
+        obj = HoldSet([1, 2, 3])
+        self.assertEqual(obj.__fget__(), {1, 2, 3})
 
     # data property
     def test_data(self: Self) -> None:
-        self.assertIsInstance(self.obj.__fget__(), frozenset)
-        self.assertEqual(self.obj.__fget__(), frozenset({1, 2, 3}))
+        self.assertIsInstance(self.obj.__fget__(), set)
+        self.assertEqual(self.obj.__fget__(), {1, 2, 3})
 
     # __contains__
     def test_contains(self: Self) -> None:
@@ -64,8 +68,8 @@ class TestHoldSet(unittest.TestCase):
 
     # __or__
     def test_or(self: Self) -> None:
-        result: Any = HoldSet({1, 2}) | HoldSet({2, 3})
-
+        result: Any
+        result = HoldSet({1, 2}) | HoldSet({2, 3})
         self.assertIsInstance(result, HoldSet)
         self.assertEqual(
             result,
@@ -74,8 +78,8 @@ class TestHoldSet(unittest.TestCase):
 
     # __and__
     def test_and(self: Self) -> None:
-        result: Any = HoldSet({1, 2, 3}) & HoldSet({2, 3, 4})
-
+        result: Any
+        result = HoldSet({1, 2, 3}) & HoldSet({2, 3, 4})
         self.assertEqual(
             result,
             HoldSet({2, 3}),
@@ -83,8 +87,8 @@ class TestHoldSet(unittest.TestCase):
 
     # __sub__
     def test_sub(self: Self) -> None:
-        result: Any = HoldSet({1, 2, 3}) - HoldSet({2})
-
+        result: Any
+        result = HoldSet({1, 2, 3}) - HoldSet({2})
         self.assertEqual(
             result,
             HoldSet({1, 3}),
@@ -92,8 +96,8 @@ class TestHoldSet(unittest.TestCase):
 
     # __xor__
     def test_xor(self: Self) -> None:
-        result: Any = HoldSet({1, 2, 3}) ^ HoldSet({3, 4})
-
+        result: Any
+        result = HoldSet({1, 2, 3}) ^ HoldSet({3, 4})
         self.assertEqual(
             result,
             HoldSet({1, 2, 4}),
@@ -109,7 +113,6 @@ class TestHoldSet(unittest.TestCase):
     # add
     def test_add(self: Self) -> None:
         self.obj.add(4)
-
         self.assertEqual(
             self.obj,
             HoldSet({1, 2, 3, 4}),
@@ -118,7 +121,6 @@ class TestHoldSet(unittest.TestCase):
     # remove
     def test_remove(self: Self) -> None:
         self.obj.remove(2)
-
         self.assertEqual(
             self.obj,
             HoldSet({1, 3}),
@@ -128,7 +130,6 @@ class TestHoldSet(unittest.TestCase):
     def test_discard(self: Self) -> None:
         self.obj.discard(2)
         self.obj.discard(999)
-
         self.assertEqual(
             self.obj,
             HoldSet({1, 3}),
@@ -136,21 +137,19 @@ class TestHoldSet(unittest.TestCase):
 
     # pop
     def test_pop(self: Self) -> None:
-        value: Any = self.obj.pop()
-
+        value: Any
+        value = self.obj.pop()
         self.assertNotIn(value, self.obj)
         self.assertEqual(len(self.obj), 2)
 
     # clear
     def test_clear(self: Self) -> None:
         self.obj.clear()
-
         self.assertEqual(len(self.obj), 0)
 
     # update
     def test_update(self: Self) -> None:
         self.obj.update({4, 5})
-
         self.assertEqual(
             self.obj,
             HoldSet({1, 2, 3, 4, 5}),
@@ -158,8 +157,8 @@ class TestHoldSet(unittest.TestCase):
 
     # union
     def test_union(self: Self) -> None:
-        result: Any = self.obj.union({4, 5})
-
+        result: Any
+        result = self.obj.union({4, 5})
         self.assertIsInstance(result, HoldSet)
         self.assertEqual(
             result,
@@ -168,8 +167,8 @@ class TestHoldSet(unittest.TestCase):
 
     # intersection
     def test_intersection(self: Self) -> None:
-        result: Any = self.obj.intersection({2, 3, 4})
-
+        result: Any
+        result = self.obj.intersection({2, 3, 4})
         self.assertEqual(
             result,
             HoldSet({2, 3}),
@@ -177,8 +176,8 @@ class TestHoldSet(unittest.TestCase):
 
     # difference
     def test_difference(self: Self) -> None:
-        result: Any = self.obj.difference({2})
-
+        result: Any
+        result = self.obj.difference({2})
         self.assertEqual(
             result,
             HoldSet({1, 3}),
@@ -186,8 +185,8 @@ class TestHoldSet(unittest.TestCase):
 
     # symmetric_difference
     def test_symmetric_difference(self: Self) -> None:
-        result: Any = self.obj.symmetric_difference({3, 4})
-
+        result: Any
+        result = self.obj.symmetric_difference({3, 4})
         self.assertEqual(
             result,
             HoldSet({1, 2, 4}),
@@ -209,8 +208,8 @@ class TestHoldSet(unittest.TestCase):
 
     # copy
     def test_copy(self: Self) -> None:
-        result: Any = self.obj.copy()
-
+        result: Any
+        result = self.obj.copy()
         self.assertIsInstance(result, HoldSet)
         self.assertEqual(result, self.obj)
         self.assertIsNot(result, self.obj)
@@ -221,17 +220,14 @@ class TestHoldSet(unittest.TestCase):
             {1, 2} | HoldSet({2, 3}),
             HoldSet({1, 2, 3}),
         )
-
         self.assertEqual(
             {1, 2} & HoldSet({2, 3}),
             HoldSet({2}),
         )
-
         self.assertEqual(
             {1, 2} - HoldSet({2}),
             HoldSet({1}),
         )
-
         self.assertEqual(
             {1, 2} ^ HoldSet({2, 3}),
             HoldSet({1, 3}),

{datahold-4.0.0.dev3 → datahold-4.0.0.dev5}/tests/test_datahold_TestDataAttribute.py

@@ -3,8 +3,6 @@ __all__: list[str] = ["TestDataAttribute"]
 import unittest
 from typing import Any, Self
 
-from frozendict import frozendict
-
 from datahold import (
     FrozenHoldDict,
     FrozenHoldList,
@@ -22,13 +20,8 @@ class TestDataAttribute(unittest.TestCase):
         obj: Any
         f = FrozenHoldDict({"a": 1})
         m = HoldDict({"a": 1})
-
         for obj in (f, m):
-            self.assertIsInstance(obj.__fget__(), frozendict)
-
-            # try to mutate underlying data
-            with self.assertRaises((TypeError, AttributeError)):
-                obj.__fget__()["b"] = 2
+            self.assertIsInstance(obj.__fget__(), dict)
 
     def test_list_data_is_tuple(self: Self) -> None:
         f: FrozenHoldList[Any]
@@ -36,11 +29,8 @@ class TestDataAttribute(unittest.TestCase):
         o: Any
         f = FrozenHoldList([1, 2, 3])
         m = HoldList([1, 2, 3])
-
         for o in (f, m):
-            self.assertIsInstance(o.__fget__(), tuple)
-            with self.assertRaises(Exception):
-                o.__fget__().append(4)
+            self.assertIsInstance(o.__fget__(), list)
 
     def test_set_data_is_frozenset(self: Self) -> None:
         f: FrozenHoldSet[Any]
@@ -48,11 +38,8 @@ class TestDataAttribute(unittest.TestCase):
         obj: Any
         f = FrozenHoldSet({1, 2, 3})
         m = HoldSet({1, 2, 3})
-
         for obj in (f, m):
-            self.assertIsInstance(obj.__fget__(), frozenset)
-            with self.assertRaises(AttributeError):
-                obj.__fget__().add(4)
+            self.assertIsInstance(obj.__fget__(), set)
 
 
 if __name__ == "__main__":

{datahold-4.0.0.dev3 → datahold-4.0.0.dev5}/tests/test_datahold_TestMutableBehavior.py

@@ -19,7 +19,7 @@ class TestMutableBehavior(unittest.TestCase):
         x = HoldList([1, 2])
         x.append(3)
         self.assertEqual(list(x), [1, 2, 3])
-        self.assertEqual(x.__fget__(), (1, 2, 3))
+        self.assertEqual(x.__fget__(), [1, 2, 3])
 
     def test_hold_set_mutates_and_syncs_data(self: Self) -> None:
         s: HoldSet[Any]