datahold 4.0.0.dev21__tar.gz → 4.0.0.dev22__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datahold
-Version: 4.0.0.dev21
+Version: 4.0.0.dev22
 Summary: This project wraps common mutable datastructures for inheritance with modification.
 Author-email: Johannes <johannes.programming@gmail.com>
 License-Expression: MIT
@@ -19,6 +19,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
+Requires-Dist: frozendict<3,>=2.4.7
 Requires-Dist: setdoc<2,>=1.3.24
 Dynamic: license-file
 

{datahold-4.0.0.dev21 → datahold-4.0.0.dev22}/pyproject.toml

@@ -19,6 +19,7 @@ classifiers = [
     "Typing :: Typed",
 ]
 dependencies = [
+    "frozendict>=2.4.7,<3",
     "setdoc>=1.3.24,<2",
 ]
 description = "This project wraps common mutable datastructures for inheritance with modification."
@@ -30,7 +31,7 @@ license-files = [
 name = "datahold"
 readme = "README.rst"
 requires-python = ">=3.11"
-version = "4.0.0.dev21"
+version = "4.0.0.dev22"
 
 [project.urls]
 Download = "https://pypi.org/project/datahold/#files"
@@ -42,5 +43,5 @@ Website = "http://datahold.johannes-programming.online/"
 files = [
     ".",
 ]
-python_version = "3.11"
+python_version = "3.12"
 strict = true

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

@@ -4,14 +4,22 @@ from __future__ import annotations
 
 __all__: list[str] = [
     "Collection",
+    "DictLike",
+    "DictSlot",
+    "FrozenDictLike",
+    "FrozenDictSlot",
     "FrozenListLike",
     "FrozenListSlot",
     "FrozenSetLike",
     "FrozenSetSlot",
     "ListLike",
     "ListSlot",
+    "Mapping",
+    "MutableDictLike",
+    "MutableDictSlot",
     "MutableListLike",
     "MutableListSlot",
+    "MutableMapping",
     "MutableSequence",
     "MutableSet",
     "MutableSetLike",
@@ -37,6 +45,7 @@ from typing import (
 )
 
 import setdoc
+from frozendict import frozendict
 
 ### UTILS ###
 
@@ -57,6 +66,20 @@ class ContextManager[Enter](Protocol):
     ) -> object: ...
 
 
+class SupportsKeysAndGetitem[Key, Value](Protocol):
+    """Provide protocol supporting keys and __getitem__."""
+
+    @setdoc.basic
+    def __getitem__(self: Self, key: Key, /) -> Value: ...
+    @setdoc.basic
+    def keys(self: Self, /) -> abc.Iterable[Key]: ...
+
+
+type DictInit[Key, Value] = (
+    SupportsKeysAndGetitem[Key | str, Optional[Value]]
+    | abc.Iterable[tuple[Key | str, Optional[Value]]]
+)
+
 type Slice[Index] = slice[Optional[Index], Optional[Index], Optional[Index]]
 
 
@@ -68,12 +91,12 @@ class Collection[Item](
     abc.Iterable[Item],
     abc.Container[object],
 ):
-    """Provide abc for custom collections."""
+    """Provide abc for custom collection."""
 
     @setdoc.basic
-    class __Frozen__[FrozenItem](
+    class __Frozen__[Item_](
         abc.Sized,
-        abc.Iterable[FrozenItem],
+        abc.Iterable[Item_],
         Protocol,
     ):
         @setdoc.basic
@@ -114,9 +137,9 @@ class MutableSet[Item: abc.Hashable](Set[Item], abc.MutableSet[Item]):
     __slots__ = ()
 
     @setdoc.basic
-    class __Mutable__[MutableItem: abc.Hashable](Protocol):
+    class __Mutable__[Item_: abc.Hashable](Protocol):
         @setdoc.basic
-        def add(self: Self, item: MutableItem, /) -> object: ...
+        def add(self: Self, item: Item_, /) -> object: ...
         @setdoc.basic
         def discard(self: Self, item: abc.Hashable, /) -> object: ...
     @abstractmethod
@@ -140,15 +163,14 @@ class SetLike[Item: abc.Hashable](Set[Item]):
     """Provide abc for custom set-like."""
 
     __slots__ = ()
-    type __Frozen__[FrozenItem] = frozenset[FrozenItem]
-    type Init[FrozenItem] = abc.Iterable[FrozenItem]
+    type __Frozen__[Item_] = frozenset[Item_]
 
     @abstractmethod
     @setdoc.basic
     def __frozen__(self: Self, /) -> __Frozen__[Item]: ...
     @abstractmethod
     @setdoc.basic
-    def __init__(self: Self, data: Init[Item] = (), /) -> None: ...
+    def __init__(self: Self, data: abc.Iterable[Item] = (), /) -> None: ...
     @setdoc.basic
     def difference(self: Self, /, *others: abc.Iterable[abc.Hashable]) -> Self:
         return type(self)(self.__frozen__().difference(*others))
@@ -190,8 +212,7 @@ class MutableSetLike[Item: abc.Hashable](SetLike[Item], MutableSet[Item]):
     """Provide abc for custom mutable set-like."""
 
     __slots__ = ()
-
-    type __Mutable__[MutableItem] = set[MutableItem]
+    type __Mutable__[Item_] = set[Item_]
 
     @setdoc.basic
     def __frozen__(self: Self, /) -> MutableSetLike.__Frozen__[Item]:
@@ -200,7 +221,7 @@ class MutableSetLike[Item: abc.Hashable](SetLike[Item], MutableSet[Item]):
 
     @abstractmethod
     @setdoc.basic
-    def __init__(self: Self, data: MutableSetLike.Init[Item] = (), /) -> None:
+    def __init__(self: Self, data: abc.Iterable[Item] = (), /) -> None:
         with self.__mutate__() as mutable:
             mutable.update(data)
 
@@ -255,7 +276,7 @@ class FrozenSetSlot[Item](SetSlot[Item], FrozenSetLike[Item]):
     __slots__ = ()
 
     @setdoc.basic
-    def __init__(self: Self, data: FrozenSetSlot.Init[Item] = (), /) -> None:
+    def __init__(self: Self, data: abc.Iterable[Item] = (), /) -> None:
         self._slot = frozenset(data)
 
 
@@ -272,38 +293,260 @@ class MutableSetSlot[Item](SetSlot[Item], MutableSetLike[Item]):
         self._slot = frozenset(slot)
 
 
+### MAPPING ###
+
+
+class Mapping[Key: abc.Hashable, Value](
+    Collection[Key],
+    abc.Mapping[Key, Value],
+):
+    """Provide abc for custom mapping."""
+
+    __slots__ = ()
+
+    @setdoc.basic
+    class __Frozen__[FrozenKey, FrozenValue](
+        Collection.__Frozen__[FrozenKey], Protocol
+    ):
+        @setdoc.basic
+        def __getitem__(self: Self, key: abc.Hashable, /) -> FrozenValue: ...
+    @abstractmethod
+    @setdoc.basic
+    def __frozen__(self: Self, /) -> __Frozen__[Key, Value]: ...
+    @setdoc.basic
+    def __getitem__(self: Self, key: abc.Hashable, /) -> Value:
+        return self.__frozen__()[key]
+
+
+class MutableMapping[Key: abc.Hashable, Value](
+    Mapping[Key, Value],
+    abc.MutableMapping[Key | str, Optional[Value]],
+):
+    """Provide abc for custom mutable mapping."""
+
+    __slots__ = ()
+
+    @setdoc.basic
+    class __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: ...
+
+    @setdoc.basic
+    def __delitem__(self: Self, key: Key | str, /) -> None:
+        with self.__mutate__() as mutable:
+            del mutable[key]
+
+    @abstractmethod
+    @setdoc.basic
+    def __mutate__(self: Self) -> ContextManager[__Mutable__[Key, Value]]: ...
+    @setdoc.basic
+    def __setitem__(
+        self: Self, key: Key | str, value: Optional[Value], /
+    ) -> None:
+        self[key] = value
+
+
+### DICT-LIKE ###
+
+
+class DictLike[Key: abc.Hashable, Value](
+    Mapping[Key | str, Optional[Value]],
+):
+    """Provide abc for custom dict-like."""
+
+    __slots__ = ()
+    type __Frozen__[FrozenKey, FrozenValue] = frozendict[
+        FrozenKey | str, Optional[FrozenValue]
+    ]
+
+    @abstractmethod
+    @setdoc.basic
+    def __frozen__(self: Self, /) -> __Frozen__[Key, Value]: ...  # type: ignore[override]
+    @abstractmethod
+    @setdoc.basic
+    def __init__(
+        self: Self,
+        data: DictInit[Key, Value] = (),
+        /,
+        **kwargs: Value,
+    ): ...
+    @setdoc.basic
+    def __or__[Key_, Value_](
+        self: Self,
+        other: DictInit[Key_, Value_],
+        /,
+    ) -> DictLike[Key | Key_, Value | Value_]:
+        data: DictLike.__Frozen__[Key_, Value_]
+        try:
+            data = frozendict(other)  # type: ignore[arg-type]
+        except TypeError:
+            return NotImplemented
+        return type(self)(  # type: ignore[return-value]
+            self.__frozen__() | data  # type: ignore[operator]
+        )
+
+    @classmethod
+    @setdoc.basic
+    def fromkeys(
+        cls: type[Self],
+        iterable: abc.Iterable[Key | str],
+        value: Optional[Value],
+        /,
+    ) -> Self:
+        return cls(dict.fromkeys(iterable, value))
+
+
+class FrozenDictLike[Key: abc.Hashable, Value](
+    DictLike[Key, Value],
+    abc.Hashable,
+):
+    """Provide abc for custom frozen dict-like."""
+
+    __slots__ = ()
+
+    @setdoc.basic
+    def __hash__(self: Self, /) -> int:
+        return hash(self.__frozen__())
+
+
+class MutableDictLike[Key: abc.Hashable, Value](
+    DictLike[Key, Value],
+    MutableMapping[Key, Value],
+):
+    """Provide abc for custom mutable dict-like."""
+
+    __slots__ = ()
+    type __Mutable__[Key_: abc.Hashable, Value_] = dict[
+        Key_ | str, Optional[Value_]
+    ]
+
+    @setdoc.basic
+    def __frozen__(  # type: ignore[override]
+        self: Self,
+        /,
+    ) -> MutableDictLike.__Frozen__[Key, Value]:
+        with self.__mutate__() as mutable:
+            return frozendict(mutable)
+
+    @setdoc.basic
+    def __init__(
+        self: Self,
+        data: DictInit[Key, Value] = (),
+        /,
+        **kwargs: Optional[Value],
+    ):
+        self.update(data, **kwargs)
+
+    @setdoc.basic
+    def __ior__(  # type: ignore[override]
+        self: Self,
+        other: DictInit[Key, Value],
+        /,
+    ) -> Self:
+        with self.__mutate__() as mutable:
+            mutable |= other
+        return self
+
+    @abstractmethod
+    @setdoc.basic
+    def __mutate__(
+        self: Self, /
+    ) -> ContextManager[__Mutable__[Key, Value]]: ...
+    @setdoc.basic
+    def copy(self: Self, /) -> Self:
+        return type(self)(self)
+
+
+### DICT-SLOT ###
+
+
+class DictSlot[Key: abc.Hashable, Value](DictLike[Key, Value]):
+    """Provide slotted dict-like."""
+
+    __slots__ = ("_slot",)
+    _slot: DictSlot.__Frozen__[Key, Value]
+
+    @setdoc.basic
+    def __frozen__(  # type: ignore[override]
+        self: Self,
+    ) -> DictSlot.__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,
+        data: DictInit[Key, Value] = (),
+        /,
+        **kwargs: Optional[Value],
+    ) -> None:
+        self._slot = frozendict(data)  # type: ignore[arg-type]
+
+
+class MutableDictSlot[Key: abc.Hashable, Value](
+    DictSlot[Key, Value],
+    MutableDictLike[Key, Value],
+):
+    """Provide slotted mutable dict-like."""
+
+    __slots__ = ()
+
+    @contextmanager
+    @setdoc.basic
+    def __mutate__(
+        self: Self,
+        /,
+    ) -> abc.Generator[MutableDictSlot.__Mutable__[Key, Value], None, None]:
+        slot: MutableDictSlot.__Mutable__[Key, Value]
+        slot = dict(getattr(self, "_slot", ()))
+        yield slot
+        self._slot = frozendict(slot)
+
+
 ### SEQUENCE ###
 
 
 class Sequence[Item](Collection[Item], abc.Sequence[Item]):
-    """Provide a base class for customized sequence."""
+    """Provide abc for customized sequence."""
 
     __slots__ = ()
 
     @setdoc.basic
-    class __Frozen__[FrozenItem](
-        Collection.__Frozen__[FrozenItem],
+    class __Frozen__[Item_](
+        Collection.__Frozen__[Item_],
         Protocol,
     ):
         @overload
         @setdoc.basic
-        def __getitem__(self: Self, key: int, /) -> FrozenItem: ...
+        def __getitem__(self: Self, key: int, /) -> Item_: ...
         @overload
         @setdoc.basic
         def __getitem__(
             self: Self, key: Slice[int], /
-        ) -> abc.Sequence[FrozenItem]: ...
+        ) -> abc.Sequence[Item_]: ...
         @setdoc.basic
         def __getitem__(
             self: Self,
             key: int | Slice[int],
             /,
-        ) -> FrozenItem | abc.Sequence[FrozenItem]: ...
-
+        ) -> Item_ | abc.Sequence[Item_]: ...
     @abstractmethod
     @setdoc.basic
     def __frozen__(self: Self, /) -> __Frozen__[Item]: ...
