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

aspyx/di/__init__.py

@@ -1,3 +1,6 @@
+"""
+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
 
 # import something from the subpackages, so that teh decorators are executed
@@ -26,4 +29,4 @@ __all__ = [
     "LifecycleCallable",
     "InjectorException",
     "Lifecycle"
-]
+]

aspyx/di/aop/__init__.py

@@ -1,3 +1,6 @@
+"""
+AOP module
+"""
 from .aop import before, after, classes, around, error, advice, methods, Invocation
 __all__ = [
     "before",
@@ -8,4 +11,4 @@ __all__ = [
     "classes",
     "methods",
     "Invocation",
-]
+]

aspyx/di/aop/aop.py

@@ -1,21 +1,26 @@
+"""
+This module provides aspect-oriented programming (AOP) capabilities for Python applications.
+"""
 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
 
 
 class AOPException(Exception):
     """
-    Exception raised for errors in the aop logic."""
-    pass
+    Exception raised for errors in the aop logic.
+    """
 
 class AspectType(Enum):
     """
@@ -51,6 +56,7 @@ class AspectTarget(ABC):
         "names",
         "patterns",
         "types",
+        "other",
         "decorators",
     ]
 
@@ -59,20 +65,38 @@ class AspectTarget(ABC):
     def __init__(self):
         self._clazz = None
         self._instance = None
+        self._function = None
+        self._type = None
 
         self.patterns = []
         self.names = []
         self.types = []
         self.decorators = []
 
-        pass
+        self.other : list[AspectTarget] = []
 
     # abstract
 
-    @abstractmethod
     def _matches(self, clazz : Type, func):
+        if not self._matches_self(clazz, func):
+            for target in self.other:
+                if target._matches(clazz, func):
+                    return True
+
+            return False
+
+        return True
+
+    @abstractmethod
+    def _matches_self(self, clazz: Type, func):
         pass
 
+    # protected
+
+    def _add(self, target: AspectTarget):
+        self.other.append(target)
+        return self
+
      # fluent
 
     def function(self, func):
@@ -83,7 +107,7 @@ class AspectTarget(ABC):
         self._type = type
 
         return self
-    
+
     def of_type(self, type: Type):
         self.types.append(type)
         return self
@@ -91,7 +115,7 @@ class AspectTarget(ABC):
     def decorated_with(self, decorator):
         self.decorators.append(decorator)
         return self
-    
+
     def matches(self, pattern: str):
         """
         Matches the target against a pattern.
@@ -109,18 +133,11 @@ class ClassAspectTarget(AspectTarget):
     __slots__ = [
     ]
 
-    # constructor
-
-    def __init__(self):
-        super().__init__()
-
-        pass
-
     # public
 
-    def _matches(self, clazz : Type, func):
-        descriptor = TypeDescriptor.for_type(clazz)
-
+    def _matches_self(self, clazz : Type, func):
+        class_descriptor = TypeDescriptor.for_type(clazz)
+        #descriptor = TypeDescriptor.for_type(func)
         # type
 
         if len(self.types) > 0:
@@ -130,7 +147,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 class_descriptor.has_decorator(decorator)), None) is None:
                 return False
 
         # names
@@ -138,46 +155,28 @@ class ClassAspectTarget(AspectTarget):
         if len(self.names) > 0:
             if next((name for name in self.names if name == clazz.__name__), None) is None:
                 return False
-            
+
         # patterns
 
         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
-    
-    # fluent
 
+    # fluent
 
-    
 class MethodAspectTarget(AspectTarget):
     # properties
 
-    __slots__ = [
-        "_clazz",
-        "_instance",
-        "_type",
-        "_function",
-        "names",
-        "patterns",
-        "types",
-        "decorators",
-    ]
-
-    # constructor
-
-    def __init__(self):
-       super().__init__()
+    __slots__ = [ ]
 
     # public
 
-    def _matches(self, clazz : Type, func):
+    def _matches_self(self, clazz : Type, func):
         descriptor = TypeDescriptor.for_type(clazz)
 
-        methodDescriptor = descriptor.get_method(func.__name__)
+        method_descriptor = descriptor.get_method(func.__name__)
 
         # type
 
@@ -188,7 +187,7 @@ class MethodAspectTarget(AspectTarget):
         # decorators
 
         if len(self.decorators) > 0:
-            if next((decorator for decorator in self.decorators if methodDescriptor.has_decorator(decorator)), None) is None:
+            if next((decorator for decorator in self.decorators if method_descriptor.has_decorator(decorator)), None) is None:
                 return False
 
         # names
@@ -196,13 +195,13 @@ class MethodAspectTarget(AspectTarget):
         if len(self.names) > 0:
             if next((name for name in self.names if name == func.__name__), None) is None:
                 return False
-            
+
         # patterns
 
         if len(self.patterns) > 0:
             if next((pattern for pattern in self.patterns if re.fullmatch(pattern, func.__name__) is not None), None) is None:
                 return False
