feat: Bidirectional link possible between modules

Author: remimd

injection/_core/module.py

@@ -120,15 +120,25 @@ def __str__(self) -> str:
         return f"`{self.module}` has propagated an event: {self.origin}"
 
     @property
-    def history(self) -> Iterator[Event]:
-        if isinstance(self.event, ModuleEventProxy):
-            yield from self.event.history
-
-        yield self.event
+    def is_duplicate(self) -> bool:
+        module, origin = self.module, self.origin
+        return any(
+            module is event.module and origin is event.origin
+            for event in self.proxy_history
+        )
 
     @property
     def origin(self) -> Event:
-        return next(self.history)
+        reversed_proxy_history = reversed(tuple(self.proxy_history))
+        return next(reversed_proxy_history, self).event
+
+    @property
+    def proxy_history(self) -> Iterator[ModuleEventProxy]:
+        event = self.event
+
+        if isinstance(event, ModuleEventProxy):
+            yield event
+            yield from event.proxy_history
 
 
 @dataclass(frozen=True, slots=True)
@@ -162,8 +172,10 @@ def __str__(self) -> str:
 
 @dataclass(frozen=True, slots=True)
 class UnlockCalled(Event):
+    module: Module
+
     def __str__(self) -> str:
-        return "An `unlock` method has been called."
+        return f"`{self.module}.unlock` has been called."
 
 
 """
@@ -420,23 +432,18 @@ def __post_init__(self) -> None:
         self.__locator.add_listener(self)
 
     def __getitem__[T](self, cls: InputType[T], /) -> Injectable[T]:
-        for broker in self.__brokers:
+        for broker in self._iter_brokers():
             with suppress(KeyError):
                 return broker[cls]
 
         raise NoInjectable(cls)
 
     def __contains__(self, cls: InputType[Any], /) -> bool:
-        return any(cls in broker for broker in self.__brokers)
+        return any(cls in broker for broker in self._iter_brokers())
 
     @property
     def is_locked(self) -> bool:
-        return any(broker.is_locked for broker in self.__brokers)
-
-    @property
-    def __brokers(self) -> Iterator[Broker]:
-        yield from self.__modules
-        yield self.__locator
+        return any(broker.is_locked for broker in self._iter_brokers())
 
     def injectable[**P, T](
         self,
@@ -857,19 +864,19 @@ def change_priority(self, module: Module, priority: Priority | PriorityStr) -> S
         return self
 
     def unlock(self) -> Self:
-        event = UnlockCalled()
+        event = UnlockCalled(self)
 
         with self.dispatch(event, lock_bypass=True):
             self.unsafe_unlocking()
 
         return self
 
     def unsafe_unlocking(self) -> None:
-        for broker in self.__brokers:
+        for broker in self._iter_brokers():
             broker.unsafe_unlocking()
 
     async def all_ready(self) -> None:
-        for broker in self.__brokers:
+        for broker in self._iter_brokers():
             await broker.all_ready()
 
     def add_logger(self, logger: Logger) -> Self:
@@ -884,8 +891,12 @@ def remove_listener(self, listener: EventListener) -> Self:
         self.__channel.remove_listener(listener)
         return self
 
-    def on_event(self, event: Event, /) -> ContextManager[None]:
+    def on_event(self, event: Event, /) -> ContextManager[None] | None:
         self_event = ModuleEventProxy(self, event)
+
+        if self_event.is_duplicate:
+            return None
+
         return self.dispatch(self_event)
 
     @contextmanager
@@ -899,6 +910,20 @@ def dispatch(self, event: Event, *, lock_bypass: bool = False) -> Iterator[None]
             finally:
                 self.__debug(event)
 
+    def _iter_brokers(self, visited: set[Module] | None = None, /) -> Iterator[Broker]:
+        if visited is None:
+            visited = set()
+
+        if self in visited:
+            return
+
+        visited.add(self)
+
+        for module in self.__modules:
+            yield from module._iter_brokers(visited)
+
+        yield self.__locator
+
     def __debug(self, message: object) -> None:
         for logger in self.__loggers:
             logger.debug(message)

injection/loaders.py

@@ -176,12 +176,12 @@ def _unload(self, name: str, /) -> None:
 
     def __init_subsets_for(self, module: Module) -> Module:
         if not self.__is_empty and not self.__is_initialized(module):
+            self.__mark_initialized(module)
             target_modules = tuple(
                 self.__init_subsets_for(mod(name))
                 for name in self.module_subsets.get(module.name, ())
             )
             module.init_modules(*target_modules)
-            self.__mark_initialized(module)
 
         return module
 

tests/core/test_module.py

@@ -292,6 +292,16 @@ def test_use_with_module_already_in_use_raise_module_error(
 
         event_history.assert_length(1)
 
+    def test_use_with_bidirectional_use(self, module, event_history):
+        second_module = Module()
+        third_module = Module()
+
+        module.use(second_module)
+        second_module.use(module)
+        module.use(third_module)
+
+        event_history.assert_length(4)
+
     """
     stop_using
     """

tests/loaders/test_profile_loader.py

@@ -108,6 +108,28 @@ class B(A): ...
 
         assert type(find_instance(A)) is A
 
+    def test_load_with_bidirectional_link(self):
+        profile_name_1 = uuid4().hex
+        profile_name_2 = uuid4().hex
+
+        @mod(profile_name_1).injectable
+        class BaseConfig: ...
+
+        @mod(profile_name_2).injectable
+        @dataclass
+        class Dependency:
+            config: BaseConfig
+
+        loader = ProfileLoader(
+            {
+                profile_name_1: [profile_name_2],
+                profile_name_2: [profile_name_1],
+            }
+        )
+
+        with loader.load(profile_name_1):
+            assert find_instance(Dependency)
+
     def test_load_with_default_profile_do_nothing(self):
         default_profile_name = mod().name
         global_profile_name = uuid4().hex