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

aspyx/di/di.py

@@ -1,3 +1,6 @@
+"""
+The deoendency injection module provides a framework for managing dependencies and lifecycle of objects in Python applications.
+"""
 from __future__ import annotations
 
 import inspect
@@ -8,6 +11,7 @@ from enum import Enum, auto
 import threading
 from typing import Type, Dict, TypeVar, Generic, Optional, cast, Callable
 
+from aspyx.di.util import StringBuilder
 from aspyx.reflection import Decorators, TypeDescriptor, DecoratorDescriptor
 
 T = TypeVar("T")
@@ -25,8 +29,8 @@ class Factory(ABC, Generic[T]):
 
 class InjectorException(Exception):
     """
-    Exception raised for errors in the injector."""
-    pass
+    Exception raised for errors in the injector.
+    """
 
 class AbstractInstanceProvider(ABC, Generic[T]):
     """
@@ -53,11 +57,11 @@ class AbstractInstanceProvider(ABC, Generic[T]):
         pass
 
     @abstractmethod
-    def create(self, env: Environment, *args):
+    def create(self, environment: Environment, *args):
         pass
 
     @abstractmethod
-    def resolve(self, context: Providers.Context) -> AbstractInstanceProvider:
+    def resolve(self, context: Providers.Context):
         pass
 
 
@@ -82,10 +86,15 @@ class InstanceProvider(AbstractInstanceProvider):
         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) -> AbstractInstanceProvider:
-        return self
+    def resolve(self, context: Providers.Context):
+        pass
 
     def get_module(self) -> str:
         return self.host.__module__
@@ -175,8 +184,8 @@ class AmbiguousProvider(AbstractInstanceProvider):
     def get_dependencies(self) -> list[AbstractInstanceProvider]:
         return []
 
-    def resolve(self, context: Providers.Context) -> AbstractInstanceProvider:
-        return self
+    def resolve(self, context: Providers.Context):
+        pass
 
     def create(self, environment: Environment, *args):
         raise InjectorException(f"multiple candidates for type {self.type}")
@@ -193,15 +202,15 @@ class Scopes:
 
     @classmethod
     def get(cls, scope: str, environment: Environment):
-        scopeType = Scopes.scopes.get(scope, None)
-        if scopeType is None:
+        scope_type = Scopes.scopes.get(scope, None)
+        if scope_type is None:
             raise InjectorException(f"unknown scope type {scope}")
 
-        return environment.get(scopeType)
+        return environment.get(scope_type)
 
     @classmethod
-    def register(cls, scopeClass: Type, name: str):
-        Scopes.scopes[name] = scopeClass
+    def register(cls, scope_type: Type, name: str):
+        Scopes.scopes[name] = scope_type
 
 class Scope:
     # properties
@@ -216,15 +225,15 @@ class Scope:
 
     # public
 
-    def get(self, provider: AbstractInstanceProvider, environment: Environment, argProvider: Callable[[],list]):
-        return provider.create(environment, *argProvider())
+    def get(self, provider: AbstractInstanceProvider, environment: Environment, arg_provider: Callable[[],list]):
+        return provider.create(environment, *arg_provider())
 
 class EnvironmentInstanceProvider(AbstractInstanceProvider):
     # properties
 
     __slots__ = [
         "environment",
-        "scopeInstance",
+        "scope_instance",
         "provider",
         "dependencies",
     ]
@@ -238,12 +247,11 @@ class EnvironmentInstanceProvider(AbstractInstanceProvider):
         self.provider = provider
         self.dependencies : list[AbstractInstanceProvider] = []
 
-        self.scopeInstance = Scopes.get(provider.get_scope(), environment)
-        print()
+        self.scope_instance = Scopes.get(provider.get_scope(), environment)
 
     # implement
 
-    def resolve(self, context: Providers.Context) -> AbstractInstanceProvider:
+    def resolve(self, context: Providers.Context):
         pass # noop
 
     def get_module(self) -> str:
