fh-pydantic-form 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

fh_pydantic_form/form_parser.py

@@ -275,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)
@@ -311,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
@@ -331,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()
@@ -430,52 +460,23 @@ 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
-
             # Convert string to int for integer-valued enums in simple lists
             if (
-                not field_def["is_model_type"]
-                and isinstance(item_type, type)
+                isinstance(item_type, type)
                 and issubclass(item_type, Enum)
                 and isinstance(item_data, str)
             ):
@@ -491,7 +492,6 @@ def _parse_list_fields(
                     # Empty enum, leave item_data as-is
                     pass
 
-            # For model types, keep as dict for now
             items.append(item_data)
 
         if items:  # Only add if items were found
@@ -515,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]]:

fh_pydantic_form/form_renderer.py

@@ -28,9 +28,11 @@ from fh_pydantic_form.form_parser import (
     _parse_list_fields,
     _parse_non_list_fields,
 )
+from fh_pydantic_form.list_path import walk_path
 from fh_pydantic_form.registry import FieldRendererRegistry
 from fh_pydantic_form.type_helpers import _UNSET, get_default
 from fh_pydantic_form.ui_style import (
+    COMPACT_EXTRA_CSS,
     SpacingTheme,
     SpacingValue,
     _normalize_spacing,
@@ -207,17 +209,56 @@ class PydanticForm(Generic[ModelType]):
     - validating request data against the model
     """
 
+    # --- module-level flag (add near top of file) ---
+
     def _compact_wrapper(self, inner: FT) -> FT:
         """
-        Wrap inner markup with a '.compact-form' div and inject one <style>
-        block when compact theme is used.
+        Wrap inner markup in a namespaced div.
+        Auto-inject the compact CSS the *first* time any compact form is rendered.
         """
-        if self.spacing == SpacingTheme.COMPACT:
-            from fh_pydantic_form.ui_style import COMPACT_EXTRA_CSS
+        wrapper_cls = "fhpf-wrapper w-full flex-1"
 
-            return fh.Div(COMPACT_EXTRA_CSS, inner, cls="compact-form")
-        else:
-            return inner
+        if self.spacing != SpacingTheme.COMPACT:
+            return fh.Div(inner, cls=wrapper_cls)
+
+        return fh.Div(
+            COMPACT_EXTRA_CSS,
+            fh.Div(inner, cls="fhpf-fields fhpf-compact"),
+            cls=wrapper_cls,
+        )
+
+    def _clone_with_values(self, values: Dict[str, Any]) -> "PydanticForm":
+        """
+        Create a copy of this renderer with the same configuration but different values.
+
+        This preserves all constructor arguments (label_colors, custom_renderers, etc.)
+        to avoid configuration drift during refresh operations.
+
+        Args:
+            values: New values dictionary to use in the cloned renderer
+
+        Returns:
+            A new PydanticForm instance with identical configuration but updated values
+        """
+        # Get custom renderers if they were registered (not stored directly on instance)
+        # We'll rely on global registry state being preserved
+
+        clone = PydanticForm(
+            form_name=self.name,
+            model_class=self.model_class,
+            initial_values=None,  # Will be set via values_dict below
+            custom_renderers=None,  # Registry is global, no need to re-register
+            disabled=self.disabled,
+            disabled_fields=self.disabled_fields,
+            label_colors=self.label_colors,
+            exclude_fields=self.exclude_fields,
+            spacing=self.spacing,
+        )
+
+        # Set the values directly
+        clone.values_dict = values
+
+        return clone
 
     def __init__(
         self,
@@ -393,6 +434,7 @@ class PydanticForm(Generic[ModelType]):
                 disabled=is_field_disabled,  # Pass the calculated disabled state
                 label_color=label_color,  # Pass the label color if specified
                 spacing=self.spacing,  # Pass the spacing
+                field_path=[field_name],  # Set top-level field path
             )
 
             rendered_field = renderer.render()
@@ -452,15 +494,8 @@ class PydanticForm(Generic[ModelType]):
                 cls=mui.AlertT.warning + " mb-4",  # Add margin bottom
             )
 
-        # Create Temporary Renderer instance
-        temp_renderer = PydanticForm(
-            form_name=self.name,
-            model_class=self.model_class,
-            # No initial_data needed here, we set values_dict below
-            spacing=self.spacing,
-        )
-        # Set the values based on the parsed (or fallback) data
-        temp_renderer.values_dict = parsed_data
+        # Create temporary renderer with same configuration but updated values
+        temp_renderer = self._clone_with_values(parsed_data)
 
         refreshed_inputs_component = temp_renderer.render_inputs()
 
@@ -565,6 +600,8 @@ class PydanticForm(Generic[ModelType]):
         Ensures that every field listed in self.exclude_fields is present in data
         if the model defines a default or default_factory, or if initial_values were provided.
 
+        Also ensures all model fields have appropriate defaults if missing.
+
         Priority order:
         1. initial_values (if provided during form creation)
         2. model defaults/default_factory
@@ -577,6 +614,7 @@ class PydanticForm(Generic[ModelType]):
         Returns:
             The same dictionary instance for method chaining
         """
+        # Handle excluded fields first
         for field_name in self.exclude_fields:
             # Skip if already present (e.g., user provided initial_values)
             if field_name in data:
@@ -613,6 +651,22 @@ class PydanticForm(Generic[ModelType]):
                 # No default → leave missing; validation will surface error
                 logger.debug(f"No default found for excluded field '{field_name}'")
 
+        # Also handle any other missing fields that should have defaults
+        for field_name, field_info in self.model_class.model_fields.items():
+            if field_name not in data:
+                # Try to inject defaults for missing fields
+                if field_name in self.initial_values_dict:
+                    initial_val = self.initial_values_dict[field_name]
+                    if hasattr(initial_val, "model_dump"):
+                        initial_val = initial_val.model_dump()
+                    data[field_name] = initial_val
+                else:
+                    default_val = get_default(field_info)
+                    if default_val is not _UNSET:
+                        if hasattr(default_val, "model_dump"):
+                            default_val = default_val.model_dump()
+                        data[field_name] = default_val
+
         return data
 
     def register_routes(self, app):
@@ -652,123 +706,76 @@ class PydanticForm(Generic[ModelType]):
             f"Registered reset route for form '{self.name}' at {reset_route_path}"
         )
 
