datahold 4.0.0.dev1__py3-none-any.whl → 4.0.0.dev2__py3-none-any.whl

datahold/__init__.py

@@ -1,24 +1,45 @@
-from datahold.core.BaseDataDict import BaseDataDict
-from datahold.core.BaseDataList import BaseDataList
-from datahold.core.BaseDataObject import BaseDataObject
-from datahold.core.BaseDataSet import BaseDataSet
-from datahold.core.BaseHoldDict import BaseHoldDict
-from datahold.core.BaseHoldList import BaseHoldList
-from datahold.core.BaseHoldObject import BaseHoldObject
-from datahold.core.BaseHoldSet import BaseHoldSet
+"""Provide __init__."""
+
+__all__ = [
+    "BaseDataAbstractSet",
+    "BaseDataCollection",
+    "BaseDataDict",
+    "BaseDataList",
+    "BaseDataMapping",
+    "BaseDataSequence",
+    "BaseDataSet",
+    "BaseHoldCollection",
+    "DataDict",
+    "DataList",
+    "DataSet",
+    "FrozenDataDict",
+    "FrozenDataList",
+    "FrozenDataSet",
+    "FrozenHoldDict",
+    "FrozenHoldList",
+    "FrozenHoldSet",
+    "HoldDict",
+    "HoldList",
+    "HoldSet",
+]
+
+from datahold.base.BaseDataAbstractSet import BaseDataAbstractSet
+from datahold.base.BaseDataCollection import BaseDataCollection
+from datahold.base.BaseDataDict import BaseDataDict
+from datahold.base.BaseDataList import BaseDataList
+from datahold.base.BaseDataMapping import BaseDataMapping
+from datahold.base.BaseDataSequence import BaseDataSequence
+from datahold.base.BaseDataSet import BaseDataSet
+from datahold.base.BaseHoldCollection import BaseHoldCollection
 from datahold.core.DataDict import DataDict
 from datahold.core.DataList import DataList
-from datahold.core.DataObject import DataObject
 from datahold.core.DataSet import DataSet
-from datahold.core.FrozenDataDict import FrozenDataDict
-from datahold.core.FrozenDataList import FrozenDataList
-from datahold.core.FrozenDataObject import FrozenDataObject
-from datahold.core.FrozenDataSet import FrozenDataSet
-from datahold.core.FrozenHoldDict import FrozenHoldDict
-from datahold.core.FrozenHoldList import FrozenHoldList
-from datahold.core.FrozenHoldObject import FrozenHoldObject
-from datahold.core.FrozenHoldSet import FrozenHoldSet
 from datahold.core.HoldDict import HoldDict
 from datahold.core.HoldList import HoldList
-from datahold.core.HoldObject import HoldObject
 from datahold.core.HoldSet import HoldSet
+from datahold.frozen.FrozenDataDict import FrozenDataDict
+from datahold.frozen.FrozenDataList import FrozenDataList
+from datahold.frozen.FrozenDataSet import FrozenDataSet
+from datahold.frozen.FrozenHoldDict import FrozenHoldDict
+from datahold.frozen.FrozenHoldList import FrozenHoldList
+from datahold.frozen.FrozenHoldSet import FrozenHoldSet

datahold/_utils/Missing.py

@@ -0,0 +1,9 @@
+"""Provide Missing."""
+
+__all__: list[str] = []
+
+import enum
+
+
+class Missing(enum.Enum):
+    missing = None

datahold/_utils/Slice.py

@@ -0,0 +1,4 @@
+__all__: list[str] = ["Slice"]
+from typing import Optional
+
+type Slice[Index] = slice[Optional[Index], Optional[Index], Optional[Index]]

datahold/_utils/__init__.py

@@ -0,0 +1,3 @@
+"""Provide _utils."""
+
+__all__: list[str] = []

datahold/base/BaseDataAbstractSet.py