@@ -260,21 +268,19 @@ class EnvironmentInstanceProvider(AbstractInstanceProvider):
 
     # custom logic
 
-    def tweakDependencies(self, providers: dict[Type, AbstractInstanceProvider]):
+    def tweak_dependencies(self, providers: dict[Type, AbstractInstanceProvider]):
         for dependency in self.provider.get_dependencies():
-            instanceProvider = providers.get(dependency.get_type(), None)
-            if instanceProvider is None:
+            instance_provider = providers.get(dependency.get_type(), None)
+            if instance_provider is None:
                 raise InjectorException(f"missing import for {dependency.get_type()} ")
 
-            self.dependencies.append(instanceProvider)
-            pass
-        pass
+            self.dependencies.append(instance_provider)
 
     def get_dependencies(self) -> list[AbstractInstanceProvider]:
         return self.provider.get_dependencies()
 
-    def create(self, env: Environment, *args):
-        return self.scopeInstance.get(self.provider, self.environment, lambda: [provider.create(env) for provider in self.dependencies] ) # already scope property!
+    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!
 
     def __str__(self):
         return f"EnvironmentInstanceProvider({self.provider})"
@@ -297,11 +303,11 @@ class ClassInstanceProvider(InstanceProvider):
 
     # implement
 
-    def resolve(self, context: Providers.Context) -> InstanceProvider:
-        if self.dependencies is None:
-            self.dependencies = []
+    def resolve(self, context: Providers.Context):
+        context.add(self)
 
-            context.add(self)
+        if not self._is_resolved():
+            self.dependencies = []
 
             # check constructor
 
@@ -309,28 +315,26 @@ class ClassInstanceProvider(InstanceProvider):
             if init is None:
                 raise InjectorException(f"{self.type.__name__} does not implement __init__")
 
-            for param in init.paramTypes:
-                provider = Providers.getProvider(param)
+            for param in init.param_types:
+                provider = Providers.get_provider(param)
                 self.params += 1
-                if self.add_dependency(provider):
+                if self.add_dependency(provider): # a dependency can occur multiple times, e.g in __init__ and in an injected method
                     provider.resolve(context)
 
             # check @inject
 
-            for method in TypeDescriptor.for_type(self.type).methods.values():
+            for method in TypeDescriptor.for_type(self.type).get_methods():
                 if method.has_decorator(inject):
-                    for param in method.paramTypes:
-                        provider = Providers.getProvider(param)
+                    for param in method.param_types:
+                        provider = Providers.get_provider(param)
 
                         if self.add_dependency(provider):
                             provider.resolve(context)
         else: # check if the dependencies create a cycle
             context.add(*self.dependencies)
 
-        return self
-
     def create(self, environment: Environment, *args):
-        Environment.logger.debug(f"{self} create class {self.type.__qualname__}")
+        Environment.logger.debug("%s create class %s", self, self.type.__qualname__)
 
         return environment.created(self.type(*args[:self.params]))
 
@@ -357,22 +361,20 @@ class FunctionInstanceProvider(InstanceProvider):
 
     # implement
 
-    def resolve(self, context: Providers.Context) -> AbstractInstanceProvider:
-        if self.dependencies is None:
-            self.dependencies = []
+    def resolve(self, context: Providers.Context):
+        context.add(self)
 
-            context.add(self)
+        if not self._is_resolved():
+            self.dependencies = []
 
-            provider = Providers.getProvider(self.host)
+            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 create(self, environment: Environment, *args):
-        Environment.logger.debug(f"{self} create class {self.type.__qualname__}")
+        Environment.logger.debug("%s create class %s", self, self.type.__qualname__)
 
         instance = self.method(*args)
 
@@ -391,23 +393,23 @@ class FactoryInstanceProvider(InstanceProvider):
     # class method
 
     @classmethod
