datahold 4.0.0.dev31__tar.gz → 4.0.0.dev33__tar.gz

{datahold-4.0.0.dev31 → datahold-4.0.0.dev33}/PKG-INFO

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

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

{datahold-4.0.0.dev31 → datahold-4.0.0.dev33}/src/datahold/__init__.py

@@ -33,15 +33,31 @@ __all__: list[str] = [
     "SetLike",
 ]
 
+import enum
 from abc import ABCMeta, abstractmethod
 from collections import abc
 from contextlib import contextmanager
 from types import NotImplementedType, TracebackType
-from typing import Any, Never, Protocol, Self, SupportsIndex, overload
+from typing import (
+    Any,
+    Never,
+    Protocol,
+    Self,
+    SupportsIndex,
+    overload,
+    runtime_checkable,
+)
 
 import setdoc
 from frozendict import frozendict
 
+### SENTINEL ###
+
+
+class Missing(enum.Enum):
+    MISSING = enum.auto()
+
+
 ### PROTOCOLS ###
 
 
@@ -61,7 +77,8 @@ class ContextManager[Enter](Protocol):
     ) -> object: ...
 
 
-class SupportsKeysAndGetitem[Key, Value](Protocol):
+@runtime_checkable
+class SupportsKeysAndGetItem[Key, Value](Protocol):
     """Provide protocol supporting keys and __getitem__."""
 
     @setdoc.basic
@@ -89,15 +106,17 @@ class SupportsAddAndDiscard[Item: abc.Hashable](Protocol):
 class Mapping_Frozen[Key, Value](Collection_Frozen[Key], Protocol):
     @setdoc.basic
     def __getitem__(self: Self, key: Never, /) -> Value: ...
