module-dependency 0.0.3__py3-none-any.whl

dependency/core/__init__.py

@@ -0,0 +1,18 @@
+from dependency_injector import providers
+from dependency.core.module.base import Module, module
+from dependency.core.declaration.component import Component, component
+from dependency.core.declaration.provider import HasDependent, Provider, provider
+from dependency.core.declaration.dependent import Dependent, dependent
+
+__all__ = [
+    "providers",
+    "Module",
+    "module",
+    "Component",
+    "component",
+    "Provider",
+    "provider",
+    "Dependent",
+    "dependent",
+    "HasDependent",
+]

dependency/core/container/__init__.py

@@ -0,0 +1,24 @@
+from typing import Any
+from dependency_injector import containers, providers
+
+class Container(containers.DynamicContainer):
+    config: providers.Configuration = providers.Configuration()
+
+    @staticmethod
+    def from_dict(
+            config: dict[str, Any],
+            required: bool = False
+        ) -> 'Container':
+        container: Container = Container()
+        container.config.from_dict(config, required)
+        return container
+    
+    @staticmethod
+    def from_json(
+            file: str,
+            required: bool = False,
+            envs_required: bool = False
+        ) -> 'Container':
+        container: Container = Container()
+        container.config.from_json(file, required, envs_required)
+        return container

dependency/core/container/injectable.py

@@ -0,0 +1,20 @@
+from dependency_injector import containers, providers
+from dependency.core.container import Container
+
+class Injectable:
+    def __init__(self,
+            inject_name: str,
+            inject_cls: type,
+            provided_cls: type,
+            provider_cls: type = providers.Singleton
+        ) -> None:
+        class Container(containers.DynamicContainer):
+            config = providers.Configuration()
+            service = provider_cls(provided_cls, config)
+        self.inject_name = inject_name
+        self.inject_cls = inject_cls
+        self.container = Container
+    
+    def populate_container(self, container: Container) -> None:
+        setattr(container, self.inject_name, providers.Container(self.container, config=container.config))
+        container.wire(modules=[self.inject_cls])

dependency/core/declaration/__init__.py

@@ -0,0 +1,13 @@
+from dependency.core.declaration.component import Component, component
+from dependency.core.declaration.provider import HasDependent, Provider, provider
+from dependency.core.declaration.dependent import Dependent, dependent
+
+__all__ = [
+    "Component",
+    "component",
+    "Provider",
+    "provider",
+    "Dependent",
+    "dependent",
+    "HasDependent",
+]

dependency/core/declaration/base.py

@@ -0,0 +1,19 @@
+from abc import ABC
+
+class ABCComponent(ABC):
+    def __init__(self, base_cls: type) -> None:
+        self.base_cls: type = base_cls
+    
+    def __repr__(self) -> str:
+        return self.base_cls.__name__
+
+class ABCProvider(ABC):
+    def __init__(self, provided_cls: type) -> None:
+        self.provided_cls: type = provided_cls
+
+    def __repr__(self) -> str:
+        return self.provided_cls.__name__
+
+class ABCDependent(ABC):
+    def __repr__(self) -> str:
+        return self.__class__.__name__

dependency/core/declaration/component.py

@@ -0,0 +1,54 @@
+from typing import Any, Callable, Optional
+from dependency_injector.wiring import Provide
+from dependency.core.exceptions import DependencyError
+from dependency.core.declaration.base import ABCComponent, ABCProvider
+
+class Component(ABCComponent):
+    """Component Base Class
+    """
+    def __init__(self, base_cls: type) -> None:
+        super().__init__(base_cls=base_cls)
+        self.__provider: Optional[ABCProvider] = None
+    
+    @property
+    def provider(self) -> Optional[ABCProvider]:
+        return self.__provider
+    
+    @provider.setter
+    def provider(self, provider: ABCProvider) -> None:
+        if self.__provider:
+            raise DependencyError(f"Component {self} is already provided by {self.__provider}. Attempted to set new provider: {provider}")
+        self.__provider = provider
+    
+    @staticmethod
+    def provide(service: Any = None) -> Any: # TODO: provide signature
+        pass
+
+def component(interface: type) -> Callable[[type[Component]], Component]:
+    """Decorator for Component class
+
+    Args:
+        interface (type): Interface class to be used as a base class for the component.
+    
+    Raises:
+        TypeError: If the wrapped class is not a subclass of Component.
+
+    Returns:
+        Callable[[type[Component]], Component]: Decorator function that wraps the component class.
+    """
+    def wrap(cls: type[Component]) -> Component:
+        if not issubclass(cls, Component):
+            raise TypeError(f"Class {cls} is not a subclass of Component")
+
+        class WrapComponent(cls): # type: ignore
+            def __init__(self) -> None:
+                super().__init__(base_cls=interface)
+
+            def provide(self,
+                    service: Any = Provide[f"{interface.__name__}.service"]
+                ) -> Any:
+                if issubclass(service.__class__, Provide):
+                    raise DependencyError(f"Component {self} was not provided")
+                return service
+        return WrapComponent()
+    return wrap