-
     @overload
     @setdoc.basic
     def __getitem__(self: Self, key: int, /) -> Item: ...
@@ -318,13 +561,12 @@ class Sequence[Item](Collection[Item], abc.Sequence[Item]):
 
 
 class MutableSequence[Item](Sequence[Item], abc.MutableSequence[Item]):
-    """Provide a base class for customized mutable list-likes."""
+    """Provide abc for custom mutable sequence."""
 
     __slots__ = ()
 
     @setdoc.basic
-    class __Mutable__[MutableItem](Protocol):
-
+    class __Mutable__[Item_](Protocol):
         @overload
         @setdoc.basic
         def __delitem__(self: Self, key: SupportsIndex, /) -> None: ...
@@ -335,42 +577,37 @@ class MutableSequence[Item](Sequence[Item], abc.MutableSequence[Item]):
         def __delitem__(
             self: Self, key: SupportsIndex | Slice[SupportsIndex], /
         ) -> None: ...
-
         @overload
         @setdoc.basic
-        def __getitem__(self: Self, key: int, /) -> MutableItem: ...
+        def __getitem__(self: Self, key: int, /) -> Item_: ...
         @overload
         @setdoc.basic
         def __getitem__(
             self: Self, key: Slice[int], /
-        ) -> abc.MutableSequence[MutableItem]: ...
+        ) -> abc.MutableSequence[Item_]: ...
         @setdoc.basic
         def __getitem__(
             self: Self,
             key: int | Slice[int],
             /,
-        ) -> MutableItem | abc.MutableSequence[MutableItem]: ...
-
+        ) -> Item_ | abc.MutableSequence[Item_]: ...
         @overload
         @setdoc.basic
