Merge pull request #12 from taskiq-python/feature/generics

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
+```

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

tests/test_graph.py

@@ -1,6 +1,6 @@
 import asyncio
 import uuid
-from typing import Any, AsyncGenerator, Generator
+from typing import Any, AsyncGenerator, Generator, Generic, TypeVar
 
 import pytest
 
@@ -313,7 +313,6 @@ def target(class_val: str = Depends(TeClass("tval"))) -> None:
 
 
 def test_exception_generators() -> None:
-
     errors_found = 0
 
     def my_generator() -> Generator[int, None, None]:
@@ -335,7 +334,6 @@ def target(_: int = Depends(my_generator)) -> None:
 
 @pytest.mark.anyio
 async def test_async_exception_generators() -> None:
-
     errors_found = 0
 
     async def my_generator() -> AsyncGenerator[int, None]:
@@ -357,7 +355,6 @@ def target(_: int = Depends(my_generator)) -> None:
 
 @pytest.mark.anyio
 async def test_async_exception_generators_multiple() -> None:
-
     errors_found = 0
 
     async def my_generator() -> AsyncGenerator[int, None]:
@@ -383,7 +380,6 @@ def target(
 
 @pytest.mark.anyio
 async def test_async_exception_in_teardown() -> None:
-
     errors_found = 0
 
     async def my_generator() -> AsyncGenerator[int, None]:
@@ -404,7 +400,6 @@ def target(_: int = Depends(my_generator)) -> None:
 
 @pytest.mark.anyio
 async def test_async_propagation_disabled() -> None:
-
     errors_found = 0
 
     async def my_generator() -> AsyncGenerator[int, None]:
@@ -428,7 +423,6 @@ def target(_: int = Depends(my_generator)) -> None:
 
 
 def test_sync_propagation_disabled() -> None:
-
     errors_found = 0
 
     def my_generator() -> Generator[int, None, None]:
@@ -447,3 +441,133 @@ def target(_: int = Depends(my_generator)) -> None:
             target(**(g.resolve_kwargs()))
 
     assert errors_found == 0
+
+
+def test_generic_classes() -> None:
+    errors_found = 0
+
+    _T = TypeVar("_T")
+
+    class MyClass:
+        pass
+
+    class MainClass(Generic[_T]):
+        def __init__(self, val: _T = Depends()) -> None:
+            self.val = val
+
+    def test_func(a: MainClass[MyClass] = Depends()) -> MyClass:
+        return a.val
+
+    with DependencyGraph(target=test_func).sync_ctx(exception_propagation=False) as g:
+        value = test_func(**(g.resolve_kwargs()))
+
+    assert errors_found == 0
+    assert isinstance(value, MyClass)
+
+
+def test_generic_multiple() -> None:
+    errors_found = 0
+
+    _T = TypeVar("_T")
+    _V = TypeVar("_V")
+
+    class MyClass1:
+        pass
+
+    class MyClass2:
+        pass
+
+    class MainClass(Generic[_T, _V]):
+        def __init__(self, t_val: _T = Depends(), v_val: _V = Depends()) -> None:
+            self.t_val = t_val
+            self.v_val = v_val
+
+    def test_func(
+        a: MainClass[MyClass1, MyClass2] = Depends(),
+    ) -> MainClass[MyClass1, MyClass2]:
+        return a
+
+    with DependencyGraph(target=test_func).sync_ctx(exception_propagation=False) as g:
+        result = test_func(**(g.resolve_kwargs()))
+
+    assert errors_found == 0
+    assert isinstance(result.t_val, MyClass1)
+    assert isinstance(result.v_val, MyClass2)
+
+
+def test_generic_unordered() -> None:
+    errors_found = 0
+
+    _T = TypeVar("_T")
+    _V = TypeVar("_V")
+
+    class MyClass1:
+        pass
+
+    class MyClass2:
+        pass
+
+    class MainClass(Generic[_T, _V]):
+        def __init__(self, v_val: _V = Depends(), t_val: _T = Depends()) -> None:
+            self.t_val = t_val
+            self.v_val = v_val
+
+    def test_func(
+        a: MainClass[MyClass1, MyClass2] = Depends(),
+    ) -> MainClass[MyClass1, MyClass2]:
+        return a
+
+    with DependencyGraph(target=test_func).sync_ctx(exception_propagation=False) as g:
+        result = test_func(**(g.resolve_kwargs()))
+
+    assert errors_found == 0
+    assert isinstance(result.t_val, MyClass1)
+    assert isinstance(result.v_val, MyClass2)
+
+
+def test_generic_classes_nesting() -> None:
+    errors_found = 0
+
+    _T = TypeVar("_T")
+    _V = TypeVar("_V")
+
+    class DummyClass:
+        pass
+
+    class DependantClass(Generic[_V]):
+        def __init__(self, var: _V = Depends()) -> None:
+            self.var = var
+
+    class MainClass(Generic[_T]):
+        def __init__(self, var: _T = Depends()) -> None:
+            self.var = var
+
+    def test_func(a: MainClass[DependantClass[DummyClass]] = Depends()) -> DummyClass:
+        return a.var.var
+
+    with DependencyGraph(target=test_func).sync_ctx(exception_propagation=False) as g:
+        value = test_func(**(g.resolve_kwargs()))
+
+    assert errors_found == 0
+    assert isinstance(value, DummyClass)
+
+
+def test_generic_class_based_dependencies() -> None:
+    """Tests that if ParamInfo is used on the target, no error is raised."""
+
+    _T = TypeVar("_T")
+
+    class GenericClass(Generic[_T]):
+        def __init__(self, class_val: _T = Depends()):
+            self.return_val = class_val
+
+    def func_dep() -> GenericClass[int]:
+        return GenericClass(123)
+
+    def target(my_dep: GenericClass[int] = Depends(func_dep)) -> int:
+        return my_dep.return_val
+
+    with DependencyGraph(target=target).sync_ctx() as g:
+        result = target(**g.resolve_kwargs())
+
+    assert result == 123