aspyx 1.2.0__py3-none-any.whl → 1.4.0__py3-none-any.whl

aspyx/di/di.py

@@ -5,13 +5,16 @@ from __future__ import annotations
 
 import inspect
 import logging
+import importlib
+import pkgutil
+import sys
 
 from abc import abstractmethod, ABC
 from enum import Enum
 import threading
-from typing import Type, Dict, TypeVar, Generic, Optional, cast, Callable
+from typing import Type, Dict, TypeVar, Generic, Optional, cast, Callable, TypedDict
 
-from aspyx.di.util import StringBuilder
+from aspyx.util import StringBuilder
 from aspyx.reflection import Decorators, TypeDescriptor, DecoratorDescriptor
 
 T = TypeVar("T")
@@ -31,16 +34,31 @@ 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]):
     """
@@ -65,17 +83,23 @@ 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):
-        pass
+    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
@@ -89,8 +113,7 @@ class InstanceProvider(AbstractInstanceProvider):
         "host",
         "type",
         "eager",
-        "scope",
-        "dependencies"
+        "scope"
     ]
 
     # constructor
@@ -100,12 +123,6 @@ 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
 
@@ -113,10 +130,6 @@ class InstanceProvider(AbstractInstanceProvider):
         return self.host
 
     def check_factories(self):
-        #register_factories(self.host)
-        pass
-
-    def resolve(self, context: Providers.Context):
         pass
 
     def get_module(self) -> str:
@@ -131,22 +144,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
@@ -159,6 +161,13 @@ class SingletonScopeInstanceProvider(InstanceProvider):
     def create(self, environment: Environment, *args):
         return SingletonScope()
 
+class EnvironmentScopeInstanceProvider(InstanceProvider):
+    def __init__(self):
+        super().__init__(SingletonScopeInstanceProvider, SingletonScope, False, "request") # TODO?
+
+    def create(self, environment: Environment, *args):
+        return EnvironmentScope()
+
 class RequestScopeInstanceProvider(InstanceProvider):
     def __init__(self):
         super().__init__(RequestScopeInstanceProvider, RequestScope, False, "singleton")
@@ -166,7 +175,6 @@ class RequestScopeInstanceProvider(InstanceProvider):
     def create(self, environment: Environment, *args):
         return RequestScope()
 
-
 class AmbiguousProvider(AbstractInstanceProvider):
     """
     An AmbiguousProvider covers all cases, where fetching a class would lead to an ambiguity exception.
@@ -204,15 +212,12 @@ 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 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})"
 
@@ -257,8 +262,8 @@ class EnvironmentInstanceProvider(AbstractInstanceProvider):
     __slots__ = [
         "environment",
         "scope_instance",
-        "provider",
         "dependencies",
+        "provider"
     ]
 
     # constructor
@@ -268,14 +273,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()
@@ -289,18 +310,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 DIRegistrationException(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!
@@ -329,41 +342,36 @@ class ClassInstanceProvider(InstanceProvider):
     def check_factories(self):
         register_factories(self.host)
 
-    def resolve(self, context: Providers.Context):
-        context.add(self)
-
-        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 DIRegistrationException(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):
@@ -387,25 +395,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__})"
 
@@ -429,32 +431,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__ = []
@@ -466,7 +460,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"
@@ -506,13 +500,54 @@ 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
 
-        def __init__(self):
-            self.dependencies : list[AbstractInstanceProvider] = []
+            provider = self.get_provider(type)
 
-        def add(self, *providers: AbstractInstanceProvider):
+            if any(issubclass(provider.get_type(), dependency.get_type()) for dependency in provider_dependencies):
+                return None
+
+            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 DIRegistrationException(self.cycle_report(provider))
@@ -529,19 +564,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
 
@@ -549,7 +582,64 @@ 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, provider_filter: Callable) -> 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)
+
+                    result = provider
+
+            return result
+
+        def provider_applies(provider: AbstractInstanceProvider) -> bool:
+            # is it in the right module?
+
+            if not provider_filter(provider):
+                return False
+
+            # check conditionals
+
+            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:
@@ -558,34 +648,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):
-            def location(provider: AbstractInstanceProvider):
-                host = provider.get_host()
-                file = inspect.getfile(host)
-                line = inspect.getsourcelines(host)[1]
-
-                return f"{file}:{line}"
-
-            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 DIRegistrationException(f"{type} already registered in {location(existing_provider)}, override in {location(provider)}")
+                    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
 