-        def __setitem__(
-            self: Self, key: int, value: MutableItem, /
-        ) -> None: ...
+        def __setitem__(self: Self, key: int, value: Item_, /) -> None: ...
         @overload
         @setdoc.basic
         def __setitem__(
-            self: Self, key: Slice[int], value: abc.Iterable[MutableItem], /
+            self: Self, key: Slice[int], value: abc.Iterable[Item_], /
         ) -> None: ...
         @setdoc.basic
         def __setitem__(
             self: Self,
             key: int | Slice[int],
-            value: MutableItem | abc.Iterable[MutableItem],
+            value: Item_ | abc.Iterable[Item_],
             /,
         ) -> None: ...
-
         @setdoc.basic
-        def insert(self: Self, index: int, item: MutableItem, /) -> None: ...
+        def insert(self: Self, index: int, item: Item_, /) -> None: ...
 
     @overload
     @setdoc.basic
@@ -428,15 +665,13 @@ class MutableSequence[Item](Sequence[Item], abc.MutableSequence[Item]):
 
 ### LIST-LIKE ###
 class ListLike[Item](Sequence[Item]):
-    """Provide a base class for customized list-likes."""
+    """Provide abc for custom list-like."""
 
     __slots__ = ()
 
-    type __Frozen__[FrozenItem] = tuple[FrozenItem, ...]
+    type __Frozen__[Item_] = tuple[Item_, ...]
     # Frozen has to be tuple to allow covariance
 
