datahold 4.0.0.dev24__tar.gz → 4.0.0.dev26__tar.gz

{datahold-4.0.0.dev24 → datahold-4.0.0.dev26}/PKG-INFO

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

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

{datahold-4.0.0.dev24 → datahold-4.0.0.dev26}/src/datahold/__init__.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 __all__: list[str] = [
     "Collection",
     "DictLike",
-    "DictSlot",
     "FrozenDictLike",
     "FrozenDictSlot",
     "FrozenListLike",
@@ -13,7 +12,6 @@ __all__: list[str] = [
     "FrozenSetLike",
     "FrozenSetSlot",
     "ListLike",
-    "ListSlot",
     "Mapping",
     "MutableDictLike",
     "MutableDictSlot",
@@ -27,7 +25,6 @@ __all__: list[str] = [
     "Sequence",
     "Set",
     "SetLike",
-    "SetSlot",
 ]
 
 from abc import abstractmethod
@@ -47,7 +44,7 @@ from typing import (
 import setdoc
 from frozendict import frozendict
 
-### UTILS ###
+### PROTOCOLS ###
 
 
 class ContextManager[Enter](Protocol):
@@ -75,6 +72,99 @@ class SupportsKeysAndGetitem[Key, Value](Protocol):
     def keys(self: Self, /) -> abc.Iterable[Key]: ...
 
 
+class Collection_Frozen[Item](
+    abc.Sized,
+    abc.Iterable[Item],
+    Protocol,
+):
+    @setdoc.basic
+    def __contains__(self: Self, other: Never, /) -> bool: ...
+
+
+class MutableSet_Mutable[Item: abc.Hashable](Protocol):
+    @setdoc.basic
+    def add(self: Self, item: Item, /) -> object: ...
+    @setdoc.basic
+    def discard(self: Self, item: abc.Hashable, /) -> object: ...
+
+
+class Mapping_Frozen[Key, Value](Collection_Frozen[Key], Protocol):
+    @setdoc.basic
+    def __getitem__(self: Self, key: abc.Hashable, /) -> Value: ...
+class MutableMapping_Mutable[Key_, Value_](
+    Protocol,
+):
+    @setdoc.basic
+    def __delitem__(self: Self, key: Key_ | str, /) -> object: ...
+    @setdoc.basic
+    def __setitem__(
+        self: Self, key: Key_ | str, value: Optional[Value_], /
+    ) -> object: ...
+class Sequence_Frozen[Item](
+    Collection_Frozen[Item],
+    Protocol,
+):
+    @overload
+    @setdoc.basic
+    def __getitem__(self: Self, key: int, /) -> Item: ...
+    @overload
+    @setdoc.basic
+    def __getitem__(self: Self, key: Slice[int], /) -> abc.Sequence[Item]: ...
+    @setdoc.basic
+    def __getitem__(
+        self: Self,
+        key: int | Slice[int],
+        /,
+    ) -> Item | abc.Sequence[Item]: ...
+
+
+class MutableSequence_Mutable[Item](Protocol):
+    @overload
+    @setdoc.basic
+    def __delitem__(self: Self, key: SupportsIndex, /) -> None: ...
+    @overload
+    @setdoc.basic
+    def __delitem__(self: Self, key: Slice[SupportsIndex], /) -> None: ...
+    @setdoc.basic
+    def __delitem__(
+        self: Self, key: SupportsIndex | Slice[SupportsIndex], /
+    ) -> None: ...
+    @overload
+    @setdoc.basic
+    def __getitem__(self: Self, key: int, /) -> Item: ...
+    @overload
+    @setdoc.basic
+    def __getitem__(
+        self: Self, key: Slice[int], /
+    ) -> abc.MutableSequence[Item]: ...
+    @setdoc.basic
+    def __getitem__(
+        self: Self,
+        key: int | Slice[int],
+        /,
+    ) -> Item | abc.MutableSequence[Item]: ...
+    @overload
+    @setdoc.basic
+    def __setitem__(self: Self, key: int, value: Item, /) -> None: ...
+    @overload
+    @setdoc.basic
+    def __setitem__(
+        self: Self, key: Slice[int], value: abc.Iterable[Item], /
+    ) -> None: ...
+    @setdoc.basic
+    def __setitem__(
+        self: Self,
+        key: int | Slice[int],
+        value: Item | abc.Iterable[Item],
+        /,
+    ) -> None: ...
+    @setdoc.basic
+    def insert(self: Self, index: int, item: Item, /) -> None: ...
+
+
+### TYPE ALIASES ###
+
+
 type DictInit[Key, Value] = (
     SupportsKeysAndGetitem[Key | str, Optional[Value]]
     | abc.Iterable[tuple[Key | str, Optional[Value]]]
@@ -86,15 +176,6 @@ type Slice[Index] = slice[Optional[Index], Optional[Index], Optional[Index]]
 ### COLLECTION ###
 
 
-class Collection_Frozen[Item](
-    abc.Sized,
-    abc.Iterable[Item],
-    Protocol,
-):
-    @setdoc.basic
-    def __contains__(self: Self, other: Never, /) -> bool: ...
-
-
 class Collection[Item](
     abc.Sized,
     abc.Iterable[Item],
@@ -133,11 +214,6 @@ class Set[Item: abc.Hashable](Collection[Item], abc.Set[Item]):
     __slots__ = ()
 
 
-class MutableSet_Mutable[Item: abc.Hashable](Protocol):
-    @setdoc.basic
-    def add(self: Self, item: Item, /) -> object: ...
-    @setdoc.basic
-    def discard(self: Self, item: abc.Hashable, /) -> object: ...
 class MutableSet[Item: abc.Hashable](Set[Item], abc.MutableSet[Item]):
     """Provide abc for custom mutable set."""
 
@@ -259,32 +335,28 @@ class MutableSetLike[Item: abc.Hashable](SetLike[Item], MutableSet[Item]):
 ### SET-SLOT ###
 
 
-class SetSlot[Item: abc.Hashable](SetLike[Item]):
-    """Provide slotted set-like."""
+class FrozenSetSlot[Item](FrozenSetLike[Item]):
+    """Provide slotted frozen set-like."""
 
     __slots__ = ("_slot",)
 
-    _slot: SetSlot.__Frozen__[Item]
+    _slot: FrozenSetSlot.__Frozen__[Item]
 
     @setdoc.basic
-    def __frozen__(self: Self, /) -> SetSlot.__Frozen__[Item]:
+    def __frozen__(self: Self, /) -> FrozenSetSlot.__Frozen__[Item]:
         return self._slot
 
-
-class FrozenSetSlot[Item](SetSlot[Item], FrozenSetLike[Item]):
-    """Provide slotted frozen set-like."""
-
-    __slots__ = ()
-
     @setdoc.basic
     def __init__(self: Self, data: abc.Iterable[Item] = (), /) -> None:
         self._slot = frozenset(data)
 
 
-class MutableSetSlot[Item](SetSlot[Item], MutableSetLike[Item]):
+class MutableSetSlot[Item](MutableSetLike[Item]):
     """Provide slotted mutable set-like."""
 
-    __slots__ = ()
+    __slots__ = ("_slot",)
+
+    _slot: FrozenSetSlot.__Frozen__[Item]
 
     @contextmanager
     @setdoc.basic
@@ -301,9 +373,6 @@ class MutableSetSlot[Item](SetSlot[Item], MutableSetLike[Item]):
 ### MAPPING ###
 
 
-class Mapping_Frozen[Key, Value](Collection_Frozen[Key], Protocol):
-    @setdoc.basic
-    def __getitem__(self: Self, key: abc.Hashable, /) -> Value: ...
 class Mapping[Key: abc.Hashable, Value](
     Collection[Key],
     abc.Mapping[Key, Value],
@@ -322,15 +391,6 @@ class Mapping[Key: abc.Hashable, Value](
         return self.__frozen__()[key]
 
 
-class MutableMapping_Mutable[Key_, Value_](
-    Protocol,
-):
-    @setdoc.basic
-    def __delitem__(self: Self, key: Key_ | str, /) -> object: ...
-    @setdoc.basic
-    def __setitem__(
-        self: Self, key: Key_ | str, value: Optional[Value_], /
-    ) -> object: ...
 class MutableMapping[Key: abc.Hashable, Value](
     Mapping[Key, Value],
     abc.MutableMapping[Key | str, Optional[Value]],
@@ -366,9 +426,7 @@ class DictLike[Key: abc.Hashable, Value](
     """Provide abc for custom dict-like."""
 
     __slots__ = ()
-    type __Frozen__[FrozenKey, FrozenValue] = frozendict[
-        FrozenKey | str, Optional[FrozenValue]
-    ]
+    type __Frozen__[Key_, Value_] = frozendict[Key_ | str, Optional[Value_]]
 
     @abstractmethod
     @setdoc.basic
@@ -471,27 +529,20 @@ class MutableDictLike[Key: abc.Hashable, Value](
 ### DICT-SLOT ###
 
 
-class DictSlot[Key: abc.Hashable, Value](DictLike[Key, Value]):
-    """Provide slotted dict-like."""
+class FrozenDictSlot[Key: abc.Hashable, Value](
+    FrozenDictLike[Key, Value],
+):
+    """Provide slotted frozen dict-like."""
 
     __slots__ = ("_slot",)
-    _slot: DictSlot.__Frozen__[Key, Value]
+    _slot: FrozenDictSlot.__Frozen__[Key, Value]
 
     @setdoc.basic
     def __frozen__(  # type: ignore[override]
         self: Self,
-    ) -> DictSlot.__Frozen__[Key, Value]:
+    ) -> FrozenDictSlot.__Frozen__[Key, Value]:
         return self._slot
 
-
-class FrozenDictSlot[Key: abc.Hashable, Value](
-    DictSlot[Key, Value],
-    FrozenDictLike[Key, Value],
-):
-    """Provide slotted frozen dict-like."""
-
-    __slots__ = ()
-
     @setdoc.basic
     def __init__(
         self: Self,
@@ -499,16 +550,16 @@ class FrozenDictSlot[Key: abc.Hashable, Value](
         /,
         **kwargs: Optional[Value],
     ) -> None:
-        self._slot = frozendict(data)  # type: ignore[arg-type]
+        self._slot = frozendict(data, **kwargs)  # type: ignore[arg-type]
 
 
 class MutableDictSlot[Key: abc.Hashable, Value](
-    DictSlot[Key, Value],
     MutableDictLike[Key, Value],
 ):
     """Provide slotted mutable dict-like."""
 
-    __slots__ = ()
+    __slots__ = ("_slot",)
+    _slot: FrozenDictSlot.__Frozen__[Key, Value]
 
     @contextmanager
     @setdoc.basic
@@ -525,22 +576,6 @@ class MutableDictSlot[Key: abc.Hashable, Value](
 ### SEQUENCE ###
 
 
-class Sequence_Frozen[Item](
-    Collection_Frozen[Item],
-    Protocol,
-):
-    @overload
-    @setdoc.basic
-    def __getitem__(self: Self, key: int, /) -> Item: ...
-    @overload
-    @setdoc.basic
-    def __getitem__(self: Self, key: Slice[int], /) -> abc.Sequence[Item]: ...
-    @setdoc.basic
-    def __getitem__(
-        self: Self,
-        key: int | Slice[int],
-        /,
-    ) -> Item | abc.Sequence[Item]: ...
 class Sequence[Item](Collection[Item], abc.Sequence[Item]):
     """Provide abc for customized sequence."""
 
@@ -563,50 +598,6 @@ class Sequence[Item](Collection[Item], abc.Sequence[Item]):
         return self.__frozen__()[key]
 
 
-class MutableSequence_Mutable[Item](Protocol):
-    @overload
-    @setdoc.basic
-    def __delitem__(self: Self, key: SupportsIndex, /) -> None: ...
-    @overload
-    @setdoc.basic
-    def __delitem__(self: Self, key: Slice[SupportsIndex], /) -> None: ...
-    @setdoc.basic
-    def __delitem__(
-        self: Self, key: SupportsIndex | Slice[SupportsIndex], /
-    ) -> None: ...
-    @overload
-    @setdoc.basic
-    def __getitem__(self: Self, key: int, /) -> Item: ...
-    @overload
-    @setdoc.basic
-    def __getitem__(
-        self: Self, key: Slice[int], /
-    ) -> abc.MutableSequence[Item]: ...
-    @setdoc.basic
-    def __getitem__(
-        self: Self,
-        key: int | Slice[int],
-        /,
-    ) -> Item | abc.MutableSequence[Item]: ...
-    @overload
-    @setdoc.basic
-    def __setitem__(self: Self, key: int, value: Item, /) -> None: ...
-    @overload
-    @setdoc.basic
-    def __setitem__(
-        self: Self, key: Slice[int], value: abc.Iterable[Item], /
-    ) -> None: ...
-    @setdoc.basic
-    def __setitem__(
-        self: Self,
-        key: int | Slice[int],
-        value: Item | abc.Iterable[Item],
-        /,
-    ) -> None: ...
-    @setdoc.basic
-    def insert(self: Self, index: int, item: Item, /) -> None: ...
-
-
 class MutableSequence[Item](Sequence[Item], abc.MutableSequence[Item]):
     """Provide abc for custom mutable sequence."""
 
@@ -853,31 +844,26 @@ class MutableListLike[Item](ListLike[Item], MutableSequence[Item]):
 ### LIST-SLOT ###
 
 
-class ListSlot[Item](ListLike[Item]):
-    """Provide slotted list-like class."""
+class FrozenListSlot[Item](FrozenListLike[Item]):
+    """Provide slotted frozen list-like."""
 
     __slots__ = ("_slot",)
-    _slot: ListSlot.__Frozen__[Item]
+    _slot: FrozenListSlot.__Frozen__[Item]
 
     @setdoc.basic
-    def __frozen__(self: Self) -> ListSlot.__Frozen__[Item]:
+    def __frozen__(self: Self) -> FrozenListSlot.__Frozen__[Item]:
         return self._slot
 
-
-class FrozenListSlot[Item](ListSlot[Item], FrozenListLike[Item]):
-    """Provide slotted frozen list-like."""
-
-    __slots__ = ()
-
     @setdoc.basic
     def __init__(self: Self, data: abc.Iterable[Item] = (), /) -> None:
         self._slot = tuple(data)
 
 
-class MutableListSlot[Item](ListSlot[Item], MutableListLike[Item]):
+class MutableListSlot[Item](MutableListLike[Item]):
     """Provide slotted mutable list-like."""
 
-    __slots__ = ()
+    __slots__ = ("_slot",)
+    _slot: MutableListSlot.__Frozen__[Item]
 
     @contextmanager
     @setdoc.basic

{datahold-4.0.0.dev24 → datahold-4.0.0.dev26}/src/datahold.egg-info/PKG-INFO

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

@@ -20,6 +20,7 @@ src/datahold.egg-info/dependency_links.txt
 src/datahold.egg-info/requires.txt
 src/datahold.egg-info/top_level.txt
 tests/test_FrozenListSlot.py
+tests/test_MutableDictSlot.py
 tests/test_MutableListSlot.py
 tests/test_abstractmethods.py
 tests/test_all.py

{datahold-4.0.0.dev24 → datahold-4.0.0.dev26}/tests/test_name.py

@@ -40,17 +40,15 @@ class TestName(unittest.TestCase):
             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:]))
-            )
+            ancestor = getattr(datahold, name[6:], object)
+            self.assertTrue(issubclass(datatype, ancestor))
         # mutable
         if prefix == "Mutable":
             self.assertIn(datatype.__hash__, [None, object.__hash__])
             self.assertTrue(hasattr(datatype, "__Mutable__"))
             self.assertTrue(hasattr(datatype, "__mutate__"))
-            self.assertTrue(
-                issubclass(datatype, Lazy.get_import("datahold." + name[7:]))
-            )
+            ancestor = getattr(datahold, name[7:], object)
+            self.assertTrue(issubclass(datatype, ancestor))
         # no prefix
         if prefix == "":
             self.assertIn(datatype.__hash__, [None, object.__hash__])
@@ -62,11 +60,8 @@ class TestName(unittest.TestCase):
         # slot
         if suffix == "Slot":
             self.assertTrue(hasattr(datatype, "__init__"))
-            self.assertTrue(
-                issubclass(
-                    datatype, Lazy.get_import("datahold." + name[:-4] + "Like")
-                )
-            )
+            ancestor = getattr(datahold, name[:-4] + "Like")
+            self.assertTrue(issubclass(datatype, ancestor))
         # no suffix
         if suffix == "":
             self.assertIs(datatype.__init__, object.__init__)

{datahold-4.0.0.dev24 → datahold-4.0.0.dev26}/tests/test_variance.py

@@ -2,7 +2,7 @@
 
 import unittest
 
-from datahold import FrozenListLike, FrozenListSlot, ListLike, ListSlot
+from datahold import FrozenListLike, FrozenListSlot, ListLike
 
 
 class Animal:
@@ -26,12 +26,6 @@ def cast_FrozenListLikeAnimal(
     return x
 
 
-def cast_ListSlotAnimal(
-    x: ListSlot[Bear],
-) -> ListSlot[Animal]:
-    return x
-
-
 def cast_FrozenListSlotAnimal(
     x: FrozenListSlot[Bear],
 ) -> FrozenListSlot[Animal]:

{datahold-4.0.0.dev24 → datahold-4.0.0.dev26}/tests/testdata.toml

@@ -7,10 +7,6 @@ __or__ = "datahold.DictLike"
 "collections.abc.Mapping" = true
 "datahold.Mapping" = true
 
-[datatypes.DictSlot.issubclass]
-"collections.abc.Mapping" = true
-"datahold.DictLike" = true
-
 [datatypes.FrozenDictLike.issubclass]
 "collections.abc.Hashable" = true
 "datahold.Mapping" = true
@@ -182,13 +178,6 @@ __Mutable__ = ""
 [datatypes.ListLike.varia]
 generic = 1
 
-[datatypes.ListSlot.nested]
-__Frozen__ = "builtins.tuple"
-__Mutable__ = ""
-
-[datatypes.ListSlot.varia]
-generic = 1
-
 [datatypes.Mapping.issubclass]
 "collections.abc.Mapping" = true
 "datahold.Collection" = true
@@ -288,7 +277,6 @@ sort = ""
 "datahold.Collection" = true
 "datahold.MutableSet" = true
 "datahold.MutableSetLike" = true
-"datahold.SetSlot" = true
 
 [datatypes.Sequence]
 
@@ -302,9 +290,4 @@ sort = ""
 "datahold.Set" = true
 "datahold.SetLike" = true
 
-[datatypes.SetSlot.issubclass]
-"collections.abc.Set" = true
-"datahold.Collection" = true
-"datahold.SetLike" = true
-
 [non_datatypes]