aspyx 1.1.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

aspyx/di/di.py

@@ -1,5 +1,5 @@
 """
-The deoendency injection module provides a framework for managing dependencies and lifecycle of objects in Python applications.
+The dependency injection module provides a framework for managing dependencies and lifecycle of objects in Python applications.
 """
 from __future__ import annotations
 
@@ -7,9 +7,10 @@ import inspect
 import logging
 
 from abc import abstractmethod, ABC
-from enum import Enum, auto
+from enum import Enum
 import threading
-from typing import Type, Dict, TypeVar, Generic, Optional, cast, Callable
+from operator import truediv
+from typing import Type, Dict, TypeVar, Generic, Optional, cast, Callable, TypedDict
 
 from aspyx.di.util import StringBuilder
 from aspyx.reflection import Decorators, TypeDescriptor, DecoratorDescriptor
@@ -27,10 +28,35 @@ class Factory(ABC, Generic[T]):
     def create(self) -> T:
         pass
 
-class InjectorException(Exception):
+class DIException(Exception):
     """
     Exception raised for errors in the injector.
     """
+    def __init__(self, message: str):
+        super().__init__(message)
+
+class DIRegistrationException(DIException):
+    """
+    Exception raised during the registration of dependencies.
+    """
+    def __init__(self, message: str):
+        super().__init__(message)
+
+class ProviderCollisionException(DIRegistrationException):
+    def __init__(self, message: str, *providers: AbstractInstanceProvider):
+         super().__init__(message)
+
+         self.providers = providers
+
+    def __str__(self):
+        return f"[{self.args[0]} {self.providers[1].location()} collides with {self.providers[0].location()}"
+
+class DIRuntimeException(DIException):
+    """
+    Exception raised during the runtime.
+    """
+    def __init__(self, message: str):
+        super().__init__(message)
 
 class AbstractInstanceProvider(ABC, Generic[T]):
     """
@@ -40,6 +66,9 @@ class AbstractInstanceProvider(ABC, Generic[T]):
     def get_module(self) -> str:
         pass
 
+    def get_host(self) -> Type[T]:
+        return type(self)
+
     @abstractmethod
     def get_type(self) -> Type[T]:
         pass
@@ -52,16 +81,25 @@ class AbstractInstanceProvider(ABC, Generic[T]):
     def get_scope(self) -> str:
         pass
 
-    @abstractmethod
-    def get_dependencies(self) -> list[AbstractInstanceProvider]:
-        pass
+    def get_dependencies(self) -> (list[Type],int):
+        return [],1
 
     @abstractmethod
     def create(self, environment: Environment, *args):
         pass
 
-    @abstractmethod
-    def resolve(self, context: Providers.Context):
+    def report(self) -> str:
+        return str(self)
+
+    def location(self) -> str:
+        host = self.get_host()
+
+        file = inspect.getfile(host)
+        line = inspect.getsourcelines(host)[1]
+
+        return f"{file}:{line}"
+
+    def check_factories(self):
         pass
 
 
@@ -73,8 +111,7 @@ class InstanceProvider(AbstractInstanceProvider):
         "host",
         "type",
         "eager",
-        "scope",
-        "dependencies"
+        "scope"
     ]
 
     # constructor
@@ -84,16 +121,13 @@ class InstanceProvider(AbstractInstanceProvider):
         self.type = t
         self.eager = eager
         self.scope = scope
-        self.dependencies : Optional[list[AbstractInstanceProvider]] = None
-
-    # internal
-
-    def _is_resolved(self) -> bool:
-        return self.dependencies is not None
 
     # implement AbstractInstanceProvider
 
-    def resolve(self, context: Providers.Context):
+    def get_host(self):
+        return self.host
+
+    def check_factories(self):
         pass
 
     def get_module(self) -> str:
@@ -108,22 +142,11 @@ class InstanceProvider(AbstractInstanceProvider):
     def get_scope(self) -> str:
         return self.scope
 
-    def get_dependencies(self) -> list[AbstractInstanceProvider]:
-        return self.dependencies
-
     # public
 
     def module(self) -> str:
         return self.host.__module__
 
-    def add_dependency(self, provider: AbstractInstanceProvider):
-        if any(issubclass(provider.get_type(), dependency.get_type()) for dependency in self.dependencies):
-            return False
-
-        self.dependencies.append(provider)
-
-        return True
-
     @abstractmethod
     def create(self, environment: Environment, *args):
         pass
@@ -181,14 +204,11 @@ class AmbiguousProvider(AbstractInstanceProvider):
     def get_scope(self) -> str:
         return "singleton"
 
-    def get_dependencies(self) -> list[AbstractInstanceProvider]:
-        return []
-
-    def resolve(self, context: Providers.Context):
-        pass
-
     def create(self, environment: Environment, *args):
-        raise InjectorException(f"multiple candidates for type {self.type}")
+        raise DIException(f"multiple candidates for type {self.type}")
+
+    def report(self) -> str:
+        return "ambiguous: " + ",".join([provider.report() for provider in self.providers])
 
     def __str__(self):
         return f"AmbiguousProvider({self.type})"
@@ -204,7 +224,7 @@ class Scopes:
     def get(cls, scope: str, environment: Environment):
         scope_type = Scopes.scopes.get(scope, None)
         if scope_type is None:
-            raise InjectorException(f"unknown scope type {scope}")
+            raise DIRegistrationException(f"unknown scope type {scope}")
 
         return environment.get(scope_type)
 
@@ -234,8 +254,8 @@ class EnvironmentInstanceProvider(AbstractInstanceProvider):
     __slots__ = [
         "environment",
         "scope_instance",
-        "provider",
         "dependencies",
+        "provider"
     ]
 
     # constructor
@@ -245,14 +265,30 @@ class EnvironmentInstanceProvider(AbstractInstanceProvider):
 
         self.environment = environment
         self.provider = provider
-        self.dependencies : list[AbstractInstanceProvider] = []
-
+        self.dependencies = []
         self.scope_instance = Scopes.get(provider.get_scope(), environment)
 
     # implement
 
-    def resolve(self, context: Providers.Context):
-        pass # noop
+    def resolve(self, context: Providers.ResolveContext):
+        context.add(self)
+
+        if not context.is_resolved(self):
+            context.provider_dependencies[self] = [] #?
+
+            type_and_params = self.provider.get_dependencies()
+            params = type_and_params[1]
+            for type in type_and_params[0]:
+                if params > 0:
+                    params -= 1
+                    self.dependencies.append(context.get_provider(type))
+
+                provider = context.add_provider_dependency(self, type)
+                if provider is not None:
+                    provider.resolve(context)
+
+        else:
+            context.add(*context.get_provider_dependencies(self))
 
     def get_module(self) -> str:
         return self.provider.get_module()
@@ -266,18 +302,10 @@ class EnvironmentInstanceProvider(AbstractInstanceProvider):
     def get_scope(self) -> str:
         return self.provider.get_scope()
 
-    # custom logic
-
-    def tweak_dependencies(self, providers: dict[Type, AbstractInstanceProvider]):
-        for dependency in self.provider.get_dependencies():
-            instance_provider = providers.get(dependency.get_type(), None)
-            if instance_provider is None:
-                raise InjectorException(f"missing import for {dependency.get_type()} ")
+    def report(self) -> str:
+        return self.provider.report()
 
-            self.dependencies.append(instance_provider)
-
-    def get_dependencies(self) -> list[AbstractInstanceProvider]:
-        return self.provider.get_dependencies()
+    # own logic
 
     def create(self, environment: Environment, *args):
         return self.scope_instance.get(self.provider, self.environment, lambda: [provider.create(environment) for provider in self.dependencies]) # already scope property!
@@ -303,41 +331,39 @@ class ClassInstanceProvider(InstanceProvider):
 
     # implement
 
-    def resolve(self, context: Providers.Context):
-        context.add(self)
+    def check_factories(self):
+        register_factories(self.host)
 
-        if not self._is_resolved():
-            self.dependencies = []
+    def get_dependencies(self) -> (list[Type],int):
+        types : list[Type] = []
 
-            # check constructor
+        # check constructor
 
-            init = TypeDescriptor.for_type(self.type).get_method("__init__")
-            if init is None:
-                raise InjectorException(f"{self.type.__name__} does not implement __init__")
+        init = TypeDescriptor.for_type(self.type).get_method("__init__")
+        if init is None:
+            raise DIRegistrationException(f"{self.type.__name__} does not implement __init__")
 
-            for param in init.param_types:
-                provider = Providers.get_provider(param)
-                self.params += 1
-                if self.add_dependency(provider): # a dependency can occur multiple times, e.g in __init__ and in an injected method
-                    provider.resolve(context)
+        self.params = len(init.param_types)
+        for param in init.param_types:
+            types.append(param)
 
-            # check @inject
+        # check @inject
 
-            for method in TypeDescriptor.for_type(self.type).get_methods():
-                if method.has_decorator(inject):
-                    for param in method.param_types:
-                        provider = Providers.get_provider(param)
+        for method in TypeDescriptor.for_type(self.type).get_methods():
+            if method.has_decorator(inject):
+                for param in method.param_types:
+                    types.append(param)
 
-                        if self.add_dependency(provider):
-                            provider.resolve(context)
-        else: # check if the dependencies create a cycle
-            context.add(*self.dependencies)
+        return (types, self.params)
 
     def create(self, environment: Environment, *args):
         Environment.logger.debug("%s create class %s", self, self.type.__qualname__)
 
         return environment.created(self.type(*args[:self.params]))
 
+    def report(self) -> str:
+        return f"{self.host.__name__}.__init__"
+
     # object
 
     def __str__(self):
@@ -361,25 +387,19 @@ class FunctionInstanceProvider(InstanceProvider):
 
     # implement
 
-    def resolve(self, context: Providers.Context):
-        context.add(self)
-
-        if not self._is_resolved():
-            self.dependencies = []
-
-            provider = Providers.get_provider(self.host)
-            if self.add_dependency(provider):
-                provider.resolve(context)
-        else: # check if the dependencies crate a cycle
-            context.add(*self.dependencies)
+    def get_dependencies(self) -> (list[Type],int):
+        return [self.host], 1
 
     def create(self, environment: Environment, *args):
         Environment.logger.debug("%s create class %s", self, self.type.__qualname__)
 
-        instance = self.method(*args)
+        instance = self.method(*args) # args[0]=self
 
         return environment.created(instance)
 
+    def report(self) -> str:
+        return f"{self.host.__name__}.{self.method.__name__}"
+
     def __str__(self):
         return f"FunctionInstanceProvider({self.host.__name__}.{self.method.__name__} -> {self.type.__name__})"
 
@@ -403,33 +423,24 @@ class FactoryInstanceProvider(InstanceProvider):
 
     # implement
 
-    def resolve(self, context: Providers.Context):
-        context.add(self)
-
-        if  not self._is_resolved():
-            self.dependencies = []
-
-            provider = Providers.get_provider(self.host)
-            if self.add_dependency(provider):
-                provider.resolve(context)
-
-        else: # check if the dependencies crate a cycle
-            context.add(*self.dependencies)
-
-        return self
+    def get_dependencies(self) -> (list[Type],int):
+        return [self.host],1
 
     def create(self, environment: Environment, *args):
         Environment.logger.debug("%s create class %s", self, self.type.__qualname__)
 
         return environment.created(args[0].create())
 
+    def report(self) -> str:
+        return f"{self.host.__name__}.create"
+
     def __str__(self):
         return f"FactoryInstanceProvider({self.host.__name__} -> {self.type.__name__})"
 
 
 class Lifecycle(Enum):
     """
