python-dictattr 0.0.4__tar.gz → 0.0.5__tar.gz

{python_dictattr-0.0.4 → python_dictattr-0.0.5}/PKG-INFO

@@ -1,26 +1,28 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: python-dictattr
-Version: 0.0.4
+Version: 0.0.5
 Summary: Python dictattr.
-Home-page: https://github.com/ChenyangGao/web-mount-packs/tree/main/python-module/python-dictattr
 License: MIT
+License-File: LICENSE
 Keywords: dictattr,attrdict
 Author: ChenyangGao
 Author-email: wosiwujm@gmail.com
-Requires-Python: >=3.11,<4.0
+Requires-Python: >=3.12,<4.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Software Development
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Project-URL: Repository, https://github.com/ChenyangGao/web-mount-packs/tree/main/python-module/python-dictattr
+Project-URL: Homepage, https://github.com/ChenyangGao/python-modules/tree/main/python-dictattr
+Project-URL: Repository, https://github.com/ChenyangGao/python-modules/tree/main/python-dictattr
 Description-Content-Type: text/markdown
 
 # Python dictattr.

python_dictattr-0.0.5/dictattr/__init__.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+# encoding: utf-8
+
+from __future__ import annotations
+
+__author__ = "ChenyangGao <https://chenyanggao.github.io>"
+__version__ = (0, 0, 5)
+__all__ = [
+    "AttrDict", "MapAttr", "MuMapAttr", "DictAttr", "UserDictAttr", "ChainUserDictAttr", 
+    "IntMapAttr", "IntMuMapAttr", "StrMapAttr", "StrMuMapAttr", 
+]
+
+from collections import UserDict
+from collections.abc import Iterator, Mapping, MutableMapping
+from typing import overload, Any, Self, Generic
+from typing import _GenericAlias # type: ignore
+
+
+class DictAttrMixin[K, V](MutableMapping[K, V]):
+
+    def __delattr__(self, name: K, /): # type: ignore
+        try:
+            del self[name]
+        except KeyError as e:
+            raise AttributeError(name) from e
+
+    def __getattr__(self, name: K, /) -> V: # type: ignore
+        try:
+            return self[name]
+        except KeyError as e:
+            raise AttributeError(name) from e
+
+    def __setattr__(self, name: K, value: V, /): # type: ignore
+        try:
+            self[name] = value
+        except KeyError as e:
+            raise AttributeError(name) from e
+
+
+class MapAttrMixin[K, V](Mapping[K, V]):
+    __dict__: dict[K, V] # type: ignore
+
+    def __contains__(self, key, /) -> bool:
+        return key in self.__dict__
+
+    def __getitem__(self, key: K, /) -> V:
+        return self.__dict__[key]
+
+    def __iter__(self, /) -> Iterator[K]:
+        return iter(self.__dict__)
+
+    def __len__(self, /) -> int:
+        return len(self.__dict__)
+
+
+class MuMapAttrMixin[K, V](MapAttrMixin[K, V], MutableMapping[K, V]):
+
+    def __delitem__(self, key: K, /):
+        del self.__dict__[key]
+
+    def __setitem__(self, key: K, val: V, /):
+        self.__dict__[key] = val
+
+
+class ValueMapAttrMixin[K, V](MapAttrMixin[K, V]):
+
+    def __new__(cls, value=None, /, *args, **kwds):
+        if isinstance(value, (tuple, list, Mapping)):
+            args = value, *args
+            value = None
+        for a in args:
+            kwds.update(a)
+        if value is None:
+            value = kwds.get("id")
+        base: Any
+        for base in reversed(cls.__bases__):
+            if not (base is Generic or isinstance(base, _GenericAlias)):
+                break
+        self = base.__new__(cls, value or 0)
+        if kwds:
+            self.__dict__.update(kwds)
+        return self
+
+    def __repr__(self, /) -> str:
+        cls = type(self)
+        return f"{cls.__module__}.{cls.__qualname__}({super().__repr__()}, {self.__dict__!r})"
+
+
+class ValueMuMapAttrMixin[K, V](ValueMapAttrMixin[K, V], MuMapAttrMixin[K, V]):
+    pass
+
+
+class AttrDict[K, V](dict[K, V]):
+
+    def __init__(self, /, *args, **kwds):
+        super().__init__(*args, **kwds)
+        self.__dict__ = self # type: ignore
+
+
+class MapAttr[K, V](MapAttrMixin[K, V]):
+
+    def __init__(self, /, *args, **kwds):
+        self.__dict__: dict[K, V] # type: ignore
+        self.__dict__.update(*args, **kwds)
+
+    def __repr__(self, /) -> str:
+        cls = type(self)
+        return f"{cls.__module__}.{cls.__qualname__}({self.__dict__})"
+
+    @classmethod
+    def of(
+        cls, 
+        d: None | dict[K, V] = None, 
+        /, 
+    ) -> Self:
+        self = cls.__new__(cls)
+        if d is not None:
+            self.__dict__ = d
+        return self
+
+
+class MuMapAttr[K, V](MapAttr[K, V], MuMapAttrMixin[K, V]):
+    pass
+
+
+class DictAttr[K, V](DictAttrMixin[K, V], dict[K, V]):
+    pass
+
+
+class UserDictAttr[K, V](DictAttrMixin[K, V], UserDict[K, V]):
+
+    def __getitem__(self, key, /):
+        d = super().__getitem__(key)
+        if isinstance(d, Mapping) and not isinstance(d, __class__): # type: ignore
+            return type(self)(d)
+        return d
+
+    def __repr__(self, /) -> str:
+        cls = type(self)
+        return f"{cls.__module__}.{cls.__qualname__}.of({self.data!r})"
+
+    @classmethod
+    def of(cls, m: Mapping, /) -> Self:
+        self = cls()
+        self.__dict__["data"] = m
+        return self
+
+
+class ChainDictAttr[K, V](UserDictAttr[K, V | "ChainDictAttr"]):
+
+    def __getitem__(self, key, /) -> V | ChainDictAttr:
+        try:
+            return super().__getitem__(key)
+        except KeyError:
+            d = self.__dict__[key] = type(self)()
+            return d
+
+
+class IntMapAttr[K, V](ValueMapAttrMixin[K, V], int):
+    pass
+
+
+class IntMuMapAttr[K, V](ValueMuMapAttrMixin[K, V], int):
+    pass
+
+
+class StrMapAttr[K, V](ValueMapAttrMixin[K, V], str):
+
+    @overload # type: ignore
+    def __getitem__(self, key: int | slice, /) -> str:
+        ...
+    @overload
+    def __getitem__(self, key: K, /) -> V:
+        ...
+    def __getitem__(self, key: int | slice | K, /) -> str | V:
+        if isinstance(key, (int, slice)):
+            return str.__getitem__(self, key)
+        else:
+            return self.__dict__[key]
+
+    def __iter__(self, /):
+        return str.__iter__(self)
+
+    def __len__(self, /):
+        return str.__len__(self)
+
+
+class StrMuMapAttr[K, V](ValueMuMapAttrMixin[K, V], StrMapAttr[K, V], str):
+    pass
+

