aldict 1.0.3__tar.gz → 1.1.1__tar.gz

{aldict-1.0.3 → aldict-1.1.1}/PKG-INFO

@@ -1,19 +1,13 @@
 Metadata-Version: 2.4
 Name: aldict
-Version: 1.0.3
+Version: 1.1.1
 Summary: Multi-key dictionary, supports adding and manipulating key-aliases pointing to shared values
-Author-email: Kaloyan Ivanov <kaloyan.ivanov88@gmail.com>
-Project-URL: repository, https://github.com/kaliv0/aldict
 Keywords: multi-key dictionary,multidict,alias-dict
+Author-Email: kaliv0 <kaloyan.ivanov88@gmail.com>
+License-File: LICENSE
+Project-URL: repository, https://github.com/kaliv0/aldict
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-License-File: LICENSE
-Provides-Extra: dev
-Requires-Dist: pytest>=8.3.4; extra == "dev"
-Requires-Dist: ruff>=0.8.3; extra == "dev"
-Requires-Dist: build>=1.2.2; extra == "dev"
-Requires-Dist: twine>=6.0.1; extra == "dev"
-Dynamic: license-file
 
 <p align="center">
   <img src="https://github.com/kaliv0/aldict/blob/main/assets/alter-ego.jpg?raw=true" width="250" alt="Alter Ego">
@@ -33,20 +27,32 @@ Multi-key dictionary, supports adding and manipulating key-aliases pointing to s
 ---
 ## How to use
 
+- initialize with aliases
+<br>(one-liner with <i>aliases</i> dict mapping <i>key</i> to list of <i>aliases</i>)
+```python
+ad = AliasDict({"a": 1, "b": 2}, aliases={"a": ["aa", "aaa"], "b": ["bb"]})
+assert ad["a"] == ad["aa"] == ad["aaa"] == 1
+assert ad["b"] == ad["bb"] == 2
+```
 - add_alias
-<br>(pass <i>key</i> as first parameter and <i>alias(es)</i> as variadic params)
+<br>(pass <i>key</i> as first parameter and <i>alias(es)</i> as variadic params, list or tuple)
 ```python
 ad = AliasDict({"a": 1, "b": 2})
 ad.add_alias("a", "aa")
 ad.add_alias("b", "bb", "Bbb")
-assert ad["a"] == ad["aa"] == 1
-assert ad["b"] == ad["bb"] == ad["Bbb"] == 2
+ad.add_alias("a", ["aaa", "aaaa"])  
+ad.add_alias("b", ("bbb",))  
+
+assert ad["a"] == ad["aa"] == ad["aaa"] == ad["aaaa"] == 1
+assert ad["b"] == ad["bb"] == ad["Bbb"] == ad["bbb"] == 2
 ```
 - remove_alias
-<br>(pass <i>alias(es)</i> to be removed as variadic parameters)
+<br>(pass <i>alias(es)</i> to be removed as variadic params, list or tuple)
 ```python
 ad.remove_alias("aa")
 ad.remove_alias("bb", "Bbb")
+ad.remove_alias(["aaa", "aaaa"])  
+ad.remove_alias(("bbb",))  
 assert len(ad.aliases()) == 0
 ```
 - clear_aliases
@@ -73,10 +79,10 @@ ad.add_alias("b", "bb", "B")
 ad.add_alias("a", "ab", "A")
 assert list(ad.aliases()) == ['aa', 'bb', 'B', 'ab', 'A']
 ```
-- aliased_keys
+- keys_with_aliases
 <br>(read <i>keys</i> with corresponding <i>alias(es)</i>)
 ```python
-assert dict(ad.aliased_keys()) == {'a': ['aa', 'ab', 'A'], 'b': ['bb', 'B']}
+assert dict(ad.keys_with_aliases()) == {'a': ['aa', 'ab', 'A'], 'b': ['bb', 'B']}
 ```
 - read dictviews
 <br>(<i>dict.keys()</i> and <i>dict.items()</i> include <i>aliased</i> versions)
@@ -98,11 +104,6 @@ ad.items()
 ad.pop("y")
 assert list(ad.items()) == [('x', 10), ('Xx', 10)]
 ```
-- origin_keys
-<br>(get original <i>keys</i> only)
-```python
-assert list(ad.origin_keys()) == ['x', 'y']
-```
 - origin_len
 <br>(get original dict <i>length</i> without aliases)
 ```python
@@ -112,3 +113,57 @@ assert list(ad.keys()) == ["a", "b", "aa"]
 assert len(ad) == 3
 assert ad.origin_len() == 2
 ```
