neuroglia-python 0.7.8__tar.gz → 0.7.9__tar.gz

{neuroglia_python-0.7.8 → neuroglia_python-0.7.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuroglia-python
-Version: 0.7.8
+Version: 0.7.9
 Summary: Port from .NET to Python of the Neuroglia Framework
 License: Apache
 License-File: LICENSE

{neuroglia_python-0.7.8 → neuroglia_python-0.7.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "neuroglia-python"
-version = "0.7.8"
+version = "0.7.9"
 description = "Port from .NET to Python of the Neuroglia Framework"
 authors = ["Charles d'Avernas <charles.davernas@neuroglia.io>", "Bruno van de Werve <bvandewe@gmail.com>"]
 license = "Apache"

{neuroglia_python-0.7.8 → neuroglia_python-0.7.9}/src/neuroglia/__init__.py

@@ -62,7 +62,7 @@ __all__ = [
 ]
 
 # Framework metadata
-__version__ = "0.7.8"
+__version__ = "0.7.9"
 __author__ = "Neuroglia Team"
 __email__ = "team@neuroglia.io"
 __license__ = "Apache"

{neuroglia_python-0.7.8 → neuroglia_python-0.7.9}/src/neuroglia/serialization/json.py

@@ -445,6 +445,10 @@ class JsonSerializer(TextSerializer):
 
     def _deserialize_object(self, data: dict, expected_type: type) -> Any:
         """Deserialize a dictionary into an object using type annotations."""
+        # Handle Pydantic BaseModel types using model_validate for proper initialization
+        if self._is_pydantic_model(expected_type):
+            return expected_type.model_validate(data)
+
         fields = {}
 
         # Collect all type annotations from the class hierarchy
@@ -733,6 +737,10 @@ class JsonSerializer(TextSerializer):
                     object.__setattr__(instance, key, val)
                 return instance
 
+            # Handle Pydantic BaseModel deserialization
+            if self._is_pydantic_model(expected_type):
+                return expected_type.model_validate(value)
+
             origin_expected = get_origin(expected_type)
             if expected_type == dict or origin_expected is dict:
                 # If the expected type is a plain dict, we need to deserialize each value in the dict.
@@ -770,20 +778,41 @@ class JsonSerializer(TextSerializer):
                 # Check if the item should be a dataclass instance
                 if isinstance(v, dict) and is_dataclass(item_type):
                     # Deserialize dict to dataclass using proper field deserialization
+                    # Use get_type_hints() to properly resolve type annotations (e.g., dict[str, Any])
+                    try:
+                        dataclass_type_hints = get_type_hints(item_type)
+                    except (NameError, TypeError, AttributeError):
+                        dataclass_type_hints = {field.name: field.type for field in fields(item_type)}
+                    except Exception:
+                        dataclass_type_hints = {field.name: field.type for field in fields(item_type)}
                     field_dict = {}
                     for field in fields(item_type):
                         if field.name in v:
-                            field_type = field.type
+                            field_type = dataclass_type_hints.get(field.name, field.type)
                             if isinstance(field_type, str):
                                 field_dict[field.name] = v[field.name]
                             else:
                                 field_value = self._deserialize_nested(v[field.name], field_type)
                                 field_dict[field.name] = field_value
+                    # Ensure Optional fields missing from the payload are explicitly populated
+                    for field in fields(item_type):
+                        if field.name in field_dict:
+                            continue
+                        resolved_type = dataclass_type_hints.get(field.name, field.type)
+                        if field.default is not MISSING:
+                            field_dict[field.name] = field.default
+                        elif field.default_factory is not MISSING:  # type: ignore[attr-defined]
+                            field_dict[field.name] = field.default_factory()  # type: ignore[attr-defined]
+                        elif self._is_optional_type(resolved_type):
+                            field_dict[field.name] = None
                     # Create instance and set fields (works for frozen and non-frozen dataclasses)
                     item_instance: Any = object.__new__(cast(type, item_type))
                     for key, val in field_dict.items():
                         object.__setattr__(item_instance, key, val)
                     values.append(item_instance)
+                elif isinstance(v, dict) and self._is_pydantic_model(item_type):
+                    # Use Pydantic's model_validate for proper model initialization
+                    values.append(item_type.model_validate(v))
                 else:
                     # For non-dataclass types, use regular deserialization
                     deserialized = self._deserialize_nested(v, item_type)
@@ -842,6 +871,28 @@ class JsonSerializer(TextSerializer):
             return any(arg is type(None) for arg in get_args(annotation))
         return False
 
+    def _is_pydantic_model(self, cls: Any) -> bool:
+        """
+        Check if a type is a Pydantic BaseModel subclass.
+
+        Uses duck typing to avoid hard dependency on Pydantic being installed.
+        Pydantic v2 models have a `model_validate` classmethod that accepts dict data.
+
+        Args:
+            cls: The type to check
+
+        Returns:
+            True if the type appears to be a Pydantic BaseModel, False otherwise
+        """
+        if not isinstance(cls, type):
+            return False
+        # Check for Pydantic v2 model_validate method (preferred detection)
+        if hasattr(cls, "model_validate") and callable(getattr(cls, "model_validate", None)):
+            # Additional check: Pydantic models also have model_fields
+            if hasattr(cls, "model_fields"):
+                return True
+        return False
+
     @staticmethod
     def configure(builder: "ApplicationBuilderBase", modules: Optional[list[str]] = None) -> "ApplicationBuilderBase":
         """