aspyx 0.1.0__py3-none-any.whl → 1.0.1__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
@@ -5,6 +8,7 @@ import logging
 
 from abc import abstractmethod, ABC
 from enum import Enum, auto
+import threading
 from typing import Type, Dict, TypeVar, Generic, Optional, cast, Callable
 
 from aspyx.reflection import Decorators, TypeDescriptor, DecoratorDescriptor
@@ -24,8 +28,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]):
     """
@@ -52,7 +56,7 @@ class AbstractInstanceProvider(ABC, Generic[T]):
         pass
 
     @abstractmethod
-    def create(self, env: Environment, *args):
+    def create(self, environment: Environment, *args):
         pass
 
     @abstractmethod
@@ -192,15 +196,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
@@ -215,15 +219,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",
     ]
@@ -237,8 +241,7 @@ 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
 
@@ -259,21 +262,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})"
@@ -308,18 +309,18 @@ 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):
                     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)
@@ -329,7 +330,7 @@ class ClassInstanceProvider(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(self.type(*args[:self.params]))
 
@@ -362,7 +363,7 @@ class FunctionInstanceProvider(InstanceProvider):
 
             context.add(self)
 
-            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
@@ -371,7 +372,7 @@ class FunctionInstanceProvider(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__)
 
         instance = self.method(*args)
 
@@ -390,13 +391,13 @@ 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
 
@@ -406,7 +407,7 @@ class FactoryInstanceProvider(InstanceProvider):
 
             context.add(self)
 
-            provider = Providers.getProvider(self.host)
+            provider = Providers.get_provider(self.host)
             if self.add_dependency(provider):
                 provider.resolve(context)
 
@@ -416,7 +417,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())
 
@@ -438,17 +439,21 @@ class LifecycleProcessor(ABC):
     """
     A LifecycleProcessor is used to perform any side effects on managed objects during their lifecycle.
     """
-    __slots__ = []
+    __slots__ = [
+        "order"
+    ]
 
     # constructor
 
     def __init__(self):
-        pass
+        self.order = 0
+        if TypeDescriptor.for_type(type(self)).has_decorator(order):
+            self.order =  TypeDescriptor.for_type(type(self)).get_decorator(order).args[0]
 
     # 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):
@@ -457,15 +462,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)
 
@@ -485,11 +486,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
@@ -508,16 +509,16 @@ class Providers:
 
     # 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
 
@@ -536,7 +537,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
@@ -552,9 +553,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
 
@@ -564,7 +565,7 @@ class Providers:
 
         # cache providers
 
-        cacheProviderForType(provider, provider.get_type())
+        cache_provider_for_type(provider, provider.get_type())
 
     @classmethod
     def resolve(cls):
@@ -581,21 +582,28 @@ class Providers:
             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):
+        Decorators.add(cls, order, prio)
+
+        return cls
+
+    return decorator
 
 def injectable(eager=True, scope="singleton"):
     """
@@ -669,7 +677,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
 
@@ -709,12 +717,13 @@ class Environment:
     __slots__ = [
         "type",
         "providers",
-        "lifecycleProcessors",
+        "lifecycle_processors",
         "parent",
         "instances"
     ]
 
     # constructor