{python_dictattr-0.0.4 → python_dictattr-0.0.5}/pyproject.toml

@@ -1,12 +1,12 @@
 [tool.poetry]
 name = "python-dictattr"
-version = "0.0.4"
+version = "0.0.5"
 description = "Python dictattr."
 authors = ["ChenyangGao <wosiwujm@gmail.com>"]
 license = "MIT"
 readme = "readme.md"
-homepage = "https://github.com/ChenyangGao/web-mount-packs/tree/main/python-module/python-dictattr"
-repository = "https://github.com/ChenyangGao/web-mount-packs/tree/main/python-module/python-dictattr"
+homepage = "https://github.com/ChenyangGao/python-modules/tree/main/python-dictattr"
+repository = "https://github.com/ChenyangGao/python-modules/tree/main/python-dictattr"
 keywords = ["dictattr", "attrdict"]
 classifiers = [
     "License :: OSI Approved :: MIT License",
@@ -25,7 +25,7 @@ include = [
 ]
 
 [tool.poetry.dependencies]
-python = "^3.11"
+python = "^3.12"
 
 [build-system]
 requires = ["poetry-core"]

python_dictattr-0.0.4/dictattr/__init__.py

@@ -1,179 +0,0 @@
-#!/usr/bin/env python3
-# encoding: utf-8
-
-from __future__ import annotations
-
-__author__ = "ChenyangGao <https://chenyanggao.github.io>"
-__version__ = (0, 0, 4)
-__all__ = [
-    "odict", "AttrDict", "MapAttr", "MuMapAttr", "DictAttr", 
-    "ChainDictAttr", "UserDictAttr", "PriorityUserDictAttr", 
-]
-
-from collections import UserDict
-from collections.abc import Iterator, Mapping, MutableMapping
-from typing import Generic, Self, TypeVar
-
-
-K = TypeVar("K")
-V = TypeVar("V")
-
-
-class odict(dict[K, V]):
-
-    __getattr__ = dict.__getitem__
-    __setattr__ = dict.__setitem__ # type: ignore
-    __delattr__ = dict.__delitem__ # type: ignore
-
-    def __hash__(self, /) -> int: # type: ignore
-        return id(self)
-
-    def __eq__(self, value, /) -> bool:
-        return self is value or super().__eq__(value)
-
-
-class AttrDict(dict[K, V]):
-
-    def __init__(self, /, *args, **kwds):
-        super().__init__(*args, **kwds)
-        self.__dict__ = self # type: ignore
-
-    def __hash__(self, /) -> int: # type: ignore
-        return id(self)
-
-    def __eq__(self, value, /) -> bool:
-        return self is value or super().__eq__(value)
-
-
-@Mapping.register
-class MapAttr(Generic[K, V]):
-
-    def __init__(self, /, *args, **kwds):
-        self.__dict__: dict[K, V] # type: ignore
-        self.__dict__.update(*args, **kwds)
-
-    def __contains__(self, key, /) -> bool:
-        return key in self.__dict__
-
-    def __getitem__(self, key, /) -> V:
-        return self.__dict__[key]
-
-    def __iter__(self, /) -> Iterator[K]:
-        return iter(self.__dict__)
-
-    def __len__(self, /) -> int:
-        return len(self.__dict__)
-
-    def __repr__(self, /) -> str:
-        cls = type(self)
-        if (mod := cls.__module__) == "__main__":
-            return f"{cls.__qualname__}({self.__dict__})"
-        else:
-            return f"{mod}.{cls.__qualname__}({self.__dict__})"
-
-    @classmethod
-    def of(
-        cls, 
-        d: None | dict[K, V] = None, 
-        /, 
-    ) -> Self:
-        if d is None:
-            return cls()
-        self = __class__.__new__(cls) # type: ignore
-        self.__dict__ = d
-        return self
-
-
-@MutableMapping.register
-class MuMapAttr(MapAttr[K, V]):
-
-    def __delitem__(self, key, /):
-        del self.__dict__[key]
-
-    def __setitem__(self, key: K, val: V, /):
-        self.__dict__[key] = val
-
-
-class DictAttr(MuMapAttr[K, V]):
-
-    def __getattr__(self, attr, /):
-        return getattr(self.__dict__, attr)
-
-    def __getattribute__(self, attr, /):
-        if attr == "__dict__":
-            return super().__getattribute__(attr)
-        try:
-            return self[attr]
-        except KeyError:
-            return super().__getattribute__(attr)
-
-    def __getitem__(self, key, /) -> V | Self: # type: ignore
-        d = self.__dict__[key]
-        if type(d) is dict:
-            return type(self)(d)
-        return d
-
-
-class ChainDictAttr(DictAttr[K, V | "ChainDictAttr"]):
-
-    def __getitem__(self, key, /) -> V | ChainDictAttr:
-        try:
-            return super().__getitem__(key)
-        except KeyError:
-            d = self.__dict__[key] = type(self)()
-            return d
-
-
-class UserDictAttr(UserDict):
-
-    def __getattr__(self, attr, /):
-        try:
-            return self[attr]
-        except KeyError as e:
-            raise AttributeError(attr) from e
-
-    def __getitem__(self, key, /):
-        d = super().__getitem__(key)
-        if isinstance(d, Mapping) and not isinstance(d, __class__): # type: ignore
-            return type(self)(d)
-        return d
-
-    def __repr__(self, /) -> str:
-        cls = type(self)
-        name = cls.__qualname__
-        if (module := cls.__module__) != "__main__":
-            name = f"{module}.{name}"
-        return f"{name}.of({self.data!r})"
-
-    @classmethod
-    def of(cls, m: Mapping, /) -> Self:
-        self = cls()
-        self.__dict__["data"] = m
-        return self
-
-
-class PriorityUserDictAttr(UserDictAttr):
-
-    def __delattr__(self, attr, /):
-        try:
-            del self[attr]
-        except KeyError:
-            super().__delattr__(attr)
-
-    def __getattribute__(self, attr, /):
-        if attr in ("__dict__", "data") or attr == f"__{attr.strip('_')}__":
-            return super().__getattribute__(attr)
-        try:
-            return self[attr]
-        except KeyError:
-            return super().__getattribute__(attr)
-
-    def __getattr__(self, attr, /):
-        raise AttributeError(attr)
-
-    def __setattr__(self, attr, val, /):
-        if attr == "data" and "data" not in self.__dict__:
-            self.__dict__["data"] = val
-        else:
-            self[attr] = val
-