datahold 3.0.2__tar.gz → 3.1.0.dev0__tar.gz

{datahold-3.0.2/src/datahold.egg-info → datahold-3.1.0.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datahold
-Version: 3.0.2
+Version: 3.1.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
@@ -44,6 +44,7 @@ Requires-Dist: cmp3<2,>=1.0
 Requires-Dist: copyable<2,>=1.0
 Requires-Dist: datarepr<2,>=1.0
 Requires-Dist: frozendict<3,>=2.4.6
+Requires-Dist: namings<2,>=1.0
 Requires-Dist: setdoc<2,>=1.2.8
 Dynamic: license-file
 

{datahold-3.0.2 → datahold-3.1.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",
@@ -24,6 +24,7 @@ dependencies = [
     "copyable>=1.0,<2",
     "datarepr>=1.0,<2",
     "frozendict>=2.4.6,<3",
+    "namings>=1.0,<2",
     "setdoc>=1.2.8,<2",
 ]
 description = "This project wraps common mutable datastructures for inheritance with modification."
@@ -31,7 +32,7 @@ keywords = []
 name = "datahold"
 readme = "README.rst"
 requires-python = ">=3.11"
-version = "3.0.2"
+version = "3.1.0.dev0"
 
 [project.license]
 file = "LICENSE.txt"

datahold-3.1.0.dev0/src/datahold/core/BaseDataNaming.py

@@ -0,0 +1,123 @@
+import collections
+from abc import abstractmethod
+from typing import *
+
+from namings import FrozenNaming, Naming
+
+from datahold._utils.wrapping import wraps
+
+from .BaseDataObject import BaseDataObject
+
+__all__ = ["BaseDataNaming"]
+
+Value = TypeVar("Value")
+
+
+class BaseDataNaming(
+    BaseDataObject,
+    collections.abc.Mapping[str, Value],
+):
+    data: FrozenNaming[Value]
+    __slots__ = ()
+
+    @wraps(Naming[Value])
+    def __contains__(self: Self, *args: Any, **kwargs: Any) -> Any:
+        "This doc string is overwritten together with the signature to match the original as closely as possible."
+        return Naming[Value](self.data).__contains__(*args, **kwargs)
+
+    @wraps(Naming[Value])
+    def __eq__(self: Self, *args: Any, **kwargs: Any) -> Any:
+        "This doc string is overwritten together with the signature to match the original as closely as possible."
+        return Naming[Value](self.data).__eq__(*args, **kwargs)
+
+    @wraps(Naming[Value])
+    def __format__(self: Self, *args: Any, **kwargs: Any) -> Any:
+        "This doc string is overwritten together with the signature to match the original as closely as possible."
+        return Naming[Value](self.data).__format__(*args, **kwargs)
+
+    @wraps(Naming[Value])
+    def __ge__(self: Self, *args: Any, **kwargs: Any) -> Any:
+        "This doc string is overwritten together with the signature to match the original as closely as possible."
+        return Naming[Value](self.data).__ge__(*args, **kwargs)
+
+    @wraps(Naming[Value])
+    def __getitem__(self: Self, *args: Any, **kwargs: Any) -> Any:
+        "This doc string is overwritten together with the signature to match the original as closely as possible."
+        return Naming[Value](self.data).__getitem__(*args, **kwargs)
+
+    @wraps(Naming[Value])
+    def __gt__(self: Self, *args: Any, **kwargs: Any) -> Any:
+        "This doc string is overwritten together with the signature to match the original as closely as possible."
+        return Naming[Value](self.data).__gt__(*args, **kwargs)
+
+    @abstractmethod
+    @wraps(Naming[Value])
+    def __init__(self: Self, *args: Any, **kwargs: Any) -> None:
+        "This doc string is overwritten together with the signature to match the original as closely as possible."
+        ...
+
+    @wraps(Naming[Value])
+    def __iter__(self: Self, *args: Any, **kwargs: Any) -> Any:
+        "This doc string is overwritten together with the signature to match the original as closely as possible."
+        return Naming[Value](self.data).__iter__(*args, **kwargs)
+
+    @wraps(Naming[Value])
+    def __le__(self: Self, *args: Any, **kwargs: Any) -> Any:
+        "This doc string is overwritten together with the signature to match the original as closely as possible."
+        return Naming[Value](self.data).__le__(*args, **kwargs)
+
+    @wraps(Naming[Value])
+    def __len__(self: Self, *args: Any, **kwargs: Any) -> Any:
+        "This doc string is overwritten together with the signature to match the original as closely as possible."
+        return Naming[Value](self.data).__len__(*args, **kwargs)
+
+    @wraps(Naming[Value])
+    def __lt__(self: Self, *args: Any, **kwargs: Any) -> Any:
+        "This doc string is overwritten together with the signature to match the original as closely as possible."
+        return Naming[Value](self.data).__lt__(*args, **kwargs)
+
+    @wraps(Naming[Value])
+    def __or__(self: Self, *args: Any, **kwargs: Any) -> Any:
+        "This doc string is overwritten together with the signature to match the original as closely as possible."
+        return Naming[Value](self.data).__or__(*args, **kwargs)
+
+    @wraps(Naming[Value])
+    def __repr__(self: Self, *args: Any, **kwargs: Any) -> Any:
+        "This doc string is overwritten together with the signature to match the original as closely as possible."
+        return Naming[Value](self.data).__repr__(*args, **kwargs)
+
+    @wraps(Naming[Value])
+    def __reversed__(self: Self, *args: Any, **kwargs: Any) -> Any:
+        "This doc string is overwritten together with the signature to match the original as closely as possible."
+        return Naming[Value](self.data).__reversed__(*args, **kwargs)
+
+    @wraps(Naming[Value])
+    def __str__(self: Self, *args: Any, **kwargs: Any) -> Any:
+        "This doc string is overwritten together with the signature to match the original as closely as possible."
+        return Naming[Value](self.data).__str__(*args, **kwargs)
+
+    @classmethod
+    @wraps(Naming[Value])
+    def fromkeys(cls: type[Self], *args: Any, **kwargs: Any) -> Any:
+        "This doc string is overwritten together with the signature to match the original as closely as possible."
+        return cls[Value](Naming[Value].fromkeys(*args, **kwargs))
+
+    @wraps(Naming[Value])
+    def get(self: Self, *args: Any, **kwargs: Any) -> Any:
+        "This doc string is overwritten together with the signature to match the original as closely as possible."
+        return Naming[Value](self.data).get(*args, **kwargs)
+
+    @wraps(Naming[Value])
+    def items(self: Self, *args: Any, **kwargs: Any) -> Any:
+        "This doc string is overwritten together with the signature to match the original as closely as possible."
+        return Naming[Value](self.data).items(*args, **kwargs)
+
+    @wraps(Naming[Value])
+    def keys(self: Self, *args: Any, **kwargs: Any) -> Any:
+        "This doc string is overwritten together with the signature to match the original as closely as possible."
+        return Naming[Value](self.data).keys(*args, **kwargs)
+
+    @wraps(Naming[Value])
+    def values(self: Self, *args: Any, **kwargs: Any) -> Any:
+        "This doc string is overwritten together with the signature to match the original as closely as possible."
+        return Naming[Value](self.data).values(*args, **kwargs)

datahold-3.1.0.dev0/src/datahold/core/BaseHoldNaming.py

@@ -0,0 +1,15 @@
+from typing import *
+
+from namings import FrozenNaming
+
+from .BaseDataNaming import BaseDataNaming
+from .BaseHoldObject import BaseHoldObject
+
+__all__ = ["BaseHoldNaming"]
+
+Value = TypeVar("Value")
+
+
+class BaseHoldNaming(BaseHoldObject, BaseDataNaming[Value]):
+    data: FrozenNaming[Value]
+    __slots__ = ()

datahold-3.1.0.dev0/src/datahold/core/DataNaming.py

@@ -0,0 +1,105 @@
+import collections
+from typing import *
+
+import setdoc
+from namings import FrozenNaming, Naming
+
+from datahold._utils.wrapping import wraps
+
+from .BaseDataNaming import BaseDataNaming
+from .DataObject import DataObject
+
+__all__ = ["DataNaming"]
+
+Value = TypeVar("Value")
+
+
+class DataNaming(
+    DataObject, BaseDataNaming[Value], collections.abc.MutableMapping[str, Value]
+):
+    data: FrozenNaming[Value]
+    __slots__ = ()
+
+    @wraps(Naming[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: Naming[Value]
+        data = Naming[Value](self.data)
+        ans = data.__delitem__(*args, **kwargs)
+        self.data = FrozenNaming[Value](data)
+        return ans
+
+    @setdoc.basic
+    def __init__(self: Self, data: Any = (), /, **kwargs: Any) -> None:
+        self.data = FrozenNaming[Value](data, **kwargs)
+
+    @wraps(Naming[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: Naming[Value]
+        data = Naming[Value](self.data)
+        ans = data.__ior__(*args, **kwargs)
+        self.data = FrozenNaming[Value](data)
+        return ans
+
+    @wraps(Naming[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: Naming[Value]
+        data = Naming[Value](self.data)
+        ans = data.__setitem__(*args, **kwargs)
+        self.data = FrozenNaming[Value](data)
+        return ans
+
+    @wraps(Naming[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: Naming[Value]
+        data = Naming[Value](self.data)
+        ans = data.clear(*args, **kwargs)
+        self.data = FrozenNaming[Value](data)
+        return ans
+
+    @wraps(Naming[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: Naming[Value]
+        data = Naming[Value](self.data)
+        ans = data.pop(*args, **kwargs)
+        self.data = FrozenNaming[Value](data)
+        return ans
+
+    @wraps(Naming[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: Naming[Value]
+        data = Naming[Value](self.data)
+        ans = data.popitem(*args, **kwargs)
+        self.data = FrozenNaming[Value](data)
+        return ans
+
+    @wraps(Naming[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: Naming[Value]
+        data = Naming[Value](self.data)
+        ans = data.setdefault(*args, **kwargs)
+        self.data = FrozenNaming[Value](data)
+        return ans
+
+    @wraps(Naming[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: Naming[Value]
+        data = Naming[Value](self.data)
+        ans = data.update(*args, **kwargs)
+        self.data = FrozenNaming[Value](data)
+        return ans

datahold-3.1.0.dev0/src/datahold/core/FrozenDataNaming.py

@@ -0,0 +1,15 @@
+from typing import *
+
+from namings import FrozenNaming
+
+from .BaseDataNaming import BaseDataNaming
+from .FrozenDataObject import FrozenDataObject
+
+__all__ = ["FrozenDataNaming"]
+
+Value = TypeVar("Value")
+
+
+class FrozenDataNaming(FrozenDataObject, BaseDataNaming[Value]):
+    data: FrozenNaming[Value]
+    __slots__ = ()

datahold-3.1.0.dev0/src/datahold/core/FrozenHoldNaming.py

@@ -0,0 +1,21 @@
+from typing import *
+
+import setdoc
+from namings import FrozenNaming
+
+from .BaseHoldNaming import BaseHoldNaming
+from .FrozenDataNaming import FrozenDataNaming
+from .FrozenHoldObject import FrozenHoldObject
+
+__all__ = ["FrozenHoldNaming"]
+
+Value = TypeVar("Value")
+
+
+class FrozenHoldNaming(FrozenHoldObject, FrozenDataNaming, BaseHoldNaming[Value]):
+    data: FrozenNaming[Value]
+    __slots__ = ()
+
+    @setdoc.basic
+    def __init__(self: Self, data: Any, /, **kwargs: Any) -> None:
+        self._data = FrozenNaming[Value](data, **kwargs)

datahold-3.1.0.dev0/src/datahold/core/HoldNaming.py

@@ -0,0 +1,26 @@
+from typing import *
+
+import setdoc
+from namings import FrozenNaming
+
+from .BaseHoldNaming import BaseHoldNaming
+from .DataNaming import DataNaming
+from .HoldObject import HoldObject
+
+__all__ = ["HoldNaming"]
+
+Value = TypeVar("Value")
+
+
+class HoldNaming(HoldObject, DataNaming[Value], BaseHoldNaming[Value]):
+    data: FrozenNaming[Value]
+    __slots__ = ()
+
+    @property
+    @setdoc.basic
+    def data(self: Self) -> FrozenNaming[Value]:
+        return self._data
+
+    @data.setter
+    def data(self: Self, value: Any) -> None:
+        self._data = FrozenNaming[Value](value)

{datahold-3.0.2 → datahold-3.1.0.dev0}/src/datahold/tests/test_0.py

@@ -4,6 +4,8 @@ from typing import *
 from datahold import core
 from datahold.core import *
 
+__all__ = ["TestData"]
+
 
 class TestData(unittest.TestCase):
     def test_constructor_abc(self: Self) -> None:
@@ -11,12 +13,15 @@ class TestData(unittest.TestCase):
             core.DataDict.DataDict()
         with self.assertRaises(Exception):
             core.DataList.DataList()
+        with self.assertRaises(Exception):
+            core.DataList.DataNaming()
         with self.assertRaises(Exception):
             core.DataSet.DataSet()
 
     def test_constructor_core(self: Self) -> None:
         core.HoldDict.HoldDict()
         core.HoldList.HoldList()
+        core.HoldNaming.HoldNaming()
         core.HoldSet.HoldSet()
 
     def test_doc(self: Self) -> None:

{datahold-3.0.2 → datahold-3.1.0.dev0}/src/datahold/tests/test_datahold_TestAbstractness.py

@@ -6,18 +6,22 @@ from frozendict import frozendict
 
 from datahold.core.DataDict import DataDict
 from datahold.core.DataList import DataList
+from datahold.core.DataNaming import DataNaming
 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.FrozenDataNaming import FrozenDataNaming
 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.FrozenHoldNaming import FrozenHoldNaming
 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.HoldNaming import HoldNaming
 from datahold.core.HoldSet import HoldSet
 
 __all__ = ["TestAbstractness"]
@@ -29,11 +33,13 @@ class TestAbstractness(unittest.TestCase):
         self.assertTrue(isabstract(DataObject))
         self.assertTrue(isabstract(DataDict))
         self.assertTrue(isabstract(DataList))
+        self.assertTrue(isabstract(DataNaming))
         self.assertTrue(isabstract(DataSet))
 
         self.assertTrue(isabstract(FrozenDataObject))
         self.assertTrue(isabstract(FrozenDataDict))
         self.assertTrue(isabstract(FrozenDataList))
+        self.assertTrue(isabstract(FrozenDataNaming))
         self.assertTrue(isabstract(FrozenDataSet))
 
         # hold
@@ -43,10 +49,12 @@ class TestAbstractness(unittest.TestCase):
     def test_concrete_classes(self: Self) -> None:
         FrozenHoldDict({"a": 1})
         FrozenHoldList([1, 2])
+        FrozenHoldNaming({"a": 1}.items())
         FrozenHoldSet({1, 2})
 
         HoldDict({"a": 1})
         HoldList([1, 2])
+        HoldNaming({"a": 1}.items())
         HoldSet({1, 2})
 
 

{datahold-3.0.2 → datahold-3.1.0.dev0}/src/datahold/tests/test_datahold_TestCopy.py

@@ -1,13 +1,15 @@
 import unittest
 from typing import Any, Self
 
-from frozendict import frozendict
+from namings import Naming
 
 from datahold.core.FrozenHoldDict import FrozenHoldDict
 from datahold.core.FrozenHoldList import FrozenHoldList
+from datahold.core.FrozenHoldNaming import FrozenHoldNaming
 from datahold.core.FrozenHoldSet import FrozenHoldSet
 from datahold.core.HoldDict import HoldDict
 from datahold.core.HoldList import HoldList
+from datahold.core.HoldNaming import HoldNaming
 from datahold.core.HoldSet import HoldSet
 
 __all__ = ["TestCopy"]
@@ -17,6 +19,7 @@ class TestCopy(unittest.TestCase):
     def test_frozen_have_no_copy(self: Self) -> None:
         self.assertFalse(hasattr(FrozenHoldDict({"a": 1}), "copy"))
         self.assertFalse(hasattr(FrozenHoldList([1, 2]), "copy"))
+        self.assertFalse(hasattr(FrozenHoldNaming({"a": 1}.items()), "copy"))
         self.assertFalse(hasattr(FrozenHoldSet({1, 2}), "copy"))
 
     def test_frozen_have_no_copy_2(self: Self) -> None:
@@ -31,6 +34,7 @@ class TestCopy(unittest.TestCase):
         for cls, args in (
             (FrozenHoldDict, ({"a": 1},)),
             (FrozenHoldList, ([1, 2],)),
+            (FrozenHoldNaming, ({"a": 1}.items(),)),
             (FrozenHoldSet, ({1, 2},)),
         ):
             # They must not *define* copy themselves
@@ -56,6 +60,19 @@ class TestCopy(unittest.TestCase):
         d["a"]["x"] = 2
         self.assertEqual(d_copy["a"]["x"], 2)
 
+    def test_naming_copy(self: Self) -> None:
+        d: HoldNaming
+        d_copy: HoldNaming
+        d = HoldNaming({"a": {"x": 1}}.items())
+        d_copy = d.copy()
+        self.assertIsInstance(d_copy, HoldNaming)
+        self.assertIsNot(d_copy, d)
+        self.assertEqual(Naming(d_copy), Naming(d))
+
+        # shallow: inner object is shared
+        d["a"]["x"] = 2
+        self.assertEqual(d_copy["a"]["x"], 2)
+
     def test_list_copy(self: Self) -> None:
         lst: HoldList
         lst_copy: HoldList

{datahold-3.0.2 → datahold-3.1.0.dev0}/src/datahold/tests/test_datahold_TestDataAttribute.py

@@ -2,14 +2,19 @@ import unittest
 from typing import Any, Self
 
 from frozendict import frozendict
+from namings import FrozenNaming
 
 from datahold.core.FrozenHoldDict import FrozenHoldDict
 from datahold.core.FrozenHoldList import FrozenHoldList
+from datahold.core.FrozenHoldNaming import FrozenHoldNaming
 from datahold.core.FrozenHoldSet import FrozenHoldSet
 from datahold.core.HoldDict import HoldDict
 from datahold.core.HoldList import HoldList
+from datahold.core.HoldNaming import HoldNaming
 from datahold.core.HoldSet import HoldSet
 
+__all__ = ["TestDataAttribute"]
+
 
 class TestDataAttribute(unittest.TestCase):
     def test_dict_data_is_immutable_mapping(self: Self) -> None:
@@ -38,6 +43,20 @@ class TestDataAttribute(unittest.TestCase):
             with self.assertRaises(Exception):
                 o.data.append(4)
 
+    def test_naming_data_is_immutable_mapping(self: Self) -> None:
+        f: FrozenHoldNaming
+        m: HoldNaming
+        obj: Any
+        f = FrozenHoldNaming({"a": 1}.items())
+        m = HoldNaming({"a": 1}.items())
+
+        for obj in (f, m):
+            self.assertIsInstance(obj.data, FrozenNaming)
+
+            # try to mutate underlying data
+            with self.assertRaises((TypeError, AttributeError)):
+                obj.data["b"] = 2
+
     def test_set_data_is_frozenset(self: Self) -> None:
         f: FrozenHoldSet
         m: HoldSet

{datahold-3.0.2 → datahold-3.1.0.dev0}/src/datahold/tests/test_datahold_TestFrozenMutability.py

@@ -1,12 +1,13 @@
 import unittest
-from typing import Any, Self
-
-from frozendict import frozendict
+from typing import *
 
 from datahold.core.FrozenHoldDict import FrozenHoldDict
 from datahold.core.FrozenHoldList import FrozenHoldList
+from datahold.core.FrozenHoldNaming import FrozenHoldNaming
 from datahold.core.FrozenHoldSet import FrozenHoldSet
 
+__all__ = ["TestFrozenMutability"]
+
 
 class TestFrozenMutability(unittest.TestCase):
     def test_frozen_dict_cannot_mutate(self: Self) -> None:
@@ -25,6 +26,14 @@ class TestFrozenMutability(unittest.TestCase):
         with self.assertRaises((TypeError, AttributeError)):
             f.pop()
 
+    def test_frozen_naming_cannot_mutate(self: Self) -> None:
+        f: FrozenHoldNaming
+        f = FrozenHoldNaming({"a": 1}.items())
+        with self.assertRaises((TypeError, AttributeError)):
+            f["b"] = 2
+        with self.assertRaises((TypeError, AttributeError)):
+            f.pop("a", None)
+
     def test_frozen_set_cannot_mutate(self: Self) -> None:
         f: FrozenHoldSet
         f = FrozenHoldSet({1, 2, 3})

{datahold-3.0.2 → datahold-3.1.0.dev0}/src/datahold/tests/test_datahold_TestInheritance.py

@@ -1,31 +1,37 @@
 import unittest
 from typing import Self
 
-from frozendict import frozendict
-
 from datahold.core.BaseDataDict import BaseDataDict
 from datahold.core.BaseDataList import BaseDataList
+from datahold.core.BaseDataNaming import BaseDataNaming
 from datahold.core.BaseDataSet import BaseDataSet
 from datahold.core.BaseHoldDict import BaseHoldDict
 from datahold.core.BaseHoldList import BaseHoldList
+from datahold.core.BaseHoldNaming import BaseHoldNaming
 from datahold.core.BaseHoldSet import BaseHoldSet
 from datahold.core.DataDict import DataDict
 from datahold.core.DataList import DataList
+from datahold.core.DataNaming import DataNaming
 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.FrozenDataNaming import FrozenDataNaming
 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.FrozenHoldNaming import FrozenHoldNaming
 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.HoldNaming import HoldNaming
 from datahold.core.HoldObject import HoldObject
 from datahold.core.HoldSet import HoldSet
 
+__all__ = ["TestInheritance"]
+
 
 class TestInheritance(unittest.TestCase):
     def test_dict_inheritance(self: Self) -> None:
@@ -48,6 +54,17 @@ class TestInheritance(unittest.TestCase):
         self.assertTrue(issubclass(DataList, BaseDataList))
         self.assertTrue(issubclass(HoldList, BaseHoldList))
 
+    def test_naming_inheritance(self: Self) -> None:
+        # base → concrete
+        self.assertTrue(issubclass(DataNaming, DataObject))
+        self.assertTrue(issubclass(FrozenDataNaming, FrozenDataObject))
+        self.assertTrue(issubclass(HoldNaming, HoldObject))
+        self.assertTrue(issubclass(FrozenHoldNaming, FrozenHoldObject))
+
+        # non-frozen data inherit from frozen
+        self.assertTrue(issubclass(DataNaming, BaseDataNaming))
+        self.assertTrue(issubclass(HoldNaming, BaseHoldNaming))
+
     def test_set_inheritance(self: Self) -> None:
         self.assertTrue(issubclass(DataSet, DataObject))
         self.assertTrue(issubclass(FrozenDataSet, FrozenDataObject))

{datahold-3.0.2 → datahold-3.1.0.dev0}/src/datahold/tests/test_datahold_TestMutableBehavior.py

@@ -1,15 +1,13 @@
 import unittest
-from typing import Any, Self
+from typing import *
 
-from frozendict import frozendict
-
-from datahold.core.FrozenHoldDict import FrozenHoldDict
-from datahold.core.FrozenHoldList import FrozenHoldList
-from datahold.core.FrozenHoldSet import FrozenHoldSet
 from datahold.core.HoldDict import HoldDict
 from datahold.core.HoldList import HoldList
+from datahold.core.HoldNaming import HoldNaming
 from datahold.core.HoldSet import HoldSet
 
+__all__ = ["TestMutableBehavior"]
+
 
 class TestMutableBehavior(unittest.TestCase):
     def test_hold_dict_mutates_and_syncs_data(self: Self) -> None:
@@ -26,6 +24,13 @@ class TestMutableBehavior(unittest.TestCase):
         self.assertEqual(list(x), [1, 2, 3])
         self.assertEqual(x.data, (1, 2, 3))
 
+    def test_hold_naming_mutates_and_syncs_data(self: Self) -> None:
+        x: HoldNaming
+        x = HoldNaming({"a": 1}.items())
+        x["b"] = 2
+        self.assertEqual(x["b"], 2)
+        self.assertEqual(x.data["b"], 2)
+
     def test_hold_set_mutates_and_syncs_data(self: Self) -> None:
         s: HoldSet
         s = HoldSet({1, 2})

{datahold-3.0.2 → datahold-3.1.0.dev0}/src/datahold/tests/test_datahold_TestProtocols.py

@@ -9,13 +9,13 @@ from collections.abc import (
 from collections.abc import Set as AbstractSet
 from typing import Self
 
-from frozendict import frozendict
-
 from datahold.core.FrozenHoldDict import FrozenHoldDict
 from datahold.core.FrozenHoldList import FrozenHoldList
+from datahold.core.FrozenHoldNaming import FrozenHoldNaming
 from datahold.core.FrozenHoldSet import FrozenHoldSet
 from datahold.core.HoldDict import HoldDict
 from datahold.core.HoldList import HoldList
+from datahold.core.HoldNaming import HoldNaming
 from datahold.core.HoldSet import HoldSet
 
 __all__ = ["TestProtocols"]
@@ -49,6 +49,20 @@ class TestProtocols(unittest.TestCase):
         self.assertIsInstance(m, Sequence)
         self.assertIsInstance(m, MutableSequence)
 
+    def test_naming_protocols_x(self: Self) -> None:
+        x: FrozenHoldNaming
+        x = FrozenHoldNaming({"a": 1}.items())
+
+        self.assertIsInstance(x, Mapping)
+        self.assertNotIsInstance(x, MutableMapping)
+
+    def test_naming_protocols_y(self: Self) -> None:
+        y: HoldNaming
+        y = HoldNaming({"a": 1}.items())
+
+        self.assertIsInstance(y, Mapping)
+        self.assertIsInstance(y, MutableMapping)
+
     def test_set_protocols(self: Self) -> None:
         f: FrozenHoldSet
         m: HoldSet

{datahold-3.0.2 → datahold-3.1.0.dev0/src/datahold.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datahold
-Version: 3.0.2
+Version: 3.1.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
@@ -44,6 +44,7 @@ Requires-Dist: cmp3<2,>=1.0
 Requires-Dist: copyable<2,>=1.0
 Requires-Dist: datarepr<2,>=1.0
 Requires-Dist: frozendict<3,>=2.4.6
+Requires-Dist: namings<2,>=1.0
 Requires-Dist: setdoc<2,>=1.2.8
 Dynamic: license-file
 

{datahold-3.0.2 → datahold-3.1.0.dev0}/src/datahold.egg-info/SOURCES.txt

@@ -13,26 +13,32 @@ src/datahold/_utils/__init__.py
 src/datahold/_utils/wrapping.py
 src/datahold/core/BaseDataDict.py
 src/datahold/core/BaseDataList.py
+src/datahold/core/BaseDataNaming.py
 src/datahold/core/BaseDataObject.py
 src/datahold/core/BaseDataSet.py
 src/datahold/core/BaseHoldDict.py
 src/datahold/core/BaseHoldList.py
+src/datahold/core/BaseHoldNaming.py
 src/datahold/core/BaseHoldObject.py
 src/datahold/core/BaseHoldSet.py
 src/datahold/core/DataDict.py
 src/datahold/core/DataList.py
+src/datahold/core/DataNaming.py
 src/datahold/core/DataObject.py
 src/datahold/core/DataSet.py
 src/datahold/core/FrozenDataDict.py
 src/datahold/core/FrozenDataList.py
+src/datahold/core/FrozenDataNaming.py
 src/datahold/core/FrozenDataObject.py
 src/datahold/core/FrozenDataSet.py
 src/datahold/core/FrozenHoldDict.py
 src/datahold/core/FrozenHoldList.py
+src/datahold/core/FrozenHoldNaming.py
 src/datahold/core/FrozenHoldObject.py
 src/datahold/core/FrozenHoldSet.py
 src/datahold/core/HoldDict.py
 src/datahold/core/HoldList.py
+src/datahold/core/HoldNaming.py
 src/datahold/core/HoldObject.py
 src/datahold/core/HoldSet.py
 src/datahold/core/__init__.py

{datahold-3.0.2 → datahold-3.1.0.dev0}/src/datahold.egg-info/requires.txt

@@ -2,4 +2,5 @@ cmp3<2,>=1.0
 copyable<2,>=1.0
 datarepr<2,>=1.0
 frozendict<3,>=2.4.6
+namings<2,>=1.0
 setdoc<2,>=1.2.8