+
     def __init__(self, env: Type, parent : Optional[Environment] = None):
         """
         Creates a new Environment instance.
@@ -730,12 +739,12 @@ 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 = []
 
@@ -748,7 +757,7 @@ class Environment:
         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
 
@@ -760,7 +769,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)
 
@@ -781,31 +790,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!
                 # 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 []
 
@@ -816,9 +825,9 @@ class Environment:
                 provider.create(self)
     # 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
 
@@ -826,7 +835,11 @@ class Environment:
         # remember lifecycle processors
 
         if isinstance(instance, LifecycleProcessor):
-            self.lifecycleProcessors.append(instance)
+            self.lifecycle_processors.append(instance)
+
+            # sort immediately
+
+            self.lifecycle_processors.sort(key=lambda processor: processor.order)
 
         # remember instance
 
@@ -834,7 +847,7 @@ class Environment:
 
         # execute processors
 
-        return self.executeProcessors(Lifecycle.ON_INIT, instance)
+        return self.execute_processors(Lifecycle.ON_INIT, instance)
 
     # public
 
@@ -843,7 +856,7 @@ class Environment:
         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
 
@@ -858,7 +871,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)
@@ -866,12 +879,17 @@ class Environment:
 class LifecycleCallable:
     __slots__ = [
         "decorator",
-        "lifecycle"
+        "lifecycle",
+        "order"
     ]
 
     def __init__(self, decorator, processor: CallableProcessor, 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]
 
         processor.register(self)
 
@@ -879,6 +897,7 @@ class LifecycleCallable:
         return []
 
 @injectable()
+@order(1)
 class CallableProcessor(LifecycleProcessor):
     # local classes
 
@@ -886,18 +905,18 @@ class CallableProcessor(LifecycleProcessor):
         __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__})"
@@ -907,25 +926,31 @@ class CallableProcessor(LifecycleProcessor):
     def __init__(self):
         super().__init__()
 
-        self.callables : Dict[object,LifecycleCallable] = dict()
-        self.cache : Dict[Type,list[CallableProcessor.MethodCall]]  = dict()
+        self.callables : Dict[object,LifecycleCallable] = {}
+        self.cache : Dict[Type,list[CallableProcessor.MethodCall]]  = {}
 
-    def computeCallables(self, type: Type) -> list[CallableProcessor.MethodCall] :
+    def compute_callables(self, type: Type) -> list[CallableProcessor.MethodCall] :
         descriptor = TypeDescriptor.for_type(type)
 
         result = []
 
-        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]))
 
+        # sort according to order
+
+        result.sort(key=lambda call: call.lifecycle_callable.order)
+
+        # done
+
         return result
 
-    def callablesFor(self, type: Type)-> list[CallableProcessor.MethodCall]:
+    def callables_for(self, type: Type)-> list[CallableProcessor.MethodCall]:
         callables = self.cache.get(type, None)
         if callables is None:
-            callables = self.computeCallables(type)
+            callables = self.compute_callables(type)
             self.cache[type] = callables
 
         return callables
@@ -935,13 +960,14 @@ class CallableProcessor(LifecycleProcessor):
 
     # implement
 
-    def processLifecycle(self, lifecycle: Lifecycle, instance: object, environment: Environment) -> object:
-        callables = self.callablesFor(type(instance))
+    def process_lifecycle(self, lifecycle: Lifecycle, instance: object, environment: Environment) -> object:
+        callables = self.callables_for(type(instance))
         for callable in callables:
-            if callable.lifecycleCallable.lifecycle is lifecycle:
+            if callable.lifecycle_callable.lifecycle is lifecycle:
                 callable.execute(instance, environment)
 
 @injectable()
+@order(1000)
 class OnInitLifecycleCallable(LifecycleCallable):
     __slots__ = []
 
@@ -949,6 +975,7 @@ class OnInitLifecycleCallable(LifecycleCallable):
         super().__init__(on_init, processor, Lifecycle.ON_INIT)
 
 @injectable()
+@order(1001)
 class OnDestroyLifecycleCallable(LifecycleCallable):
     __slots__ = []
 
@@ -956,6 +983,7 @@ class OnDestroyLifecycleCallable(LifecycleCallable):
         super().__init__(on_destroy, processor, Lifecycle.ON_DESTROY)
 
 @injectable()
+@order(9)
 class EnvironmentAwareLifecycleCallable(LifecycleCallable):
     __slots__ = []
 
@@ -966,6 +994,7 @@ class EnvironmentAwareLifecycleCallable(LifecycleCallable):
         return [environment]
 
 @injectable()
+@order(10)
 class InjectLifecycleCallable(LifecycleCallable):
     __slots__ = []
 
@@ -975,7 +1004,7 @@ class InjectLifecycleCallable(LifecycleCallable):
     # 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):
@@ -997,22 +1026,18 @@ 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):
     # properties
 
     __slots__ = [
-        "value"
+        "value",
+        "lock"
     ]
 
     # constructor
@@ -1021,12 +1046,15 @@ class SingletonScope(Scope):
         super().__init__()
 
         self.value = None
+        self.lock = threading.Lock()
 
     # override
 
-    def get(self, provider: AbstractInstanceProvider, environment: Environment, argProvider: Callable[[],list]):
-        if self.value is None: # TODO thread-safe
-            self.value = provider.create(environment, *argProvider())
+    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, *arg_provider())
 
         return self.value
 
@@ -1052,4 +1080,4 @@ class BootEnvironment:
     # constructor
 
     def __init__(self):
-        pass
+        pass

aspyx/reflection/__init__.py

@@ -1,3 +1,6 @@
+"""
+This module provides tools for dynamic proxy creation and reflection
+"""
 from .proxy import DynamicProxy
 from .reflection import Decorators, TypeDescriptor, DecoratorDescriptor
 
@@ -6,4 +9,4 @@ __all__ = [
     "Decorators",
     "DecoratorDescriptor",
     "TypeDescriptor"
-]
+]