@@ -593,39 +670,39 @@ class Providers:
                 if is_injectable(super_class):
                     cache_provider_for_type(provider, super_class)
 
-        # go
-
-        Providers.check.append(provider)
+        # filter conditional providers and fill base classes as well
 
-        Providers.providers[provider.get_type()] = provider
+        for provider_type, _ in Providers.providers.items():
+            matching_provider = filter_type(provider_type)
+            if matching_provider is not None:
+                cache_provider_for_type(matching_provider, provider_type)
 
-        # cache providers
+        # replace by EnvironmentInstanceProvider
 
-        cache_provider_for_type(provider, provider.get_type())
+        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
 
-    @classmethod
-    def resolve(cls):
+            result[provider_type] = environment_provider
 
-        for check in  Providers.check:
-            check.check_factories()
+        # and resolve
 
-        # in the loop additional providers may be added
-        while len(Providers.check) > 0:
-            check = Providers.check.pop(0)
-            check.resolve(Providers.Context())
+        providers = result
+        if environment.parent is not None:
+            providers = providers | environment.parent.providers # add parent providers
 
-    @classmethod
-    def report(cls):
-        for provider in Providers.cache.values():
-            print(f"provider {provider.get_type().__qualname__}")
+        provider_context = Providers.ResolveContext(providers)
+        for provider in mapped.values():
+            provider.resolve(provider_context)
+            provider_context.next() # clear dependencies
 
-    @classmethod
-    def get_provider(cls, type: Type) -> AbstractInstanceProvider:
-        provider = Providers.cache.get(type, None)
-        if provider is None:
-            raise DIException(f"{type.__name__} not registered as injectable")
+        # done
 
-        return provider
+        return result
 
 def register_factories(cls: Type):
     descriptor = TypeDescriptor.for_type(cls)
@@ -750,6 +827,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.
@@ -766,12 +886,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.
 
@@ -779,6 +900,9 @@ 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
@@ -786,20 +910,37 @@ class Environment:
         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.instances = []
         self.lifecycle_processors: list[LifecycleProcessor] = []
 
         if self.parent is not None:
-            self.providers |= self.parent.providers
-            self.lifecycle_processors += self.parent.lifecycle_processors
+            # inherit providers from parent
 
-        self.instances = []
+            for provider_type, inherited_provider in self.parent.providers.items():
+                if inherited_provider.get_scope() == "environment":
+                    # replace with own environment instance provider
+                    self.providers[provider_type] = EnvironmentInstanceProvider(self, cast(EnvironmentInstanceProvider, inherited_provider).provider)
+                else:
+                    self.providers[provider_type] = inherited_provider
 
-        Environment.instance = self
+            # inherit processors as is unless they have an environment scope
 
-        # resolve providers on a static basis. This is executed for all new providers ( in case of new modules multiple times) !
+            for processor in self.parent.lifecycle_processors:
+                if self.providers[type(processor)].get_scope() != "environment":
+                    self.lifecycle_processors.append(processor)
+                else:
+                    # create and remember
+                    self.lifecycle_processors.append(self.get(type(processor)))
+        else:
+            self.providers[SingletonScope] = SingletonScopeInstanceProvider()
+            self.providers[RequestScope]   = RequestScopeInstanceProvider()
+            self.providers[EnvironmentScope] = EnvironmentScopeInstanceProvider()
+
+        Environment.instance = self
 
-        Providers.resolve()
+        prefix_list : list[str] = []
 
         loaded = set()
 
@@ -808,11 +949,35 @@ class Environment:
 
             self.providers[type] = provider
 
-        # bootstrapping hack, they will be overwritten by the "real" providers
+        def get_type_package(type: Type):
+            module_name = type.__module__
+            module = sys.modules[module_name]
+
+            return module.__package__
+
+        def import_package(name: str):
+            """Import a package and all its submodules recursively."""
+            package = importlib.import_module(name)
+            results = {name: package}
 