+- origin_keys
+<br>(get original <i>keys</i> only)
+```python
+assert list(ad.origin_keys()) == ['x', 'y']
+```
+- origin_key
+<br>(get original <i>key</i> for an <i>alias</i>)
+```python
+ad = AliasDict({"a": 1, "b": 2})
+ad.add_alias("a", "aa")
+assert ad.origin_key("aa") == "a"
+assert ad.origin_key("a") is None  # not an alias
+```
+- is_alias
+<br>(check if <i>key</i> is an <i>alias</i>)
+```python
+ad = AliasDict({"a": 1, "b": 2})
+ad.add_alias("a", "aa")
+assert ad.is_alias("aa") is True
+assert ad.is_alias("a") is False
+```
+- has_aliases
+<br>(check if <i>key</i> has any <i>aliases</i>)
+```python
+ad = AliasDict({"a": 1, "b": 2})
+ad.add_alias("a", "aa")
+assert ad.has_aliases("a") is True
+assert ad.has_aliases("b") is False
+```
+- copy
+```python
+ad = AliasDict({"a": 1, "b": 2})
+ad.add_alias("a", "aa")
+ad_copy = ad.copy()
+assert ad_copy == ad
+assert ad_copy is not ad
+```
+- merge with | and |= operators
+```python
+ad1 = AliasDict({"a": 1}, aliases={"a": ["aa"]})
+ad2 = AliasDict({"b": 2}, aliases={"b": ["bb"]})
+
+merged = ad1 | ad2
+assert merged["aa"] == 1
+assert merged["bb"] == 2
+
+ad1 |= {"c": 3}
+assert ad1["c"] == 3
+```
+- fromkeys
+```python
+ad = AliasDict.fromkeys(["a", "b", "c"], 0, aliases={"a": ["aa"]})
+assert ad["a"] == ad["aa"] == 0
+```

aldict-1.0.3/aldict.egg-info/PKG-INFO → aldict-1.1.1/README.md

@@ -1,20 +1,3 @@
-Metadata-Version: 2.4
-Name: aldict
-Version: 1.0.3
-Summary: Multi-key dictionary, supports adding and manipulating key-aliases pointing to shared values
-Author-email: Kaloyan Ivanov <kaloyan.ivanov88@gmail.com>
-Project-URL: repository, https://github.com/kaliv0/aldict
-Keywords: multi-key dictionary,multidict,alias-dict
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Provides-Extra: dev
-Requires-Dist: pytest>=8.3.4; extra == "dev"
-Requires-Dist: ruff>=0.8.3; extra == "dev"
-Requires-Dist: build>=1.2.2; extra == "dev"
-Requires-Dist: twine>=6.0.1; extra == "dev"
-Dynamic: license-file
-
 <p align="center">
   <img src="https://github.com/kaliv0/aldict/blob/main/assets/alter-ego.jpg?raw=true" width="250" alt="Alter Ego">
 </p>
@@ -33,20 +16,32 @@ Multi-key dictionary, supports adding and manipulating key-aliases pointing to s
 ---
 ## How to use
 
+- initialize with aliases
+<br>(one-liner with <i>aliases</i> dict mapping <i>key</i> to list of <i>aliases</i>)
+```python
+ad = AliasDict({"a": 1, "b": 2}, aliases={"a": ["aa", "aaa"], "b": ["bb"]})
+assert ad["a"] == ad["aa"] == ad["aaa"] == 1
+assert ad["b"] == ad["bb"] == 2
+```
 - add_alias
-<br>(pass <i>key</i> as first parameter and <i>alias(es)</i> as variadic params)
+<br>(pass <i>key</i> as first parameter and <i>alias(es)</i> as variadic params, list or tuple)
 ```python
 ad = AliasDict({"a": 1, "b": 2})
 ad.add_alias("a", "aa")
 ad.add_alias("b", "bb", "Bbb")
-assert ad["a"] == ad["aa"] == 1
-assert ad["b"] == ad["bb"] == ad["Bbb"] == 2
+ad.add_alias("a", ["aaa", "aaaa"])  
+ad.add_alias("b", ("bbb",))  
+
+assert ad["a"] == ad["aa"] == ad["aaa"] == ad["aaaa"] == 1
+assert ad["b"] == ad["bb"] == ad["Bbb"] == ad["bbb"] == 2
 ```
 - remove_alias
-<br>(pass <i>alias(es)</i> to be removed as variadic parameters)
+<br>(pass <i>alias(es)</i> to be removed as variadic params, list or tuple)
 ```python
 ad.remove_alias("aa")
 ad.remove_alias("bb", "Bbb")
+ad.remove_alias(["aaa", "aaaa"])  
+ad.remove_alias(("bbb",))  
 assert len(ad.aliases()) == 0
 ```
 - clear_aliases
@@ -73,10 +68,10 @@ ad.add_alias("b", "bb", "B")
 ad.add_alias("a", "ab", "A")
 assert list(ad.aliases()) == ['aa', 'bb', 'B', 'ab', 'A']
 ```
-- aliased_keys
+- keys_with_aliases
 <br>(read <i>keys</i> with corresponding <i>alias(es)</i>)
 ```python
