aldict 1.1.1__py3-none-any.whl → 1.2.0__py3-none-any.whl

aldict/__init__.py

@@ -2,5 +2,5 @@ from .alias_dict import AliasDict as AliasDict
 from .exception import AliasError as AliasError
 from .exception import AliasValueError as AliasValueError
 
-__version__ = "1.1.1"
+__version__ = "1.2.0"
 __all__ = ["AliasDict", "AliasError", "AliasValueError"]

aldict/alias_dict.py

@@ -1,4 +1,4 @@
-from collections import UserDict, defaultdict
+from collections import UserDict
 from collections.abc import Mapping
 from itertools import chain
 
@@ -9,10 +9,13 @@ class AliasDict(UserDict):
     """Dict with key-aliases pointing to shared values."""
 
     def __init__(self, dict_=None, /, aliases=None):
-        self._alias_dict = {}
+        self._lookup_map = {}  # key -> set(aliases)
+        self._alias_map = {}  # alias -> key
+
         if isinstance(dict_, AliasDict):
             super().__init__(dict_.data)
-            self._alias_dict = dict(dict_._alias_dict)
+            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_)
 
@@ -20,8 +23,9 @@ class AliasDict(UserDict):
             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."""
+    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)
 
@@ -30,16 +34,31 @@ class AliasDict(UserDict):
                 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
+
+            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:
-                self._alias_dict.__delitem__(alias)
+                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
@@ -52,30 +71,29 @@ class AliasDict(UserDict):
     def clear(self):
         """Clear all data and aliases."""
         super().clear()
-        self._alias_dict.clear()
+        self._lookup_map.clear()
+        self._alias_map.clear()
 
     def clear_aliases(self):
         """Remove all aliases."""
-        self._alias_dict.clear()
+        self._lookup_map.clear()
+        self._alias_map.clear()
 
     def aliases(self):
         """Return all aliases."""
-        return self._alias_dict.keys()
+        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_dict
+        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._alias_dict.values()
+        return key in self._lookup_map
 
     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()
+        return self._lookup_map.items()
 
     def origin_keys(self):
         """Return original keys (without aliases)."""
@@ -83,12 +101,11 @@ class AliasDict(UserDict):
 
     def origin_key(self, alias):
         """Return the original key for an alias, or None if not an alias."""
-        return self._alias_dict.get(alias)
+        return self._alias_map.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())
+        return (self.data | self._alias_map).keys()
 
     def values(self):
         """Return all values."""
@@ -96,47 +113,52 @@ class AliasDict(UserDict):
 
     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)
+        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_dict)
+        return len(self.data) + len(self._alias_map)
 
     def __missing__(self, key):
         try:
-            return super().__getitem__(self._alias_dict[key])
+            return super().__getitem__(self._alias_map[key])
         except KeyError:
             raise KeyError(key) from None
 
     def __setitem__(self, key, value):
         try:
-            key = self._alias_dict[key]
+            key = self._alias_map[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]
+            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_dict
+        return item in self.data or item in self._alias_map
 
     def __iter__(self):
-        return chain(self.data, self._alias_dict)
+        return chain(self.data, self._alias_map)
 
     def __reversed__(self):
-        return chain(reversed(self._alias_dict), reversed(self.data))
+        return chain(reversed(self._alias_map), reversed(self.data))
 
     def copy(self):
         """Return a shallow copy of the AliasDict."""
@@ -148,7 +170,8 @@ class AliasDict(UserDict):
     def __eq__(self, other):
         if not isinstance(other, AliasDict):
             return NotImplemented
-        return self.data == other.data and self._alias_dict == other._alias_dict
+        # _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):
@@ -156,7 +179,10 @@ class AliasDict(UserDict):
         new = self.copy()
         if isinstance(other, AliasDict):
             new.update(other.data)
-            new._alias_dict.update(other._alias_dict)
+            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
@@ -164,17 +190,35 @@ class AliasDict(UserDict):
     def __ror__(self, other):
         if not isinstance(other, Mapping):
             return NotImplemented
-        new = AliasDict(other)
+        new = type(self)(other)
         new.update(self.data)
-        new._alias_dict.update(self._alias_dict)
+        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_dict.update(other._alias_dict)
+            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.1.dist-info → aldict-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aldict
-Version: 1.1.1
+Version: 1.2.0
 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>
@@ -28,9 +28,9 @@ 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>)
+<br>(one-liner with <i>aliases</i> dict mapping <i>original key</i> to <i>alias keys</i>)
 ```python
-ad = AliasDict({"a": 1, "b": 2}, aliases={"a": ["aa", "aaa"], "b": ["bb"]})
+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
 ```
@@ -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.2.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+aldict-1.2.0.dist-info/METADATA,sha256=QNtG7xV9icevXw4BkrpNkcILHOUyu7Ch69NLNRI4B0M,5239
+aldict-1.2.0.dist-info/WHEEL,sha256=Wb0ASbVj8JvWHpOiIpPi7ucfIgJeCi__PzivviEAQFc,90
+aldict-1.2.0.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+aldict-1.2.0.dist-info/licenses/LICENSE,sha256=frOVyHZrx5o-fh5xC-kggT3MaLdp6yxV_YGpVXFHFSQ,1071
+aldict/__init__.py,sha256=Fog4LzmMPlKzmFAuJ7YpYVSmSemClWfs_gA3qjWP_q8,233
+aldict/alias_dict.py,sha256=JOC8-z08zhfEOSHyVoWg4dq1gX1MFs-bjFUBmeu7ydo,8012
+aldict/exception.py,sha256=rFNmv9HuUOn2toPVYpVPQq6SOsl8nvwtJpGhPkK1puQ,83
+aldict-1.2.0.dist-info/RECORD,,

{aldict-1.1.1.dist-info → aldict-1.2.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: pdm-backend (2.4.6)
+Generator: pdm-backend (2.4.7)
 Root-Is-Purelib: true
 Tag: py3-none-any

aldict-1.1.1.dist-info/RECORD

@@ -1,8 +0,0 @@
-aldict-1.1.1.dist-info/METADATA,sha256=nRJAZ0Ra2gbzejZufFJxyp8HAftTQ5I63zJYrdP7UIk,4882
-aldict-1.1.1.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
-aldict-1.1.1.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
-aldict-1.1.1.dist-info/licenses/LICENSE,sha256=frOVyHZrx5o-fh5xC-kggT3MaLdp6yxV_YGpVXFHFSQ,1071
-aldict/__init__.py,sha256=6dHZU-HPKpqt6z5bX4-zWA0Vy7Wm2emhnmO4aEnaRXk,233
-aldict/alias_dict.py,sha256=O4EGRp-VtW1Mb-Fr1-_VDkPof6G9UBYYhx5l2I8FKck,5934
-aldict/exception.py,sha256=rFNmv9HuUOn2toPVYpVPQq6SOsl8nvwtJpGhPkK1puQ,83
-aldict-1.1.1.dist-info/RECORD,,