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

aspyx/di/__init__.py

@@ -1,9 +1,12 @@
-from .di import InjectorException, CallableProcessor, LifecycleCallable, Lifecycle, Providers, Environment, ClassInstanceProvider, injectable, factory, environment, inject, create, on_init, on_destroy, inject_environment, Factory, PostProcessor
+"""
+This module provides dependency injection and aop capabilities for Python applications.
+"""
+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]
 
@@ -18,12 +21,13 @@ __all__ = [
     "create",
 
     "on_init",
+    "on_running",
     "on_destroy",
     "inject_environment",
     "Factory",
     "PostProcessor",
-    "CallableProcessor",
+    "AbstractCallableProcessor",
     "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,3 +1,6 @@
+"""
+This module provides aspect-oriented programming (AOP) capabilities for Python applications.
+"""
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
@@ -16,8 +19,8 @@ from aspyx.di import injectable, Providers, ClassInstanceProvider, Environment,
 
 class AOPException(Exception):
     """
-    Exception raised for errors in the aop logic."""
-    pass
+    Exception raised for errors in the aop logic.
+    """
 
 class AspectType(Enum):
     """
@@ -62,6 +65,8 @@ class AspectTarget(ABC):
     def __init__(self):
         self._clazz = None
         self._instance = None
+        self._function = None
+        self._type = None
 
         self.patterns = []
         self.names = []
@@ -70,12 +75,10 @@ class AspectTarget(ABC):
 
         self.other : list[AspectTarget] = []
 
-        pass
-
     # abstract
 
     def _matches(self, clazz : Type, func):
-        if not self._matchesSelf(clazz, func):
+        if not self._matches_self(clazz, func):
             for target in self.other:
                 if target._matches(clazz, func):
                     return True
@@ -85,7 +88,7 @@ class AspectTarget(ABC):
         return True
 
     @abstractmethod
-    def _matchesSelf(self, clazz: Type, func):
+    def _matches_self(self, clazz: Type, func):
         pass
 
     # protected
@@ -112,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.
@@ -130,17 +133,10 @@ class ClassAspectTarget(AspectTarget):
     __slots__ = [
     ]
 
-    # constructor
-
-    def __init__(self):
-        super().__init__()
-
-        pass
-
     # public
 
-    def _matchesSelf(self, clazz : Type, func):
-        classDescriptor = TypeDescriptor.for_type(clazz)
+    def _matches_self(self, clazz : Type, func):
+        class_descriptor = TypeDescriptor.for_type(clazz)
         #descriptor = TypeDescriptor.for_type(func)
         # type
 
@@ -151,7 +147,7 @@ class ClassAspectTarget(AspectTarget):
         # decorators
 
         if len(self.decorators) > 0:
-            if next((decorator for decorator in self.decorators if classDescriptor.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
@@ -159,7 +155,7 @@ 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:
@@ -167,36 +163,20 @@ class ClassAspectTarget(AspectTarget):
                 return False
 
         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 _matchesSelf(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
 
@@ -207,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
@@ -215,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
@@ -267,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)
 
@@ -278,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)
 
@@ -302,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
@@ -325,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):
         """
@@ -358,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:
@@ -374,7 +354,7 @@ class Advice:
     # constructor
 
     def __init__(self):
-        self.cache : Dict[Type, Dict[Callable,JoinPoints]] = dict()
+        self.cache : Dict[Type, Dict[Callable,JoinPoints]] = {}
         self.lock = threading.RLock()
 
     # methods
@@ -391,7 +371,7 @@ class Advice:
 
         return aspects
 
-    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)
@@ -400,18 +380,18 @@ class Advice:
                 result = self.cache.get(clazz, None)
 
                 if result is None:
-                    result = dict()
+                    result = {}
 
-                    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 _, 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(
@@ -432,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)
@@ -448,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
@@ -469,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
@@ -477,13 +457,13 @@ def advice(cls):
 
 # decorators
 
-def _register(decorator, targets: list[AspectTarget], func, aspectType: 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(aspectType)
+    target.function(func).type(aspect_type)
 
     Decorators.add(func, decorator, target)
 
@@ -551,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,8 +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.di import order
+from aspyx.di import injectable, Environment, LifecycleCallable, Lifecycle
+from aspyx.di.di import order, inject
 from aspyx.reflection import Decorators, DecoratorDescriptor, TypeDescriptor
 
 T = TypeVar("T")
@@ -15,7 +18,6 @@ class ConfigurationException(Exception):
     """
     Exception raised for errors in the configuration logic.
     """
-    pass
 
 @injectable()
 class ConfigurationManager:
@@ -30,7 +32,7 @@ class ConfigurationManager:
 
     def __init__(self):
         self.sources = []
-        self._data = dict()
+        self._data = {}
         self.coercions = {
             int: int,
             float: float,
@@ -82,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}")
 
@@ -104,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):
@@ -124,8 +129,8 @@ class EnvConfigurationSource(ConfigurationSource):
 
     # constructor
 
-    def __init__(self, manager: ConfigurationManager):
-        super().__init__(manager)
+    def __init__(self):
+        super().__init__()
 
         load_dotenv()
 
@@ -183,10 +188,10 @@ 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
 
     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])]