-    def getFactoryType(cls, clazz):
-        return TypeDescriptor.for_type(clazz).get_local_method("create").returnType
+    def get_factory_type(cls, clazz):
+        return TypeDescriptor.for_type(clazz).get_method("create", local=True).return_type
 
     # constructor
 
     def __init__(self, factory: Type, eager: bool, scope: str):
-        super().__init__(factory, FactoryInstanceProvider.getFactoryType(factory), eager, scope)
+        super().__init__(factory, FactoryInstanceProvider.get_factory_type(factory), eager, scope)
 
     # implement
 
-    def resolve(self, context: Providers.Context) -> AbstractInstanceProvider:
-        if self.dependencies is None:
-            self.dependencies = []
+    def resolve(self, context: Providers.Context):
+        context.add(self)
 
-            context.add(self)
+        if  not self._is_resolved():
+            self.dependencies = []
 
-            provider = Providers.getProvider(self.host)
+            provider = Providers.get_provider(self.host)
             if self.add_dependency(provider):
                 provider.resolve(context)
 
@@ -417,7 +419,7 @@ class FactoryInstanceProvider(InstanceProvider):
         return self
 
     def create(self, environment: Environment, *args):
-        Environment.logger.debug(f"{self} create class {self.type.__qualname__}")
+        Environment.logger.debug("%s create class %s", self, self.type.__qualname__)
 
         return environment.created(args[0].create())
 
@@ -432,8 +434,10 @@ class Lifecycle(Enum):
 
     __slots__ = []
 
-    ON_INIT = auto()
-    ON_DESTROY = auto()
+    ON_INJECT  = 0
+    ON_INIT    = 1
+    ON_RUNNING = 2
+    ON_DESTROY = 3
 
 class LifecycleProcessor(ABC):
     """
@@ -453,7 +457,7 @@ class LifecycleProcessor(ABC):
     # methods
 
     @abstractmethod
-    def processLifecycle(self, lifecycle: Lifecycle, instance: object, environment: Environment) -> object:
+    def process_lifecycle(self, lifecycle: Lifecycle, instance: object, environment: Environment) -> object:
         pass
 
 class PostProcessor(LifecycleProcessor):
@@ -462,15 +466,11 @@ class PostProcessor(LifecycleProcessor):
     """
     __slots__ = []
 
-    # constructor
-
-    def __init__(self):
-        super().__init__()
 
     def process(self, instance: object, environment: Environment):
         pass
 
-    def processLifecycle(self, lifecycle: Lifecycle, instance: object, environment: Environment) -> object:
+    def process_lifecycle(self, lifecycle: Lifecycle, instance: object, environment: Environment) -> object:
         if lifecycle == Lifecycle.ON_INIT:
             self.process(instance, environment)
 
@@ -490,11 +490,11 @@ class Providers:
         def add(self, *providers: AbstractInstanceProvider):
             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.cycleReport(provider))
+                    raise InjectorException(self.cycle_report(provider))
 
                 self.dependencies.append(provider)
 
-        def cycleReport(self, provider: AbstractInstanceProvider):
+        def cycle_report(self, provider: AbstractInstanceProvider):
             cycle = ""
 
             first = True
@@ -506,23 +506,23 @@ class Providers:
 
                 cycle += f"{p.get_type().__name__}"
 
-            cycle += f" -> {provider.get_type().__name__}"
+            cycle += f" <> {provider.get_type().__name__}"
 
             return cycle
 
 
     # class properties
 
-    check: list[AbstractInstanceProvider] = list()
+    check: list[AbstractInstanceProvider] = []
 
-    providers : Dict[Type,AbstractInstanceProvider] = dict()
-    cache: Dict[Type, AbstractInstanceProvider] = dict()
+    providers : Dict[Type,AbstractInstanceProvider] = {}
+    cache: Dict[Type, AbstractInstanceProvider] = {}
 
     resolved = False
 
     @classmethod
     def register(cls, provider: AbstractInstanceProvider):