-    This enum defines the lifecycle events that can be processed by lifecycle processors.
+    This enum defines the lifecycle phases that can be processed by lifecycle processors.
     """
 
     __slots__ = []
@@ -441,7 +452,7 @@ class Lifecycle(Enum):
 
 class LifecycleProcessor(ABC):
     """
-    A LifecycleProcessor is used to perform any side effects on managed objects during their lifecycle.
+    A LifecycleProcessor is used to perform any side effects on managed objects during different lifecycle phases.
     """
     __slots__ = [
         "order"
@@ -481,16 +492,57 @@ class Providers:
     """
     # local class
 
-    class Context:
-        __slots__ = ["dependencies"]
+    class ResolveContext:
+        __slots__ = [
+            "dependencies",
+            "providers",
+            "provider_dependencies"
+        ]
+
+        # constructor
+
+        def __init__(self, providers: Dict[Type, EnvironmentInstanceProvider]):
+            self.dependencies : list[EnvironmentInstanceProvider] = []
+            self.providers = providers
+            self.provider_dependencies : dict[EnvironmentInstanceProvider, list[EnvironmentInstanceProvider]] = {}
+
+        # public
+
+        def is_resolved(self, provider: EnvironmentInstanceProvider) -> bool:
+            return self.provider_dependencies.get(provider, None) is not None
+
+        def get_provider_dependencies(self, provider: EnvironmentInstanceProvider) -> list[EnvironmentInstanceProvider]:
+            return self.provider_dependencies[provider]
+
+        def add_provider_dependency(self, provider: EnvironmentInstanceProvider, type: Type) -> Optional[EnvironmentInstanceProvider]:
+            provider_dependencies = self.provider_dependencies.get(provider, None)
+            if provider_dependencies is None:
+                provider_dependencies = []
+                self.provider_dependencies[provider] = provider_dependencies
+
+            provider = self.get_provider(type)
 
