Add typing for the factories

src/dependency_injector/providers.pyi

@@ -1,10 +1,86 @@
-from typing import TypeVar, Generic, Callable, Any
+from __future__ import annotations
+
+from typing import TypeVar, Generic, Type, Callable, Any, Tuple, Optional, Dict, Union
 
 Injection = Any
 T = TypeVar('T')
 
 
-class Factory(Generic[T]):
+class OverridingContext:
+    def __init__(self, overridden: Provider, overriding: Provider): ...
+    def __enter__(self) -> Provider: ...
+    def __exit__(self, *_: Any) -> None: ...
 
+
+class Provider:
+    def __init__(self) -> None: ...
+    def __call__(self, *args: Injection, **kwargs: Injection) -> Any: ...
+    def __deepcopy__(self, memo: Optional[Dict[str, Any]]) -> Provider: ...
+    def __str__(self) -> str: ...
+    def __repr__(self) -> str: ...
+    @property
+    def overridden(self) -> Tuple[Provider]: ...
+    @property
+    def last_overriding(self) -> Optional[Provider]: ...
+    def override(self, provider: Union[Provider, Any]) -> OverridingContext: ...
+    def reset_last_overriding(self) -> None: ...
+    def reset_override(self) -> None: ...
+    def delegate(self) -> Provider: ...
+    @property
+    def provider(self) -> Provider: ...
+
+
+class Factory(Provider, Generic[T]):
+    provided_type: Optional[Type]
     def __init__(self, provides: Callable[..., T], *args: Injection, **kwargs: Injection) -> None: ...
     def __call__(self, *args: Injection, **kwargs: Injection) -> T: ...
+    @property
+    def cls(self) -> T: ...
+    @property
+    def provides(self) -> T: ...
+    @property
+    def provided(self) -> ProvidedInstance: ...
+    @property
+    def args(self) -> Tuple[Injection]: ...
+    def add_args(self, *args: Injection) -> Factory[T]: ...
+    def set_args(self, *args: Injection) -> Factory[T]: ...
+    def clear_args(self) -> Factory[T]: ...
+    @property
+    def kwargs(self) -> Dict[str, Injection]: ...
+    def add_kwargs(self, **kwargs: Injection) -> Factory[T]: ...
+    def set_kwargs(self, **kwargs: Injection) -> Factory[T]: ...
+    def clear_kwargs(self) -> Factory[T]: ...
+    @property
+    def attributes(self) -> Dict[str, Injection]: ...
+    def add_attributes(self, **kwargs: Injection) -> Factory[T]: ...
+    def set_attributes(self, **kwargs: Injection) -> Factory[T]: ...
+    def clear_attributes(self) -> Factory[T]: ...
+
+
+class DelegatedFactory(Factory): ...
+
+
+class AbstractFactory(Factory):
+    def override(self, provider: Factory) -> OverridingContext: ...
+
+
+class ProvidedInstanceFluentInterface:
+    def __getattr__(self, item: str) -> AttributeGetter: ...
+    def __getitem__(self, item: str) -> ItemGetter: ...
+    def call(self, *args: Injection, **kwargs: Injection) -> MethodCaller: ...
+
+
+class ProvidedInstance(Provider, ProvidedInstanceFluentInterface):
+    def __init__(self, provider: Provider) -> None: ...
+
+
+class AttributeGetter(Provider, ProvidedInstanceFluentInterface):
+    def __init__(self, provider: Provider, attribute: str) -> None: ...
+
+
+class ItemGetter(Provider, ProvidedInstanceFluentInterface):
+    def __init__(self, provider: Provider, item: str) -> None: ...
+
+
+class MethodCaller(Provider, ProvidedInstanceFluentInterface):
+    def __init__(self, provider: Provider, *args: Injection, **kwargs: Injection) -> None: ...

tests/typing/factory.py

@@ -1,3 +1,5 @@
+from typing import Tuple, Any, Dict
+
 from dependency_injector import providers
 
 
@@ -19,3 +21,30 @@ animal1: Animal = provider1(1, 2, 3, b='1', c=2, e=0.0)
 # Test 2: to check the return type (class factory method)
 provider2 = providers.Factory(Cat.create)
 animal2: Animal = provider2()
+
+# Test 3: to check the .override() method
+provider3 = providers.Factory(Animal)
+with provider3.override(providers.Factory(Cat)):
+    provider3()
+
+# 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
+
+# Test 5: to check the provided instance interface
+provider5 = providers.Factory(Animal)
+provided5: providers.ProvidedInstance = provider5.provided
+attr_getter5: providers.AttributeGetter = provider5.provided.attr
+item_getter5: providers.ItemGetter = provider5.provided['item']
+method_caller: providers.MethodCaller = provider5.provided.method.call(123, arg=324)
+
+# Test 6: to check the DelegatedFactory
+provider6 = providers.DelegatedFactory(Cat)
+animal6: Animal = provider6(1, 2, 3, b='1', c=2, e=0.0)
+
+# 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)