-        Environment.logger.debug(f"register provider {provider.get_type().__qualname__}({provider.get_type().__name__})")
+        Environment.logger.debug("register provider %s(%s)", provider.get_type().__qualname__, provider.get_type().__name__)
 
         # local functions
 
@@ -541,7 +541,7 @@ class Providers:
 
             return True
 
-        def cacheProviderForType(provider: AbstractInstanceProvider, type: Type):
+        def cache_provider_for_type(provider: AbstractInstanceProvider, type: Type):
             existing_provider = Providers.cache.get(type)
             if existing_provider is None:
                 Providers.cache[type] = provider
@@ -557,9 +557,9 @@ class Providers:
 
             # recursion
 
-            for superClass in type.__bases__:
-                if is_injectable(superClass):
-                    cacheProviderForType(provider, superClass)
+            for super_class in type.__bases__:
+                if is_injectable(super_class):
+                    cache_provider_for_type(provider, super_class)
 
         # go
 
@@ -569,7 +569,7 @@ class Providers:
 
         # cache providers
 
-        cacheProviderForType(provider, provider.get_type())
+        cache_provider_for_type(provider, provider.get_type())
 
     @classmethod
     def resolve(cls):
@@ -578,28 +578,26 @@ class Providers:
 
         Providers.check.clear()
 
-        #Providers.report()
-
     @classmethod
     def report(cls):
         for provider in Providers.cache.values():
             print(f"provider {provider.get_type().__qualname__}")
 
     @classmethod
-    def getProvider(cls, type: Type) -> AbstractInstanceProvider:
+    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")
 
         return provider
 
-def registerFactories(cls: Type):
+def register_factories(cls: Type):
     descriptor = TypeDescriptor.for_type(cls)
 
-    for method in descriptor.methods.values():
+    for method in descriptor.get_methods():
         if method.has_decorator(create):
             create_decorator = method.get_decorator(create)
