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

aspyx/di/__init__.py

@@ -1,12 +1,12 @@
 """
 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
+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
 
 # 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]
 
@@ -19,14 +19,16 @@ __all__ = [
     "environment",
     "inject",
     "create",
+    "order",
 
     "on_init",
+    "on_running",
     "on_destroy",
     "inject_environment",
     "Factory",
     "PostProcessor",
-    "CallableProcessor",
+    "AbstractCallableProcessor",
     "LifecycleCallable",
-    "InjectorException",
+    "DIException",
     "Lifecycle"
 ]

aspyx/di/aop/aop.py

@@ -533,10 +533,10 @@ class AdviceProcessor(PostProcessor):
     def process(self, instance: object, environment: Environment):
         join_point_dict = self.advice.join_points4(instance, environment)
 
-        for member, join_points in join_point_dict.items():
+        for member, joinPoints 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(join_points), instance))
+            setattr(instance, member.__name__, types.MethodType(wrap(joinPoints), 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,11 +4,9 @@ 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, CallableProcessor, LifecycleCallable, Lifecycle
+from aspyx.di import injectable, Environment, LifecycleCallable, Lifecycle
 from aspyx.di.di import order, inject
 from aspyx.reflection import Decorators, DecoratorDescriptor, TypeDescriptor
 
@@ -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):
@@ -188,8 +138,8 @@ 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
 

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)