aspyx 1.1.0__tar.gz → 1.2.0__tar.gz

{aspyx-1.1.0/src/aspyx.egg-info → aspyx-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aspyx
-Version: 1.1.0
+Version: 1.2.0
 Summary: A DI and AOP library for Python
 Author-email: Andreas Ernst <andreas.ernst7@gmail.com>
 License: MIT License
@@ -192,9 +192,9 @@ The decorator accepts the keyword arguments
  - `singleton`  
    objects are created once inside an environment and cached. This is the default.
  - `request`  
-   obejcts are created on every injection request
+   objects are created on every injection request
  - `thread`  
-   objects are cerated and cached with respect to the current thread.
+   objects are created and cached with respect to the current thread.
 
  Other scopes - e.g. session related scopes - can be defined dynamically. Please check the corresponding chapter.
 
@@ -455,7 +455,7 @@ Both add the fluent methods:
 
 The fluent methods `named`, `matches` and `of_type` can be called multiple times!
 
-**Example**:
+**Example**: react on both `transactional` decorators on methods or classes
 
 ```python
 @injectable()
@@ -478,11 +478,13 @@ class Foo:
     def __init__(self):
         pass
 
-    @value("OS")
-    def inject_value(self, os: str):
+    @inject_value("HOME")
+    def inject_home(self, os: str):
         ...
 ```
 
+If required a coercion will be executed.
+
 This concept relies on a central object `ConfigurationManager` that stores the overall configuration values as provided by so called configuration sources that are defined as follows.
 
 ```python
@@ -494,14 +496,24 @@ class ConfigurationSource(ABC):
 
     @abstractmethod
     def load(self) -> dict:
-        pass
 ```
 
 The `load` method is able to return a tree-like structure by returning a `dict`.
 
-As a default environment variables are already supported.
+Configuration variables are retrieved with the method
+
+```python
+def get(self, path: str, type: Type[T], default : Optional[T]=None) -> T:
+ ```
+
+- `path`  
+  a '.' separated path
+- `type`  
+  the desired type
+- `default`  
+  a default, if no value is registered
 
-Other sources can be added dynamically by just registering them.
+Sources can be added dynamically by registering them.
 
 **Example**:
 ```python
@@ -521,6 +533,31 @@ class SampleConfigurationSource(ConfigurationSource):
             }
 ```
 
+Two specific source are already implemented:
+- `EnvConfigurationSource`  
+   reads the os environment variables
+- `YamlConfigurationSource`  
+   reads a specific yaml file
+
+Typically you create the required configuration sources in an environment class, e.g.
+
+```python
+@environment()
+class SampleEnvironment:
+    # constructor
+
+    def __init__(self):
+        pass
+
+    @create()
+    def create_env_source(self) -> EnvConfigurationSource:
+        return EnvConfigurationSource()
+
+    @create()
+    def create_yaml_source(self) -> YamlConfigurationSource:
+        return YamlConfigurationSource("config.yaml")
+```
+
 # Reflection
 
 As the library heavily relies on type introspection of classes and methods, a utility class `TypeDescriptor` is available that covers type information on classes. 
@@ -537,7 +574,7 @@ it offers the methods
 - `get_method(name: str, local=False)`  
    return a single either local or overall method
 - `has_decorator(decorator: Callable) -> bool`  
-   return `True`, if the class is decorated with the specified decrator
+   return `True`, if the class is decorated with the specified decorator
 - `get_decorator(decorator) -> Optional[DecoratorDescriptor]`  
    return a descriptor covering the decorator. In addition to the callable, it also stores the supplied args in the `args` property
 
@@ -545,9 +582,9 @@ The returned method descriptors offer:
 - `param_types`  
    list of arg types
 - `return_type`  
-   the retur type
+   the return type
 - `has_decorator(decorator: Callable) -> bool` 
-   return `True`, if the method is decorated with the specified decrator
+   return `True`, if the method is decorated with the specified decorator
 - `get_decorator(decorator: Callable) -> Optional[DecoratorDescriptor]`  
    return a descriptor covering the decorator. In addition to the callable, it also stores the supplied args in the `args` property
 
@@ -557,9 +594,9 @@ Whenver you define a custom decorator, you will need to register it accordingly.
 
 **Example**:
 ```python
-def transactional():
+def transactional(scope):
     def decorator(func):
-        Decorators.add(func, transactional)
+        Decorators.add(func, transactional, scope) # also add _all_ parameters in order to cache them
         return func
 
     return decorator
@@ -577,6 +614,10 @@ def transactional():
 - added `@on_running()` callback
 - added `thread` scope
 
+**1.2.0**
+
+- added `YamlConfigurationSource`
+
 
       
 

{aspyx-1.1.0 → aspyx-1.2.0}/README.md

@@ -160,9 +160,9 @@ The decorator accepts the keyword arguments
  - `singleton`  
    objects are created once inside an environment and cached. This is the default.
  - `request`  
-   obejcts are created on every injection request
+   objects are created on every injection request
  - `thread`  
-   objects are cerated and cached with respect to the current thread.
+   objects are created and cached with respect to the current thread.
 
  Other scopes - e.g. session related scopes - can be defined dynamically. Please check the corresponding chapter.
 
@@ -423,7 +423,7 @@ Both add the fluent methods:
 
 The fluent methods `named`, `matches` and `of_type` can be called multiple times!
 
-**Example**:
+**Example**: react on both `transactional` decorators on methods or classes
 
 ```python
 @injectable()
@@ -446,11 +446,13 @@ class Foo:
     def __init__(self):
         pass
 
-    @value("OS")
-    def inject_value(self, os: str):
+    @inject_value("HOME")
+    def inject_home(self, os: str):
         ...
 ```
 
+If required a coercion will be executed.
+
 This concept relies on a central object `ConfigurationManager` that stores the overall configuration values as provided by so called configuration sources that are defined as follows.
 
 ```python
@@ -462,14 +464,24 @@ class ConfigurationSource(ABC):
 
     @abstractmethod
     def load(self) -> dict:
-        pass
 ```
 
 The `load` method is able to return a tree-like structure by returning a `dict`.
 
-As a default environment variables are already supported.
+Configuration variables are retrieved with the method
+
+```python
+def get(self, path: str, type: Type[T], default : Optional[T]=None) -> T:
+ ```
+
+- `path`  
+  a '.' separated path
+- `type`  
+  the desired type
+- `default`  
+  a default, if no value is registered
 
-Other sources can be added dynamically by just registering them.
+Sources can be added dynamically by registering them.
 
 **Example**:
 ```python
@@ -489,6 +501,31 @@ class SampleConfigurationSource(ConfigurationSource):
             }
 ```
 
+Two specific source are already implemented:
+- `EnvConfigurationSource`  
+   reads the os environment variables
+- `YamlConfigurationSource`  
+   reads a specific yaml file
+
+Typically you create the required configuration sources in an environment class, e.g.
+
+```python
+@environment()
+class SampleEnvironment:
+    # constructor
+
+    def __init__(self):
+        pass
+
+    @create()
+    def create_env_source(self) -> EnvConfigurationSource:
+        return EnvConfigurationSource()
+
+    @create()
+    def create_yaml_source(self) -> YamlConfigurationSource:
+        return YamlConfigurationSource("config.yaml")
+```
+
 # Reflection
 
 As the library heavily relies on type introspection of classes and methods, a utility class `TypeDescriptor` is available that covers type information on classes. 
@@ -505,7 +542,7 @@ it offers the methods
 - `get_method(name: str, local=False)`  
    return a single either local or overall method
 - `has_decorator(decorator: Callable) -> bool`  
-   return `True`, if the class is decorated with the specified decrator
+   return `True`, if the class is decorated with the specified decorator
 - `get_decorator(decorator) -> Optional[DecoratorDescriptor]`  
    return a descriptor covering the decorator. In addition to the callable, it also stores the supplied args in the `args` property
 
@@ -513,9 +550,9 @@ The returned method descriptors offer:
 - `param_types`  
    list of arg types
 - `return_type`  
-   the retur type
+   the return type
 - `has_decorator(decorator: Callable) -> bool` 
-   return `True`, if the method is decorated with the specified decrator
+   return `True`, if the method is decorated with the specified decorator
 - `get_decorator(decorator: Callable) -> Optional[DecoratorDescriptor]`  
    return a descriptor covering the decorator. In addition to the callable, it also stores the supplied args in the `args` property
 
@@ -525,9 +562,9 @@ Whenver you define a custom decorator, you will need to register it accordingly.
 
 **Example**:
 ```python
