fh-pydantic-form 0.1.3__py3-none-any.whl → 0.2.1__py3-none-any.whl

fh_pydantic_form/form_parser.py

@@ -1,4 +1,5 @@
 import logging
+from enum import Enum
 from typing import (
     Any,
     Dict,
@@ -10,6 +11,7 @@ from typing import (
 
 from fh_pydantic_form.type_helpers import (
     _get_underlying_type_if_optional,
+    _is_enum_type,
     _is_literal_type,
     _is_optional_type,
 )
@@ -49,6 +51,7 @@ def _parse_non_list_fields(
     model_class,
     list_field_defs: Dict[str, Dict[str, Any]],
     base_prefix: str = "",
+    exclude_fields: Optional[List[str]] = None,
 ) -> Dict[str, Any]:
     """
     Parses non-list fields from form data based on the model definition.
@@ -58,16 +61,22 @@ def _parse_non_list_fields(
         model_class: The Pydantic model class defining the structure
         list_field_defs: Dictionary of list field definitions (to skip)
         base_prefix: Prefix to use when looking up field names in form_data
+        exclude_fields: Optional list of field names to exclude from parsing
 
     Returns:
         Dictionary with parsed non-list fields
     """
     result: Dict[str, Any] = {}
+    exclude_fields = exclude_fields or []
 
     for field_name, field_info in model_class.model_fields.items():
         if field_name in list_field_defs:
             continue  # Skip list fields, handled separately
 
+        # Skip excluded fields - they will be handled by default injection later
+        if field_name in exclude_fields:
+            continue
+
         # Create full key with prefix
         full_key = f"{base_prefix}{field_name}"
 
@@ -84,6 +93,10 @@ def _parse_non_list_fields(
         elif _is_literal_type(annotation):
             result[field_name] = _parse_literal_field(full_key, form_data, field_info)
 
+        # Handle Enum fields (including Optional[Enum])
+        elif _is_enum_type(annotation):
+            result[field_name] = _parse_enum_field(full_key, form_data, field_info)
+
         # Handle nested model fields (including Optional[NestedModel])
         elif (
             isinstance(annotation, type)
@@ -157,6 +170,49 @@ def _parse_literal_field(field_name: str, form_data: Dict[str, Any], field_info)
     return value
 
 
+def _parse_enum_field(field_name: str, form_data: Dict[str, Any], field_info) -> Any:
+    """
+    Parse an Enum field, converting empty string OR '-- None --' to None for optional fields.
+
+    Args:
+        field_name: Name of the field to parse
+        form_data: Dictionary containing form field data
+        field_info: FieldInfo object to check for optionality
+
+    Returns:
+        The parsed value or None for empty/None values with optional fields
+    """
+    value = form_data.get(field_name)
+
+    # Check if the field is Optional[Enum]
+    if _is_optional_type(field_info.annotation):
+        # If the submitted value is the empty string OR the display text for None, treat it as None
+        if value == "" or value == "-- None --":
+            return None
+
+    enum_cls = _get_underlying_type_if_optional(field_info.annotation)
+    if isinstance(enum_cls, type) and issubclass(enum_cls, Enum) and value is not None:
+        try:
+            first = next(iter(enum_cls))
+            # Handle integer enums - convert string to int
+            if isinstance(first.value, int):
+                try:
+                    value = int(value)
+                except (TypeError, ValueError):
+                    # leave it as-is; pydantic will raise if really invalid
+                    pass
+            # Handle string enums - keep the value as-is, let Pydantic handle validation
+            elif isinstance(first.value, str):
+                # Keep the submitted value unchanged for string enums
+                pass
+        except StopIteration:
+            # Empty enum, leave value as-is
+            pass
+
+    # Return the actual submitted value for Pydantic validation
+    return value
+
+
 def _parse_simple_field(
     field_name: str, form_data: Dict[str, Any], field_info=None
 ) -> Any:
@@ -219,7 +275,9 @@ def _parse_nested_model_field(
             break
 
     if found_any_subfield:
-        # Process each field in the nested model
+        # ------------------------------------------------------------------
+        # 1. Process each **non-list** field in the nested model
+        # ------------------------------------------------------------------
         for sub_field_name, sub_field_info in nested_model_class.model_fields.items():
             sub_key = f"{current_prefix}{sub_field_name}"
             annotation = getattr(sub_field_info, "annotation", None)
@@ -255,6 +313,22 @@ def _parse_nested_model_field(
             elif is_optional:
                 nested_data[sub_field_name] = None
 
+        # ------------------------------------------------------------------
+        # 2. Handle **list fields** inside this nested model (e.g. Address.tags)
+        #    Re-use the generic helpers so behaviour matches top-level lists.
+        # ------------------------------------------------------------------
+        nested_list_defs = _identify_list_fields(nested_model_class)
+        if nested_list_defs:
+            list_results = _parse_list_fields(
+                form_data,
+                nested_list_defs,
+                current_prefix,  # ← prefix for this nested model
+            )
+            # Merge without clobbering keys already set in step 1
+            for lf_name, lf_val in list_results.items():
+                if lf_name not in nested_data:
+                    nested_data[lf_name] = lf_val
+
         return nested_data
 
     # No data found for this nested model
@@ -275,13 +349,25 @@ def _parse_nested_model_field(
     default_value = None
     default_applied = False
 
-    if hasattr(field_info, "default") and field_info.default is not None:
+    # Import PydanticUndefined to check for it specifically
+    try:
+        from pydantic_core import PydanticUndefined
+    except ImportError:
+        # Fallback for older pydantic versions
+        from pydantic.fields import PydanticUndefined
+
+    if (
+        hasattr(field_info, "default")
+        and field_info.default is not None
+        and field_info.default is not PydanticUndefined
+    ):
         default_value = field_info.default
         default_applied = True
         logger.debug(f"Nested field {field_name} using default value.")
     elif (
         hasattr(field_info, "default_factory")
         and field_info.default_factory is not None
+        and field_info.default_factory is not PydanticUndefined
     ):
         try:
             default_value = field_info.default_factory()
@@ -374,49 +460,38 @@ def _parse_list_fields(
 
         items = []
         for idx_str in ordered_indices:
+            # ------------------------------------------------------------------
+            # If this list stores *BaseModel* items, completely re-parse the item
+            # so that any inner lists (e.g. tags inside Address) become real lists
+            # instead of a bunch of 'tags_0', 'tags_new_xxx' flat entries.
+            # ------------------------------------------------------------------
+            if field_def["is_model_type"]:
+                item_prefix = f"{base_prefix}{field_name}_{idx_str}_"
+                parsed_item = _parse_model_list_item(form_data, item_type, item_prefix)
+                items.append(parsed_item)
+                continue
+
+            # ───────── simple (non-model) items – keep existing logic ──────────
             item_data = list_items_temp[field_name][idx_str]
 
-            # Handle empty strings for optional fields inside models
-            if isinstance(item_data, dict):
-                # Check each subfield for optional type and empty string
-                for subfield_name, subfield_value in list(item_data.items()):
-                    # Get the corresponding field_info from the item_type
-                    if (
-                        hasattr(item_type, "model_fields")
-                        and subfield_name in item_type.model_fields
-                    ):
-                        subfield_info = item_type.model_fields[subfield_name]
-                        # Convert empty strings to None for optional fields
-                        if subfield_value == "" and _is_optional_type(
-                            subfield_info.annotation
-                        ):
-                            item_data[subfield_name] = None
-                        # Convert 'on' to True for boolean fields
-                        elif subfield_value == "on":
-                            annotation = getattr(subfield_info, "annotation", None)
-                            base_type = _get_underlying_type_if_optional(annotation)
-                            if base_type is bool:
-                                item_data[subfield_name] = True
-
-                # Handle missing boolean fields in model list items
-                if field_def["is_model_type"] and hasattr(item_type, "model_fields"):
-                    # Iterate through all model fields to find missing boolean fields
-                    for (
-                        model_field_name,
-                        model_field_info,
-                    ) in item_type.model_fields.items():
-                        annotation = getattr(model_field_info, "annotation", None)
-                        base_type = _get_underlying_type_if_optional(annotation)
-                        is_bool_type = base_type is bool
-
-                        # If it's a boolean field and not in the item_data, set it to False
-                        if is_bool_type and model_field_name not in item_data:
-                            logger.info(
-                                f"Setting missing boolean '{model_field_name}' to False for item in list '{field_name}'"
-                            )
-                            item_data[model_field_name] = False
-
-            # For model types, keep as dict for now
+            # Convert string to int for integer-valued enums in simple lists
+            if (
+                isinstance(item_type, type)
+                and issubclass(item_type, Enum)
+                and isinstance(item_data, str)
+            ):
+                try:
+                    first = next(iter(item_type))
+                    if isinstance(first.value, int):
+                        try:
+                            item_data = int(item_data)
+                        except (TypeError, ValueError):
+                            # leave it as-is; pydantic will raise if really invalid
+                            pass
+                except StopIteration:
+                    # Empty enum, leave item_data as-is
+                    pass
+
             items.append(item_data)
 
         if items:  # Only add if items were found
@@ -440,6 +515,39 @@ def _parse_list_fields(
     return final_lists
 
 
+def _parse_model_list_item(
+    form_data: Dict[str, Any],
+    item_type,
+    item_prefix: str,
+) -> Dict[str, Any]:
+    """
+    Fully parse a single BaseModel list item – including its own nested lists.
+
+    Re-uses the existing non-list and list helpers so we don't duplicate logic.
+
+    Args:
+        form_data: Dictionary containing form field data
+        item_type: The BaseModel class for this list item
+        item_prefix: Prefix for this specific list item (e.g., "main_form_compact_other_addresses_0_")
+
+    Returns:
+        Dictionary with fully parsed item data including nested lists
+    """
+    nested_list_defs = _identify_list_fields(item_type)
+    # 1. Parse scalars & nested models
+    result = _parse_non_list_fields(
+        form_data,
+        item_type,
+        nested_list_defs,
+        base_prefix=item_prefix,
+    )
+    # 2. Parse inner lists
+    result.update(
+        _parse_list_fields(form_data, nested_list_defs, base_prefix=item_prefix)
+    )
+    return result
+
+
 def _parse_list_item_key(
     key: str, list_field_defs: Dict[str, Dict[str, Any]], base_prefix: str = ""
 ) -> Optional[Tuple[str, str, Optional[str], bool]]: