Merge branch 'release/1.2.3'

Author: s3rius

.flake8

@@ -90,6 +90,8 @@ ignore =
   B008,
   ; Found except `BaseException`
   WPS424,
+  ; Found a too complex `f` string
+  WPS237,
 
   ; all init files
   __init__.py:

.github/workflows/test.yml

@@ -1,6 +1,6 @@
 name: Testing
 
-on: push
+on: [push, pull_request]
 
 jobs:
   pre_job:

README.md

@@ -176,3 +176,87 @@ with graph.sync_ctx(exception_propagation=False) as ctx:
 
 
 ```
+
+
+## Generics support
+
+We support generics substitution for class-based dependencies.
+For example, let's define an interface and a class. This class can be
+parameterized with some type and we consider this type a dependency.
+
+```python
+import abc
+from typing import Any, Generic, TypeVar
+
+class MyInterface(abc.ABC):
+    @abc.abstractmethod
+    def getval(self) -> Any:
+        ...
+
+
+_T = TypeVar("_T", bound=MyInterface)
+
+
+class MyClass(Generic[_T]):
+    # We don't know exact type, but we assume
+    # that it can be used as a dependency.
+    def __init__(self, resource: _T = Depends()):
+        self.resource = resource
+
+    @property
+    def my_value(self) -> Any:
+        return self.resource.getval()
+
+```
+
+Now let's create several implementation of defined interface:
+
+```python
+
+def getstr() -> str:
+    return "strstr"
+
+
+def getint() -> int:
+    return 100
+
+
+class MyDep1(MyInterface):
+    def __init__(self, s: str = Depends(getstr)) -> None:
+        self.s = s
+
+    def getval(self) -> str:
+        return self.s
+
+
+class MyDep2(MyInterface):
+    def __init__(self, i: int = Depends(getint)) -> None:
+        self.i = i
+
+    def getval(self) -> int:
+        return self.i
+
+```
+
+Now you can use these dependencies by just setting proper type hints.
+
+```python
+def my_target(
+    d1: MyClass[MyDep1] = Depends(),
+    d2: MyClass[MyDep2] = Depends(),
+) -> None:
+    print(d1.my_value)
+    print(d2.my_value)
+
+
+with DependencyGraph(my_target).sync_ctx() as ctx:
+    my_target(**ctx.resolve_kwargs())
+
+```
+
+This code will is going to print:
+
+```
+strstr
+100
+```

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "taskiq-dependencies"
-version = "1.2.2"
+version = "1.2.3"
 description = "FastAPI like dependency injection implementation"
 authors = ["Pavel Kirilin <win10@list.ru>"]
 readme = "README.md"

taskiq_dependencies/dependency.py

@@ -102,20 +102,22 @@ class Dependency:
     and calculate before execution.
     """
 
-    def __init__(  # noqa: WPS234
+    def __init__(  # noqa: WPS211, WPS234
         self,
         dependency: Optional[Union[Type[Any], Callable[..., Any]]] = None,
         *,
         use_cache: bool = True,
         kwargs: Optional[Dict[str, Any]] = None,
         signature: Optional[inspect.Parameter] = None,
+        parent: "Optional[Dependency]" = None,
     ) -> None:
         self._id = uuid.uuid4()
         self.dependency = dependency
         self.use_cache = use_cache
         self.param_name = ""
         self.kwargs = kwargs or {}
         self.signature = signature
+        self.parent = parent
 
     def __hash__(self) -> int:
         return hash(self._id)

taskiq_dependencies/graph.py

@@ -1,7 +1,7 @@
 import inspect
 from collections import defaultdict, deque
 from graphlib import TopologicalSorter
-from typing import Any, Callable, Dict, List, Optional, get_type_hints
+from typing import Any, Callable, Dict, List, Optional, TypeVar, get_type_hints
 
 from taskiq_dependencies.ctx import AsyncResolveContext, SyncResolveContext
 from taskiq_dependencies.dependency import Dependency
@@ -103,18 +103,55 @@ def _build_graph(self) -> None:  # noqa: C901, WPS210
             if dep.dependency is None:
                 continue
             # Get signature and type hints.
-            sign = inspect.signature(dep.dependency)
-            if inspect.isclass(dep.dependency):
+            origin = getattr(dep.dependency, "__origin__", None)
+            if origin is None:
+                origin = dep.dependency
+
+            # If we found the typevar.
+            # It means, that somebody depend on generic type.
+            if isinstance(origin, TypeVar):
+                if dep.parent is None:
+                    raise ValueError(f"Cannot resolve generic {dep.dependency}")
+                parent_cls = dep.parent.dependency
+                parent_cls_origin = getattr(parent_cls, "__origin__", None)
+                # If we cannot find origin, than means, that we cannot resolve
+                # generic parameters. So exiting.
+                if parent_cls_origin is None:
+                    raise ValueError(
+                        f"Unknown generic argument {origin}. "
+                        + f"Please provide a type in param `{dep.parent.param_name}`"
+                        + f" of `{dep.parent.dependency}`",
+                    )
+                # We zip together names of parameters and the subsctituted values
+                # In parameters we would see TypeVars in args
+                # we would find actual classes.
+                generics = zip(
+                    parent_cls_origin.__parameters__,
+                    parent_cls.__args__,  # type: ignore
+                )
+                for tvar, type_param in generics:
+                    # If we found the typevar we're currently try to resolve,
+                    # we need to find origin of the substituted class.
+                    if tvar == origin:
+                        dep.dependency = type_param
+                        origin = getattr(type_param, "__origin__", None)
+                        if origin is None:
+                            origin = type_param
+
+            if inspect.isclass(origin):
                 # If this is a class, we need to get signature of
                 # an __init__ method.
-                hints = get_type_hints(dep.dependency.__init__)  # noqa: WPS609
+                hints = get_type_hints(origin.__init__)  # noqa: WPS609
+                sign = inspect.signature(origin.__init__)  # noqa: WPS609
             elif inspect.isfunction(dep.dependency):
                 # If this is function or an instance of a class, we get it's type hints.
                 hints = get_type_hints(dep.dependency)
+                sign = inspect.signature(origin)  # type: ignore
             else:
                 hints = get_type_hints(
                     dep.dependency.__call__,  # type: ignore # noqa: WPS609
                 )
+                sign = inspect.signature(origin)  # type: ignore
 
             # Now we need to iterate over parameters, to
             # find all parameters, that have TaskiqDepends as it's
@@ -172,6 +209,7 @@ def _build_graph(self) -> None:  # noqa: C901, WPS210
                     use_cache=default_value.use_cache,
                     kwargs=default_value.kwargs,
                     signature=param,
+                    parent=dep,
                 )
                 # Also we set the parameter name,
                 # it will help us in future when