✨ Added function to inject dependencies

Author: serivt

pymediator/mediator.py

@@ -16,27 +16,48 @@ class BaseMediator(ABC):
     request to the handler.
     """
 
-    def __init__(self, *, registry: Registry) -> None:
+    def __init__(self, *, registry: Registry, dependencies: dict | None = None) -> None:
         self._registry: Registry = registry
+        self._dependencies: dict = dependencies or {}
+
+    @property
+    def registry(self) -> Registry:
+        return self._registry
+
+    @abstractmethod
+    def inject(self, **kwargs) -> "BaseMediator":  # type: ignore[no-untyped-def]
+        """
+        Abstract method to inject dependencies to the handler.
+
+        Args:
+            kwargs (dict[str, Any]): The dependencies to be injected.
+
+        Returns:
+            BaseMediator: A mediator instance ready to inject dependencies when making
+                the handler call
+        """
 
     @abstractmethod
-    def send(self, request: Request, dependencies: dict[str, Any] | None = None) -> Any:
+    def send(self, request: Request) -> Any:
         """
         Abstract method to send the request to the handler.
 
         Args:
             request (Request): The request to be handled.
             dependencies (dict[str, Any] | None, optional): A dictionary of dependencies
-            to pass to the handler during execution.
+                to pass to the handler during execution.
 
         Returns:
             Any: The result from handling the request.
         """
 
 
 class Mediator(BaseMediator):
-    def send(self, request: Request, dependencies: dict[str, Any] | None = None) -> Any:
-        handler: Handler = self._registry.get_handler(request)(**(dependencies or {}))
+    def inject(self, **kwargs) -> "Mediator":  # type: ignore[no-untyped-def]
+        return Mediator(registry=self.registry, dependencies=kwargs)
+
+    def send(self, request: Request) -> Any:
+        handler: Handler = self._registry.get_handler(request)(**self._dependencies)
         if not isinstance(handler, Handler):
             raise HandlerProtocolViolationException(handler.__class__.__name__)
         return handler.handle(request)

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pymediator"
-version = "0.1.0"
+version = "0.2.0"
 description = "Lightweight and extensible implementation of the Mediator pattern in Python"
 authors = ["Sergio Torrado"]
 license = "MIT"

tests/test_mediators.py

@@ -37,3 +37,26 @@ def sum(self, request: SumRequest) -> int:
         mediator: Mediator = Mediator(registry=registry)
         with pytest.raises(HandlerProtocolViolationException):
             mediator.send(SumRequest(x=3, y=5))
+
+    def test_injection(self) -> None:
+        class SumUtils:
+            def sum(self, x: int, y: int) -> int:
+                return x + y
+
+        @dataclass
+        class SumRequest:
+            x: int
+            y: int
+
+        class SumHandler:
+            def __init__(self, sum_utils: SumUtils) -> None:
+                self._sum_utils: SumUtils = sum_utils
+
+            def handle(self, request: SumRequest) -> int:
+                return self._sum_utils.sum(request.x, request.y)
+
+        registry: InstanceRegistry = InstanceRegistry()
+        registry.register(SumRequest, SumHandler)
+        mediator: Mediator = Mediator(registry=registry)
+        response: int = mediator.inject(sum_utils=SumUtils()).send(SumRequest(x=3, y=5))
+        assert response == 8