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

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,6 +9,7 @@ from inspect import signature, getmembers
 from typing import Callable, get_type_hints, Type, Dict, Optional
 from weakref import WeakKeyDictionary
 
+
 class DecoratorDescriptor:
     __slots__ = [
         "decorator",
@@ -39,25 +44,25 @@ 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 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 is decorator:
                     return True
@@ -67,8 +72,6 @@ class TypeDescriptor:
         def __str__(self):
             return f"Method({self.method.__name__})"
 
-    # class methods
-
     # class properties
 
     _cache = WeakKeyDictionary()
@@ -81,6 +84,7 @@ class TypeDescriptor:
         if descriptor is None:
             descriptor = TypeDescriptor(clazz)
             cls._cache[clazz] = descriptor
+
         return descriptor
 
     # constructor
@@ -88,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,13 +129,19 @@ class TypeDescriptor:
 
     def has_decorator(self, decorator) -> bool:
         for dec in self.decorators:
-            if dec.decorator.__name__ == decorator.__name__:
+            if dec.decorator is decorator:
                 return True
 
         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-1.0.0.dist-info → aspyx-1.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aspyx
-Version: 1.0.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,7 +25,7 @@ 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
@@ -34,11 +34,13 @@ Dynamic: license-file
 
 ![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)
@@ -53,6 +55,7 @@ Dynamic: license-file
 - [Custom scopes](#custom-scopes)
 - [AOP](#aop)
 - [Configuration](#configuration)
+- [Reflection](#reflection)
 
 # Introduction
 
@@ -71,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):
@@ -85,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):
         ...
 
@@ -101,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()
@@ -150,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
@@ -171,12 +181,14 @@ All referenced types will be injected by the environemnt.
 
 Only eligible types are allowed, of course!
 
+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`
 
- 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
-
- 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
 
@@ -386,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
@@ -417,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()`.
 
@@ -431,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 
 
@@ -452,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
@@ -467,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 {
@@ -487,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-1.0.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-aspyx/di/__init__.py,sha256=US6i6s94TIpk4eiRFKYm9JB0NnU9F_3RAoIoXa-OnTI,800
-aspyx/di/di.py,sha256=IdMNkPmMaVhRNr8heE8msGO3KYEc69pf2pjcJ8_rp4E,31169
-aspyx/di/aop/__init__.py,sha256=2mv6o38HHoBzF_nx8rsrvuOlUlNgYITmNRcQJVT2Bk8,213
-aspyx/di/aop/aop.py,sha256=stgSLSBpOd9XV_qo7KEazinq8Ul_csWbCx1w30dioWw,14647
-aspyx/di/configuration/__init__.py,sha256=YgUk1bHVYq1EJ9W4D_CJ9ZM-3kje-vzPNMxBdUm0Vlg,211
-aspyx/di/configuration/configuration.py,sha256=6EG2kf2v5pk9fTeCQUD5j6Jo5v00CFd5Nz7qXyYmxKw,5725
-aspyx/reflection/__init__.py,sha256=jZAjw5NDrtXENmlBsQ0u9MobcNkfEuT0Oey8IWNYh34,204
-aspyx/reflection/proxy.py,sha256=Re643BJAgbQjmDXO5JAvj4mu3RTpe_HF3TcFQ1euArg,1910
-aspyx/reflection/reflection.py,sha256=LIUu-SxA_GJ1JurbQKTrvMUrE05OOcXxXOu65zRWubw,4004
-aspyx-1.0.0.dist-info/licenses/LICENSE,sha256=n4jfx_MNj7cBtPhhI7MCoB_K35cj1icP9yJ4Rh4vlvY,1070
-aspyx-1.0.0.dist-info/METADATA,sha256=3AuH9LBUHpPfxu9BcmawTaaJIHTBWwHuFpP_gBasyh0,15227
-aspyx-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aspyx-1.0.0.dist-info/top_level.txt,sha256=A_ZwhBY_ybIgjZlztd44eaOrWqkJAndiqjGlbJ3tR_I,6
-aspyx-1.0.0.dist-info/RECORD,,