-        def __init__(self):
-            self.dependencies : list[AbstractInstanceProvider] = []
+            if any(issubclass(provider.get_type(), dependency.get_type()) for dependency in provider_dependencies):
+                return None
 
-        def add(self, *providers: AbstractInstanceProvider):
+            provider_dependencies.append(provider)
+
+            return provider
+
+        def next(self):
+            self.dependencies.clear()
+
+        def get_provider(self, type: Type) -> EnvironmentInstanceProvider:
+            provider = self.providers.get(type, None)
+            if provider is None:
+                raise DIRegistrationException(f"Provider for {type} is not defined")
+
+            return provider
+
+        def add(self, *providers: EnvironmentInstanceProvider):
             for provider in providers:
                 if next((p for p in self.dependencies if p.get_type() is provider.get_type()), None) is not None:
-                    raise InjectorException(self.cycle_report(provider))
+                    raise DIRegistrationException(self.cycle_report(provider))
 
                 self.dependencies.append(provider)
 
@@ -504,19 +556,17 @@ class Providers:
 
                 first = False
 
-                cycle += f"{p.get_type().__name__}"
+                cycle += f"{p.report()}"
 
-            cycle += f" <> {provider.get_type().__name__}"
+            cycle += f" <> {provider.report()}"
 
             return cycle
 
 
     # class properties
 