-    type Init[InitItem] = abc.Iterable[InitItem]
-
     @setdoc.basic
     def __add__[Item_](
         self: Self, other: ListLike[Item_], /
@@ -492,7 +727,7 @@ class ListLike[Item](Sequence[Item]):
 
     @abstractmethod
     @setdoc.basic
-    def __init__(self: Self, data: Init[Item] = (), /) -> None: ...
+    def __init__(self: Self, data: abc.Iterable[Item] = (), /) -> None: ...
 
     @setdoc.basic
     def __le__(self: Self, other: ListLike[Any], /) -> bool:
@@ -523,7 +758,7 @@ class ListLike[Item](Sequence[Item]):
 
 
 class FrozenListLike[Item](ListLike[Item], abc.Hashable):
-    """Provide a base class for customized frozen list-likes."""
+    """Provide abc for custom frozen list-like."""
 
     __slots__ = ()
 
@@ -533,11 +768,11 @@ class FrozenListLike[Item](ListLike[Item], abc.Hashable):
 
 
 class MutableListLike[Item](ListLike[Item], MutableSequence[Item]):
-    """Provide a base class for customized mutable list-likes."""
+    """Provide abc for custom mutable list-like."""
 
     __slots__ = ()
 
-    type __Mutable__[MutableItem] = list[MutableItem]
+    type __Mutable__[Item_] = list[Item_]
 
     @overload
     @setdoc.basic
@@ -618,7 +853,6 @@ class ListSlot[Item](ListLike[Item]):
     """Provide slotted list-like class."""
 
     __slots__ = ("_slot",)
-
     _slot: ListSlot.__Frozen__[Item]
 
     @setdoc.basic
@@ -627,7 +861,7 @@ class ListSlot[Item](ListLike[Item]):
 
 
 class FrozenListSlot[Item](ListSlot[Item], FrozenListLike[Item]):
-    """Provide a base class for customized frozen data-holds."""
+    """Provide slotted frozen list-like."""
 
     __slots__ = ()
 
@@ -637,7 +871,7 @@ class FrozenListSlot[Item](ListSlot[Item], FrozenListLike[Item]):
 
 
 class MutableListSlot[Item](ListSlot[Item], MutableListLike[Item]):
-    """Provide slotted mutable list-like class."""
+    """Provide slotted mutable list-like."""
 
     __slots__ = ()
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datahold
-Version: 4.0.0.dev21
+Version: 4.0.0.dev22
 Summary: This project wraps common mutable datastructures for inheritance with modification.
 Author-email: Johannes <johannes.programming@gmail.com>
 License-Expression: MIT
@@ -19,6 +19,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
+Requires-Dist: frozendict<3,>=2.4.7
 Requires-Dist: setdoc<2,>=1.3.24
 Dynamic: license-file
 

datahold-4.0.0.dev22/src/datahold.egg-info/requires.txt

@@ -0,0 +1,2 @@
+frozendict<3,>=2.4.7
+setdoc<2,>=1.3.24

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

@@ -1,5 +1,21 @@
 [datatypes.Collection]
 
+[datatypes.DictLike.issubclass]
+"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
+
+[datatypes.FrozenDictSlot.issubclass]
+"collections.abc.Hashable" = true
+"datahold.FrozenDictLike" = true
+
 [datatypes.FrozenListLike]
 abstractmethods = [
     "__frozen__",
@@ -18,7 +34,6 @@ __init__ = "datahold.ListLike"
 "collections.abc.Sequence" = true
 
 [datatypes.FrozenListLike.nested]
-Init = "collections.abc.Iterable"
 __Frozen__ = "builtins.tuple"
 __Mutable__ = ""
 
@@ -133,7 +148,6 @@ args = [
 ]
 
 [datatypes.FrozenListSlot.nested]
-Init = "collections.abc.Iterable"
 __Frozen__ = "builtins.tuple"
 __Mutable__ = ""
 
@@ -174,7 +188,6 @@ index = "collections.abc.Sequence"
 "datahold.MutableSequence" = false
 
 [datatypes.ListLike.nested]
-Init = "collections.abc.Iterable"
 __Frozen__ = "builtins.tuple"
 __Mutable__ = ""
 
@@ -187,13 +200,27 @@ abstractmethods = [
 ]
 
 [datatypes.ListSlot.nested]
-Init = "collections.abc.Iterable"
 __Frozen__ = "builtins.tuple"
 __Mutable__ = ""
 
 [datatypes.ListSlot.varia]
 generic = 1
 
+[datatypes.Mapping.issubclass]
+"collections.abc.Mapping" = true
+"datahold.Collection" = true
+
+[datatypes.MutableDictLike.issubclass]
+"collections.abc.Mapping" = true
+"collections.abc.MutableMapping" = true
+"datahold.MutableMapping" = true
+
+[datatypes.MutableDictSlot.issubclass]
+"collections.abc.Mapping" = true
+"collections.abc.MutableMapping" = true
+"datahold.MutableDictLike" = true
+"datahold.MutableMapping" = true
+
 [datatypes.MutableListLike]
 abstractmethods = [
     "__mutate__",
@@ -226,7 +253,6 @@ reverse = "collections.abc.MutableSequence"
 "datahold.MutableSequence" = true
 
 [datatypes.MutableListLike.nested]
-Init = "collections.abc.Iterable"
 __Frozen__ = "builtins.tuple"
 __hash__ = ""
 
@@ -243,13 +269,16 @@ abstractmethods = []
 "datahold.MutableListSlot" = true
 
 [datatypes.MutableListSlot.nested]
-Init = "collections.abc.Iterable"
 __Frozen__ = "builtins.tuple"
 __hash__ = ""
 
 [datatypes.MutableListSlot.varia]
 generic = 1
 
+[datatypes.MutableMapping.issubclass]
+"collections.abc.MutableMapping" = true
+"datahold.Mapping" = true
+
 [datatypes.MutableSequence.attributes]
 __Frozen__ = "datahold.Sequence"
 __Mutable__ = "datahold.MutableSequence"

datahold-4.0.0.dev21/src/datahold.egg-info/requires.txt

@@ -1 +0,0 @@
-setdoc<2,>=1.3.24