fh-pydantic-form 0.1.2__py3-none-any.whl → 0.2.0__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:
@@ -416,6 +472,25 @@ def _parse_list_fields(
                             )
                             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)
+                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
+
             # For model types, keep as dict for now
             items.append(item_data)
 

fh_pydantic_form/form_renderer.py

@@ -9,6 +9,7 @@ from typing import (
     Tuple,
     Type,
     TypeVar,
+    Union,
 )
 
 import fasthtml.common as fh
@@ -16,6 +17,7 @@ import monsterui.all as mui
 from fastcore.xml import FT
 from pydantic import BaseModel
 
+from fh_pydantic_form.defaults import default_dict_for_model, default_for_annotation
 from fh_pydantic_form.field_renderers import (
     BaseFieldRenderer,
     ListFieldRenderer,
@@ -27,6 +29,13 @@ from fh_pydantic_form.form_parser import (
     _parse_non_list_fields,
 )
 from fh_pydantic_form.registry import FieldRendererRegistry
+from fh_pydantic_form.type_helpers import _UNSET, get_default
+from fh_pydantic_form.ui_style import (
+    SpacingTheme,
+    SpacingValue,
+    _normalize_spacing,
+    spacing,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -181,7 +190,11 @@ document.addEventListener('DOMContentLoaded', () => {
 
 class PydanticForm(Generic[ModelType]):
     """
-    Renders a form from a Pydantic model class
+    Renders a form from a Pydantic model class with robust schema drift handling
+
+    Accepts initial values as either BaseModel instances or dictionaries.
+    Gracefully handles missing fields and schema mismatches by rendering
+    available fields and skipping problematic ones.
 
     This class handles:
     - Finding appropriate renderers for each field
@@ -194,15 +207,29 @@ class PydanticForm(Generic[ModelType]):
     - validating request data against the model
     """
 
+    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.
+        """
+        if self.spacing == SpacingTheme.COMPACT:
+            from fh_pydantic_form.ui_style import COMPACT_EXTRA_CSS
+
+            return fh.Div(COMPACT_EXTRA_CSS, inner, cls="compact-form")
+        else:
+            return inner
+
     def __init__(
         self,
         form_name: str,
         model_class: Type[ModelType],
-        initial_values: Optional[ModelType] = None,
+        initial_values: Optional[Union[ModelType, Dict[str, Any]]] = None,
         custom_renderers: Optional[List[Tuple[Type, Type[BaseFieldRenderer]]]] = None,
         disabled: bool = False,
         disabled_fields: Optional[List[str]] = None,
         label_colors: Optional[Dict[str, str]] = None,
+        exclude_fields: Optional[List[str]] = None,
+        spacing: SpacingValue = SpacingTheme.NORMAL,
     ):
         """
         Initialize the form renderer
@@ -210,22 +237,56 @@ class PydanticForm(Generic[ModelType]):
         Args:
             form_name: Unique name for this form
             model_class: The Pydantic model class to render
-            initial_values: Optional initial Pydantic model instance
+            initial_values: Initial values as BaseModel instance or dict.
+                           Missing fields will not be auto-filled with defaults.
+                           Supports robust handling of schema drift.
             custom_renderers: Optional list of tuples (field_type, renderer_cls) to register
             disabled: Whether all form inputs should be disabled
             disabled_fields: Optional list of top-level field names to disable specifically
             label_colors: Optional dictionary mapping field names to label colors (CSS color values)
+            exclude_fields: Optional list of top-level field names to exclude from the form
+            spacing: Spacing theme to use for form layout ("normal", "compact", or SpacingTheme enum)
         """
         self.name = form_name
         self.model_class = model_class
-        self.initial_data_model = initial_values  # Store original model for fallback
-        self.values_dict = initial_values.model_dump() if initial_values else {}
+
+        self.initial_values_dict: Dict[str, Any] = {}
+
+        # Store initial values as dict for robustness to schema drift
+        if initial_values is None:
+            self.initial_values_dict = {}
+        elif isinstance(initial_values, dict):
+            self.initial_values_dict = initial_values.copy()
+        elif hasattr(initial_values, "model_dump"):
+            self.initial_values_dict = initial_values.model_dump()
+        else:
+            # Fallback - attempt dict conversion
+            try:
+                temp_dict = dict(initial_values)
+                model_field_names = set(self.model_class.model_fields.keys())
+                # Only accept if all keys are in the model's field names
+                if not isinstance(temp_dict, dict) or not set(
+                    temp_dict.keys()
+                ).issubset(model_field_names):
+                    raise ValueError("Converted to dict with keys not in model fields")
+                self.initial_values_dict = temp_dict
+            except (TypeError, ValueError):
+                logger.warning(
+                    "Could not convert initial_values to dict, using empty dict"
+                )
+                self.initial_values_dict = {}
+
+        # Use copy for rendering to avoid mutations
+        self.values_dict: Dict[str, Any] = self.initial_values_dict.copy()
+
         self.base_prefix = f"{form_name}_"
         self.disabled = disabled
         self.disabled_fields = (
             disabled_fields or []
         )  # Store as list for easier checking
         self.label_colors = label_colors or {}  # Store label colors mapping
+        self.exclude_fields = exclude_fields or []  # Store excluded fields list
+        self.spacing = _normalize_spacing(spacing)  # Store normalized spacing
 
         # Register custom renderers with the global registry if provided
         if custom_renderers:
@@ -247,11 +308,22 @@ class PydanticForm(Generic[ModelType]):
         )
 
         for field_name, field_info in self.model_class.model_fields.items():
-            # Determine initial value
+            # Skip excluded fields
+            if field_name in self.exclude_fields:
+                logger.debug(f"Skipping excluded field: {field_name}")
+                continue
+
+            # Only use what was explicitly provided in initial values
             initial_value = (
                 self.values_dict.get(field_name) if self.values_dict else None
             )
 
+            # Only use model defaults if field was not provided at all
+            # (not if it was provided as None/empty)
+            field_was_provided = (
+                field_name in self.values_dict if self.values_dict else False
+            )
+
             # Log the initial value type and a summary for debugging
             if initial_value is not None:
                 value_type = type(initial_value).__name__
@@ -259,26 +331,39 @@ class PydanticForm(Generic[ModelType]):
                     value_size = f"size={len(initial_value)}"
                 else:
                     value_size = ""
-                logger.debug(f"Field '{field_name}': {value_type} {value_size}")
+                logger.debug(
+                    f"Field '{field_name}': {value_type} {value_size} (provided: {field_was_provided})"
+                )
             else:
                 logger.debug(
-                    f"Field '{field_name}': None (will use default if available)"
+                    f"Field '{field_name}': None (provided: {field_was_provided})"
                 )
 
-            # Use default if no value is provided
-            if initial_value is None:
+            # Only use defaults if field was not provided at all
+            if not field_was_provided:
+                # Field not provided - use model defaults
                 if field_info.default is not None:
                     initial_value = field_info.default
                     logger.debug(f"  - Using default value for '{field_name}'")
                 elif getattr(field_info, "default_factory", None) is not None:
                     try:
-                        initial_value = field_info.default_factory()
-                        logger.debug(f"  - Using default_factory for '{field_name}'")
+                        default_factory = field_info.default_factory
+                        if callable(default_factory):
+                            initial_value = default_factory()
+                            logger.debug(
+                                f"  - Using default_factory for '{field_name}'"
+                            )
+                        else:
+                            initial_value = None
+                            logger.warning(
+                                f"  - default_factory for '{field_name}' is not callable"
+                            )
                     except Exception as e:
                         initial_value = None
                         logger.warning(
                             f"  - Error in default_factory for '{field_name}': {e}"
                         )
+            # If field was provided (even as None), respect that value
 
             # Get renderer from global registry
             renderer_cls = registry.get_renderer(field_name, field_info)
@@ -307,21 +392,28 @@ class PydanticForm(Generic[ModelType]):
                 prefix=self.base_prefix,
                 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
             )
 
             rendered_field = renderer.render()
             form_inputs.append(rendered_field)
 
         # Create container for inputs, ensuring items stretch to full width
-        inputs_container = mui.DivVStacked(*form_inputs, cls="space-y-3 items-stretch")
+        inputs_container = mui.DivVStacked(
+            *form_inputs,
+            cls=f"{spacing('stack_gap', self.spacing)} items-stretch",
+        )
 
         # Define the ID for the wrapper div - this is what the HTMX request targets
         form_content_wrapper_id = f"{self.name}-inputs-wrapper"
         logger.debug(f"Creating form inputs wrapper with ID: {form_content_wrapper_id}")
 
-        # Return only the inner container without the wrapper div
-        # The wrapper will be added by the main route handler instead
-        return fh.Div(inputs_container, id=form_content_wrapper_id)
+        # Create the wrapper div and apply compact styling if needed
+        wrapped = self._compact_wrapper(
+            fh.Div(inputs_container, id=form_content_wrapper_id)
+        )
+
+        return wrapped
 
     # ---- Form Renderer Methods (continued) ----
 
@@ -351,9 +443,9 @@ class PydanticForm(Generic[ModelType]):
                 f"Error parsing form data for refresh on form '{self.name}': {e}",
                 exc_info=True,
             )
-            # Fallback: Use original initial data model dump if available, otherwise empty dict
+            # Fallback: Use original initial values dict if available, otherwise empty dict
             parsed_data = (
-                self.initial_data_model.model_dump() if self.initial_data_model else {}
+                self.initial_values_dict.copy() if self.initial_values_dict else {}
             )
             alert_ft = mui.Alert(
                 f"Warning: Could not fully process current form values for refresh. Display might not be fully updated. Error: {str(e)}",
@@ -365,6 +457,7 @@ class PydanticForm(Generic[ModelType]):
             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
@@ -395,27 +488,28 @@ class PydanticForm(Generic[ModelType]):
         Returns:
             HTML response with reset form inputs
         """
-        logger.info(
-            f"Resetting form '{self.name}' to initial values. Initial model: {self.initial_data_model}"
-        )
+        logger.info(f"Resetting form '{self.name}' to initial values")
 
-        # Create a temporary renderer with the original initial data
+        # Create temporary renderer with original initial dict
         temp_renderer = PydanticForm(
             form_name=self.name,
             model_class=self.model_class,
-            initial_values=self.initial_data_model,  # Use the originally stored model
+            initial_values=self.initial_values_dict,  # Use dict instead of BaseModel
+            custom_renderers=getattr(self, "custom_renderers", None),
+            disabled=self.disabled,
+            disabled_fields=self.disabled_fields,
+            label_colors=self.label_colors,
+            exclude_fields=self.exclude_fields,
+            spacing=self.spacing,
         )
 
-        # Render inputs with the initial data
         reset_inputs_component = temp_renderer.render_inputs()
 
         if reset_inputs_component is None:
             logger.error(f"Reset for form '{self.name}' failed to render inputs.")
             return mui.Alert("Error resetting form.", cls=mui.AlertT.error)
 
-        logger.info(
-            f"Reset form '{self.name}' successful. Component: {reset_inputs_component}"
-        )
+        logger.info(f"Reset form '{self.name}' successful")
         return reset_inputs_component
 
     def parse(self, form_dict: Dict[str, Any]) -> Dict[str, Any]:
@@ -434,20 +528,93 @@ class PydanticForm(Generic[ModelType]):
 
         list_field_defs = _identify_list_fields(self.model_class)
 
-        # Parse non-list fields first - pass the base_prefix
+        # Filter out excluded fields from list field definitions
+        filtered_list_field_defs = {
+            field_name: field_def
+            for field_name, field_def in list_field_defs.items()
+            if field_name not in self.exclude_fields
+        }
 
+        # Parse non-list fields first - pass the base_prefix and exclude_fields
         result = _parse_non_list_fields(
-            form_dict, self.model_class, list_field_defs, self.base_prefix
+            form_dict,
+            self.model_class,
+            list_field_defs,
+            self.base_prefix,
+            self.exclude_fields,
         )
 
         # Parse list fields based on keys present in form_dict - pass the base_prefix
-        list_results = _parse_list_fields(form_dict, list_field_defs, self.base_prefix)
+        # Use filtered list field definitions to skip excluded list fields
+        list_results = _parse_list_fields(
+            form_dict, filtered_list_field_defs, self.base_prefix
+        )
 
         # Merge list results into the main result
         result.update(list_results)
 
+        # Inject defaults for excluded fields before returning
+        self._inject_default_values_for_excluded(result)
+
         return result
 
+    def _inject_default_values_for_excluded(
+        self, data: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        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.
+
+        Priority order:
+        1. initial_values (if provided during form creation)
+        2. model defaults/default_factory
+
+        Operates top-level only (exclude_fields spec is top-level names).
+
+        Args:
+            data: Dictionary to modify in-place
+
+        Returns:
+            The same dictionary instance for method chaining
+        """
+        for field_name in self.exclude_fields:
+            # Skip if already present (e.g., user provided initial_values)
+            if field_name in data:
+                continue
+
+            # First priority: check if initial_values_dict has this field
+            if field_name in self.initial_values_dict:
+                initial_val = self.initial_values_dict[field_name]
+                # If the initial value is a BaseModel, convert to dict for consistency
+                if hasattr(initial_val, "model_dump"):
+                    initial_val = initial_val.model_dump()
+                data[field_name] = initial_val
+                logger.debug(
+                    f"Injected initial value for excluded field '{field_name}'"
+                )
+                continue
+
+            # Second priority: use model defaults
+            field_info = self.model_class.model_fields.get(field_name)
+            if field_info is None:
+                logger.warning(f"exclude_fields contains unknown field '{field_name}'")
+                continue
+
+            default_val = get_default(field_info)
+            if default_val is not _UNSET:
+                # If the default is a BaseModel, convert to dict for consistency
+                if hasattr(default_val, "model_dump"):
+                    default_val = default_val.model_dump()
+                data[field_name] = default_val
+                logger.debug(
+                    f"Injected model default value for excluded field '{field_name}'"
+                )
+            else:
+                # No default → leave missing; validation will surface error
+                logger.debug(f"No default found for excluded field '{field_name}'")
+
+        return data
+
     def register_routes(self, app):
         """
         Register HTMX routes for list manipulation and form refresh
@@ -521,40 +688,29 @@ class PydanticForm(Generic[ModelType]):
                         cls=mui.AlertT.error,
                     )
 
-            # Create a default item
+            # Create a default item using smart defaults
+            default_item_dict: Dict[str, Any] | str | Any | None = None
             try:
-                # Ensure item_type is not None before checking attributes or type
-                if item_type:
-                    # For Pydantic models, try to use model_construct for default values
-                    if hasattr(item_type, "model_construct"):
-                        try:
-                            default_item = item_type.model_construct()
-                        except Exception as e:
-                            return fh.Li(
-                                mui.Alert(
-                                    f"Error creating model instance: {str(e)}",
-                                    cls=mui.AlertT.error,
-                                ),
-                                cls="mb-2",
-                            )
-                    # Handle simple types with appropriate defaults
-                    elif item_type is str:
-                        default_item = ""
-                    elif item_type is int:
-                        default_item = 0
-                    elif item_type is float:
-                        default_item = 0.0
-                    elif item_type is bool:
-                        default_item = False
-                    else:
-                        default_item = None
-                else:
-                    # Case where item_type itself was None (should ideally be caught earlier)
-                    default_item = None
+                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)
+
+                # 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
@@ -565,17 +721,33 @@ class PydanticForm(Generic[ModelType]):
             # Generate a unique placeholder index
             placeholder_idx = f"new_{int(pytime.time() * 1000)}"
 
-            # Create a list renderer and render the new item
-            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
+            # 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,
+                )
+
+            # 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}"
             )
 
             # Render the new item card, set is_open=True to make it expanded by default
             new_item_card = list_renderer._render_item_card(
-                default_item, placeholder_idx, item_type, is_open=True
+                item_data_for_renderer,  # Pass the dictionary or simple value
+                placeholder_idx,
+                item_type,
+                is_open=True,
             )
 
             return new_item_card