black reformatting

Author: KommuSoft

inheritance_dict/__init__.py

@@ -20,7 +20,7 @@
 def concatMap(func, items):
     """
     Yield items from the iterables produced by applying func to each element of items.
-    
+
     func should be a callable that accepts a single item and returns an iterable; concatMap lazily iterates over items, calls func(item) for each, and yields each element from the resulting iterable in order.
     """
     for item in items:
@@ -37,11 +37,11 @@ class BaseDict(dict):
     def _get_keys(self, key) -> Iterable[object]:
         """
         Return an iterable of candidate lookup keys for dictionary lookup.
-        
+
         This default implementation yields only the original `key`. Subclasses (e.g., those that perform
         Method Resolution Order or tuple-based fallback lookups) should override this to produce additional
         candidate keys to try in order.
-        
+
         Returns:
             Iterable[object]: An iterable yielding candidate keys; by default a single-item tuple containing `key`.
         """
@@ -50,7 +50,7 @@ def _get_keys(self, key) -> Iterable[object]:
     def __getitem__(self, key):
         """
         Return the value mapped to `key` by trying candidate lookup keys produced by `_get_keys`.
-        
+
         This performs lookups in the order produced by `self._get_keys(key)` and returns the first mapped value found. If no candidate is present in the mapping a `KeyError` is raised.
         """
         for item in self._get_keys(key):
@@ -115,14 +115,14 @@ def _get_keys(self, key) -> Iterable[object]:
         """
         Return an iterable of candidate lookup keys, expanding tuple keys by concatenating
         the candidate sequences for each element.
-        
+
         If `key` is a tuple, yields all items produced by applying the superclass's
         `_get_keys` to each element of the tuple (flattened in element order). If `key`
         is not a tuple, delegates to the superclass's `_get_keys`.
-        
+
         Parameters:
             key: The lookup key or a tuple of lookup keys.
-        
+
         Returns:
             An iterable of candidate keys to try for dictionary lookup.
         """
@@ -162,12 +162,12 @@ class TypeConvertingInheritanceDict(InheritanceDict):
     def _get_keys(self, key):
         """
         Yield candidate lookup keys for a lookup key.
-        
+
         Always yields the candidates produced by super()._get_keys(key). If key is not a type, also yields the candidates produced by super()._get_keys(type(key)) so lookups will fall back to the key's type (and its MRO) after the original candidates.
-        
+
         Parameters:
             key: The lookup key. Non-type keys cause an additional sequence of candidate keys derived from type(key).
-        
+
         Yields:
             Candidate keys (types or other lookup keys) in the order they should be tried.
         """

typetest.py

@@ -1,7 +1,11 @@
 import unittest
 from datetime import date, datetime, time, timedelta
 
-from inheritance_dict import FallbackInheritanceDict, InheritanceDict, TypeConvertingInheritanceDict
+from inheritance_dict import (
+    FallbackInheritanceDict,
+    InheritanceDict,
+    TypeConvertingInheritanceDict,
+)
 
 
 class A(str):
@@ -13,14 +17,14 @@ class TypeTest(unittest.TestCase):
     def setUpClass(cls):
         """
         Create shared class-level dictionary fixtures used by the tests.
-        
+
         Sets up five fixtures on the test class:
         - inheritance_dict: InheritanceDict({object: 1, int: 2, str: 3, "a": 4})
         - inheritance_dict2: InheritanceDict({int: 2, str: 3, "a": 4})
         - inheritance_dict3: FallbackInheritanceDict({int: 2, str: 3, "a": 4})
         - type_converting_inheritance_dict: TypeConvertingInheritanceDict({object: 1, int: 2, str: 3, "a": 4})
         - type_converting_inheritance_dict2: TypeConvertingInheritanceDict({int: 2, str: 3, "a": 4})
-        
+
         These fixtures are reused across tests to verify exact-type lookups, MRO-based resolution, tuple-key fallbacks, and type-converting behavior.
         """
         super().setUpClass()