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

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

fh_pydantic_form/ui_style.py

@@ -1,5 +1,6 @@
 from enum import Enum, auto
 from typing import Dict, Literal, Union
+
 import fasthtml.common as fh
 
 
@@ -50,15 +51,17 @@ SPACING_MAP: Dict[SpacingTheme, Dict[str, str]] = {
         "accordion_content": "",
         "input_size": "",
         "input_padding": "",
+        "horizontal_gap": "gap-3",
+        "label_align": "items-start",
     },
     SpacingTheme.COMPACT: {
-        "outer_margin": "mb-0.5",
-        "outer_margin_sm": "mb-0.5",
-        "inner_gap": "",
-        "inner_gap_small": "",
-        "stack_gap": "",
-        "padding": "p-2",
-        "padding_sm": "p-1",
+        "outer_margin": "mb-0",
+        "outer_margin_sm": "mb-0",
+        "inner_gap": "space-y-1",
+        "inner_gap_small": "space-y-0.5",
+        "stack_gap": "space-y-1",
+        "padding": "p-1",
+        "padding_sm": "p-0.5",
         "padding_card": "px-2 py-1",
         "card_border": "",
         "section_divider": "",
@@ -68,6 +71,8 @@ SPACING_MAP: Dict[SpacingTheme, Dict[str, str]] = {
         "accordion_content": "uk-padding-remove-vertical",
         "input_size": "uk-form-small",
         "input_padding": "p-1",
+        "horizontal_gap": "gap-2",
+        "label_align": "items-center",
     },
 }
 
@@ -78,46 +83,52 @@ def spacing(token: str, spacing: SpacingValue) -> str:
     return SPACING_MAP[theme][token]
 
 
-# CSS override to kill any residual borders in compact mode
+# Optional minimal CSS for compact mode - affects only form inputs, not layout
+# Host applications can optionally inject this once at app level if desired
 COMPACT_EXTRA_CSS = fh.Style("""
-/* Aggressive margin reduction for all UIkit margin utilities */
-.compact-form .uk-margin-small-bottom,
-.compact-form .uk-margin,
-.compact-form .uk-margin-bottom {
-    margin-bottom: 2px !important;
-}
-
-/* Remove borders and shrink accordion chrome */
-.compact-form .uk-accordion > li,
-.compact-form .uk-accordion .uk-accordion-content {
-    border: 0 !important;
-}
-
-/* Minimize accordion content padding */
-.compact-form .uk-accordion-content {
-    padding-top: 0.25rem !important;
-    padding-bottom: 0.25rem !important;
-}
-
-/* Shrink accordion item title padding */
-.compact-form li.uk-open > a {
-    padding-top: 0.25rem;
-    padding-bottom: 0.25rem;
-}
-
-/* Apply smaller font and reduced padding to all form inputs */
-.compact-form input,
-.compact-form select,
-.compact-form textarea {
-    line-height: 1.25rem !important;   /* ~20px */
-    font-size: 0.8125rem !important;   /* 13px */
-}
-
-/* Legacy overrides for specific UIkit classes */
-.compact-form input.uk-form-small,
-.compact-form select.uk-form-small,
-.compact-form textarea.uk-textarea-small {
-    padding-top: 2px !important;
-    padding-bottom: 2px !important;
+/* Compact polish – applies ONLY inside .fhpf-compact ------------------- */
+.fhpf-compact {
+
+  /* Accordion chrome: remove border and default 20 px gap */
+  .uk-accordion > li,
+  .uk-accordion > li + li {          /* second & later items */
+        border-top: 0 !important;
+        margin-top: 0 !important;
+  }
+  .uk-accordion-title::after {       /* the hair-line we still see */
+        border-top: 0 !important;
+  }
+
+  /* Tighter title and content padding */
+  li > a.uk-accordion-title,
+  .uk-accordion-content {
+        padding-top: 0.25rem !important;
+        padding-bottom: 0.25rem !important;
+  }
+
+  /* Remove residual card outline */
+  .uk-card,
+  .uk-card-body { border: 0 !important; }
+
+  /* Small-size inputs */
+  input, select, textarea {
+        line-height: 1.25rem !important;
+        font-size: 0.8125rem !important;
+        padding-top: 0.25rem !important;
+        padding-bottom: 0.25rem !important;
+  }
+
+  /* Legacy uk-form-small support */
+  input.uk-form-small,
+  select.uk-form-small,
+  textarea.uk-textarea-small {
+        padding-top: 2px !important;
+        padding-bottom: 2px !important;
+  }
+
+  /* Kill generic uk-margin utilities inside the form */
+  .uk-margin-small-bottom,
+  .uk-margin,
+  .uk-margin-bottom { margin-bottom: 2px !important; }
 }
 """)

{fh_pydantic_form-0.2.0.dist-info → fh_pydantic_form-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fh-pydantic-form
-Version: 0.2.0
+Version: 0.2.1
 Summary: a library to turn any pydantic BaseModel object into a fasthtml/monsterui input form
 Project-URL: Homepage, https://github.com/Marcura/fh-pydantic-form
 Project-URL: Repository, https://github.com/Marcura/fh-pydantic-form
@@ -32,7 +32,8 @@ Description-Content-Type: text/markdown
 
 `fh-pydantic-form` simplifies creating web forms for [FastHTML](https://github.com/AnswerDotAI/fasthtml) by automatically generating the necessary HTML input elements based on your Pydantic model definitions. It integrates seamlessly with  and leverages [MonsterUI](https://github.com/AnswerDotAI/monsterui) components for styling.
 
-<img width="1405" alt="image" src="https://github.com/user-attachments/assets/d65d9d68-1635-4ea4-83f8-70c4b6b79796" />
+<img width="1348" alt="image" src="https://github.com/user-attachments/assets/59cc4f10-6858-41cb-80ed-e735a883cf20" />
+
 
 
 <details >
@@ -225,19 +226,8 @@ form_normal = PydanticForm("normal_form", MyModel, spacing="normal")
 form_compact = PydanticForm("compact_form", MyModel, spacing="compact")
 ```
 
-**Compact mode** automatically injects additional CSS (`COMPACT_EXTRA_CSS`) to minimize margins, borders, and padding throughout the form. You can also import and use this CSS independently:
-
-```python
-from fh_pydantic_form import COMPACT_EXTRA_CSS
 
-app, rt = fh.fast_app(
-    hdrs=[
-        mui.Theme.blue.headers(),
-        COMPACT_EXTRA_CSS,  # Apply compact styling globally
-    ],
-    # ...
-)
-```
+**Important:** The compact CSS is now scoped with `.fhpf-compact` classes and only affects form inputs, not layout containers. This prevents conflicts with your application's layout system.
 
 ## Working with Lists