-class SupportsDelitemAndSetitem[Key, Value](
+
+
+class SupportsDelItemAndSetItem[Key, Value](
     Protocol,
 ):
     @setdoc.basic
-    def __delitem__(self: Self, key: Key | str, /) -> object: ...
+    def __delitem__(self: Self, key: Key, /) -> object: ...
     @setdoc.basic
-    def __setitem__(
-        self: Self, key: Key | str, value: Value | None, /
-    ) -> object: ...
+    def __setitem__(self: Self, key: Key, value: Value, /) -> object: ...
+
+
 class Sequence_Frozen[Item](
     Collection_Frozen[Item],
     Protocol,
@@ -165,8 +184,9 @@ class MutableSequence_Mutable[Item](Protocol):
 type Dict[Key, Value] = dict[Key | str, Value | None]
 
 type Dict_Init[Key, Value] = (
-    SupportsKeysAndGetitem[Key, Value | None]
-    | SupportsKeysAndGetitem[Key | str, Value | None]
+    SupportsKeysAndGetItem[Key, Value | None]
+    | SupportsKeysAndGetItem[str, Value | None]
+    | SupportsKeysAndGetItem[Key | str, Value | None]
     | abc.Iterable[tuple[Key | str, Value | None]]
 )
 
@@ -320,9 +340,11 @@ class SetLike[Item: abc.Hashable](Set[Item]):
     @abstractmethod
     @setdoc.basic
     def __frozen__(self: Self, /) -> frozenset[Item]: ...
+
     @abstractmethod
     @setdoc.basic
     def __init__(self: Self, other: abc.Iterable[Item] = (), /) -> None: ...
+
     @setdoc.basic
     def difference(self: Self, /, *others: abc.Iterable[abc.Hashable]) -> Self:
         return type(self)(self.__frozen__().difference(*others))
@@ -481,11 +503,11 @@ class Mapping[Key: abc.Hashable, Value](
 
 
 class MutableMapping[Key: abc.Hashable, Value](
-    Mapping[Key, Value],
+    Mapping[Key | str, Value | None],
     abc.MutableMapping[Key | str, Value | None],
     MutableObject[
         Mapping_Frozen[Key | str, Value | None],
-        SupportsDelitemAndSetitem[Key | str, Value | None],
+        SupportsDelItemAndSetItem[Key | str, Value | None],
     ],
 ):
     """Provide abc for custom mutable mapping."""
@@ -504,13 +526,69 @@ class MutableMapping[Key: abc.Hashable, Value](
         with self.__mutate__() as mutable:
             mutable[key] = value
 
+    @overload
+    @setdoc.basic
+    def pop(self: Self, key: Key | str, /) -> Value: ...
+    @overload
+    @setdoc.basic
+    def pop[Value_](
+        self: Self, key: Key | str, default: Value_, /
+    ) -> Value | Value_: ...
+    @setdoc.basic
+    def pop[Value_](
+        self: Self,
+        key: Key | str,
+        default: Missing | Value_ = Missing.MISSING,
+        /,
+    ) -> Value | Value_ | None:
+        try:
+            value = self[key]
+        except KeyError:
+            if isinstance(default, Missing):
+                raise
+            return default
+        else:
+            del self[key]
+            return value
+
+    @setdoc.basic
+    def setdefault(
+        self: Self,
+        key: Key | str,
+        default: Value | None = None,
+        /,
+    ) -> Value | None:
+        try:
+            return self[key]
+        except KeyError:
+            self[key] = default
+        return default
+
+    @setdoc.basic
+    def update(
+        self: Self,
+        other: Dict_Init[Key, Value] = (),
+        /,
+        **kwargs: Value | None,
+    ) -> None:
+        key: Any
+        value: Value | None
+        if isinstance(other, SupportsKeysAndGetItem):
+            for key in other.keys():
+                self[key] = other[key]
+        else:
+            for key, value in other:
+                self[key] = value
+        for key, value in kwargs.items():
+            self[key] = value
+
 
 ### DICT-LIKE ###
 
 
 class DictLike[Key: abc.Hashable, Value](
-    Mapping[Key | str, Value | None],
-    abc.Reversible[Key | str],
+    Mapping[Key, Value],
+    abc.Reversible[Key],
 ):
     """Provide abc for custom dict-like."""
 
@@ -518,7 +596,7 @@ class DictLike[Key: abc.Hashable, Value](
 
     @abstractmethod
     @setdoc.basic
-    def __frozen__(self: Self, /) -> FrozenDict[Key, Value]: ...
+    def __frozen__(self: Self, /) -> frozendict[Key, Value]: ...
 
     @abstractmethod
     @setdoc.basic
@@ -528,38 +606,54 @@ class DictLike[Key: abc.Hashable, Value](
         /,
         **kwargs: Value,
     ): ...
+
     @setdoc.basic
     def __or__[Key_: abc.Hashable, Value_](
         self: Self,
-        other: Dict_Init[Key_, Value_],
+        other: DictLike[Key_, Value_],
         /,
     ) -> DictLike[Key | Key_, Value | Value_]:
-        other_: FrozenDict[Key, Value]
-        try:
-            other_ = frozendict(other)  # type: ignore[arg-type]
-        except TypeError:
+        if isinstance(other, DictLike):
+            return type(self)(  # type: ignore[return-value]
+                self.__frozen__() | other  # type: ignore[arg-type]
+            )
+        else:
             return NotImplemented
-        return type(self)(  # type: ignore[return-value]
-            self.__frozen__() | other_
-        )
 
     @setdoc.basic
-    def __reversed__(self: Self, /) -> abc.Iterator[Key | str]:
-        yield from reversed(self.__frozen__())
+    def __reversed__(self: Self, /) -> abc.Iterator[Key]:
+        return reversed(self.__frozen__())
 
+    @overload
     @classmethod
     @setdoc.basic
     def fromkeys(
         cls: type[Self],
-        iterable: abc.Iterable[Key | str],
-        value: Value | None = None,
+        iterable: abc.Iterable[Key],
         /,
-    ) -> Self:
+    ) -> DictLike[Key, None]: ...
+    @overload
+    @classmethod
+    @setdoc.basic
+    def fromkeys(
+        cls: type[Self],
+        iterable: abc.Iterable[Key],
+        value: Value,
+        /,
+    ) -> Self: ...
+    @classmethod
+    @setdoc.basic
+    def fromkeys(
+        cls: type[Self],
+        iterable: abc.Iterable[Key],
+        value: Any = None,
+        /,
+    ) -> Any:
         return cls(dict.fromkeys(iterable, value))
 
 
 class FrozenDictLike[Key: abc.Hashable, Value](
-    FrozenObjectLike[FrozenDict[Key, Value]],
+    FrozenObjectLike[frozendict[Key, Value]],
     DictLike[Key, Value],
 ):
     """Provide abc for custom frozen dict-like."""
@@ -568,7 +662,7 @@ class FrozenDictLike[Key: abc.Hashable, Value](
 
 
 class MutableDictLike[Key: abc.Hashable, Value](
-    DictLike[Key, Value],
+    DictLike[Key | str, Value | None],
     MutableObjectLike[FrozenDict[Key, Value], Dict[Key, Value]],
     MutableMapping[Key, Value],
 ):
@@ -590,9 +684,9 @@ class MutableDictLike[Key: abc.Hashable, Value](
         other: Dict_Init[Key, Value] = (),
         /,
         **kwargs: Value | None,
-    ):
+    ) -> None:
         self.update(
-            other,  # type: ignore[arg-type]
+            other,
             **kwargs,
         )
 
@@ -619,7 +713,7 @@ class MutableDictLike[Key: abc.Hashable, Value](
 
 
 class FrozenDictSlot[Key: abc.Hashable, Value](
-    FrozenObjectSlot[FrozenDict[Key, Value]],
+    FrozenObjectSlot[frozendict[Key, Value]],
     FrozenDictLike[Key, Value],
 ):
     """Provide slotted frozen dict-like."""

{datahold-4.0.0.dev31 → datahold-4.0.0.dev33}/src/datahold.egg-info/PKG-INFO

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

@@ -17,7 +17,6 @@ __all__: list[str] = [
     "TestOperatorReversed",
     "TestOperatorSubscription",
     "TestOperatorTruth",
-    "TestOperatorUnion",
 ]
 import unittest
 from collections import abc
@@ -430,46 +429,6 @@ class TestOperatorInequality(unittest.TestCase):
         self.assertFalse(value != {"a": 1})
 
 
-class TestOperatorUnion(unittest.TestCase):
-    def test_disjoint_mappings(self: Self, /) -> None:
-        left: FrozenDictSlot[Any, Any]
-        result: Any
-        left = FrozenDictSlot({"a": 1})
-        result = left | {"b": 2}
-        self.assertEqual(result, {"a": 1, "b": 2})
-
-    def test_right_operand_overrides(self: Self, /) -> None:
-        left: FrozenDictSlot[Any, Any]
-        result: Any
-        left = FrozenDictSlot({"a": 1, "b": 2})
-        result = left | {"b": 20}
-        self.assertEqual(result, {"a": 1, "b": 20})
-
-    def test_union_with_empty_dictionary(self: Self, /) -> None:
-        left: FrozenDictSlot[Any, Any]
-        result: Any
-        left = FrozenDictSlot({"a": 1})
-        result = left | {}
-        self.assertEqual(result, {"a": 1})
-
-    def test_union_does_not_change_left_operand(self: Self, /) -> None:
-        answer: FrozenDictSlot[str, int]
-        left: FrozenDictSlot[str, int]
-        solution: FrozenDictSlot[str, int]
-        left = FrozenDictSlot({"a": 1})
-        answer = left | {"b": 2}  # type: ignore[operator]
-        # this is the only mypy suppression
-        # that seemingly stems not from a faulty typeshed
-        # but from a fault in mypy itself
-        # FrozenDictSlot[str, int].__or__
-        # annotates SupportsKeyAndGetitem[str, int | None]
-        # which is covariant in the second parameter
-        # and therefore should work
-        solution = FrozenDictSlot({"a": 1, "b": 2})
-        self.assertEqual(answer, solution)
-        self.assertEqual(left, {"a": 1})
-
-
 class TestOperatorLength(unittest.TestCase):
     def test_empty_mapping(self: Self, /) -> None:
         self.assertEqual(len(FrozenDictSlot({})), 0)