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

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/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,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)

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/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.dist-info → aspyx-1.2.0.dist-info}/METADATA

@@ -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.2.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+aspyx/di/__init__.py,sha256=xdb2lsKh00uGMFCWYavhUEMGH15OSeAhUC-iSosqHqU,935
+aspyx/di/di.py,sha256=evfhTznmPNRDjamthSPisMpDhGZJdNmEREUhdJ9nsTE,35571
+aspyx/di/aop/__init__.py,sha256=nOABex49zSyMZ2w1ezwX3Q3yrOcQRSDjDtSj0DwKVbQ,233
+aspyx/di/aop/aop.py,sha256=3GKN6sGlsZbJ7_WSxQvHZNFYouAfU4Eq6H5cBBB_e_4,14455
+aspyx/di/configuration/__init__.py,sha256=mweJ3tZX1YJfY1d4ra-i0TWEcF3EwXBpGbHrKg1Kc6E,380
+aspyx/di/configuration/configuration.py,sha256=KfPjrlUhhmEOUxdJiXePt5RGxKc8JczkWqlEBjpWQTg,4362
+aspyx/di/configuration/env_configuration_source.py,sha256=Xh8g3AuQdgk89nG6GKA4iKILXaqHecD0KqMW2w91hXs,1445
+aspyx/di/configuration/yaml_configuration_source.py,sha256=LM-5J6IRxBBbBAjDeGIFsmiT-61WuGv1sU_zXWNzhkI,549
+aspyx/di/util/__init__.py,sha256=8H2yKkXu3nkRGeTerb8ialzKGfvzUx44XUWFUYcYuQM,125
+aspyx/di/util/stringbuilder.py,sha256=JywkLxZfaQUUWjSB5wvqA6a6Cfs3sW1jbaZ1z4U0-CQ,540
+aspyx/reflection/__init__.py,sha256=r2sNJrfHDpuqaIYu4fTYsoo046gpgn4VTd7bsS3mQJY,282
+aspyx/reflection/proxy.py,sha256=zJ6Psd6zWfFABdrKOf4cULt3gibyqCRdcR6z8WKIkzE,1982
+aspyx/reflection/reflection.py,sha256=2oYJKYysH3ULmTzbXdjGBCB1iaLbWh3IPKSnorVLshU,5719
+aspyx-1.2.0.dist-info/licenses/LICENSE,sha256=n4jfx_MNj7cBtPhhI7MCoB_K35cj1icP9yJ4Rh4vlvY,1070
+aspyx-1.2.0.dist-info/METADATA,sha256=wXSu9Clxg4ZZCoiRAhiZzAR1Wcqtjv4NZie4XilJNSs,19009
+aspyx-1.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aspyx-1.2.0.dist-info/top_level.txt,sha256=A_ZwhBY_ybIgjZlztd44eaOrWqkJAndiqjGlbJ3tR_I,6
+aspyx-1.2.0.dist-info/RECORD,,

aspyx-1.1.0.dist-info/RECORD

@@ -1,16 +0,0 @@
-aspyx/di/__init__.py,sha256=U2-4JnCmSO_IXCnN1jeig9nuWfJN__z9yRzl1WexQJk,927
-aspyx/di/di.py,sha256=VVLOXhTKJer2cV0rNEOqMLyMigsNMEQ7xoc-6M7a8wU,34296
-aspyx/di/aop/__init__.py,sha256=nOABex49zSyMZ2w1ezwX3Q3yrOcQRSDjDtSj0DwKVbQ,233
-aspyx/di/aop/aop.py,sha256=1RUgijk8RsiXWTizfNQX1IfHF7b96kCPdUgahX_J4Io,14457
-aspyx/di/configuration/__init__.py,sha256=Zw7h-OlbJD7LyJvzkgyF0EmVqra6oN_Pt0HuUdjTPTA,249
-aspyx/di/configuration/configuration.py,sha256=jJJSHRG2wOIvle23Xc8CQ4WM7lp_xCL8-ENVZO603uQ,5682
-aspyx/di/util/__init__.py,sha256=8H2yKkXu3nkRGeTerb8ialzKGfvzUx44XUWFUYcYuQM,125
-aspyx/di/util/stringbuilder.py,sha256=JywkLxZfaQUUWjSB5wvqA6a6Cfs3sW1jbaZ1z4U0-CQ,540
-aspyx/reflection/__init__.py,sha256=r2sNJrfHDpuqaIYu4fTYsoo046gpgn4VTd7bsS3mQJY,282
-aspyx/reflection/proxy.py,sha256=zJ6Psd6zWfFABdrKOf4cULt3gibyqCRdcR6z8WKIkzE,1982
-aspyx/reflection/reflection.py,sha256=HfPFd_FehTGmgF6NA-IJ_aHePE6GXM1ag7K3h8YIXjI,4600
-aspyx-1.1.0.dist-info/licenses/LICENSE,sha256=n4jfx_MNj7cBtPhhI7MCoB_K35cj1icP9yJ4Rh4vlvY,1070
-aspyx-1.1.0.dist-info/METADATA,sha256=rdeICMYyQSJmSZDJZrsdw6l5ZVrQrxvAPS_z47ObM-Y,17989
-aspyx-1.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aspyx-1.1.0.dist-info/top_level.txt,sha256=A_ZwhBY_ybIgjZlztd44eaOrWqkJAndiqjGlbJ3tR_I,6
-aspyx-1.1.0.dist-info/RECORD,,