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

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,27 +27,64 @@ 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:
     """
     Utility class that caches decorators ( Python does not have a feature for this )
     """
     @classmethod
-    def add(cls, func, decorator: Callable, *args):
-        decorators = getattr(func, '__decorators__', None)
+    def add(cls, func_or_class, decorator: Callable, *args):
+        """
+        Remember the decorator
+        Args:
+            func_or_class: a function or class
+            decorator: the decorator
+            *args: any arguments supplied to the decorator
+        """
+        decorators = getattr(func_or_class, '__decorators__', None)
         if decorators is None:
-            setattr(func, '__decorators__', [DecoratorDescriptor(decorator, *args)])
+            setattr(func_or_class, '__decorators__', [DecoratorDescriptor(decorator, *args)])
         else:
             decorators.append(DecoratorDescriptor(decorator, *args))
 
     @classmethod
-    def has_decorator(cls, func, callable: Callable) -> bool:
-        return any(decorator.decorator is callable for decorator in Decorators.get(func))
+    def has_decorator(cls, func_or_class, callable: Callable) -> bool:
+        """
+        Return True, if the function or class is decorated with the decorator
+        Args:
+            func_or_class: a function or class
+            callable: the decorator
+
+        Returns:
+            bool: the result
+        """
+        return any(decorator.decorator is callable for decorator in Decorators.get(func_or_class))
 
     @classmethod
-    def get(cls, func) -> list[DecoratorDescriptor]:
-        return getattr(func, '__decorators__', [])
+    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]:
+        """
+        return the list of decorators associated with the given function or class
+        Args:
+            func_or_class: the function or class
+
+        Returns:
+            list[DecoratorDescriptor]: the list
+        """
+        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:
     """
@@ -79,30 +118,45 @@ class TypeDescriptor:
         def get_name(self) -> str:
             """
             return the method name
-            :return: the method name
+
+            Returns:
+                str: the method name
             """
             return self.method.__name__
 
         def get_doc(self, default = "") -> str:
             """
             return the method docstring
-            :param default: the default if no docstring is found
-            :return:  the docstring
+
+            Args:
+                default: the default if no docstring is found
+
+            Returns:
+                str: the docstring
             """
             return self.method.__doc__ or default
 
         def is_async(self) -> bool:
             """
             return true if the method is asynchronous
-            :return: async flag
+
+            Returns:
+                bool: async flag
             """
             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
-            :param decorator:
-            :return:  the DecoratorDescriptor or None
+
+            Args:
+                decorator: the decorator
+
+            Returns:
+                Optional[DecoratorDescriptor]: the DecoratorDescriptor or None
             """
             for dec in self.decorators:
                 if dec.decorator is decorator:
@@ -113,8 +167,12 @@ class TypeDescriptor:
         def has_decorator(self, decorator: Callable) -> bool:
             """
             return True if the method is decorated with the decorator
-            :param decorator: the decorator callable
-            :return:  True if the method is decorated with the decorator
+
+            Args:
+                decorator: the decorator callable
+
+            Returns:
+                bool: True if the method is decorated with the decorator
             """
             for dec in self.decorators:
                 if dec.decorator is decorator:
@@ -172,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/threading/__init__.py

@@ -1,5 +1,5 @@
 """
-threading utilities
+A module with threading related utilities
 """
 from .thread_local import ThreadLocal
 

aspyx/threading/thread_local.py

@@ -22,7 +22,9 @@ class ThreadLocal(Generic[T]):
     def get(self) -> Optional[T]:
         """
         return the current value or invoke the optional factory to compute one
-        :return: the value associated with the current thread
+
+        Returns:
+            Optional[T]: the value associated with the current thread
         """
         if not hasattr(self.local, "value"):
             if self.factory is not None:
@@ -35,7 +37,9 @@ class ThreadLocal(Generic[T]):
     def set(self, value: T) -> None:
         """
         set a value in the current thread
-        :param value: the value
+
+        Args:
+            value: the value
         """
         self.local.value = value
 

aspyx/util/stringbuilder.py

@@ -17,8 +17,12 @@ class StringBuilder:
     def append(self, s: str) -> "StringBuilder":
         """
         append a string to the end of the string builder
-        :param s:  the string
-        :return: self
+
+        Args:
+            s (str): the string
+
+        Returns:
+            StringBuilder: self
         """
         self._parts.append(str(s))
 

aspyx-1.5.0.dist-info/METADATA

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: aspyx
+Version: 1.5.0
+Summary: A DI and AOP library for Python
+Author-email: Andreas Ernst <andreas.ernst7@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 Andreas Ernst
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        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
+
+aspyx

aspyx-1.5.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+aspyx/__init__.py,sha256=MsSFjiLMLJZ7QhUPpVBWKiyDnCzryquRyr329NoCACI,2
+aspyx/di/__init__.py,sha256=AGVU2VBWQyBxSssvbk_GOKrYWIYtcmSoIlupz-Oqxi4,1138
+aspyx/di/di.py,sha256=MN9I-KIAgBQYakctEZQH3W1_jjsc7pgGyeLt7eJr0yY,46539
+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
+aspyx/di/configuration/configuration.py,sha256=cXW40bPXiUZ9hUtBoZkSATT3nLrDPWsSqxtgASIBQaM,4375
+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=OZwv-C3ZHD0Eg1rohCQMj575WLJ7lfYuk6PZD6sh1MA,211
+aspyx/exception/exception_manager.py,sha256=tv0nb0b2CFPiYWK6wwH9yI8hSc--9Xz9_xQVBwU42wc,5228
+aspyx/reflection/__init__.py,sha256=r2sNJrfHDpuqaIYu4fTYsoo046gpgn4VTd7bsS3mQJY,282
+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.5.0.dist-info/METADATA,sha256=dm6A8H-_qsn1NDzfFFG2AYclm7Bj6BbLdgtbuVRR6HY,1540
+aspyx-1.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+aspyx-1.5.0.dist-info/licenses/LICENSE,sha256=n4jfx_MNj7cBtPhhI7MCoB_K35cj1icP9yJ4Rh4vlvY,1070
+aspyx-1.5.0.dist-info/RECORD,,

{aspyx-1.4.0.dist-info → aspyx-1.5.0.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
-