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

aspyx/di/__init__.py

@@ -1,12 +1,12 @@
 """
 This module provides dependency injection and aop capabilities for Python applications.
 """
-from .di import InjectorException, CallableProcessor, LifecycleCallable, Lifecycle, Providers, Environment, ClassInstanceProvider, injectable, factory, environment, inject, create, on_init, on_destroy, inject_environment, Factory, PostProcessor
+from .di import InjectorException, AbstractCallableProcessor, LifecycleCallable, Lifecycle, Providers, Environment, ClassInstanceProvider, injectable, factory, environment, inject, create, on_init, on_running, on_destroy, inject_environment, Factory, PostProcessor
 
 # import something from the subpackages, so that teh decorators are executed
 
-from aspyx.di.configuration import ConfigurationManager
-from aspyx.di.aop import before
+from .configuration import ConfigurationManager
+from .aop import before
 
 imports = [ConfigurationManager, before]
 
@@ -21,11 +21,12 @@ __all__ = [
     "create",
 
     "on_init",
+    "on_running",
     "on_destroy",
     "inject_environment",
     "Factory",
     "PostProcessor",
-    "CallableProcessor",
+    "AbstractCallableProcessor",
     "LifecycleCallable",
     "InjectorException",
     "Lifecycle"

aspyx/di/configuration/configuration.py

@@ -8,7 +8,7 @@ import os
 from typing import Optional, Type, TypeVar
 from dotenv import load_dotenv
 
-from aspyx.di import injectable, Environment, CallableProcessor, LifecycleCallable, Lifecycle
+from aspyx.di import injectable, Environment, LifecycleCallable, Lifecycle
 from aspyx.di.di import order, inject
 from aspyx.reflection import Decorators, DecoratorDescriptor, TypeDescriptor
 
@@ -188,8 +188,8 @@ def value(key: str, default=None):
 @injectable()
 @order(9)
 class ConfigurationLifecycleCallable(LifecycleCallable):
-    def __init__(self, processor: CallableProcessor,  manager: ConfigurationManager):
-        super().__init__(value, processor, Lifecycle.ON_INIT)
+    def __init__(self,  manager: ConfigurationManager):
+        super().__init__(value, Lifecycle.ON_INJECT)
 
         self.manager = manager
 

aspyx/di/di.py

@@ -11,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")
@@ -60,7 +61,7 @@ class AbstractInstanceProvider(ABC, Generic[T]):
         pass
 
     @abstractmethod
-    def resolve(self, context: Providers.Context) -> AbstractInstanceProvider:
+    def resolve(self, context: Providers.Context):
         pass
 
 
@@ -85,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__
@@ -178,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}")
@@ -245,7 +251,7 @@ class EnvironmentInstanceProvider(AbstractInstanceProvider):
 
     # implement
 
-    def resolve(self, context: Providers.Context) -> AbstractInstanceProvider:
+    def resolve(self, context: Providers.Context):
         pass # noop
 
     def get_module(self) -> str:
@@ -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
 
@@ -312,7 +318,7 @@ class ClassInstanceProvider(InstanceProvider):
             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
@@ -327,8 +333,6 @@ class ClassInstanceProvider(InstanceProvider):
         else: # check if the dependencies create a cycle
             context.add(*self.dependencies)
 
-        return self
-
     def create(self, environment: Environment, *args):
         Environment.logger.debug("%s create class %s", self, self.type.__qualname__)
 
@@ -357,11 +361,11 @@ 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.get_provider(self.host)
             if self.add_dependency(provider):
@@ -369,8 +373,6 @@ class FunctionInstanceProvider(InstanceProvider):
         else: # check if the dependencies crate a cycle
             context.add(*self.dependencies)
 
-        return self
-
     def create(self, environment: Environment, *args):
         Environment.logger.debug("%s create class %s", self, self.type.__qualname__)
 
