aldict 1.0.0__tar.gz

aldict-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Kaloyan Ivanov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

aldict-1.0.0/PKG-INFO

@@ -0,0 +1,104 @@
+Metadata-Version: 2.1
+Name: aldict
+Version: 1.0.0
+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.11
+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"
+
+<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.11-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)
+
+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()
+```
+```shell
+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']
+```

aldict-1.0.0/README.md

@@ -0,0 +1,88 @@
+<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.11-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)
+
+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()
+```
+```shell
+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']
+```

aldict-1.0.0/aldict/__init__.py

@@ -0,0 +1,3 @@
+from .alias_dict import AliasDict as AliasDict
+from .exception import AliasError as AliasError
+from .exception import AliasValueError as AliasValueError

aldict-1.0.0/aldict/alias_dict.py

@@ -0,0 +1,92 @@
+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__(self, **dict_)
+
+    def add_alias(self, key, *aliases):
+        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):
+        for alias in aliases:
+            try:
+                self._alias_dict.__delitem__(alias)
+            except KeyError as e:
+                raise AliasError(alias) from e
+
+    def clear_aliases(self):
+        self._alias_dict.clear()
+
+    def aliases(self):
+        return self._alias_dict.keys()
+
+    def aliased_keys(self):
+        result = defaultdict(list)
+        for alias, key in self._alias_dict.items():
+            result[key].append(alias)
+        return result.items()
+
+    def origin_keys(self):
+        return self.data.keys()
+
+    def keys(self):
+        return dict(**self.data, **self._alias_dict).keys()
+
+    def values(self):
+        return self.data.values()
+
+    def items(self):
+        return dict(**self.data, **{k: self.data[v] for k, v in self._alias_dict.items()}).items()
+
+    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)
+        except KeyError:
+            # in case we try to delete alias e.g. via pop()
+            pass
+        self._alias_dict = {k: v for k, v in self._alias_dict.items() if v != key}
+
+    def __contains__(self, item):
+        return item in set(self.keys())
+
+    def __iter__(self):
+        for item in self.keys():
+            yield item
+
+    def __len__(self):
+        return len(self.keys())
+
+    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.0/aldict/exception.py

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

aldict-1.0.0/aldict.egg-info/PKG-INFO

@@ -0,0 +1,104 @@
+Metadata-Version: 2.1
+Name: aldict
+Version: 1.0.0
+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.11
+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"
+
+<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.11-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)
+
+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()
+```
+```shell
+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']
+```

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

@@ -0,0 +1,12 @@
+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.0/aldict.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

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

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

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

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

aldict-1.0.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=75.6.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "aldict"
+version = "1.0.0"
+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.11"
+
+[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.0/setup.cfg

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

aldict-1.0.0/tests/test_alias_dict.py

@@ -0,0 +1,246 @@
+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 ".yaml" in alias_dict
+
+
+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_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)]