aldict 1.1.2__tar.gz → 1.2.1__tar.gz

{aldict-1.1.2 → aldict-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aldict
-Version: 1.1.2
+Version: 1.2.1
 Summary: Multi-key dictionary, supports adding and manipulating key-aliases pointing to shared values
 Keywords: multi-key dictionary,multidict,alias-dict
 Author-Email: kaliv0 <kaloyan.ivanov88@gmail.com>
@@ -10,7 +10,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 
 <p align="center">
-  <img src="https://github.com/kaliv0/aldict/blob/main/assets/alter-ego.jpg?raw=true" width="250" alt="Alter Ego">
+  <img src="https://github.com/kaliv0/aldict/blob/main/.github/assets/alter-ego.jpg?raw=true" width="250" alt="Alter Ego">
 </p>
 
 ---
@@ -99,6 +99,19 @@ ad.items()
 # dict_values([10, 20])
 # dict_items([('x', 10), ('y', 20), ('Xx', 10), ('Yy', 20), ('xyz', 20)])
 ```
+- iterkeys
+<br>(lazy iterator over all <i>keys</i> and <i>aliases</i>)
+```python
+ad = AliasDict({"x": 10, "y": 20})
+ad.add_alias("x", "Xx")
+
+assert list(ad.iterkeys()) == ['x', 'y', 'Xx']
+```
+- iteritems
+<br>(lazy iterator over all <i>items</i> including <i>alias/value</i> pairs)
+```python
+assert list(ad.iteritems()) == [('x', 10), ('y', 20), ('Xx', 10)]
+```
 - remove key and aliases
 ```python
 ad.pop("y")
@@ -152,8 +165,8 @@ 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"]})
+ad1 = AliasDict({"a": 1}, aliases={"a": "aa"})
+ad2 = AliasDict({"b": 2}, aliases={"b": "bb"})
 
 merged = ad1 | ad2
 assert merged["aa"] == 1
@@ -164,6 +177,6 @@ assert ad1["c"] == 3
 ```
 - fromkeys
 ```python
-ad = AliasDict.fromkeys(["a", "b", "c"], 0, aliases={"a": ["aa"]})
+ad = AliasDict.fromkeys(["a", "b", "c"], 0, aliases={"a": "aa"})
 assert ad["a"] == ad["aa"] == 0
 ```

{aldict-1.1.2 → aldict-1.2.1}/README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <img src="https://github.com/kaliv0/aldict/blob/main/assets/alter-ego.jpg?raw=true" width="250" alt="Alter Ego">
+  <img src="https://github.com/kaliv0/aldict/blob/main/.github/assets/alter-ego.jpg?raw=true" width="250" alt="Alter Ego">
 </p>
 
 ---
@@ -88,6 +88,19 @@ ad.items()
 # dict_values([10, 20])
 # dict_items([('x', 10), ('y', 20), ('Xx', 10), ('Yy', 20), ('xyz', 20)])
 ```
+- iterkeys
+<br>(lazy iterator over all <i>keys</i> and <i>aliases</i>)
+```python
+ad = AliasDict({"x": 10, "y": 20})
+ad.add_alias("x", "Xx")
+
+assert list(ad.iterkeys()) == ['x', 'y', 'Xx']
+```
+- iteritems
+<br>(lazy iterator over all <i>items</i> including <i>alias/value</i> pairs)
+```python
+assert list(ad.iteritems()) == [('x', 10), ('y', 20), ('Xx', 10)]
+```
 - remove key and aliases
 ```python
 ad.pop("y")
@@ -141,8 +154,8 @@ 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"]})
+ad1 = AliasDict({"a": 1}, aliases={"a": "aa"})
+ad2 = AliasDict({"b": 2}, aliases={"b": "bb"})
 
 merged = ad1 | ad2
 assert merged["aa"] == 1
@@ -153,6 +166,6 @@ assert ad1["c"] == 3
 ```
 - fromkeys
 ```python
-ad = AliasDict.fromkeys(["a", "b", "c"], 0, aliases={"a": ["aa"]})
+ad = AliasDict.fromkeys(["a", "b", "c"], 0, aliases={"a": "aa"})
 assert ad["a"] == ad["aa"] == 0
 ```

aldict-1.2.1/aldict/__init__.py

@@ -0,0 +1,8 @@
+from .alias_dict import (
+    AliasDict as AliasDict,
+    AliasError as AliasError,
+    AliasValueError as AliasValueError,
+)
+
+__version__ = "1.2.1"
+__all__ = ["AliasDict", "AliasError", "AliasValueError"]

aldict-1.2.1/aldict/alias_dict.py

@@ -0,0 +1,234 @@
+from collections import UserDict
+from collections.abc import Mapping
+from itertools import chain
+
+
+class AliasError(KeyError):
+    """Key alias not found"""
+
+    pass
+
+
+class AliasValueError(ValueError):
+    """Inappropriate alias value"""
+
+    pass
+
+
+class AliasDict(UserDict):
+    """Dict with key-aliases pointing to shared values."""
+
+    def __init__(self, dict_=None, /, aliases=None):
+        self._lookup_map = {}  # key -> set(aliases)
+        self._alias_map = {}  # alias -> key
+
+        if isinstance(dict_, AliasDict):
+            super().__init__(dict_.data)
+            self._lookup_map = {k: v.copy() for k, v in dict_._lookup_map.items()}
+            self._alias_map = dict_._alias_map.copy()
+        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, strict=False):
+        """Add one or more aliases to a key. Accepts *args or a list/tuple.
+        If strict=True, raises AliasValueError when an alias is already assigned to a different key."""
+        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")
+
+            if (old_key := self._alias_map.get(alias)) is not None and old_key != key:
+                if strict:
+                    raise AliasValueError(f"Alias '{alias}' already assigned to key '{old_key}'")
+                aliases_set = self._lookup_map[old_key]
+                aliases_set.discard(alias)
+                if not aliases_set:
+                    del self._lookup_map[old_key]
+
+            self._lookup_map.setdefault(key, set()).add(alias)
+            self._alias_map[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:
+                key = self._alias_map.pop(alias)
+            except KeyError as e:
+                raise AliasError(f"Alias '{alias}' not found") from e
+
+            aliases_set = self._lookup_map[key]
+            aliases_set.discard(alias)
+            if not aliases_set:
+                del self._lookup_map[key]
+
+    @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._lookup_map.clear()
+        self._alias_map.clear()
+
+    def clear_aliases(self):
+        """Remove all aliases."""
+        self._lookup_map.clear()
+        self._alias_map.clear()
+
+    def aliases(self):
+        """Return all aliases."""
+        return self._alias_map.keys()
+
+    def is_alias(self, key):
+        """Return True if the key is an alias, False otherwise."""
+        return key in self._alias_map
+
+    def has_aliases(self, key):
+        """Return True if the key has any aliases, False otherwise."""
+        return key in self._lookup_map
+
+    def keys_with_aliases(self):
+        """Return keys with their aliases."""
+        return self._lookup_map.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_map.get(alias)
+
+    def keys(self):
+        """Return all keys and aliases."""
+        return (self.data | self._alias_map).keys()
+
+    def values(self):
+        """Return all values."""
+        return self.data.values()
+
+    def items(self):
+        """Return all items (including alias/value pairs)."""
+        return (self.data | {k: self.data[v] for k, v in self._alias_map.items()}).items()
+
+    def iterkeys(self):
+        """Return a lazy iterator over all keys and aliases."""
+        return iter(self)
+
+    def iteritems(self):
+        """Return a lazy iterator over all items (including alias/value pairs)."""
+        return chain(self.data.items(), ((k, self.data[v]) for k, v in self._alias_map.items()))
+
+    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_map)
+
+    def __missing__(self, key):
+        try:
+            return super().__getitem__(self._alias_map[key])
+        except KeyError:
+            raise KeyError(key) from None
+
+    def __setitem__(self, key, value):
+        try:
+            key = self._alias_map[key]
+        except KeyError:
+            pass
+        super().__setitem__(key, value)
+
+    def __delitem__(self, key):
+        try:
+            del self.data[key]
+            for alias in self._lookup_map.pop(key, ()):
+                del self._alias_map[alias]
+        except KeyError:
+            return self.remove_alias(key)
+
+    def __contains__(self, item):
+        return item in self.data or item in self._alias_map
+
+    def __iter__(self):
+        return chain(self.data, self._alias_map)
+
+    def __reversed__(self):
+        return chain(reversed(self._alias_map), 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
+        # _lookup_map is derived from _alias_map, so comparing it is redundant
+        return self.data == other.data and self._alias_map == other._alias_map
+
+    def __or__(self, other):
+        if not isinstance(other, Mapping):
+            return NotImplemented
+        new = self.copy()
+        if isinstance(other, AliasDict):
+            new.update(other.data)
+            self._validate_merge_aliases(new, other)
+            new._alias_map.update(other._alias_map)
+            for k, v in other._lookup_map.items():
+                new._lookup_map.setdefault(k, set()).update(v)
+        else:
+            new.update(other)
+        return new
+
+    def __ror__(self, other):
+        if not isinstance(other, Mapping):
+            return NotImplemented
+        new = type(self)(other)
+        new.update(self.data)
+        self._validate_merge_aliases(new, self)
+        new._alias_map.update(self._alias_map)
+        for k, v in self._lookup_map.items():
+            new._lookup_map.setdefault(k, set()).update(v)
+        return new
+
+    def __ior__(self, other):
+        if isinstance(other, AliasDict):
+            self._validate_merge_aliases(self, other)
+            self.update(other.data)
+            self._alias_map.update(other._alias_map)
+            for k, v in other._lookup_map.items():
+                self._lookup_map.setdefault(k, set()).update(v)
+        else:
+            self.update(other)
+        return self
+
+    @staticmethod
+    def _validate_merge_aliases(target, other):
+        """Check that other's aliases don't collide with target's keys and vice versa."""
+        for alias, key in other._alias_map.items():  # noqa
+            if alias in target.data:
+                raise AliasValueError(f"Alias '{alias}' already exists as a key in the dictionary")
+            if (existing := target._alias_map.get(alias)) is not None and existing != key:  # noqa
+                raise AliasValueError(f"Alias '{alias}' already assigned to key '{existing}'")
+        for key in other.data:
+            if key in target._alias_map:  # noqa
+                raise AliasValueError(f"Key '{key}' already exists as an alias in the dictionary")
+
+    __hash__ = None

{aldict-1.1.2 → aldict-1.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "aldict"
-version = "1.1.2"
+version = "1.2.1"
 requires-python = ">=3.10"
 authors = [
     { name = "kaliv0", email = "kaloyan.ivanov88@gmail.com" },

aldict-1.1.2/aldict/__init__.py

@@ -1,6 +0,0 @@
-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.2/aldict/alias_dict.py

@@ -1,180 +0,0 @@
-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.2/aldict/exception.py

@@ -1,6 +0,0 @@
-class AliasError(KeyError):
-    pass
-
-
-class AliasValueError(ValueError):
-    pass