aspyx 1.4.1__py3-none-any.whl → 1.5.1__py3-none-any.whl

aspyx/__init__.py

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

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

{aspyx-1.4.1.dist-info → aspyx-1.5.1.dist-info}/METADATA

@@ -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.dist-info → aspyx-1.5.1.dist-info}/RECORD

@@ -1,6 +1,6 @@
-aspyx/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-aspyx/di/__init__.py,sha256=BDOloIhmCIUJWC7l4PLtuiWS1LlWyitIofLCLcyXYpQ,1097
-aspyx/di/di.py,sha256=ozZanDcrmluzghQBqqD_vbav3Civ-V4R8XXwlBAM3MI,44068
+aspyx/__init__.py,sha256=MsSFjiLMLJZ7QhUPpVBWKiyDnCzryquRyr329NoCACI,2
+aspyx/di/__init__.py,sha256=AGVU2VBWQyBxSssvbk_GOKrYWIYtcmSoIlupz-Oqxi4,1138
+aspyx/di/di.py,sha256=O8FUZm68aimUbt7GnIc43XzRa47iFV8Qh696JGOwdEE,44703
 aspyx/di/aop/__init__.py,sha256=rn6LSpzFtUOlgaBATyhLRWBzFmZ6XoVKA9B8SgQzYEI,746
 aspyx/di/aop/aop.py,sha256=Cn-fqFW6PznVDM38fPX7mqlSpjGKMsgpJRBSYBv59xY,18403
 aspyx/di/configuration/__init__.py,sha256=flM9A79J2wfA5I8goQbxs4tTqYustR9tn_9s0YO2WJQ,484
@@ -10,16 +10,15 @@ aspyx/di/configuration/yaml_configuration_source.py,sha256=NDl3SeoLMNVlzHgfP-Ysv
 aspyx/di/threading/__init__.py,sha256=qrWdaq7MewQ2UmZy4J0Dn6BhY-ahfiG3xsv-EHqoqSE,191
 aspyx/di/threading/synchronized.py,sha256=BQ9PjMQUJsF5r-qWaDgvqg3AvFm_R9QZdKB49EkoelQ,1263
 aspyx/exception/__init__.py,sha256=OZwv-C3ZHD0Eg1rohCQMj575WLJ7lfYuk6PZD6sh1MA,211
-aspyx/exception/exception_manager.py,sha256=ihQ8Hs_EAUi-4xtVOn6kNZVblJjznpscLQ4vKXfWq7s,5228
+aspyx/exception/exception_manager.py,sha256=tv0nb0b2CFPiYWK6wwH9yI8hSc--9Xz9_xQVBwU42wc,5228
 aspyx/reflection/__init__.py,sha256=r2sNJrfHDpuqaIYu4fTYsoo046gpgn4VTd7bsS3mQJY,282
-aspyx/reflection/proxy.py,sha256=kaVPeEGuerdYgcgchMe99c8xykDskRSYR-w4OF83Ofo,1868
-aspyx/reflection/reflection.py,sha256=AgChenUzK9elcqOc_BfMiszTQuXrsy0NHYkqy9Jsl0E,8066
+aspyx/reflection/proxy.py,sha256=9zqzmK2HGGx7LxdiBw8MfKRNT8H03h_0I6Y972eKFH8,2582
+aspyx/reflection/reflection.py,sha256=HYzbzExG7jzdHG_AggrRxy9yte6Cl192dPsJBRl785Y,8939
 aspyx/threading/__init__.py,sha256=3clmbCDP37GPan3dWtxTQvpg0Ti4aFzruAbUClkHGi0,147
 aspyx/threading/thread_local.py,sha256=86dNtbA4k2B-rNUUnZgn3_pU0DAojgLrRnh8RL6zf1E,1196
 aspyx/util/__init__.py,sha256=8H2yKkXu3nkRGeTerb8ialzKGfvzUx44XUWFUYcYuQM,125
 aspyx/util/stringbuilder.py,sha256=a-0T4YEXSJFUuQ3ztKN1ZPARkh8dIGMSkNEEJHRN7dc,856
-aspyx-1.4.1.dist-info/licenses/LICENSE,sha256=n4jfx_MNj7cBtPhhI7MCoB_K35cj1icP9yJ4Rh4vlvY,1070
-aspyx-1.4.1.dist-info/METADATA,sha256=cEYH9P1Mng4RjRQID-bUp-5X6fbxUHhQWf3WDUwkPI0,26564
-aspyx-1.4.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aspyx-1.4.1.dist-info/top_level.txt,sha256=A_ZwhBY_ybIgjZlztd44eaOrWqkJAndiqjGlbJ3tR_I,6
-aspyx-1.4.1.dist-info/RECORD,,
+aspyx-1.5.1.dist-info/METADATA,sha256=U4sRH9owvFuCgQINKFlC84hL5BnQ-5kGavDNb-q8D88,26490
+aspyx-1.5.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+aspyx-1.5.1.dist-info/licenses/LICENSE,sha256=n4jfx_MNj7cBtPhhI7MCoB_K35cj1icP9yJ4Rh4vlvY,1070
+aspyx-1.5.1.dist-info/RECORD,,

{aspyx-1.4.1.dist-info → aspyx-1.5.1.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any
-

aspyx-1.4.1.dist-info/top_level.txt

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