aspyx 1.4.1__tar.gz → 1.5.0__tar.gz

aspyx-1.5.0/.gitignore

@@ -0,0 +1,194 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the enitre vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore

aspyx-1.5.0/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: aspyx
+Version: 1.5.0
+Summary: A DI and AOP library for Python
+Author-email: Andreas Ernst <andreas.ernst7@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 Andreas Ernst
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Requires-Python: >=3.9
+Requires-Dist: python-dotenv~=1.1.0
+Requires-Dist: pyyaml~=6.0.2
+Description-Content-Type: text/markdown
+
+aspyx

aspyx-1.5.0/README.md

@@ -0,0 +1 @@
+aspyx

aspyx-1.5.0/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "aspyx"
+version = "1.5.0"
+description = "A DI and AOP library for Python"
+authors = [{ name = "Andreas Ernst", email = "andreas.ernst7@gmail.com" }]
+readme = "README.md"
+license = { file = "LICENSE" }
+requires-python = ">=3.9"
+dependencies = [
+    "python-dotenv~=1.1.0",
+    "pyyaml~=6.0.2"
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build]
+source = "src"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/aspyx"]

aspyx-1.5.0/src/aspyx/__init__.py

@@ -0,0 +1 @@
+#

{aspyx-1.4.1 → aspyx-1.5.0}/src/aspyx/di/__init__.py

@@ -1,7 +1,7 @@
 """
 This module provides dependency injection and aop capabilities for Python applications.
 """
-from .di import conditional, requires_class, requires_feature, DIException, AbstractCallableProcessor, LifecycleCallable, Lifecycle, Providers, Environment, ClassInstanceProvider, injectable, factory, module, inject, order, create, on_init, on_running, on_destroy, inject_environment, Factory, PostProcessor
+from .di import InstanceProvider, conditional, requires_class, requires_feature, DIException, AbstractCallableProcessor, LifecycleCallable, Lifecycle, Providers, Environment, ClassInstanceProvider, injectable, factory, module, inject, order, create, on_init, on_running, on_destroy, inject_environment, Factory, PostProcessor
 
 # import something from the subpackages, so that the decorators are executed
 
