feat: ✨ Custom default value for get_instance and get_lazy_instance

Author: remimd

injection/__init__.pyi

@@ -136,18 +136,23 @@ class Module:
         parameter or an exception will be raised.
         """
 
-    def get_instance[T](self, cls: _InputType[T]) -> T | None:
+    def get_instance[T, Default](
+        self,
+        cls: _InputType[T],
+        default: Default | None = ...,
+    ) -> T | Default | None:
         """
         Function used to retrieve an instance associated with the type passed in
         parameter or return `None`.
         """
 
-    def get_lazy_instance[T](
+    def get_lazy_instance[T, Default](
         self,
         cls: _InputType[T],
+        default: Default | None = ...,
         *,
         cache: bool = ...,
-    ) -> _Invertible[T | None]:
+    ) -> _Invertible[T | Default | None]:
         """
         Function used to retrieve an instance associated with the type passed in
         parameter or `None`. Return a `Invertible` object. To access the instance

injection/_core/module.py

@@ -572,22 +572,27 @@ def find_instance[T](self, cls: InputType[T]) -> T:
         injectable = self[cls]
         return injectable.get_instance()
 
-    def get_instance[T](self, cls: InputType[T]) -> T | None:
+    def get_instance[T, Default](
+        self,
+        cls: InputType[T],
+        default: Default | None = None,
+    ) -> T | Default | None:
         try:
             return self.find_instance(cls)
         except KeyError:
-            return None
+            return default
 
-    def get_lazy_instance[T](
+    def get_lazy_instance[T, Default](
         self,
         cls: InputType[T],
+        default: Default | None = None,
         *,
         cache: bool = False,
-    ) -> Invertible[T | None]:
+    ) -> Invertible[T | Default | None]:
         if cache:
-            return Lazy(lambda: self.get_instance(cls))
+            return Lazy(lambda: self.get_instance(cls, default))
 
-        function = self.inject(lambda instance=None: instance)
+        function = self.inject(lambda instance=default: instance)
         function.__injected__.set_owner(cls)
         return SimpleInvertible(function)
 

injection/integrations/fastapi.py

@@ -1,6 +1,6 @@
 from collections.abc import Callable
 from types import GenericAlias
-from typing import Any, TypeAliasType
+from typing import Any, ClassVar, TypeAliasType
 
 from injection import Module, mod
 from injection.exceptions import InjectionError
@@ -33,8 +33,10 @@ class InjectionDependency[T]:
     __call__: Callable[[], T]
     __class: type[T] | TypeAliasType | GenericAlias
 
+    __sentinel: ClassVar[object] = object()
+
     def __init__(self, cls: type[T] | TypeAliasType | GenericAlias, module: Module):
-        lazy_instance = module.get_lazy_instance(cls)
+        lazy_instance = module.get_lazy_instance(cls, default=self.__sentinel)
         self.__call__ = lambda: self.__ensure(~lazy_instance)
         self.__class = cls
 
@@ -47,8 +49,8 @@ def __eq__(self, other: Any) -> bool:
     def __hash__(self) -> int:
         return hash((self.__class,))
 
-    def __ensure(self, instance: T | None) -> T:
-        if instance is None:
+    def __ensure(self, instance: T | Any) -> T:
+        if instance is self.__sentinel:
             raise InjectionError(f"`{self.__class}` is an unknown dependency.")
 
         return instance