aspyx 1.4.1__tar.gz → 1.5.1__tar.gz

aspyx-1.5.1/.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.4.1/src/aspyx.egg-info → aspyx-1.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aspyx
-Version: 1.4.1
+Version: 1.5.1
 Summary: A DI and AOP library for Python
 Author-email: Andreas Ernst <andreas.ernst7@gmail.com>
 License: MIT License
@@ -24,13 +24,11 @@ License: MIT License
         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
-License-File: LICENSE
-Provides-Extra: dev
-Requires-Dist: mkdocstrings-python; extra == "dev"
-Dynamic: license-file
 
 # aspyx
 
@@ -73,7 +71,7 @@ Dynamic: license-file
 
 While working on AI-related projects in Python, I was looking for a dependency injection (DI) framework. After evaluating existing options, my impression was that the most either lacked key features — such as integrated AOP — or had APIs that felt overly technical and complex, which made me develop a library on my own with the following goals
 
-- bring both di and AOP features together in a lightweight library ( still only about 2T loc),
+- bring both di and AOP features together in a lightweight library,
 - be as minimal invasive as possible,
 - offering mechanisms to easily extend and customize features without touching the core,
 - while still offering a _simple_ and _readable_ api that doesnt overwhelm developers and only requires a minimum initial learning curve
@@ -85,7 +83,7 @@ The AOP integration, in particular, makes a lot of sense because:
 
 # Overview
 
-Aspyx is a lightweight - still only about 2T LOC- Python library that provides both Dependency Injection (DI) and Aspect-Oriented Programming (AOP) support.
+Aspyx is a lightweight - still only about 2K LOC - Python library that provides both Dependency Injection (DI) and Aspect-Oriented Programming (AOP) support.
 
 The following DI features are supported 
 - constructor and setter injection
@@ -100,7 +98,7 @@ The following DI features are supported
 - lifecycle events methods `on_init`, `on_destroy`, `on_running`
 - Automatic discovery and bundling of injectable objects based on their module location, including support for recursive imports
 - Instantiation of one or possible more isolated container instances — called environments — each managing the lifecycle of a related set of objects,
- - Support for hierarchical environments, enabling structured scoping and layered object management.
+- Support for hierarchical environments, enabling structured scoping and layered object management.
 
 With respect to AOP:
 - support for before, around, after and error aspects 
@@ -839,7 +837,3 @@ class ExceptionAdvice:
 **1.4.1**
 
 - mkdocs
-
-
-      
-

{aspyx-1.4.1 → aspyx-1.5.1}/README.md

@@ -39,7 +39,7 @@
 
 While working on AI-related projects in Python, I was looking for a dependency injection (DI) framework. After evaluating existing options, my impression was that the most either lacked key features — such as integrated AOP — or had APIs that felt overly technical and complex, which made me develop a library on my own with the following goals
 
-- bring both di and AOP features together in a lightweight library ( still only about 2T loc),
+- bring both di and AOP features together in a lightweight library,
 - be as minimal invasive as possible,
 - offering mechanisms to easily extend and customize features without touching the core,
 - while still offering a _simple_ and _readable_ api that doesnt overwhelm developers and only requires a minimum initial learning curve
@@ -51,7 +51,7 @@ The AOP integration, in particular, makes a lot of sense because:
 
 # Overview
 
-Aspyx is a lightweight - still only about 2T LOC- Python library that provides both Dependency Injection (DI) and Aspect-Oriented Programming (AOP) support.
+Aspyx is a lightweight - still only about 2K LOC - Python library that provides both Dependency Injection (DI) and Aspect-Oriented Programming (AOP) support.
 
 The following DI features are supported 
 - constructor and setter injection
@@ -66,7 +66,7 @@ The following DI features are supported
 - lifecycle events methods `on_init`, `on_destroy`, `on_running`
 - Automatic discovery and bundling of injectable objects based on their module location, including support for recursive imports
 - Instantiation of one or possible more isolated container instances — called environments — each managing the lifecycle of a related set of objects,
- - Support for hierarchical environments, enabling structured scoping and layered object management.
+- Support for hierarchical environments, enabling structured scoping and layered object management.
 
 With respect to AOP:
 - support for before, around, after and error aspects 
@@ -805,7 +805,3 @@ class ExceptionAdvice:
 **1.4.1**
 
 - mkdocs
-
-
-      
-

aspyx-1.5.1/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "aspyx"
+version = "1.5.1"
+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.1/src/aspyx/__init__.py

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

{aspyx-1.4.1 → aspyx-1.5.1}/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.1}/src/aspyx/di/di.py

@@ -316,30 +316,44 @@ class EnvironmentInstanceProvider(AbstractInstanceProvider):
 
         self.environment = environment
         self.provider = provider
-        self.dependencies = []
+        self.dependencies : Optional[list[AbstractInstanceProvider]] = None # FOO
         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)
-
-        if not context.is_resolved(self):
-            context.provider_dependencies[self] = [] #?
+        if self.dependencies is None:
+            self.dependencies = []
+            context.push(self)
+            try:
+                type_and_params = self.provider.get_dependencies()
+                #params = type_and_params[1]
+                for type in type_and_params[0]:
+                    provider = context.require_provider(type)
 