@@ -21,7 +21,7 @@ __all__ = [
     "inject",
     "create",
     "order",
-
+    "InstanceProvider",
     "on_init",
     "on_running",
     "on_destroy",

{aspyx-1.4.1 → aspyx-1.5.0}/src/aspyx/di/di.py

@@ -316,13 +316,32 @@ class EnvironmentInstanceProvider(AbstractInstanceProvider):
 
         self.environment = environment
         self.provider = provider
-        self.dependencies = []
+        self.dependencies : list[AbstractInstanceProvider] = []
         self.scope_instance = Scopes.get(provider.get_scope(), environment)
 
+    # public
+
+    def print_tree(self, prefix=""):
+        children = self.dependencies
+        last_index = len(children) - 1
+        print(prefix + "+- " + self.report())
+
+        for i, child in enumerate(children):
+            if i == last_index:
+                # Last child
+                child_prefix = prefix + "   "
+            else:
+                # Not last child
+                child_prefix = prefix + "|  "
+
+
+            cast(EnvironmentInstanceProvider, child).print_tree(child_prefix)
+
     # implement
 
     def resolve(self, context: Providers.ResolveContext):
         context.add(self)
+        context.push(self)
 
         if not context.is_resolved(self):
             context.provider_dependencies[self] = [] #?
@@ -332,7 +351,7 @@ class EnvironmentInstanceProvider(AbstractInstanceProvider):
             for type in type_and_params[0]:
                 if params > 0:
                     params -= 1
-                    self.dependencies.append(context.get_provider(type))
+                    self.dependencies.append(context.get_provider(type)) # try/catch TODO
 
                 provider = context.add_provider_dependency(self, type)
                 if provider is not None:
@@ -341,6 +360,8 @@ class EnvironmentInstanceProvider(AbstractInstanceProvider):
         else:
             context.add(*context.get_provider_dependencies(self))
 
+        context.pop()
+
     def get_module(self) -> str:
         return self.provider.get_module()
 
@@ -403,7 +424,11 @@ class ClassInstanceProvider(InstanceProvider):
         for method in TypeDescriptor.for_type(self.type).get_methods():
             if method.has_decorator(inject):
                 for param in method.param_types:
+                    if not Providers.is_registered(param):
+                        raise DIRegistrationException(f"{self.type.__name__}.{method.method.__name__} declares an unknown parameter type {param.__name__}")
+
                     types.append(param)
+        # done
 
         return types, self.params
 
@@ -431,28 +456,28 @@ class FunctionInstanceProvider(InstanceProvider):
 
     # constructor
 
-    def __init__(self, clazz : Type, method, return_type : Type[T], eager = True, scope = "singleton"):
-        super().__init__(clazz, return_type, eager, scope)
+    def __init__(self, clazz : Type, method: TypeDescriptor.MethodDescriptor, eager = True, scope = "singleton"):
+        super().__init__(clazz, method.return_type, eager, scope)
 
-        self.method = method
+        self.method : TypeDescriptor.MethodDescriptor = method
 
     # implement
 
     def get_dependencies(self) -> (list[Type],int):
-        return [self.host], 1
+        return [self.host, *self.method.param_types], 1 + len(self.method.param_types)
 
     def create(self, environment: Environment, *args):
         Environment.logger.debug("%s create class %s", self, self.type.__qualname__)
 
-        instance = self.method(*args) # args[0]=self
+        instance = self.method.method(*args) # args[0]=self
 
         return environment.created(instance)
 
     def report(self) -> str:
-        return f"{self.host.__name__}.{self.method.__name__}"
+        return f"{self.host.__name__}.{self.method.get_name()}({', '.join(t.__name__ for t in self.method.param_types)}) -> {self.type.__qualname__}"
 
     def __str__(self):
-        return f"FunctionInstanceProvider({self.host.__name__}.{self.method.__name__} -> {self.type.__name__})"
+        return f"FunctionInstanceProvider({self.host.__name__}.{self.method.get_name()}({', '.join(t.__name__ for t in self.method.param_types)}) -> {self.type.__name__})"
 
 class FactoryInstanceProvider(InstanceProvider):
     """
@@ -483,7 +508,7 @@ class FactoryInstanceProvider(InstanceProvider):
         return environment.created(args[0].create())
 
     def report(self) -> str:
-        return f"{self.host.__name__}.create"
+        return f"{self.host.__name__}.create() -> {self.type.__name__} "
 
     def __str__(self):
         return f"FactoryInstanceProvider({self.host.__name__} -> {self.type.__name__})"
@@ -553,7 +578,8 @@ class Providers:
         __slots__ = [
             "dependencies",
             "providers",
-            "provider_dependencies"
+            "provider_dependencies",
+            "path"
         ]
 
         # constructor
@@ -561,6 +587,7 @@ class Providers:
         def __init__(self, providers: Dict[Type, EnvironmentInstanceProvider]):
             self.dependencies : list[EnvironmentInstanceProvider] = []
             self.providers = providers
+            self.path = []
             self.provider_dependencies : dict[EnvironmentInstanceProvider, list[EnvironmentInstanceProvider]] = {}
 
         # public
@@ -586,7 +613,14 @@ class Providers:
 
             return provider
 
+        def push(self, provider):
+            self.path.append(provider)
+
+        def pop(self):
+            self.path.pop()
+
         def next(self):
+            self.path.clear()
             self.dependencies.clear()
 
         def get_provider(self, type: Type) -> EnvironmentInstanceProvider:
@@ -607,7 +641,7 @@ class Providers:
             cycle = ""
 
             first = True
-            for p in self.dependencies:
+            for p in self.path:
                 if not first:
                     cycle += " -> "
 
@@ -638,6 +672,10 @@ class Providers:
         else:
             candidates.append(provider)
 
+    @classmethod
+    def is_registered(cls,type: Type) -> bool:
+        return Providers.providers.get(type, None) is not None
+
     # add factories lazily
 
     @classmethod
@@ -652,7 +690,7 @@ class Providers:
         cache: Dict[Type,AbstractInstanceProvider] = {}
 
         context: ConditionContext = {
-            "requires_feature": lambda feature : environment.has_feature(feature),
+            "requires_feature": environment.has_feature,
             "requires_class": lambda clazz : cache.get(clazz, None) is not None # ? only works if the class is in the cache already?
         }
 
@@ -708,10 +746,13 @@ class Providers:
                 if type is provider.get_type():
                     raise ProviderCollisionException(f"type {type.__name__} already registered", existing_provider, provider)
 
-                if isinstance(existing_provider, AmbiguousProvider):
-                    cast(AmbiguousProvider, existing_provider).add_provider(provider)
-                else:
-                    cache[type] = AmbiguousProvider(type, existing_provider, provider)
+                if existing_provider.get_type() is not type:
+                    # only overwrite if the existing provider is not specific
+
+                    if isinstance(existing_provider, AmbiguousProvider):
+                        cast(AmbiguousProvider, existing_provider).add_provider(provider)
+                    else:
+                        cache[type] = AmbiguousProvider(type, existing_provider, provider)
 
             # recursion
 
@@ -763,8 +804,7 @@ def register_factories(cls: 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]))
+            Providers.register(FunctionInstanceProvider(cls, method, create_decorator.args[0], create_decorator.args[1]))
 def order(prio = 0):
     def decorator(cls):
         Decorators.add(cls, order, prio)
@@ -939,12 +979,12 @@ class Environment:
     class Foo:
         def __init__(self):
 
-    @environment()
-    class SimpleEnvironment:
+    @module()
+    class Module:
         def __init__(self):
             pass
 
-    environment = Environment(SimpleEnvironment)
+    environment = Environment(Module)
 
     foo = environment.get(Foo)  # will create an instance of Foo
     ```
@@ -1026,9 +1066,33 @@ class Environment:
 
         def get_type_package(type: Type):
             module_name = type.__module__
-            module = sys.modules[module_name]
+            module = sys.modules.get(module_name)
+
+            if not module:
+                raise ImportError(f"Module {module_name} not found")
+
+            # Try to get the package
+
+            package = getattr(module, '__package__', None)
 
-            return module.__package__
+            # Fallback: if module is __main__, try to infer from the module name if possible
+
+            if not package:
+                if module_name == '__main__':
+                    # Try to resolve real name via __file__
+                    path = getattr(module, '__file__', None)
+                    if path:
+                        Environment.logger.warning(
+                            "Module is __main__; consider running via -m to preserve package context")
+                    return ''
+
+                # Try to infer package name from module name
+
+                parts = module_name.split('.')
+                if len(parts) > 1:
+                    return '.'.join(parts[:-1])
+
+            return package or ''
 
         def import_package(name: str):
             """Import a package and all its submodules recursively."""
@@ -1106,6 +1170,9 @@ class Environment:
         # construct eager objects for local providers
 
         for provider in set(self.providers.values()):
+            if isinstance(provider, EnvironmentInstanceProvider):
+                provider.print_tree()
+
             if provider.is_eager():
                 provider.create(self)
 

{aspyx-1.4.1 → aspyx-1.5.0}/src/aspyx/exception/exception_manager.py

@@ -155,7 +155,7 @@ class ExceptionManager:
 
         # chain
 
-        for i in range(0, len(chain) - 2):
+        for i in range(0, len(chain) - 1):
             chain[i].next = chain[i + 1]
 
         if len(chain) > 0:

{aspyx-1.4.1 → aspyx-1.5.0}/src/aspyx/reflection/proxy.py

@@ -1,7 +1,8 @@
 """
 Dynamic proxies for method interception and delegation.
 """
-from typing import Generic, TypeVar, Type
+import inspect
+from typing import Generic, TypeVar, Type, Callable
 
 T = TypeVar("T")
 
@@ -28,9 +29,18 @@ class DynamicProxy(Generic[T]):
     # inner class
 
     class Invocation:
-        def __init__(self, type: Type[T], name: str, *args, **kwargs):
+        __slots__ = [
+            "type",
+            "method",
+            "args",
+            "kwargs",
+        ]
+
+        # constructor
+
+        def __init__(self, type: Type[T], method: Callable, *args, **kwargs):
             self.type = type
-            self.name = name
+            self.method = method
             self.args = args
             self.kwargs = kwargs
 
@@ -38,12 +48,20 @@ class DynamicProxy(Generic[T]):
         def invoke(self, invocation: 'DynamicProxy.Invocation'):
             pass
 
+        async def invoke_async(self, invocation: 'DynamicProxy.Invocation'):
+            return self.invoke(invocation)
+
     # class methods
 
     @classmethod
     def create(cls, type: Type[T], invocation_handler: 'DynamicProxy.InvocationHandler') -> T:
         return DynamicProxy(type, invocation_handler)
 
+    __slots__ = [
+        "type",
+        "invocation_handler"
+    ]
+
     # constructor
 
     def __init__(self, type: Type[T], invocation_handler: 'DynamicProxy.InvocationHandler'):
@@ -53,7 +71,16 @@ class DynamicProxy(Generic[T]):
     # public
 
     def __getattr__(self, name):
-        def wrapper(*args, **kwargs):
-            return self.invocation_handler.invoke(DynamicProxy.Invocation(self.type, name, *args, **kwargs))
+        method = getattr(self.type, name)
+
+        if  inspect.iscoroutinefunction(method):
+            async def async_wrapper(*args, **kwargs):
+                return  await self.invocation_handler.invoke_async(DynamicProxy.Invocation(self.type, method, *args, **kwargs))
+
+            return async_wrapper
+
+        else:
+            def sync_wrapper(*args, **kwargs):
+                return self.invocation_handler.invoke(DynamicProxy.Invocation(self.type, method, *args, **kwargs))
 
-        return wrapper
+            return sync_wrapper

{aspyx-1.4.1 → aspyx-1.5.0}/src/aspyx/reflection/reflection.py

@@ -5,8 +5,10 @@ including their methods, decorators, and type hints. It supports caching for per
 from __future__ import annotations
 
 import inspect
-from inspect import signature, getmembers
+from inspect import signature
 import threading
+from types import FunctionType
+
 from typing import Callable, get_type_hints, Type, Dict, Optional
 from weakref import WeakKeyDictionary
 
@@ -25,7 +27,7 @@ class DecoratorDescriptor:
         self.args = args
 
     def __str__(self):
-        return f"@{self.decorator.__name__}({','.join(self.args)})"
+        return f"@{self.decorator.__name__}({', '.join(map(str, self.args))})"
 
 class Decorators:
     """
@@ -59,6 +61,14 @@ class Decorators:
         """
         return any(decorator.decorator is callable for decorator in Decorators.get(func_or_class))
 
+    @classmethod
+    def get_decorator(cls, func_or_class, callable: Callable) -> DecoratorDescriptor:
+        return next((decorator for decorator in Decorators.get_all(func_or_class) if decorator.decorator is callable), None)
+
+    @classmethod
+    def get_all(cls, func_or_class) -> list[DecoratorDescriptor]:
+        return getattr(func_or_class, '__decorators__', [])
+
     @classmethod
     def get(cls, func_or_class) -> list[DecoratorDescriptor]:
         """
@@ -67,9 +77,14 @@ class Decorators:
             func_or_class: the function or class
 
         Returns:
-            list[DecoratorDescriptor]: ths list
+            list[DecoratorDescriptor]: the list
         """
-        return getattr(func_or_class, '__decorators__', [])
+        if inspect.ismethod(func_or_class):
+            func_or_class = func_or_class.__func__  # unwrap bound method
+
+        #return getattr(func_or_class, '__decorators__', []) will return inherited as well
+        return func_or_class.__dict__.get('__decorators__', [])
+
 
 class TypeDescriptor:
     """
@@ -130,6 +145,9 @@ class TypeDescriptor:
             """
             return inspect.iscoroutinefunction(self.method)
 
+        def get_decorators(self) -> list[DecoratorDescriptor]:
+            return self.decorators
+
         def get_decorator(self, decorator: Callable) -> Optional[DecoratorDescriptor]:
             """
             return the DecoratorDescriptor - if any - associated with the passed Callable
@@ -212,10 +230,16 @@ class TypeDescriptor:
     # internal
 
     def _get_local_members(self, cls):
+        #return [
+        #    (name, value)
+        #    for name, value in getmembers(cls, predicate=inspect.isfunction)
+        #    if name in cls.__dict__
+        #]
+
         return [
-            (name, value)
-            for name, value in getmembers(cls, predicate=inspect.isfunction)
-            if name in cls.__dict__
+            (name, attr)
+            for name, attr in cls.__dict__.items()
+            if isinstance(attr, FunctionType)
         ]
 
     # public