dependency/core/declaration/dependent.py

@@ -0,0 +1,47 @@
+from typing import Callable, Sequence, cast
+from dependency.core.declaration.base import ABCComponent, ABCProvider, ABCDependent
+
+class Dependent(ABCDependent):
+    """Dependent Base Class
+    """
+    _dependency_imports: Sequence[ABCComponent]
+    _dependency_resolved: bool = False
+
+    @classmethod
+    def resolve_dependent(cls, providers: Sequence[ABCProvider]) -> list[str]:
+        if cls._dependency_resolved:
+            return []
+        cls._dependency_resolved = True
+        
+        return [
+            component.__repr__()
+            for component in cls._dependency_imports
+            if not any(
+                issubclass(provider.provided_cls, component.base_cls)
+                for provider in providers
+            )
+        ]
+
+def dependent(
+        imports: Sequence[type[ABCComponent]] = [],
+    ) -> Callable[[type[Dependent]], type[Dependent]]:
+    """Decorator for Dependent class
+
+    Args:
+        imports (Sequence[type[Component]], optional): List of components to be imported by the dependent. Defaults to [].
+
+    Raises:
+        TypeError: If the wrapped class is not a subclass of Dependent.
+
+    Returns:
+        Callable[[type[Dependent]], type[Dependent]]: Decorator function that wraps the dependent class.
+    """
+    # Cast due to mypy not supporting class decorators
+    _imports = cast(Sequence[ABCComponent], imports)
+    def wrap(cls: type[Dependent]) -> type[Dependent]:
+        if not issubclass(cls, Dependent):
+            raise TypeError(f"Class {cls} is not a subclass of Dependent")
+
+        cls._dependency_imports = _imports
+        return cls
+    return wrap

dependency/core/declaration/provider.py

@@ -0,0 +1,90 @@
+from pprint import pformat
+from typing import Callable, Optional, cast
+from dependency_injector import providers
+from dependency.core.container.injectable import Container, Injectable
+from dependency.core.declaration.base import ABCProvider
+from dependency.core.declaration.component import Component
+from dependency.core.declaration.dependent import Dependent
+
+class Provider(ABCProvider):
+    """Provider Base Class
+    """
+    def __init__(self,
+            imports: list[Component],
+            dependents: list[type[Dependent]],
+            provided_cls: type,
+            inject: Injectable,
+        ) -> None:
+        super().__init__(provided_cls=provided_cls)
+        self.provider = inject
+        self.imports = imports
+        self.dependents = dependents
+
+        self.__providers: list['Provider'] = []
+    
+    def resolve_dependents(self, dependents: list[type[Dependent]]) -> None:
+        self.unresolved_dependents: dict[str, list[str]] = {}
+        for dependent in dependents:
+            unresolved = dependent.resolve_dependent(self.__providers)
+            if len(unresolved) > 0:
+                self.unresolved_dependents[dependent.__name__] = unresolved
+        if len(self.unresolved_dependents) > 0:
+            named_dependents = pformat(self.unresolved_dependents)
+            raise TypeError(f"Provider {self} has unresolved dependents:\n{named_dependents}")
+    
+    def resolve(self, container: Container, providers: list['Provider']) -> None:
+        self.__providers = providers
+        self.resolve_dependents(self.dependents)
+        self.provider.populate_container(container)
+
+class HasDependent():
+    _dependency_provider: Optional[Provider] = None
+
+    def declare_dependents(self, dependents: list[type[Dependent]]) -> None:
+        if self._dependency_provider is None:
+            raise TypeError(f"Class {self} provider is not declared yet")
+        self._dependency_provider.resolve_dependents(dependents)
+
+def provider(
+        component: type[Component],
+        imports: list[type[Component]] = [],
+        dependents: list[type[Dependent]] = [],
+        provider: type[providers.Provider] = providers.Singleton
+    ) -> Callable[[type], Provider]:
+    """Decorator for Provider class
+
+    Args:
+        component (type[Component]): Component class to be used as a base class for the provider.
+        imports (list[type[Component]], optional): List of components to be imported by the provider. Defaults to [].
+        dependents (list[type[Dependent]], optional): List of dependents to be declared by the provider. Defaults to [].
+        provider (type[providers.Provider], optional): Provider class to be used. Defaults to providers.Singleton.
+
+    Raises:
+        TypeError: If the wrapped class is not a subclass of Component declared base class.
+
+    Returns:
+        Callable[[type], Provider]: Decorator function that wraps the provider class.
+    """
+    # Cast due to mypy not supporting class decorators
+    _component = cast(Component, component)
+    _imports = cast(list[Component], imports)
+    def wrap(cls: type) -> Provider:
+        if not issubclass(cls, _component.base_cls):
+            raise TypeError(f"Class {cls} is not a subclass of {_component.base_cls}")
+        
+        provider_wrap = Provider(
+            imports=_imports,
+            dependents=dependents,
+            provided_cls=cls,
+            inject=Injectable(
+                inject_name=_component.base_cls.__name__,
+                inject_cls=_component.__class__,
+                provided_cls=cls,
+                provider_cls=provider
+            )
+        )
+        _component.provider = provider_wrap
+        if issubclass(cls, HasDependent):
+            cls._dependency_provider = provider_wrap
+        return provider_wrap
+    return wrap

