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

aspyx/di/__init__.py

@@ -1,14 +1,15 @@
 """
 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
+from .di import conditional, requires_class, requires_feature, DIException, AbstractCallableProcessor, LifecycleCallable, Lifecycle, Providers, Environment, ClassInstanceProvider, injectable, factory, environment, inject, order, create, on_init, on_running, on_destroy, inject_environment, Factory, PostProcessor
 
-# import something from the subpackages, so that teh decorators are executed
+# import something from the subpackages, so that the decorators are executed
 
 from .configuration import ConfigurationManager
 from .aop import before
+from .threading import SynchronizeAdvice
 
-imports = [ConfigurationManager, before]
+imports = [ConfigurationManager, before, SynchronizeAdvice]
 
 __all__ = [
     "ClassInstanceProvider",
@@ -19,6 +20,7 @@ __all__ = [
     "environment",
     "inject",
     "create",
+    "order",
 
     "on_init",
     "on_running",
@@ -28,6 +30,9 @@ __all__ = [
     "PostProcessor",
     "AbstractCallableProcessor",
     "LifecycleCallable",
-    "InjectorException",
-    "Lifecycle"
+    "DIException",
+    "Lifecycle",
+    "conditional",
+    "requires_class",
+    "requires_feature"
 ]

aspyx/di/aop/aop.py

@@ -50,7 +50,7 @@ class AspectTarget(ABC):
     __slots__ = [
         "_function",
         "_type",
-
+        "_async",
         "_clazz",
         "_instance",
         "names",
@@ -65,6 +65,7 @@ class AspectTarget(ABC):
     def __init__(self):
         self._clazz = None
         self._instance = None
+        self._async = False
         self._function = None
         self._type = None
 
@@ -108,6 +109,10 @@ class AspectTarget(ABC):
 
         return self
 
+    def that_are_async(self):
+        self._async = True
+        return self
+
     def of_type(self, type: Type):
         self.types.append(type)
         return self
@@ -178,6 +183,14 @@ class MethodAspectTarget(AspectTarget):
 
         method_descriptor = descriptor.get_method(func.__name__)
 
+        # async
+
+        name = method_descriptor.method.__name__
+        is_async = method_descriptor.is_async()
+
+        if self._async is not method_descriptor.is_async():
+            return False
+
         # type
 
         if len(self.types) > 0:
@@ -234,6 +247,9 @@ class JoinPoint:
     def call(self, invocation: 'Invocation'):
         pass
 
+    async def call_async(self, invocation: 'Invocation'):
+        pass
+
 class FunctionJoinPoint(JoinPoint):
     __slots__ = [
         "instance",
@@ -251,6 +267,11 @@ class FunctionJoinPoint(JoinPoint):
 
         return self.func(self.instance, invocation)
 
+    async def call_async(self, invocation: 'Invocation'):
+        invocation.current_join_point = self
+
+        return await self.func(self.instance, invocation)
+
 class MethodJoinPoint(FunctionJoinPoint):
     __slots__ = []
 
@@ -262,6 +283,11 @@ class MethodJoinPoint(FunctionJoinPoint):
 
         return self.func(*invocation.args, **invocation.kwargs)
 
+    async def call_async(self, invocation: 'Invocation'):
+        invocation.current_join_point = self
+
+        return await self.func(*invocation.args, **invocation.kwargs)
+
 @dataclass
 class JoinPoints:
     before: list[JoinPoint]
@@ -328,6 +354,37 @@ class Invocation:
 
         return self.result
 
+    async def call_async(self, *args, **kwargs):
+        # remember args
+
+        self.args = args
+        self.kwargs = kwargs
+
+        # run all before
+
+        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 = await self.join_points.around[0].call_async(self) # will follow the proceed chain
+
+        except Exception as e:
+            self.exception = e
+            for join_point in self.join_points.error:
+                join_point.call(self)
+
+        # run all before
+
+        for join_point in self.join_points.after:
+            join_point.call(self)
+
+        if self.exception is not None:
+            raise self.exception # rethrow the error
+
+        return self.result
+
     def proceed(self, *args, **kwargs):
         """
         Proceed to the next join point in the around chain up to the original method.
@@ -340,6 +397,18 @@ class Invocation:
 
         return self.current_join_point.next.call(self)
 
+    async def proceed_async(self, *args, **kwargs):
+        """
+        Proceed to the next join point in the around chain up to the original method.
+        """
+        if len(args) > 0 or len(kwargs) > 0:  # as soon as we have args, we replace the current ones
+            self.args = args
+            self.kwargs = kwargs
+
+        # next one please...
+
+        return await self.current_join_point.next.call_async(self)
+
 @injectable()
 class Advice:
     # static data
@@ -381,13 +450,14 @@ class Advice:
 
                 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
 
@@ -537,6 +607,18 @@ class AdviceProcessor(PostProcessor):
             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)
+                def sync_wrapper(*args, **kwargs):
+                    return Invocation(member, jp).call(*args, **kwargs)
+
+                return sync_wrapper
+
+            def wrap_async(jp):
+                async def async_wrapper(*args, **kwargs):
+                    return await Invocation(member, jp).call_async(*args, **kwargs)
+
+                return async_wrapper
 