-assert dict(ad.aliased_keys()) == {'a': ['aa', 'ab', 'A'], 'b': ['bb', 'B']}
+assert dict(ad.keys_with_aliases()) == {'a': ['aa', 'ab', 'A'], 'b': ['bb', 'B']}
 ```
 - read dictviews
 <br>(<i>dict.keys()</i> and <i>dict.items()</i> include <i>aliased</i> versions)
@@ -98,11 +93,6 @@ ad.items()
 ad.pop("y")
 assert list(ad.items()) == [('x', 10), ('Xx', 10)]
 ```
-- origin_keys
-<br>(get original <i>keys</i> only)
-```python
-assert list(ad.origin_keys()) == ['x', 'y']
-```
 - origin_len
 <br>(get original dict <i>length</i> without aliases)
 ```python
@@ -112,3 +102,57 @@ assert list(ad.keys()) == ["a", "b", "aa"]
 assert len(ad) == 3
 assert ad.origin_len() == 2
 ```
+- origin_keys
+<br>(get original <i>keys</i> only)
+```python
+assert list(ad.origin_keys()) == ['x', 'y']
+```
+- origin_key
+<br>(get original <i>key</i> for an <i>alias</i>)
+```python
+ad = AliasDict({"a": 1, "b": 2})
+ad.add_alias("a", "aa")
+assert ad.origin_key("aa") == "a"
+assert ad.origin_key("a") is None  # not an alias
+```
+- is_alias
+<br>(check if <i>key</i> is an <i>alias</i>)
+```python
+ad = AliasDict({"a": 1, "b": 2})
+ad.add_alias("a", "aa")
+assert ad.is_alias("aa") is True
+assert ad.is_alias("a") is False
+```
+- has_aliases
+<br>(check if <i>key</i> has any <i>aliases</i>)
+```python
+ad = AliasDict({"a": 1, "b": 2})
+ad.add_alias("a", "aa")
+assert ad.has_aliases("a") is True
+assert ad.has_aliases("b") is False
+```
+- copy
+```python
+ad = AliasDict({"a": 1, "b": 2})
+ad.add_alias("a", "aa")
+ad_copy = ad.copy()
+assert ad_copy == ad
+assert ad_copy is not ad
+```
+- merge with | and |= operators
+```python
+ad1 = AliasDict({"a": 1}, aliases={"a": ["aa"]})
+ad2 = AliasDict({"b": 2}, aliases={"b": ["bb"]})
+
+merged = ad1 | ad2
+assert merged["aa"] == 1
+assert merged["bb"] == 2
+
+ad1 |= {"c": 3}
+assert ad1["c"] == 3
+```
+- fromkeys
+```python
+ad = AliasDict.fromkeys(["a", "b", "c"], 0, aliases={"a": ["aa"]})
+assert ad["a"] == ad["aa"] == 0
+```

{aldict-1.0.3 → aldict-1.1.1}/aldict/__init__.py

@@ -1,3 +1,6 @@
 from .alias_dict import AliasDict as AliasDict
 from .exception import AliasError as AliasError
 from .exception import AliasValueError as AliasValueError
+
+__version__ = "1.1.1"
+__all__ = ["AliasDict", "AliasError", "AliasValueError"]

aldict-1.1.1/aldict/alias_dict.py

