Retrofit assert type for remaining type-stub checks

tests/typing/factory.py

@@ -1,4 +1,5 @@
 from typing import Any, Callable, Dict, Optional, Tuple, Type
+from typing_extensions import assert_type
 
 from dependency_injector import providers
 
@@ -17,103 +18,136 @@ def create(cls) -> Animal:
 
 # Test 1: to check the return type (class)
 provider1 = providers.Factory(Cat)
-animal1: Animal = provider1(1, 2, 3, b="1", c=2, e=0.0)
+animal1 = provider1(1, 2, 3, b="1", c=2, e=0.0)
+assert_type(animal1, Cat)
 
 # Test 2: to check the return type (class factory method)
 provider2 = providers.Factory(Cat.create)
-animal2: Animal = provider2()
+animal2 = provider2()
+assert_type(animal2, Animal)
 
 # Test 3: to check the .override() method
 provider3 = providers.Factory(Animal)
 with provider3.override(providers.Factory(Cat)):
-    provider3()
+    animal3 = provider3()
+    assert_type(animal3, Animal)
 
 # Test 4: to check the .args, .kwargs, .attributes attributes
 provider4 = providers.Factory(Animal)
-args4: Tuple[Any] = provider4.args
-kwargs4: Dict[str, Any] = provider4.kwargs
-attributes4: Dict[str, Any] = provider4.attributes
+args4 = provider4.args
+kwargs4  = provider4.kwargs
+attributes4 = provider4.attributes
+assert_type(args4, Tuple[Any])
+assert_type(kwargs4, Dict[str, Any])
+assert_type(attributes4, Dict[str, Any])
 
 # Test 5: to check the provided instance interface
 provider5 = providers.Factory(Animal)
-provided5: Animal = provider5.provided()
-attr_getter5: providers.AttributeGetter = provider5.provided.attr
-item_getter5: providers.ItemGetter = provider5.provided["item"]
-method_caller5: providers.MethodCaller = provider5.provided.method.call(123, arg=324)
+provided5 = provider5.provided
+provided_val5 = provided5()
+attr_getter5 = provider5.provided.attr
+item_getter5 = provider5.provided["item"]
+method_caller5 = provider5.provided.method.call(123, arg=324)
+assert_type(provided5, providers.ProvidedInstance)
+assert_type(provided_val5, Any)
+assert_type(attr_getter5, providers.AttributeGetter)
+assert_type(item_getter5, providers.ItemGetter)
+assert_type(method_caller5, providers.MethodCaller)
 
 # Test 6: to check the DelegatedFactory
 provider6 = providers.DelegatedFactory(Cat)
-animal6: Animal = provider6(1, 2, 3, b="1", c=2, e=0.0)
+animal6 = provider6(1, 2, 3, b="1", c=2, e=0.0)
+assert_type(animal6, Cat)
 
 # Test 7: to check the AbstractFactory
 provider7 = providers.AbstractFactory(Animal)
 provider7.override(providers.Factory(Cat))
-animal7: Animal = provider7(1, 2, 3, b="1", c=2, e=0.0)
+animal7 = provider7(1, 2, 3, b="1", c=2, e=0.0)
+assert_type(animal7, Animal)
 
 # Test 8: to check the FactoryDelegate __init__
 provider8 = providers.FactoryDelegate(providers.Factory(object))
 
 # Test 9: to check FactoryAggregate provider
