datahold 4.0.0.dev22__tar.gz → 4.0.0.dev23__tar.gz

{datahold-4.0.0.dev22 → datahold-4.0.0.dev23}/PKG-INFO

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

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

{datahold-4.0.0.dev22 → datahold-4.0.0.dev23}/src/datahold/__init__.py

@@ -219,7 +219,6 @@ class MutableSetLike[Item: abc.Hashable](SetLike[Item], MutableSet[Item]):
         with self.__mutate__() as mutable:
             return frozenset(mutable)
 
-    @abstractmethod
     @setdoc.basic
     def __init__(self: Self, data: abc.Iterable[Item] = (), /) -> None:
         with self.__mutate__() as mutable:
@@ -287,7 +286,11 @@ class MutableSetSlot[Item](SetSlot[Item], MutableSetLike[Item]):
 
     @contextmanager
     @setdoc.basic
-    def __mutate__(self: Self, /) -> abc.Generator[set[Item], None, None]:
+    def __mutate__(
+        self: Self,
+        /,
+    ) -> abc.Generator[MutableSetSlot.__Mutable__[Item], None, None]:
+        slot: MutableSetSlot.__Mutable__[Item]
         slot = set(getattr(self, "_slot", ()))
         yield slot
         self._slot = frozenset(slot)

{datahold-4.0.0.dev22 → datahold-4.0.0.dev23}/src/datahold.egg-info/PKG-INFO

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

@@ -20,7 +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_MutableListHold.py
+tests/test_MutableListSlot.py
 tests/test_abstractmethods.py
 tests/test_all.py
 tests/test_attributes.py
@@ -28,8 +28,8 @@ tests/test_docs.py
 tests/test_generic.py
 tests/test_internal_comparison.py
 tests/test_issubclass.py
+tests/test_name.py
 tests/test_nested.py
-tests/test_prefix.py
 tests/test_sorted.py
 tests/test_variance.py
 tests/testdata.toml

{datahold-4.0.0.dev22 → datahold-4.0.0.dev23}/tests/test_abstractmethods.py

@@ -12,22 +12,18 @@ import datahold
 
 
 class TestAbstractmethods(unittest.TestCase):
-    def _test(
-        self: Self, name: str, abstractmethods: Optional[list[str]] = None, /
-    ) -> None:
+    def _test(self: Self, name: str, abstractmethods: set[str], /) -> None:
         datatype: Any
-        if abstractmethods is None:
-            return
         datatype = getattr(datahold, name)
-        self.assertSetEqual(datatype.__abstractmethods__, set(abstractmethods))
+        self.assertLessEqual(len(datatype.__abstractmethods__), 2)
+        self.assertSetEqual(datatype.__abstractmethods__, abstractmethods)
         self.assertEqual(ins.isabstract(datatype), bool(abstractmethods))
 
     def test_abstractmethods(self: Self, /) -> None:
-        data: Any
         name: Any
-        for name, data in Lazy.lazy.datatypes.items():
+        for name in Lazy.lazy.datatypes.keys():
             with self.subTest(datatype=name):
-                self._test(name, data.get("abstractmethods"))
+                self._test(name, Lazy.get_abstractmethods(name))
 
 
 if __name__ == "__main__":

datahold-4.0.0.dev23/tests/test_name.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+__all__: list[str] = ["TestName"]
+
+import unittest
+from collections import abc
+from typing import Self
+
+from Lazy import Lazy
+
+import datahold
+
+
+class TestName(unittest.TestCase):
+
+    def _test_name(self: Self, name: str, /) -> None:
+        prefix: str
+        suffix: str
+        if name.startswith("Frozen"):
+            prefix = "Frozen"
+        elif name.startswith("Mutable"):
+            prefix = "Mutable"
+        else:
+            prefix = ""
+        if name.endswith("Like"):
+            suffix = "Like"
+        elif name.endswith("Slot"):
+            suffix = "Slot"
+        else:
+            suffix = ""
+        # 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.Collection))
+        # 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__"))
+            self.assertTrue(
+                issubclass(datatype, Lazy.get_import("datahold." + name[6:]))
+            )
+        # 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, Lazy.get_import("datahold." + name[7:]))
+            )
+        # 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":
+            self.assertTrue(hasattr(datatype, "__init__"))
+        # slot
+        if suffix == "Slot":
+            self.assertTrue(hasattr(datatype, "__init__"))
+            self.assertTrue(
+                issubclass(
+                    datatype, Lazy.get_import("datahold." + name[:-4] + "Like")
+                )
+            )
+        # no suffix
+        if suffix == "":
+            self.assertIs(datatype.__init__, object.__init__)
+
+    def test_name(self: Self, /) -> None:
+        for name in Lazy.lazy.datatypes.keys():
+            with self.subTest(datatype=name):
+                self._test_name(name)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