@@ -0,0 +1,180 @@
+from collections import UserDict, defaultdict
+from collections.abc import Mapping
+from itertools import chain
+
+from aldict.exception import AliasError, AliasValueError
+
+
+class AliasDict(UserDict):
+    """Dict with key-aliases pointing to shared values."""
+
+    def __init__(self, dict_=None, /, aliases=None):
+        self._alias_dict = {}
+        if isinstance(dict_, AliasDict):
+            super().__init__(dict_.data)
+            self._alias_dict = dict(dict_._alias_dict)
+        else:
+            super().__init__(dict_)
+
+        if aliases:
+            for key, alias_list in aliases.items():
+                self.add_alias(key, alias_list)
+
+    def add_alias(self, key, *aliases):
+        """Add one or more aliases to a key. Accepts *args or a list/tuple."""
+        if key not in self.data:
+            raise KeyError(key)
+
+        for alias in self._unpack(aliases):
+            if alias == key:
+                raise AliasValueError(f"Key and corresponding alias cannot be equal: '{key}'")
+            if alias in self.data:
+                raise AliasValueError(f"Alias '{alias}' already exists as a key in the dictionary")
+            self._alias_dict[alias] = key
+
+    def remove_alias(self, *aliases):
+        """Remove one or more aliases. Accepts *args or a list/tuple."""
+        for alias in self._unpack(aliases):
+            try:
+                self._alias_dict.__delitem__(alias)
+            except KeyError as e:
+                raise AliasError(f"Alias '{alias}' not found") from e
+
+    @staticmethod
+    def _unpack(args):
+        return args[0] if len(args) == 1 and isinstance(args[0], (list, tuple)) else args
+
+    @classmethod
+    def fromkeys(cls, iterable, value=None, aliases=None):
+        """Create an AliasDict from an iterable of keys with optional aliases."""
+        return cls(dict.fromkeys(iterable, value), aliases=aliases)
+
+    def clear(self):
+        """Clear all data and aliases."""
+        super().clear()
+        self._alias_dict.clear()
+
+    def clear_aliases(self):
+        """Remove all aliases."""
+        self._alias_dict.clear()
+
+    def aliases(self):
+        """Return all aliases."""
+        return self._alias_dict.keys()
+
+    def is_alias(self, key):
+        """Return True if the key is an alias, False otherwise."""
+        return key in self._alias_dict
+
+    def has_aliases(self, key):
+        """Return True if the key has any aliases, False otherwise."""
+        return key in self._alias_dict.values()
+
+    def keys_with_aliases(self):
+        """Return keys with their aliases."""
+        result = defaultdict(list)
+        for alias, key in self._alias_dict.items():
+            result[key].append(alias)
+        return result.items()
+
+    def origin_keys(self):
+        """Return original keys (without aliases)."""
+        return self.data.keys()
+
+    def origin_key(self, alias):
+        """Return the original key for an alias, or None if not an alias."""
+        return self._alias_dict.get(alias)
+
+    def keys(self):
+        """Return all keys and aliases."""
+        return dict(**self.data, **self._alias_dict).keys()
+        # NB: could be optimized as 'return iter(self)' but we won't be able to call e.g. len(alias_dict.keys())
+
+    def values(self):
+        """Return all values."""
+        return self.data.values()
+
+    def items(self):
+        """Return all items (including alias/value pairs)."""
+        return dict(**self.data, **{k: self.data[v] for k, v in self._alias_dict.items()}).items()
+        # NB: could be optimized as
+        #   'return chain(self.data.items(), ((k, self.data[v]) for k, v in self._alias_dict.items()))'
+        # (same as .keys() above)
+
+    def origin_len(self):
+        """Return count of original keys (without aliases)."""
+        return len(self.data)
+
+    def __len__(self):
+        return len(self.data) + len(self._alias_dict)
+
+    def __missing__(self, key):
+        try:
+            return super().__getitem__(self._alias_dict[key])
+        except KeyError:
+            raise KeyError(key) from None
+
+    def __setitem__(self, key, value):
+        try:
+            key = self._alias_dict[key]
+        except KeyError:
+            pass
+        super().__setitem__(key, value)
+
+    def __delitem__(self, key):
+        try:
+            self.data.__delitem__(key)
+            for alias in [k for k, v in self._alias_dict.items() if v == key]:
+                del self._alias_dict[alias]
+        except KeyError:
+            return self.remove_alias(key)
+
+    def __contains__(self, item):
+        return item in self.data or item in self._alias_dict
+
+    def __iter__(self):
+        return chain(self.data, self._alias_dict)
+
+    def __reversed__(self):
+        return chain(reversed(self._alias_dict), reversed(self.data))
+
+    def copy(self):
+        """Return a shallow copy of the AliasDict."""
+        return type(self)(self)
+
+    def __repr__(self):
+        return f"AliasDict({dict(self.items())})"
+
+    def __eq__(self, other):
+        if not isinstance(other, AliasDict):
+            return NotImplemented
+        return self.data == other.data and self._alias_dict == other._alias_dict
+
+    def __or__(self, other):
+        if not isinstance(other, Mapping):
+            return NotImplemented
+        new = self.copy()
+        if isinstance(other, AliasDict):
+            new.update(other.data)
+            new._alias_dict.update(other._alias_dict)
+        else:
+            new.update(other)
+        return new
+
+    def __ror__(self, other):
+        if not isinstance(other, Mapping):
+            return NotImplemented
+        new = AliasDict(other)
+        new.update(self.data)
+        new._alias_dict.update(self._alias_dict)
+        return new
+
+    def __ior__(self, other):
+        if isinstance(other, AliasDict):
+            self.update(other.data)
+            self._alias_dict.update(other._alias_dict)
+        else:
+            self.update(other)
+        return self
+
+    __hash__ = None

aldict-1.1.1/pyproject.toml

@@ -0,0 +1,42 @@
+[project]
+name = "aldict"
+version = "1.1.1"
+requires-python = ">=3.10"
+authors = [
+    { name = "kaliv0", email = "kaloyan.ivanov88@gmail.com" },
+]
+description = "Multi-key dictionary, supports adding and manipulating key-aliases pointing to shared values"
+keywords = [
+    "multi-key dictionary",
+    "multidict",
+    "alias-dict",
+]
+readme = "README.md"
+license-files = [
+    "LICENSE",
+]
+dependencies = []
+
+[project.urls]
+repository = "https://github.com/kaliv0/aldict"
+
+[dependency-groups]
+dev = [
+    "ruff>=0.12.4",
+    "pytest>=8.3.2",
+]
+
+[build-system]
+requires = [
+    "pdm-backend",
+]
+build-backend = "pdm.backend"
+
+[tool.pdm.build]
+excludes = [
+    "tests/",
+]
+
+[tool.ruff]
+fix = true
+line-length = 100