-provider9: providers.FactoryAggregate[str] = providers.FactoryAggregate(
+provider9 = providers.FactoryAggregate(
     a=providers.Factory(str, "str1"),
     b=providers.Factory(str, "str2"),
 )
-factory_a_9: providers.Factory[str] = provider9.a
-factory_b_9: providers.Factory[str] = provider9.b
-val9: str = provider9("a")
-
-provider9_set_non_string_keys: providers.FactoryAggregate[str] = (
-    providers.FactoryAggregate()
+factory_a_9 = provider9.a
+factory_b_9 = provider9.b
+val9 = provider9("a")
+assert_type(provider9, providers.FactoryAggregate[str])
+assert_type(factory_a_9, providers.Factory[str])
+assert_type(factory_b_9, providers.Factory[str])
+assert_type(val9, str)
+
+provider9_set_non_string_keys = (
+    providers.FactoryAggregate[str]()
 )
 provider9_set_non_string_keys.set_factories({Cat: providers.Factory(str, "str")})
-factory_set_non_string_9: providers.Factory[str] = (
+factory_set_non_string_9 = (
     provider9_set_non_string_keys.factories[Cat]
 )
+assert_type(provider9_set_non_string_keys, providers.FactoryAggregate[str])
+assert_type(factory_set_non_string_9, providers.Factory[str])
 
-provider9_new_non_string_keys: providers.FactoryAggregate[str] = (
+provider9_new_non_string_keys = (
     providers.FactoryAggregate(
         {Cat: providers.Factory(str, "str")},
     )
 )
-factory_new_non_string_9: providers.Factory[str] = (
+factory_new_non_string_9 = (
     provider9_new_non_string_keys.factories[Cat]
 )
+assert_type(provider9_new_non_string_keys, providers.FactoryAggregate[str])
+assert_type(factory_new_non_string_9, providers.Factory[str])
 
 provider9_no_explicit_typing = providers.FactoryAggregate(
     a=providers.Factory(str, "str")
 )
-provider9_no_explicit_typing_factory: providers.Factory[str] = (
+provider9_no_explicit_typing_factory = (
     provider9_no_explicit_typing.factories["a"]
 )
-provider9_no_explicit_typing_object: str = provider9_no_explicit_typing("a")
+provider9_no_explicit_typing_object = provider9_no_explicit_typing("a")
+assert_type(provider9_no_explicit_typing, providers.FactoryAggregate[str])
+assert_type(provider9_no_explicit_typing_factory, providers.Factory[str])
+assert_type(provider9_no_explicit_typing_object, str)
 
 # Test 10: to check the explicit typing
-factory10: providers.Provider[Animal] = providers.Factory(Cat)
-animal10: Animal = factory10()
+factory10 = providers.Factory[Animal](Cat)
+animal10 = factory10()
+assert_type(factory10, providers.Factory[Animal])
+assert_type(animal10, Animal)
 
 # Test 11: to check the return type with await
 provider11 = providers.Factory(Cat)
 
 
 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)
+    animal1 = await provider11(1, 2, 3, b="1", c=2, e=0.0)  # type: ignore
+    animal2 = await provider11.async_(1, 2, 3, b="1", c=2, e=0.0)
+    assert_type(animal2, Cat)
 
 
 # Test 12: to check class type from .provides
 provider12 = providers.Factory(Cat)
-provided_cls12: Type[Animal] = provider12.cls
+provided_cls12 = provider12.cls
 assert issubclass(provided_cls12, Animal)
-provided_provides12: Optional[Callable[..., Animal]] = provider12.provides
+provided_provides12 = provider12.provides
 assert provided_provides12 is not None and provided_provides12() == Cat()
+assert_type(provided_cls12, Type[Cat])
+assert_type(provided_provides12, Callable[..., Cat])
+
 
 # Test 13: to check class from .provides with explicit typevar
 provider13 = providers.Factory[Animal](Cat)
-provided_cls13: Type[Animal] = provider13.cls
+provided_cls13 = provider13.cls
 assert issubclass(provided_cls13, Animal)
-provided_provides13: Optional[Callable[..., Animal]] = provider13.provides
+provided_provides13 = provider13.provides
 assert provided_provides13 is not None and provided_provides13() == Cat()
+assert_type(provided_cls13, Type[Animal])
+assert_type(provided_provides13, Callable[..., Animal])
 
 # Test 14: to check string imports
-provider14: providers.Factory[Dict[Any, Any]] = providers.Factory("builtins.dict")
+provider14 = providers.Factory[Any]("builtins.dict")
 provider14.set_provides("builtins.dict")

tests/typing/list.py

@@ -1,4 +1,5 @@
 from typing import Any, List, Tuple
+from typing_extensions import assert_type
 
 from dependency_injector import providers
 
@@ -7,25 +8,33 @@
     providers.Factory(object),
     providers.Factory(object),
 )
-var1: List[Any] = provider1()
+var1 = provider1()
+assert_type(var1, List[Any])
 
 
 # Test 2: to check the .args attributes
 provider2 = providers.List(
     providers.Factory(object),
     providers.Factory(object),
 )
-args2: Tuple[Any] = provider2.args
+args2 = provider2.args
+assert_type(args2, Tuple[Any])
 
 # Test 3: to check the provided instance interface
 provider3 = providers.List(
     providers.Factory(object),
     providers.Factory(object),
 )
-provided3: List[Any] = provider3.provided()
-attr_getter3: providers.AttributeGetter = provider3.provided.attr
-item_getter3: providers.ItemGetter = provider3.provided["item"]
-method_caller3: providers.MethodCaller = provider3.provided.method.call(123, arg=324)
+provided3 = provider3.provided
+provided_val3 = provided3()
+attr_getter3 = provider3.provided.attr
+item_getter3 = provider3.provided["item"]
+method_caller3 = provider3.provided.method.call(123, arg=324)
+assert_type(provided3, providers.ProvidedInstance)
+assert_type(provided_val3, Any)
+assert_type(attr_getter3, providers.AttributeGetter)
+assert_type(item_getter3, providers.ItemGetter)
+assert_type(method_caller3, providers.MethodCaller)
 
 # Test 4: to check the return type with await
 provider4 = providers.List(
@@ -35,5 +44,6 @@
 
 
 async def _async4() -> None:
-    var1: List[Any] = await provider4()  # type: ignore
-    var2: List[Any] = await provider4.async_()
+    var1 = await provider4()  # type: ignore
+    var2 = await provider4.async_()
+    assert_type(var2, List[Any])

tests/typing/object.py

@@ -1,27 +1,38 @@
-from typing import Optional, Type
+from typing import Optional, Any
+from typing_extensions import assert_type
 
 from dependency_injector import providers
 
 # Test 1: to check the return type
 provider1 = providers.Object(int(3))
-var1: int = provider1()
+var1 = provider1()
+assert_type(var1, int)
 
 # Test 2: to check the provided instance interface
 provider2 = providers.Object(int)
-provided2: Type[int] = provider2.provided()
-attr_getter2: providers.AttributeGetter = provider2.provided.attr
-item_getter2: providers.ItemGetter = provider2.provided["item"]
-method_caller2: providers.MethodCaller = provider2.provided.method.call(123, arg=324)
+provided2 = provider2.provided
+provided_val2 = provided2()
+attr_getter2 = provider2.provided.attr
+item_getter2 = provider2.provided["item"]
+method_caller2 = provider2.provided.method.call(123, arg=324)
+assert_type(provided2, providers.ProvidedInstance)
+assert_type(provided_val2, Any)
+assert_type(attr_getter2, providers.AttributeGetter)
+assert_type(item_getter2, providers.ItemGetter)
+assert_type(method_caller2, providers.MethodCaller)
+
 
 # Test 3: to check the return type with await
 provider3 = providers.Object(int(3))
 
 
 async def _async3() -> None:
-    var1: int = await provider3()  # type: ignore
-    var2: int = await provider3.async_()
+    var1 = await provider3()  # type: ignore
+    var2 = await provider3.async_()
+    assert_type(var2, int)
 
 
 # Test 4: to check class type from provider
 provider4 = providers.Object(int("1"))
-provided_provides: Optional[int] = provider4.provides
+provided_provides4 = provider4.provides
+assert_type(provided_provides4, Optional[int])

tests/typing/provider.py

@@ -1,17 +1,26 @@
 from typing import Any
+from typing_extensions import assert_type
 
 from dependency_injector import providers
 
 # Test 1: to check .provided attribute
 provider1: providers.Provider[int] = providers.Object(1)
-provided: int = provider1.provided()
-provider1_delegate: providers.Provider[int] = provider1.provider
+provided1 = provider1.provided
+provided_val1 = provided1()
+provider1_delegate = provider1.provider
+assert_type(provider1, providers.Provider[int])
+assert_type(provided1, providers.ProvidedInstance)
+assert_type(provided_val1, Any)
+assert_type(provider1_delegate, providers.Provider[int])
 
 # Test 2: to check async mode API
-provider2: providers.Provider[Any] = providers.Provider()
+provider2 = providers.Provider[Any]()
 provider2.enable_async_mode()
 provider2.disable_async_mode()
 provider2.reset_async_mode()
-r1: bool = provider2.is_async_mode_enabled()
-r2: bool = provider2.is_async_mode_disabled()
-r3: bool = provider2.is_async_mode_undefined()
+r1 = provider2.is_async_mode_enabled()
+r2 = provider2.is_async_mode_disabled()
+r3 = provider2.is_async_mode_undefined()
+assert_type(r1, bool)
+assert_type(r2, bool)
+assert_type(r3, bool)