aspyx 1.2.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 DIException, AbstractCallableProcessor, LifecycleCallable, Lifecycle, Providers, Environment, ClassInstanceProvider, injectable, factory, environment, inject, order, 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",
@@ -30,5 +31,8 @@ __all__ = [
     "AbstractCallableProcessor",
     "LifecycleCallable",
     "DIException",
-    "Lifecycle"
+    "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
 
@@ -533,10 +603,22 @@ class AdviceProcessor(PostProcessor):
     def process(self, instance: object, environment: Environment):
         join_point_dict = self.advice.join_points4(instance, environment)
 
-        for member, joinPoints in join_point_dict.items():
+        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)
+                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(joinPoints), 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/env_configuration_source.py

@@ -52,4 +52,4 @@ class EnvConfigurationSource(ConfigurationSource):
             else:
                 exploded[key] = value
 
-        return exploded
+        return exploded

aspyx/di/configuration/yaml_configuration_source.py

@@ -23,4 +23,4 @@ class YamlConfigurationSource(ConfigurationSource):
 
     def load(self) -> dict:
         with open(self.file, "r") as file:
-            return yaml.safe_load(file)
+            return yaml.safe_load(file)