aldict-1.0.3/README.md

@@ -1,97 +0,0 @@
-<p align="center">
-  <img src="https://github.com/kaliv0/aldict/blob/main/assets/alter-ego.jpg?raw=true" width="250" alt="Alter Ego">
-</p>
-
----
-# Aldict
-
-[![tests](https://img.shields.io/github/actions/workflow/status/kaliv0/aldict/ci.yml)](https://github.com/kaliv0/aldict/actions/workflows/ci.yml)
-![Python 3.x](https://img.shields.io/badge/python-^3.10-blue?style=flat-square&logo=Python&logoColor=white)
-[![PyPI](https://img.shields.io/pypi/v/aldict.svg)](https://pypi.org/project/aldict/)
-[![License](https://img.shields.io/badge/License-MIT-yellow?style=flat-square)](https://github.com/kaliv0/aldict/blob/main/LICENSE)
-[![Downloads](https://static.pepy.tech/badge/aldict)](https://pepy.tech/projects/aldict)
-
-Multi-key dictionary, supports adding and manipulating key-aliases pointing to shared values
-
----
-## How to use
-
-- add_alias
-<br>(pass <i>key</i> as first parameter and <i>alias(es)</i> as variadic params)
-```python
-ad = AliasDict({"a": 1, "b": 2})
-ad.add_alias("a", "aa")
-ad.add_alias("b", "bb", "Bbb")
-assert ad["a"] == ad["aa"] == 1
-assert ad["b"] == ad["bb"] == ad["Bbb"] == 2
-```
-- remove_alias
-<br>(pass <i>alias(es)</i> to be removed as variadic parameters)
-```python
-ad.remove_alias("aa")
-ad.remove_alias("bb", "Bbb")
-assert len(ad.aliases()) == 0
-```
-- clear_aliases
-<br>(remove all <i>aliases</i> at once)
-```python
-ad.clear_aliases()
-assert len(ad.aliases()) == 0
-```
-- update alias
-<br>(point <i>alias</i> to different <i>key</i>)
-```python
-ad = AliasDict({"a": 1, "b": 2})
-ad.add_alias("a", "ab")
-assert list(ad.items()) == [('a', 1), ('b', 2), ('ab', 1)]
-
-ad.add_alias("b", "ab")
-assert list(ad.items()) == [('a', 1), ('b', 2), ('ab', 2)]
-```
-- read all aliases
-```python
-ad = AliasDict({"a": 1, "b": 2})
-ad.add_alias("a", "aa")
-ad.add_alias("b", "bb", "B")
-ad.add_alias("a", "ab", "A")
-assert list(ad.aliases()) == ['aa', 'bb', 'B', 'ab', 'A']
-```
-- aliased_keys
-<br>(read <i>keys</i> with corresponding <i>alias(es)</i>)
-```python
-assert dict(ad.aliased_keys()) == {'a': ['aa', 'ab', 'A'], 'b': ['bb', 'B']}
-```
-- read dictviews
-<br>(<i>dict.keys()</i> and <i>dict.items()</i> include <i>aliased</i> versions)
-```python
-ad = AliasDict({"x": 10, "y": 20})
-ad.add_alias("x", "Xx")
-ad.add_alias("y", "Yy", "xyz")
-
-ad.keys()
-ad.values()
-ad.items()
-
-# dict_keys(['x', 'y', 'Xx', 'Yy', 'xyz'])
-# dict_values([10, 20])
-# dict_items([('x', 10), ('y', 20), ('Xx', 10), ('Yy', 20), ('xyz', 20)])
-```
-- remove key and aliases
-```python
-ad.pop("y")
-assert list(ad.items()) == [('x', 10), ('Xx', 10)]
-```
-- origin_keys
-<br>(get original <i>keys</i> only)
-```python
-assert list(ad.origin_keys()) == ['x', 'y']
-```
-- origin_len
-<br>(get original dict <i>length</i> without aliases)
-```python
-ad = AliasDict({"a": 1, "b": 2})
-ad.add_alias("a", "aa")
-assert list(ad.keys()) == ["a", "b", "aa"]
-assert len(ad) == 3
-assert ad.origin_len() == 2
-```

aldict-1.0.3/aldict/alias_dict.py

@@ -1,105 +0,0 @@
-from collections import UserDict, defaultdict
-
-from aldict.exception import AliasError, AliasValueError
-
-
-class AliasDict(UserDict):
-    """Custom Dict class supporting key-aliases pointing to shared values"""
-
-    def __init__(self, dict_):
-        self._alias_dict = {}
-        super().__init__(**dict_)
-
-    def add_alias(self, key, *aliases):
-        """Adds one or more aliases to specified key in the dictionary"""
-        if key not in self.data.keys():
-            raise KeyError(key)
-        for alias in aliases:
-            if alias == key:
-                raise AliasValueError(f"Key and corresponding alias cannot be equal: '{key}'")
-            self._alias_dict[alias] = key
-
-    def remove_alias(self, *aliases):
-        """Removes one or more aliases"""
-        for alias in aliases:
-            try:
-                self._alias_dict.__delitem__(alias)
-            except KeyError as e:
-                raise AliasError(alias) from e
-
-    def clear_aliases(self):
-        """Removes all aliases"""
-        self._alias_dict.clear()
-
-    def aliases(self):
-        """Returns all aliases present in the dictionary"""
-        return self._alias_dict.keys()
-
-    def aliased_keys(self):
-        """Returns a dictview of all keys with their corresponding aliases"""
-        result = defaultdict(list)
-        for alias, key in self._alias_dict.items():
-            result[key].append(alias)
-        return result.items()
-
-    def origin_keys(self):
-        """Returns all keys"""
-        return self.data.keys()
-
-    def keys(self):
-        """Returns all keys and aliases"""
-        return dict(**self.data, **self._alias_dict).keys()
-
-    def values(self):
-        """Returns all values"""
-        return self.data.values()
-
-    def items(self):
-        """Returns a dictview with all items (including alias/value tuples)"""
-        return dict(**self.data, **{k: self.data[v] for k, v in self._alias_dict.items()}).items()
-
-    def origin_len(self):
-        """Returns the length of the original dictionary (without aliases)"""
-        return len(self.data)
-
-    def __len__(self):
-        return len(self.keys())
-
-    def __missing__(self, key):
-        try:
-            return super().__getitem__(self._alias_dict[key])
-        except AttributeError as e:
-            raise KeyError(key) from e
-
-    def __setitem__(self, key, value):
-        try:
-            key = self._alias_dict[key]
-        except KeyError:
-            pass
-        super().__setitem__(key, value)
-
-    def __delitem__(self, key):
-        try:
-            self.data.__delitem__(key)
-            self._alias_dict = {k: v for k, v in self._alias_dict.items() if v != key}
-        except KeyError:
-            # in case we try to delete alias via pop() or del
-            return self.remove_alias(key)
-
-    def __contains__(self, item):
-        return item in set(self.keys())
-
-    def __iter__(self):
-        for item in self.keys():
-            yield item
-
-    def __repr__(self):
-        return f"AliasDict({self.items()})"
-
-    def __eq__(self, other):
-        if not isinstance(other, AliasDict):
-            raise TypeError(f"{other} is not an AliasDict")
-        return self.data == other.data and self._alias_dict == other._alias_dict
-
-    def __hash__(self):
-        return hash((self.data, self._alias_dict))

aldict-1.0.3/aldict.egg-info/SOURCES.txt

@@ -1,12 +0,0 @@
-LICENSE
-README.md
-pyproject.toml
-aldict/__init__.py
-aldict/alias_dict.py
-aldict/exception.py
-aldict.egg-info/PKG-INFO
-aldict.egg-info/SOURCES.txt
-aldict.egg-info/dependency_links.txt
-aldict.egg-info/requires.txt
-aldict.egg-info/top_level.txt
-tests/test_alias_dict.py

aldict-1.0.3/aldict.egg-info/dependency_links.txt

@@ -1 +0,0 @@
-

aldict-1.0.3/aldict.egg-info/requires.txt

@@ -1,6 +0,0 @@
-
-[dev]
-pytest>=8.3.4
-ruff>=0.8.3
-build>=1.2.2
-twine>=6.0.1

aldict-1.0.3/aldict.egg-info/top_level.txt

@@ -1 +0,0 @@
-aldict

aldict-1.0.3/pyproject.toml

@@ -1,27 +0,0 @@
-[build-system]
-requires = ["setuptools>=75.6.0", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "aldict"
-version = "1.0.3"
-readme = "README.md"
-authors = [{ name = "Kaloyan Ivanov", email = "kaloyan.ivanov88@gmail.com" }]
-description = "Multi-key dictionary, supports adding and manipulating key-aliases pointing to shared values"
-keywords = ["multi-key dictionary", "multidict", "alias-dict"]
-urls = { repository = "https://github.com/kaliv0/aldict" }
-
-requires-python = ">= 3.10"
-
-[project.optional-dependencies]
-dev = [
-    "pytest>=8.3.4",
-    "ruff>=0.8.3",
-    "build>=1.2.2",
-    "twine>=6.0.1",
-]
-
-[tool.setuptools.packages.find]
-where = ["."]
-include = ["aldict"]
-exclude = ["tests"]

aldict-1.0.3/setup.cfg

@@ -1,4 +0,0 @@
-[egg_info]
-tag_build = 
-tag_date = 0
-

aldict-1.0.3/tests/test_alias_dict.py

@@ -1,251 +0,0 @@
-import pytest
-
-from aldict import AliasDict, AliasValueError, AliasError
-
-
-def test_alias_dict(alias_dict):
-    assert alias_dict[".toml"] == {
-        "callable": "load",
-        "import_mod": "tomli",
-        "read_mode": "r",
-    }
-    assert (
-        alias_dict[".yml"]
-        == alias_dict[".yaml"]
-        == {"callable": "safe_load", "import_mod": "yaml", "read_mode": "r"}
-    )
-
-
-def test_add_alias(alias_dict):
-    alias_dict.add_alias(".toml", ".tml")
-    assert (
-        alias_dict[".toml"]
-        == alias_dict[".tml"]
-        == {"callable": "load", "import_mod": "tomli", "read_mode": "r"}
-    )
-
-
-def test_add_multiple_aliases(alias_dict):
-    alias_dict.add_alias(".json", ".jsn", ".joojoo", ".jazz")
-    assert list(alias_dict.keys()) == [
-        ".json",
-        ".yaml",
-        ".toml",
-        ".yml",
-        ".jsn",
-        ".joojoo",
-        ".jazz",
-    ]
-
-
-def test_add_alias_raises(alias_dict):
-    with pytest.raises(
-        AliasValueError, match="Key and corresponding alias cannot be equal: '.toml'"
-    ):
-        alias_dict.add_alias(".toml", ".toml")
-
-
-def test_update_alias(alias_dict):
-    # redirect ".yml" to point to ".toml"
-    alias_dict.add_alias(".toml", ".yml")
-    assert list(alias_dict.items()) == [
-        (".json", {"callable": "load", "import_mod": "json", "read_mode": "r"}),
-        (".yaml", {"callable": "safe_load", "import_mod": "yaml", "read_mode": "r"}),
-        (".toml", {"callable": "load", "import_mod": "tomli", "read_mode": "r"}),
-        (".yml", {"callable": "load", "import_mod": "tomli", "read_mode": "r"}),
-    ]
-
-
-def test_update_alias_raises(alias_dict):
-    with pytest.raises(KeyError, match=".foo"):
-        alias_dict.add_alias(".foo", ".bar")
-
-
-def test_remove_alias(alias_dict):
-    assert list(alias_dict.keys()) == [".json", ".yaml", ".toml", ".yml"]
-
-    alias_dict.remove_alias(".yml")
-    assert list(alias_dict.keys()) == [".json", ".yaml", ".toml"]
-    assert list(alias_dict.items()) == [
-        (".json", {"callable": "load", "import_mod": "json", "read_mode": "r"}),
-        (".yaml", {"callable": "safe_load", "import_mod": "yaml", "read_mode": "r"}),
-        (".toml", {"callable": "load", "import_mod": "tomli", "read_mode": "r"}),
-    ]
-
-
-def test_remove_alias_raises(alias_dict):
-    assert list(alias_dict.keys()) == [".json", ".yaml", ".toml", ".yml"]
-    with pytest.raises(AliasError, match=".foo"):
-        alias_dict.remove_alias(".foo")
-
-
-def test_remove_multiple_aliases(alias_dict):
-    alias_dict.add_alias(".json", ".jsn")
-    assert list(alias_dict.keys()) == [".json", ".yaml", ".toml", ".yml", ".jsn"]
-
-    alias_dict.remove_alias(".yml", ".jsn")
-    assert list(alias_dict.keys()) == [".json", ".yaml", ".toml"]
-
-
-def test_read_aliases(alias_dict):
-    alias_dict.add_alias(".toml", ".tml")
-    alias_dict.add_alias(".json", ".jsn")
-    alias_dict.add_alias(".json", ".whaaaaat!")
-    assert list(alias_dict.aliases()) == [".yml", ".tml", ".jsn", ".whaaaaat!"]
-
-
-def test_dictviews(alias_dict):
-    assert list(alias_dict.keys()) == [".json", ".yaml", ".toml", ".yml"]
-    assert list(alias_dict.values()) == [
-        {"import_mod": "json", "callable": "load", "read_mode": "r"},
-        {"import_mod": "yaml", "callable": "safe_load", "read_mode": "r"},
-        {"import_mod": "tomli", "callable": "load", "read_mode": "r"},
-    ]
-    assert list(alias_dict.items()) == [
-        (".json", {"callable": "load", "import_mod": "json", "read_mode": "r"}),
-        (".yaml", {"callable": "safe_load", "import_mod": "yaml", "read_mode": "r"}),
-        (".toml", {"callable": "load", "import_mod": "tomli", "read_mode": "r"}),
-        (".yml", {"callable": "safe_load", "import_mod": "yaml", "read_mode": "r"}),
-    ]
-
-
-def test_remove_key_and_aliases(alias_dict):
-    assert list(alias_dict.keys()) == [".json", ".yaml", ".toml", ".yml"]
-    alias_dict.pop(".yaml")
-    assert list(alias_dict.keys()) == [".json", ".toml"]
-
-
-def test_contains(alias_dict):
-    alias_dict.add_alias(".toml", ".tml")
-    assert (".toml" in alias_dict) is True
-    assert (".tml" in alias_dict) is True
-    assert (".foo" in alias_dict) is False
-
-
-def test_get(alias_dict):
-    assert alias_dict.get(".yaml") == {
-        "callable": "safe_load",
-        "import_mod": "yaml",
-        "read_mode": "r",
-    }
-    assert alias_dict.get(".yml") == {
-        "callable": "safe_load",
-        "import_mod": "yaml",
-        "read_mode": "r",
-    }
-    assert alias_dict.get(".foo") is None
-
-
-def test_pop_alias_doesnt_remove_key(alias_dict):
-    assert alias_dict.pop(".yml") == {
-        "callable": "safe_load",
-        "import_mod": "yaml",
-        "read_mode": "r",
-    }
-    assert list(alias_dict.keys()) == [".json", ".yaml", ".toml"]
-
-
-def test_iter(alias_dict):
-    assert [k for k in alias_dict] == [".json", ".yaml", ".toml", ".yml"]
-
-
-def test_origin_keys(alias_dict):
-    assert list(alias_dict.origin_keys()) == [".json", ".yaml", ".toml"]
-
-
-def test_aliased_keys(alias_dict):
-    assert list(alias_dict.aliased_keys()) == [(".yaml", [".yml"])]
-    alias_dict.add_alias(".toml", ".tml", ".tommy", ".tomograph")
-    assert list(alias_dict.aliased_keys()) == [
-        (".yaml", [".yml"]),
-        (".toml", [".tml", ".tommy", ".tomograph"]),
-    ]
-
-
-def test_repr(alias_dict):
-    assert str(alias_dict) == (
-        "AliasDict(dict_items(["
-        "('.json', {'import_mod': 'json', 'callable': 'load', 'read_mode': 'r'}), "
-        "('.yaml', {'import_mod': 'yaml', 'callable': 'safe_load', 'read_mode': 'r'}), "
-        "('.toml', {'import_mod': 'tomli', 'callable': 'load', 'read_mode': 'r'}), "
-        "('.yml', {'import_mod': 'yaml', 'callable': 'safe_load', 'read_mode': 'r'})"
-        "]))"
-    )
-
-
-def test_eq():
-    ad_0 = {"a": 1, "b": 2}
-    ad_1 = AliasDict(ad_0)
-    ad_1.add_alias("a", "aa", "aaa")
-
-    ad_2 = AliasDict(ad_0)
-    ad_2.add_alias("a", "aa", "aaa")
-
-    ad_3 = AliasDict(ad_0)
-    ad_3.add_alias("a", "abc")
-
-    assert ad_1 == ad_2
-    assert ad_1 != ad_3
-    assert ad_2 != ad_3
-
-
-def test_dict_len_includes_aliases(alias_dict):
-    assert list(alias_dict.keys()) == [".json", ".yaml", ".toml", ".yml"]
-    assert len(alias_dict) == 4
-
-
-def test_dict_origin_len_excludes_aliases(alias_dict):
-    assert list(alias_dict.keys()) == [".json", ".yaml", ".toml", ".yml"]
-    assert alias_dict.origin_len() == 3
-
-
-def test_popitem(alias_dict):
-    # pops first item -> MutableMapping.popitem()
-    assert alias_dict.popitem() == (
-        ".json",
-        {"callable": "load", "import_mod": "json", "read_mode": "r"},
-    )
-    assert alias_dict.popitem() == (
-        ".yaml",
-        {"callable": "safe_load", "import_mod": "yaml", "read_mode": "r"},
-    )
-    assert len(alias_dict.aliased_keys()) == 0
-    assert list(alias_dict.keys()) == [".toml"]
-
-
-def test_clear(alias_dict):
-    alias_dict.clear()
-    assert len(alias_dict.items()) == 0
-
-
-def test_clear_aliases(alias_dict):
-    alias_dict.clear_aliases()
-    assert len(alias_dict.aliases()) == 0
-    assert list(alias_dict.items()) == [
-        (".json", {"callable": "load", "import_mod": "json", "read_mode": "r"}),
-        (".yaml", {"callable": "safe_load", "import_mod": "yaml", "read_mode": "r"}),
-        (".toml", {"callable": "load", "import_mod": "tomli", "read_mode": "r"}),
-    ]
-
-
-def test_setdefault():
-    ad = AliasDict({"a": 1, "b": 2})
-    ad.setdefault("foo", "bar")
-    ad.add_alias("foo", "fizz")
-    assert ad["foo"] == "bar"
-    assert ad["fizz"] == "bar"
-
-
-def test_setdefault_on_existing_aliased_key():
-    ad = AliasDict({"a": 1, "b": 2})
-    ad.setdefault("a", 42)
-    ad.add_alias("a", "aa")
-    assert ad["a"] == 1
-    assert ad["aa"] == 1
-
-
-def test_update_modifies_aliases():
-    ad = AliasDict({"a": 1, "b": 2})
-    ad.add_alias("a", "aa", "aaa")
-    ad.update(**{"a": 40, "y": 50})
-    assert list(ad.items()) == [("a", 40), ("b", 2), ("y", 50), ("aa", 40), ("aaa", 40)]