@@ -0,0 +1,16 @@
+"""Provide BaseDataAbstractSet."""
+
+__all__: list[str] = ["BaseDataAbstractSet"]
+
+from collections import abc
+
+from .BaseDataCollection import BaseDataCollection
+
+
+class BaseDataAbstractSet[Item](
+    BaseDataCollection[Item],
+    abc.Set[Item],
+):
+    """Provide an easy abc for a custom (abstract) set."""
+
+    __slots__ = ()

datahold/base/BaseDataCollection.py

@@ -0,0 +1,49 @@
+"""Provide BaseDataCollection."""
+
+__all__: list[str] = ["BaseDataCollection"]
+
+from abc import ABCMeta, abstractmethod
+from collections import abc
+from typing import Never, Protocol, Self
+
+import setdoc
+
+
+class BaseDataCollection[Item](
+    abc.Sized,
+    abc.Iterable[Item],
+    abc.Container[object],
+    metaclass=ABCMeta,
+):
+    """Provide an easy abc for a custom collection."""
+
+    __slots__ = ()
+
+    @setdoc.basic
+    class Data[DataItem](
+        abc.Sized,
+        abc.Iterable[DataItem],
+        abc.Container[Never],
+        abc.Hashable,
+        Protocol,
+    ):
+        """Provide collection data protocol."""
+
+    @setdoc.basic
+    def __contains__(self: Self, other: object, /) -> bool:
+        try:
+            return other in self.__fget__()
+        except TypeError:
+            return other in (x for x in self.__fget__())  # type: ignore[operator]
+
+    @setdoc.basic
+    def __iter__(self: Self, /) -> abc.Iterator[Item]:
+        return iter(self.__fget__())
+
+    @setdoc.basic
+    def __len__(self: Self, /) -> int:
+        return len(self.__fget__())
+
+    @abstractmethod
+    @setdoc.basic
+    def __fget__(self: Self) -> Data[Item]: ...

datahold/base/BaseDataDict.py

@@ -0,0 +1,76 @@
+"""Provide BaseDataDict."""
+
+from __future__ import annotations
+
+__all__: list[str] = ["BaseDataDict"]
+
+from abc import abstractmethod
+from collections import abc
+from typing import Never, Optional, Protocol, Self
+
+import setdoc
+from frozendict import frozendict
+
+from .BaseDataMapping import BaseDataMapping
+
+
+class SupportsKeysAndGetitem[Key, Value](Protocol):
+
+    @setdoc.basic
+    def __getitem__(self: Self, key: Never, /) -> Value: ...
+
+    @setdoc.basic
+    def keys(self: Self) -> abc.Iterable[Key]: ...
+
+
+class BaseDataDict[Key: abc.Hashable, Value](
+    BaseDataMapping[Key | str, Optional[Value]],
+):
+    """Provide an easy abc for custom dict-like."""
+
+    __slots__ = ()
+
+    type Data[DataKey, DataValue] = frozendict[
+        DataKey | str, Optional[DataValue]
+    ]
+    type Init[DataKey, DataValue] = (
+        SupportsKeysAndGetitem[DataKey | str, Optional[DataValue]]
+        | abc.Iterable[tuple[DataKey | str, Optional[DataValue]]]
+    )
+
+    @abstractmethod
+    @setdoc.basic
+    def __init__(
+        self: Self,
+        data: Init[Key, Value] = (),
+        /,
+        **kwargs: Optional[Value],
+    ) -> None: ...
+
+    @setdoc.basic
+    def __or__(
+        self: Self,
+        other: BaseDataDict[Key, Value],
+        /,
+    ) -> Self:
+        return type(self)(self.__fget__() | other.__fget__())
+
+    @setdoc.basic
+    def __repr__(self: Self, /) -> str:
+        return f"{type(self).__name__}({dict(self)!r})"
+
+    # __ror__ is unnecessary because of how __or__ is defined
+
+    @abstractmethod
+    @setdoc.basic
+    def __fget__(self: Self) -> Data[Key, Value]: ...
+
+    @classmethod
+    @setdoc.basic
+    def fromkeys(
+        cls: type[Self],
+        iterable: abc.Iterable[Key | str],
+        value: Optional[Value] = None,
+        /,
+    ) -> Self:
+        return cls(dict.fromkeys(iterable, value))

