datahold 1.2.1__tar.gz → 1.3.0.dev0__tar.gz

{datahold-1.2.1/src/datahold.egg-info → datahold-1.3.0.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datahold
-Version: 1.2.1
+Version: 1.3.0.dev0
 Summary: This project wraps common mutable datastructures for inheritance with modification.
 Author-email: Johannes <johannes.programming@gmail.com>
 License: The MIT License (MIT)
@@ -28,7 +28,7 @@ Project-URL: Download, https://pypi.org/project/datahold/#files
 Project-URL: Index, https://pypi.org/project/datahold/
 Project-URL: Source, https://github.com/johannes-programming/datahold/
 Project-URL: Website, http://datahold.johannes-programming.online/
-Classifier: Development Status :: 5 - Production/Stable
+Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
@@ -41,6 +41,7 @@ Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
 Requires-Dist: datarepr<2,>=1.0
+Requires-Dist: frozendict<3,>=2.4.6
 Requires-Dist: scaevola<2,>=1.0.11
 Requires-Dist: setdoc<2,>=1.2
 Requires-Dist: unhash<2,>=1.0

{datahold-1.2.1 → datahold-1.3.0.dev0}/pyproject.toml

@@ -9,7 +9,7 @@ authors = [
     { email = "johannes.programming@gmail.com", name = "Johannes" },
 ]
 classifiers = [
-    "Development Status :: 5 - Production/Stable",
+    "Development Status :: 3 - Alpha",
     "Intended Audience :: Developers",
     "License :: OSI Approved :: MIT License",
     "Natural Language :: English",
@@ -21,6 +21,7 @@ classifiers = [
 ]
 dependencies = [
     "datarepr>=1.0,<2",
+    "frozendict>=2.4.6,<3",
     "scaevola>=1.0.11,<2",
     "setdoc>=1.2,<2",
     "unhash>=1.0,<2",
@@ -30,7 +31,7 @@ keywords = []
 name = "datahold"
 readme = "README.rst"
 requires-python = ">=3.11"
-version = "1.2.1"
+version = "1.3.0.dev0"
 
 [project.license]
 file = "LICENSE.txt"

datahold-1.3.0.dev0/src/datahold/_utils/deco/__init__.py

@@ -0,0 +1,3 @@
+from datahold._utils.deco.dataDeco import dataDeco
+from datahold._utils.deco.funcDeco import funcDeco
+from datahold._utils.deco.initDeco import initDeco

datahold-1.3.0.dev0/src/datahold/_utils/deco/dataDeco.py

@@ -0,0 +1,46 @@
+import abc
+from functools import partial
+from typing import *
+
+import setdoc
+
+__all__ = ["dataDeco"]
+
+
+def dataDeco() -> partial:
+    return update
+
+
+def update(
+    Target: type,
+) -> type:
+    Target.data = makeData(Target)
+    abc.update_abstractmethods(Target)
+    return Target
+
+
+def makeData(Target: type) -> property:
+    Frozen: type = Target.__annotations__["data"]
+
+    def fget(self: Self) -> Any:
+        return self._data
+
+    adapt(fget, Target=Target)
+
+    def fset(self: Self, value: Any) -> None:
+        self._data = Frozen(value)
+
+    adapt(fset, Target=Target)
+
+    ans: property = property(
+        fget=fget,
+        fset=fset,
+        doc=setdoc.getbasicdoc("data"),
+    )
+    return ans
+
+
+def adapt(func: Callable, *, Target: type) -> None:
+    func.__module__ = Target.__module__
+    func.__qualname__ = Target.__qualname__ + ".data." + func.__name__
+    func.__name__ = "data"

datahold-1.3.0.dev0/src/datahold/_utils/deco/funcDeco.py

@@ -0,0 +1,62 @@
+import abc
+from functools import partial
+from types import FunctionType
+from typing import *
+
+from datahold._utils.deco.wrapping import wrap
+
+__all__ = ["funcDeco"]
+
+
+def funcDeco(*args: str, **kwargs: type) -> partial:
+    return partial(update, funcnames=args, **kwargs)
+
+
+def update(
+    Target: type,
+    *,
+    funcnames: str,
+    Frozen: type,
+    NonFrozen: type,
+) -> type:
+    name: str
+    for name in funcnames:
+        setupFunc(
+            Target=Target,
+            name=name,
+            Frozen=Frozen,
+            NonFrozen=NonFrozen,
+        )
+    abc.update_abstractmethods(Target)
+    return Target
+
+
+def setupFunc(
+    *,
+    Target: type,
+    NonFrozen: type,
+    Frozen: type,
+    name: str,
+) -> None:
+    old: Callable = getattr(NonFrozen, name)
+    new: FunctionType = makeFunc(
+        old=old,
+        NonFrozen=NonFrozen,
+        Frozen=Frozen,
+    )
+    new.__module__ = Target.__module__
+    new.__name__ = name
+    new.__qualname__ = Target.__qualname__ + "." + name
+    setattr(Target, name, new)
+
+
+def makeFunc(*, old: FunctionType, NonFrozen: type, Frozen: type) -> Any:
+    def new(self: Self, *args: Any, **kwargs: Any) -> Any:
+        data: Any = NonFrozen(self.data)
+        ans: Any = old(data, *args, **kwargs)
+        self.data = Frozen(data)
+        return ans
+
+    wrap(new=new, old=old)
+
+    return new

datahold-1.3.0.dev0/src/datahold/_utils/deco/initDeco.py

@@ -0,0 +1,45 @@
+import abc
+from functools import partial
+from types import FunctionType
+from typing import *
+
+from datahold._utils.deco.wrapping import wrap
+
+__all__ = ["initDeco"]
+
+
+def initDeco(**kwargs: type) -> partial:
+    return partial(update, **kwargs)
+
+
+def update(
+    Target: type,
+    *,
+    Frozen: type,
+    NonFrozen: type,
+) -> type:
+    setupInit(
+        Target=Target,
+        Frozen=Frozen,
+        NonFrozen=NonFrozen,
+    )
+    Target.__annotations__ = dict(data=Frozen)
+    abc.update_abstractmethods(Target)
+    return Target
+
+
+def setupInit(*, Target: type, **kwargs: type) -> None:
+    new: FunctionType = makeInit(**kwargs)
+    new.__module__ = Target.__module__
+    new.__name__ = "__init__"
+    new.__qualname__ = Target.__qualname__ + ".__init__"
+    Target.__init__ = new
+
+
+def makeInit(*, Frozen: type, NonFrozen: type) -> FunctionType:
+    def new(self: Self, *args: Any, **kwargs: Any) -> None:
+        self.data = Frozen(*args, **kwargs)
+
+    wrap(new=new, old=NonFrozen.__init__)
+
+    return new

datahold-1.2.1/src/datahold/_utils/deco/util.py → datahold-1.3.0.dev0/src/datahold/_utils/deco/wrapping.py

@@ -2,35 +2,15 @@ import inspect as ins
 from types import FunctionType
 from typing import *
 
-__all__ = [
-    "getAnnotationsDict",
-    "getNonEmpty",
-    "wrap",
-]
-
-
-def getAnnotationsDict(sig: ins.Signature) -> dict:
-    ans: dict = dict()
-    p: ins.Parameter
-    for p in sig.parameters.values():
-        ans[p.name] = p.annotation
-    ans["return"] = sig.return_annotation
-    return ans
-
-
-def getNonEmpty(value: Any, backup: Any = Any) -> Any:
-    if value is ins.Parameter.empty:
-        return backup
-    else:
-        return value
+__all__ = ["wrap"]
 
 
 def wrap(
     *,
     old: Callable,
     new: FunctionType,
-    isinit: bool,
 ) -> ins.Signature:
+    new.__doc__ = old.__doc__
     try:
         oldsig: ins.Signature = ins.signature(old)
     except ValueError:
@@ -47,7 +27,23 @@ def wrap(
             a = getNonEmpty(p.annotation)
         q = p.replace(annotation=a)
         params.append(q)
-    a = None if isinit else Any
+    a = ins.signature(new).return_annotation
     a = getNonEmpty(oldsig.return_annotation, backup=a)
     new.__signature__ = ins.Signature(params, return_annotation=a)
     new.__annotations__ = getAnnotationsDict(new.__signature__)
+
+
+def getAnnotationsDict(sig: ins.Signature) -> dict:
+    ans: dict = dict()
+    p: ins.Parameter
+    for p in sig.parameters.values():
+        ans[p.name] = p.annotation
+    ans["return"] = sig.return_annotation
+    return ans
+
+
+def getNonEmpty(value: Any, backup: Any = Any) -> Any:
+    if value is ins.Parameter.empty:
+        return backup
+    else:
+        return value

datahold-1.3.0.dev0/src/datahold/core/DataABC.py

@@ -0,0 +1,26 @@
+from abc import ABCMeta, abstractmethod
+from typing import *
+
+import setdoc
+from unhash import unhash
+
+__all__ = ["DataABC"]
+
+
+class DataABC(metaclass=ABCMeta):
+    __slots__ = ()
+
+    __hash__ = unhash
+
+    @abstractmethod
+    @setdoc.basic
+    def __init__(self: Self, *args: Any, **kwargs: Any) -> None: ...
+
+    @classmethod
+    def __subclasshook__(cls: type, other: type, /) -> bool:
+        "This magic classmethod can be overwritten for a custom subclass check."
+        return NotImplemented
+
+    @property
+    @abstractmethod
+    def data(self: Self) -> Any: ...

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

@@ -0,0 +1,47 @@
+import collections
+from typing import *
+
+from frozendict import frozendict
+
+from datahold._utils import deco
+from datahold.core.DataABC import DataABC
+
+
+@deco.funcDeco(
+    "__contains__",
+    "__delitem__",
+    "__eq__",
+    "__format__",
+    "__ge__",
+    "__getitem__",
+    "__gt__",
+    "__ior__",
+    "__iter__",
+    "__le__",
+    "__len__",
+    "__lt__",
+    "__or__",
+    "__repr__",
+    "__reversed__",
+    "__ror__",
+    "__setitem__",
+    "__str__",
+    "clear",
+    "copy",
+    "get",
+    "items",
+    "keys",
+    "pop",
+    "popitem",
+    "setdefault",
+    "update",
+    "values",
+    Frozen=frozendict,
+    NonFrozen=dict,
+)
+@deco.initDeco(
+    Frozen=frozendict,
+    NonFrozen=dict,
+)
+class DataDict(DataABC, collections.abc.MutableMapping):
+    __slots__ = ()

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

@@ -0,0 +1,50 @@
+import collections
+from typing import *
+
+from datahold._utils import deco
+from datahold.core.DataABC import DataABC
+
+__all__ = ["DataList"]
+
+
+@deco.funcDeco(
+    "__add__",
+    "__contains__",
+    "__delitem__",
+    "__eq__",
+    "__format__",
+    "__ge__",
+    "__getitem__",
+    "__gt__",
+    "__iadd__",
+    "__imul__",
+    "__iter__",
+    "__le__",
+    "__len__",
+    "__lt__",
+    "__mul__",
+    "__repr__",
+    "__reversed__",
+    "__rmul__",
+    "__setitem__",
+    "__str__",
+    "append",
+    "clear",
+    "copy",
+    "count",
+    "extend",
+    "index",
+    "insert",
+    "pop",
+    "remove",
+    "reverse",
+    "sort",
+    Frozen=tuple,
+    NonFrozen=list,
+)
+@deco.initDeco(
+    Frozen=tuple,
+    NonFrozen=list,
+)
+class DataList(DataABC, collections.abc.MutableSequence):
+    __slots__ = ()

datahold-1.3.0.dev0/src/datahold/core/DataSet.py

@@ -0,0 +1,59 @@
+import collections
+from typing import *
+
+from datahold._utils import deco
+from datahold.core.DataABC import DataABC
+
+__all__ = ["DataSet"]
+
+
+@deco.funcDeco(
+    "__and__",
+    "__contains__",
+    "__eq__",
+    "__format__",
+    "__ge__",
+    "__gt__",
+    "__iand__",
+    "__ior__",
+    "__isub__",
+    "__iter__",
+    "__ixor__",
+    "__le__",
+    "__len__",
+    "__lt__",
+    "__or__",
+    "__rand__",
+    "__repr__",
+    "__ror__",
+    "__rsub__",
+    "__rxor__",
+    "__str__",
+    "__sub__",
+    "__xor__",
+    "add",
+    "clear",
+    "copy",
+    "difference",
+    "difference_update",
+    "discard",
+    "intersection",
+    "intersection_update",
+    "isdisjoint",
+    "issubset",
+    "issuperset",
+    "pop",
+    "remove",
+    "symmetric_difference",
+    "symmetric_difference_update",
+    "union",
+    "update",
+    Frozen=frozenset,
+    NonFrozen=set,
+)
+@deco.initDeco(
+    Frozen=frozenset,
+    NonFrozen=set,
+)
+class DataSet(DataABC, collections.abc.MutableSet):
+    __slots__ = ()

datahold-1.3.0.dev0/src/datahold/core/HoldABC.py

@@ -0,0 +1,9 @@
+from typing import *
+
+from datahold.core.DataABC import DataABC
+
+__all__ = ["HoldABC"]
+
+
+class HoldABC(DataABC):
+    __slots__ = ("_data",)

datahold-1.3.0.dev0/src/datahold/core/HoldDict.py

@@ -0,0 +1,17 @@
+from typing import *
+
+from frozendict import frozendict
+
+from datahold._utils import deco
+from datahold.core.DataDict import DataDict
+from datahold.core.HoldABC import HoldABC
+
+__all__ = [
+    "HoldDict",
+]
+
+
+@deco.dataDeco()
+class HoldDict(DataDict, HoldABC):
+    __slots__ = ()
+    data: frozendict

datahold-1.3.0.dev0/src/datahold/core/HoldList.py

@@ -0,0 +1,15 @@
+from typing import *
+
+from datahold._utils import deco
+from datahold.core.DataList import DataList
+from datahold.core.HoldABC import HoldABC
+
+__all__ = [
+    "HoldList",
+]
+
+
+@deco.dataDeco()
+class HoldList(DataList, HoldABC):
+    __slots__ = ()
+    data: tuple

datahold-1.3.0.dev0/src/datahold/core/HoldSet.py

@@ -0,0 +1,15 @@
+from typing import *
+
+from datahold._utils import deco
+from datahold.core.DataSet import DataSet
+from datahold.core.HoldABC import HoldABC
+
+__all__ = [
+    "HoldSet",
+]
+
+
+@deco.dataDeco()
+class HoldSet(DataSet, HoldABC):
+    __slots__ = ()
+    data: frozenset

datahold-1.3.0.dev0/src/datahold/core/OkayABC.py

@@ -0,0 +1,84 @@
+import collections
+from abc import ABCMeta, abstractmethod
+from typing import *
+
+import setdoc
+from datarepr import datarepr
+from scaevola import Scaevola
+
+from datahold.core.HoldABC import HoldABC
+
+__all__ = [
+    "OkayABC",
+]
+
+
+class OkayABC(Scaevola, HoldABC):
+    __slots__ = ()
+
+    @setdoc.basic
+    def __bool__(self: Self, /) -> bool:
+        return bool(self._data)
+
+    @setdoc.basic
+    def __contains__(self: Self, other: Any, /) -> bool:
+        return other in self._data
+
+    @setdoc.basic
+    def __eq__(self: Self, other: Any, /) -> bool:
+        if type(self) is type(other):
+            return self._data == other._data
+        try:
+            opp: Self = type(self)(other)
+        except:
+            return False
+        else:
+            return self._data == opp._data
+
+    @setdoc.basic
+    def __format__(self: Self, format_spec: Any = "", /) -> str:
+        return format(self._data, str(format_spec))
+
+    @setdoc.basic
+    def __getitem__(self: Self, key: Any, /) -> Any:
+        return self._data[key]
+
+    @setdoc.basic
+    def __gt__(self: Self, other: Any, /) -> bool:
+        return not (self == other) and (self >= other)
+
+    @setdoc.basic
+    def __iter__(self: Self, /) -> Iterator:
+        return iter(self._data)
+
+    @setdoc.basic
+    def __le__(self: Self, other: Any, /) -> bool:
+        return self._data <= type(self._data)(other)
+
+    @setdoc.basic
+    def __len__(self: Self, /) -> int:
+        return len(self._data)
+
+    @setdoc.basic
+    def __lt__(self: Self, other: Any, /) -> bool:
+        return not (self == other) and (self <= other)
+
+    @setdoc.basic
+    def __ne__(self: Self, other: Any, /) -> bool:
+        return not (self == other)
+
+    @setdoc.basic
+    def __repr__(self: Self, /) -> str:
+        return datarepr(type(self).__name__, self._data)
+
+    @setdoc.basic
+    def __reversed__(self: Self, /) -> reversed:
+        return reversed(self._data)
+
+    @setdoc.basic
+    def __str__(self: Self, /) -> str:
+        return repr(self)
+
+    @setdoc.basic
+    def copy(self: Self, /) -> Self:
+        return type(self)(self.data)

datahold-1.3.0.dev0/src/datahold/core/OkayDict.py

@@ -0,0 +1,47 @@
+import collections
+from typing import *
+
+import setdoc
+from frozendict import frozendict
+
+from datahold.core.HoldDict import HoldDict
+from datahold.core.OkayABC import OkayABC
+
+__all__ = [
+    "OkayDict",
+]
+
+
+class OkayDict(OkayABC, HoldDict):
+    __slots__ = ()
+
+    data: frozendict
+
+    @setdoc.basic
+    def __init__(self: Self, data: Iterable = (), /, **kwargs: Any) -> None:
+        self.data = dict(data, **kwargs)
+
+    @setdoc.basic
+    def __or__(self: Self, other: Any, /) -> Self:
+        return type(self)(self._data | dict(other))
+
+    @classmethod
+    def fromkeys(cls: type, iterable: Iterable, value: Any = None, /) -> Self:
+        "This classmethod creates a new instance with keys from iterable and values set to value."
+        return cls(dict.fromkeys(iterable, value))
+
+    def get(self: Self, /, *args: Any) -> Any:
+        "This method returns self[key] if key is in the dictionary, and default otherwise."
+        return self._data.get(*args)
+
+    def items(self: Self, /) -> collections.abc.ItemsView:
+        "This method returns a view of the items of the current instance."
+        return self._data.items()
+
+    def keys(self: Self, /) -> collections.abc.KeysView:
+        "This method returns a view of the keys of the current instance."
+        return self._data.keys()
+
+    def values(self: Self, /) -> collections.abc.ValuesView:
+        "This method returns a view of the values of the current instance."
+        return self._data.values()

datahold-1.3.0.dev0/src/datahold/core/OkayList.py

@@ -0,0 +1,39 @@
+from typing import *
+
+import setdoc
+
+from datahold.core.HoldList import HoldList
+from datahold.core.OkayABC import OkayABC
+
+__all__ = [
+    "OkayList",
+]
+
+
+class OkayList(OkayABC, HoldList):
+    __slots__ = ()
+    data: tuple
+
+    @setdoc.basic
+    def __add__(self: Self, other: Any, /) -> Self:
+        return type(self)(self._data + list(other))
+
+    @setdoc.basic
+    def __init__(self: Self, data: Iterable = ()) -> None:
+        self.data = data
+
+    @setdoc.basic
+    def __mul__(self: Self, value: SupportsIndex, /) -> Self:
+        return type(self)(self.data * value)
+
+    @setdoc.basic
+    def __rmul__(self: Self, value: SupportsIndex, /) -> Self:
+        return self * value
+
+    def count(self: Self, value: Any, /) -> int:
+        "This method returns the number of occurences of value."
+        return self._data.count(value)
+
+    def index(self: Self, /, *args: Any) -> int:
+        "This method returns the index of the first occurence of value, or raises a ValueError if value is not present."
+        return self._data.index(*args)