-   
+
         # yipee
 
         return True
@@ -248,7 +247,7 @@ class FunctionJoinPoint(JoinPoint):
         self.func = func
 
     def call(self, invocation: 'Invocation'):
-        invocation.currentJoinPoint = self
+        invocation.current_join_point = self
 
         return self.func(self.instance, invocation)
 
@@ -259,7 +258,7 @@ class MethodJoinPoint(FunctionJoinPoint):
         super().__init__(instance, func, None)
 
     def call(self, invocation: 'Invocation'):
-        invocation.currentJoinPoint = self
+        invocation.current_join_point = self
 
         return self.func(*invocation.args, **invocation.kwargs)
 
@@ -283,20 +282,20 @@ class Invocation:
         "kwargs",
         "result",
         "exception",
-        "joinPoints",
-        "currentJoinPoint",
+        "join_points",
+        "current_join_point",
     ]
 
     # constructor
 
-    def __init__(self,  func, joinPoints: JoinPoints):
+    def __init__(self, func, join_points: JoinPoints):
         self.func = func
         self.args : list[object] = []
         self.kwargs = None
         self.result = None
         self.exception = None
-        self.joinPoints = joinPoints
-        self.currentJoinPoint = None
+        self.join_points = join_points
+        self.current_join_point = None
 
     def call(self, *args, **kwargs):
         # remember args
@@ -306,28 +305,28 @@ class Invocation:
 
         # run all before
 
-        for joinPoint in self.joinPoints.before:
-            joinPoint.call(self)
+        for join_point in self.join_points.before:
+            join_point.call(self)
 
         # run around's with the method being the last aspect!
 
         try:
-            self.result = self.joinPoints.around[0].call(self) # will follow the proceed chain
+            self.result = self.join_points.around[0].call(self) # will follow the proceed chain
 
         except Exception as e:
             self.exception = e
-            for joinPoint in self.joinPoints.error:
-                joinPoint.call(self)
+            for join_point in self.join_points.error:
+                join_point.call(self)
 
         # run all before
 
-        for joinPoint in self.joinPoints.after:
-            joinPoint.call(self)
+        for join_point in self.join_points.after:
+            join_point.call(self)
 
         if self.exception is not None:
             raise self.exception # rethrow the error