-    check: list[AbstractInstanceProvider] = []
-
-    providers : Dict[Type,AbstractInstanceProvider] = {}
-    cache: Dict[Type, AbstractInstanceProvider] = {}
+    check : list[AbstractInstanceProvider] = []
+    providers : Dict[Type,list[AbstractInstanceProvider]] = {}
 
     resolved = False
 
@@ -524,7 +574,58 @@ class Providers:
     def register(cls, provider: AbstractInstanceProvider):
         Environment.logger.debug("register provider %s(%s)", provider.get_type().__qualname__, provider.get_type().__name__)
 
-        # local functions
+        Providers.check.append(provider)
+        candidates = Providers.providers.get(provider.get_type(), None)
+        if candidates is None:
+            Providers.providers[provider.get_type()] = [provider]
+        else:
+            candidates.append(provider)
+
+    # add factories lazily
+
+    @classmethod
+    def check_factories(cls):
+        for check in Providers.check:
+            check.check_factories()
+
+        Providers.check.clear()
+
+    @classmethod
+    def filter(cls, environment: Environment) -> Dict[Type,AbstractInstanceProvider]:
+        cache: Dict[Type,AbstractInstanceProvider] = {}
+
+        context: ConditionContext = {
+            "requires_feature": lambda feature : environment.has_feature(feature),
+            "requires_class": lambda clazz : cache.get(clazz, None) is not None # ? only works if the class is in the cache already?
+        }
+
+        Providers.check_factories() # check for additional factories
+
+        # local methods
+
+        def filter_type(clazz: Type) -> Optional[AbstractInstanceProvider]:
+            result = None
+            for provider in Providers.providers[clazz]:
+                if provider_applies(provider):
+                    if result is not None:
+                        raise ProviderCollisionException(f"type {clazz.__name__} already registered", result, provider)
+
+                    else:
+                        result = provider
+
+            return result
+
+        def provider_applies(provider: AbstractInstanceProvider) -> bool:
+            descriptor = TypeDescriptor.for_type(provider.get_host())
+            if descriptor.has_decorator(conditional):
+                conditions: list[Condition] = [*descriptor.get_decorator(conditional).args]
+                for condition in conditions:
+                    if not condition.apply(context):
+                        return False
+
+                return True
+
+            return True
 
         def is_injectable(type: Type) -> bool:
             if type is object:
@@ -533,27 +634,21 @@ class Providers:
             if inspect.isabstract(type):
                 return False
 
-            #for decorator in Decorators.get(type):
-            #    if decorator.decorator is injectable:
-            #        return True
-
-            # darn
-
             return True
 
         def cache_provider_for_type(provider: AbstractInstanceProvider, type: Type):
-            existing_provider = Providers.cache.get(type)
+            existing_provider = cache.get(type)
             if existing_provider is None:
-                Providers.cache[type] = provider
+                cache[type] = provider
 
             else:
                 if type is provider.get_type():
-                    raise InjectorException(f"{type} already registered")
+                    raise ProviderCollisionException(f"type {type.__name__} already registered", existing_provider, provider)
 
                 if isinstance(existing_provider, AmbiguousProvider):
                     cast(AmbiguousProvider, existing_provider).add_provider(provider)
                 else:
-                    Providers.cache[type] = AmbiguousProvider(type, existing_provider, provider)
+                    cache[type] = AmbiguousProvider(type, existing_provider, provider)
 
             # recursion
 
@@ -561,35 +656,35 @@ class Providers:
                 if is_injectable(super_class):
                     cache_provider_for_type(provider, super_class)
 
-        # go
+        # filter conditional providers and fill base classes as well
 
-        Providers.check.append(provider)
+        for provider_type, providers in Providers.providers.items():
+            matching_provider = filter_type(provider_type)
+            if matching_provider is not None:
+                cache_provider_for_type(matching_provider, provider_type)
 
-        Providers.providers[provider.get_type()] = provider
+        # replace by EnvironmentInstanceProvider
 
-        # cache providers
+        mapped = {}
+        result = {}
+        for provider_type, provider in cache.items():
+            environment_provider = mapped.get(provider, None)
+            if environment_provider is None:
+                environment_provider = EnvironmentInstanceProvider(environment,  provider)
+                mapped[provider] = environment_provider
 
-        cache_provider_for_type(provider, provider.get_type())
+            result[provider_type] = environment_provider
 
-    @classmethod
-    def resolve(cls):
-        for provider in Providers.check:
-            provider.resolve(Providers.Context())
+        # and resolve
 