dependency/core/exceptions.py

@@ -0,0 +1,2 @@
+
+class DependencyError(Exception): ...

dependency/core/loader.py

@@ -0,0 +1,27 @@
+import logging
+from pprint import pformat
+from typing import cast
+from dependency.core.module.base import Module
+from dependency.core.container import Container
+from dependency.core.resolver import resolve_dependency_layers
+logger = logging.getLogger("DependencyLoader")
+
+def resolve_dependency(container: Container, appmodule: type[Module]) -> None:
+    # Cast due to mypy not supporting class decorators
+    _appmodule = cast(Module, appmodule)
+    logger.info(f"Resolving dependencies in {_appmodule}")
+
+    unresolved_layers = _appmodule.init_providers()
+    resolved_layers = resolve_dependency_layers(unresolved_layers)
+
+    named_layers = pformat(resolved_layers)
+    logger.info(f"Resolved layers:\n{named_layers}")
+
+    for resolved_layer in resolved_layers:
+        for provider in resolved_layer:
+            provider.resolve(container, unresolved_layers)
+    
+    container.check_dependencies()
+    container.init_resources()
+    _appmodule.init_bootstrap()
+    logger.info("Dependencies resolved and injected")

dependency/core/module/__init__.py

@@ -0,0 +1,6 @@
+from dependency.core.module.base import Module, module
+
+__all__ = [
+    "Module",
+    "module",
+]

dependency/core/module/base.py

@@ -0,0 +1,100 @@
+from abc import ABC
+from typing import Callable, cast
+from dependency.core.exceptions import DependencyError
+from dependency.core.declaration import Component, Provider
+
+class Module(ABC):
+    """Module Base Class
+    """
+    def __init__(self,
+            module_cls: type,
+            imports: list["Module"],
+            declaration: list[Component],
+            bootstrap: list[Component]
+        ):
+        self.module_cls = module_cls
+        self.imports = imports
+        self.declaration = declaration
+        self.bootstrap = bootstrap
+    
+    def declare_providers(self) -> None:
+        pass
+
+    @property
+    def modules(self) -> list["Module"]:
+        modules = self.imports
+        for module in self.imports:
+            modules.extend(module.modules)
+        return modules
+    
+    @property
+    def providers(self) -> list[Provider]:
+        return [
+            cast(Provider, component.provider)
+            for component in self.declaration
+            if not component.provider is None
+        ]
+    
+    @property
+    def bootstraps(self) -> list[Component]:
+        return [
+            component
+            for component in self.bootstrap
+            if not component.provider is None
+        ]
+    
+    def init_providers(self) -> list[Provider]:
+        self.declare_providers()
+        providers: list[Provider] = self.providers
+        for module in self.imports:
+            providers.extend(module.init_providers())
+        return providers
+    
+    def init_bootstrap(self) -> None:
+        for module in self.imports:
+            module.init_bootstrap()
+        for component in self.bootstraps:
+            try:
+                component.provide()
+            except Exception as e:
+                raise DependencyError(f"Failed to bootstrap {component}: {e}") from e
+    
+    def __repr__(self) -> str:
+        return self.module_cls.__name__
+
+def module(
+        imports: list[type[Module]] = [],
+        declaration: list[type[Component]] = [],
+        bootstrap: list[type[Component]] = [],
+    ) -> Callable[[type[Module]], Module]:
+    """Decorator for Module class
+
+    Args:
+        imports (list[type[Module]], optional): List of modules to be imported by the module. Defaults to [].
+        declaration (list[type[Component]], optional): List of components to be declared by the module. Defaults to [].
+        bootstrap (list[type[Component]], optional): List of components to be bootstrapped by the module. Defaults to [].
+
+    Raises:
+        TypeError: If the wrapped class is not a subclass of Module.
+
+    Returns:
+        Callable[[type[Module]], Module]: Decorator function that wraps the module class.
+    """
+    # Cast due to mypy not supporting class decorators
+    _declaration = cast(list[Component], declaration)
+    _imports = cast(list[Module], imports)
+    _bootstrap = cast(list[Component], bootstrap)
+    def wrap(cls: type[Module]) -> Module:
+        if not issubclass(cls, Module):
+            raise TypeError(f"Class {cls} is not a subclass of Module")
+
+        class WrapModule(cls): # type: ignore
+            def __init__(self) -> None:
+                super().__init__(
+                    module_cls=cls,
+                    declaration=_declaration,
+                    imports=_imports,
+                    bootstrap=_bootstrap,
+                )
+        return WrapModule()
+    return wrap