-            type_and_params = self.provider.get_dependencies()
-            params = type_and_params[1]
-            for type in type_and_params[0]:
-                if params > 0:
-                    params -= 1
-                    self.dependencies.append(context.get_provider(type))
+                    self.dependencies.append(provider)
 
-                provider = context.add_provider_dependency(self, type)
-                if provider is not None:
                     provider.resolve(context)
-
-        else:
-            context.add(*context.get_provider_dependencies(self))
+            finally:
+                context.pop()
 
     def get_module(self) -> str:
         return self.provider.get_module()
@@ -403,7 +417,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 +449,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 +501,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__})"
@@ -545,69 +563,45 @@ class PostProcessor(LifecycleProcessor):
 
 class Providers:
     """
-    The Providers class is a static class that manages the registration and resolution of InstanceProviders.
+    The Providers class is a static class used in the context of the registration and resolution of InstanceProviders.
     """
     # local class
 
     class ResolveContext:
         __slots__ = [
-            "dependencies",
             "providers",
-            "provider_dependencies"
+            "path"
         ]
 
         # constructor
 
         def __init__(self, providers: Dict[Type, EnvironmentInstanceProvider]):
-            self.dependencies : list[EnvironmentInstanceProvider] = []
             self.providers = providers
-            self.provider_dependencies : dict[EnvironmentInstanceProvider, list[EnvironmentInstanceProvider]] = {}
+            self.path = []
 
         # public
 
-        def is_resolved(self, provider: EnvironmentInstanceProvider) -> bool:
-            return self.provider_dependencies.get(provider, None) is not None
-
-        def get_provider_dependencies(self, provider: EnvironmentInstanceProvider) -> list[EnvironmentInstanceProvider]:
-            return self.provider_dependencies[provider]
-
-        def add_provider_dependency(self, provider: EnvironmentInstanceProvider, type: Type) -> Optional[EnvironmentInstanceProvider]:
-            provider_dependencies = self.provider_dependencies.get(provider, None)
-            if provider_dependencies is None:
-                provider_dependencies = []
-                self.provider_dependencies[provider] = provider_dependencies
+        def push(self, provider):
+            self.path.append(provider)
 
-            provider = self.get_provider(type)
+        def pop(self):
+            self.path.pop()
 
-            if any(issubclass(provider.get_type(), dependency.get_type()) for dependency in provider_dependencies):
-                return None
-
-            provider_dependencies.append(provider)
-
-            return provider
-
-        def next(self):
-            self.dependencies.clear()
-
-        def get_provider(self, type: Type) -> EnvironmentInstanceProvider:
+        def require_provider(self, type: Type) -> EnvironmentInstanceProvider:
             provider = self.providers.get(type, None)
             if provider is None:
                 raise DIRegistrationException(f"Provider for {type} is not defined")
 
-            return provider
+            if provider in self.path:
+                raise DIRegistrationException(self.cycle_report(provider))
 
-        def add(self, *providers: EnvironmentInstanceProvider):
-            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 DIRegistrationException(self.cycle_report(provider))
-
-                self.dependencies.append(provider)
+            return provider
 
         def cycle_report(self, provider: AbstractInstanceProvider):
             cycle = ""
 
             first = True
-            for p in self.dependencies:
+            for p in self.path:
                 if not first:
                     cycle += " -> "
 
@@ -638,6 +632,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 +650,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 +706,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
 
@@ -747,7 +748,6 @@ class Providers:
         provider_context = Providers.ResolveContext(providers)
         for provider in mapped.values():
             provider.resolve(provider_context)
-            provider_context.next() # clear dependencies
 
         # done
 
@@ -763,8 +763,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 +938,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
     ```
@@ -976,6 +975,11 @@ class Environment:
             parent (Optional[Environment]): Optional parent environment, whose objects are inherited.
         """
 
+        def add_provider(type: Type, provider: AbstractInstanceProvider):
+            Environment.logger.debug("\tadd provider %s for %s", provider, type)
+
+            self.providers[type] = provider
+
         Environment.logger.debug("create environment for class %s", env.__qualname__)
 
         # initialize
@@ -996,9 +1000,11 @@ class Environment:
             for provider_type, inherited_provider in self.parent.providers.items():
                 if inherited_provider.get_scope() == "environment":
                     # replace with own environment instance provider
-                    self.providers[provider_type] = EnvironmentInstanceProvider(self, cast(EnvironmentInstanceProvider, inherited_provider).provider)
+                    provider = EnvironmentInstanceProvider(self, cast(EnvironmentInstanceProvider, inherited_provider).provider)
+                    provider.dependencies = [] # ??
+                    add_provider(provider_type, provider)
                 else:
-                    self.providers[provider_type] = inherited_provider
+                    add_provider(provider_type, inherited_provider)
 
             # inherit processors as is unless they have an environment scope
 
@@ -1019,16 +1025,35 @@ class Environment:
 
         loaded = set()
 
-        def add_provider(type: Type, provider: AbstractInstanceProvider):
-            Environment.logger.debug("\tadd provider %s for %s", provider, type)
-
-            self.providers[type] = provider
-
         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)
+
+            # 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 module.__package__
+            return package or ''
 
         def import_package(name: str):
             """Import a package and all its submodules recursively."""

{aspyx-1.4.1 → aspyx-1.5.1}/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: