aspyx 0.1.0__tar.gz → 1.0.0__tar.gz

{aspyx-0.1.0/src/aspyx.egg-info → aspyx-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aspyx
-Version: 0.1.0
+Version: 1.0.0
 Summary: A DI and AOP library for Python
 Author-email: Andreas Ernst <andreas.ernst7@gmail.com>
 License: MIT License
@@ -32,8 +32,8 @@ Dynamic: license-file
 
 # aspyx
 
-![Pylint](https://github.com/andreasernst/aspyx/actions/workflows/pylint.yml/badge.svg)
-![Build Status](https://github.com/andreasernst/aspyx/actions/workflows/ci.yml/badge.svg)
+![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)
 
 
 ## Table of Contents
@@ -46,8 +46,10 @@ Dynamic: license-file
 - [Environment](#environment)
   - [Definition](#definition)
   - [Retrieval](#retrieval)
-- [Lifecycle methods](#lifecycle-methods)
-- [Post Processors](#post-processors)
+- [Instantiation logic](#instantiation-logic)
+  - [Injection Methods](#injection-methods)
+  - [Lifecycle Methods](#lifecycle-methods)
+  - [Post Processors](#post-processors)
 - [Custom scopes](#custom-scopes)
 - [AOP](#aop)
 - [Configuration](#configuration)
@@ -164,9 +166,10 @@ class Foo:
     def __init__(self):
         pass
 ```
- Please make sure, that the class defines a constructor, as this is required to determine injected instances. 
+Please make sure, that the class defines a local constructor, as this is required to determine injected instances. 
+All referenced types will be injected by the environemnt. 
 
- The constructor can only define parameter types that are known as well to the container! 
+Only eligible types are allowed, of course!
 
 
  The decorator accepts the keyword arguments
@@ -268,15 +271,55 @@ In case of ambiguities, it will throw an exception.
 
 Please be aware, that a base class are not _required_ to be annotated with `@injectable`, as this would mean, that it could be created on its own as well. ( Which is possible as well, btw. ) 
 
-# Lifecycle methods
+# Instantiation logic
 
-It is possible to declare methods that will be called from the container
+Constructing a new instance involves a number of steps executed in this order
+- Constructor call  
+  the constructor is called with the resolved parameters
+- Advice injection  
+  All methods involving aspects are updated
+- Lifecycle methods   
+  different decorators can mark methods that should be called during the lifecycle ( here the construction ) of an instance.
+  These are various injection possibilities as well as an optional final `on_init` call
+- PostProcessors  
+  Any custom post processors, that can add isde effects or modify the instances
+
+## Injection methods
+
+Different decorators are implemented, that call methods with computed values
+
+- `@inject`  
+   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()`  
+   the method is called with a resolved configuration value. Check the corresponding chapter
+
+**Example**:
+```python
+@injectable()
+class Foo:
+    def __init__(self):
+        pass
+
+    @inject_environment()
+    def initEnvironment(self, env: Environment):
+        ...
+
+    @inject()
+    def set(self, baz: Baz) -> None:
+        ...
+```
+
+## Lifecycle methods
+
+It is possible to mark specific lifecle methods. 
 - `@on_init()` 
    called after the constructor and all other injections.
 - `@on_destroy()` 
-   called after the container has been shut down
+   called during shutdown of the environment
 
-# Post Processors
+## Post Processors
 
 As part of the instantiation logic it is possible to define post processors that execute any side effect on newly created instances.
 

{aspyx-0.1.0 → aspyx-1.0.0}/README.md

@@ -1,7 +1,7 @@
 # aspyx
 
-![Pylint](https://github.com/andreasernst/aspyx/actions/workflows/pylint.yml/badge.svg)
-![Build Status](https://github.com/andreasernst/aspyx/actions/workflows/ci.yml/badge.svg)
+![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)
 
 
 ## Table of Contents
@@ -14,8 +14,10 @@
 - [Environment](#environment)
   - [Definition](#definition)
   - [Retrieval](#retrieval)
-- [Lifecycle methods](#lifecycle-methods)
-- [Post Processors](#post-processors)
+- [Instantiation logic](#instantiation-logic)
+  - [Injection Methods](#injection-methods)
+  - [Lifecycle Methods](#lifecycle-methods)
+  - [Post Processors](#post-processors)
 - [Custom scopes](#custom-scopes)
 - [AOP](#aop)
 - [Configuration](#configuration)
@@ -132,9 +134,10 @@ class Foo:
     def __init__(self):
         pass
 ```
- Please make sure, that the class defines a constructor, as this is required to determine injected instances. 
+Please make sure, that the class defines a local constructor, as this is required to determine injected instances. 
+All referenced types will be injected by the environemnt. 
 
- The constructor can only define parameter types that are known as well to the container! 
+Only eligible types are allowed, of course!
 
 
  The decorator accepts the keyword arguments
@@ -236,15 +239,55 @@ In case of ambiguities, it will throw an exception.
 
 Please be aware, that a base class are not _required_ to be annotated with `@injectable`, as this would mean, that it could be created on its own as well. ( Which is possible as well, btw. ) 
 
-# Lifecycle methods
+# Instantiation logic
 
-It is possible to declare methods that will be called from the container
+Constructing a new instance involves a number of steps executed in this order
+- Constructor call  
+  the constructor is called with the resolved parameters
+- Advice injection  
+  All methods involving aspects are updated
+- Lifecycle methods   
+  different decorators can mark methods that should be called during the lifecycle ( here the construction ) of an instance.
+  These are various injection possibilities as well as an optional final `on_init` call
+- PostProcessors  
+  Any custom post processors, that can add isde effects or modify the instances
+
+## Injection methods
+
+Different decorators are implemented, that call methods with computed values
+
+- `@inject`  
+   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()`  
+   the method is called with a resolved configuration value. Check the corresponding chapter
+
+**Example**:
+```python
+@injectable()
+class Foo:
+    def __init__(self):
+        pass
+
+    @inject_environment()
+    def initEnvironment(self, env: Environment):
+        ...
+
+    @inject()
+    def set(self, baz: Baz) -> None:
+        ...
+```
+
+## Lifecycle methods
+
+It is possible to mark specific lifecle methods. 
 - `@on_init()` 
    called after the constructor and all other injections.
 - `@on_destroy()` 
-   called after the container has been shut down
+   called during shutdown of the environment
 
-# Post Processors
+## Post Processors
 
 As part of the instantiation logic it is possible to define post processors that execute any side effect on newly created instances.
 

{aspyx-0.1.0 → aspyx-1.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aspyx"
-version = "0.1.0"
+version = "1.0.0"
 description = "A DI and AOP library for Python"
 authors = [{ name = "Andreas Ernst", email = "andreas.ernst7@gmail.com" }]
 readme = "README.md"

{aspyx-0.1.0 → aspyx-1.0.0}/src/aspyx/di/aop/aop.py

@@ -3,11 +3,13 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 import inspect
 import re
+import threading
 import types
 from dataclasses import dataclass
 from enum import auto, Enum
 from typing import Optional, Dict, Type, Callable
 
+from aspyx.di.di import order
 from aspyx.reflection import Decorators, TypeDescriptor
 from aspyx.di import injectable, Providers, ClassInstanceProvider, Environment, PostProcessor
 
@@ -51,6 +53,7 @@ class AspectTarget(ABC):
         "names",
         "patterns",
         "types",
+        "other",
         "decorators",
     ]
 
@@ -65,14 +68,32 @@ class AspectTarget(ABC):
         self.types = []
         self.decorators = []
 
+        self.other : list[AspectTarget] = []
+
         pass
 
     # abstract
 
-    @abstractmethod
     def _matches(self, clazz : Type, func):
+        if not self._matchesSelf(clazz, func):
+            for target in self.other:
+                if target._matches(clazz, func):
+                    return True
+
+            return False
+
+        return True
+
+    @abstractmethod
+    def _matchesSelf(self, clazz: Type, func):
         pass
 
+    # protected
+
+    def _add(self, target: AspectTarget):
+        self.other.append(target)
+        return self
+
      # fluent
 
     def function(self, func):
@@ -83,7 +104,7 @@ class AspectTarget(ABC):
         self._type = type
 
         return self
-    
+
     def of_type(self, type: Type):
         self.types.append(type)
         return self
@@ -118,9 +139,9 @@ class ClassAspectTarget(AspectTarget):
 
     # public
 
-    def _matches(self, clazz : Type, func):
-        descriptor = TypeDescriptor.for_type(clazz)
-
+    def _matchesSelf(self, clazz : Type, func):
+        classDescriptor = TypeDescriptor.for_type(clazz)
+        #descriptor = TypeDescriptor.for_type(func)
         # type
 
         if len(self.types) > 0:
@@ -130,7 +151,7 @@ class ClassAspectTarget(AspectTarget):
         # decorators
 
         if len(self.decorators) > 0:
-            if next((decorator for decorator in self.decorators if descriptor.has_decorator(decorator)), None) is None:
+            if next((decorator for decorator in self.decorators if classDescriptor.has_decorator(decorator)), None) is None:
                 return False
 
         # names
@@ -144,8 +165,6 @@ class ClassAspectTarget(AspectTarget):
         if len(self.patterns) > 0:
             if next((pattern for pattern in self.patterns if re.fullmatch(pattern, clazz.__name__) is not None), None) is None:
                 return False
-   
-        # yipee
 
         return True
     
@@ -174,7 +193,7 @@ class MethodAspectTarget(AspectTarget):
 
     # public
 
-    def _matches(self, clazz : Type, func):
+    def _matchesSelf(self, clazz : Type, func):
         descriptor = TypeDescriptor.for_type(clazz)
 
         methodDescriptor = descriptor.get_method(func.__name__)
@@ -349,12 +368,14 @@ class Advice:
 
     __slots__ = [
         "cache",
+        "lock"
     ]
 
     # constructor
 
     def __init__(self):
         self.cache : Dict[Type, Dict[Callable,JoinPoints]] = dict()
+        self.lock = threading.RLock()
 
     # methods
 
@@ -370,20 +391,23 @@ class Advice:
 
         return aspects
 
-    # TODO thread-safe
     def joinPoints4(self, instance, environment: Environment) -> Dict[Callable,JoinPoints]:
         clazz = type(instance)
 
         result = self.cache.get(clazz, None)
         if result is None:
-            result = dict()
+            with self.lock:
+                result = self.cache.get(clazz, None)
+
+                if result is None:
+                    result = dict()
 
-            for name, member in inspect.getmembers(clazz, predicate=inspect.isfunction):
-                joinPoints = self.computeJoinPoints(clazz, member, environment)
-                if joinPoints is not None:
-                    result[member] = joinPoints
+                    for name, member in inspect.getmembers(clazz, predicate=inspect.isfunction):
+                        joinPoints = self.computeJoinPoints(clazz, member, environment)
+                        if joinPoints is not None:
+                            result[member] = joinPoints
 
-            self.cache[clazz] = result
+                    self.cache[clazz] = result
 
         # add around methods
 
@@ -453,57 +477,63 @@ def advice(cls):
 
 # decorators
 
-def _register(decorator, target: AspectTarget, func, aspectType: AspectType):
+def _register(decorator, targets: list[AspectTarget], func, aspectType: AspectType):
+    target = targets[0]
+
+    for i in range(1, len(targets)):
+        target._add(targets[i])
+
     target.function(func).type(aspectType)
 
     Decorators.add(func, decorator, target)
 
-def before(target: AspectTarget):
+def before(*targets: AspectTarget):
     """
     Methods decorated with @before will be executed before the target method is invoked.
     """
     def decorator(func):
-        _register(before, target, func, AspectType.BEFORE)
+        _register(before, targets, func, AspectType.BEFORE)
 
         return func
 
     return decorator
 
-def error(target: AspectTarget):
+def error(*targets: AspectTarget):
     """
     Methods decorated with @error will be executed if the target method raises an exception."""
     def decorator(func):
-        _register(error, target, func, AspectType.ERROR)
+        _register(error, targets, func, AspectType.ERROR)
 
         return func
 
     return decorator
 
-def after(target: AspectTarget):
+def after(*targets: AspectTarget):
     """
     Methods decorated with @after will be executed after the target method is invoked.
     """
     def decorator(func):
-        _register(after, target, func, AspectType.AFTER)
+        _register(after, targets, func, AspectType.AFTER)
 
         return func
 
     return decorator
 
-def around(target: AspectTarget):
+def around(*targets: AspectTarget):
     """
     Methods decorated with @around will be executed around the target method.
     Every around method must accept a single parameter of type Invocation and needs to call proceed
     on this parameter to proceed to the next around method.
     """
     def decorator(func):
-        _register(around, target, func, AspectType.AROUND)
+        _register(around, targets, func, AspectType.AROUND)
 
         return func
 
     return decorator
 
 @injectable()
+@order(0)
 class AdviceProcessor(PostProcessor):
     # properties
 

{aspyx-0.1.0 → aspyx-1.0.0}/src/aspyx/di/configuration/configuration.py

@@ -6,6 +6,7 @@ from typing import Optional, Type, TypeVar
 from dotenv import load_dotenv
 
 from aspyx.di import injectable, Environment, CallableProcessor, LifecycleCallable, Lifecycle, environment
+from aspyx.di.di import order
 from aspyx.reflection import Decorators, DecoratorDescriptor, TypeDescriptor
 
 T = TypeVar("T")
@@ -180,6 +181,7 @@ def value(key: str, default=None):
     return decorator
 
 @injectable()
+@order(9)
 class ConfigurationLifecycleCallable(LifecycleCallable):
     def __init__(self, processor: CallableProcessor,  manager: ConfigurationManager):
         super().__init__(value, processor, Lifecycle.ON_INIT)

{aspyx-0.1.0 → aspyx-1.0.0}/src/aspyx/di/di.py

@@ -5,6 +5,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
@@ -438,12 +439,16 @@ 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
 
@@ -596,6 +601,13 @@ def registerFactories(cls: Type):
             create_decorator = method.get_decorator(create)
             Providers.register(FunctionInstanceProvider(cls, method.method, method.returnType, 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"):
     """
@@ -715,6 +727,7 @@ class Environment:
     ]
 
     # constructor
+
     def __init__(self, env: Type, parent : Optional[Environment] = None):
         """
         Creates a new Environment instance.
@@ -823,11 +836,21 @@ class Environment:
         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)
 
+            # sort immediately
+
+            self.lifecycleProcessors.sort(key=lambda processor: processor.order)
+
         # remember instance
 
         self.instances.append(instance)
@@ -866,12 +889,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 +907,7 @@ class LifecycleCallable:
         return []
 
 @injectable()
+@order(1)
 class CallableProcessor(LifecycleProcessor):
     # local classes
 
@@ -920,6 +949,12 @@ class CallableProcessor(LifecycleProcessor):
                 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.lifecycleCallable.order)
+
+        # done
+
         return result
 
     def callablesFor(self, type: Type)-> list[CallableProcessor.MethodCall]:
@@ -942,6 +977,7 @@ class CallableProcessor(LifecycleProcessor):
                 callable.execute(instance, environment)
 
 @injectable()
+@order(1000)
 class OnInitLifecycleCallable(LifecycleCallable):
     __slots__ = []
 
@@ -949,6 +985,7 @@ class OnInitLifecycleCallable(LifecycleCallable):
         super().__init__(on_init, processor, Lifecycle.ON_INIT)
 
 @injectable()
+@order(1001)
 class OnDestroyLifecycleCallable(LifecycleCallable):
     __slots__ = []
 
@@ -956,6 +993,7 @@ class OnDestroyLifecycleCallable(LifecycleCallable):
         super().__init__(on_destroy, processor, Lifecycle.ON_DESTROY)
 
 @injectable()
+@order(9)
 class EnvironmentAwareLifecycleCallable(LifecycleCallable):
     __slots__ = []
 
@@ -966,6 +1004,7 @@ class EnvironmentAwareLifecycleCallable(LifecycleCallable):
         return [environment]
 
 @injectable()
+@order(10)
 class InjectLifecycleCallable(LifecycleCallable):
     __slots__ = []
 
@@ -1012,7 +1051,8 @@ class SingletonScope(Scope):
     # properties
 
     __slots__ = [
-        "value"
+        "value",
+        "lock"
     ]
 
     # constructor
@@ -1021,12 +1061,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())
+        if self.value is None:
+            with self.lock:
+                if self.value is None: 
+                    self.value = provider.create(environment, *argProvider())
 
         return self.value
 

{aspyx-0.1.0 → aspyx-1.0.0}/src/aspyx/reflection/reflection.py

@@ -6,6 +6,11 @@ from typing import Callable, get_type_hints, Type, Dict, Optional
 from weakref import WeakKeyDictionary
 
 class DecoratorDescriptor:
+    __slots__ = [
+        "decorator",
+        "args"
+    ]
+
     def __init__(self, decorator, *args):
         self.decorator = decorator
         self.args = args
@@ -47,14 +52,14 @@ class TypeDescriptor:
 
         def get_decorator(self, decorator):
             for dec in self.decorators:
-                if dec.decorator == decorator:
+                if dec.decorator is decorator:
                     return dec
 
             return None
 
         def has_decorator(self, decorator):
             for dec in self.decorators:
-                if dec.decorator == decorator:
+                if dec.decorator is decorator:
                     return True
 
             return False
@@ -122,7 +127,7 @@ class TypeDescriptor:
 
     def has_decorator(self, decorator) -> bool:
         for dec in self.decorators:
-            if dec.decorator is decorator:
+            if dec.decorator.__name__ == decorator.__name__:
                 return True
 
         return False

{aspyx-0.1.0 → aspyx-1.0.0/src/aspyx.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aspyx
-Version: 0.1.0
+Version: 1.0.0
 Summary: A DI and AOP library for Python
 Author-email: Andreas Ernst <andreas.ernst7@gmail.com>
 License: MIT License
@@ -32,8 +32,8 @@ Dynamic: license-file
 
 # aspyx
 
-![Pylint](https://github.com/andreasernst/aspyx/actions/workflows/pylint.yml/badge.svg)
-![Build Status](https://github.com/andreasernst/aspyx/actions/workflows/ci.yml/badge.svg)
+![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)
 
 
 ## Table of Contents
@@ -46,8 +46,10 @@ Dynamic: license-file
 - [Environment](#environment)
   - [Definition](#definition)
   - [Retrieval](#retrieval)
-- [Lifecycle methods](#lifecycle-methods)
-- [Post Processors](#post-processors)
+- [Instantiation logic](#instantiation-logic)
+  - [Injection Methods](#injection-methods)
+  - [Lifecycle Methods](#lifecycle-methods)
+  - [Post Processors](#post-processors)
 - [Custom scopes](#custom-scopes)
 - [AOP](#aop)
 - [Configuration](#configuration)
@@ -164,9 +166,10 @@ class Foo:
     def __init__(self):
         pass
 ```
- Please make sure, that the class defines a constructor, as this is required to determine injected instances. 
+Please make sure, that the class defines a local constructor, as this is required to determine injected instances. 
+All referenced types will be injected by the environemnt. 
 
- The constructor can only define parameter types that are known as well to the container! 
+Only eligible types are allowed, of course!
 
 
  The decorator accepts the keyword arguments
@@ -268,15 +271,55 @@ In case of ambiguities, it will throw an exception.
 
 Please be aware, that a base class are not _required_ to be annotated with `@injectable`, as this would mean, that it could be created on its own as well. ( Which is possible as well, btw. ) 
 
-# Lifecycle methods
+# Instantiation logic
 
-It is possible to declare methods that will be called from the container
+Constructing a new instance involves a number of steps executed in this order
+- Constructor call  
+  the constructor is called with the resolved parameters
+- Advice injection  
+  All methods involving aspects are updated
+- Lifecycle methods   
+  different decorators can mark methods that should be called during the lifecycle ( here the construction ) of an instance.
+  These are various injection possibilities as well as an optional final `on_init` call
+- PostProcessors  
+  Any custom post processors, that can add isde effects or modify the instances
+
+## Injection methods
+
+Different decorators are implemented, that call methods with computed values
+
+- `@inject`  
+   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()`  
+   the method is called with a resolved configuration value. Check the corresponding chapter
+
+**Example**:
+```python
+@injectable()
+class Foo:
+    def __init__(self):
+        pass
+
+    @inject_environment()
+    def initEnvironment(self, env: Environment):
+        ...
+
+    @inject()
+    def set(self, baz: Baz) -> None:
+        ...
+```
+
+## Lifecycle methods
+
+It is possible to mark specific lifecle methods. 
 - `@on_init()` 
    called after the constructor and all other injections.
 - `@on_destroy()` 
-   called after the container has been shut down
+   called during shutdown of the environment
 
-# Post Processors
+## Post Processors
 
 As part of the instantiation logic it is possible to define post processors that execute any side effect on newly created instances.
 

{aspyx-0.1.0 → aspyx-1.0.0}/tests/test_aop.py

@@ -5,7 +5,7 @@ import unittest
 
 from aspyx.reflection import Decorators
 from aspyx.di import injectable, Environment, environment
-from aspyx.di.aop import advice, before, after, around, methods, Invocation, error
+from aspyx.di.aop import advice, before, after, around, methods, Invocation, error, classes
 
 
 def transactional():
@@ -22,11 +22,12 @@ class TestEnvironment:
 
 
 @injectable()
+@transactional()
 class Bar:
     def __init__(self):
         pass
 
-    @transactional()
+    #@transactional()
     def say(self, hello: str):
         return hello
 
@@ -89,7 +90,7 @@ class SampleAdvice:
 
         return invocation.proceed()
 
-    @around(methods().decorated_with(transactional))
+    @around(methods().decorated_with(transactional), classes().decorated_with(transactional))
     def callTransactional1(self, invocation: Invocation):
         self.around_calls += 1
 
@@ -101,7 +102,7 @@ class SampleAdvice:
 
         return invocation.proceed()
 
-logging.basicConfig(level=logging.DEBUG)
+#logging.basicConfig(level=logging.DEBUG)
 
 class TestAdvice(unittest.TestCase):
     testEnvironment = Environment(TestEnvironment)

{aspyx-0.1.0 → aspyx-1.0.0}/tests/test_di.py

@@ -6,6 +6,7 @@ import unittest
 from typing import Dict
 
 from aspyx.di import InjectorException, injectable, on_init, on_destroy, inject_environment, inject, Factory, create, environment, Environment, PostProcessor, factory
+from aspyx.di.di import order
 from di_import import ImportedEnvironment, ImportedClass
 
 # not here
@@ -27,6 +28,7 @@ configure_logging({
 
 
 @injectable()
+@order(10)
 class SamplePostProcessor(PostProcessor):
     def process(self, instance: object, environment: Environment):
         pass #print(f"created a {instance}")
@@ -220,7 +222,7 @@ class TestInject(unittest.TestCase):
 
         self.assertIsNot(ns, ns1)
 
-    #def test_import_configurations(self):
+    #def test_import_configurations(self): TODO
     #    env = Environment(TestEnvironment)#
 
     #    imported = env.get(ImportedClass)

{aspyx-0.1.0 → aspyx-1.0.0}/tests/test_reflection.py

@@ -2,12 +2,23 @@ from __future__ import annotations
 
 import unittest
 
-from aspyx.reflection import TypeDescriptor
+from aspyx.di import injectable
+from aspyx.reflection import TypeDescriptor, Decorators
 
+
+def transactional():
+    def decorator(func):
+        Decorators.add(func, transactional)
+        return func #
+
+    return decorator
+
+@transactional()
 class Base:
     def __init__(self):
         pass
 
+    @transactional()
     def base(self, message: str) -> str:
         pass
 
@@ -26,7 +37,13 @@ class Derived(Base):
         pass
 
 class TestReflection(unittest.TestCase):
-    def test(self):
+    def test_decorators(self):
+        baseDescriptor = TypeDescriptor.for_type(Base)
+
+        self.assertTrue(baseDescriptor.has_decorator(transactional))
+        self.assertTrue( baseDescriptor.get_method("base").has_decorator(transactional))
+
+    def test_methods(self):
         derivedDescriptor = TypeDescriptor.for_type(Derived)
 
         self.assertIsNotNone(derivedDescriptor.get_method("derived").returnType, str)