aspyx 0.1.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

aspyx/reflection/proxy.py

@@ -1,3 +1,6 @@
+"""
+Dynamic proxies for method interception and delegation.
+"""
 from typing import Generic, TypeVar, Type
 
 T = TypeVar("T")
@@ -22,7 +25,7 @@ class DynamicProxy(Generic[T]):
 
     Attributes:
         type: The proxied class type.
-        invocationHandler: The handler that processes intercepted method calls.
+        invocation_handler: The handler that processes intercepted method calls.
     """
     # inner class
 
@@ -40,19 +43,19 @@ class DynamicProxy(Generic[T]):
     # class methods
 
     @classmethod
-    def create(cls, type: Type[T], invocationHandler: 'DynamicProxy.InvocationHandler') -> T:
-        return DynamicProxy(type, invocationHandler)
+    def create(cls, type: Type[T], invocation_handler: 'DynamicProxy.InvocationHandler') -> T:
+        return DynamicProxy(type, invocation_handler)
 
     # constructor
 
-    def __init__(self, type: Type[T], invocationHandler: 'DynamicProxy.InvocationHandler'):
+    def __init__(self, type: Type[T], invocation_handler: 'DynamicProxy.InvocationHandler'):
         self.type = type
-        self.invocationHandler = invocationHandler
+        self.invocation_handler = invocation_handler
 
     # public
 
     def __getattr__(self, name):
         def wrapper(*args, **kwargs):
-            return self.invocationHandler.invoke(DynamicProxy.Invocation(self.type, name, *args, **kwargs))
+            return self.invocation_handler.invoke(DynamicProxy.Invocation(self.type, name, *args, **kwargs))
 
-        return wrapper
+        return wrapper

aspyx/reflection/reflection.py

@@ -1,3 +1,7 @@
+"""
+This module provides a TypeDescriptor class that allows introspection of Python classes,
+including their methods, decorators, and type hints. It supports caching for performance
+"""
 from __future__ import annotations
 
 import inspect
@@ -5,7 +9,13 @@ from inspect import signature, getmembers
 from typing import Callable, get_type_hints, Type, Dict, Optional
 from weakref import WeakKeyDictionary
 
+
 class DecoratorDescriptor:
+    __slots__ = [
+        "decorator",
+        "args"
+    ]
+
     def __init__(self, decorator, *args):
         self.decorator = decorator
         self.args = args
@@ -34,27 +44,27 @@ class TypeDescriptor:
             self.clazz = cls
             self.method = method
             self.decorators: list[DecoratorDescriptor] = Decorators.get(method)
-            self.paramTypes : list[Type] = []
+            self.param_types : list[Type] = []
 
             type_hints = get_type_hints(method)
             sig = signature(method)
 
-            for name, param in sig.parameters.items():
+            for name, _ in sig.parameters.items():
                 if name != 'self':
-                    self.paramTypes.append(type_hints.get(name, object))
+                    self.param_types.append(type_hints.get(name, object))
 
-            self.returnType = type_hints.get('return', None)
+            self.return_type = type_hints.get('return', None)
 
-        def get_decorator(self, decorator):
+        def get_decorator(self, decorator) -> Optional[DecoratorDescriptor]:
             for dec in self.decorators:
-                if dec.decorator == decorator:
+                if dec.decorator is decorator:
                     return dec
 
             return None
 
-        def has_decorator(self, decorator):
+        def has_decorator(self, decorator) -> bool:
             for dec in self.decorators:
-                if dec.decorator == decorator:
+                if dec.decorator is decorator:
                     return True
 
             return False
@@ -62,8 +72,6 @@ class TypeDescriptor:
         def __str__(self):
             return f"Method({self.method.__name__})"
 
-    # class methods
-
     # class properties
 
     _cache = WeakKeyDictionary()
@@ -76,6 +84,7 @@ class TypeDescriptor:
         if descriptor is None:
             descriptor = TypeDescriptor(clazz)
             cls._cache[clazz] = descriptor
+
         return descriptor
 
     # constructor
@@ -83,27 +92,25 @@ class TypeDescriptor:
     def __init__(self, cls):
         self.cls = cls
         self.decorators = Decorators.get(cls)
-        self.methods: Dict[str, TypeDescriptor.MethodDescriptor] = dict()
-        self.localMethods: Dict[str, TypeDescriptor.MethodDescriptor] = dict()
+        self.methods: Dict[str, TypeDescriptor.MethodDescriptor] = {}
+        self.local_methods: Dict[str, TypeDescriptor.MethodDescriptor] = {}
 
         # check superclasses
 
-        self.superTypes = [TypeDescriptor.for_type(x) for x in cls.__bases__ if not x is object]
+        self.super_types = [TypeDescriptor.for_type(x) for x in cls.__bases__ if not x is object]
 
-        for superType in self.superTypes:
-            self.methods = self.methods | superType.methods
+        for super_type in self.super_types:
+            self.methods = self.methods | super_type.methods
 
         # methods
 
         for name, member in self._get_local_members(cls):
             method = TypeDescriptor.MethodDescriptor(cls, member)
-            self.localMethods[name] = method
+            self.local_methods[name] = method
             self.methods[name] = method
 
     # internal
 
-    #isinstance(attr, classmethod)
-
     def _get_local_members(self, cls):
         return [
             (name, value)
@@ -127,8 +134,14 @@ class TypeDescriptor:
 
         return False
 
-    def get_local_method(self, name) -> Optional[MethodDescriptor]:
-        return self.localMethods.get(name, None)
+    def get_methods(self, local = False) ->  list[TypeDescriptor.MethodDescriptor]:
+        if local:
+            return list(self.local_methods.values())
+        else:
+            return list(self.methods.values())
 
-    def get_method(self, name) -> Optional[MethodDescriptor]:
-        return self.methods.get(name, None)
+    def get_method(self, name: str, local = False) -> Optional[TypeDescriptor.MethodDescriptor]:
+        if local:
+            return self.local_methods.get(name, None)
+        else:
+            return self.methods.get(name, None)

{aspyx-0.1.0.dist-info → aspyx-1.0.1.dist-info}/METADATA

@@ -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-1.0.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+aspyx/di/__init__.py,sha256=G13Cz1MMElBKNWsrhgTEIvhmIKj5MX4uqK_Apke4w8I,897
+aspyx/di/di.py,sha256=elT3XJokxYxPJ9mx528MAU-pmm9lIZF8_AXKGkjyhBo,31014
+aspyx/di/aop/__init__.py,sha256=nOABex49zSyMZ2w1ezwX3Q3yrOcQRSDjDtSj0DwKVbQ,233
+aspyx/di/aop/aop.py,sha256=1RUgijk8RsiXWTizfNQX1IfHF7b96kCPdUgahX_J4Io,14457
+aspyx/di/configuration/__init__.py,sha256=Zw7h-OlbJD7LyJvzkgyF0EmVqra6oN_Pt0HuUdjTPTA,249
+aspyx/di/configuration/configuration.py,sha256=dHYoM3jC43QeDVlT6-mGDj05Sz6-Nm91LNE2TfQT1UU,5740
+aspyx/reflection/__init__.py,sha256=r2sNJrfHDpuqaIYu4fTYsoo046gpgn4VTd7bsS3mQJY,282
+aspyx/reflection/proxy.py,sha256=zJ6Psd6zWfFABdrKOf4cULt3gibyqCRdcR6z8WKIkzE,1982
+aspyx/reflection/reflection.py,sha256=NkBK94kjJ7rQpPsK4mzHzX5TLSlWRM3mbNVzkwOZo4o,4379
+aspyx-1.0.1.dist-info/licenses/LICENSE,sha256=n4jfx_MNj7cBtPhhI7MCoB_K35cj1icP9yJ4Rh4vlvY,1070
+aspyx-1.0.1.dist-info/METADATA,sha256=69OakKuzM1UK0YTgH-y6-473YWhylxQvt8v993WsqiU,16798
+aspyx-1.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aspyx-1.0.1.dist-info/top_level.txt,sha256=A_ZwhBY_ybIgjZlztd44eaOrWqkJAndiqjGlbJ3tR_I,6
+aspyx-1.0.1.dist-info/RECORD,,

aspyx-0.1.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-aspyx/di/__init__.py,sha256=US6i6s94TIpk4eiRFKYm9JB0NnU9F_3RAoIoXa-OnTI,800
-aspyx/di/di.py,sha256=6A_-x6NrPArcKddlntpDj41yNOF0Gvbte1wSosv9UCI,30035
-aspyx/di/aop/__init__.py,sha256=2mv6o38HHoBzF_nx8rsrvuOlUlNgYITmNRcQJVT2Bk8,213
-aspyx/di/aop/aop.py,sha256=y5kwSzWWzKsPQNP3RUhxiNA0q5o_T_eGDE5vScOiPTM,13798
-aspyx/di/configuration/__init__.py,sha256=YgUk1bHVYq1EJ9W4D_CJ9ZM-3kje-vzPNMxBdUm0Vlg,211
-aspyx/di/configuration/configuration.py,sha256=-9QgOnC9HyWk9d3N8UQCRYHNtk4qDXjxUBaHC3RvAYc,5685
-aspyx/reflection/__init__.py,sha256=jZAjw5NDrtXENmlBsQ0u9MobcNkfEuT0Oey8IWNYh34,204
-aspyx/reflection/proxy.py,sha256=Re643BJAgbQjmDXO5JAvj4mu3RTpe_HF3TcFQ1euArg,1910
-aspyx/reflection/reflection.py,sha256=DS2J3CfxZ0BpdzGBOBU9c1H3R0XCTE34Zx5k2OWn8Iw,3925
-aspyx-0.1.0.dist-info/licenses/LICENSE,sha256=n4jfx_MNj7cBtPhhI7MCoB_K35cj1icP9yJ4Rh4vlvY,1070
-aspyx-0.1.0.dist-info/METADATA,sha256=Ch6Qb4hxI_vFRJ09nZgRKSiAoIhH8xERLT9a8qDUgqA,13906
-aspyx-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aspyx-0.1.0.dist-info/top_level.txt,sha256=A_ZwhBY_ybIgjZlztd44eaOrWqkJAndiqjGlbJ3tR_I,6
-aspyx-0.1.0.dist-info/RECORD,,