-            setattr(instance, member.__name__, types.MethodType(wrap(join_points), instance))
+            if inspect.iscoroutinefunction(member):
+                setattr(instance, member.__name__, types.MethodType(wrap_async(join_points), instance))
+            else:
+                setattr(instance, member.__name__, types.MethodType(wrap(join_points), instance))

aspyx/di/configuration/__init__.py

@@ -1,11 +1,14 @@
 """
 Configuration value handling
 """
-from .configuration import ConfigurationManager, ConfigurationSource, EnvConfigurationSource, value
+from .configuration import ConfigurationManager, ConfigurationSource, value
+from .env_configuration_source import EnvConfigurationSource
+from .yaml_configuration_source import YamlConfigurationSource
 
 __all__ = [
     "ConfigurationManager",
     "ConfigurationSource",
     "EnvConfigurationSource",
+    "YamlConfigurationSource",
     "value"
 ]

aspyx/di/configuration/configuration.py

@@ -4,9 +4,7 @@ Configuration handling module.
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-import os
 from typing import Optional, Type, TypeVar
-from dotenv import load_dotenv
 
 from aspyx.di import injectable, Environment, LifecycleCallable, Lifecycle
 from aspyx.di.di import order, inject
@@ -67,7 +65,7 @@ class ConfigurationManager:
 
     def get(self, path: str, type: Type[T], default : Optional[T]=None) -> T:
         """
-        Get a configuration value by path and type, with optional coercion.
+        Retrieve a configuration value by path and type, with optional coercion.
         Arguments:
             path (str): The path to the configuration value, e.g. "database.host".
             type (Type[T]): The expected type.
@@ -119,54 +117,6 @@ class ConfigurationSource(ABC):
         return the configuration values of this source as a dictionary.
         """
 
-@injectable()
-class EnvConfigurationSource(ConfigurationSource):
-    """
-    EnvConfigurationSource loads all environment variables.
-    """
-
-    __slots__ = []
-
-    # constructor
-
-    def __init__(self):
-        super().__init__()
-
-        load_dotenv()
-
-    # implement
-
-    def load(self) -> dict:
-        def merge_dicts(a, b):
-            """Recursively merges b into a"""
-            for key, value in b.items():
-                if isinstance(value, dict) and key in a and isinstance(a[key], dict):
-                    merge_dicts(a[key], value)
-                else:
-                    a[key] = value
-            return a
-
-        def explode_key(key, value):
-            """Explodes keys with '.' or '/' into nested dictionaries"""
-            parts = key.replace('/', '.').split('.')
-            d = current = {}
-            for part in parts[:-1]:
-                current[part] = {}
-                current = current[part]
-            current[parts[-1]] = value
-            return d
-
-        exploded = {}
-
-        for key, value in os.environ.items():
-            if '.' in key or '/' in key:
-                partial = explode_key(key, value)
-                merge_dicts(exploded, partial)
-            else:
-                exploded[key] = value
-
-        return exploded
-
 # decorator
 
 def value(key: str, default=None):

aspyx/di/configuration/env_configuration_source.py

@@ -0,0 +1,55 @@
+"""
+EnvConfigurationSource - Loads environment variables as configuration source.
+"""
+import os
+
+from dotenv import load_dotenv
+
+from .configuration import ConfigurationSource
+
+class EnvConfigurationSource(ConfigurationSource):
+    """
+    EnvConfigurationSource loads all environment variables.
+    """
+
+    __slots__ = []
+
+    # constructor
+
+    def __init__(self):
+        super().__init__()
+
+    # implement
+
+    def load(self) -> dict:
+        def merge_dicts(a, b):
+            """Recursively merges b into a"""
+            for key, value in b.items():
+                if isinstance(value, dict) and key in a and isinstance(a[key], dict):
+                    merge_dicts(a[key], value)
+                else:
+                    a[key] = value
+            return a
+
+        def explode_key(key, value):
+            """Explodes keys with '.' or '/' into nested dictionaries"""
+            parts = key.replace('/', '.').split('.')
+            d = current = {}
+            for part in parts[:-1]:
+                current[part] = {}
+                current = current[part]
+            current[parts[-1]] = value
+            return d
+
+        exploded = {}
+
+        load_dotenv()
+
+        for key, value in os.environ.items():
+            if '.' in key or '/' in key:
+                partial = explode_key(key, value)
+                merge_dicts(exploded, partial)
+            else:
+                exploded[key] = value
+
+        return exploded

aspyx/di/configuration/yaml_configuration_source.py

@@ -0,0 +1,26 @@
+"""
+YamlConfigurationSource - Loads variables from a YAML configuration file.
+"""
+import yaml
+
+from .configuration import ConfigurationSource
+
+class YamlConfigurationSource(ConfigurationSource):
+    """
+    YamlConfigurationSource loads variables from a YAML configuration file.
+    """
+
+    __slots__ = ["file"]
+
+    # constructor
+
+    def __init__(self, file: str):
+        super().__init__()
+
+        self.file = file
+
+    # implement
+
+    def load(self) -> dict:
+        with open(self.file, "r") as file:
+            return yaml.safe_load(file)