-def transactional():
+def transactional(scope):
     def decorator(func):
-        Decorators.add(func, transactional)
+        Decorators.add(func, transactional, scope) # also add _all_ parameters in order to cache them
         return func
 
     return decorator
@@ -545,6 +582,10 @@ def transactional():
 - added `@on_running()` callback
 - added `thread` scope
 
+**1.2.0**
+
+- added `YamlConfigurationSource`
+
 
       
 

{aspyx-1.1.0 → aspyx-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aspyx"
-version = "1.1.0"
+version = "1.2.0"
 description = "A DI and AOP library for Python"
 authors = [{ name = "Andreas Ernst", email = "andreas.ernst7@gmail.com" }]
 readme = "README.md"

{aspyx-1.1.0 → aspyx-1.2.0}/src/aspyx/di/__init__.py

@@ -1,7 +1,7 @@
 """
 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 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
 
@@ -19,6 +19,7 @@ __all__ = [
     "environment",
     "inject",
     "create",
+    "order",
 
     "on_init",
     "on_running",
@@ -28,6 +29,6 @@ __all__ = [
     "PostProcessor",
     "AbstractCallableProcessor",
     "LifecycleCallable",
-    "InjectorException",
+    "DIException",
     "Lifecycle"
 ]

{aspyx-1.1.0 → aspyx-1.2.0}/src/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-1.1.0 → aspyx-1.2.0}/src/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-1.1.0 → aspyx-1.2.0}/src/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-1.2.0/src/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-1.2.0/src/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)

{aspyx-1.1.0 → aspyx-1.2.0}/src/aspyx/di/di.py

@@ -1,5 +1,5 @@
 """
-The deoendency injection module provides a framework for managing dependencies and lifecycle of objects in Python applications.
+The dependency injection module provides a framework for managing dependencies and lifecycle of objects in Python applications.
 """
 from __future__ import annotations
 
@@ -7,7 +7,7 @@ import inspect
 import logging
 
 from abc import abstractmethod, ABC
-from enum import Enum, auto
+from enum import Enum
 import threading
 from typing import Type, Dict, TypeVar, Generic, Optional, cast, Callable
 
@@ -27,11 +27,21 @@ class Factory(ABC, Generic[T]):
     def create(self) -> T:
         pass
 
-class InjectorException(Exception):
+class DIException(Exception):
     """
     Exception raised for errors in the injector.
     """
 
+class DIRegistrationException(DIException):
+    """
+    Exception raised during the registration of dependencies.
+    """
+
+class DIRuntimeException(DIException):
+    """
+    Exception raised during the runtime.
+    """
+
 class AbstractInstanceProvider(ABC, Generic[T]):
     """
     Interface for instance providers.
@@ -40,6 +50,9 @@ class AbstractInstanceProvider(ABC, Generic[T]):
     def get_module(self) -> str:
         pass
 
+    def get_host(self) -> Type[T]:
+        return type(self)
+
     @abstractmethod
     def get_type(self) -> Type[T]:
         pass
@@ -64,6 +77,9 @@ class AbstractInstanceProvider(ABC, Generic[T]):
     def resolve(self, context: Providers.Context):
         pass
 
+    def check_factories(self):
+        pass
+
 
 class InstanceProvider(AbstractInstanceProvider):
     """
@@ -93,6 +109,13 @@ class InstanceProvider(AbstractInstanceProvider):
 
     # implement AbstractInstanceProvider
 
+    def get_host(self):
+        return self.host
+
+    def check_factories(self):
+        #register_factories(self.host)
+        pass
+
     def resolve(self, context: Providers.Context):
         pass
 
@@ -188,7 +211,7 @@ class AmbiguousProvider(AbstractInstanceProvider):
         pass
 
     def create(self, environment: Environment, *args):
-        raise InjectorException(f"multiple candidates for type {self.type}")
+        raise DIException(f"multiple candidates for type {self.type}")
 
     def __str__(self):
         return f"AmbiguousProvider({self.type})"
@@ -204,7 +227,7 @@ class Scopes:
     def get(cls, scope: str, environment: Environment):
         scope_type = Scopes.scopes.get(scope, None)
         if scope_type is None:
-            raise InjectorException(f"unknown scope type {scope}")
+            raise DIRegistrationException(f"unknown scope type {scope}")
 
         return environment.get(scope_type)
 
@@ -272,7 +295,7 @@ class EnvironmentInstanceProvider(AbstractInstanceProvider):
         for dependency in self.provider.get_dependencies():
             instance_provider = providers.get(dependency.get_type(), None)
             if instance_provider is None:
-                raise InjectorException(f"missing import for {dependency.get_type()} ")
+                raise DIRegistrationException(f"missing import for {dependency.get_type()} ")
 
             self.dependencies.append(instance_provider)
 
@@ -303,6 +326,9 @@ class ClassInstanceProvider(InstanceProvider):
 
     # implement
 
+    def check_factories(self):
+        register_factories(self.host)
+
     def resolve(self, context: Providers.Context):
         context.add(self)
 
@@ -313,7 +339,7 @@ class ClassInstanceProvider(InstanceProvider):
 
             init = TypeDescriptor.for_type(self.type).get_method("__init__")
             if init is None:
-                raise InjectorException(f"{self.type.__name__} does not implement __init__")
+                raise DIRegistrationException(f"{self.type.__name__} does not implement __init__")
 
             for param in init.param_types:
                 provider = Providers.get_provider(param)
@@ -412,7 +438,6 @@ class FactoryInstanceProvider(InstanceProvider):
             provider = Providers.get_provider(self.host)
             if self.add_dependency(provider):
                 provider.resolve(context)
-
         else: # check if the dependencies crate a cycle
             context.add(*self.dependencies)
 
@@ -490,7 +515,7 @@ class Providers:
         def add(self, *providers: AbstractInstanceProvider):
             for provider in providers:
                 if next((p for p in self.dependencies if p.get_type() is provider.get_type()), None) is not None:
-                    raise InjectorException(self.cycle_report(provider))
+                    raise DIRegistrationException(self.cycle_report(provider))
 
                 self.dependencies.append(provider)
 
@@ -542,13 +567,20 @@ class Providers:
             return True
 
         def cache_provider_for_type(provider: AbstractInstanceProvider, type: Type):
+            def location(provider: AbstractInstanceProvider):
+                host = provider.get_host()
+                file = inspect.getfile(host)
+                line = inspect.getsourcelines(host)[1]
+
+                return f"{file}:{line}"
+
             existing_provider = Providers.cache.get(type)
             if existing_provider is None:
                 Providers.cache[type] = provider
 
             else:
                 if type is provider.get_type():
-                    raise InjectorException(f"{type} already registered")
+                    raise DIRegistrationException(f"{type} already registered in {location(existing_provider)}, override in {location(provider)}")
 
                 if isinstance(existing_provider, AmbiguousProvider):
                     cast(AmbiguousProvider, existing_provider).add_provider(provider)
@@ -573,10 +605,14 @@ class Providers:
 
     @classmethod
     def resolve(cls):
-        for provider in Providers.check:
-            provider.resolve(Providers.Context())
 
-        Providers.check.clear()
+        for check in  Providers.check:
+            check.check_factories()
+
+        # in the loop additional providers may be added
+        while len(Providers.check) > 0:
+            check = Providers.check.pop(0)
+            check.resolve(Providers.Context())
 
     @classmethod
     def report(cls):
@@ -587,7 +623,7 @@ class Providers:
     def get_provider(cls, type: Type) -> AbstractInstanceProvider:
         provider = Providers.cache.get(type, None)
         if provider is None:
-            raise InjectorException(f"{type.__name__} not registered as injectable")
+            raise DIException(f"{type.__name__} not registered as injectable")
 
         return provider
 
@@ -597,7 +633,11 @@ def register_factories(cls: Type):
     for method in descriptor.get_methods():
         if method.has_decorator(create):
             create_decorator = method.get_decorator(create)
-            Providers.register(FunctionInstanceProvider(cls, method.method, method.return_type, create_decorator.args[0],
+            return_type = method.return_type
+            if return_type is None:
+                raise DIRegistrationException(f"{cls.__name__}.{method.method.__name__} expected to have a return type")
+
+            Providers.register(FunctionInstanceProvider(cls, method.method, return_type, create_decorator.args[0],
                                                         create_decorator.args[1]))
 def order(prio = 0):
     def decorator(cls):
@@ -686,8 +726,6 @@ def environment(imports: Optional[list[Type]] = None):
         Decorators.add(cls, environment, imports)
         Decorators.add(cls, injectable) # do we need that?
 
-        register_factories(cls)
-
         return cls
 
     return decorator
@@ -745,8 +783,8 @@ class Environment:
 
         self.type = env
         self.parent = parent
-        if self.parent is None and env is not BootEnvironment:
-            self.parent = BootEnvironment.get_instance() # inherit environment including its manged instances!
+        if self.parent is None and env is not Boot:
+            self.parent = Boot.get_environment() # inherit environment including its manged instances!
 
         self.providers: Dict[Type, AbstractInstanceProvider] = {}
         self.lifecycle_processors: list[LifecycleProcessor] = []
@@ -772,7 +810,7 @@ class Environment:
 
         # bootstrapping hack, they will be overwritten by the "real" providers
 
-        if env is BootEnvironment:
+        if env is Boot:
             add_provider(SingletonScope, SingletonScopeInstanceProvider())
             add_provider(RequestScope, RequestScopeInstanceProvider())
 
@@ -786,7 +824,7 @@ class Environment:
 
                 decorator = TypeDescriptor.for_type(env).get_decorator(environment)
                 if decorator is None:
-                    raise InjectorException(f"{env.__name__} is not an environment class")
+                    raise DIRegistrationException(f"{env.__name__} is not an environment class")
 
                 scan = env.__module__
                 if "." in scan:
@@ -921,7 +959,7 @@ class Environment:
 
     def get(self, type: Type[T]) -> T:
         """
-        Return and possibly create a new instance of the given type.
+        Create or return a cached instance for the given type.
 
         Arguments:
             type (Type): The desired type
@@ -931,7 +969,7 @@ class Environment:
         provider = self.providers.get(type, None)
         if provider is None:
             Environment.logger.error("%s is not supported", type)
-            raise InjectorException(f"{type} is not supported")
+            raise DIRuntimeException(f"{type} is not supported")
 
         return provider.create(self)
 
@@ -981,6 +1019,7 @@ class AbstractCallableProcessor(LifecycleProcessor):
 
     # static data
 
+    lock = threading.RLock()
     callables : Dict[object, LifecycleCallable] = {}
     cache : Dict[Type, list[list[AbstractCallableProcessor.MethodCall]]] = {}
 
@@ -1018,8 +1057,11 @@ class AbstractCallableProcessor(LifecycleProcessor):
     def callables_for(cls, type: Type) -> list[list[AbstractCallableProcessor.MethodCall]]:
         callables = AbstractCallableProcessor.cache.get(type, None)
         if callables is None:
-            callables = AbstractCallableProcessor.compute_callables(type)
-            AbstractCallableProcessor.cache[type] = callables
+            with AbstractCallableProcessor.lock:
+                callables = AbstractCallableProcessor.cache.get(type, None)
+                if callables is None:
+                    callables = AbstractCallableProcessor.compute_callables(type)
+                    AbstractCallableProcessor.cache[type] = callables
 
         return callables
 
@@ -1164,7 +1206,7 @@ class SingletonScope(Scope):
                     self.value = provider.create(environment, *arg_provider())
 
         return self.value
-    
+
 @scope("thread")
 class ThreadScope(Scope):
     __slots__ = [
@@ -1185,17 +1227,17 @@ class ThreadScope(Scope):
 # internal class that is required to import technical instance providers
 
 @environment()
-class BootEnvironment:
+class Boot:
     # class
 
     environment = None
 
     @classmethod
-    def get_instance(cls):
-        if BootEnvironment.environment is None:
-            BootEnvironment.environment = Environment(BootEnvironment)
+    def get_environment(cls):
+        if Boot.environment is None:
+            Boot.environment = Environment(Boot)
 
-        return BootEnvironment.environment
+        return Boot.environment
 
     # properties
 

{aspyx-1.1.0 → aspyx-1.2.0}/src/aspyx/reflection/reflection.py

@@ -25,6 +25,9 @@ class DecoratorDescriptor:
         return f"@{self.decorator.__name__}({','.join(self.args)})"
 
 class Decorators:
+    """
+    Utility class that caches decorators ( Python does not have a feature for this )
+    """
     @classmethod
     def add(cls, func, decorator, *args):
         decorators = getattr(func, '__decorators__', None)
@@ -38,9 +41,17 @@ class Decorators:
         return getattr(func, '__decorators__', [])
 
 class TypeDescriptor:
+    """
+    This class provides a way to introspect Python classes, their methods, decorators, and type hints.
+    """
     # inner class
 
     class MethodDescriptor:
+        """
+        This class represents a method of a class, including its decorators, parameter types, and return type.
+        """
+        # constructor
+
         def __init__(self, cls, method: Callable):
             self.clazz = cls
             self.method = method
@@ -56,6 +67,8 @@ class TypeDescriptor:
 
             self.return_type = type_hints.get('return', None)
 
+        # public
+
         def get_decorator(self, decorator: Callable) -> Optional[DecoratorDescriptor]:
             for dec in self.decorators:
                 if dec.decorator is decorator:
@@ -82,6 +95,9 @@ class TypeDescriptor:
 
     @classmethod
     def for_type(cls, clazz: Type) -> TypeDescriptor:
+        """
+        Returns a TypeDescriptor for the given class, using a cache to avoid redundant introspection.
+        """
         descriptor = cls._cache.get(clazz)
         if descriptor is None:
             with cls._lock:
@@ -126,6 +142,9 @@ class TypeDescriptor:
     # public
 
     def get_decorator(self, decorator: Callable) -> Optional[DecoratorDescriptor]:
+        """
+        Returns the first decorator of the given type, or None if not found.
+        """
         for dec in self.decorators:
             if dec.decorator is decorator:
                 return dec
@@ -133,6 +152,8 @@ class TypeDescriptor:
         return None
 
     def has_decorator(self, decorator: Callable) -> bool:
+        """
+        Checks if the class has a decorator of the given type."""
         for dec in self.decorators:
             if dec.decorator is decorator:
                 return True
@@ -140,12 +161,20 @@ class TypeDescriptor:
         return False
 
     def get_methods(self, local = False) ->  list[TypeDescriptor.MethodDescriptor]:
+        """
+        Returns a list of MethodDescriptor objects for the class.
+        If local is True, only returns methods defined in the class itself, otherwise includes inherited methods.
+        """
         if local:
             return list(self.local_methods.values())
         else:
             return list(self.methods.values())
 
     def get_method(self, name: str, local = False) -> Optional[TypeDescriptor.MethodDescriptor]:
+        """
+        Returns a MethodDescriptor for the method with the given name.
+        If local is True, only searches for methods defined in the class itself, otherwise includes inherited methods.
+        """
         if local:
             return self.local_methods.get(name, None)
         else:

{aspyx-1.1.0 → aspyx-1.2.0/src/aspyx.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aspyx
-Version: 1.1.0
+Version: 1.2.0
 Summary: A DI and AOP library for Python
 Author-email: Andreas Ernst <andreas.ernst7@gmail.com>
 License: MIT License
@@ -192,9 +192,9 @@ The decorator accepts the keyword arguments
  - `singleton`  
    objects are created once inside an environment and cached. This is the default.
  - `request`  
-   obejcts are created on every injection request
+   objects are created on every injection request
  - `thread`  
-   objects are cerated and cached with respect to the current thread.
+   objects are created and cached with respect to the current thread.
 
  Other scopes - e.g. session related scopes - can be defined dynamically. Please check the corresponding chapter.
 
@@ -455,7 +455,7 @@ Both add the fluent methods:
 
 The fluent methods `named`, `matches` and `of_type` can be called multiple times!
 
-**Example**:
+**Example**: react on both `transactional` decorators on methods or classes
 
 ```python
 @injectable()
@@ -478,11 +478,13 @@ class Foo:
     def __init__(self):
         pass
 
-    @value("OS")
-    def inject_value(self, os: str):
+    @inject_value("HOME")
+    def inject_home(self, os: str):
         ...
 ```
 
+If required a coercion will be executed.
+
 This concept relies on a central object `ConfigurationManager` that stores the overall configuration values as provided by so called configuration sources that are defined as follows.
 
 ```python
@@ -494,14 +496,24 @@ class ConfigurationSource(ABC):
 
     @abstractmethod
     def load(self) -> dict:
-        pass
 ```
 
 The `load` method is able to return a tree-like structure by returning a `dict`.
 
-As a default environment variables are already supported.
+Configuration variables are retrieved with the method
+
+```python
+def get(self, path: str, type: Type[T], default : Optional[T]=None) -> T:
+ ```
+
+- `path`  
+  a '.' separated path
+- `type`  
+  the desired type
+- `default`  
+  a default, if no value is registered
 
-Other sources can be added dynamically by just registering them.
+Sources can be added dynamically by registering them.
 
 **Example**:
 ```python
@@ -521,6 +533,31 @@ class SampleConfigurationSource(ConfigurationSource):
             }
 ```
 
+Two specific source are already implemented:
+- `EnvConfigurationSource`  
+   reads the os environment variables
+- `YamlConfigurationSource`  
+   reads a specific yaml file
+
+Typically you create the required configuration sources in an environment class, e.g.
+
+```python
+@environment()
+class SampleEnvironment:
+    # constructor
+
+    def __init__(self):
+        pass
+
+    @create()
+    def create_env_source(self) -> EnvConfigurationSource:
+        return EnvConfigurationSource()
+
+    @create()
+    def create_yaml_source(self) -> YamlConfigurationSource:
+        return YamlConfigurationSource("config.yaml")
+```
+
 # Reflection
 
 As the library heavily relies on type introspection of classes and methods, a utility class `TypeDescriptor` is available that covers type information on classes. 
@@ -537,7 +574,7 @@ it offers the methods
 - `get_method(name: str, local=False)`  
    return a single either local or overall method
 - `has_decorator(decorator: Callable) -> bool`  
-   return `True`, if the class is decorated with the specified decrator
+   return `True`, if the class is decorated with the specified decorator
 - `get_decorator(decorator) -> Optional[DecoratorDescriptor]`  
    return a descriptor covering the decorator. In addition to the callable, it also stores the supplied args in the `args` property
 
@@ -545,9 +582,9 @@ The returned method descriptors offer:
 - `param_types`  
    list of arg types
 - `return_type`  
-   the retur type
+   the return type
 - `has_decorator(decorator: Callable) -> bool` 
-   return `True`, if the method is decorated with the specified decrator
+   return `True`, if the method is decorated with the specified decorator
 - `get_decorator(decorator: Callable) -> Optional[DecoratorDescriptor]`  
    return a descriptor covering the decorator. In addition to the callable, it also stores the supplied args in the `args` property
 
@@ -557,9 +594,9 @@ Whenver you define a custom decorator, you will need to register it accordingly.
 
 **Example**:
 ```python
-def transactional():
+def transactional(scope):
     def decorator(func):
-        Decorators.add(func, transactional)
+        Decorators.add(func, transactional, scope) # also add _all_ parameters in order to cache them
         return func
 
     return decorator
@@ -577,6 +614,10 @@ def transactional():
 - added `@on_running()` callback
 - added `thread` scope
 
+**1.2.0**
+
+- added `YamlConfigurationSource`
+
 
       
 

{aspyx-1.1.0 → aspyx-1.2.0}/src/aspyx.egg-info/SOURCES.txt

@@ -11,6 +11,8 @@ src/aspyx/di/aop/__init__.py
 src/aspyx/di/aop/aop.py
 src/aspyx/di/configuration/__init__.py
 src/aspyx/di/configuration/configuration.py
+src/aspyx/di/configuration/env_configuration_source.py
+src/aspyx/di/configuration/yaml_configuration_source.py
 src/aspyx/di/util/__init__.py
 src/aspyx/di/util/stringbuilder.py
 src/aspyx/reflection/__init__.py

{aspyx-1.1.0 → aspyx-1.2.0}/tests/test_configuration.py

@@ -4,17 +4,30 @@ Test cases for the Configuration system in aspyx.di
 from __future__ import annotations
 
 import unittest
+from pathlib import Path
 
-from aspyx.di.configuration import ConfigurationSource, ConfigurationManager, value
+from aspyx.di.configuration import ConfigurationSource, ConfigurationManager, value, EnvConfigurationSource, \
+    YamlConfigurationSource
 
-from aspyx.di import injectable, Environment, environment
+from aspyx.di import injectable, Environment, environment, create
 
 
 @environment()
 class SampleEnvironment:
+    # constructor
+
     def __init__(self):
         pass
 
+    @create()
+    def create_env_source(self) -> EnvConfigurationSource:
+        return EnvConfigurationSource()
+
+    @create()
+    def create_yaml_source(self) -> YamlConfigurationSource:
+        return YamlConfigurationSource(f"{Path(__file__).parent}/config.yaml"
+)
+
 @injectable()
 class SampleConfigurationSource1(ConfigurationSource):
     # constructor
@@ -67,6 +80,22 @@ class Foo:
 class TestConfiguration(unittest.TestCase):
     testEnvironment = Environment(SampleEnvironment)
 
+    def test_yaml(self):
+        env = TestConfiguration.testEnvironment
+
+        config = env.get(ConfigurationManager)
+
+        server = config.get("server.name", str)
+        self.assertEqual(server, "bla")
+
+    def test_env(self):
+        env = TestConfiguration.testEnvironment
+
+        config = env.get(ConfigurationManager)
+
+        os = config.get("HOME", str)
+        self.assertIsNotNone(os)
+
     def test_configuration(self):
         env = TestConfiguration.testEnvironment
 

{aspyx-1.1.0 → aspyx-1.2.0}/tests/test_di.py

@@ -8,8 +8,7 @@ import logging
 import unittest
 from typing import Dict
 
-from aspyx.di import InjectorException, injectable, on_init, on_running, on_destroy, inject_environment, inject, Factory, create, environment, Environment, PostProcessor, factory
-from aspyx.di.di import order, on_running
+from aspyx.di import DIException, injectable, order, on_init, on_running, on_destroy, inject_environment, inject, Factory, create, environment, Environment, PostProcessor, factory
 
 from .di_import import ImportedEnvironment
 
@@ -26,15 +25,16 @@ def configure_logging(levels: Dict[str, int]) -> None:
 
 #configure_logging({"aspyx": logging.DEBUG})
 
-# not here
-
-
 @injectable()
 @order(10)
 class SamplePostProcessor(PostProcessor):
     def process(self, instance: object, environment: Environment):
         pass #print(f"created a {instance}")
 
+class Baa:
+    def init(self):
+        pass
+
 class Foo:
     def __init__(self):
         self.inited = False
@@ -96,6 +96,10 @@ class Bar(Base):
         self.destroyed = False
         self.environment = None
 
+    @create()
+    def create_baa(self) -> Baa:
+        return Baa()
+
     @on_init()
     def init(self):
         self.inited = True
@@ -167,12 +171,12 @@ class TestDI(unittest.TestCase):
         self.assertEqual(type(base), Bar)
 
     def test_inject_ambiguous_class(self):
-        with self.assertRaises(InjectorException):
+        with self.assertRaises(DIException):
             env = TestDI.testEnvironment
             env.get(Ambiguous)
 
     def test_create_unknown(self):
-        with self.assertRaises(InjectorException):
+        with self.assertRaises(DIException):
             env = TestDI.testEnvironment
             env.get(Unknown)
 
@@ -197,7 +201,9 @@ class TestDI(unittest.TestCase):
     def test_create_factory(self):
         env = TestDI.testEnvironment
         baz = env.get(Baz)
+        baa= env.get(Baa)
         self.assertIsNotNone(baz)
+        self.assertIsNotNone(baa)
 
     def test_singleton(self):
         env = TestDI.testEnvironment

{aspyx-1.1.0 → aspyx-1.2.0}/tests/test_di_cycle.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 import unittest
 
 from aspyx.di import injectable, environment, Environment
-from aspyx.di.di import InjectorException
+from aspyx.di.di import DIException
 
 
 @injectable()
@@ -28,7 +28,7 @@ class SampleEnvironment:
 
 class TestCycle(unittest.TestCase):
     def test_cycle(self):
-        with self.assertRaises(InjectorException):
+        with self.assertRaises(DIException):
             Environment(SampleEnvironment)