@@ -401,11 +403,11 @@ class FactoryInstanceProvider(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.get_provider(self.host)
             if self.add_dependency(provider):
@@ -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):
     """
@@ -502,7 +506,7 @@ class Providers:
 
                 cycle += f"{p.get_type().__name__}"
 
-            cycle += f" -> {provider.get_type().__name__}"
+            cycle += f" <> {provider.get_type().__name__}"
 
             return cycle
 
@@ -574,8 +578,6 @@ class Providers:
 
         Providers.check.clear()
 
-        #Providers.report()
-
     @classmethod
     def report(cls):
         for provider in Providers.cache.values():
@@ -614,8 +616,6 @@ def injectable(eager=True, scope="singleton"):
 
         Providers.register(ClassInstanceProvider(cls, eager, scope))
 
-        #TODO registerFactories(cls)
-
         return cls
 
     return decorator
@@ -653,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.
@@ -750,7 +759,7 @@ class Environment:
 
         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()
 
@@ -794,7 +803,7 @@ class Environment:
 
                 # 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
 
                 environment_providers : dict[AbstractInstanceProvider, EnvironmentInstanceProvider] = {}
@@ -823,6 +832,12 @@ 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 execute_processors(self, lifecycle: Lifecycle, instance: T) -> T:
@@ -847,10 +862,54 @@ class Environment:
 
         # execute processors
 
-        return self.execute_processors(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
@@ -883,22 +942,21 @@ 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:
@@ -921,74 +979,123 @@ class CallableProcessor(LifecycleProcessor):
         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]]] = {}
+
+    # static methods
 
-        self.callables : Dict[object,LifecycleCallable] = {}
-        self.cache : Dict[Type,list[CallableProcessor.MethodCall]]  = {}
+    @classmethod
+    def register(cls, callable: LifecycleCallable):
+        AbstractCallableProcessor.callables[callable.decorator] = callable
 
-    def compute_callables(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.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.lifecycle_callable.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 callables_for(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.compute_callables(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 process_lifecycle(self, lifecycle: Lifecycle, instance: object, environment: Environment) -> object:
-        callables = self.callables_for(type(instance))
-        for callable in callables:
-            if callable.lifecycle_callable.lifecycle is lifecycle:
+        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]
@@ -998,8 +1105,8 @@ 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
 
@@ -1046,7 +1153,7 @@ class SingletonScope(Scope):
         super().__init__()
 
         self.value = None
-        self.lock = threading.Lock()
+        self.lock = threading.RLock()
 
     # override
 
@@ -1057,6 +1164,23 @@ class SingletonScope(Scope):
                     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
 

aspyx/di/util/__init__.py

@@ -0,0 +1,8 @@
+"""
+This module provides utility functions.
+"""
+from .stringbuilder import StringBuilder
+
+__all__ = [
+    "StringBuilder",
+]

aspyx/di/util/stringbuilder.py

@@ -0,0 +1,31 @@
+"""
+Utility class for Java lovers
+"""
+class StringBuilder:
+    ___slots__ = ("_parts",)
+
+    # constructor
+
+    def __init__(self):
+        self._parts = []
+
+    # public
+
+    def append(self, s: str) -> "StringBuilder":
+        self._parts.append(str(s))
+
+        return self
+
+    def extend(self, iterable) -> "StringBuilder":
+        for s in iterable:
+            self._parts.append(str(s))
+
+        return self
+
+    def clear(self):
+        self._parts.clear()
+
+    # object
+
+    def __str__(self):
+        return ''.join(self._parts)

aspyx/reflection/reflection.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 
 import inspect
 from inspect import signature, getmembers
+import threading
 from typing import Callable, get_type_hints, Type, Dict, Optional
 from weakref import WeakKeyDictionary
 
@@ -55,14 +56,14 @@ class TypeDescriptor:
 
             self.return_type = type_hints.get('return', None)
 
-        def get_decorator(self, decorator) -> Optional[DecoratorDescriptor]:
+        def get_decorator(self, decorator: Callable) -> Optional[DecoratorDescriptor]:
             for dec in self.decorators:
                 if dec.decorator is decorator:
                     return dec
 
             return None
 
-        def has_decorator(self, decorator) -> bool:
+        def has_decorator(self, decorator: Callable) -> bool:
             for dec in self.decorators:
                 if dec.decorator is decorator:
                     return True
@@ -75,6 +76,7 @@ class TypeDescriptor:
     # class properties
 
     _cache = WeakKeyDictionary()
+    _lock = threading.RLock()
 
     # class methods
 
@@ -82,8 +84,11 @@ class TypeDescriptor:
     def for_type(cls, clazz: Type) -> TypeDescriptor:
         descriptor = cls._cache.get(clazz)
         if descriptor is None:
-            descriptor = TypeDescriptor(clazz)
-            cls._cache[clazz] = descriptor
+            with cls._lock:
+                descriptor = cls._cache.get(clazz)
+                if descriptor is None:
+                    descriptor = TypeDescriptor(clazz)
+                    cls._cache[clazz] = descriptor
 
         return descriptor
 
@@ -120,14 +125,14 @@ class TypeDescriptor:
 
     # public
 
-    def get_decorator(self, decorator) -> Optional[DecoratorDescriptor]:
+    def get_decorator(self, decorator: Callable) -> Optional[DecoratorDescriptor]:
         for dec in self.decorators:
             if dec.decorator is decorator:
                 return dec
 
         return None
 
-    def has_decorator(self, decorator) -> bool:
+    def has_decorator(self, decorator: Callable) -> bool:
         for dec in self.decorators:
             if dec.decorator is decorator:
                 return True

{aspyx-1.0.1.dist-info → aspyx-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aspyx
-Version: 1.0.1
+Version: 1.1.0
 Summary: A DI and AOP library for Python
 Author-email: Andreas Ernst <andreas.ernst7@gmail.com>
 License: MIT License
@@ -34,8 +34,9 @@ Dynamic: license-file
 
 ![Pylint](https://github.com/coolsamson7/aspyx/actions/workflows/pylint.yml/badge.svg)
 ![Build Status](https://github.com/coolsamson7/aspyx/actions/workflows/ci.yml/badge.svg)
-![PyPI - Python Version](https://img.shields.io/pypi/pyversions/aspyx)
+![Python Versions](https://img.shields.io/badge/python-3.9%20|%203.10%20|%203.11%20|%203.12-blue)
 ![License](https://img.shields.io/github/license/coolsamson7/aspyx)
+![coverage](https://img.shields.io/badge/coverage-94%25-brightgreen)
 
 ## Table of Contents
 
@@ -56,18 +57,18 @@ Dynamic: license-file
 - [AOP](#aop)
 - [Configuration](#configuration)
 - [Reflection](#reflection)
+- [Version History](#version-history)
 
 # Introduction
 
 Aspyx is a small python libary, that adds support for both dependency injection and aop.
 
 The following features are supported 
-- constructor injection
-- method injection
+- constructor and setter injection
 - post processors
 - factory classes and methods
 - support for eager construction
-- support for singleton and reuqest scopes
+- support for singleton and request scopes
 - possibilty to add custom scopes
 - lifecycle events methods
 - bundling of injectable object sets by environment classes including recursive imports and inheritance
@@ -156,7 +157,7 @@ Let's look at the details
 
 `pip install aspyx`
 
-The library is tested with Python version > 3.8
+The library is tested with all Python version > 3.9
 
 Ready to go...
 
@@ -185,8 +186,15 @@ The decorator accepts the keyword arguments
 - `eager : boolean`  
   if `True`, the container will create the instances automatically while booting the environment. This is the default.
 - `scope: str`  
-  the name of a scope which will determine how often instances will be created.
- `singleton` will create it only once - per environment -, while `request` will recreate it on every injection request. The default is `singleton`
+  the name of a - registered - scope which will determine how often instances will be created.
+
+ The following scopes are implemented out of the box:
+ - `singleton`  
+   objects are created once inside an environment and cached. This is the default.
+ - `request`  
+   obejcts are created on every injection request
+ - `thread`  
+   objects are cerated and cached with respect to the current thread.
 
  Other scopes - e.g. session related scopes - can be defined dynamically. Please check the corresponding chapter.
 
@@ -304,7 +312,7 @@ Different decorators are implemented, that call methods with computed values
    the method is called with all resolved parameter types ( same as the constructor call)
 - `@inject_environment`  
    the method is called with the creating environment as a single parameter
-- `@value()`  
+- `@inject_value()`  
    the method is called with a resolved configuration value. Check the corresponding chapter
 
 **Example**:
@@ -325,9 +333,11 @@ class Foo:
 
 ## Lifecycle methods
 
-It is possible to mark specific lifecle methods. 
+It is possible to mark specific lifecyle methods. 
 - `@on_init()` 
    called after the constructor and all other injections.
+- `@on_running()` 
+   called an environment has initialized all eager objects.
 - `@on_destroy()` 
    called during shutdown of the environment
 
@@ -460,7 +470,7 @@ class TransactionAdvice:
 
 # Configuration 
 
-It is possible to inject configuration values, by decorating methods with `@value(<name>)` given a configuration key.
+It is possible to inject configuration values, by decorating methods with `@inject-value(<name>)` given a configuration key.
 
 ```python
 @injectable()
@@ -522,16 +532,24 @@ TypeDescriptor.for_type(<type>)
 ```
 
 it offers the methods
-- `get_methods(local=False)`
-- `get_method(name: str, local=False)`
-- `has_decorator(decorator) -> bool`
-- `get_decorator(decorator)`
+- `get_methods(local=False)`  
+   return a list of either local or overall methods
+- `get_method(name: str, local=False)`  
+   return a single either local or overall method
+- `has_decorator(decorator: Callable) -> bool`  
+   return `True`, if the class is decorated with the specified decrator
+- `get_decorator(decorator) -> Optional[DecoratorDescriptor]`  
+   return a descriptor covering the decorator. In addition to the callable, it also stores the supplied args in the `args` property
 
 The returned method descriptors offer:
-- `param_types`
-- `return_type`
-- `has_decorator(decorator)`
-- `get_decorator(decorator)`
+- `param_types`  
+   list of arg types
+- `return_type`  
+   the retur type
+- `has_decorator(decorator: Callable) -> bool` 
+   return `True`, if the method is decorated with the specified decrator
+- `get_decorator(decorator: Callable) -> Optional[DecoratorDescriptor]`  
+   return a descriptor covering the decorator. In addition to the callable, it also stores the supplied args in the `args` property
 
 The management of decorators in turn relies on another utility class `Decorators` that caches decorators.
 
@@ -548,7 +566,16 @@ def transactional():
 ```
 
 
+# Version History
+
+**1.0.1**
+
+- some internal refactorings
+
+**1.1.0**
 
+- added `@on_running()` callback
+- added `thread` scope
 
 
       

aspyx-1.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+aspyx/di/__init__.py,sha256=U2-4JnCmSO_IXCnN1jeig9nuWfJN__z9yRzl1WexQJk,927
+aspyx/di/di.py,sha256=VVLOXhTKJer2cV0rNEOqMLyMigsNMEQ7xoc-6M7a8wU,34296
+aspyx/di/aop/__init__.py,sha256=nOABex49zSyMZ2w1ezwX3Q3yrOcQRSDjDtSj0DwKVbQ,233
+aspyx/di/aop/aop.py,sha256=1RUgijk8RsiXWTizfNQX1IfHF7b96kCPdUgahX_J4Io,14457
+aspyx/di/configuration/__init__.py,sha256=Zw7h-OlbJD7LyJvzkgyF0EmVqra6oN_Pt0HuUdjTPTA,249
+aspyx/di/configuration/configuration.py,sha256=jJJSHRG2wOIvle23Xc8CQ4WM7lp_xCL8-ENVZO603uQ,5682
+aspyx/di/util/__init__.py,sha256=8H2yKkXu3nkRGeTerb8ialzKGfvzUx44XUWFUYcYuQM,125
+aspyx/di/util/stringbuilder.py,sha256=JywkLxZfaQUUWjSB5wvqA6a6Cfs3sW1jbaZ1z4U0-CQ,540
+aspyx/reflection/__init__.py,sha256=r2sNJrfHDpuqaIYu4fTYsoo046gpgn4VTd7bsS3mQJY,282
+aspyx/reflection/proxy.py,sha256=zJ6Psd6zWfFABdrKOf4cULt3gibyqCRdcR6z8WKIkzE,1982
+aspyx/reflection/reflection.py,sha256=HfPFd_FehTGmgF6NA-IJ_aHePE6GXM1ag7K3h8YIXjI,4600
+aspyx-1.1.0.dist-info/licenses/LICENSE,sha256=n4jfx_MNj7cBtPhhI7MCoB_K35cj1icP9yJ4Rh4vlvY,1070
+aspyx-1.1.0.dist-info/METADATA,sha256=rdeICMYyQSJmSZDJZrsdw6l5ZVrQrxvAPS_z47ObM-Y,17989
+aspyx-1.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aspyx-1.1.0.dist-info/top_level.txt,sha256=A_ZwhBY_ybIgjZlztd44eaOrWqkJAndiqjGlbJ3tR_I,6
+aspyx-1.1.0.dist-info/RECORD,,

aspyx-1.0.1.dist-info/RECORD

@@ -1,14 +0,0 @@
-aspyx/di/__init__.py,sha256=G13Cz1MMElBKNWsrhgTEIvhmIKj5MX4uqK_Apke4w8I,897
-aspyx/di/di.py,sha256=elT3XJokxYxPJ9mx528MAU-pmm9lIZF8_AXKGkjyhBo,31014
-aspyx/di/aop/__init__.py,sha256=nOABex49zSyMZ2w1ezwX3Q3yrOcQRSDjDtSj0DwKVbQ,233
-aspyx/di/aop/aop.py,sha256=1RUgijk8RsiXWTizfNQX1IfHF7b96kCPdUgahX_J4Io,14457
-aspyx/di/configuration/__init__.py,sha256=Zw7h-OlbJD7LyJvzkgyF0EmVqra6oN_Pt0HuUdjTPTA,249
-aspyx/di/configuration/configuration.py,sha256=dHYoM3jC43QeDVlT6-mGDj05Sz6-Nm91LNE2TfQT1UU,5740
-aspyx/reflection/__init__.py,sha256=r2sNJrfHDpuqaIYu4fTYsoo046gpgn4VTd7bsS3mQJY,282
-aspyx/reflection/proxy.py,sha256=zJ6Psd6zWfFABdrKOf4cULt3gibyqCRdcR6z8WKIkzE,1982
-aspyx/reflection/reflection.py,sha256=NkBK94kjJ7rQpPsK4mzHzX5TLSlWRM3mbNVzkwOZo4o,4379
-aspyx-1.0.1.dist-info/licenses/LICENSE,sha256=n4jfx_MNj7cBtPhhI7MCoB_K35cj1icP9yJ4Rh4vlvY,1070
-aspyx-1.0.1.dist-info/METADATA,sha256=69OakKuzM1UK0YTgH-y6-473YWhylxQvt8v993WsqiU,16798
-aspyx-1.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aspyx-1.0.1.dist-info/top_level.txt,sha256=A_ZwhBY_ybIgjZlztd44eaOrWqkJAndiqjGlbJ3tR_I,6
-aspyx-1.0.1.dist-info/RECORD,,