datahold 4.0.0.dev10__tar.gz → 4.0.0.dev21__tar.gz

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

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

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

datahold-4.0.0.dev21/src/datahold/__init__.py

@@ -0,0 +1,649 @@
+"""Provide provides base classes for customized collections."""
+
+from __future__ import annotations
+
+__all__: list[str] = [
+    "Collection",
+    "FrozenListLike",
+    "FrozenListSlot",
+    "FrozenSetLike",
+    "FrozenSetSlot",
+    "ListLike",
+    "ListSlot",
+    "MutableListLike",
+    "MutableListSlot",
+    "MutableSequence",
+    "MutableSet",
+    "MutableSetLike",
+    "MutableSetSlot",
+    "Sequence",
+    "Set",
+    "SetLike",
+    "SetSlot",
+]
+
+from abc import abstractmethod
+from collections import abc
+from contextlib import contextmanager
+from types import NotImplementedType, TracebackType
+from typing import (
+    Any,
+    Never,
+    Optional,
+    Protocol,
+    Self,
+    SupportsIndex,
+    overload,
+)
+
+import setdoc
+
+### UTILS ###
+
+
+class ContextManager[Enter](Protocol):
+    """Provide context manager protocol."""
+
+    @setdoc.basic
+    def __enter__(self: Self, /) -> Enter: ...
+
+    @setdoc.basic
+    def __exit__(
+        self: Self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+        /,
+    ) -> object: ...
+
+
+type Slice[Index] = slice[Optional[Index], Optional[Index], Optional[Index]]
+
+
+### COLLECTION ###
+
+
+class Collection[Item](
+    abc.Sized,
+    abc.Iterable[Item],
+    abc.Container[object],
+):
+    """Provide abc for custom collections."""
+
+    @setdoc.basic
+    class __Frozen__[FrozenItem](
+        abc.Sized,
+        abc.Iterable[FrozenItem],
+        Protocol,
+    ):
+        @setdoc.basic
+        def __contains__(self: Self, other: Never, /) -> bool: ...
+
+    @setdoc.basic
+    def __contains__(self: Self, other: object, /) -> bool:
+        try:
+            return other in self.__frozen__()  # type: ignore[operator]
+        except TypeError:
+            return other in (x for x in self)  # type: ignore[operator]
+
+    @abstractmethod
+    @setdoc.basic
+    def __frozen__(self: Self, /) -> __Frozen__[Item]: ...
+
+    @setdoc.basic
+    def __iter__(self: Self) -> abc.Iterator[Item]:
+        return iter(self.__frozen__())
+
+    @setdoc.basic
+    def __len__(self: Self, /) -> int:
+        return len(self.__frozen__())
+
+
+### SET ###
+
+
+class Set[Item: abc.Hashable](Collection[Item], abc.Set[Item]):
+    """Provide abc for custom set."""
+
+    __slots__ = ()
+
+
+class MutableSet[Item: abc.Hashable](Set[Item], abc.MutableSet[Item]):
+    """Provide abc for custom mutable set."""
+
+    __slots__ = ()
+
+    @setdoc.basic
+    class __Mutable__[MutableItem: abc.Hashable](Protocol):
+        @setdoc.basic
+        def add(self: Self, item: MutableItem, /) -> object: ...
+        @setdoc.basic
+        def discard(self: Self, item: abc.Hashable, /) -> object: ...
+    @abstractmethod
+    @setdoc.basic
+    def __mutate__(self: Self) -> ContextManager[__Mutable__[Item]]: ...
+    @setdoc.basic
+    def add(self: Self, item: Item, /) -> None:
+        with self.__mutate__() as mutable:
+            mutable.add(item)
+
+    @setdoc.basic
+    def discard(self: Self, item: abc.Hashable, /) -> None:
+        with self.__mutate__() as mutable:
+            mutable.discard(item)
+
+
+### SET-LIKE ###
+
+
+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]
+
+    @abstractmethod
+    @setdoc.basic
+    def __frozen__(self: Self, /) -> __Frozen__[Item]: ...
+    @abstractmethod
+    @setdoc.basic
+    def __init__(self: Self, data: Init[Item] = (), /) -> None: ...
+    @setdoc.basic
+    def difference(self: Self, /, *others: abc.Iterable[abc.Hashable]) -> Self:
+        return type(self)(self.__frozen__().difference(*others))
+
+    @setdoc.basic
+    def intersection(
+        self: Self, /, *others: abc.Iterable[abc.Hashable]
+    ) -> Self:
+        return type(self)(self.__frozen__().intersection(*others))
+
+    @setdoc.basic
+    def issubset(self: Self, other: abc.Iterable[abc.Hashable], /) -> Self:
+        return type(self)(self.__frozen__().issubset(other))  # type: ignore
+
+    @setdoc.basic
+    def issuperset(self: Self, other: abc.Iterable[abc.Hashable], /) -> Self:
+        return type(self)(self.__frozen__().issuperset(other))  # type: ignore
+
+    @setdoc.basic
+    def symmetric_difference(self: Self, other: abc.Iterable[Item], /) -> Self:
+        return type(self)(self.__frozen__().symmetric_difference(other))
+
+    @setdoc.basic
+    def union(self: Self, /, *others: abc.Iterable[Item]) -> Self:
+        return type(self)(self.__frozen__().union(others))  # type: ignore
+
+
+class FrozenSetLike[Item: abc.Hashable](SetLike[Item], abc.Hashable):
+    """Provide abc for custom frozen set-like."""
+
+    __slots__ = ()
+
+    @setdoc.basic
+    def __hash__(self: Self) -> int:
+        return hash(self.__frozen__())
+
+
+class MutableSetLike[Item: abc.Hashable](SetLike[Item], MutableSet[Item]):
+    """Provide abc for custom mutable set-like."""
+
+    __slots__ = ()
+
+    type __Mutable__[MutableItem] = set[MutableItem]
+
+    @setdoc.basic
+    def __frozen__(self: Self, /) -> MutableSetLike.__Frozen__[Item]:
+        with self.__mutate__() as mutable:
+            return frozenset(mutable)
+
+    @abstractmethod
+    @setdoc.basic
+    def __init__(self: Self, data: MutableSetLike.Init[Item] = (), /) -> None:
+        with self.__mutate__() as mutable:
+            mutable.update(data)
+
+    @abstractmethod
+    @setdoc.basic
+    def __mutate__(self: Self) -> ContextManager[__Mutable__[Item]]: ...
+    @setdoc.basic
+    def difference_update(
+        self: Self, /, *others: abc.Iterable[abc.Hashable]
+    ) -> None:
+        with self.__mutate__() as mutable:
+            mutable.difference_update(*others)
+
+    @setdoc.basic
+    def intersection_update(
+        self: Self, /, *others: abc.Iterable[abc.Hashable]
+    ) -> None:
+        with self.__mutate__() as mutable:
+            mutable.intersection_update(*others)
+
+    @setdoc.basic
+    def symmetric_difference_update(
+        self: Self, other: abc.Iterable[Item], /
+    ) -> None:
+        with self.__mutate__() as mutable:
+            mutable.symmetric_difference_update(other)
+
+    @setdoc.basic
+    def update(self: Self, /, *others: abc.Iterable[Item]) -> None:
+        with self.__mutate__() as mutable:
+            mutable.update(*others)
+
+
+### SET-SLOT ###
+
+
+class SetSlot[Item: abc.Hashable](SetLike[Item]):
+    """Provide slotted set-like."""
+
+    __slots__ = ("_slot",)
+
+    _slot: SetSlot.__Frozen__[Item]
+
+    @setdoc.basic
+    def __frozen__(self: Self) -> SetSlot.__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: FrozenSetSlot.Init[Item] = (), /) -> None:
+        self._slot = frozenset(data)
+
+
+class MutableSetSlot[Item](SetSlot[Item], MutableSetLike[Item]):
+    """Provide slotted mutable set-like."""
+
+    __slots__ = ()
+
+    @contextmanager
+    @setdoc.basic
+    def __mutate__(self: Self, /) -> abc.Generator[set[Item], None, None]:
+        slot = set(getattr(self, "_slot", ()))
+        yield slot
+        self._slot = frozenset(slot)
+
+
+### SEQUENCE ###
+
+
+class Sequence[Item](Collection[Item], abc.Sequence[Item]):
+    """Provide a base class for customized sequence."""
+
+    __slots__ = ()
+
+    @setdoc.basic
+    class __Frozen__[FrozenItem](
+        Collection.__Frozen__[FrozenItem],
+        Protocol,
+    ):
+        @overload
+        @setdoc.basic
+        def __getitem__(self: Self, key: int, /) -> FrozenItem: ...
+        @overload
+        @setdoc.basic
+        def __getitem__(
+            self: Self, key: Slice[int], /
+        ) -> abc.Sequence[FrozenItem]: ...
+        @setdoc.basic
+        def __getitem__(
+            self: Self,
+            key: int | Slice[int],
+            /,
+        ) -> FrozenItem | abc.Sequence[FrozenItem]: ...
+
+    @abstractmethod
+    @setdoc.basic
+    def __frozen__(self: Self, /) -> __Frozen__[Item]: ...
+
+    @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.__frozen__()[key]
+
+
+class MutableSequence[Item](Sequence[Item], abc.MutableSequence[Item]):
+    """Provide a base class for customized mutable list-likes."""
+
+    __slots__ = ()
+
+    @setdoc.basic
+    class __Mutable__[MutableItem](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, /) -> MutableItem: ...
+        @overload
+        @setdoc.basic
+        def __getitem__(
+            self: Self, key: Slice[int], /
+        ) -> abc.MutableSequence[MutableItem]: ...
+        @setdoc.basic
+        def __getitem__(
+            self: Self,
+            key: int | Slice[int],
+            /,
+        ) -> MutableItem | abc.MutableSequence[MutableItem]: ...
+
+        @overload
+        @setdoc.basic
+        def __setitem__(
+            self: Self, key: int, value: MutableItem, /
+        ) -> None: ...
+        @overload
+        @setdoc.basic
+        def __setitem__(
+            self: Self, key: Slice[int], value: abc.Iterable[MutableItem], /
+        ) -> None: ...
+        @setdoc.basic
+        def __setitem__(
+            self: Self,
+            key: int | Slice[int],
+            value: MutableItem | abc.Iterable[MutableItem],
+            /,
+        ) -> None: ...
+
+        @setdoc.basic
+        def insert(self: Self, index: int, item: MutableItem, /) -> None: ...
+
+    @overload
+    @setdoc.basic
+    def __delitem__(self: Self, key: int, /) -> None: ...
+    @overload
+    @setdoc.basic
+    def __delitem__(self: Self, key: Slice[int], /) -> None: ...
+    @setdoc.basic
+    def __delitem__(self: Self, key: int | Slice[int], /) -> None:
+        with self.__mutate__() as mutable:
+            del mutable[key]
+
+    @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]:
+        with self.__mutate__() as mutable:
+            return mutable[key]
+
+    @abstractmethod
+    @setdoc.basic
+    def __mutate__(self: Self, /) -> ContextManager[__Mutable__[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:
+        with self.__mutate__() as mutable:
+            mutable[key] = value  # type: ignore
+
+    @setdoc.basic
+    def insert(self: Self, index: int, item: Item, /) -> None:
+        with self.__mutate__() as mutable:
+            mutable.insert(index, item)
+
+
+### LIST-LIKE ###
+class ListLike[Item](Sequence[Item]):
+    """Provide a base class for customized list-likes."""
+
+    __slots__ = ()
+
+    type __Frozen__[FrozenItem] = tuple[FrozenItem, ...]
+    # Frozen has to be tuple to allow covariance
+
+    type Init[InitItem] = abc.Iterable[InitItem]
+
+    @setdoc.basic
+    def __add__[Item_](
+        self: Self, other: ListLike[Item_], /
+    ) -> ListLike[Item | Item_]:
+        if isinstance(other, ListLike):
+            return type(self)(self.__frozen__() + other.__frozen__())  # type: ignore[operator]
+        else:
+            raise TypeError
+
+    @setdoc.basic
+    def __eq__(self: Self, other: object, /) -> NotImplementedType | bool:
+        if isinstance(other, ListLike):
+            return self.__frozen__() == other.__frozen__()
+        else:
+            return NotImplemented
+
+    @abstractmethod
+    @setdoc.basic
+    def __frozen__(self: Self, /) -> __Frozen__[Item]: ...
+
+    @setdoc.basic
+    def __ge__(self: Self, other: ListLike[Any], /) -> bool:
+        if isinstance(other, ListLike):
+            return self.__frozen__() >= other.__frozen__()
+        else:
+            return NotImplemented
+
+    @overload
+    @setdoc.basic
+    def __getitem__(self: Self, key: SupportsIndex, /) -> Item: ...
+
+    @overload
+    @setdoc.basic
+    def __getitem__(self: Self, key: Slice[SupportsIndex], /) -> Self: ...
+
+    @setdoc.basic
+    def __getitem__(
+        self: Self,
+        key: SupportsIndex | Slice[SupportsIndex],
+        /,
+    ) -> Item | Self:
+        if isinstance(key, SupportsIndex):
+            return self.__frozen__()[key]
+        else:
+            return type(self)(self.__frozen__()[key])
+
+    @setdoc.basic
+    def __gt__(self: Self, other: ListLike[Any], /) -> bool:
+        if isinstance(other, ListLike):
+            return self.__frozen__() > other.__frozen__()
+        else:
+            return NotImplemented
+
+    @abstractmethod
+    @setdoc.basic
+    def __init__(self: Self, data: Init[Item] = (), /) -> None: ...
+
+    @setdoc.basic
+    def __le__(self: Self, other: ListLike[Any], /) -> bool:
+        if isinstance(other, ListLike):
+            return self.__frozen__() <= other.__frozen__()
+        else:
+            return NotImplemented
+
+    @setdoc.basic
+    def __lt__(self: Self, other: ListLike[Any], /) -> bool:
+        if isinstance(other, ListLike):
+            return self.__frozen__() < other.__frozen__()
+        else:
+            return NotImplemented
+
+    @setdoc.basic
+    def __mul__(self: Self, other: SupportsIndex, /) -> Self:
+        if isinstance(other, SupportsIndex):
+            return type(self)(self.__frozen__() * other)
+        else:
+            raise TypeError
+
+    __rmul__ = __mul__
+
+    @setdoc.basic
+    def __repr__(self: Self, /) -> str:
+        return f"{type(self).__name__}({list(self)!r})"
+
+
+class FrozenListLike[Item](ListLike[Item], abc.Hashable):
+    """Provide a base class for customized frozen list-likes."""
+
+    __slots__ = ()
+
+    @setdoc.basic
+    def __hash__(self: Self) -> int:
+        return hash(self.__frozen__())
+
+
+class MutableListLike[Item](ListLike[Item], MutableSequence[Item]):
+    """Provide a base class for customized mutable list-likes."""
+
+    __slots__ = ()
+
+    type __Mutable__[MutableItem] = list[MutableItem]
+
+    @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:
+        with self.__mutate__() as mutable:
+            del mutable[key]
+
+    @setdoc.basic
+    def __frozen__(self: Self) -> MutableListLike.__Frozen__[Item]:
+        with self.__mutate__() as mutable:
+            return tuple(mutable)
+
+    @setdoc.basic
+    def __imul__(self: Self, other: SupportsIndex, /) -> Self:
+        with self.__mutate__() as mutable:
+            mutable *= other
+        return self
+
+    @setdoc.basic
+    def __init__(self: Self, data: abc.Iterable[Item] = (), /) -> None:
+        with self.__mutate__() as mutable:
+            mutable.extend(data)
+
+    @abstractmethod
+    @setdoc.basic
+    def __mutate__(self: Self, /) -> ContextManager[__Mutable__[Item]]: ...
+
+    @overload
+    @setdoc.basic
+    def __setitem__(
+        self: Self, key: SupportsIndex, value: Item, /
+    ) -> None: ...
+    @overload
+    @setdoc.basic
+    def __setitem__(
+        self: Self, key: Slice[SupportsIndex], value: abc.Iterable[Item], /
+    ) -> None: ...
+    @setdoc.basic
+    def __setitem__(
+        self: Self,
+        key: SupportsIndex | Slice[SupportsIndex],
+        value: Item | abc.Iterable[Item],
+        /,
+    ) -> None:
+        with self.__mutate__() as mutable:
+            mutable[key] = value  # type: ignore
+
+    @setdoc.basic
+    def copy(self: Self) -> Self:
+        return type(self)(self)
+
+    @setdoc.basic
+    def insert(self: Self, index: SupportsIndex, item: Item, /) -> None:
+        with self.__mutate__() as mutable:
+            mutable.insert(index, item)
+
+    @setdoc.basic
+    def sort(self: Self, /, *, key: Any = None, reverse: bool = False) -> None:
+        # list.sort reveals Overload(
+        #     def [_T, SupportsRichComparisonT <: _typeshed.SupportsDunderLT[Any] | _typeshed.SupportsDunderGT[Any]] (self: list[SupportsRichComparisonT], *, key: None =, reverse: bool =),
+        #     def [_T] (self: list[_T], *, key: def (_T) -> _typeshed.SupportsDunderLT[Any] | _typeshed.SupportsDunderGT[Any], reverse: bool =),
+        # )
+        with self.__mutate__() as mutable:
+            mutable.sort(key=key, reverse=reverse)
+
+
+### LIST-SLOT ###
+
+
+class ListSlot[Item](ListLike[Item]):
+    """Provide slotted list-like class."""
+
+    __slots__ = ("_slot",)
+
+    _slot: ListSlot.__Frozen__[Item]
+
+    @setdoc.basic
+    def __frozen__(self: Self) -> ListSlot.__Frozen__[Item]:
+        return self._slot
+
+
+class FrozenListSlot[Item](ListSlot[Item], FrozenListLike[Item]):
+    """Provide a base class for customized frozen data-holds."""
+
+    __slots__ = ()
+
+    @setdoc.basic
+    def __init__(self: Self, data: abc.Iterable[Item] = (), /) -> None:
+        self._slot = tuple(data)
+
+
+class MutableListSlot[Item](ListSlot[Item], MutableListLike[Item]):
+    """Provide slotted mutable list-like class."""
+
+    __slots__ = ()
+
+    @contextmanager
+    @setdoc.basic
+    def __mutate__(self: Self, /) -> abc.Generator[list[Item], None, None]:
+        slot = list(getattr(self, "_slot", ()))
+        yield slot
+        self._slot = tuple(slot)

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

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

@@ -29,6 +29,7 @@ tests/test_generic.py
 tests/test_internal_comparison.py
 tests/test_issubclass.py
 tests/test_nested.py
+tests/test_prefix.py
 tests/test_sorted.py
 tests/test_variance.py
 tests/testdata.toml

datahold-4.0.0.dev21/tests/test_prefix.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+__all__: list[str] = ["TestPrefix"]
+
+import unittest
+from collections import abc
+from typing import Self
+
+from Lazy import Lazy
+
+import datahold
+
+
+class TestPrefix(unittest.TestCase):
+    def _test_prefix(self: Self, name: str, /) -> None:
+        datatype = getattr(datahold, name)
+        self.assertEqual(datatype.__name__, name)
+        self.assertTrue(hasattr(datatype, "__Frozen__"))
+        self.assertTrue(hasattr(datatype, "__frozen__"))
+        if name.startswith("Frozen"):
+            self.assertIsNot(datatype.__hash__, object.__hash__)
+            self.assertTrue(issubclass(datatype, abc.Hashable))
+            self.assertFalse(hasattr(datatype, "__Mutable__"))
+            self.assertFalse(hasattr(datatype, "__mutate__"))
+            return
+        self.assertIn(datatype.__hash__, [None, object.__hash__])
+        if name.startswith("Mutable"):
+            self.assertTrue(hasattr(datatype, "__Mutable__"))
+            self.assertTrue(hasattr(datatype, "__mutate__"))
+            return
+        self.assertFalse(hasattr(datatype, "__Mutable__"))
+        self.assertFalse(hasattr(datatype, "__mutate__"))
+
+    def test_prefix(self: Self, /) -> None:
+        for name in Lazy.lazy.datatypes.keys():
+            with self.subTest(datatype=name):
+                self._test_prefix(name)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

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

@@ -1,3 +1,5 @@
+[datatypes.Collection]
+
 [datatypes.FrozenListLike]
 abstractmethods = [
     "__frozen__",
@@ -16,9 +18,9 @@ __init__ = "datahold.ListLike"
 "collections.abc.Sequence" = true
 
 [datatypes.FrozenListLike.nested]
-Frozen = "builtins.tuple"
 Init = "collections.abc.Iterable"
-Mutable = ""
+__Frozen__ = "builtins.tuple"
+__Mutable__ = ""
 
 [datatypes.FrozenListLike.varia]
 generic = 1
@@ -131,13 +133,25 @@ args = [
 ]
 
 [datatypes.FrozenListSlot.nested]
-Frozen = "builtins.tuple"
 Init = "collections.abc.Iterable"
-Mutable = ""
+__Frozen__ = "builtins.tuple"
+__Mutable__ = ""
 
 [datatypes.FrozenListSlot.varia]
 generic = 1
 
+[datatypes.FrozenSetLike.issubclass]
+"collections.abc.Hashable" = true
+"collections.abc.Set" = true
+"datahold.Collection" = true
+"datahold.SetLike" = true
+
+[datatypes.FrozenSetSlot.issubclass]
+"collections.abc.Collection" = true
+"collections.abc.MutableSet" = false
+"collections.abc.Set" = true
+"datahold.Collection" = true
+
 [datatypes.ListLike]
 abstractmethods = [
     "__frozen__",
@@ -147,7 +161,7 @@ abstractmethods = [
 [datatypes.ListLike.attributes]
 __frozen__ = "datahold.ListLike"
 __init__ = "datahold.ListLike"
-__mutable__ = ""
+__mutate__ = ""
 __reversed__ = "collections.abc.Sequence"
 count = "collections.abc.Sequence"
 index = "collections.abc.Sequence"
@@ -157,11 +171,12 @@ index = "collections.abc.Sequence"
 "collections.abc.MutableSequence" = false
 "collections.abc.Sequence" = true
 "datahold.ListLike" = true
+"datahold.MutableSequence" = false
 
 [datatypes.ListLike.nested]
-Frozen = "builtins.tuple"
 Init = "collections.abc.Iterable"
-Mutable = ""
+__Frozen__ = "builtins.tuple"
+__Mutable__ = ""
 
 [datatypes.ListLike.varia]
 generic = 1
@@ -172,26 +187,25 @@ abstractmethods = [
 ]
 
 [datatypes.ListSlot.nested]
-Frozen = "builtins.tuple"
 Init = "collections.abc.Iterable"
-Mutable = ""
+__Frozen__ = "builtins.tuple"
+__Mutable__ = ""
 
 [datatypes.ListSlot.varia]
 generic = 1
 
 [datatypes.MutableListLike]
 abstractmethods = [
-    "__frozen__",
-    "__mutable__",
+    "__mutate__",
 ]
 
 [datatypes.MutableListLike.attributes]
 __add__ = "datahold.MutableListLike"
-__frozen__ = "datahold.ListLike"
+__frozen__ = "datahold.MutableListLike"
 __iadd__ = "collections.abc.MutableSequence"
 __imul__ = "datahold.MutableListLike"
 __init__ = "datahold.MutableListLike"
-__mutable__ = "datahold.MutableListLike"
+__mutate__ = "datahold.MutableListLike"
 __reversed__ = "collections.abc.Sequence"
 append = "collections.abc.MutableSequence"
 clear = "collections.abc.MutableSequence"
@@ -199,6 +213,7 @@ count = "collections.abc.Sequence"
 extend = "collections.abc.MutableSequence"
 foo = ""
 index = "collections.abc.Sequence"
+insert = "datahold.MutableListLike"
 pop = "collections.abc.MutableSequence"
 remove = "collections.abc.MutableSequence"
 reverse = "collections.abc.MutableSequence"
@@ -208,10 +223,11 @@ reverse = "collections.abc.MutableSequence"
 "collections.abc.Hashable" = false
 "collections.abc.MutableMapping" = false
 "collections.abc.MutableSequence" = true
+"datahold.MutableSequence" = true
 
 [datatypes.MutableListLike.nested]
-Frozen = "builtins.tuple"
 Init = "collections.abc.Iterable"
+__Frozen__ = "builtins.tuple"
 __hash__ = ""
 
 [datatypes.MutableListLike.varia]
@@ -227,11 +243,63 @@ abstractmethods = []
 "datahold.MutableListSlot" = true
 
 [datatypes.MutableListSlot.nested]
-Frozen = "builtins.tuple"
 Init = "collections.abc.Iterable"
+__Frozen__ = "builtins.tuple"
 __hash__ = ""
 
 [datatypes.MutableListSlot.varia]
 generic = 1
 
+[datatypes.MutableSequence.attributes]
+__Frozen__ = "datahold.Sequence"
+__Mutable__ = "datahold.MutableSequence"
+__delitem__ = "datahold.MutableSequence"
+__frozen__ = "datahold.Sequence"
+__getitem__ = "datahold.MutableSequence"
+__mutate__ = "datahold.MutableSequence"
+__setitem__ = "datahold.MutableSequence"
+insert = "datahold.MutableSequence"
+sort = ""
+
+[datatypes.MutableSet.issubclass]
+"collections.abc.MutableSet" = true
+"collections.abc.Set" = true
+"datahold.Collection" = true
+
+[datatypes.MutableSetLike.issubclass]
+"collections.abc.Hashable" = false
+"collections.abc.MutableSet" = true
+"collections.abc.Set" = true
+"datahold.Collection" = true
+"datahold.MutableSet" = true
+"datahold.SetLike" = true
+
+[datatypes.MutableSetSlot.issubclass]
+"collections.abc.MutableSet" = true
+"collections.abc.Set" = true
+"datahold.Collection" = true
+"datahold.MutableSet" = true
+"datahold.MutableSetLike" = true
+"datahold.SetSlot" = true
+
+[datatypes.Sequence]
+abstractmethods = [
+    "__frozen__",
+]
+
+[datatypes.Set.issubclass]
+"collections.abc.Set" = true
+"datahold.Collection" = true
+
+[datatypes.SetLike.issubclass]
+"collections.abc.Set" = true
+"datahold.Collection" = true
+"datahold.Set" = true
+"datahold.SetLike" = true
+
+[datatypes.SetSlot.issubclass]
+"collections.abc.Set" = true
+"datahold.Collection" = true
+"datahold.SetLike" = true
+
 [non_datatypes]

datahold-4.0.0.dev10/src/datahold/__init__.py

@@ -1,258 +0,0 @@
-"""Provide provides base classes for customized collections."""
-
-from __future__ import annotations
-
-__all__: list[str] = [
-    "FrozenListLike",
-    "FrozenListSlot",
-    "ListLike",
-    "ListSlot",
-    "MutableListLike",
-    "MutableListSlot",
-]
-
-from abc import abstractmethod
-from collections import abc
-from contextlib import contextmanager
-from types import NotImplementedType, TracebackType
-from typing import Any, Optional, Protocol, Self, SupportsIndex, overload
-
-import setdoc
-
-### UTILS ###
-
-type Slice[Index] = slice[Optional[Index], Optional[Index], Optional[Index]]
-
-
-### LIST-LIKE ###
-class ListLike[Item](abc.Sequence[Item]):
-    """Provide a base class for customized list-likes."""
-
-    __slots__ = ()
-
-    type Frozen[FrozenItem] = tuple[FrozenItem, ...]
-    # Frozen has to be tuple to allow covariance
-
-    type Init[InitItem] = abc.Iterable[InitItem]
-
-    @setdoc.basic
-    def __add__[Item_](
-        self: Self, other: ListLike[Item_], /
-    ) -> ListLike[Item | Item_]:
-        if isinstance(other, ListLike):
-            return type(self)(self.__frozen__() + other.__frozen__())  # type: ignore[operator]
-        else:
-            raise TypeError
-
-    @setdoc.basic
-    def __contains__(self: Self, other: object, /) -> bool:
-        return other in self.__frozen__()
-
-    @setdoc.basic
-    def __eq__(self: Self, other: object, /) -> NotImplementedType | bool:
-        if isinstance(other, ListLike):
-            return self.__frozen__() == other.__frozen__()
-        else:
-            return NotImplemented
-
-    @abstractmethod
-    @setdoc.basic
-    def __frozen__(self: Self, /) -> Frozen[Item]: ...
-
-    @setdoc.basic
-    def __ge__(self: Self, other: ListLike[Any], /) -> bool:
-        if isinstance(other, ListLike):
-            return self.__frozen__() >= other.__frozen__()
-        else:
-            return NotImplemented
-
-    @overload
-    @setdoc.basic
-    def __getitem__(self: Self, key: SupportsIndex, /) -> Item: ...
-
-    @overload
-    @setdoc.basic
-    def __getitem__(self: Self, key: Slice[SupportsIndex], /) -> Self: ...
-
-    @setdoc.basic
-    def __getitem__(
-        self: Self,
-        key: SupportsIndex | Slice[SupportsIndex],
-        /,
-    ) -> Item | Self:
-        if isinstance(key, SupportsIndex):
-            return self.__frozen__()[key]
-        else:
-            return type(self)(self.__frozen__()[key])
-
-    @setdoc.basic
-    def __gt__(self: Self, other: ListLike[Any], /) -> bool:
-        if isinstance(other, ListLike):
-            return self.__frozen__() > other.__frozen__()
-        else:
-            return NotImplemented
-
-    @abstractmethod
-    @setdoc.basic
-    def __init__(self: Self, data: Init[Item] = (), /) -> None: ...
-
-    @setdoc.basic
-    def __le__(self: Self, other: ListLike[Any], /) -> bool:
-        if isinstance(other, ListLike):
-            return self.__frozen__() <= other.__frozen__()
-        else:
-            return NotImplemented
-
-    @setdoc.basic
-    def __len__(self: Self, /) -> int:
-        return len(self.__frozen__())
-
-    @setdoc.basic
-    def __lt__(self: Self, other: ListLike[Any], /) -> bool:
-        if isinstance(other, ListLike):
-            return self.__frozen__() < other.__frozen__()
-        else:
-            return NotImplemented
-
-    @setdoc.basic
-    def __mul__(self: Self, other: SupportsIndex, /) -> Self:
-        if isinstance(other, SupportsIndex):
-            return type(self)(self.__frozen__() * other)
-        else:
-            raise TypeError
-
-    __rmul__ = __mul__
-
-    @setdoc.basic
-    def __repr__(self: Self, /) -> str:
-        return f"{type(self).__name__}({list(self)!r})"
-
-
-class ListSlot[Item](ListLike[Item]):
-    """Provide slotted list-like class."""
-
-    __slots__ = ("_slot",)
-
-    _slot: ListSlot.Frozen[Item]
-
-    @setdoc.basic
-    def __frozen__(self: Self) -> ListSlot.Frozen[Item]:
-        return self._slot
-
-
-class FrozenListLike[Item](ListLike[Item], abc.Hashable):
-    """Provide a base class for customized frozen list-likes."""
-
-    __slots__ = ()
-
-    @setdoc.basic
-    def __hash__(self: Self) -> int:
-        return hash(self.__frozen__())
-
-
-class FrozenListSlot[Item](ListSlot[Item], FrozenListLike[Item]):
-    """Provide a base class for customized frozen data-holds."""
-
-    __slots__ = ()
-
-    @setdoc.basic
-    def __init__(self: Self, data: abc.Iterable[Item] = (), /) -> None:
-        self._slot = tuple(data)
-
-
-class MutableListLike[Item](ListLike[Item], abc.MutableSequence[Item]):
-    """Provide a base class for customized mutable list-likes."""
-
-    __slots__ = ()
-
-    @setdoc.basic
-    class Mutable[MutableItem](Protocol):
-        @setdoc.basic
-        def __enter__(self: Self, /) -> list[MutableItem]: ...
-        @setdoc.basic
-        def __exit__(
-            self,
-            exc_type: type[BaseException] | None,
-            exc_value: BaseException | None,
-            traceback: TracebackType | None,
-            /,
-        ) -> object: ...
-
-    @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:
-        with self.__mutable__() as mutable:
-            del mutable[key]
-
-    @setdoc.basic
-    def __imul__(self: Self, other: SupportsIndex, /) -> Self:
-        with self.__mutable__() as mutable:
-            mutable *= other
-        return self
-
-    @setdoc.basic
-    def __init__(self: Self, data: abc.Iterable[Item] = (), /) -> None:
-        with self.__mutable__() as mutable:
-            mutable.extend(data)
-
-    @abstractmethod
-    @setdoc.basic
-    def __mutable__(self: Self, /) -> Mutable[Item]: ...
-
-    @overload
-    @setdoc.basic
-    def __setitem__(
-        self: Self, key: SupportsIndex, value: Item, /
-    ) -> None: ...
-    @overload
-    @setdoc.basic
-    def __setitem__(
-        self: Self, key: Slice[SupportsIndex], value: abc.Iterable[Item], /
-    ) -> None: ...
-    @setdoc.basic
-    def __setitem__(
-        self: Self,
-        key: SupportsIndex | Slice[SupportsIndex],
-        value: Item | abc.Iterable[Item],
-        /,
-    ) -> None:
-        with self.__mutable__() as mutable:
-            mutable[key] = value  # type: ignore
-
-    @setdoc.basic
-    def copy(self: Self) -> Self:
-        return type(self)(self.__frozen__())
-
-    @setdoc.basic
-    def insert(self: Self, index: SupportsIndex, item: Item, /) -> None:
-        with self.__mutable__() as mutable:
-            mutable.insert(index, item)
-
-    @setdoc.basic
-    def sort(self: Self, /, *, key: Any = None, reverse: bool = False) -> None:
-        # list.sort reveals Overload(
-        #     def [_T, SupportsRichComparisonT <: _typeshed.SupportsDunderLT[Any] | _typeshed.SupportsDunderGT[Any]] (self: list[SupportsRichComparisonT], *, key: None =, reverse: bool =),
-        #     def [_T] (self: list[_T], *, key: def (_T) -> _typeshed.SupportsDunderLT[Any] | _typeshed.SupportsDunderGT[Any], reverse: bool =),
-        # )
-        with self.__mutable__() as mutable:
-            mutable.sort(key=key, reverse=reverse)
-
-
-class MutableListSlot[Item](ListSlot[Item], MutableListLike[Item]):
-    """Provide slotted mutable list-like class."""
-
-    __slots__ = ()
-
-    @contextmanager
-    @setdoc.basic
-    def __mutable__(self: Self, /) -> abc.Generator[list[Item], None, None]:
-        slot = list(getattr(self, "_slot", ()))
-        yield slot
-        self._slot = tuple(slot)