-        @app.route(f"/form/{self.name}/list/add/{{field_name}}")
-        async def post_list_add(req, field_name: str):
+        # Try the route with a more explicit pattern
+        route_pattern = f"/form/{self.name}/list/{{action}}/{{list_path:path}}"
+        logger.debug(f"Registering list action route: {route_pattern}")
+
+        @app.route(route_pattern, methods=["POST", "DELETE"])
+        async def list_action(req, action: str, list_path: str):
             """
-            Handle adding an item to a list for this specific form
+            Handle list actions (add/delete) for nested lists in this specific form
 
             Args:
                 req: The request object
-                field_name: The name of the list field
+                action: Either "add" or "delete"
+                list_path: Path to the list field (e.g., "tags" or "main_address/tags" or "other_addresses/1/tags")
 
             Returns:
-                A component for the new list item
+                A component for the new list item (add) or empty response (delete)
             """
-            # Find field info
-            field_info = None
-            item_type = None
-
-            if field_name in self.model_class.model_fields:
-                field_info = self.model_class.model_fields[field_name]
-                annotation = getattr(field_info, "annotation", None)
-
-                if (
-                    annotation is not None
-                    and hasattr(annotation, "__origin__")
-                    and annotation.__origin__ is list
-                ):
-                    item_type = annotation.__args__[0]
-
-                if not item_type:
-                    logger.error(
-                        f"Cannot determine item type for list field {field_name}"
-                    )
-                    return mui.Alert(
-                        f"Cannot determine item type for list field {field_name}",
-                        cls=mui.AlertT.error,
-                    )
-
-            # Create a default item using smart defaults
-            default_item_dict: Dict[str, Any] | str | Any | None = None
-            try:
-                if not item_type:
-                    logger.warning(
-                        f"item_type was None when trying to create default for {field_name}"
-                    )
-                    default_item_dict = ""
-                elif hasattr(item_type, "model_fields"):
-                    # For Pydantic models, use smart default generation
-                    default_item_dict = default_dict_for_model(item_type)
-                else:
-                    # For simple types, use annotation-based defaults
-                    default_item_dict = default_for_annotation(item_type)
+            if action not in {"add", "delete"}:
+                return fh.Response(status_code=400, content="Unknown list action")
 