-        if env is Boot:
-            add_provider(SingletonScope, SingletonScopeInstanceProvider())
-            add_provider(RequestScope, RequestScopeInstanceProvider())
+            if hasattr(package, '__path__'):  # it's a package, not a single file
+                for finder, name, ispkg in pkgutil.walk_packages(package.__path__, prefix=package.__name__ + "."):
+                    try:
+                        loaded = sys.modules
+
+                        if loaded.get(name, None) is None:
+                            Environment.logger.debug("import module %s", name)
+
+                            submodule = importlib.import_module(name)
+                            results[name] = submodule
+                        else:
+                            # skip import
+                            results[name] = loaded[name]
+
+                    except Exception as e:
+                        Environment.logger.info("failed to import module %s due to %s", name, str(e))
+
+            return results
 
         def load_environment(env: Type):
             if env not in loaded:
@@ -826,48 +991,46 @@ class Environment:
                 if decorator is None:
                     raise DIRegistrationException(f"{env.__name__} is not an environment class")
 
-                scan = env.__module__
-                if "." in scan:
-                    scan = scan.rsplit('.', 1)[0]
+                # package
+
+                package_name = get_type_package(env)
 
                 # recursion
 
                 for import_environment in decorator.args[0] or []:
                     load_environment(import_environment)
 
-                # load providers
+                # import package
 
-                local_providers = {type: provider for type, provider in Providers.cache.items() if provider.get_module().startswith(scan)}
+                if package_name is not None and len(package_name) > 0: # files outside of a package return None pr ""
+                    import_package(package_name)
 
-                # register providers
+                # filter and load providers according to their module
 
-                # make sure, that for every type only a single EnvironmentInstanceProvider is created!
-                # otherwise inheritance will fuck it up
+                module_prefix = package_name
+                if len(module_prefix) == 0:
+                    module_prefix = env.__module__
 
-                environment_providers : dict[AbstractInstanceProvider, EnvironmentInstanceProvider] = {}
+                prefix_list.append(module_prefix)
 
-                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
+        # go
 
-                    add_provider(type, environment_provider)
+        load_environment(env)
 
-                # tweak dependencies
+        # filter according to the prefix list
 
-                for type, provider in local_providers.items():
-                    cast(EnvironmentInstanceProvider, self.providers[type]).tweak_dependencies(self.providers)
+        def filter_provider(provider: AbstractInstanceProvider) -> bool:
+            for prefix in prefix_list:
+                if provider.get_host().__module__.startswith(prefix):
+                    return True
 
-                # return local providers
+            return False
 
-                return environment_providers.values()
-            else:
-                return []
+        self.providers.update(Providers.filter(self, filter_provider))
 
         # 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)
 
@@ -876,8 +1039,19 @@ class Environment:
         for instance in self.instances:
             self.execute_processors(Lifecycle.ON_RUNNING, instance)
 
+    def is_registered_type(self, type: Type) -> bool:
+        provider = self.providers.get(type, None)
+        return provider is not None and not isinstance(provider, AmbiguousProvider)
+
+    def registered_types(self,  predicate: Callable[[Type], bool]) -> list[Type]:
+        return [provider.get_type() for provider in self.providers.values()
+                if predicate(provider.get_type())]
+
     # 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)
@@ -927,8 +1101,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
 
@@ -973,6 +1148,9 @@ class Environment:
 
         return provider.create(self)
 
+    def __str__(self):
+        return f"Environment({self.type.__name__})"
+
 class LifecycleCallable:
     __slots__ = [
         "decorator",
@@ -1155,20 +1333,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
 
@@ -1180,7 +1358,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
 
@@ -1207,6 +1385,19 @@ class SingletonScope(Scope):
 
         return self.value
 
+@scope("environment", register=False)
+class EnvironmentScope(SingletonScope):
+    # properties
+
+    __slots__ = [
+    ]
+
+    # constructor
+
+    def __init__(self):
+        super().__init__()
+
+
 @scope("thread")
 class ThreadScope(Scope):
     __slots__ = [