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

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

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

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "neuroglia-python"
-version = "0.7.7"
+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.7 → neuroglia_python-0.7.9}/src/neuroglia/__init__.py

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

{neuroglia_python-0.7.7 → 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
@@ -553,11 +557,33 @@ class JsonSerializer(TextSerializer):
         return bool(re.match(r"^-?\d+\.?\d*(?:[eE][+-]?\d+)?$", value.strip()))
 
     def _is_datetime_string(self, value: str) -> bool:
-        """Check if a string looks like an ISO datetime."""
+        """
+        Check if a string looks like an ISO datetime.
+
+        Uses a conservative approach to avoid false positives:
+        - Requires the string to contain 'T' or a time separator to distinguish
+          datetime strings from date-only strings in type inference scenarios
+        - Validates with datetime.fromisoformat after initial filtering
+        - Catches TypeError for non-string inputs that slip through
+
+        Note: Date-only strings like '2025-12-15' are NOT matched as datetime strings
+        in type inference to avoid unexpected conversions. If you need to deserialize
+        date-only strings, provide explicit type hints.
+        """
+        # Fast pre-check: must be a non-empty string
+        if not isinstance(value, str) or not value:
+            return False
+
+        # Require 'T' separator to distinguish datetime from date-only strings
+        # This prevents date-only strings like '2025-12-15' from being converted
+        # to datetime objects when the intended type might be a plain date or string
+        if "T" not in value and " " not in value:
+            return False
+
         try:
             datetime.fromisoformat(value.replace("Z", "+00:00"))
             return True
-        except (ValueError, AttributeError):
+        except (ValueError, AttributeError, TypeError):
             return False
 
     def _try_deserialize_enum(self, value: str, target_type: type) -> Any:
@@ -581,6 +607,15 @@ class JsonSerializer(TextSerializer):
         """
         Fallback enum detection that only checks the target type's module.
         Used when TypeRegistry is not available.
+
+        Matching priority (returns on first match):
+        1. Exact match on enum member value
+        2. Exact match on enum member name
+        3. Case-insensitive match on value (lowercase comparison)
+        4. Case-insensitive match on name (uppercase comparison for CONSTANT_CASE convention)
+
+        Note: This returns the first matching enum from the module. For deterministic
+        behavior with multiple enum types, use TypeRegistry with explicit module registration.
         """
         try:
             import sys
@@ -592,11 +627,25 @@ class JsonSerializer(TextSerializer):
 
             module = sys.modules.get(target_module)
             if module:
+                value_lower = value.lower()
+                value_upper = value.upper()
+
                 for attr_name in dir(module):
                     attr = getattr(module, attr_name)
                     if isinstance(attr, type) and issubclass(attr, Enum) and attr != Enum:
                         for enum_member in attr:
-                            if enum_member.value == value or enum_member.value == value.lower() or enum_member.name == value or enum_member.name == value.upper():
+                            # Priority 1: Exact match on value
+                            if enum_member.value == value:
+                                return enum_member
+                            # Priority 2: Exact match on name
+                            if enum_member.name == value:
+                                return enum_member
+                            # Priority 3: Case-insensitive match on value
+                            member_value = enum_member.value
+                            if isinstance(member_value, str) and member_value.lower() == value_lower:
+                                return enum_member
+                            # Priority 4: Case-insensitive match on name (CONSTANT_CASE convention)
+                            if enum_member.name.upper() == value_upper:
                                 return enum_member
         except Exception:
             pass
@@ -688,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.
@@ -725,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)
@@ -757,10 +831,33 @@ class JsonSerializer(TextSerializer):
             return value
 
         elif hasattr(expected_type, "__bases__") and expected_type.__bases__ and issubclass(expected_type, Enum):
-            # Handle Enum deserialization - check both value and name
+            # Handle Enum deserialization with priority-based matching:
+            # 1. Exact match on value
+            # 2. Exact match on name
+            # 3. Case-insensitive match on value (for string values)
+            # 4. Case-insensitive match on name
+            value_str = str(value) if not isinstance(value, str) else value
+            value_lower = value_str.lower()
+            value_upper = value_str.upper()
+
+            for enum_member in expected_type:
+                # Priority 1: Exact match on value
+                if enum_member.value == value:
+                    return enum_member
+                # Priority 2: Exact match on name
+                if enum_member.name == value_str:
+                    return enum_member
+
+            # Second pass for case-insensitive matching
             for enum_member in expected_type:
-                if enum_member.value == value or enum_member.name == value:
+                # Priority 3: Case-insensitive match on value
+                member_value = enum_member.value
+                if isinstance(member_value, str) and member_value.lower() == value_lower:
                     return enum_member
+                # Priority 4: Case-insensitive match on name
+                if enum_member.name.upper() == value_upper:
+                    return enum_member
+
             raise ValueError(f"Invalid enum value for {expected_type.__name__}: {value}")
 
         else:
@@ -774,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":
         """