-        Providers.check.clear()
+        provider_context = Providers.ResolveContext(result)
+        for provider in mapped.values():
+            provider.resolve(provider_context)
+            provider_context.next() # clear dependencies
 
-    @classmethod
-    def report(cls):
-        for provider in Providers.cache.values():
-            print(f"provider {provider.get_type().__qualname__}")
-
-    @classmethod
-    def get_provider(cls, type: Type) -> AbstractInstanceProvider:
-        provider = Providers.cache.get(type, None)
-        if provider is None:
-            raise InjectorException(f"{type.__name__} not registered as injectable")
+        # done
 
-        return provider
+        return result
 
 def register_factories(cls: Type):
     descriptor = TypeDescriptor.for_type(cls)
@@ -597,7 +692,11 @@ def register_factories(cls: Type):
     for method in descriptor.get_methods():
         if method.has_decorator(create):
             create_decorator = method.get_decorator(create)
-            Providers.register(FunctionInstanceProvider(cls, method.method, method.return_type, create_decorator.args[0],
+            return_type = method.return_type
+            if return_type is None:
+                raise DIRegistrationException(f"{cls.__name__}.{method.method.__name__} expected to have a return type")
+
+            Providers.register(FunctionInstanceProvider(cls, method.method, return_type, create_decorator.args[0],
                                                         create_decorator.args[1]))
 def order(prio = 0):
     def decorator(cls):
@@ -686,8 +785,6 @@ def environment(imports: Optional[list[Type]] = None):
         Decorators.add(cls, environment, imports)
         Decorators.add(cls, injectable) # do we need that?
 
-        register_factories(cls)
-
         return cls
 
     return decorator
@@ -712,6 +809,49 @@ def inject_environment():
 
     return decorator
 
+# conditional stuff
+
+class ConditionContext(TypedDict):
+    requires_feature: Callable[[str], bool]
+    requires_class: Callable[[Type], bool]
+
+class Condition(ABC):
+    @abstractmethod
+    def apply(self, context: ConditionContext) -> bool:
+        pass
+
+class FeatureCondition(Condition):
+    def __init__(self, feature: str):
+        super().__init__()
+
+        self.feature = feature
+
+    def apply(self, context: ConditionContext) -> bool:
+        return context["requires_feature"](self.feature)
+
+class ClassCondition(Condition):
+    def __init__(self, clazz: Type):
+        super().__init__()
+
+        self.clazz = clazz
+
+    def apply(self, context: ConditionContext) -> bool:
+        return context["requires_class"](self.clazz)
+
+def requires_feature(feature: str):
+    return FeatureCondition(feature)
+
+def requires_class(clazz: Type):
+    return ClassCondition(clazz)
+
+def conditional(*conditions: Condition):
+    def decorator(cls):
+        Decorators.add(cls, conditional, *conditions)
+
+        return cls
+
+    return decorator
+
 class Environment:
     """
     Central class that manages the lifecycle of instances and their dependencies.
@@ -728,12 +868,13 @@ class Environment:
         "providers",
         "lifecycle_processors",
         "parent",
+        "features",
         "instances"
     ]
 
     # constructor
 
-    def __init__(self, env: Type, parent : Optional[Environment] = None):
+    def __init__(self, env: Type, features: list[str] = [], parent : Optional[Environment] = None):
         """
         Creates a new Environment instance.
 
@@ -741,27 +882,34 @@ class Environment:
             env (Type): The environment class that controls the scanning of managed objects.
             parent (Optional[Environment]): Optional parent environment, whose objects are inherited.
         """
+
+        Environment.logger.debug("create environment for class %s", env.__qualname__)
+
         # initialize
 
         self.type = env
         self.parent = parent
-        if self.parent is None and env is not BootEnvironment:
-            self.parent = BootEnvironment.get_instance() # inherit environment including its manged instances!
+        if self.parent is None and env is not Boot:
+            self.parent = Boot.get_environment() # inherit environment including its manged instances!
 
+        self.features = features
         self.providers: Dict[Type, AbstractInstanceProvider] = {}
         self.lifecycle_processors: list[LifecycleProcessor] = []
 
         if self.parent is not None:
             self.providers |= self.parent.providers
             self.lifecycle_processors += self.parent.lifecycle_processors
+        else: #if self.type is Boot:
+            self.providers[SingletonScope] = SingletonScopeInstanceProvider()
+            self.providers[RequestScope]   = RequestScopeInstanceProvider()
 
         self.instances = []
 
         Environment.instance = self
 
-        # resolve providers on a static basis. This is executed for all new providers ( in case of new modules multiple times) !
+        # filter conditional providers
 
-        Providers.resolve()
+        overall_providers = Providers.filter(self)
 
         loaded = set()
 
@@ -770,12 +918,6 @@ class Environment:
 
             self.providers[type] = provider
 
-        # bootstrapping hack, they will be overwritten by the "real" providers
-
-        if env is BootEnvironment:
-            add_provider(SingletonScope, SingletonScopeInstanceProvider())
-            add_provider(RequestScope, RequestScopeInstanceProvider())
-
         def load_environment(env: Type):
             if env not in loaded:
                 Environment.logger.debug("load environment %s", env.__qualname__)
@@ -786,7 +928,7 @@ class Environment:
 
                 decorator = TypeDescriptor.for_type(env).get_decorator(environment)
                 if decorator is None:
-                    raise InjectorException(f"{env.__name__} is not an environment class")
+                    raise DIRegistrationException(f"{env.__name__} is not an environment class")
 
                 scan = env.__module__
                 if "." in scan:
@@ -797,39 +939,18 @@ class Environment:
                 for import_environment in decorator.args[0] or []:
                     load_environment(import_environment)
 
-                # load providers
-
-                local_providers = {type: provider for type, provider in Providers.cache.items() if provider.get_module().startswith(scan)}
-
-                # register providers
-
-                # make sure, that for every type only a single EnvironmentInstanceProvider is created!
-                # otherwise inheritance will fuck it up
-
-                environment_providers : dict[AbstractInstanceProvider, EnvironmentInstanceProvider] = {}
-
-                for type, provider in local_providers.items():
-                    environment_provider = environment_providers.get(provider, None)
-                    if environment_provider is None:
-                        environment_provider =  EnvironmentInstanceProvider(self, provider)
-                        environment_providers[provider] = environment_provider
-
-                    add_provider(type, environment_provider)
+                # filter and load providers according to their module
 
-                # tweak dependencies
-
-                for type, provider in local_providers.items():
-                    cast(EnvironmentInstanceProvider, self.providers[type]).tweak_dependencies(self.providers)
-
-                # return local providers
+                for type, provider in overall_providers.items():
+                    if provider.get_module().startswith(scan):
+                        add_provider(type, provider)
+        # go
 
-                return environment_providers.values()
-            else:
-                return []
+        load_environment(env)
 
         # construct eager objects for local providers
 
-        for provider in load_environment(env):
+        for provider in set(self.providers.values()):
             if provider.is_eager():
                 provider.create(self)
 
@@ -840,6 +961,9 @@ class Environment:
 
     # internal
 
+    def has_feature(self, feature: str) -> bool:
+        return feature in self.features
+
     def execute_processors(self, lifecycle: Lifecycle, instance: T) -> T:
         for processor in self.lifecycle_processors:
             processor.process_lifecycle(lifecycle, instance, self)
@@ -889,8 +1013,9 @@ class Environment:
 
         builder.append("Providers \n")
         for result_type, provider in self.providers.items():
-            if cast(EnvironmentInstanceProvider, provider).environment is self:
-                builder.append(f"- {result_type.__name__}: {cast(EnvironmentInstanceProvider, provider).provider}\n")
+            if isinstance(provider, EnvironmentInstanceProvider):
+                if cast(EnvironmentInstanceProvider, provider).environment is self:
+                    builder.append(f"- {result_type.__name__}: {provider.report()}\n")
 
         # instances
 
@@ -921,7 +1046,7 @@ class Environment:
 
     def get(self, type: Type[T]) -> T:
         """
-        Return and possibly create a new instance of the given type.
+        Create or return a cached instance for the given type.
 
         Arguments:
             type (Type): The desired type
@@ -931,10 +1056,13 @@ class Environment:
         provider = self.providers.get(type, None)
         if provider is None:
             Environment.logger.error("%s is not supported", type)
-            raise InjectorException(f"{type} is not supported")
+            raise DIRuntimeException(f"{type} is not supported")
 
         return provider.create(self)
 
+    def __str__(self):
+        return f"Environment({self.type.__name__})"
+
 class LifecycleCallable:
     __slots__ = [
         "decorator",
@@ -981,6 +1109,7 @@ class AbstractCallableProcessor(LifecycleProcessor):
 
     # static data
 
+    lock = threading.RLock()
     callables : Dict[object, LifecycleCallable] = {}
     cache : Dict[Type, list[list[AbstractCallableProcessor.MethodCall]]] = {}
 
@@ -1018,8 +1147,11 @@ class AbstractCallableProcessor(LifecycleProcessor):
     def callables_for(cls, type: Type) -> list[list[AbstractCallableProcessor.MethodCall]]:
         callables = AbstractCallableProcessor.cache.get(type, None)
         if callables is None:
-            callables = AbstractCallableProcessor.compute_callables(type)
-            AbstractCallableProcessor.cache[type] = callables
+            with AbstractCallableProcessor.lock:
+                callables = AbstractCallableProcessor.cache.get(type, None)
+                if callables is None:
+                    callables = AbstractCallableProcessor.compute_callables(type)
+                    AbstractCallableProcessor.cache[type] = callables
 
         return callables
 
@@ -1113,20 +1245,20 @@ class InjectLifecycleCallable(LifecycleCallable):
     def args(self, decorator: DecoratorDescriptor,  method: TypeDescriptor.MethodDescriptor, environment: Environment):
         return [environment.get(type) for type in method.param_types]
 
-def scope(name: str):
+def scope(name: str, register=True):
     def decorator(cls):
         Scopes.register(cls, name)
 
         Decorators.add(cls, scope)
-        # Decorators.add(cls, injectable)
 
-        Providers.register(ClassInstanceProvider(cls, eager=True, scope="request"))
+        if register:
+            Providers.register(ClassInstanceProvider(cls, eager=True, scope="request"))
 
         return cls
 
     return decorator
 
-@scope("request")
+@scope("request", register=False)
 class RequestScope(Scope):
     # properties
 
@@ -1138,7 +1270,7 @@ class RequestScope(Scope):
     def get(self, provider: AbstractInstanceProvider, environment: Environment, arg_provider: Callable[[],list]):
         return provider.create(environment, *arg_provider())
 
-@scope("singleton")
+@scope("singleton", register=False)
 class SingletonScope(Scope):
     # properties
 
@@ -1164,7 +1296,7 @@ class SingletonScope(Scope):
                     self.value = provider.create(environment, *arg_provider())
 
         return self.value
-    
+
 @scope("thread")
 class ThreadScope(Scope):
     __slots__ = [
@@ -1185,17 +1317,17 @@ class ThreadScope(Scope):
 # internal class that is required to import technical instance providers
 
 @environment()
-class BootEnvironment:
+class Boot:
     # class
 
     environment = None
 
     @classmethod
-    def get_instance(cls):
-        if BootEnvironment.environment is None:
-            BootEnvironment.environment = Environment(BootEnvironment)
+    def get_environment(cls):
+        if Boot.environment is None:
+            Boot.environment = Environment(Boot)
 
-        return BootEnvironment.environment
+        return Boot.environment
 
     # properties