-        else:
-            return self.result
+
+        return self.result
 
     def proceed(self, *args, **kwargs):
         """
@@ -339,7 +338,7 @@ class Invocation:
 
         # next one please...
 
-        return self.currentJoinPoint.next.call(self)
+        return self.current_join_point.next.call(self)
 
 @injectable()
 class Advice:
@@ -349,12 +348,14 @@ class Advice:
 
     __slots__ = [
         "cache",
+        "lock"
     ]
 
     # constructor
 
     def __init__(self):
-        self.cache : Dict[Type, Dict[Callable,JoinPoints]] = dict()
+        self.cache : Dict[Type, Dict[Callable,JoinPoints]] = {}
+        self.lock = threading.RLock()
 
     # methods
 
@@ -370,24 +371,27 @@ class Advice:
 
         return aspects
 
-    # TODO thread-safe
-    def joinPoints4(self, instance, environment: Environment) -> Dict[Callable,JoinPoints]:
+    def join_points4(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)
 
-            for name, member in inspect.getmembers(clazz, predicate=inspect.isfunction):
-                joinPoints = self.computeJoinPoints(clazz, member, environment)
-                if joinPoints is not None:
-                    result[member] = joinPoints
+                if result is None:
+                    result = {}
 
-            self.cache[clazz] = result
+                    for _, member in inspect.getmembers(clazz, predicate=inspect.isfunction):
+                        join_points = self.compute_join_points(clazz, member, environment)
+                        if join_points is not None:
+                            result[member] = join_points
+
+                    self.cache[clazz] = result
 
         # add around methods
 
-        value = dict()
+        value = {}
 
         for key, cjp in result.items():
             jp = JoinPoints(
@@ -408,7 +412,7 @@ class Advice:
 
         return value
 
-    def computeJoinPoints(self, clazz, member, environment: Environment) -> Optional[JoinPoints]:
+    def compute_join_points(self, clazz, member, environment: Environment) -> Optional[JoinPoints]:
         befores = self.collect(clazz, member, AspectType.BEFORE, environment)
         arounds = self.collect(clazz, member, AspectType.AROUND, environment)
         afters = self.collect(clazz, member, AspectType.AFTER, environment)
@@ -424,9 +428,9 @@ class Advice:
         else:
             return None
 
-def sanityCheck(clazz: Type, name: str):
+def sanity_check(clazz: Type, name: str):
     m = TypeDescriptor.for_type(clazz).get_method(name)
-    if len(m.paramTypes) != 1 or m.paramTypes[0] != Invocation:
+    if len(m.param_types) != 1 or m.param_types[0] != Invocation:
         raise AOPException(f"Method {clazz.__name__}.{name} expected to have one parameter of type Invocation")
 
 # decorators
@@ -445,7 +449,7 @@ def advice(cls):
         if decorator is not None:
             target = decorator.args[0]
             target._clazz = cls
-            sanityCheck(cls, name)
+            sanity_check(cls, name)
             Advice.targets.append(target)
 
     return cls
@@ -453,57 +457,63 @@ def advice(cls):
 
 # decorators
 
-def _register(decorator, target: AspectTarget, func, aspectType: AspectType):
-    target.function(func).type(aspectType)
+def _register(decorator, targets: list[AspectTarget], func, aspect_type: AspectType):
+    target = targets[0]
+
+    for i in range(1, len(targets)):
+        target._add(targets[i])
+
+    target.function(func).type(aspect_type)
 
     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
 
@@ -521,12 +531,12 @@ class AdviceProcessor(PostProcessor):
     # implement
 
     def process(self, instance: object, environment: Environment):
-        joinPointDict = self.advice.joinPoints4(instance, environment)
+        join_point_dict = self.advice.join_points4(instance, environment)
 
-        for member, joinPoints in joinPointDict.items():
-            Environment.logger.debug(f"add aspects for {type(instance)}:{member.__name__}")
+        for member, join_points in join_point_dict.items():
+            Environment.logger.debug("add aspects for %s:%s", type(instance), member.__name__)
 
             def wrap(jp):
                 return lambda *args, **kwargs: Invocation(member, jp).call(*args, **kwargs)
 
-            setattr(instance, member.__name__, types.MethodType(wrap(joinPoints), instance))
+            setattr(instance, member.__name__, types.MethodType(wrap(join_points), instance))

aspyx/di/configuration/__init__.py

@@ -1,3 +1,6 @@
+"""
+Configuration value handling
+"""
 from .configuration import ConfigurationManager, ConfigurationSource, EnvConfigurationSource, value
 
 __all__ = [
@@ -5,4 +8,4 @@ __all__ = [
     "ConfigurationSource",
     "EnvConfigurationSource",
     "value"
-]
+]

aspyx/di/configuration/configuration.py

@@ -1,3 +1,6 @@
+"""
+Configuration handling module.
+"""
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
@@ -5,7 +8,8 @@ import os
 from typing import Optional, Type, TypeVar
 from dotenv import load_dotenv
 
-from aspyx.di import injectable, Environment, CallableProcessor, LifecycleCallable, Lifecycle, environment
+from aspyx.di import injectable, Environment, CallableProcessor, LifecycleCallable, Lifecycle
+from aspyx.di.di import order, inject
 from aspyx.reflection import Decorators, DecoratorDescriptor, TypeDescriptor
 
 T = TypeVar("T")
@@ -14,7 +18,6 @@ class ConfigurationException(Exception):
     """
     Exception raised for errors in the configuration logic.
     """
-    pass
 
 @injectable()
 class ConfigurationManager:
@@ -29,7 +32,7 @@ class ConfigurationManager:
 
     def __init__(self):
         self.sources = []
-        self._data = dict()
+        self._data = {}
         self.coercions = {
             int: int,
             float: float,
@@ -81,17 +84,17 @@ class ConfigurationManager:
                 current = current[key]
 
             return current
-        
+
         v = resolve_value(path, default)
 
         if isinstance(v, type):
             return v
-            
+
         if type in self.coercions:
             try:
                 return self.coercions[type](v)
-            except Exception:
-                raise ConfigurationException(f"error during coercion to {type}")
+            except Exception as e:
+                raise ConfigurationException(f"error during coercion to {type}") from e
         else:
             raise ConfigurationException(f"unknown coercion to {type}")
 
@@ -103,15 +106,18 @@ class ConfigurationSource(ABC):
 
     __slots__ = []
 
-    def __init__(self, manager: ConfigurationManager):
-        manager._register(self)
+    def __init__(self):
         pass
 
+    @inject()
+    def set_manager(self, manager: ConfigurationManager):
+        manager._register(self)
+
     @abstractmethod
     def load(self) -> dict:
         """
-        return the configuration values of this source as a dictionary."""
-        pass
+        return the configuration values of this source as a dictionary.
+        """
 
 @injectable()
 class EnvConfigurationSource(ConfigurationSource):
@@ -123,8 +129,8 @@ class EnvConfigurationSource(ConfigurationSource):
 
     # constructor
 
-    def __init__(self, manager: ConfigurationManager):
-        super().__init__(manager)
+    def __init__(self):
+        super().__init__()
 
         load_dotenv()
 
@@ -180,6 +186,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)
@@ -187,4 +194,4 @@ class ConfigurationLifecycleCallable(LifecycleCallable):
         self.manager = manager
 
     def args(self, decorator: DecoratorDescriptor, method: TypeDescriptor.MethodDescriptor, environment: Environment):
-        return [self.manager.get(decorator.args[0], method.paramTypes[0], decorator.args[1])]
+        return [self.manager.get(decorator.args[0], method.param_types[0], decorator.args[1])]