datahold/base/BaseDataList.py

@@ -0,0 +1,109 @@
+"""Provide BaseDataList."""
+
+from __future__ import annotations
+
+__all__: list[str] = ["BaseDataList"]
+
+from abc import abstractmethod
+from collections import abc
+from types import NotImplementedType
+from typing import Self, SupportsIndex, overload
+
+import setdoc
+
+from .._utils.Slice import Slice
+from .BaseDataSequence import BaseDataSequence
+
+
+class BaseDataList[Item](BaseDataSequence[Item]):
+    """Provide an easy abc for custom list-like."""
+
+    __slots__ = ()
+
+    type Data[DataItem] = tuple[DataItem, ...]
+    type Init[InitItem] = abc.Iterable[InitItem]
+
+    @setdoc.basic
+    def __add__(self: Self, other: BaseDataList[Item], /) -> Self:
+        # list.__add__ reveals Overload(
+        #     def [_T] (list[_T], list[_T]) -> list[_T],
+        #     def [_T, _S] (list[_T], list[_S]) -> list[_S | _T],
+        # )
+        # tuple.__add__ reveals Overload(
+        #     def [_T_co] (tuple[_T_co, ...], tuple[_T_co, ...]) -> tuple[_T_co, ...],
+        #     def [_T_co, _T] (tuple[_T_co, ...], tuple[_T, ...]) -> tuple[_T_co | _T, ...],
+        # )
+        if isinstance(other, BaseDataList):
+            return type(self)(self.__fget__() + other.__fget__())
+        else:
+            return NotImplemented
+
+    @setdoc.basic
+    def __eq__(self: Self, other: object, /) -> NotImplementedType | bool:
+        if isinstance(other, BaseDataList):
+            return self.__fget__() == other.__fget__()
+        else:
+            return NotImplemented
+
+    @setdoc.basic
+    def __ge__(self: Self, other: object, /) -> NotImplementedType | bool:
+        if isinstance(other, BaseDataList):
+            return self.__fget__() >= other.__fget__()
+        else:
+            return NotImplemented
+
+    @overload
+    @setdoc.basic
+    def __getitem__(self: Self, index: SupportsIndex, /) -> Item: ...
+
+    @overload
+    @setdoc.basic
+    def __getitem__(self: Self, index: Slice[SupportsIndex], /) -> Self: ...
+
+    @setdoc.basic
+    def __getitem__(
+        self: Self, index: SupportsIndex | Slice[SupportsIndex], /
+    ) -> Item | Self:
+        if isinstance(index, SupportsIndex):
+            return self.__fget__()[index]
+        else:
+            return type(self)(self.__fget__()[index])
+
+    @setdoc.basic
+    def __gt__(self: Self, other: object, /) -> NotImplementedType | bool:
+        if isinstance(other, BaseDataList):
+            return self.__fget__() > other.__fget__()
+        else:
+            return NotImplemented
+
+    @abstractmethod
+    @setdoc.basic
+    def __init__(self: Self, data: Init[Item] = (), /) -> None: ...
+
+    @setdoc.basic
+    def __le__(self: Self, other: object, /) -> NotImplementedType | bool:
+        if isinstance(other, BaseDataList):
+            return self.__fget__() <= other.__fget__()
+        else:
+            return NotImplemented
+
+    @setdoc.basic
+    def __lt__(self: Self, other: object, /) -> NotImplementedType | bool:
+        if isinstance(other, BaseDataList):
+            return self.__fget__() < other.__fget__()
+        else:
+            return NotImplemented
+
+    @setdoc.basic
+    def __mul__(self: Self, other: SupportsIndex, /) -> Self:
+        return type(self)(self.__fget__() * other)
+
+    @setdoc.basic
+    def __repr__(self: Self, /) -> str:
+        return f"{type(self).__name__}({list(self.__fget__())!r})"
+
+    __rmul__ = __mul__
+
+    @abstractmethod
+    @setdoc.basic
+    def __fget__(self: Self) -> Data[Item]: ...

