datahold 3.0.33__tar.gz → 3.0.34.dev0__tar.gz

{datahold-3.0.33 → datahold-3.0.34.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datahold
-Version: 3.0.33
+Version: 3.0.34.dev0
 Summary: This project wraps common mutable datastructures for inheritance with modification.
 Author-email: Johannes <johannes.programming@gmail.com>
 License-Expression: MIT

{datahold-3.0.33 → datahold-3.0.34.dev0}/pyproject.toml

@@ -35,7 +35,7 @@ license-files = [
 name = "datahold"
 readme = "README.rst"
 requires-python = ">=3.11"
-version = "3.0.33"
+version = "3.0.34.dev0"
 
 [project.urls]
 Download = "https://pypi.org/project/datahold/#files"

datahold-3.0.34.dev0/src/datahold/base/BaseDataCollection.py

@@ -0,0 +1,32 @@
+from abc import abstractmethod
+from collections.abc import Collection, Iterator
+from typing import Self, TypeVar
+
+import setdoc
+
+from ..typing.HashableCollection import HashableCollection
+from .BaseDataObject import BaseDataObject
+
+__all__ = ["BaseDataCollection"]
+
+Item = TypeVar("Item", covariant=True)
+
+
+class BaseDataCollection(BaseDataObject, Collection[Item]):
+    __slots__ = ()
+
+    @setdoc.basic
+    def __contains__(self: Self, other: object, /) -> bool:
+        return other in self.data
+
+    @setdoc.basic
+    def __iter__(self: Self, /) -> Iterator[Item]:
+        return iter(self.data)
+
+    @setdoc.basic
+    def __len__(self: Self, /) -> int:
+        return len(self.data)
+
+    @property
+    @abstractmethod
+    def data(self: Self) -> HashableCollection[Item]: ...

datahold-3.0.34.dev0/src/datahold/base/BaseDataDict.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from collections.abc import (
+    Hashable,
+    ItemsView,
+    Iterable,
+    Iterator,
+    KeysView,
+    Mapping,
+    ValuesView,
+)
+from typing import Optional, Self, TypeVar
+
+import setdoc
+from frozendict import frozendict
+
+from ..typing.SupportsKeysAndGetitem import SupportsKeysAndGetitem
+from .BaseDataCollection import BaseDataCollection
+
+__all__ = ["BaseDataDict"]
+
+Key = TypeVar("Key", bound=Hashable, covariant=True)
+Value = TypeVar("Value", covariant=True)
+Value_ = TypeVar("Value_")
+
+
+class BaseDataDict(
+    BaseDataCollection[Key | str], Mapping[Key | str, Optional[Value]]
+):
+
+    __slots__ = ()
+
+    @setdoc.setdoc(dict.__getitem__.__doc__)
+    def __getitem__(self: Self, key: Hashable, /) -> Optional[Value]:
+        return self.data[key]  # type: ignore[index]
+
+    @abstractmethod
+    @setdoc.setdoc(dict.__init__.__doc__)
+    def __init__(
+        self: Self,
+        data: (
+            SupportsKeysAndGetitem[Key | str, Optional[Value]]
+            | Iterable[tuple[Key | str, Optional[Value]]]
+        ) = (),
+        /,
+        **kwargs: Optional[Value],
+    ) -> None: ...
+
+    @setdoc.basic
+    def __or__(
+        self: Self,
+        other: BaseDataDict[Key, Value],
+        /,
+    ) -> Self:
+        return type(self)(self.data | other.data)
+
+    @setdoc.setdoc(dict.__repr__.__doc__)
+    def __repr__(self: Self, /) -> str:
+        return f"{type(self).__name__}({dict(self)})"
+
+    @setdoc.setdoc(dict.__reversed__.__doc__)
+    def __reversed__(self: Self, /) -> Iterator[Key | str]:
+        return reversed(self.data)
+
+    @property
+    @abstractmethod
+    def data(self: Self) -> frozendict[Key | str, Optional[Value]]: ...
+
+    @classmethod
+    @setdoc.setdoc(dict.fromkeys.__doc__)
+    def fromkeys(
+        cls: type[Self],
+        iterable: Iterable[Key | str],
+        value: Optional[Value] = None,
+        /,
+    ) -> Self:
+        return cls(dict.fromkeys(iterable, value))
+
+    @setdoc.setdoc(dict.get.__doc__)
+    def get(
+        self: Self,
+        key: Hashable,
+        default: Optional[Value_] = None,
+        /,
+    ) -> Optional[Value | Value_]:
+        return self.data.get(key, default)  # type: ignore[arg-type]
+
+    @setdoc.basic
+    def items(
+        self: Self,
+        /,
+    ) -> ItemsView[Key | str, Optional[Value]]:
+        return dict(self.data).items()
+
+    @setdoc.basic
+    def keys(self: Self, /) -> KeysView[Key | str]:
+        return dict(self.data).keys()
+
+    @setdoc.basic
+    def values(self: Self, /) -> ValuesView[Optional[Value]]:
+        return dict(self.data).values()

datahold-3.0.34.dev0/src/datahold/base/BaseDataList.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import sys
+from abc import abstractmethod
+from collections.abc import Hashable, Iterable, Iterator, Sequence
+from typing import Any, Self, SupportsIndex, TypeVar, cast, overload
+
+import setdoc
+
+from .BaseDataCollection import BaseDataCollection
+
+__all__ = ["BaseDataList"]
+
+Item = TypeVar("Item", covariant=True)
+Item_ = TypeVar("Item_")
+
+
+class BaseDataList(BaseDataCollection[Item], Sequence[Item]):
+    __slots__ = ()
+
+    @setdoc.basic
+    def __add__(self: Self, other: Iterable[Item], /) -> Self:
+        return type(self)(self.data + tuple(other))
+
+    @overload
+    @setdoc.basic
+    def __getitem__(self: Self, index: SupportsIndex, /) -> Item: ...
+
+    @overload
+    @setdoc.basic
+    def __getitem__(self: Self, index: slice, /) -> Self: ...
+
+    @setdoc.basic
+    def __getitem__(
+        self: Self, index: SupportsIndex | slice, /
+    ) -> Item | Self:
+        if isinstance(index, SupportsIndex):
+            return self.data[index]
+        else:
+            return type(self)(self.data[index])
+
+    @abstractmethod
+    @setdoc.basic
+    def __init__(self: Self, data: Iterable[Item] = (), /) -> None: ...
+
+    @setdoc.basic
+    def __mul__(self: Self, other: SupportsIndex, /) -> Self:
+        return type(self)(self.data * other)
+
+    @setdoc.basic
+    def __repr__(self: Self, /) -> str:
+        return f"{type(self).__name__}({list(self.data)})"
+
+    @setdoc.basic
+    def __reversed__(self: Self, /) -> Iterator[Item]:
+        return reversed(self.data)
+
+    @setdoc.basic
+    def __rmul__(self: Self, other: SupportsIndex, /) -> Self:
+        return type(self)(other * self.data)
+
+    @setdoc.setdoc(list.count.__doc__)
+    def count(self: Self, value: Hashable, /) -> int:
+        return self.data.count(cast(Any, value))
+
+    @property
+    @abstractmethod
+    def data(self: Self) -> tuple[Item, ...]: ...
+
+    @setdoc.setdoc(list.index.__doc__)
+    def index(
+        self: Self,
+        value: Hashable,
+        start: SupportsIndex = 0,
+        end: SupportsIndex = sys.maxsize,
+        /,
+    ) -> int:
+        return self.data.index(cast(Any, value), start, end)

{datahold-3.0.33 → datahold-3.0.34.dev0}/src/datahold/base/BaseDataObject.py

@@ -1,4 +1,5 @@
 from abc import ABCMeta, abstractmethod
+from collections.abc import Hashable
 from typing import Any, Self
 
 import setdoc
@@ -19,16 +20,20 @@ class BaseDataObject(metaclass=ABCMeta):
 
     @setdoc.basic
     def __ge__(self: Self, other: Any, /) -> Any:
-        if isinstance(other, BaseDataObject):
-            return self.data.__ge__(other.data)
-        else:
+        if not isinstance(other, BaseDataObject):
+            return NotImplemented
+        try:
+            return self.data.__ge__(other.data)  # type: ignore[operator]
+        except Exception:
             return NotImplemented
 
     @setdoc.basic
     def __gt__(self: Self, other: Any, /) -> Any:
-        if isinstance(other, BaseDataObject):
-            return self.data.__gt__(other.data)
-        else:
+        if not isinstance(other, BaseDataObject):
+            return NotImplemented
+        try:
+            return self.data.__gt__(other.data)  # type: ignore[operator]
+        except Exception:
             return NotImplemented
 
     @abstractmethod
@@ -37,16 +42,20 @@ class BaseDataObject(metaclass=ABCMeta):
 
     @setdoc.basic
     def __le__(self: Self, other: Any, /) -> Any:
-        if isinstance(other, BaseDataObject):
-            return self.data.__le__(other.data)
-        else:
+        if not isinstance(other, BaseDataObject):
+            return NotImplemented
+        try:
+            return self.data.__le__(other.data)  # type: ignore[operator]
+        except Exception:
             return NotImplemented
 
     @setdoc.basic
     def __lt__(self: Self, other: Any, /) -> Any:
-        if isinstance(other, BaseDataObject):
-            return self.data.__lt__(other.data)
-        else:
+        if not isinstance(other, BaseDataObject):
+            return NotImplemented
+        try:
+            return self.data.__lt__(other.data)  # type: ignore[operator]
+        except Exception:
             return NotImplemented
 
     @setdoc.basic
@@ -58,4 +67,4 @@ class BaseDataObject(metaclass=ABCMeta):
 
     @property
     @abstractmethod
-    def data(self: Self) -> Any: ...
+    def data(self: Self) -> Hashable: ...

datahold-3.0.34.dev0/src/datahold/base/BaseDataSet.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from collections.abc import Hashable, Iterable, Set
+from typing import Generic, Self, TypeVar
+
+import setdoc
+
+from .BaseDataCollection import BaseDataCollection
+
+__all__ = ["BaseDataSet"]
+
+Item = TypeVar("Item", bound=Hashable, covariant=True)
+
+
+class BaseDataSet(BaseDataCollection[Item], Generic[Item]):
+    __slots__ = ()
+
+    @setdoc.basic
+    def __and__(
+        self: Self,
+        other: BaseDataSet[Hashable],
+        /,
+    ) -> Self:
+        return type(self)(self.data & other.data)
+
+    @abstractmethod
+    @setdoc.basic
+    def __init__(self: Self, data: Iterable[Item] = (), /) -> None: ...
+
+    @setdoc.basic
+    def __or__(
+        self: Self,
+        other: BaseDataSet[Item],
+        /,
+    ) -> Self:
+        return type(self)(self.data | other.data)
+
+    @setdoc.setdoc(set.__repr__.__doc__)
+    def __repr__(self: Self, /) -> str:
+        return f"{type(self).__name__}({set(self.data)})"
+
+    @setdoc.basic
+    def __sub__(
+        self: Self,
+        other: BaseDataSet[Hashable],
+        /,
+    ) -> Self:
+        return type(self)(self.data - other.data)
+
+    @setdoc.basic
+    def __xor__(
+        self: Self,
+        other: BaseDataSet[Item],
+        /,
+    ) -> Self:
+        return type(self)(self.data ^ other.data)
+
+    @property
+    @abstractmethod
+    def data(self: Self) -> frozenset[Item]: ...
+
+    @setdoc.setdoc(set.difference.__doc__)
+    def difference(self: Self, /, *others: Iterable[Hashable]) -> Self:
+        return type(self)(self.data.difference(*others))
+
+    @setdoc.setdoc(set.intersection.__doc__)
+    def intersection(self: Self, /, *others: Iterable[Hashable]) -> Self:
+        return type(self)(self.data.intersection(*others))
+
+    @setdoc.setdoc(set.isdisjoint.__doc__)
+    def isdisjoint(self: Self, other: Iterable[Hashable], /) -> bool:
+        return self.data.isdisjoint(other)
+
+    @setdoc.setdoc(set.issubset.__doc__)
+    def issubset(self: Self, other: Iterable[Hashable], /) -> bool:
+        return self.data.issubset(other)
+
+    @setdoc.setdoc(set.issuperset.__doc__)
+    def issuperset(self: Self, other: Iterable[Hashable], /) -> bool:
+        return self.data.issuperset(other)
+
+    @setdoc.setdoc(set.symmetric_difference.__doc__)
+    def symmetric_difference(
+        self: Self,
+        other: Iterable[Item],
+        /,
+    ) -> Self:
+        return type(self)(self.data.symmetric_difference(other))
+
+    @setdoc.setdoc(set.union.__doc__)
+    def union(self: Self, /, *others: Iterable[Item]) -> Self:
+        return type(self)(self.data.union(*others))
+
+
+Set.register(BaseDataSet)  # type: ignore[type-abstract]

{datahold-3.0.33 → datahold-3.0.34.dev0}/src/datahold/base/BaseHoldDict.py

@@ -1,12 +1,12 @@
-import typing
+from typing import TypeVar
 
 from .BaseDataDict import BaseDataDict
 from .BaseHoldObject import BaseHoldObject
 
 __all__ = ["BaseHoldDict"]
 
-Key = typing.TypeVar("Key", covariant=True)
-Value = typing.TypeVar("Value", covariant=True)
+Key = TypeVar("Key", covariant=True)
+Value = TypeVar("Value", covariant=True)
 
 
 class BaseHoldDict(BaseHoldObject, BaseDataDict[Key, Value]):

{datahold-3.0.33 → datahold-3.0.34.dev0}/src/datahold/base/BaseHoldList.py

@@ -1,11 +1,11 @@
-import typing
+from typing import TypeVar
 
 from .BaseDataList import BaseDataList
 from .BaseHoldObject import BaseHoldObject
 
 __all__ = ["BaseHoldList"]
 
-Item = typing.TypeVar("Item", covariant=True)
+Item = TypeVar("Item", covariant=True)
 
 
 class BaseHoldList(BaseHoldObject, BaseDataList[Item]):

datahold-3.0.34.dev0/src/datahold/core/DataDict.py

@@ -0,0 +1,146 @@
+from abc import abstractmethod
+from collections.abc import Hashable, Iterable, MutableMapping
+from typing import Any, Final, Optional, Self, TypeVar, overload
+
+import setdoc
+from frozendict import frozendict
+
+from ..base.BaseDataDict import BaseDataDict
+from ..typing.SupportsKeysAndGetitem import SupportsKeysAndGetitem
+from .DataObject import DataObject
+
+__all__ = ["DataDict"]
+
+Key = TypeVar("Key", bound=Hashable)
+Value = TypeVar("Value")
+Value_ = TypeVar("Value_")
+
+MISSING: Final[object] = object()
+
+
+class DataDict(
+    DataObject,
+    BaseDataDict[Key, Value],
+    MutableMapping[Key | str, Optional[Value]],
+):
+    __slots__ = ()
+
+    @setdoc.basic
+    def __delitem__(self: Self, key: Hashable, /) -> None:
+        self.data = self.data.delete(key)  # type: ignore[arg-type]
+
+    @setdoc.basic
+    def __init__(
+        self: Self,
+        data: (
+            SupportsKeysAndGetitem[Key | str, Optional[Value]]
+            | Iterable[tuple[Key | str, Optional[Value]]]
+        ) = (),
+        /,
+        **kwargs: Optional[Value],
+    ) -> None:
+        self.data = frozendict(data, **kwargs)  # type: ignore[arg-type]
+
+    @setdoc.basic
+    def __ior__(
+        self: Self,
+        other: BaseDataDict[Key, Value],
+        /,
+    ) -> Self:
+        self.data |= other.data
+        return self
+
+    @setdoc.setdoc(dict.__setitem__.__doc__)
+    def __setitem__(
+        self: Self,
+        key: Key | str,
+        value: Optional[Value],
+        /,
+    ) -> None:
+        self.data = self.data.set(key, value)
+
+    @setdoc.setdoc(dict.clear.__doc__)
+    def clear(self: Self, /) -> None:
+        self.data = frozendict()
+
+    @property
+    @abstractmethod
+    def data(self: Self) -> frozendict[Key | str, Optional[Value]]: ...
+
+    @data.setter
+    @abstractmethod
+    def data(
+        self: Self,
+        value: (
+            SupportsKeysAndGetitem[Key | str, Optional[Value]]
+            | Iterable[tuple[Key | str, Optional[Value]]]
+        ),
+    ) -> None: ...
+
+    @overload
+    @setdoc.setdoc(dict.pop.__doc__)
+    def pop(self: Self, key: Hashable, /) -> Optional[Value]: ...
+
+    @overload
+    @setdoc.setdoc(dict.pop.__doc__)
+    def pop(
+        self: Self,
+        key: Hashable,
+        default: Value_,
+        /,
+    ) -> Optional[Value | Value_]: ...
+
+    @setdoc.setdoc(dict.pop.__doc__)
+    def pop(
+        self: Self,
+        key: Hashable,
+        default: Any = MISSING,
+        /,
+    ) -> Optional[Value | Value_]:
+        ans: Optional[Value | Value_]
+        data: dict[Key | str, Optional[Value]]
+        data = dict(self.data)
+        if default is MISSING:
+            ans = data.pop(key)  # type: ignore[arg-type]
+        else:
+            ans = data.pop(key, default)  # type: ignore[arg-type]
+        self.data = frozendict(data)
+        return ans
+
+    @setdoc.setdoc(dict.popitem.__doc__)
+    def popitem(self: Self, /) -> tuple[Key | str, Optional[Value]]:
+        ans: tuple[Key | str, Optional[Value]]
+        data: dict[Key | str, Optional[Value]]
+        data = dict(self.data)
+        ans = data.popitem()
+        self.data = frozendict(data)
+        return ans
+
+    @setdoc.setdoc(dict.setdefault.__doc__)
+    def setdefault(
+        self: Self,
+        key: Key | str,
+        default: Optional[Value] = None,
+        /,
+    ) -> Optional[Value]:
+        ans: Optional[Value]
+        data: dict[Key | str, Optional[Value]]
+        data = dict(self.data)
+        ans = data.setdefault(key, default)
+        self.data = frozendict(data)
+        return ans
+
+    @setdoc.setdoc(dict.update.__doc__)
+    def update(
+        self: Self,
+        other: (
+            SupportsKeysAndGetitem[Key | str, Optional[Value]]
+            | Iterable[tuple[Key | str, Optional[Value]]]
+        ) = (),
+        /,
+        **kwargs: Optional[Value],
+    ) -> None:
+        data: dict[Key | str, Optional[Value]]
+        data = dict(self.data)
+        data.update(other, **kwargs)
+        self.data = frozendict(data)

datahold-3.0.34.dev0/src/datahold/core/DataList.py

@@ -0,0 +1,117 @@
+from collections.abc import Iterable, MutableSequence
+from typing import Any, Optional, Self, SupportsIndex, TypeVar, overload
+
+import setdoc
+
+from ..base.BaseDataList import BaseDataList
+from .DataObject import DataObject
+
+__all__ = ["DataList"]
+
+Item = TypeVar("Item")
+
+
+class DataList(
+    DataObject,
+    BaseDataList[Item],
+    MutableSequence[Item],
+):
+    __slots__ = ()
+
+    @setdoc.basic
+    def __delitem__(self: Self, other: SupportsIndex | slice, /) -> None:
+        data: list[Item]
+        data = list(self.data)
+        del data[other]
+        self.data = tuple(data)
+
+    @setdoc.basic
+    def __iadd__(self: Self, other: Iterable[Item], /) -> Self:
+        self.data += tuple(other)
+        return self
+
+    @setdoc.basic
+    def __imul__(self: Self, other: SupportsIndex, /) -> Self:
+        self.data *= other
+        return self
+
+    @setdoc.basic
+    def __init__(
+        self: Self,
+        data: Iterable[Item] = (),
+        /,
+    ) -> None:
+        self.data = tuple(data)
+
+    @overload
+    @setdoc.basic
+    def __setitem__(
+        self: Self, key: SupportsIndex, value: Item, /
+    ) -> None: ...
+
+    @overload
+    @setdoc.basic
+    def __setitem__(
+        self: Self,
+        key: slice,
+        value: Iterable[Item],
+        /,
+    ) -> None: ...
+
+    @setdoc.basic
+    def __setitem__(
+        self: Self,
+        key: SupportsIndex | slice,
+        value: Item | Iterable[Item],
+        /,
+    ) -> None:
+        data: Any
+        data = list(self.data)
+        data[key] = value
+        self.data = tuple(data)
+
+    @setdoc.setdoc(list.append.__doc__)
+    def append(self: Self, value: Item, /) -> None:
+        self.data += (value,)
+
+    @setdoc.setdoc(list.clear.__doc__)
+    def clear(self: Self, /) -> None:
+        self.data = ()
+
+    @setdoc.setdoc(list.extend.__doc__)
+    def extend(self: Self, iterable: Iterable[Item], /) -> None:
+        self.data += tuple(iterable)
+
+    @setdoc.setdoc(list.insert.__doc__)
+    def insert(self: Self, index: SupportsIndex, object: Item, /) -> None:
+        data: list[Item]
+        data = list(self.data)
+        data.insert(index, object)
+        self.data = tuple(data)
+
+    @setdoc.setdoc(list.pop.__doc__)
+    def pop(self: Self, index: SupportsIndex = -1, /) -> Item:
+        ans: Item
+        data: list[Item]
+        data = list(self.data)
+        ans = data.pop(index)
+        self.data = tuple(data)
+        return ans
+
+    @setdoc.setdoc(list.remove.__doc__)
+    def remove(self: Self, value: object) -> None:
+        data: list[Item]
+        data = list(self.data)
+        data.remove(value)  # type: ignore[arg-type]
+        self.data = tuple(data)
+
+    @setdoc.setdoc(list.reverse.__doc__)
+    def reverse(self: Self) -> None:
+        self.data = tuple(self.data[::-1])
+
+    @setdoc.setdoc(list.sort.__doc__)
+    def sort(self: Self, key: Any = None, reverse: bool = False) -> None:
+        data: list[Item]
+        data = list(self.data)
+        data.sort(key=key, reverse=reverse)
+        self.data = tuple(data)