-            Providers.register(FunctionInstanceProvider(cls, method.method, method.returnType, create_decorator.args[0],
+            Providers.register(FunctionInstanceProvider(cls, method.method, method.return_type, create_decorator.args[0],
                                                         create_decorator.args[1]))
 def order(prio = 0):
     def decorator(cls):
@@ -618,8 +616,6 @@ def injectable(eager=True, scope="singleton"):
 
         Providers.register(ClassInstanceProvider(cls, eager, scope))
 
-        #TODO registerFactories(cls)
-
         return cls
 
     return decorator
@@ -657,6 +653,15 @@ def on_init():
 
     return decorator
 
+def on_running():
+    """
+    Methods annotated with @on_running will be called when the container up and running."""
+    def decorator(func):
+        Decorators.add(func, on_running)
+        return func
+
+    return decorator
+
 def on_destroy():
     """
     Methods annotated with @on_destroy will be called when the instance is destroyed.
@@ -681,7 +686,7 @@ def environment(imports: Optional[list[Type]] = None):
         Decorators.add(cls, environment, imports)
         Decorators.add(cls, injectable) # do we need that?
 
-        registerFactories(cls)
+        register_factories(cls)
 
         return cls
 
@@ -721,7 +726,7 @@ class Environment:
     __slots__ = [
         "type",
         "providers",
-        "lifecycleProcessors",
+        "lifecycle_processors",
         "parent",
         "instances"
     ]
@@ -743,25 +748,25 @@ class Environment:
         if self.parent is None and env is not BootEnvironment:
             self.parent = BootEnvironment.get_instance() # inherit environment including its manged instances!
 
-        self.providers: Dict[Type, AbstractInstanceProvider] = dict()
-        self.lifecycleProcessors: list[LifecycleProcessor] = []
+        self.providers: Dict[Type, AbstractInstanceProvider] = {}
+        self.lifecycle_processors: list[LifecycleProcessor] = []
 
         if self.parent is not None:
             self.providers |= self.parent.providers
-            self.lifecycleProcessors += self.parent.lifecycleProcessors
+            self.lifecycle_processors += self.parent.lifecycle_processors
 
         self.instances = []
 
         Environment.instance = self
 
-        # resolve providers on a static basis. This is only executed once!
+        # resolve providers on a static basis. This is executed for all new providers ( in case of new modules multiple times) !
 
         Providers.resolve()
 
         loaded = set()
 
         def add_provider(type: Type, provider: AbstractInstanceProvider):
-            Environment.logger.debug(f"\tadd provider {provider} for {type})")
+            Environment.logger.debug("\tadd provider %s for %s", provider, type)
 
             self.providers[type] = provider
 
@@ -773,7 +778,7 @@ class Environment:
 
         def load_environment(env: Type):
             if env not in loaded:
-                Environment.logger.debug(f"load environment {env.__qualname__}")
+                Environment.logger.debug("load environment %s", env.__qualname__)
 
                 loaded.add(env)
 
@@ -794,31 +799,31 @@ class Environment:
 
                 # load providers
 
-                localProviders = {type: provider for type, provider in Providers.cache.items() if provider.get_module().startswith(scan)}
+                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 ony a single EnvironmentInstanceProvider is created!
+                # make sure, that for every type only a single EnvironmentInstanceProvider is created!
                 # otherwise inheritance will fuck it up
 
-                environmentProviders : dict[AbstractInstanceProvider, EnvironmentInstanceProvider] = {}
+                environment_providers : dict[AbstractInstanceProvider, EnvironmentInstanceProvider] = {}
 
-                for type, provider in localProviders.items():
-                    environmentProvider = environmentProviders.get(provider, None)
-                    if environmentProvider is None:
-                        environmentProvider =  EnvironmentInstanceProvider(self, provider)
-                        environmentProviders[provider] = environmentProvider
+                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, environmentProvider)
+                    add_provider(type, environment_provider)
 
                 # tweak dependencies
 
-                for type, provider in localProviders.items():
-                    cast(EnvironmentInstanceProvider, self.providers[type]).tweakDependencies(self.providers)
+                for type, provider in local_providers.items():
+                    cast(EnvironmentInstanceProvider, self.providers[type]).tweak_dependencies(self.providers)
 
                 # return local providers
 
-                return environmentProviders.values()
+                return environment_providers.values()
             else:
                 return []
 
@@ -827,29 +832,29 @@ class Environment:
         for provider in load_environment(env):
             if provider.is_eager():
                 provider.create(self)
+
+        # running callback
+
+        for instance in self.instances:
+            self.execute_processors(Lifecycle.ON_RUNNING, instance)
+
     # internal
 
-    def executeProcessors(self, lifecycle: Lifecycle, instance: T) -> T:
-        for processor in self.lifecycleProcessors:
-            processor.processLifecycle(lifecycle, instance, self)
+    def execute_processors(self, lifecycle: Lifecycle, instance: T) -> T:
+        for processor in self.lifecycle_processors:
+            processor.process_lifecycle(lifecycle, instance, self)
 
         return instance
 
     def created(self, instance: T) -> T:
-        def get_order(type: TypeDescriptor) -> int:
-            if type.has_decorator(order):
-                return type.get_decorator(order).args[0]
-            else:
-                return 10
-
         # remember lifecycle processors
 
         if isinstance(instance, LifecycleProcessor):
-            self.lifecycleProcessors.append(instance)
+            self.lifecycle_processors.append(instance)
 
             # sort immediately
 
-            self.lifecycleProcessors.sort(key=lambda processor: processor.order)
+            self.lifecycle_processors.sort(key=lambda processor: processor.order)
 
         # remember instance
 
@@ -857,16 +862,60 @@ class Environment:
 
         # execute processors
 
-        return self.executeProcessors(Lifecycle.ON_INIT, instance)
+        self.execute_processors(Lifecycle.ON_INJECT, instance)
+        self.execute_processors(Lifecycle.ON_INIT, instance)
+
+        return instance
 
     # public
 
+    def report(self):
+        builder = StringBuilder()
+
+        builder.append(f"Environment {self.type.__name__}")
+
+        if self.parent is not None:
+            builder.append(f" parent {self.parent.type.__name__}")
+
+        builder.append("\n")
+
+        # post processors
+
+        builder.append("Processors \n")
+        for processor in self.lifecycle_processors:
+            builder.append(f"- {processor.__class__.__name__}\n")
+
+        # providers
+
+        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")
+
+        # instances
+
+        builder.append("Instances \n")
+
+        result = {}
+        for obj in self.instances:
+            cls = type(obj)
+            result[cls] = result.get(cls, 0) + 1
+
+        for cls, count in result.items():
+            builder.append(f"- {cls.__name__}: {count} \n")
+
+        # done
+
+        result = str(builder)
+
+        return result
+
     def destroy(self):
         """
         destroy all managed instances by calling the appropriate lifecycle methods
         """
         for instance in self.instances:
-            self.executeProcessors(Lifecycle.ON_DESTROY, instance)
+            self.execute_processors(Lifecycle.ON_DESTROY, instance)
 
         self.instances.clear() # make the cy happy
 
@@ -881,7 +930,7 @@ class Environment:
         """
         provider = self.providers.get(type, None)
         if provider is None:
-            Environment.logger.error(f"{type} is not supported")
+            Environment.logger.error("%s is not supported", type)
             raise InjectorException(f"{type} is not supported")
 
         return provider.create(self)
@@ -893,112 +942,160 @@ class LifecycleCallable:
         "order"
     ]
 
-    def __init__(self, decorator, processor: CallableProcessor, lifecycle: Lifecycle):
+    def __init__(self, decorator, lifecycle: Lifecycle):
         self.decorator = decorator
         self.lifecycle = lifecycle
         self.order = 0
 
         if TypeDescriptor.for_type(type(self)).has_decorator(order):
-            self.order =  TypeDescriptor.for_type(type(self)).get_decorator(order).args[0]
+            self.order = TypeDescriptor.for_type(type(self)).get_decorator(order).args[0]
 
-        processor.register(self)
+        AbstractCallableProcessor.register(self)
 
     def args(self, decorator: DecoratorDescriptor, method: TypeDescriptor.MethodDescriptor, environment: Environment):
         return []
 
-@injectable()
-@order(1)
-class CallableProcessor(LifecycleProcessor):
+
+class AbstractCallableProcessor(LifecycleProcessor):
     # local classes
 
     class MethodCall:
         __slots__ = [
             "decorator",
             "method",
-            "lifecycleCallable"
+            "lifecycle_callable"
         ]
 
         # constructor
 
-        def __init__(self, method: TypeDescriptor.MethodDescriptor, decorator: DecoratorDescriptor, lifecycleCallable: LifecycleCallable):
+        def __init__(self, method: TypeDescriptor.MethodDescriptor, decorator: DecoratorDescriptor, lifecycle_callable: LifecycleCallable):
             self.decorator = decorator
             self.method = method
-            self.lifecycleCallable = lifecycleCallable
+            self.lifecycle_callable = lifecycle_callable
 
         def execute(self, instance, environment: Environment):
-            self.method.method(instance, *self.lifecycleCallable.args(self.decorator, self.method, environment))
+            self.method.method(instance, *self.lifecycle_callable.args(self.decorator, self.method, environment))
 
         def __str__(self):
             return f"MethodCall({self.method.method.__name__})"
 
-    # constructor
+    # static data
 
-    def __init__(self):
-        super().__init__()
+    callables : Dict[object, LifecycleCallable] = {}
+    cache : Dict[Type, list[list[AbstractCallableProcessor.MethodCall]]] = {}
 
-        self.callables : Dict[object,LifecycleCallable] = dict()
-        self.cache : Dict[Type,list[CallableProcessor.MethodCall]]  = dict()
+    # static methods
+
+    @classmethod
+    def register(cls, callable: LifecycleCallable):
+        AbstractCallableProcessor.callables[callable.decorator] = callable
 
-    def computeCallables(self, type: Type) -> list[CallableProcessor.MethodCall] :
+    @classmethod
+    def compute_callables(cls, type: Type) -> list[list[AbstractCallableProcessor.MethodCall]]:
         descriptor = TypeDescriptor.for_type(type)
 
-        result = []
+        result = [[], [], [], []]  # per lifecycle
 
-        for method in descriptor.methods.values():
+        for method in descriptor.get_methods():
             for decorator in method.decorators:
-                if self.callables.get(decorator.decorator) is not None:
-                    result.append(CallableProcessor.MethodCall(method, decorator, self.callables[decorator.decorator]))
+                callable = AbstractCallableProcessor.callables.get(decorator.decorator)
+                if callable is not None:  # any callable for this decorator?
+                    result[callable.lifecycle.value].append(
+                        AbstractCallableProcessor.MethodCall(method, decorator, callable))
 
         # sort according to order
 
-        result.sort(key=lambda call: call.lifecycleCallable.order)
+        result[0].sort(key=lambda call: call.lifecycle_callable.order)
+        result[1].sort(key=lambda call: call.lifecycle_callable.order)
+        result[2].sort(key=lambda call: call.lifecycle_callable.order)
+        result[3].sort(key=lambda call: call.lifecycle_callable.order)
 
         # done
 
         return result
 
-    def callablesFor(self, type: Type)-> list[CallableProcessor.MethodCall]:
-        callables = self.cache.get(type, None)
+    @classmethod
+    def callables_for(cls, type: Type) -> list[list[AbstractCallableProcessor.MethodCall]]:
+        callables = AbstractCallableProcessor.cache.get(type, None)
         if callables is None:
-            callables = self.computeCallables(type)
-            self.cache[type] = callables
+            callables = AbstractCallableProcessor.compute_callables(type)
+            AbstractCallableProcessor.cache[type] = callables
 
         return callables
 
-    def register(self, callable: LifecycleCallable):
-        self.callables[callable.decorator] = callable
+    # constructor
+
+    def __init__(self, lifecycle: Lifecycle):
+        super().__init__()
+
+        self.lifecycle = lifecycle
 
     # implement
 
-    def processLifecycle(self, lifecycle: Lifecycle, instance: object, environment: Environment) -> object:
-        callables = self.callablesFor(type(instance))
-        for callable in callables:
-            if callable.lifecycleCallable.lifecycle is lifecycle:
+    def process_lifecycle(self, lifecycle: Lifecycle, instance: object, environment: Environment) -> object:
+        if lifecycle is self.lifecycle:
+            callables = self.callables_for(type(instance))
+
+            for callable in callables[lifecycle.value]:
                 callable.execute(instance, environment)
 
+@injectable()
+@order(1)
+class OnInjectCallableProcessor(AbstractCallableProcessor):
+    def __init__(self):
+        super().__init__(Lifecycle.ON_INJECT)
+
+@injectable()
+@order(2)
+class OnInitCallableProcessor(AbstractCallableProcessor):
+    def __init__(self):
+        super().__init__(Lifecycle.ON_INIT)
+
+@injectable()
+@order(3)
+class OnRunningCallableProcessor(AbstractCallableProcessor):
+    def __init__(self):
+        super().__init__(Lifecycle.ON_RUNNING)
+
+@injectable()
+@order(4)
+class OnDestroyCallableProcessor(AbstractCallableProcessor):
+    def __init__(self):
+        super().__init__(Lifecycle.ON_DESTROY)
+
+# the callables
+
 @injectable()
 @order(1000)
 class OnInitLifecycleCallable(LifecycleCallable):
     __slots__ = []
 
-    def __init__(self, processor: CallableProcessor):
-        super().__init__(on_init, processor, Lifecycle.ON_INIT)
+    def __init__(self):
+        super().__init__(on_init, Lifecycle.ON_INIT)
 
 @injectable()
 @order(1001)
 class OnDestroyLifecycleCallable(LifecycleCallable):
     __slots__ = []
 
-    def __init__(self, processor: CallableProcessor):
-        super().__init__(on_destroy, processor, Lifecycle.ON_DESTROY)
+    def __init__(self):
+        super().__init__(on_destroy, Lifecycle.ON_DESTROY)
+
+@injectable()
+@order(1002)
+class OnRunningLifecycleCallable(LifecycleCallable):
+    __slots__ = []
+
+    def __init__(self):
+        super().__init__(on_running, Lifecycle.ON_RUNNING)
 
 @injectable()
 @order(9)
 class EnvironmentAwareLifecycleCallable(LifecycleCallable):
     __slots__ = []
 
-    def __init__(self, processor: CallableProcessor):
-        super().__init__(inject_environment, processor, Lifecycle.ON_INIT)
+    def __init__(self):
+        super().__init__(inject_environment, Lifecycle.ON_INJECT)
 
     def args(self, decorator: DecoratorDescriptor, method: TypeDescriptor.MethodDescriptor, environment: Environment):
         return [environment]
@@ -1008,13 +1105,13 @@ class EnvironmentAwareLifecycleCallable(LifecycleCallable):
 class InjectLifecycleCallable(LifecycleCallable):
     __slots__ = []
 
-    def __init__(self, processor: CallableProcessor):
-        super().__init__(inject, processor, Lifecycle.ON_INIT)
+    def __init__(self):
+        super().__init__(inject, Lifecycle.ON_INJECT)
 
     # override
 
     def args(self, decorator: DecoratorDescriptor,  method: TypeDescriptor.MethodDescriptor, environment: Environment):
-        return [environment.get(type) for type in method.paramTypes]
+        return [environment.get(type) for type in method.param_types]
 
 def scope(name: str):
     def decorator(cls):
@@ -1036,15 +1133,10 @@ class RequestScope(Scope):
     __slots__ = [
     ]
 
-    # constructor
-
-    def __init__(self):
-        super().__init__()
-
     # public
 
-    def get(self, provider: AbstractInstanceProvider, environment: Environment, argProvider: Callable[[],list]):
-        return provider.create(environment, *argProvider())
+    def get(self, provider: AbstractInstanceProvider, environment: Environment, arg_provider: Callable[[],list]):
+        return provider.create(environment, *arg_provider())
 
 @scope("singleton")
 class SingletonScope(Scope):
@@ -1061,17 +1153,34 @@ class SingletonScope(Scope):
         super().__init__()
 
         self.value = None
-        self.lock = threading.Lock()
+        self.lock = threading.RLock()
 
     # override
 
-    def get(self, provider: AbstractInstanceProvider, environment: Environment, argProvider: Callable[[],list]):
+    def get(self, provider: AbstractInstanceProvider, environment: Environment, arg_provider: Callable[[],list]):
         if self.value is None:
             with self.lock:
-                if self.value is None: 
-                    self.value = provider.create(environment, *argProvider())
+                if self.value is None:
+                    self.value = provider.create(environment, *arg_provider())
 
         return self.value
+    
+@scope("thread")
+class ThreadScope(Scope):
+    __slots__ = [
+        "_local"
+    ]
+
+    # constructor
+
+    def __init__(self):
+        super().__init__()
+        self._local = threading.local()
+
+    def get(self, provider: AbstractInstanceProvider, environment: Environment, arg_provider: Callable[[], list]):
+        if not hasattr(self._local, "value"):
+            self._local.value = provider.create(environment, *arg_provider())
+        return self._local.value
 
 # internal class that is required to import technical instance providers
 
@@ -1095,4 +1204,4 @@ class BootEnvironment:
     # constructor
 
     def __init__(self):
-        pass
+        pass