feat: ⚡️ Shorter syntax for FastAPI dependencies

Author: remimd

documentation/integrations.md

@@ -8,29 +8,11 @@
 
 Here's how to inject an instance into a FastAPI endpoint.
 
-> Import:
-
 ```python
 from injection.ext.fastapi import Inject
-```
-
-> With **Annotated**:
-
-```python
-@app.get("/")
-async def my_endpoint(
-    service: Annotated[MyService, Inject(MyService)],
-) -> None:
-    ...
-```
 
-> Without **Annotated**:
-
-```python
 @app.get("/")
-async def my_endpoint(
-    service: MyService = Inject(MyService),
-) -> None:
+async def my_endpoint(service: Inject[MyService]) -> None:
     ...
 ```
 

injection/ext/fastapi.py

@@ -1,5 +1,5 @@
 from types import GenericAlias
-from typing import Any, TypeAliasType
+from typing import TYPE_CHECKING, Annotated, Any, TypeAliasType
 
 from fastapi import Depends
 
@@ -8,20 +8,37 @@
 __all__ = ("Inject",)
 
 
-def Inject[T](  # noqa: N802
-    cls: type[T] | TypeAliasType | GenericAlias,
-    /,
-    default: T = NotImplemented,
-    module: Module | None = None,
-) -> Any:
-    """
-    Declare a FastAPI dependency with `python-injection`.
-    """
+class FastAPIInject:
+    __slots__ = ()
 
-    module = module or mod()
-    lazy_instance = module.aget_lazy_instance(cls, default)
+    def __call__[T](
+        self,
+        cls: type[T] | TypeAliasType | GenericAlias,
+        /,
+        default: T = NotImplemented,
+        module: Module | None = None,
+    ) -> Any:
+        module = module or mod()
+        lazy_instance = module.aget_lazy_instance(cls, default)
 
-    async def getter() -> T:
-        return await lazy_instance
+        async def getter() -> T:
+            return await lazy_instance
 
-    return Depends(getter, use_cache=False)
+        return Depends(getter, use_cache=False)
+
+    def __getitem__(self, params: Any, /) -> Any:
+        if not isinstance(params, tuple):
+            params = (params,)
+
+        iter_params = iter(params)
+        cls = next(iter_params)
+        return Annotated[cls, self(cls), *iter_params]
+
+
+if TYPE_CHECKING:
+    type Inject[T, *Args] = Annotated[T, Depends(), *Args]
+
+else:
+    Inject = FastAPIInject()
+
+del FastAPIInject

tests/ext/test_fastapi.py

@@ -13,12 +13,12 @@ class Dependency: ...
 
 
 @application.post("/integration", status_code=204)
-async def integration_endpoint(dependency: Dependency = Inject(Dependency)):
+async def integration_endpoint(dependency: Inject[Dependency]):
     assert isinstance(dependency, Dependency)
 
 
 @application.post("/integration-unknown-dependency", status_code=204)
-async def integration_unknown_dependency_endpoint(dependency: object = Inject(object)):
+async def integration_unknown_dependency_endpoint(dependency: Inject[object]):
     assert dependency is NotImplemented