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

{aspyx-1.2.0.dist-info → aspyx-1.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aspyx
-Version: 1.2.0
+Version: 1.4.0
 Summary: A DI and AOP library for Python
 Author-email: Andreas Ernst <andreas.ernst7@gmail.com>
 License: MIT License
@@ -28,6 +28,8 @@ License: MIT License
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: mkdocstrings-python; extra == "dev"
 Dynamic: license-file
 
 # aspyx
@@ -37,15 +39,19 @@ Dynamic: license-file
 ![Python Versions](https://img.shields.io/badge/python-3.9%20|%203.10%20|%203.11%20|%203.12-blue)
 ![License](https://img.shields.io/github/license/coolsamson7/aspyx)
 ![coverage](https://img.shields.io/badge/coverage-94%25-brightgreen)
+[![PyPI](https://img.shields.io/pypi/v/aspyx)](https://pypi.org/project/aspyx/)
+[![Docs](https://img.shields.io/badge/docs-online-blue?logo=github)](https://coolsamson7.github.io/aspyx/)
 
-## Table of Contents
+## Table of Contents 
 
-- [Introduction](#aspyx)
+- [Motivation](#motivation)
+- [Introduction](#introduction)
 - [Installation](#installation)
 - [Registration](#registration)
   - [Class](#class)
   - [Class Factory](#class-factory)
   - [Method](#method)
+  - [Conditional](#conditional)
 - [Environment](#environment)
   - [Definition](#definition)
   - [Retrieval](#retrieval)
@@ -55,27 +61,48 @@ Dynamic: license-file
   - [Post Processors](#post-processors)
 - [Custom scopes](#custom-scopes)
 - [AOP](#aop)
+- [Threading](#threading)
 - [Configuration](#configuration)
 - [Reflection](#reflection)
+- [Exceptions](#exceptions)
 - [Version History](#version-history)
 
+# Motivation
+
+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,
+- 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
+
+Especially the AOP integration definitely makes sense, as aspects on their own also usually require a context, which in a DI world is simply injected.
+
 # Introduction
 
-Aspyx is a small python libary, that adds support for both dependency injection and aop.
+Aspyx is a lightweight Python library that provides both Dependency Injection (DI) and Aspect-Oriented Programming (AOP) support.
 
-The following features are supported 
+The following DI features are supported 
 - constructor and setter injection
+- injection of configuration variables
+- possibility to define custom injections
 - post processors
-- factory classes and methods
-- support for eager construction
-- support for singleton and request scopes
-- possibilty to add custom scopes
-- lifecycle events methods
-- bundling of injectable object sets by environment classes including recursive imports and inheritance
-- container instances that relate to environment classes and manage the lifecylce of related objects
+- support for factory classes and methods
+- support for eager and lazy construction
+- support for scopes singleton, request and thread
+- possibility to add custom scopes
+- conditional registration of classes and factories ( aka profiles in spring )
+- lifecycle events methods `on_init`, `on_destroy`, `on_running`
+- bundling of injectable objects according to their module location including recursive imports and inheritance
+- instantiation of - possibly multiple - container instances - so called environments - that manage the lifecycle of related objects
 - hierarchical environments
 
-The library is thread-safe!
+With respect to AOP:
+- support for before, around, after and error aspects 
+- simple fluent interface to specify which methods are targeted by an aspect
+- sync and async method support
+
+The library is thread-safe and heavily performance optimized as most of the runtime information is precomputed and cached!
 
 Let's look at a simple example
 
@@ -87,7 +114,7 @@ class Foo:
     def __init__(self):
         pass
 
-    def hello(msg: str):
+    def hello(self, msg: str):
         print(f"hello {msg}")
 
 @injectable()  # eager and singleton by default
@@ -108,16 +135,18 @@ class SampleEnvironment:
     def __init__(self):
         pass
 
-# go, forrest
+# create environment
 
 environment = Environment(SampleEnvironment)
 
+# fetch an instance
+
 bar = env.get(Bar)
 
 bar.foo.hello("world")
 ```
 
-The concepts should be pretty familiar as well as the names which are a combination of Spring and Angular names :-)
+The concepts should be pretty familiar as well as the names as they are inspired by both Spring and Angular.
 
 Let's add some aspects...
 
@@ -130,17 +159,15 @@ class SampleAdvice:
 
     @before(methods().named("hello").of_type(Foo))
     def call_before(self, invocation: Invocation):
-        print("before Foo.hello(...)")
+        ...
 
     @error(methods().named("hello").of_type(Foo))
     def call_error(self, invocation: Invocation):
-        print("error Foo.hello(...)")
-        print(invocation.exception)
+        ... # exception accessible in invocation.exception
 
     @around(methods().named("hello"))
     def call_around(self, invocation: Invocation):
-        print("around Foo.hello()")
-
+        ...
         return invocation.proceed()
 ```
 
@@ -155,11 +182,11 @@ Let's look at the details
 
 # Installation
 
-`pip install aspyx`
+Just install from PyPI with 
 
-The library is tested with all Python version > 3.9
+`pip install aspyx`
 
-Ready to go...
+The library is tested with all Python version >= 3.9
 
 # Registration
 
@@ -177,8 +204,8 @@ class Foo:
     def __init__(self):
         pass
 ```
-Please make sure, that the class defines a local constructor, as this is required to determine injected instances. 
-All referenced types will be injected by the environemnt. 
+⚠️ **Attention:** Please make sure, that the class defines a local constructor, as this is _required_ to determine injected instances. 
+All referenced types will be injected by the environment. 
 
 Only eligible types are allowed, of course!
 
@@ -233,6 +260,22 @@ class Foo:
 
  The same arguments as in `@injectable` are possible.
 
+## Conditional
+
+All `@injectable` declarations can be supplemented with 
+
+```python
+@conditional(<condition>, ..., <condition>)
+```
+
+decorators that act as filters in the context of an environment.
+
+Valid conditions are created by:
+- `requires_class(clazz: Type)`  
+  the injectable is valid, if the specified class is registered as well.
+- `requires_feature(feature: str)`  
+  the injectable is valid, if the environment defines the specified feature.
+
 # Environment
 
 ## Definition
@@ -250,13 +293,35 @@ environment = Environment(SampleEnvironment)
 ```
 
 The default is that all eligible classes, that are implemented in the containing module or in any submodule will be managed.
+THe container will import the module and its children automatically. No need to add artificial import statements!
+
+
+By adding the parameter `features: list[str]`, it is possible to filter injectables by evaluating the corresponding `@conditional` decorators.
+
+**Example**: 
+```python
+
+@injectable()
+@conditional(requires_feature("dev"))
+class DevOnly:
+     def __init__(self):
+        pass
+
+@environment()
+class SampleEnvironmen():
+    def __init__(self):
+        pass
+
+environment = Environment(SampleEnvironment, features=["dev"])
+```
+
 
 By adding an `imports: list[Type]` parameter, specifying other environment types, it will register the appropriate classes recursively.
 
 **Example**: 
 ```python
 @environment()
-class SampleEnvironmen(imports=[OtherEnvironment])):
+class SampleEnvironmen(imports=[OtherEnvironment]):
     def __init__(self):
         pass
 ```
@@ -289,7 +354,7 @@ The container knows about class hierarchies and is able to `get` base classes, a
 
 In case of ambiguities, it will throw an exception.
 
-Please be aware, that a base class are not _required_ to be annotated with `@injectable`, as this would mean, that it could be created on its own as well. ( Which is possible as well, btw. ) 
+Note that a base class are not _required_ to be annotated with `@injectable`, as this would mean, that it could be created on its own as well. ( Which is possible as well, btw. ) 
 
 # Instantiation logic
 
@@ -302,7 +367,7 @@ Constructing a new instance involves a number of steps executed in this order
   different decorators can mark methods that should be called during the lifecycle ( here the construction ) of an instance.
   These are various injection possibilities as well as an optional final `on_init` call
 - PostProcessors  
-  Any custom post processors, that can add isde effects or modify the instances
+  Any custom post processors, that can add side effects or modify the instances
 
 ## Injection methods
 
@@ -337,7 +402,7 @@ It is possible to mark specific lifecyle methods.
 - `@on_init()` 
    called after the constructor and all other injections.
 - `@on_running()` 
-   called an environment has initialized all eager objects.
+   called after an environment has initialized completely ( e.g. created all eager objects ).
 - `@on_destroy()` 
    called during shutdown of the environment
 
@@ -355,7 +420,7 @@ class SamplePostProcessor(PostProcessor):
 
 Any implementing class of `PostProcessor` that is eligible for injection will be called by passing the new instance.
 
-Please be aware, that a post processor will only handle instances _after_ its _own_ registration.
+Note that a post processor will only handle instances _after_ its _own_ registration.
 
 As injectables within a single file will be handled in the order as they are declared, a post processor will only take effect for all classes after its declaration!
 
@@ -372,7 +437,7 @@ def get(self, provider: AbstractInstanceProvider, environment: Environment, argP
 Arguments are:
 - `provider` the actual provider that will create an instance
 - `environment`the requesting environment
-- `argPovider` a function that can be called to compute the required arguments recursively
+- `argProvider` a function that can be called to compute the required arguments recursively
 
 **Example**: The simplified code of the singleton provider ( disregarding locking logic )
 
@@ -397,49 +462,74 @@ class SingletonScope(Scope):
 
 # AOP
 
-It is possible to define different Aspects, that will be part of method calling flow. This logic fits nicely in the library, since the DI framework controls the instantiation logic and can handle aspects within a regular post processor. 
+It is possible to define different aspects, that will be part of method calling flow. This logic fits nicely in the library, since the DI framework controls the instantiation logic and can handle aspects within a regular post processor. 
 
 Advice classes need to be part of classes that add a `@advice()` decorator and can define methods that add aspects.
 
 ```python
-@advice()
+@advice
 class SampleAdvice:
     def __init__(self):  # could inject dependencies
         pass
 
     @before(methods().named("hello").of_type(Foo))
     def call_before(self, invocation: Invocation):
-        # arguments: invocation.args
-        print("before Foo.hello(...)")
+        # arguments: invocation.args and invocation.kwargs
+        ...
+
+     @after(methods().named("hello").of_type(Foo))
+    def call_after(self, invocation: Invocation):
+        # arguments: invocation.args and invocation.kwargs
+        ...
 
     @error(methods().named("hello").of_type(Foo))
     def call_error(self, invocation: Invocation):
-        print("error Foo.hello(...)")
-        print(invocation.exception)
+         # error: invocation.exception
+        ...
 
     @around(methods().named("hello"))
     def call_around(self, invocation: Invocation):
-        print("around Foo.hello()")
-
-        return invocation.proceed()  # will leave a result in invocation.result or invocation.exception in case of an exception
+        try:
+            ...
+            return invocation.proceed()  # will leave a result in invocation.result or invocation.exception in case of an exception
+        finally:
+            ...
 ```
 
 Different aspects - with the appropriate decorator - are possible:
 - `before`  
    methods that will be executed _prior_ to the original method
 - `around`  
-   methods that will be executed _around_ to the original method giving it the possibility add side effects or even change the parameters.
+   methods that will be executed _around_ to the original method allowing you to add side effects or even modify parameters.
 - `after`  
-    methods that will be executed _after_ to the original method
+   methods that will be executed _after_ to the original method
 - `error`  
-   methods that will be executed in case of a caught exception, which can be retrieved by `invocation.exception`
+   methods that will be executed in case of a caught exception
+
+The different aspects can be supplemented with an `@order(<prio>)` decorator that controls the execution order based on the passed number. Smaller values get executed first. 
+
+All methods are expected to have single `Invocation` parameter, that stores
+
+- `func` the target function
+- `args` the supplied args ( including the `self` instance as the first element)
+- `kwargs` the keywords args
+- `result` the result ( initially `None`)
+- `exception` a possible caught exception ( initially `None`)
 
-All methods are expected to hava single `Invocation` parameter, that stores, the function, args and kwargs, the return value and possible exceptions.
+⚠️ **Attention:** It is essential for `around` methods to call `proceed()` on the invocation, which will call the next around method in the chain and finally the original method.
 
-It is essential for `around` methods to call `proceed()` on the invocation, which will call the next around method in the chain and finally the original method.
 If the `proceed` is called with parameters, they will replace the original parameters! 
 
-The argument list to the corresponding decorators control, how aspects are associated with which methods.
+**Example**: Parameter modifications
+
+```python
+@around(methods().named("say"))
+def call_around(self, invocation: Invocation):
+    return invocation.proceed(invocation.args[0], invocation.args[1] + "!") # 0 is self!
+```
+
+The argument list to the corresponding decorators control which methods are targeted by the advice.
+
 A fluent interface is used describe the mapping. 
 The parameters restrict either methods or classes and are constructed by a call to either `methods()` or `classes()`.
 
@@ -448,6 +538,8 @@ Both add the fluent methods:
    defines the matching classes
 - `named(name: str)`  
    defines method or class names
+- `that_are_async()`  
+   defines async methods
 - `matches(re: str)`  
    defines regular expressions for methods or classes
 - `decorated_with(type: Type)`  
@@ -458,7 +550,7 @@ The fluent methods `named`, `matches` and `of_type` can be called multiple times
 **Example**: react on both `transactional` decorators on methods or classes
 
 ```python
-@injectable()
+@advice
 class TransactionAdvice:
     def __init__(self):
         pass
@@ -468,6 +560,24 @@ class TransactionAdvice:
         ...
 ```
 
+With respect to async methods, you need to make sure, to replace a `proceed()` with a `await proceed_async()` to have the overall chain async!
+
+# Threading
+
+A handy decorator `@synchronized` in combination with the respective advice is implemented that automatically synchronizes methods with a `RLock` associated with the instance.
+
+**Example**:
+```python
+@injectable()
+class Foo:
+    def __init__(self):
+        pass
+
+    @synchronized()
+    def execute_synchronized(self):
+        ...
+```
+
 # Configuration 
 
 It is possible to inject configuration values, by decorating methods with `@inject-value(<name>)` given a configuration key.
@@ -483,9 +593,9 @@ class Foo:
         ...
 ```
 
-If required a coercion will be executed.
+If required type coercion will be applied.
 
-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.
+Configuration values are managed centrally using a `ConfigurationManager`, which aggregates values from various configuration sources that are defined as follows.
 
 ```python
 class ConfigurationSource(ABC):
@@ -562,7 +672,7 @@ class SampleEnvironment:
 
 As the library heavily relies on type introspection of classes and methods, a utility class `TypeDescriptor` is available that covers type information on classes. 
 
-After beeing instatiated with
+After being instantiated with
 
 ```python
 TypeDescriptor.for_type(<type>)
@@ -578,7 +688,7 @@ it offers the methods
 - `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
 
-The returned method descriptors offer:
+The returned method descriptors provide:
 - `param_types`  
    list of arg types
 - `return_type`  
@@ -602,6 +712,87 @@ def transactional(scope):
     return decorator
 ```
 
+# Exceptions
+
+The class `ExceptionManager` is used to collect dynamic handlers for specific exceptions and is able to dispatch to the concrete functions
+given a specific exception.
+
+The handlers are declared by annoting a class with `@exception_handler` and decorating specific methods with `@handle`
+
+**Example**:
+```python
+class DerivedException(Exception):
+    def __init__(self):
+        pass
+
+@environment()
+class SampleEnvironment:
+    # constructor
+
+    def __init__(self):
+        pass
+
+    @create()
+    def create_exception_manager(self) -> ExceptionManager:
+        return ExceptionManager()
+
+@injectable()
+@exception_handler()
+class TestExceptionHandler:
+    def __init__(self):
+        pass
+
+    @handle()
+    def handle_derived_exception(self, exception: DerivedException):
+        ExceptionManager.proceed()
+
+    @handle()
+    def handle_exception(self, exception: Exception):
+        pass
+
+    @handle()
+    def handle_base_exception(self, exception: BaseException):
+        pass
+
+
+@advice
+class ExceptionAdvice:
+    def __init__(self, exceptionManager: ExceptionManager):
+        self.exceptionManager = exceptionManager
+
+    @error(methods().of_type(Service))
+    def handle_error(self, invocation: Invocation):
+        self.exceptionManager.handle(invocation.exception)
+
+environment =  Environment(SampleEnvironment)
+
+environment.get(ExceptionManager).handle(DerivedException())
+```
+
+The exception maanger will first call the most appropriate method. 
+Any `ExceptionManager.proceed()` will in turn call the next most applicable method ( if available).
+
+Together with a simple around advice we can now add exception handling to any method:
+
+**Example**:
+```python
+@injectable()
+class Service:
+    def __init__(self):
+        pass
+
+    def throw(self):
+        raise DerivedException()
+
+@advice
+class ExceptionAdvice:
+    def __init__(self, exceptionManager: ExceptionManager):
+        self.exceptionManager = exceptionManager
+
+    @error(methods().of_type(Service))
+    def handle_error(self, invocation: Invocation):
+        self.exceptionManager.handle(invocation.exception)
+```
 
 # Version History
 
@@ -618,6 +809,17 @@ def transactional(scope):
 
 - added `YamlConfigurationSource`
 
+**1.3.0**
+
+- added `@conditional`
+- added support for `async` advices
+
+
+**1.4.0**
+
+- bugfixes
+- added `@ExceptionManager`
+
 
       
 

aspyx-1.4.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+aspyx/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aspyx/di/__init__.py,sha256=OfETLGaquTbFHhhDRzzGtnSu-KkMj68aDdEaVU19KoI,1107
+aspyx/di/di.py,sha256=qoOChsiUBla52UaclRlX6o5ZxRylaFF4IneanvwISos,42095
+aspyx/di/aop/__init__.py,sha256=nOABex49zSyMZ2w1ezwX3Q3yrOcQRSDjDtSj0DwKVbQ,233
+aspyx/di/aop/aop.py,sha256=36p3jCnNtrDL11jTi7NNpW1eGO_BqKL0s5rErsPdxps,17520
+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=FXPvREzq2ZER6_GG5xdpx154TQQDxZVf7LW7cvaylAk,1446
+aspyx/di/configuration/yaml_configuration_source.py,sha256=NDl3SeoLMNVlzHgfP-Ysvhco1tRew_zFnBL5gGy2WRk,550
+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=2Jo0a_fZK8_U9SpPZ0j4aeAXJZ28uw6g-20TH_85JqY,200
+aspyx/exception/exception_manager.py,sha256=8H5fbbcpzLxiK7OI-EZaXyX5Db4uZt9-VrAx5LMiSm8,4692
+aspyx/reflection/__init__.py,sha256=r2sNJrfHDpuqaIYu4fTYsoo046gpgn4VTd7bsS3mQJY,282
+aspyx/reflection/proxy.py,sha256=zJ6Psd6zWfFABdrKOf4cULt3gibyqCRdcR6z8WKIkzE,1982
+aspyx/reflection/reflection.py,sha256=bzH5KVJ5X5ycQu5SG7BFZtioWN7sa1w1Y-xR_Y-oN6w,7113
+aspyx/threading/__init__.py,sha256=_j_AQ4t1ecRaKIb9KCTT_EV0b7hivNML-2wV2XF7G6Y,125
+aspyx/threading/thread_local.py,sha256=nOSS2DM1rIHmzdU9_fjxaUF3oXCaRTBHwe76IdwMqC8,1158
+aspyx/util/__init__.py,sha256=8H2yKkXu3nkRGeTerb8ialzKGfvzUx44XUWFUYcYuQM,125
+aspyx/util/stringbuilder.py,sha256=L3MkHAo4CJrBXuWmaRQASIa9EAs8O_ea7EjZoLsvp08,811
+aspyx-1.4.0.dist-info/licenses/LICENSE,sha256=n4jfx_MNj7cBtPhhI7MCoB_K35cj1icP9yJ4Rh4vlvY,1070
+aspyx-1.4.0.dist-info/METADATA,sha256=S9Qcqc9v6VHJSU76dGT_iEo1Z4ghvpp8nE7uxoc2NkI,25213
+aspyx-1.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aspyx-1.4.0.dist-info/top_level.txt,sha256=A_ZwhBY_ybIgjZlztd44eaOrWqkJAndiqjGlbJ3tR_I,6
+aspyx-1.4.0.dist-info/RECORD,,

aspyx-1.2.0.dist-info/RECORD

@@ -1,18 +0,0 @@
-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,,