datahold 4.0.0.dev7__tar.gz → 4.0.0.dev9__tar.gz

{datahold-4.0.0.dev7 → datahold-4.0.0.dev9}/PKG-INFO

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

@@ -34,7 +34,7 @@ license-files = [
 name = "datahold"
 readme = "README.rst"
 requires-python = ">=3.12"
-version = "4.0.0.dev7"
+version = "4.0.0.dev9"
 
 [project.urls]
 Download = "https://pypi.org/project/datahold/#files"

{datahold-4.0.0.dev7 → datahold-4.0.0.dev9}/src/datahold/__init__.py

@@ -3,20 +3,21 @@
 from __future__ import annotations
 
 __all__: list[str] = [
-    "BaseDataAbstractSet",
-    "BaseDataCollection",
-    "BaseDataDict",
-    "BaseDataList",
-    "BaseDataMapping",
-    "BaseDataSequence",
-    "BaseDataSet",
     "BaseHoldObject",
-    "DataDict",
-    "DataList",
-    "DataSet",
-    "FrozenDataDict",
-    "FrozenDataList",
-    "FrozenDataSet",
+    "Collection",
+    "DictLike",
+    "FrozenDictLike",
+    "FrozenListLike",
+    "FrozenMapping",
+    "FrozenSetLike",
+    "ListLike",
+    "Mapping",
+    "MutableDictLike",
+    "MutableListLike",
+    "MutableSetLike",
+    "Sequence",
+    "Set",
+    "SetLike",
 ]
 
 import enum
@@ -80,7 +81,7 @@ class BaseHoldObject[HoldData: Copyable]:
 ### COLLECTION ###
 
 
-class BaseDataCollection[Item](
+class Collection[Item](
     abc.Sized,
     abc.Iterable[Item],
     abc.Container[object],
@@ -106,6 +107,10 @@ class BaseDataCollection[Item](
         except TypeError:
             return other in (x for x in self.__fget__())  # type: ignore[operator]
 
+    @abstractmethod
+    @setdoc.basic
+    def __fget__(self: Self) -> Data[Item]: ...
+
     @setdoc.basic
     def __iter__(self: Self, /) -> abc.Iterator[Item]:
         return iter(self.__fget__())
@@ -114,16 +119,12 @@ class BaseDataCollection[Item](
     def __len__(self: Self, /) -> int:
         return len(self.__fget__())
 
-    @abstractmethod
-    @setdoc.basic
-    def __fget__(self: Self) -> Data[Item]: ...
-
 
 ### ABSTRACT SET ###
 
 
-class BaseDataAbstractSet[Item](
-    BaseDataCollection[Item],
+class Set[Item](
+    Collection[Item],
     abc.Set[Item],
 ):
     """Provide an easy abc for a custom (abstract) set."""
@@ -134,7 +135,7 @@ class BaseDataAbstractSet[Item](
 ### SET ###
 
 
-class BaseDataSet[Item: abc.Hashable](BaseDataAbstractSet[Item]):
+class SetLike[Item: abc.Hashable](Set[Item]):
     """Provide an easy abc for custom set-like."""
 
     __slots__ = ()
@@ -189,7 +190,7 @@ class BaseDataSet[Item: abc.Hashable](BaseDataAbstractSet[Item]):
         return type(self)(self.__fget__().union(*others))
 
 
-class FrozenDataSet[Item: abc.Hashable](BaseDataSet[Item], abc.Hashable):
+class FrozenSetLike[Item: abc.Hashable](SetLike[Item], abc.Hashable):
     """Provide easy abc for custom frozen set-like."""
 
     __slots__ = ()
@@ -199,8 +200,8 @@ class FrozenDataSet[Item: abc.Hashable](BaseDataSet[Item], abc.Hashable):
         return hash(frozenset(self.__fget__()))
 
 
-class DataSet[Item: abc.Hashable](
-    BaseDataSet[Item],
+class MutableSetLike[Item: abc.Hashable](
+    SetLike[Item],
     abc.MutableSet[Item],
 ):
     """Provide easy abc for custom mutable set-like."""
@@ -209,7 +210,10 @@ class DataSet[Item: abc.Hashable](
 
     @setdoc.basic
     def add(self: Self, item: Item, /) -> None:
-        self.__fset__(self.__fget__() | {item})
+        data: set[Item]
+        data = self.__fget__()
+        data.add(item)
+        self.__fset__(data)
 
     @setdoc.basic
     def copy(self: Self) -> Self:
@@ -221,10 +225,7 @@ class DataSet[Item: abc.Hashable](
         /,
         *others: abc.Iterable[abc.Hashable],
     ) -> None:
-        data: set[Item]
-        data = self.__fget__()
-        data.difference_update(*others)
-        self.__fset__(data)
+        self.__fset__(self.__fget__().difference(*others))
 
     @setdoc.basic
     def discard(self: Self, item: abc.Hashable, /) -> None:
@@ -237,19 +238,13 @@ class DataSet[Item: abc.Hashable](
     def intersection_update(
         self: Self, /, *others: abc.Iterable[abc.Hashable]
     ) -> None:
-        data: set[Item]
-        data = self.__fget__()
-        data.intersection_update(*others)
-        self.__fset__(data)
+        self.__fset__(self.__fget__().intersection(*others))
 
     @setdoc.basic
     def symmetric_difference_update(
         self: Self, other: abc.Iterable[Item], /
     ) -> None:
-        data: set[Item]
-        data = self.__fget__()
-        data.symmetric_difference_update(other)
-        self.__fset__(data)
+        self.__fset__(self.__fget__().symmetric_difference(other))
 
     @setdoc.basic
     def update(self: Self, /, *others: abc.Iterable[Item]) -> None:
@@ -257,8 +252,8 @@ class DataSet[Item: abc.Hashable](
 
 
 ### MAPPING ###
-class BaseDataMapping[Key, Value](
-    BaseDataCollection[Key], abc.Mapping[Key, Value]
+class Mapping[Key: abc.Hashable, Value](
+    Collection[Key], abc.Mapping[Key, Value]
 ):
     """Provide an easy abc for a custom mapping."""
 
@@ -266,12 +261,15 @@ class BaseDataMapping[Key, Value](
 
     @setdoc.basic
     class Data[DataKey, DataValue](
-        BaseDataCollection.Data[DataKey],
+        Collection.Data[DataKey],
         Protocol,
     ):
         @setdoc.basic
-        def __getitem__(self: Self, key: Never, /) -> DataValue:
-            pass
+        def __getitem__(self: Self, key: Never, /) -> DataValue: ...
+
+    @abstractmethod
+    @setdoc.basic
+    def __fget__(self: Self) -> Data[Key, Value]: ...
 
     @setdoc.basic
     def __getitem__(self: Self, key: object, /) -> Value:
@@ -280,16 +278,25 @@ class BaseDataMapping[Key, Value](
         except TypeError:
             raise KeyError(key) from None
 
-    @abstractmethod
+
+class FrozenMapping[Key: abc.Hashable, Value](
+    Mapping[Key, Value],
+    abc.Hashable,
+):
+    """Provide an easy abc for a custom frozen mapping."""
+
+    __slots__ = ()
+
     @setdoc.basic
-    def __fget__(self: Self) -> Data[Key, Value]: ...
+    def __hash__(self: Self) -> int:
+        return hash(frozendict(self.items()))
 
 
 ### DICT ###
 
 
-class BaseDataDict[Key: abc.Hashable, Value](
-    BaseDataMapping[Key | str, Optional[Value]],
+class DictLike[Key: abc.Hashable, Value](
+    Mapping[Key | str, Optional[Value]],
 ):
     """Provide an easy abc for custom dict-like."""
 
@@ -316,7 +323,7 @@ class BaseDataDict[Key: abc.Hashable, Value](
         /,
         **kwargs: Optional[Value],
     ) -> None:
-        data_: BaseDataDict.Data[Key, Value]
+        data_: DictLike.Data[Key, Value]
         data_ = dict(  # type: ignore[assignment]
             data,  # type: ignore[arg-type]
             **kwargs,
@@ -326,7 +333,7 @@ class BaseDataDict[Key: abc.Hashable, Value](
     @setdoc.basic
     def __or__(
         self: Self,
-        other: BaseDataDict[Key, Value],
+        other: DictLike[Key, Value],
         /,
     ) -> Self:
         return type(self)(self.__fget__() | other.__fget__())
@@ -348,21 +355,17 @@ class BaseDataDict[Key: abc.Hashable, Value](
         return cls(dict.fromkeys(iterable, value))
 
 
-class FrozenDataDict[Key: abc.Hashable, Value](
-    BaseDataDict[Key, Value],
-    abc.Hashable,
+class FrozenDictLike[Key: abc.Hashable, Value](
+    DictLike[Key, Value],
+    FrozenMapping[Key | str, Optional[Value]],
 ):
     """Provide easy abc for custom frozen dict-like."""
 
     __slots__ = ()
 
-    @setdoc.basic
-    def __hash__(self: Self) -> int:
-        return hash(frozendict(self.__fget__()))
-
 
-class DataDict[Key: abc.Hashable, Value](
-    BaseDataDict[Key, Value],
+class MutableDictLike[Key: abc.Hashable, Value](
+    DictLike[Key, Value],
     abc.MutableMapping[Key | str, Optional[Value]],
 ):
     """Provide easy abc for custom mutable dict-like."""
@@ -371,7 +374,7 @@ class DataDict[Key: abc.Hashable, Value](
 
     @setdoc.basic
     def __delitem__(self: Self, key: Key | str, /) -> None:
-        data: DataDict.Data[Key, Value]
+        data: MutableDictLike.Data[Key, Value]
         data = self.__fget__()
         del data[key]
         self.__fset__(data)
@@ -379,7 +382,7 @@ class DataDict[Key: abc.Hashable, Value](
     @setdoc.basic
     def __ior__(
         self: Self,
-        other: BaseDataDict[Key, Value],
+        other: DictLike[Key, Value],
         /,
     ) -> Self:
         self.__fset__(self.__fget__() | other.__fget__())
@@ -393,7 +396,7 @@ class DataDict[Key: abc.Hashable, Value](
         /,
     ) -> None:
         # what to do if Key includes unhashable types?
-        data: DataDict.Data[Key, Value]
+        data: MutableDictLike.Data[Key, Value]
         data = self.__fget__()
         data[key] = value
         self.__fset__(data)
@@ -406,8 +409,8 @@ class DataDict[Key: abc.Hashable, Value](
 ### SEQUENCE ###
 
 
-class BaseDataSequence[Item](
-    BaseDataCollection[Item],
+class Sequence[Item](
+    Collection[Item],
     abc.Sequence[Item],
 ):
     """Provide an easy abc for a custom sequence."""
@@ -416,7 +419,7 @@ class BaseDataSequence[Item](
 
     @setdoc.basic
     class Data[DataItem](
-        BaseDataCollection.Data[DataItem],
+        Collection.Data[DataItem],
         Protocol,
     ):
         """Provide sequence data protocol."""
@@ -434,6 +437,10 @@ class BaseDataSequence[Item](
             self: Self, key: int | Slice[int], /
         ) -> DataItem | abc.Sequence[DataItem]: ...
 
+    @abstractmethod
+    @setdoc.basic
+    def __fget__(self: Self) -> Data[Item]: ...
+
     @overload
     @setdoc.basic
     def __getitem__(self: Self, key: int, /) -> Item: ...
@@ -446,15 +453,11 @@ class BaseDataSequence[Item](
     ) -> Item | abc.Sequence[Item]:
         return self.__fget__()[key]
 
-    @abstractmethod
-    @setdoc.basic
-    def __fget__(self: Self) -> Data[Item]: ...
-
 
 ### LIST ###
 
 
-class BaseDataList[Item](BaseDataSequence[Item]):
+class ListLike[Item](Sequence[Item]):
     """Provide an easy abc for custom list-like."""
 
     __slots__ = ()
@@ -463,7 +466,7 @@ class BaseDataList[Item](BaseDataSequence[Item]):
     type Init[InitItem] = abc.Iterable[InitItem]
 
     @setdoc.basic
-    def __add__(self: Self, other: BaseDataList[Item], /) -> Self:
+    def __add__(self: Self, other: ListLike[Item], /) -> Self:
         # list.__add__ reveals Overload(
         #     def [_T] (list[_T], list[_T]) -> list[_T],
         #     def [_T, _S] (list[_T], list[_S]) -> list[_S | _T],
@@ -472,14 +475,14 @@ class BaseDataList[Item](BaseDataSequence[Item]):
         #     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):
+        if isinstance(other, ListLike):
             return type(self)(self.__fget__() + other.__fget__())
         else:
             return NotImplemented
 
     @setdoc.basic
     def __eq__(self: Self, other: object, /) -> NotImplementedType | bool:
-        if isinstance(other, BaseDataList):
+        if isinstance(other, ListLike):
             return self.__fget__() == other.__fget__()
         else:
             return NotImplemented
@@ -494,7 +497,7 @@ class BaseDataList[Item](BaseDataSequence[Item]):
 
     @setdoc.basic
     def __ge__(self: Self, other: object, /) -> NotImplementedType | bool:
-        if isinstance(other, BaseDataList):
+        if isinstance(other, ListLike):
             return self.__fget__() >= other.__fget__()
         else:
             return NotImplemented
@@ -518,7 +521,7 @@ class BaseDataList[Item](BaseDataSequence[Item]):
 
     @setdoc.basic
     def __gt__(self: Self, other: object, /) -> NotImplementedType | bool:
-        if isinstance(other, BaseDataList):
+        if isinstance(other, ListLike):
             return self.__fget__() > other.__fget__()
         else:
             return NotImplemented
@@ -529,14 +532,14 @@ class BaseDataList[Item](BaseDataSequence[Item]):
 
     @setdoc.basic
     def __le__(self: Self, other: object, /) -> NotImplementedType | bool:
-        if isinstance(other, BaseDataList):
+        if isinstance(other, ListLike):
             return self.__fget__() <= other.__fget__()
         else:
             return NotImplemented
 
     @setdoc.basic
     def __lt__(self: Self, other: object, /) -> NotImplementedType | bool:
-        if isinstance(other, BaseDataList):
+        if isinstance(other, ListLike):
             return self.__fget__() < other.__fget__()
         else:
             return NotImplemented
@@ -552,8 +555,8 @@ class BaseDataList[Item](BaseDataSequence[Item]):
     __rmul__ = __mul__
 
 
-class FrozenDataList[Item](
-    BaseDataList[Item],
+class FrozenListLike[Item](
+    ListLike[Item],
     abc.Hashable,
 ):
     """Provide easy abc for custom frozen list-like."""
@@ -565,8 +568,8 @@ class FrozenDataList[Item](
         return hash(tuple(self.__fget__()))
 
 
-class DataList[Item](
-    BaseDataList[Item],
+class MutableListLike[Item](
+    ListLike[Item],
     abc.MutableSequence[Item],
 ):
     """Provide easy abc for custom mutable list-like."""

{datahold-4.0.0.dev7 → datahold-4.0.0.dev9}/src/datahold.egg-info/PKG-INFO

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

@@ -11,12 +11,12 @@ from typing import Any, Self
 
 from frozendict import frozendict
 
-from datahold import BaseHoldObject, FrozenDataDict
+from datahold import BaseHoldObject, FrozenDictLike
 
 
 class FrozenHoldDict[Key: abc.Hashable, Value](
-    BaseHoldObject[FrozenDataDict.Data[Key, Value]],
-    FrozenDataDict[Key, Value],
+    BaseHoldObject[FrozenDictLike.Data[Key, Value]],
+    FrozenDictLike[Key, Value],
 ):
     """Provide usable frozen dict-like with slots."""
 

{datahold-4.0.0.dev7 → datahold-4.0.0.dev9}/tests/test_FrozenHoldList.py

@@ -7,12 +7,12 @@ __all__: list[str] = [
 import unittest
 from typing import Any, Self
 
-from datahold import BaseHoldObject, FrozenDataList
+from datahold import BaseHoldObject, FrozenListLike
 
 
 class FrozenHoldList[Item](
-    BaseHoldObject[FrozenDataList.Data[Item]],
-    FrozenDataList[Item],
+    BaseHoldObject[FrozenListLike.Data[Item]],
+    FrozenListLike[Item],
 ):
     """Provide usable frozen list-like with slots."""
 

{datahold-4.0.0.dev7 → datahold-4.0.0.dev9}/tests/test_FrozenHoldSet.py

@@ -8,12 +8,12 @@ import unittest
 from collections import abc
 from typing import Any, Self
 
-from datahold import BaseHoldObject, FrozenDataSet
+from datahold import BaseHoldObject, FrozenSetLike
 
 
 class FrozenHoldSet[Item: abc.Hashable](
-    BaseHoldObject[FrozenDataSet.Data[Item]],
-    FrozenDataSet[Item],
+    BaseHoldObject[FrozenSetLike.Data[Item]],
+    FrozenSetLike[Item],
 ):
     """Provide usable frozen set-like with slots."""
 

{datahold-4.0.0.dev7 → datahold-4.0.0.dev9}/tests/test_HoldDict.py

@@ -8,12 +8,12 @@ import unittest
 from collections import abc
 from typing import Any, Self, cast
 
-from datahold import BaseHoldObject, DataDict
+from datahold import BaseHoldObject, MutableDictLike
 
 
 class HoldDict[Key: abc.Hashable, Value](
-    BaseHoldObject[DataDict.Data[Key, Value]],
-    DataDict[Key, Value],
+    BaseHoldObject[MutableDictLike.Data[Key, Value]],
+    MutableDictLike[Key, Value],
 ):
     """Provide usable mutable dict-like with slots."""
 

{datahold-4.0.0.dev7 → datahold-4.0.0.dev9}/tests/test_HoldList.py

@@ -7,12 +7,12 @@ __all__: list[str] = [
 import unittest
 from typing import Any, Self
 
-from datahold import BaseHoldObject, DataList
+from datahold import BaseHoldObject, MutableListLike
 
 
 class HoldList[Item](
-    BaseHoldObject[DataList.Data[Item]],
-    DataList[Item],
+    BaseHoldObject[MutableListLike.Data[Item]],
+    MutableListLike[Item],
 ):
     """Provide usable mutable list-like with slots."""
 

{datahold-4.0.0.dev7 → datahold-4.0.0.dev9}/tests/test_HoldSet.py

@@ -8,12 +8,12 @@ import unittest
 from collections import abc
 from typing import Any, Self
 
-from datahold import BaseHoldObject, DataSet
+from datahold import BaseHoldObject, MutableSetLike
 
 
 class HoldSet[Item: abc.Hashable](
-    BaseHoldObject[DataSet.Data[Item]],
-    DataSet[Item],
+    BaseHoldObject[MutableSetLike.Data[Item]],
+    MutableSetLike[Item],
 ):
     """Provide usable mutable set-like with slots."""
 

{datahold-4.0.0.dev7 → datahold-4.0.0.dev9}/tests/test_testdata.py

@@ -17,6 +17,7 @@ import io
 import tomllib
 import unittest
 from functools import cached_property
+from importlib import import_module
 from pathlib import Path
 from typing import Any, Self, TypeAliasType, cast, get_args, get_origin
 
@@ -42,14 +43,17 @@ class Lazy(enum.Enum):
         with file.open("rb") as stream:
             return tomllib.load(stream)
 
+    @classmethod
+    def get_import(cls: type[Self], qualname: str) -> type[Any]:
+        module: Any
+        parts: list[str]
+        parts = qualname.split(".")
+        module = import_module(".".join(parts[:-1]))
+        return cast(type[Any], getattr(module, parts[-1]))
+
     @classmethod
     def get_type(cls: type[Self], typename: str) -> type[Any]:
-        ans: Any
-        if typename in collections.abc.__all__:
-            ans = getattr(collections.abc, typename)
-        else:
-            ans = getattr(datahold, typename)
-        return cast(type[Any], ans)
+        return cast(type[Any], getattr(datahold, typename))
 
     @cached_property
     def test_object(self: Self) -> dict[str, Any]:
@@ -102,8 +106,6 @@ class TestCollection(unittest.TestCase):
         typename: str
         for typename in Lazy.lazy.types.keys():
             cls = Lazy.get_type(typename=typename)
-            if cls is None:
-                raise Exception
             self._test_cls(cls)
 
 
@@ -133,7 +135,7 @@ class TestConstructor(unittest.TestCase):
         self.assertIn(info.get("repr"), [None, repr(obj)])
         self.assertIn(info.get("str"), [None, str(obj)])
         for x, y in info.get("parents", {}).items():
-            parenttype = Lazy.get_type(x)
+            parenttype = Lazy.get_import(x)
             self.assertEqual(isinstance(obj, parenttype), y)
 
     def go_types(self: Self, typename: str, /, **kwargs: Any) -> None:
@@ -147,7 +149,7 @@ class TestConstructor(unittest.TestCase):
 
     def test_abstract_classes(self: Self) -> None:
         for typename, kwargs in Lazy.lazy.types.items():
-            with self.subTest(typename=typename):
+            with self.subTest(type=typename):
                 self.go_types(typename, **kwargs)
 
 
@@ -303,7 +305,7 @@ class TestParents(unittest.TestCase):
         if cls is None:
             raise Exception
         for x, y in kwargs.get("parents", {}).items():
-            parenttype = Lazy.get_type(x)
+            parenttype = Lazy.get_import(x)
             self.assertEqual(issubclass(cls, parenttype), y, x)
 
     def test_parents(self: Self) -> None:

datahold-4.0.0.dev9/tests/testdata.toml

@@ -0,0 +1,145 @@
+[test_object]
+METHODS = [
+    "__format__",
+    "__str__",
+]
+
+[types.Collection]
+dirData = [
+    "__contains__",
+    "__iter__",
+    "__len__",
+]
+
+[types.Collection.parents]
+"collections.abc.Collection" = true
+"collections.abc.Hashable" = true
+
+[types.DictLike]
+dirData = []
+
+[types.DictLike.parents]
+"collections.abc.Hashable" = false
+"collections.abc.Mapping" = true
+
+[types.FrozenDictLike]
+Data = "frozendict"
+dirData = []
+isabstract = true
+
+[types.FrozenDictLike.parents]
+"datahold.DictLike" = true
+"datahold.FrozenMapping" = true
+
+[types.FrozenListLike]
+Data = "tuple"
+dirData = []
+isabstract = true
+
+[types.FrozenListLike.parents]
+
+[types.FrozenMapping]
+dirData = []
+
+[types.FrozenMapping.parents]
+"collections.abc.Hashable" = true
+"datahold.Mapping" = true
+
+[types.FrozenSetLike]
+Data = "frozenset"
+dirData = []
+isabstract = true
+
+[types.FrozenSetLike.parents]
+
+[types.ListLike]
+dirData = []
+
+[types.ListLike.parents]
+"collections.abc.Hashable" = false
+"collections.abc.Sequence" = true
+
+[types.Mapping]
+dirData = []
+
+[types.Mapping.parents]
+"collections.abc.Hashable" = false
+"datahold.Collection" = true
+
+[types.MutableDictLike]
+Data = "frozendict"
+dirData = []
+isabstract = true
+n_type_params = 2
+
+[types.MutableDictLike.constructor.empty]
+valid = false
+
+[types.MutableDictLike.parents]
+"collections.abc.MutableMapping" = true
+"datahold.DictLike" = true
+"datahold.Mapping" = true
+
+[types.MutableListLike]
+Data = "tuple"
+dirData = []
+isabstract = true
+n_type_params = 1
+
+[types.MutableListLike.constructor.empty]
+valid = false
+
+[types.MutableListLike.parents]
+"collections.abc.MutableSequence" = true
+"collections.abc.Sequence" = true
+"datahold.ListLike" = true
+
+[types.MutableSetLike]
+Data = "frozenset"
+dirData = []
+isabstract = true
+n_type_params = 1
+
+[types.MutableSetLike.constructor.empty]
+valid = false
+
+[types.MutableSetLike.parents]
+"collections.abc.MutableSet" = true
+"collections.abc.Set" = true
+"datahold.SetLike" = true
+
+[types.Sequence]
+dirData = [
+    "__contains__",
+    "__getitem__",
+    "__iter__",
+    "__len__",
+]
+
+[types.Sequence.parents]
+"collections.abc.Hashable" = true
+"datahold.Collection" = true
+
+[types.Set]
+dirData = [
+    "__contains__",
+    "__iter__",
+    "__len__",
+]
+
+[types.Set.parents]
+"collections.abc.Hashable" = false
+"datahold.Collection" = true
+
+[types.SetLike]
+dirData = []
+
+[types.SetLike.parents]
+"collections.abc.Hashable" = false
+"collections.abc.Set" = true
+"datahold.Set" = true
+
+[varia]
+HOLD_TYPES = [
+    "BaseHoldObject",
+]

datahold-4.0.0.dev7/tests/testdata.toml

@@ -1,136 +0,0 @@
-[test_object]
-METHODS = [
-    "__format__",
-    "__str__",
-]
-
-[types.BaseDataAbstractSet]
-dirData = [
-    "__contains__",
-    "__iter__",
-    "__len__",
-]
-
-[types.BaseDataAbstractSet.parents]
-BaseDataCollection = true
-Hashable = false
-
-[types.BaseDataCollection]
-dirData = [
-    "__contains__",
-    "__iter__",
-    "__len__",
-]
-
-[types.BaseDataCollection.parents]
-Collection = true
-Hashable = true
-
-[types.BaseDataDict]
-dirData = []
-
-[types.BaseDataDict.parents]
-Hashable = false
-Mapping = true
-
-[types.BaseDataList]
-dirData = []
-
-[types.BaseDataList.parents]
-Hashable = false
-Sequence = true
-
-[types.BaseDataMapping]
-dirData = []
-
-[types.BaseDataMapping.parents]
-BaseDataCollection = true
-Hashable = false
-
-[types.BaseDataSequence]
-dirData = [
-    "__contains__",
-    "__getitem__",
-    "__iter__",
-    "__len__",
-]
-
-[types.BaseDataSequence.parents]
-BaseDataCollection = true
-Hashable = true
-
-[types.BaseDataSet]
-dirData = []
-
-[types.BaseDataSet.parents]
-BaseDataAbstractSet = true
-Hashable = false
-Set = true
-
-[types.DataDict]
-Data = "frozendict"
-dirData = []
-isabstract = true
-n_type_params = 2
-
-[types.DataDict.constructor.empty]
-valid = false
-
-[types.DataDict.parents]
-BaseDataDict = true
-BaseDataMapping = true
-MutableMapping = true
-
-[types.DataList]
-Data = "tuple"
-dirData = []
-isabstract = true
-n_type_params = 1
-
-[types.DataList.constructor.empty]
-valid = false
-
-[types.DataList.parents]
-BaseDataList = true
-MutableSequence = true
-Sequence = true
-
-[types.DataSet]
-Data = "frozenset"
-dirData = []
-isabstract = true
-n_type_params = 1
-
-[types.DataSet.constructor.empty]
-valid = false
-
-[types.DataSet.parents]
-BaseDataSet = true
-MutableSet = true
-Set = true
-
-[types.FrozenDataDict]
-Data = "frozendict"
-dirData = []
-isabstract = true
-
-[types.FrozenDataDict.parents]
-
-[types.FrozenDataList]
-Data = "tuple"
-dirData = []
-isabstract = true
-
-[types.FrozenDataList.parents]
-
-[types.FrozenDataSet]
-Data = "frozenset"
-dirData = []
-isabstract = true
-
-[types.FrozenDataSet.parents]
-
-[varia]
-HOLD_TYPES = [
-    "BaseHoldObject",
-]