refactoring: ♻️ ModuleEventProxy

Author: remimd

injection/common/lazy.py

@@ -1,9 +1,6 @@
-from functools import partial
-from types import new_class
+from types import MappingProxyType, new_class
 from typing import Any, Callable, Generic, Iterator, Mapping, TypeVar
 
-from frozendict import frozendict
-
 __all__ = ("Lazy", "LazyMapping")
 
 _sentinel = new_class("sentinel")()
@@ -22,7 +19,7 @@ def __init__(self, factory: Callable[[], T]):
 
     def __setattr__(self, name: str, value: Any):
         if self.is_set:
-            raise TypeError(f"`{repr(self)}` is frozen.")
+            raise TypeError(f"`{self}` is frozen.")
 
         return super().__setattr__(name, value)
 
@@ -47,11 +44,10 @@ def is_set(self) -> bool:
 class LazyMapping(Mapping[K, V]):
     __slots__ = ("__lazy",)
 
-    __lazy: Lazy[frozendict[K, V]]
+    __lazy: Lazy[MappingProxyType[K, V]]
 
     def __init__(self, iterator: Iterator[tuple[K, V]]):
-        factory = partial(frozendict, iterator)
-        self.__lazy = Lazy(factory)
+        self.__lazy = Lazy(lambda: MappingProxyType(dict(iterator)))
 
     def __getitem__(self, key: K) -> V:
         return self.__lazy.value[key]

injection/core/module.py

@@ -84,29 +84,37 @@ class ModuleEventProxy(ModuleEvent):
     def __str__(self) -> str:
         return f"`{self.on_module}` has propagated an event: {self.origin}"
 
-    def __iter__(self) -> Iterator[Event]:
+    @property
+    def history(self) -> Iterator[Event]:
         if isinstance(self.event, ModuleEventProxy):
-            yield from self.event
+            yield from self.event.history
 
         yield self.event
 
     @property
     def origin(self) -> Event:
-        return next(iter(self))
+        return next(self.history)
 
-    @property
-    def is_circular(self) -> bool:
-        return any(
-            isinstance(event, ModuleEvent) and event.on_module is self.on_module
-            for event in self
-        )
+    def check_recursion(self):
+        last_module = None
+        found = False
 
-    @property
-    def previous_module(self) -> Module | None:
-        if isinstance(self.event, ModuleEvent):
-            return self.event.on_module
+        for event in self.history:
+            if not isinstance(event, ModuleEvent):
+                continue
 
-        return None
+            last_module = event.on_module
+
+            if found is False:
+                found = last_module is self.on_module
+
+        if found:
+            raise ModuleCircularUseError(
+                "Circular dependency between two modules: "
+                f"`{self.on_module}` and `{last_module}`."
+            )
+
+        return self
 
 
 @dataclass(frozen=True, slots=True)
@@ -390,14 +398,7 @@ def remove_listener(self, listener: EventListener):
         return self
 
     def on_event(self, event: Event, /):
-        self_event = ModuleEventProxy(self, event)
-
-        if self_event.is_circular:
-            raise ModuleCircularUseError(
-                "Circular dependency between two modules: "
-                f"`{self_event.previous_module}` and `{self}`."
-            )
-
+        self_event = ModuleEventProxy(self, event).check_recursion()
         self.notify(self_event)
 
     def notify(self, event: Event):

poetry.lock

@@ -11,7 +11,6 @@ repository = "https://github.com/simplysquare/python-injection"
 
 [tool.poetry.dependencies]
 python = ">=3.10, <4"
-frozendict = "*"
 
 [tool.poetry.group.dev.dependencies]
 black = "*"