dependency/core/resolver/__init__.py

@@ -0,0 +1,24 @@
+from dependency.core import Provider
+from dependency.core.resolver.errors import raise_dependency_error
+from dependency.core.resolver.utils import provider_is_resolved
+
+def resolve_dependency_layers(unresolved_providers: list[Provider]) -> list[list[Provider]]:
+    resolved_layers: list[list[Provider]] = []
+
+    while unresolved_providers:
+        new_layer = [
+            provider
+            for provider in unresolved_providers
+            if provider_is_resolved(provider, resolved_layers)
+        ]
+        
+        if not new_layer:
+            raise_dependency_error(unresolved_providers, resolved_layers)
+        resolved_layers.append(new_layer)
+        
+        unresolved_providers = [
+            provider
+            for provider in unresolved_providers
+            if provider not in new_layer
+        ]
+    return resolved_layers

dependency/core/resolver/errors.py

@@ -0,0 +1,27 @@
+import logging
+from dependency.core.exceptions import DependencyError
+from dependency.core.declaration import Component
+from dependency.core.declaration.provider import Provider
+from dependency.core.resolver.utils import provider_unresolved
+logger = logging.getLogger("DependencyLoader")
+
+def provider_detect_error(
+        provider: Provider,
+        unresolved_providers: list[Provider],
+        resolved_layers: list[list[Provider]]
+    ) -> tuple[list[Component], list[Component]]:
+    deps_circular: list[Component] = []
+    deps_missing: list[Component] = []
+
+    for dep in provider_unresolved(provider, resolved_layers):
+        # TODO: Check for circular dependencies
+        deps_missing.append(dep)
+
+    logger.error(f"Provider {provider} has unresolved dependencies: {deps_missing}")
+    return deps_circular, deps_missing
+
+def raise_dependency_error(providers: list[Provider], resolved_layers: list[list[Provider]]) -> None:
+    for provider in providers:
+        provider_detect_error(provider, providers, resolved_layers)
+    
+    raise DependencyError("Dependencies cannot be resolved")

dependency/core/resolver/utils.py

@@ -0,0 +1,24 @@
+from dependency.core.declaration import Component, Provider
+from dependency.core.declaration.component import ABCComponent
+
+def dep_in_layers(dep: ABCComponent, layers: list[list[Provider]]) -> bool:
+    return any(
+        issubclass(res.provided_cls, dep.base_cls)
+        for layer in layers
+        for res in layer
+    )
+
+def provider_is_resolved(provider: Provider, resolved_layers: list[list[Provider]]) -> bool:
+    dependencies = provider.imports
+    return all(
+        dep_in_layers(dep, resolved_layers)
+        for dep in dependencies
+    )
+
+def provider_unresolved(provider: Provider, resolved_layers: list[list[Provider]]) -> list[Component]:
+    dependencies = provider.imports
+    return [
+        dep
+        for dep in dependencies
+        if not dep_in_layers(dep, resolved_layers)
+    ]

