aspyx 0.1.0__tar.gz → 1.0.1__tar.gz

{aspyx-0.1.0/src/aspyx.egg-info → aspyx-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aspyx
-Version: 0.1.0
+Version: 1.0.1
 Summary: A DI and AOP library for Python
 Author-email: Andreas Ernst <andreas.ernst7@gmail.com>
 License: MIT License
@@ -25,20 +25,22 @@ License: MIT License
         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
         SOFTWARE.
         
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Dynamic: license-file
 
 # aspyx
 
-![Pylint](https://github.com/andreasernst/aspyx/actions/workflows/pylint.yml/badge.svg)
-![Build Status](https://github.com/andreasernst/aspyx/actions/workflows/ci.yml/badge.svg)
-
+![Pylint](https://github.com/coolsamson7/aspyx/actions/workflows/pylint.yml/badge.svg)
+![Build Status](https://github.com/coolsamson7/aspyx/actions/workflows/ci.yml/badge.svg)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/aspyx)
+![License](https://img.shields.io/github/license/coolsamson7/aspyx)
 
 ## Table of Contents
 
 - [Introduction](#aspyx)
+- [Installation](#installation)
 - [Registration](#registration)
   - [Class](#class)
   - [Class Factory](#class-factory)
@@ -46,11 +48,14 @@ Dynamic: license-file
 - [Environment](#environment)
   - [Definition](#definition)
   - [Retrieval](#retrieval)
-- [Lifecycle methods](#lifecycle-methods)
-- [Post Processors](#post-processors)
+- [Instantiation logic](#instantiation-logic)
+  - [Injection Methods](#injection-methods)
+  - [Lifecycle Methods](#lifecycle-methods)
+  - [Post Processors](#post-processors)
 - [Custom scopes](#custom-scopes)
 - [AOP](#aop)
 - [Configuration](#configuration)
+- [Reflection](#reflection)
 
 # Introduction
 
@@ -69,12 +74,13 @@ The following features are supported
 - container instances that relate to environment classes and manage the lifecylce of related objects
 - hierarchical environments
 
+The library is thread-safe!
+
 Let's look at a simple example
 
 ```python
 from aspyx.di import injectable, on_init, on_destroy, environment, Environment
 
-
 @injectable()
 class Foo:
     def __init__(self):
@@ -83,13 +89,12 @@ class Foo:
     def hello(msg: str):
         print(f"hello {msg}")
 
-
 @injectable()  # eager and singleton by default
 class Bar:
     def __init__(self, foo: Foo): # will inject the Foo dependency
         self.foo = foo
 
-    @on_init() # a lifecycle callback called  after the constructor
+    @on_init() # a lifecycle callback called after the constructor and all possible injections
     def init(self):
         ...
 
@@ -99,41 +104,40 @@ class Bar:
 
 @environment()
 class SampleEnvironment:
-    # constructor
-
     def __init__(self):
         pass
 
-
 # go, forrest
 
-environment = SampleEnvironment(Configuration)
+environment = Environment(SampleEnvironment)
 
 bar = env.get(Bar)
-bar.foo.hello("Andi")
+
+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 which are a combination of Spring and Angular names :-)
 
 Let's add some aspects...
 
 ```python
+
 @advice
 class SampleAdvice:
-    def __init__(self):
+    def __init__(self): # could inject additional stuff
         pass
 
     @before(methods().named("hello").of_type(Foo))
-    def callBefore(self, invocation: Invocation):
+    def call_before(self, invocation: Invocation):
         print("before Foo.hello(...)")
 
     @error(methods().named("hello").of_type(Foo))
-    def callError(self, invocation: Invocation):
+    def call_error(self, invocation: Invocation):
         print("error Foo.hello(...)")
         print(invocation.exception)
 
     @around(methods().named("hello"))
-    def callAround(self, invocation: Invocation):
+    def call_around(self, invocation: Invocation):
         print("around Foo.hello()")
 
         return invocation.proceed()
@@ -148,6 +152,14 @@ The invocation parameter stores the complete context of the current execution, w
 
 Let's look at the details
 
+# Installation
+
+`pip install aspyx`
+
+The library is tested with Python version > 3.8
+
+Ready to go...
+
 # Registration
 
 Different mechanisms are available that make classes eligible for injection
@@ -164,16 +176,19 @@ class Foo:
     def __init__(self):
         pass
 ```
- Please make sure, that the class defines a constructor, as this is required to determine injected instances. 
-
- The constructor can only define parameter types that are known as well to the container! 
+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. 
 
+Only eligible types are allowed, of course!
 
- The decorator accepts the keyword arguments
- - `eager=True` if `True`, the container will create the instances automatically while booting the environment
- - `scope="singleton"` defines how often instances will be created. `singleton` will create it only once - per environment -, while `request` will recreate it on every injection request
+The decorator accepts the keyword arguments
+- `eager : boolean`  
+  if `True`, the container will create the instances automatically while booting the environment. This is the default.
+- `scope: str`  
+  the name of a scope which will determine how often instances will be created.
+ `singleton` will create it only once - per environment -, while `request` will recreate it on every injection request. The default is `singleton`
 
- Other scopes can be defined. Please check the corresponding chapter.
+ Other scopes - e.g. session related scopes - can be defined dynamically. Please check the corresponding chapter.
 
 ## Class Factory
 
@@ -268,15 +283,55 @@ 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. ) 
 
-# Lifecycle methods
+# Instantiation logic
+
+Constructing a new instance involves a number of steps executed in this order
+- Constructor call  
+  the constructor is called with the resolved parameters
+- Advice injection  
+  All methods involving aspects are updated
+- Lifecycle methods   
+  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
+
+## Injection methods
+
+Different decorators are implemented, that call methods with computed values
+
+- `@inject`  
+   the method is called with all resolved parameter types ( same as the constructor call)
+- `@inject_environment`  
+   the method is called with the creating environment as a single parameter
+- `@value()`  
+   the method is called with a resolved configuration value. Check the corresponding chapter
+
+**Example**:
+```python
+@injectable()
+class Foo:
+    def __init__(self):
+        pass
+
+    @inject_environment()
+    def initEnvironment(self, env: Environment):
+        ...
+
+    @inject()
+    def set(self, baz: Baz) -> None:
+        ...
+```
+
+## Lifecycle methods
 
-It is possible to declare methods that will be called from the container
+It is possible to mark specific lifecle methods. 
 - `@on_init()` 
    called after the constructor and all other injections.
 - `@on_destroy()` 
-   called after the container has been shut down
+   called during shutdown of the environment
 
-# Post Processors
+## Post Processors
 
 As part of the instantiation logic it is possible to define post processors that execute any side effect on newly created instances.
 
@@ -343,17 +398,17 @@ class SampleAdvice:
         pass
 
     @before(methods().named("hello").of_type(Foo))
-    def callBefore(self, invocation: Invocation):
+    def call_before(self, invocation: Invocation):
         # arguments: invocation.args
         print("before Foo.hello(...)")
 
     @error(methods().named("hello").of_type(Foo))
-    def callError(self, invocation: Invocation):
+    def call_error(self, invocation: Invocation):
         print("error Foo.hello(...)")
         print(invocation.exception)
 
     @around(methods().named("hello"))
-    def callAround(self, invocation: Invocation):
+    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
@@ -374,7 +429,7 @@ All methods are expected to hava single `Invocation` parameter, that stores, the
 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 arguments to the corresponding decorators control, how aspects are associated with which methods.
+The argument list to the corresponding decorators control, how aspects are associated with which methods.
 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()`.
 
@@ -388,7 +443,20 @@ Both add the fluent methods:
 - `decorated_with(type: Type)`  
    defines decorators on methods or classes
 
-The fluent methods `named`, `matches` and `of_type` can be called multiple timess!
+The fluent methods `named`, `matches` and `of_type` can be called multiple times!
+
+**Example**:
+
+```python
+@injectable()
+class TransactionAdvice:
+    def __init__(self):
+        pass
+
+    @around(methods().decorated_with(transactional), classes().decorated_with(transactional))
+    def establish_transaction(self, invocation: Invocation):
+        ...
+```
 
 # Configuration 
 
@@ -409,10 +477,11 @@ This concept relies on a central object `ConfigurationManager` that stores the o
 
 ```python
 class ConfigurationSource(ABC):
-    def __init__(self, manager: ConfigurationManager):
-        manager._register(self)
+    def __init__(self):
         pass
 
+   ...
+
     @abstractmethod
     def load(self) -> dict:
         pass
@@ -424,14 +493,12 @@ As a default environment variables are already supported.
 
 Other sources can be added dynamically by just registering them.
 
+**Example**:
 ```python
 @injectable()
 class SampleConfigurationSource(ConfigurationSource):
-    # constructor
-
-    def __init__(self, manager: ConfigurationManager):
-        super().__init__(manager)
-
+    def __init__(self):
+        super().__init__()
 
     def load(self) -> dict:
         return {
@@ -444,6 +511,43 @@ class SampleConfigurationSource(ConfigurationSource):
             }
 ```
 
+# Reflection
+
+As the library heavily relies on type introspection of classes and methods, a utility class `TypeDescriptor` is available that covers type information on classes. 
+
+After beeing instatiated with
+
+```python
+TypeDescriptor.for_type(<type>)
+```
+
+it offers the methods
+- `get_methods(local=False)`
+- `get_method(name: str, local=False)`
+- `has_decorator(decorator) -> bool`
+- `get_decorator(decorator)`
+
+The returned method descriptors offer:
+- `param_types`
+- `return_type`
+- `has_decorator(decorator)`
+- `get_decorator(decorator)`
+
+The management of decorators in turn relies on another utility class `Decorators` that caches decorators.
+
+Whenver you define a custom decorator, you will need to register it accordingly.
+
+**Example**:
+```python
+def transactional():
+    def decorator(func):
+        Decorators.add(func, transactional)
+        return func
+
+    return decorator
+```
+
+
 
 
 

{aspyx-0.1.0 → aspyx-1.0.1}/README.md

@@ -1,12 +1,14 @@
 # aspyx
 
-![Pylint](https://github.com/andreasernst/aspyx/actions/workflows/pylint.yml/badge.svg)
-![Build Status](https://github.com/andreasernst/aspyx/actions/workflows/ci.yml/badge.svg)
-
+![Pylint](https://github.com/coolsamson7/aspyx/actions/workflows/pylint.yml/badge.svg)
+![Build Status](https://github.com/coolsamson7/aspyx/actions/workflows/ci.yml/badge.svg)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/aspyx)
+![License](https://img.shields.io/github/license/coolsamson7/aspyx)
 
 ## Table of Contents
 
 - [Introduction](#aspyx)
+- [Installation](#installation)
 - [Registration](#registration)
   - [Class](#class)
   - [Class Factory](#class-factory)
@@ -14,11 +16,14 @@
 - [Environment](#environment)
   - [Definition](#definition)
   - [Retrieval](#retrieval)
-- [Lifecycle methods](#lifecycle-methods)
-- [Post Processors](#post-processors)
+- [Instantiation logic](#instantiation-logic)
+  - [Injection Methods](#injection-methods)
+  - [Lifecycle Methods](#lifecycle-methods)
+  - [Post Processors](#post-processors)
 - [Custom scopes](#custom-scopes)
 - [AOP](#aop)
 - [Configuration](#configuration)
+- [Reflection](#reflection)
 
 # Introduction
 
@@ -37,12 +42,13 @@ The following features are supported
 - container instances that relate to environment classes and manage the lifecylce of related objects
 - hierarchical environments
 
+The library is thread-safe!
+
 Let's look at a simple example
 
 ```python
 from aspyx.di import injectable, on_init, on_destroy, environment, Environment
 
-
 @injectable()
 class Foo:
     def __init__(self):
@@ -51,13 +57,12 @@ class Foo:
     def hello(msg: str):
         print(f"hello {msg}")
 
-
 @injectable()  # eager and singleton by default
 class Bar:
     def __init__(self, foo: Foo): # will inject the Foo dependency
         self.foo = foo
 
-    @on_init() # a lifecycle callback called  after the constructor
+    @on_init() # a lifecycle callback called after the constructor and all possible injections
     def init(self):
         ...
 
@@ -67,41 +72,40 @@ class Bar:
 
 @environment()
 class SampleEnvironment:
-    # constructor
-
     def __init__(self):
         pass
 
-
 # go, forrest
 
-environment = SampleEnvironment(Configuration)
+environment = Environment(SampleEnvironment)
 
 bar = env.get(Bar)
-bar.foo.hello("Andi")
+
+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 which are a combination of Spring and Angular names :-)
 
 Let's add some aspects...
 
 ```python
+
 @advice
 class SampleAdvice:
-    def __init__(self):
+    def __init__(self): # could inject additional stuff
         pass
 
     @before(methods().named("hello").of_type(Foo))
-    def callBefore(self, invocation: Invocation):
+    def call_before(self, invocation: Invocation):
         print("before Foo.hello(...)")
 
     @error(methods().named("hello").of_type(Foo))
-    def callError(self, invocation: Invocation):
+    def call_error(self, invocation: Invocation):
         print("error Foo.hello(...)")
         print(invocation.exception)
 
     @around(methods().named("hello"))
-    def callAround(self, invocation: Invocation):
+    def call_around(self, invocation: Invocation):
         print("around Foo.hello()")
 
         return invocation.proceed()
@@ -116,6 +120,14 @@ The invocation parameter stores the complete context of the current execution, w
 
 Let's look at the details
 
+# Installation
+
+`pip install aspyx`
+
+The library is tested with Python version > 3.8
+
+Ready to go...
+
 # Registration
 
 Different mechanisms are available that make classes eligible for injection
@@ -132,16 +144,19 @@ class Foo:
     def __init__(self):
         pass
 ```
- Please make sure, that the class defines a constructor, as this is required to determine injected instances. 
-
- The constructor can only define parameter types that are known as well to the container! 
+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. 
 
+Only eligible types are allowed, of course!
 
- The decorator accepts the keyword arguments
- - `eager=True` if `True`, the container will create the instances automatically while booting the environment
- - `scope="singleton"` defines how often instances will be created. `singleton` will create it only once - per environment -, while `request` will recreate it on every injection request
+The decorator accepts the keyword arguments
+- `eager : boolean`  
+  if `True`, the container will create the instances automatically while booting the environment. This is the default.
+- `scope: str`  
+  the name of a scope which will determine how often instances will be created.
+ `singleton` will create it only once - per environment -, while `request` will recreate it on every injection request. The default is `singleton`
 
- Other scopes can be defined. Please check the corresponding chapter.
+ Other scopes - e.g. session related scopes - can be defined dynamically. Please check the corresponding chapter.
 
 ## Class Factory
 
@@ -236,15 +251,55 @@ 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. ) 
 
-# Lifecycle methods
+# Instantiation logic
+
+Constructing a new instance involves a number of steps executed in this order
+- Constructor call  
+  the constructor is called with the resolved parameters
+- Advice injection  
+  All methods involving aspects are updated
+- Lifecycle methods   
+  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
+
+## Injection methods
+
+Different decorators are implemented, that call methods with computed values
+
+- `@inject`  
+   the method is called with all resolved parameter types ( same as the constructor call)
+- `@inject_environment`  
+   the method is called with the creating environment as a single parameter
+- `@value()`  
+   the method is called with a resolved configuration value. Check the corresponding chapter
+
+**Example**:
+```python
+@injectable()
+class Foo:
+    def __init__(self):
+        pass
+
+    @inject_environment()
+    def initEnvironment(self, env: Environment):
+        ...
+
+    @inject()
+    def set(self, baz: Baz) -> None:
+        ...
+```
+
+## Lifecycle methods
 
-It is possible to declare methods that will be called from the container
+It is possible to mark specific lifecle methods. 
 - `@on_init()` 
    called after the constructor and all other injections.
 - `@on_destroy()` 
-   called after the container has been shut down
+   called during shutdown of the environment
 
-# Post Processors
+## Post Processors
 
 As part of the instantiation logic it is possible to define post processors that execute any side effect on newly created instances.
 
@@ -311,17 +366,17 @@ class SampleAdvice:
         pass
 
     @before(methods().named("hello").of_type(Foo))
-    def callBefore(self, invocation: Invocation):
+    def call_before(self, invocation: Invocation):
         # arguments: invocation.args
         print("before Foo.hello(...)")
 
     @error(methods().named("hello").of_type(Foo))
-    def callError(self, invocation: Invocation):
+    def call_error(self, invocation: Invocation):
         print("error Foo.hello(...)")
         print(invocation.exception)
 
     @around(methods().named("hello"))
-    def callAround(self, invocation: Invocation):
+    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
@@ -342,7 +397,7 @@ All methods are expected to hava single `Invocation` parameter, that stores, the
 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 arguments to the corresponding decorators control, how aspects are associated with which methods.
+The argument list to the corresponding decorators control, how aspects are associated with which methods.
 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()`.
 
@@ -356,7 +411,20 @@ Both add the fluent methods:
 - `decorated_with(type: Type)`  
    defines decorators on methods or classes
 
-The fluent methods `named`, `matches` and `of_type` can be called multiple timess!
+The fluent methods `named`, `matches` and `of_type` can be called multiple times!
+
+**Example**:
+
+```python
+@injectable()
+class TransactionAdvice:
+    def __init__(self):
+        pass
+
+    @around(methods().decorated_with(transactional), classes().decorated_with(transactional))
+    def establish_transaction(self, invocation: Invocation):
+        ...
+```
 
 # Configuration 
 
@@ -377,10 +445,11 @@ This concept relies on a central object `ConfigurationManager` that stores the o
 
 ```python
 class ConfigurationSource(ABC):
-    def __init__(self, manager: ConfigurationManager):
-        manager._register(self)
+    def __init__(self):
         pass
 
+   ...
+
     @abstractmethod
     def load(self) -> dict:
         pass
@@ -392,14 +461,12 @@ As a default environment variables are already supported.
 
 Other sources can be added dynamically by just registering them.
 
+**Example**:
 ```python
 @injectable()
 class SampleConfigurationSource(ConfigurationSource):
-    # constructor
-
-    def __init__(self, manager: ConfigurationManager):
-        super().__init__(manager)
-
+    def __init__(self):
+        super().__init__()
 
     def load(self) -> dict:
         return {
@@ -412,6 +479,43 @@ class SampleConfigurationSource(ConfigurationSource):
             }
 ```
 
+# Reflection
+
+As the library heavily relies on type introspection of classes and methods, a utility class `TypeDescriptor` is available that covers type information on classes. 
+
+After beeing instatiated with
+
+```python
+TypeDescriptor.for_type(<type>)
+```
+
+it offers the methods
+- `get_methods(local=False)`
+- `get_method(name: str, local=False)`
+- `has_decorator(decorator) -> bool`
+- `get_decorator(decorator)`
+
+The returned method descriptors offer:
+- `param_types`
+- `return_type`
+- `has_decorator(decorator)`
+- `get_decorator(decorator)`
+
+The management of decorators in turn relies on another utility class `Decorators` that caches decorators.
+
+Whenver you define a custom decorator, you will need to register it accordingly.
+
+**Example**:
+```python
+def transactional():
+    def decorator(func):
+        Decorators.add(func, transactional)
+        return func
+
+    return decorator
+```
+
+