datahold/base/BaseDataMapping.py

@@ -0,0 +1,41 @@
+"""Provide BaseDataMapping."""
+
+from __future__ import annotations
+
+__all__: list[str] = ["BaseDataMapping"]
+
+from abc import abstractmethod
+from collections import abc
+from typing import Never, Protocol, Self
+
+import setdoc
+
+from .BaseDataCollection import BaseDataCollection
+
+
+class BaseDataMapping[Key, Value](
+    BaseDataCollection[Key], abc.Mapping[Key, Value]
+):
+    """Provide an easy abc for a custom mapping."""
+
+    __slots__ = ()
+
+    @setdoc.basic
+    class Data[DataKey, DataValue](
+        BaseDataCollection.Data[DataKey],
+        Protocol,
+    ):
+        @setdoc.basic
+        def __getitem__(self: Self, key: Never, /) -> DataValue:
+            pass
+
+    @setdoc.basic
+    def __getitem__(self: Self, key: object, /) -> Value:
+        try:
+            return self.__fget__()[key]  # type: ignore[index]
+        except TypeError:
+            raise KeyError(key) from None
+
+    @abstractmethod
+    @setdoc.basic
+    def __fget__(self: Self) -> Data[Key, Value]: ...

datahold/base/BaseDataSequence.py

@@ -0,0 +1,57 @@
+"""Provide BaseDataSequence."""
+
+__all__: list[str] = ["BaseDataSequence"]
+
+from abc import abstractmethod
+from collections import abc
+from typing import Protocol, Self, overload
+
+import setdoc
+
+from .._utils.Slice import Slice
+from .BaseDataCollection import BaseDataCollection
+
+
+class BaseDataSequence[Item](
+    BaseDataCollection[Item],
+    abc.Sequence[Item],
+):
+    """Provide an easy abc for a custom sequence."""
+
+    __slots__ = ()
+
+    @setdoc.basic
+    class Data[DataItem](
+        BaseDataCollection.Data[DataItem],
+        Protocol,
+    ):
+        """Provide sequence data protocol."""
+
+        @overload
+        @setdoc.basic
+        def __getitem__(self: Self, key: int, /) -> DataItem: ...
+        @overload
+        @setdoc.basic
+        def __getitem__(
+            self: Self, key: Slice[int], /
+        ) -> abc.Sequence[DataItem]: ...
+        @setdoc.basic
+        def __getitem__(
+            self: Self, key: int | Slice[int], /
+        ) -> DataItem | abc.Sequence[DataItem]: ...
+
+    @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]:
+        return self.__fget__()[key]
+
+    @abstractmethod
+    @setdoc.basic
+    def __fget__(self: Self) -> Data[Item]: ...

datahold/base/BaseDataSet.py