-                # Final fallback for exotic cases
-                if default_item_dict is None:
-                    default_item_dict = ""
-
-            except Exception as e:
-                logger.error(
-                    f"Error creating default item for {field_name}: {e}", exc_info=True
-                )
-                return fh.Li(
-                    mui.Alert(
-                        f"Error creating default item: {str(e)}", cls=mui.AlertT.error
-                    ),
-                    cls="mb-2",
+            segments = list_path.split("/")
+            try:
+                list_field_info, html_parts, item_type = walk_path(
+                    self.model_class, segments
                 )
+            except ValueError as exc:
+                logger.warning("Bad list path %s – %s", list_path, exc)
+                return mui.Alert(str(exc), cls=mui.AlertT.error)
 
-            # Generate a unique placeholder index
-            placeholder_idx = f"new_{int(pytime.time() * 1000)}"
-
-            # Create a list renderer
-            if field_info is not None:
-                list_renderer = ListFieldRenderer(
-                    field_name=field_name,
-                    field_info=field_info,
-                    value=[],  # Empty list, we only need to render one item
-                    prefix=self.base_prefix,  # Use the form's base prefix
-                )
-            else:
-                logger.error(f"field_info is None for field {field_name}")
-                return mui.Alert(
-                    f"Field info not found for {field_name}",
-                    cls=mui.AlertT.error,
+            if req.method == "DELETE":
+                logger.debug(
+                    f"Received DELETE request for {list_path} for form '{self.name}'"
                 )
+                return fh.Response(status_code=200, content="")
 
-            # The default_item_dict is already in the correct format (dict for models, primitive for simple types)
-            item_data_for_renderer = default_item_dict
-            logger.debug(
-                f"Add item: Using smart default for renderer: {item_data_for_renderer}"
+            # === add (POST) ===
+            default_item = (
+                default_dict_for_model(item_type)
+                if hasattr(item_type, "model_fields")
+                else default_for_annotation(item_type)
             )
 
-            # Render the new item card, set is_open=True to make it expanded by default
-            new_item_card = list_renderer._render_item_card(
-                item_data_for_renderer,  # Pass the dictionary or simple value
-                placeholder_idx,
-                item_type,
-                is_open=True,
+            # Build prefix **without** the list field itself to avoid duplication
+            parts_before_list = html_parts[:-1]  # drop final segment
+            if parts_before_list:
+                html_prefix = f"{self.base_prefix}{'_'.join(parts_before_list)}_"
+            else:
+                html_prefix = self.base_prefix
+
+            # Create renderer for the list field
+            renderer = ListFieldRenderer(
+                field_name=segments[-1],
+                field_info=list_field_info,
+                value=[],
+                prefix=html_prefix,
+                spacing=self.spacing,
+                disabled=self.disabled,
+                field_path=segments,  # Pass the full path segments
+                form_name=self.name,  # Pass the explicit form name
             )
 
-            return new_item_card
-
-        @app.route(f"/form/{self.name}/list/delete/{{field_name}}", methods=["DELETE"])
-        async def delete_list_item(req, field_name: str):
-            """
-            Handle deleting an item from a list for this specific form
-
-            Args:
-                req: The request object
-                field_name: The name of the list field
+            # Generate a unique placeholder index
+            placeholder_idx = f"new_{int(pytime.time() * 1000)}"
 
-            Returns:
-                Empty string to delete the target element
-            """
-            # Return empty string to delete the target element
-            logger.debug(
-                f"Received DELETE request for {field_name} for form '{self.name}'"
+            # Render the new item card, set is_open=True to make it expanded by default
+            new_card = renderer._render_item_card(
+                default_item, placeholder_idx, item_type, is_open=True
             )
-            return fh.Response(status_code=200, content="")
+
+            return new_card
 
     def refresh_button(self, text: Optional[str] = None, **kwargs) -> FT:
         """
@@ -787,9 +794,6 @@ class PydanticForm(Generic[ModelType]):
         # Define the target wrapper ID
         form_content_wrapper_id = f"{self.name}-inputs-wrapper"
 
-        # Define the form ID to include
-        form_id = f"{self.name}-form"
-
         # Define the target URL
         refresh_url = f"/form/{self.name}/refresh"
 
@@ -800,7 +804,7 @@ class PydanticForm(Generic[ModelType]):
             "hx_target": f"#{form_content_wrapper_id}",  # Target the wrapper Div ID
             "hx_swap": "innerHTML",
             "hx_trigger": "click",  # Explicit trigger on click
-            "hx_include": f"#{form_id}",  # Include all form fields in the request
+            "hx_include": "closest form",  # Include all form fields from the enclosing form
             "uk_tooltip": "Update the form display based on current values (e.g., list item titles)",
             "cls": mui.ButtonT.secondary,
         }
@@ -883,3 +887,12 @@ class PydanticForm(Generic[ModelType]):
         logger.info(f"Request validation successful for form '{self.name}'")
 
         return validated_model
+
+    def form_id(self) -> str:
+        """
+        Get the standard form ID for this renderer.
+
+        Returns:
+            The form ID string that should be used for the HTML form element
+        """
+        return f"{self.name}-form"

fh_pydantic_form/list_path.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+import logging
+from typing import List, Tuple, Type, get_origin, get_args
+from pydantic import BaseModel
+from pydantic.fields import FieldInfo
+
+from fh_pydantic_form.type_helpers import _get_underlying_type_if_optional
+
+logger = logging.getLogger(__name__)
+
+
+def walk_path(
+    model: Type[BaseModel], segments: List[str]
+) -> Tuple[FieldInfo, List[str], Type]:
+    """
+    Resolve `segments` against `model`, stopping at the *list* field.
+
+    Args:
+        model: The BaseModel class to traverse
+        segments: Path segments like ["main_address", "tags"] or ["other_addresses", "1", "tags"]
+                 The final segment should always be a list field name.
+
+    Returns:
+        Tuple of:
+        - list_field_info: the FieldInfo for the target list field
+        - html_prefix_parts: segments used to build element IDs (includes indices)
+        - item_type: the concrete python type of items in the list
+
+    Raises:
+        ValueError: if the path is invalid or doesn't lead to a list field
+    """
+    if not segments:
+        raise ValueError("Empty path provided")
+
+    current_model = model
+    html_parts = []
+    i = 0
+
+    # Process all segments except the last one (which should be the list field)
+    while i < len(segments) - 1:
+        segment = segments[i]
+
+        # Check if this segment is a field name
+        if segment in current_model.model_fields:
+            field_info = current_model.model_fields[segment]
+            field_type = _get_underlying_type_if_optional(field_info.annotation)
+            html_parts.append(segment)
+
+            # Check if this is a list field (we're traversing into a list element)
+            if get_origin(field_type) is list:
+                # Next segment should be an index
+                if i + 1 >= len(segments) - 1:
+                    raise ValueError(f"Expected index after list field '{segment}'")
+
+                next_segment = segments[i + 1]
+                if not _is_index_segment(next_segment):
+                    raise ValueError(
+                        f"Expected index after list field '{segment}', got '{next_segment}'"
+                    )
+
+                # Get the item type of the list
+                list_item_type = (
+                    get_args(field_type)[0] if get_args(field_type) else None
+                )
+                if not list_item_type or not hasattr(list_item_type, "model_fields"):
+                    raise ValueError(
+                        f"List field '{segment}' does not contain BaseModel items"
+                    )
+
+                # Add the index to html_parts and update current model
+                html_parts.append(next_segment)
+                current_model = list_item_type
+
+                # Skip the next segment (the index) since we processed it
+                i += 2
+                continue
+
+            # Check if this is a BaseModel field
+            elif hasattr(field_type, "model_fields"):
+                current_model = field_type
+                i += 1
+            else:
+                raise ValueError(f"Field '{segment}' is not a BaseModel or list type")
+
+        elif _is_index_segment(segment):
+            # This should only happen if we're processing an index that wasn't handled above
+            raise ValueError(
+                f"Unexpected index segment '{segment}' without preceding list field"
+            )
+        else:
+            raise ValueError(
+                f"Field '{segment}' not found in model {current_model.__name__}"
+            )
+
+    # Process the final segment (should be a list field)
+    final_field_name = segments[-1]
+    if final_field_name not in current_model.model_fields:
+        raise ValueError(
+            f"Field '{final_field_name}' not found in model {current_model.__name__}"
+        )
+
+    list_field_info = current_model.model_fields[final_field_name]
+    list_field_type = _get_underlying_type_if_optional(list_field_info.annotation)
+
+    # Verify this is actually a list field
+    if get_origin(list_field_type) is not list:
+        raise ValueError(f"Final field '{final_field_name}' is not a list type")
+
+    # Get the item type
+    item_type_args = get_args(list_field_type)
+    if not item_type_args:
+        raise ValueError(
+            f"Cannot determine item type for list field '{final_field_name}'"
+        )
+
+    item_type = item_type_args[0]
+    html_parts.append(final_field_name)
+
+    logger.debug(
+        f"walk_path resolved: {segments} -> field_info={list_field_info}, html_parts={html_parts}, item_type={item_type}"
+    )
+
+    return list_field_info, html_parts, item_type
+
+
+def _is_index_segment(segment: str) -> bool:
+    """
+    Check if a segment represents an index (purely numeric or placeholder like 'new_1234').
+
+    Args:
+        segment: The segment to check
+
+    Returns:
+        True if the segment represents an index
+    """
+    # Pure numeric (like "0", "1", "2")
+    if segment.isdigit():
+        return True
+
+    # Placeholder format (like "new_1234567890")
+    if segment.startswith("new_") and len(segment) > 4:
+        timestamp_part = segment[4:]
+        return timestamp_part.isdigit()
+
+    return False