module_dependency-0.0.3.dist-info/METADATA

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: module_dependency
+Version: 0.0.3
+Summary: A dependency management tool for Python projects.
+Project-URL: Homepage, https://github.com/fabaindaiz/module-injection
+Project-URL: Issues, https://github.com/fabaindaiz/module-injection/issues
+Author-email: Fabian D <github.clapping767@passmail.net>
+License-Expression: GPL-3.0-or-later
+License-File: LICENSE
+Keywords: dependency-injection
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Requires-Dist: dependency-injector
+Description-Content-Type: text/markdown
+
+# module-injection
+
+This repository contains experiments and examples for managing dependencies using dependency injection with class decorators in Python projects. The structures and patterns demonstrated here are flexible and can be adapted to suit various project needs.
+
+## Overview
+
+The goal of this project is to showcase different approaches to dependency management, focusing on modularity, flexibility, and ease of use. While the provided examples are specific, the underlying concepts can be applied to a wide range of scenarios.
+
+## Core Components
+
+The project is built around four components that implement different aspects of dependency management:
+
+### 1. Module
+- Acts as a container for organizing and grouping related dependencies
+- Facilitates modular design and hierarchical structuring of application components
+
+```python
+from dependency.core import Module, module
+from plugin........component import SomeService, SomeServiceComponent
+
+@module(
+    declaration=[   # Declare all components that are part of the module
+        SomeServiceComponent,
+        ...         # Every used component must be declared in some module
+    ],
+    bootstrap=[     # Bootstrap components will be started on loading
+        SomeServiceComponent
+    ]
+)
+class SomeModule(Module):
+    """This is a module class.
+       Here the providers are declared and provided
+    """
+    def declare_providers(self):
+        from plugin........provider import ImplementedSomeService
+        return [    # Here you declare the providers for the components
+            ImplementedSomeService,
+            ...     # Only one provider per component is allowed
+        ]
+```
+
+### 2. Component
+- Defines abstract interfaces or contracts for dependencies
+- Promotes loose coupling and enables easier testing and maintenance
+
+```python
+from abc import ABC, abstractmethod
+from dependency.core import Component, component
+
+class SomeService(ABC):
+    """This is the interface for a new component."""
+    @abstractmethod
+    def method(self, ...) -> ...:
+        pass
+
+@component(
+    interface=SomeService, # Declares the interface used by the component
+)
+class SomeServiceComponent(Component):
+    """This is the component class.
+       Provider selected for this component will injected here.
+       Components are only started when provided or bootstrapped.
+    """
+    pass
+```
+
+### 3. Provider
+- Delivers concrete implementations of Components
+- Manages the lifecycle and injection of dependency objects
+
+```python
+from dependency_injector import providers
+from dependency.core import provider
+from plugin........component import SomeService, SomeServiceComponent
+from plugin..other_component import OtherService, OtherServiceComponent
+
+@provider(
+    component=SomeServiceComponent, # Declares the component to be provided
+    imports=[OtherService, ...],    # List of dependencies (components) that are needed
+    provider=providers.Singleton    # Provider type (Singleton, Factory)
+)
+class ImplementedSomeService(SomeService):
+    """This is a provider class. Here the component is implemented.
+       Providers are injected into the respective components when provided.
+    """
+    def __init__(self, cfg: dict, **kwargs) -> None:
+        """Init method will be called when the provider is stared.
+           This will happen once for singleton and every time for factories.
+        """
+
+        # Once declared, i can use the dependencies for the class.
+        self.dependency: OtherService = OtherServiceComponent.provide()
+    
+    def method(self, ...) -> ...:
+        """Methods declared in the interface must be implemented."""
+        do_something()
+```
+
+## 4. Dependent
+- Represents a class produced by a Provider that requires dependencies
+- Allows to provide standalone classed without the need to define new providers
+
+```python
+from dependency.core import Dependent, dependent
+
+@dependent(
+    imports=[SomeComponent, ...], # List of dependencies (components) that are needed
+)
+class SomeDependent(Interface, Dependent):
+    """This is the dependent class.
+       Dependents must be declared in the provider that provides them.
+       Dependents can be instantiated without the need to define new providers.
+    """
+    def method(self, ...) -> ...:
+        pass
+```
+
+These components work together to create a powerful and flexible dependency injection system, allowing for more maintainable and testable Python applications.
+
+## Usage Examples
+
+This repository includes a practical example demonstrating how to use the framework. You can find this example in the `example` directory. It showcases the implementation of the core components and how they interact to manage dependencies effectively in a sample application.
+
+## Future Work
+
+This project is a work in progress, and there are several improvements and enhancements planned for the future. Some of the areas that will be explored include:
+- Improve component registration and resolution mechanisms
+- Improve ways to handle module definitions and configurations
+- Explore more advanced dependency injection patterns and use cases
+- Enhance validation and error handling mechanisms of the framework
+
+## Aknowledgements
+
+This project depends on [dependency-injector](https://python-dependency-injector.ets-labs.org/introduction/di_in_python.html). This library provides a robust and flexible framework for managing dependencies in Python projects.