@@ -0,0 +1,64 @@
+"""Provide BaseDataSet."""
+
+from __future__ import annotations
+
+__all__: list[str] = ["BaseDataSet"]
+
+from abc import abstractmethod
+from collections import abc
+from typing import Self
+
+import setdoc
+
+from .BaseDataAbstractSet import BaseDataAbstractSet
+
+
+class BaseDataSet[Item: abc.Hashable](BaseDataAbstractSet[Item]):
+    """Provide an easy abc for custom set-like."""
+
+    __slots__ = ()
+
+    type Data[DataItem] = frozenset[DataItem]
+    type Init[InitItem] = abc.Iterable[InitItem]
+
+    @abstractmethod
+    @setdoc.basic
+    def __init__(self: Self, data: Init[Item] = (), /) -> None: ...
+
+    @setdoc.basic
+    def __repr__(self: Self, /) -> str:
+        return f"{type(self).__name__}({set(self.__fget__())!r})"
+
+    @abstractmethod
+    @setdoc.basic
+    def __fget__(self: Self) -> frozenset[Item]: ...
+
+    @setdoc.basic
+    def difference(self: Self, /, *others: abc.Iterable[abc.Hashable]) -> Self:
+        return type(self)(self.__fget__().difference(*others))
+
+    @setdoc.basic
+    def intersection(
+        self: Self, /, *others: abc.Iterable[abc.Hashable]
+    ) -> Self:
+        return type(self)(self.__fget__().intersection(*others))
+
+    @setdoc.basic
+    def issubset(self: Self, other: abc.Iterable[abc.Hashable], /) -> bool:
+        return self.__fget__().issubset(other)
+
+    @setdoc.basic
+    def issuperset(self: Self, other: abc.Iterable[abc.Hashable], /) -> bool:
+        return self.__fget__().issuperset(other)
+
+    @setdoc.basic
+    def symmetric_difference(
+        self: Self,
+        other: abc.Iterable[Item],
+        /,
+    ) -> Self:
+        return type(self)(self.__fget__().symmetric_difference(other))
+
+    @setdoc.basic
+    def union(self: Self, /, *others: abc.Iterable[Item]) -> Self:
+        return type(self)(self.__fget__().union(*others))

datahold/base/BaseHoldCollection.py

@@ -0,0 +1,11 @@
+"""Provide BaseHoldCollection."""
+
+__all__: list[str] = ["BaseHoldCollection"]
+
+from .BaseDataCollection import BaseDataCollection
+
+
+class BaseHoldCollection[Item](BaseDataCollection[Item]):
+    """Provide abc for usable classes with slots."""
+
+    __slots__ = ("_data",)

datahold/base/__init__.py

@@ -0,0 +1,3 @@
+"""Provide base holder types."""
+
+__all__: list[str] = []

datahold/core/DataDict.py

@@ -1,106 +1,67 @@
-import collections
-from types import MappingProxyType
-from typing import *
+"""Provide DataDict."""
 
-import setdoc
+from __future__ import annotations
 
-from datahold._utils.wrapping import wraps
+__all__: list[str] = ["DataDict"]
 
-from .BaseDataDict import BaseDataDict
-from .DataObject import DataObject
+from abc import abstractmethod
+from collections import abc
+from typing import Optional, Self
 
-__all__ = ["DataDict"]
+import setdoc
+from frozendict import frozendict
 