{datahold-4.0.0.dev22 → datahold-4.0.0.dev23}/tests/testdata.toml

@@ -1,5 +1,8 @@
 [datatypes.Collection]
 
+[datatypes.DictLike.attributes]
+__or__ = "datahold.DictLike"
+
 [datatypes.DictLike.issubclass]
 "collections.abc.Mapping" = true
 "datahold.Mapping" = true
@@ -16,12 +19,6 @@
 "collections.abc.Hashable" = true
 "datahold.FrozenDictLike" = true
 
-[datatypes.FrozenListLike]
-abstractmethods = [
-    "__frozen__",
-    "__init__",
-]
-
 [datatypes.FrozenListLike.attributes]
 __frozen__ = "datahold.ListLike"
 __init__ = "datahold.ListLike"
@@ -40,9 +37,6 @@ __Mutable__ = ""
 [datatypes.FrozenListLike.varia]
 generic = 1
 
-[datatypes.FrozenListSlot]
-abstractmethods = []
-
 [datatypes.FrozenListSlot.TestInternalComparsion.ge.test_greater_value]
 a = "_1_3"
 b = "_1_2"
@@ -166,12 +160,6 @@ generic = 1
 "collections.abc.Set" = true
 "datahold.Collection" = true
 
-[datatypes.ListLike]
-abstractmethods = [
-    "__frozen__",
-    "__init__",
-]
-
 [datatypes.ListLike.attributes]
 __frozen__ = "datahold.ListLike"
 __init__ = "datahold.ListLike"
@@ -194,11 +182,6 @@ __Mutable__ = ""
 [datatypes.ListLike.varia]
 generic = 1
 
-[datatypes.ListSlot]
-abstractmethods = [
-    "__init__",
-]
-
 [datatypes.ListSlot.nested]
 __Frozen__ = "builtins.tuple"
 __Mutable__ = ""
@@ -210,6 +193,10 @@ generic = 1
 "collections.abc.Mapping" = true
 "datahold.Collection" = true
 
+[datatypes.MutableDictLike.attributes]
+__ior__ = "datahold.MutableDictLike"
+__or__ = "datahold.DictLike"
+
 [datatypes.MutableDictLike.issubclass]
 "collections.abc.Mapping" = true
 "collections.abc.MutableMapping" = true
@@ -221,11 +208,6 @@ generic = 1
 "datahold.MutableDictLike" = true
 "datahold.MutableMapping" = true
 
-[datatypes.MutableListLike]
-abstractmethods = [
-    "__mutate__",
-]
-
 [datatypes.MutableListLike.attributes]
 __add__ = "datahold.MutableListLike"
 __frozen__ = "datahold.MutableListLike"
@@ -259,9 +241,6 @@ __hash__ = ""
 [datatypes.MutableListLike.varia]
 generic = 1
 
-[datatypes.MutableListSlot]
-abstractmethods = []
-
 [datatypes.MutableListSlot.issubclass]
 "builtins.list" = false
 "datahold.ListLike" = true
@@ -312,9 +291,6 @@ sort = ""
 "datahold.SetSlot" = true
 
 [datatypes.Sequence]
-abstractmethods = [
-    "__frozen__",
-]
 
 [datatypes.Set.issubclass]
 "collections.abc.Set" = true

datahold-4.0.0.dev22/tests/test_prefix.py

@@ -1,41 +0,0 @@
-from __future__ import annotations
-
-__all__: list[str] = ["TestPrefix"]
-
-import unittest
-from collections import abc
-from typing import Self
-
-from Lazy import Lazy
-
-import datahold
-
-
-class TestPrefix(unittest.TestCase):
-    def _test_prefix(self: Self, name: str, /) -> None:
-        datatype = getattr(datahold, name)
-        self.assertEqual(datatype.__name__, name)
-        self.assertTrue(hasattr(datatype, "__Frozen__"))
-        self.assertTrue(hasattr(datatype, "__frozen__"))
-        if name.startswith("Frozen"):
-            self.assertIsNot(datatype.__hash__, object.__hash__)
-            self.assertTrue(issubclass(datatype, abc.Hashable))
-            self.assertFalse(hasattr(datatype, "__Mutable__"))
-            self.assertFalse(hasattr(datatype, "__mutate__"))
-            return
-        self.assertIn(datatype.__hash__, [None, object.__hash__])
-        if name.startswith("Mutable"):
-            self.assertTrue(hasattr(datatype, "__Mutable__"))
-            self.assertTrue(hasattr(datatype, "__mutate__"))
-            return
-        self.assertFalse(hasattr(datatype, "__Mutable__"))
-        self.assertFalse(hasattr(datatype, "__mutate__"))
-
-    def test_prefix(self: Self, /) -> None:
-        for name in Lazy.lazy.datatypes.keys():
-            with self.subTest(datatype=name):
-                self._test_prefix(name)
-
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)