Add type hints to method signatures.

Author: runemalm

src/dependency_injection/container.py

@@ -1,10 +1,13 @@
 import inspect
-from typing import Any, Dict, Type
+
+from typing import Any, Dict, Optional, TypeVar, Type
 
 from dependency_injection.registration import Registration
 from dependency_injection.scope import DEFAULT_SCOPE_NAME, Scope
 from dependency_injection.utils.singleton_meta import SingletonMeta
 
+Self = TypeVar('Self', bound='DependencyContainer')
+
 
 DEFAULT_CONTAINER_NAME = "default_container"
 
@@ -17,7 +20,7 @@ def __init__(self, name: str=None):
         self._scoped_instances = {}
 
     @classmethod
-    def get_instance(cls, name: str=None):
+    def get_instance(cls, name: str=None) -> Self:
         if name is None:
             name = DEFAULT_CONTAINER_NAME
 
@@ -26,22 +29,22 @@ def get_instance(cls, name: str=None):
 
         return cls._instances[(cls, name)]
 
-    def register_transient(self, dependency: Type, implementation: Type, constructor_args=None):
+    def register_transient(self, dependency: Type, implementation: Type, constructor_args: Optional[Dict[str, Any]] = None) -> None:
         if dependency in self._registrations:
             raise ValueError(f"Dependency {dependency} is already registered.")
         self._registrations[dependency] = Registration(dependency, implementation, Scope.TRANSIENT, constructor_args)
 
-    def register_scoped(self, dependency: Type, implementation: Type, constructor_args=None):
+    def register_scoped(self, dependency: Type, implementation: Type, constructor_args: Optional[Dict[str, Any]] = None) -> None:
         if dependency in self._registrations:
             raise ValueError(f"Dependency {dependency} is already registered.")
         self._registrations[dependency] = Registration(dependency, implementation, Scope.SCOPED, constructor_args)
 
-    def register_singleton(self, dependency: Type, implementation: Type, constructor_args=None):
+    def register_singleton(self, dependency: Type, implementation: Type, constructor_args: Optional[Dict[str, Any]] = None) -> None:
         if dependency in self._registrations:
             raise ValueError(f"Dependency {dependency} is already registered.")
         self._registrations[dependency] = Registration(dependency, implementation, Scope.SINGLETON, constructor_args)
 
-    def resolve(self, dependency: Type, scope_name=DEFAULT_SCOPE_NAME):
+    def resolve(self, dependency: Type, scope_name: str = DEFAULT_SCOPE_NAME) -> Type:
         if scope_name not in self._scoped_instances:
             self._scoped_instances[scope_name] = {}
 
@@ -106,7 +109,7 @@ def _validate_constructor_args(self, constructor_args: Dict[str, Any], implement
                         f"Constructor argument '{arg_name}' has an incompatible type. "
                         f"Expected type: {expected_type}, provided type: {type(arg_value)}.")
 
-    def _inject_dependencies(self, implementation, scope_name=None, constructor_args=None):
+    def _inject_dependencies(self, implementation: Type, scope_name: str = None, constructor_args: Optional[Dict[str, Any]] = None) -> Type:
         constructor = inspect.signature(implementation.__init__)
         params = constructor.parameters
 

src/dependency_injection/decorator.py

@@ -1,22 +1,25 @@
 import functools
 import inspect
+from typing import Any, Callable, TypeVar
 
 from dependency_injection.container import DEFAULT_CONTAINER_NAME, \
     DependencyContainer
 from dependency_injection.scope import DEFAULT_SCOPE_NAME
 
+F = TypeVar('F', bound=Callable[..., Any])
 
-def inject(container_name=DEFAULT_CONTAINER_NAME, scope_name=DEFAULT_SCOPE_NAME):
 
-    def is_instance_method(func):
+def inject(container_name=DEFAULT_CONTAINER_NAME, scope_name=DEFAULT_SCOPE_NAME) -> Callable[[F], F]:
+
+    def is_instance_method(func: Callable[..., Any]) -> bool:
         parameters = inspect.signature(func).parameters
         is_instance_method = len(parameters) > 0 and list(parameters.values())[0].name == 'self'
         return is_instance_method
 
-    def decorator_inject(func):
+    def decorator_inject(func: F) -> F:
 
         @functools.wraps(func)
-        def wrapper_inject(*args, **kwargs):
+        def wrapper_inject(*args: Any, **kwargs: Any) -> Any:
 
             # Get the parameter names from the function signature
             sig = inspect.signature(func)

src/dependency_injection/registration.py

@@ -1,11 +1,11 @@
-from typing import Any, Dict, Type
+from typing import Any, Dict, Optional, Type
 
 from dependency_injection.scope import Scope
 
 
 class Registration():
 
-    def __init__(self, dependency: Type, implementation: Type, scope: Scope, constructor_args: Dict[str, Any] = None):
+    def __init__(self, dependency: Type, implementation: Type, scope: Scope, constructor_args: Optional[Dict[str, Any]] = None):
         self.dependency = dependency
         self.implementation = implementation
         self.scope = scope