From 47cf4c253b5470294e2cb7e534b2b118169c731b Mon Sep 17 00:00:00 2001 From: Thiago Hiromi Date: Mon, 23 Aug 2021 03:23:18 +0200 Subject: [PATCH] Fix type hinting for .provides as @rmk135 suggested --- src/dependency_injector/providers.pyi | 6 +++--- tests/typing/callable.py | 13 +++++++++---- tests/typing/factory.py | 21 ++++++++++++++------- tests/typing/singleton.py | 19 +++++++++++++------ 4 files changed, 39 insertions(+), 20 deletions(-) diff --git a/src/dependency_injector/providers.pyi b/src/dependency_injector/providers.pyi index 0a538f17..17eee7a8 100644 --- a/src/dependency_injector/providers.pyi +++ b/src/dependency_injector/providers.pyi @@ -145,7 +145,7 @@ class DependenciesContainer(Object): class Callable(Provider[T]): def __init__(self, provides: Optional[_Callable[..., T]] = None, *args: Injection, **kwargs: Injection) -> None: ... @property - def provides(self) -> Type[T]: ... + def provides(self) -> Optional[_Callable[..., T]]: ... def set_provides(self, provides: Optional[_Callable[..., T]]) -> Callable[T]: ... @property def args(self) -> Tuple[Injection]: ... @@ -252,7 +252,7 @@ class Factory(Provider[T]): @property def cls(self) -> Type[T]: ... @property - def provides(self) -> Type[T]: ... + def provides(self) -> Optional[_Callable[..., T]]: ... def set_provides(self, provides: Optional[_Callable[..., T]]) -> Factory[T]: ... @property def args(self) -> Tuple[Injection]: ... @@ -303,7 +303,7 @@ class BaseSingleton(Provider[T]): @property def cls(self) -> Type[T]: ... @property - def provides(self) -> Type[T]: ... + def provides(self) -> Optional[_Callable[..., T]]: ... def set_provides(self, provides: Optional[_Callable[..., T]]) -> BaseSingleton[T]: ... @property def args(self) -> Tuple[Injection]: ... diff --git a/tests/typing/callable.py b/tests/typing/callable.py index 29922505..46966f9f 100644 --- a/tests/typing/callable.py +++ b/tests/typing/callable.py @@ -1,4 +1,4 @@ -from typing import Tuple, Any, Dict, Type +from typing import Callable, Optional, Tuple, Any, Dict, Type from dependency_injector import providers @@ -57,7 +57,12 @@ async def _async9() -> None: animal1: Animal = await provider9(1, 2, 3, b='1', c=2, e=0.0) # type: ignore animal2: Animal = await provider9.async_(1, 2, 3, b='1', c=2, e=0.0) -# Test 10: to check the provides attr +# Test 10: to check the .provides provider10 = providers.Callable(Cat) -provided_cls: Type[Cat] = provider10.provides -assert provided_cls is Cat +provides10: Optional[Callable[..., Cat]] = provider10.provides +assert provides10 is Cat + +# Test 11: to check the .provides for explicit typevar +provider11 = providers.Callable[Animal](Cat) +provides11: Optional[Callable[..., Animal]] = provider11.provides +assert provides11 is Cat diff --git a/tests/typing/factory.py b/tests/typing/factory.py index f86dea41..963eb37c 100644 --- a/tests/typing/factory.py +++ b/tests/typing/factory.py @@ -1,4 +1,4 @@ -from typing import Tuple, Any, Dict, Type +from typing import Callable, Optional, Tuple, Any, Dict, Type from dependency_injector import providers @@ -73,9 +73,16 @@ async def _async11() -> None: animal1: Animal = await provider11(1, 2, 3, b='1', c=2, e=0.0) # type: ignore animal2: Animal = await provider11.async_(1, 2, 3, b='1', c=2, e=0.0) -# Test 12: to check class type from provider -factory_provider = providers.Factory(int, '1') -factory_provided_cls: Type[int] = factory_provider.cls -assert factory_provided_cls("1") == 1 -factory_provided_provides: Type[int] = factory_provider.provides -assert factory_provided_provides("1") == 1 +# Test 12: to check class type from .provides +provider12 = providers.Factory(Cat) +provided_cls12: Type[Animal] = provider12.cls +assert issubclass(provided_cls12, Animal) +provided_provides12: Optional[Callable[..., Animal]] = provider12.provides +assert provided_provides12 is not None and provided_provides12() == Cat() + +# Test 13: to check class from .provides with explicit typevar +provider13 = providers.Factory[Animal](Cat) +provided_cls13: Type[Animal] = provider13.cls +assert issubclass(provided_cls13, Animal) +provided_provides13: Optional[Callable[..., Animal]] = provider13.provides +assert provided_provides13 is not None and provided_provides13() == Cat() diff --git a/tests/typing/singleton.py b/tests/typing/singleton.py index 4bc0bd83..11276c6e 100644 --- a/tests/typing/singleton.py +++ b/tests/typing/singleton.py @@ -1,4 +1,4 @@ -from typing import Tuple, Any, Dict, Type +from typing import Callable, Optional, Tuple, Any, Dict, Type from dependency_injector import providers @@ -76,9 +76,16 @@ async def _async13() -> None: animal1: Animal = await provider13(1, 2, 3, b='1', c=2, e=0.0) # type: ignore animal2: Animal = await provider13.async_(1, 2, 3, b='1', c=2, e=0.0) -# Test 14: to check class from provider +# Test 14: to check class from .provides provider14 = providers.Singleton(Cat) -provided_cls: Type[Cat] = provider14.cls -assert issubclass(provided_cls, Cat) -provided_provides: Type[Cat] = provider14.provides -assert issubclass(provided_provides, Cat) +provided_cls14: Type[Cat] = provider14.cls +assert issubclass(provided_cls14, Cat) +provided_provides14: Optional[Callable[..., Cat]] = provider14.provides +assert provided_provides14 is not None and provided_provides14() == Cat() + +# Test 15: to check class from .provides with explicit typevar +provider15 = providers.Singleton[Animal](Cat) +provided_cls15: Type[Animal] = provider15.cls +assert issubclass(provided_cls15, Animal) +provided_provides15: Optional[Callable[..., Animal]] = provider15.provides +assert provided_provides15 is not None and provided_provides15() == Cat()