aspyx 1.6.1__tar.gz → 1.8.0__tar.gz

{aspyx-1.6.1 → aspyx-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aspyx
-Version: 1.6.1
+Version: 1.8.0
 Summary: A DI and AOP library for Python
 Author-email: Andreas Ernst <andreas.ernst7@gmail.com>
 License: MIT License

{aspyx-1.6.1 → aspyx-1.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "aspyx"
-version = "1.6.1"
+version = "1.8.0"
 description = "A DI and AOP library for Python"
 authors = [{ name = "Andreas Ernst", email = "andreas.ernst7@gmail.com" }]
 readme = "README.md"

{aspyx-1.6.1 → aspyx-1.8.0}/src/aspyx/di/di.py

@@ -975,7 +975,7 @@ class Environment:
         """
 
         def add_provider(type: Type, provider: AbstractInstanceProvider):
-            Environment.logger.info("\tadd provider %s for %s", provider, type)
+            Environment.logger.debug("\tadd provider %s for %s", provider, type)
 
             self.providers[type] = provider
 

{aspyx-1.6.1 → aspyx-1.8.0}/src/aspyx/reflection/__init__.py

@@ -2,11 +2,12 @@
 This module provides tools for dynamic proxy creation and reflection
 """
 from .proxy import DynamicProxy
-from .reflection import Decorators, TypeDescriptor, DecoratorDescriptor
+from .reflection import Decorators, TypeDescriptor, DecoratorDescriptor, get_method_class
 
 __all__ = [
     "DynamicProxy",
     "Decorators",
     "DecoratorDescriptor",
-    "TypeDescriptor"
+    "TypeDescriptor",
+    "get_method_class"
 ]

{aspyx-1.6.1 → aspyx-1.8.0}/src/aspyx/reflection/reflection.py

@@ -12,6 +12,27 @@ from types import FunctionType
 from typing import Callable, get_type_hints, Type, Dict, Optional
 from weakref import WeakKeyDictionary
 
+def get_method_class(method):
+    """
+    return the class of the specified method
+    Args:
+        method: the method
+
+    Returns:
+        the class of the specified method
+
+    """
+    if inspect.ismethod(method) or inspect.isfunction(method):
+        qualname = method.__qualname__
+        module = inspect.getmodule(method)
+        if module:
+            cls_name = qualname.split('.<locals>', 1)[0].rsplit('.', 1)[0]
+            cls = getattr(module, cls_name, None)
+            if inspect.isclass(cls):
+                return cls
+
+    return None
+
 
 class DecoratorDescriptor:
     """
@@ -94,7 +115,12 @@ class TypeDescriptor:
     """
     This class provides a way to introspect Python classes, their methods, decorators, and type hints.
     """
-    # inner class
+    # inner classes
+
+    class ParameterDescriptor:
+        def __init__(self, name: str, type: Type):
+            self.name = name
+            self.type = type
 
     class MethodDescriptor:
         """
@@ -107,12 +133,14 @@ class TypeDescriptor:
             self.method = method
             self.decorators: list[DecoratorDescriptor] = Decorators.get(method)
             self.param_types : list[Type] = []
+            self.params: list[TypeDescriptor.ParameterDescriptor] = []
 
             type_hints = get_type_hints(method)
             sig = signature(method)
 
             for name, _ in sig.parameters.items():
                 if name != 'self':
+                    self.params.append(TypeDescriptor.ParameterDescriptor(name, type_hints.get(name)))
                     self.param_types.append(type_hints.get(name, object))
 
             self.return_type = type_hints.get('return', None)

{aspyx-1.6.1 → aspyx-1.8.0}/src/aspyx/util/__init__.py

@@ -4,11 +4,14 @@ This module provides utility functions.
 from .stringbuilder import StringBuilder
 from .logger import Logger
 from .serialization import TypeSerializer, TypeDeserializer, get_serializer, get_deserializer
+from .copy_on_write_cache import CopyOnWriteCache
 
 __all__ = [
     "StringBuilder",
     "Logger",
 
+    "CopyOnWriteCache",
+
     "TypeSerializer",
     "TypeDeserializer",
     "get_serializer",

aspyx-1.8.0/src/aspyx/util/copy_on_write_cache.py

@@ -0,0 +1,40 @@
+from typing import TypeVar, Generic, Optional, Callable
+
+K = TypeVar("K")
+V = TypeVar("V")
+
+class CopyOnWriteCache(Generic[K, V]):
+    """
+    cache, that clones the existing dict, whenever a new item is added, avoiding any locks
+    """
+    # constructor
+
+    def __init__(self, factory: Optional[Callable[[K], V]] = None) -> None:
+        self._cache: dict[K, V] = {}
+        self._factory = factory
+
+    # public
+
+    def get(self, key: K, factory: Optional[Callable[[K], V]] = None) -> Optional[V]:
+        value = self._cache.get(key, None)
+        if value is None:
+            if factory is not None:
+                value = factory(key)
+                self.put(key, value)
+
+            elif self._factory is not None:
+                value = self._factory(key)
+                self.put(key, value)
+
+        return value
+
+    def put(self, key: K, value: V) -> None:
+        new_cache = self._cache.copy()
+        new_cache[key] = value
+        self._cache = new_cache
+
+    def contains(self, key: K) -> bool:
+        return key in self._cache
+
+    def clear(self) -> None:
+        self._cache = {}

{aspyx-1.6.1 → aspyx-1.8.0}/src/aspyx/util/serialization.py

@@ -24,7 +24,9 @@ class TypeDeserializer:
         args = get_args(typ)
 
         if origin is Union:
-            deserializers = [TypeDeserializer(arg) for arg in args if arg is not type(None)]
+            # Optional[X] => Union[X, NoneType]
+            deserializers = [self._build_deserializer(arg) for arg in args if arg is not type(None)]
+
             def deser_union(value):
                 if value is None:
                     return None
@@ -33,34 +35,61 @@ class TypeDeserializer:
                         return d(value)
                     except Exception:
                         continue
-                return value
+                raise ValueError(f"Cannot deserialize value: {value!r} into Union[{args}]")
+
             return deser_union
 
         if isinstance(typ, type) and issubclass(typ, BaseModel):
-            return typ.model_validate
+            field_deserializers = {
+                name: self._build_deserializer(field.annotation)
+                for name, field in typ.model_fields.items()
+            }
+
+            def deser_model(value):
+                if isinstance(value, typ):
+                    return value
+                if not isinstance(value, dict):
+                    raise TypeError(f"Expected dict to construct {typ.__name__}, got {type(value).__name__}")
+                kwargs = {
+                    k: field_deserializers[k](v)
+                    for k, v in value.items()
+                    if k in field_deserializers
+                }
+                return typ.model_construct(**kwargs)
+
+            return deser_model
 
         if is_dataclass(typ):
-            field_deserializers = {f.name: TypeDeserializer(f.type) for f in fields(typ)}
+            field_deserializers = {
+                f.name: self._build_deserializer(f.type) for f in fields(typ)
+            }
+
             def deser_dataclass(value):
-                if is_dataclass(value):
+                if isinstance(value, typ):
                     return value
-
+                if not isinstance(value, dict):
+                    raise TypeError(f"Expected dict to construct {typ}, got {type(value).__name__}")
                 return typ(**{
-                    k: field_deserializers[k](v) for k, v in value.items()
+                    k: field_deserializers[k](v) for k, v in value.items() if k in field_deserializers
                 })
+
             return deser_dataclass
 
         if origin is list:
-            item_deser = TypeDeserializer(args[0]) if args else lambda x: x
+            item_type = args[0] if args else Any
+            item_deser = self._build_deserializer(item_type)
             return lambda v: [item_deser(item) for item in v]
 
         if origin is dict:
-            key_deser = TypeDeserializer(args[0]) if args else lambda x: x
-            val_deser = TypeDeserializer(args[1]) if len(args) > 1 else lambda x: x
+            key_type = args[0] if args else Any
+            val_type = args[1] if len(args) > 1 else Any
+            key_deser = self._build_deserializer(key_type)
+            val_deser = self._build_deserializer(val_type)
             return lambda v: {key_deser(k): val_deser(val) for k, val in v.items()}
 
-        # Fallback
-        return lambda v: v
+        # Fallback: primitive types, str, int, etc.
+        return lambda v: typ(v) if callable(typ) else v
+
 
 class TypeSerializer:
     def __init__(self, typ):

aspyx-1.8.0/tests/test_serialization.py

@@ -0,0 +1,56 @@
+from dataclasses import dataclass
+from lib2to3.btm_utils import pysyms
+
+from pydantic import BaseModel
+
+from aspyx.util import get_serializer, get_deserializer
+
+@dataclass
+class EmbeddedDataClass:
+    name: str
+
+embedded_dataclass = EmbeddedDataClass(name="foo")
+
+class EmbeddedPydantic(BaseModel):
+    name: str
+
+embedded_pydantic = EmbeddedPydantic(name="foo")
+
+@dataclass
+class DataClass:
+    int_attr : int
+    bool_attr: bool
+    int_list : list[int]
+
+    embedded_dataclass : EmbeddedDataClass
+    embedded_pydantic: EmbeddedPydantic
+
+data_class = DataClass(int_attr=1, bool_attr=True, int_list=[1], embedded_pydantic=embedded_pydantic, embedded_dataclass=embedded_dataclass)
+
+class Pydantic(BaseModel):
+    int_attr: int
+    bool_attr: bool
+
+    int_list : list[int]
+
+    embedded_dataclass: EmbeddedDataClass
+    embedded_pydantic: EmbeddedPydantic
+
+pydantic = Pydantic(int_attr=1, bool_attr=True,  int_list=[1], embedded_pydantic=embedded_pydantic, embedded_dataclass=embedded_dataclass)
+
+class TestSerialization():
+    def test_data_class(self):
+        serializer = get_serializer(DataClass)
+        deserializer = get_deserializer(DataClass)
+
+        result = deserializer(serializer(data_class))
+
+        assert data_class == result
+
+    def test_pydantic(self):
+        serializer = get_serializer(Pydantic)
+        deserializer = get_deserializer(Pydantic)
+
+        result = deserializer(serializer(pydantic))
+
+        assert pydantic == result