Merge pull request #4 from runemalm/feature/next-version

Add next version.

Author: runemalm

README.md

@@ -67,6 +67,23 @@ dependency_container.register_transient(
     SomeClass,
     constructor_args={"arg1": value1, "arg2": value2}
 )
+
+# Registering dependencies with a factory
+dependency_container.register_factory(
+    SomeInterface,
+    lambda: SomeClass(arg1=value1, arg2=value2)
+)
+
+# Registering dependencies with an instance
+instance = SomeClass(arg1=value1, arg2=value2)
+dependency_container.register_instance(SomeInterface, instance)
+
+# Registering dependencies with tags
+dependency_container.register_transient(
+    SomeInterface,
+    SomeClass,
+    tags={SomeAdjective, AnotherAdjective}
+)
 ```
 
 ### Resolving dependencies using the container
@@ -80,6 +97,9 @@ scoped_instance = dependency_container.resolve(AnotherInterface, scope_name="som
 
 # Resolve singleton instance (consistent across the entire application).
 singleton_instance = dependency_container.resolve(ThirdInterface)
+
+# Resolve all instances with a specific tag
+tagged_instances = dependency_container.resolve_all(tags={SomeAdjective})
 ```
 
 ### Constructor injection
@@ -146,6 +166,12 @@ To contribute, create a pull request on the develop branch following the [git fl
 
 ## Release Notes
 
+### [1.0.0-alpha.6](https://github.com/runemalm/py-dependency-injection/releases/tag/v1.0.0-alpha.6) (2024-03-23)
+
+- **Factory Registration:** Added support for registering dependencies using factory functions for dynamic instantiation.
+- **Instance Registration:** Enabled registering existing instances as dependencies.
+- **Tag-based Registration and Resolution:** Introduced the ability to register and resolve dependencies using tags for flexible dependency management.
+
 ### [1.0.0-alpha.5](https://github.com/runemalm/py-dependency-injection/releases/tag/v1.0.0-alpha.5) (2024-03-03)
 
 - **Critical Package Integrity Fix**: This release addresses a critical issue that affected the packaging of the Python library in all previous alpha releases (1.0.0-alpha.1 to 1.0.0-alpha.4). The problem involved missing source files in the distribution, rendering the library incomplete and non-functional.

docs/conf.py

@@ -34,7 +34,7 @@
 version = '1.0'
 
 # The full version, including alpha/beta/rc tags
-release = '1.0.0-alpha.4'
+release = '1.0.0-alpha.6'
 
 
 # -- General configuration ---------------------------------------------------

docs/versionhistory.rst

@@ -2,6 +2,16 @@
 Version history
 ###############
 
+**1.0.0-alpha.6 (2024-03-23)**
+
+- **Factory Registration:** Added support for registering dependencies using factory functions for dynamic instantiation.
+
+- **Instance Registration:** Enabled registering existing instances as dependencies.
+
+- **Tag-based Registration and Resolution:** Introduced the ability to register and resolve dependencies using tags for flexible dependency management.
+
+`View release on GitHub <https://github.com/runemalm/py-dependency-injection/releases/tag/v1.0.0-alpha.6>`_
+
 **1.0.0-alpha.5 (2024-03-03)**
 
 - **Critical Package Integrity Fix**: This release addresses a critical issue that affected the packaging of the Python library in all previous alpha releases (1.0.0-alpha.1 to 1.0.0-alpha.4). The problem involved missing source files in the distribution, rendering the library incomplete and non-functional.

setup.py

@@ -6,7 +6,7 @@
 
 setup(
     name='py-dependency-injection',
-    version='1.0.0-alpha.5',
+    version='1.0.0-alpha.6',
     author='David Runemalm, 2024',
     author_email='david.runemalm@gmail.com',
     description=

src/dependency_injection/container.py

@@ -1,23 +1,26 @@
 import inspect
-from typing import Any, Dict, Type
+
+from typing import Any, Callable, Dict, List, 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"
 
 class DependencyContainer(metaclass=SingletonMeta):
 
-    def __init__(self, name=None):
+    def __init__(self, name: str=None):
         self.name = name if name is not None else DEFAULT_CONTAINER_NAME
         self._registrations = {}
         self._singleton_instances = {}
         self._scoped_instances = {}
 
     @classmethod
-    def get_instance(cls, name=None):
+    def get_instance(cls, name: str=None) -> Self:
         if name is None:
             name = DEFAULT_CONTAINER_NAME
 
@@ -26,88 +29,118 @@ def get_instance(cls, name=None):
 
         return cls._instances[(cls, name)]
 
-    def register_transient(self, interface, class_, constructor_args=None):
-        if interface in self._registrations:
-            raise ValueError(f"Dependency {interface} is already registered.")
-        self._registrations[interface] = Registration(interface, class_, Scope.TRANSIENT, constructor_args)
-
-    def register_scoped(self, interface, class_, constructor_args=None):
-        if interface in self._registrations:
-            raise ValueError(f"Dependency {interface} is already registered.")
-        self._registrations[interface] = Registration(interface, class_, Scope.SCOPED, constructor_args)
-
-    def register_singleton(self, interface, class_, constructor_args=None):
-        if interface in self._registrations:
-            raise ValueError(f"Dependency {interface} is already registered.")
-        self._registrations[interface] = Registration(interface, class_, Scope.SINGLETON, constructor_args)
-
-    def resolve(self, interface, scope_name=DEFAULT_SCOPE_NAME):
+    def register_transient(self, dependency: Type, implementation: Optional[Type] = None, tags: Optional[set] = None, constructor_args: Optional[Dict[str, Any]] = None) -> None:
+        if implementation is None:
+            implementation = dependency
+        if dependency in self._registrations:
+            raise ValueError(f"Dependency {dependency} is already registered.")
+        self._registrations[dependency] = Registration(dependency, implementation, Scope.TRANSIENT, tags, constructor_args)
+
+    def register_scoped(self, dependency: Type, implementation: Optional[Type] = None, tags: Optional[set] = None, constructor_args: Optional[Dict[str, Any]] = None) -> None:
+        if implementation is None:
+            implementation = dependency
+        if dependency in self._registrations:
+            raise ValueError(f"Dependency {dependency} is already registered.")
+        self._registrations[dependency] = Registration(dependency, implementation, Scope.SCOPED, tags, constructor_args)
+
+    def register_singleton(self, dependency: Type, implementation: Optional[Type] = None, tags: Optional[set] = None, constructor_args: Optional[Dict[str, Any]] = None) -> None:
+        if implementation is None:
+            implementation = dependency
+        if dependency in self._registrations:
+            raise ValueError(f"Dependency {dependency} is already registered.")
+        self._registrations[dependency] = Registration(dependency, implementation, Scope.SINGLETON, tags, constructor_args)
+
+    def register_factory(self, dependency: Type, factory: Callable[[Any], Any], factory_args: Optional[Dict[str, Any]] = None, tags: Optional[set] = None) -> None:
+        if dependency in self._registrations:
+            raise ValueError(f"Dependency {dependency} is already registered.")
+        self._registrations[dependency] = Registration(dependency, None, Scope.FACTORY, None, tags, factory, factory_args)
+
+    def register_instance(self, dependency: Type, instance: Any, tags: Optional[set] = None) -> None:
+        if dependency in self._registrations:
+            raise ValueError(f"Dependency {dependency} is already registered.")
+        self._registrations[dependency] = Registration(dependency, type(instance), Scope.SINGLETON, constructor_args={}, tags=tags)
+        self._singleton_instances[dependency] = instance
+
+    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] = {}
 
-        if interface not in self._registrations:
-            raise KeyError(f"Dependency {interface.__name__} is not registered.")
+        if dependency not in self._registrations:
+            raise KeyError(f"Dependency {dependency.__name__} is not registered.")
 
-        registration = self._registrations[interface]
-        dependency_scope = registration.scope
-        dependency_class = registration.class_
+        registration = self._registrations[dependency]
+        scope = registration.scope
+        implementation = registration.implementation
         constructor_args = registration.constructor_args
 
-        self._validate_constructor_args(constructor_args=constructor_args, class_=dependency_class)
+        self._validate_constructor_args(constructor_args=constructor_args, implementation=implementation)
 
-        if dependency_scope == Scope.TRANSIENT:
+        if scope == Scope.TRANSIENT:
             return self._inject_dependencies(
-                class_=dependency_class,
+                implementation=implementation,
                 constructor_args=constructor_args
             )
-        elif dependency_scope == Scope.SCOPED:
-            if interface not in self._scoped_instances[scope_name]:
-                self._scoped_instances[scope_name][interface] = (
+        elif scope == Scope.SCOPED:
+            if dependency not in self._scoped_instances[scope_name]:
+                self._scoped_instances[scope_name][dependency] = (
                     self._inject_dependencies(
-                        class_=dependency_class,
+                        implementation=implementation,
                         scope_name=scope_name,
                         constructor_args=constructor_args,
                     ))
-            return self._scoped_instances[scope_name][interface]
-        elif dependency_scope == Scope.SINGLETON:
-            if interface not in self._singleton_instances:
-                self._singleton_instances[interface] = (
+            return self._scoped_instances[scope_name][dependency]
+        elif scope == Scope.SINGLETON:
+            if dependency not in self._singleton_instances:
+                self._singleton_instances[dependency] = (
                     self._inject_dependencies(
-                        class_=dependency_class,
+                        implementation=implementation,
                         constructor_args=constructor_args
                     )
                 )
-            return self._singleton_instances[interface]
-
-        raise ValueError(f"Invalid dependency scope: {dependency_scope}")
-
-    def _validate_constructor_args(self, constructor_args: Dict[str, Any], class_: Type) -> None:
-        class_constructor = inspect.signature(class_.__init__).parameters
+            return self._singleton_instances[dependency]
+        elif scope == Scope.FACTORY:
+            factory = registration.factory
+            factory_args = registration.factory_args or {}
+            return factory(**factory_args)
+
+        raise ValueError(f"Invalid dependency scope: {scope}")
+
+    def resolve_all(self, tags: Optional[set] = None) -> List[Any]:
+        tags = tags or []
+        resolved_dependencies = []
+        for registration in self._registrations.values():
+            if not len(tags) or tags.intersection(registration.tags):
+                resolved_dependencies.append(
+                    self.resolve(registration.dependency))
+        return resolved_dependencies
+
+    def _validate_constructor_args(self, constructor_args: Dict[str, Any], implementation: Type) -> None:
+        constructor = inspect.signature(implementation.__init__).parameters
 
         # Check if any required parameter is missing
-        missing_params = [param for param in class_constructor.keys() if
+        missing_params = [param for param in constructor.keys() if
                           param not in ["self", "cls", "args", "kwargs"] and
                           param not in constructor_args]
         if missing_params:
             raise ValueError(
                 f"Missing required constructor arguments: "
-                f"{', '.join(missing_params)} for class '{class_.__name__}'.")
+                f"{', '.join(missing_params)} for class '{implementation.__name__}'.")
 
         for arg_name, arg_value in constructor_args.items():
-            if arg_name not in class_constructor:
+            if arg_name not in constructor:
                 raise ValueError(
-                    f"Invalid constructor argument '{arg_name}' for class '{class_.__name__}'. "
+                    f"Invalid constructor argument '{arg_name}' for class '{implementation.__name__}'. "
                     f"The class does not have a constructor parameter with this name.")
 
-            expected_type = class_constructor[arg_name].annotation
+            expected_type = constructor[arg_name].annotation
             if expected_type != inspect.Parameter.empty:
                 if not isinstance(arg_value, expected_type):
                     raise TypeError(
                         f"Constructor argument '{arg_name}' has an incompatible type. "
                         f"Expected type: {expected_type}, provided type: {type(arg_value)}.")
 
-    def _inject_dependencies(self, class_, scope_name=None, constructor_args=None):
-        constructor = inspect.signature(class_.__init__)
+    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
 
         dependencies = {}
@@ -127,4 +160,4 @@ def _inject_dependencies(self, class_, scope_name=None, constructor_args=None):
                     else:
                         dependencies[param_name] = self.resolve(param_info.annotation, scope_name=scope_name)
 
-        return class_(**dependencies)
+        return implementation(**dependencies)

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,12 +1,18 @@
-from typing import Any, Dict
+from typing import Any, Callable, Dict, Optional, Type
 
 from dependency_injection.scope import Scope
 
 
 class Registration():
 
-    def __init__(self, interface, class_, scope: Scope, constructor_args: Dict[str, Any] = None):
-        self.interface = interface
-        self.class_ = class_
+    def __init__(self, dependency: Type, implementation: Optional[Type], scope: Scope, tags: Optional[set] = None, constructor_args: Optional[Dict[str, Any]] = None, factory: Optional[Callable[[Any], Any]] = None, factory_args: Optional[Dict[str, Any]] = None):
+        self.dependency = dependency
+        self.implementation = implementation
         self.scope = scope
+        self.tags = tags or set()
         self.constructor_args = constructor_args or {}
+        self.factory = factory
+        self.factory_args = factory_args or {}
+
+        if not any([self.implementation, self.factory]):
+            raise Exception("There must be either an implementation or a factory.")

src/dependency_injection/scope.py

@@ -7,3 +7,4 @@ class Scope(Enum):
     TRANSIENT = "transient"
     SCOPED = "scoped"
     SINGLETON = "singleton"
+    FACTORY = "factory"