-Key = TypeVar("Key")
-Value = TypeVar("Value")
+from ..base.BaseDataDict import BaseDataDict
 
 
-class DataDict(
-    DataObject, BaseDataDict[Key, Value], collections.abc.MutableMapping[Key, Value]
+class DataDict[Key: abc.Hashable, Value](
+    BaseDataDict[Key, Value],
+    abc.MutableMapping[Key | str, Optional[Value]],
 ):
-    data: MappingProxyType[Key, Value]
-    __slots__ = ()
+    """Provide easy abc for custom mutable dict-like."""
 
-    @wraps(dict[Key, Value])
-    def __delitem__(self: Self, *args: Any, **kwargs: Any) -> Any:
-        "This doc string is overwritten together with the signature to match the original as closely as possible."
-        ans: Any
-        data: dict[Key, Value]
-        data = dict[Key, Value](self.data)
-        ans = data.__delitem__(*args, **kwargs)
-        self.data = MappingProxyType[Key, Value](data)
-        return ans
+    __slots__ = ()
 
     @setdoc.basic
-    def __init__(self: Self, data: Any = (), /, **kwargs: Any) -> None:
-        self.data = MappingProxyType[Key, Value](dict[Key, Value](data, **kwargs))
-
-    @wraps(dict[Key, Value])
-    def __ior__(self: Self, *args: Any, **kwargs: Any) -> Any:
-        "This doc string is overwritten together with the signature to match the original as closely as possible."
-        ans: Any
-        data: dict[Key, Value]
-        data = dict[Key, Value](self.data)
-        ans = data.__ior__(*args, **kwargs)
-        self.data = MappingProxyType[Key, Value](data)
-        return ans
+    def __delitem__(self: Self, key: Key | str, /) -> None:
+        self.__fset__(self.__fget__().delete(key))
 
-    @wraps(dict[Key, Value])
-    def __setitem__(self: Self, *args: Any, **kwargs: Any) -> Any:
-        "This doc string is overwritten together with the signature to match the original as closely as possible."
-        ans: Any
-        data: dict[Key, Value]
-        data = dict[Key, Value](self.data)
-        ans = data.__setitem__(*args, **kwargs)
-        self.data = MappingProxyType[Key, Value](data)
-        return ans
+    @abstractmethod
+    @setdoc.basic
+    def __fget__(self: Self) -> DataDict.Data[Key, Value]: ...
 
-    @wraps(dict[Key, Value])
-    def clear(self: Self, *args: Any, **kwargs: Any) -> Any:
-        "This doc string is overwritten together with the signature to match the original as closely as possible."
-        ans: Any
-        data: dict[Key, Value]
-        data = dict[Key, Value](self.data)
-        ans = data.clear(*args, **kwargs)
-        self.data = MappingProxyType[Key, Value](data)
-        return ans
+    @abstractmethod
+    @setdoc.basic
+    def __fset__(self: Self, data: DataDict.Data[Key, Value], /) -> None: ...
 
-    @wraps(dict[Key, Value])
-    def pop(self: Self, *args: Any, **kwargs: Any) -> Any:
-        "This doc string is overwritten together with the signature to match the original as closely as possible."
-        ans: Any
-        data: dict[Key, Value]
-        data = dict[Key, Value](self.data)
-        ans = data.pop(*args, **kwargs)
-        self.data = MappingProxyType[Key, Value](data)
-        return ans
+    @setdoc.basic
+    def __init__(
+        self: Self,
+        data: BaseDataDict.Init[Key, Value] = (),
+        /,
+        **kwargs: Optional[Value],
+    ) -> None:
+        self.__fset__(frozendict(data, **kwargs))  # type: ignore[arg-type]
 
-    @wraps(dict[Key, Value])
-    def popitem(self: Self, *args: Any, **kwargs: Any) -> Any:
-        "This doc string is overwritten together with the signature to match the original as closely as possible."
-        ans: Any
-        data: dict[Key, Value]
-        data = dict[Key, Value](self.data)
-        ans = data.popitem(*args, **kwargs)
-        self.data = MappingProxyType[Key, Value](data)
-        return ans
+    @setdoc.basic
+    def __ior__(
+        self: Self,
+        other: BaseDataDict[Key, Value],
+        /,
+    ) -> Self:
+        self.__fset__(self.__fget__() | other.__fget__())
+        return self
 
-    @wraps(dict[Key, Value])
-    def setdefault(self: Self, *args: Any, **kwargs: Any) -> Any:
-        "This doc string is overwritten together with the signature to match the original as closely as possible."
-        ans: Any
-        data: dict[Key, Value]
-        data = dict[Key, Value](self.data)
-        ans = data.setdefault(*args, **kwargs)
-        self.data = MappingProxyType[Key, Value](data)
-        return ans
+    @setdoc.basic
+    def __setitem__(
+        self: Self,
+        key: Key | str,
+        value: Optional[Value],
+        /,
+    ) -> None:
+        # what to do if Key includes unhashable types?
+        self.__fset__(self.__fget__().set(key, value))
 
-    @wraps(dict[Key, Value])
-    def update(self: Self, *args: Any, **kwargs: Any) -> Any:
-        "This doc string is overwritten together with the signature to match the original as closely as possible."
-        ans: Any
-        data: dict[Key, Value]
-        data = dict[Key, Value](self.data)
-        ans = data.update(*args, **kwargs)
-        self.data = MappingProxyType[Key, Value](data)
-        return ans
+    @setdoc.basic
+    def copy(self: Self) -> Self:
+        return type(self)(self)