fh-pydantic-form 0.3.6__py3-none-any.whl → 0.3.8__py3-none-any.whl

fh_pydantic_form/form_parser.py

@@ -54,6 +54,8 @@ def _parse_non_list_fields(
     list_field_defs: Dict[str, Dict[str, Any]],
     base_prefix: str = "",
     exclude_fields: Optional[List[str]] = None,
+    keep_skip_json_pathset: Optional[set[str]] = None,
+    current_field_path: Optional[List[str]] = None,
 ) -> Dict[str, Any]:
     """
     Parses non-list fields from form data based on the model definition.
@@ -64,12 +66,30 @@ def _parse_non_list_fields(
         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
+        keep_skip_json_pathset: Optional set of normalized paths for SkipJsonSchema fields to keep
 
     Returns:
         Dictionary with parsed non-list fields
     """
     result: Dict[str, Any] = {}
     exclude_fields = exclude_fields or []
+    keep_skip_json_pathset = keep_skip_json_pathset or set()
+
+    # Helper function to check if a SkipJsonSchema field should be kept
+    def _should_keep_skip_field(path_segments: List[str]) -> bool:
+        from fh_pydantic_form.type_helpers import normalize_path_segments
+
+        normalized = normalize_path_segments(path_segments)
+        return bool(normalized) and normalized in keep_skip_json_pathset
+
+    # Calculate the current path context for fields at this level
+    # For top-level parsing, this will be empty
+    # For nested parsing, this will contain the nested path segments
+    current_path_segments: List[str] = []
+    if current_field_path is not None:
+        # Use explicitly passed field path
+        current_path_segments = current_field_path
+    # For top-level parsing (base_prefix is just form name), current_path_segments remains empty
 
     for field_name, field_info in model_class.model_fields.items():
         if field_name in list_field_defs:
@@ -79,9 +99,11 @@ def _parse_non_list_fields(
         if field_name in exclude_fields:
             continue
 
-        # Skip SkipJsonSchema fields - they should not be parsed from form data
+        # Skip SkipJsonSchema fields unless they're explicitly kept
         if _is_skip_json_schema_field(field_info):
-            continue
+            field_path_segments = current_path_segments + [field_name]
+            if not _should_keep_skip_field(field_path_segments):
+                continue
 
         # Create full key with prefix
         full_key = f"{base_prefix}{field_name}"
@@ -128,7 +150,8 @@ def _parse_non_list_fields(
             # Get the nested model class (unwrap Optional if needed)
             nested_model_class = _get_underlying_type_if_optional(annotation)
 
-            # Parse the nested model - pass the base_prefix and exclude_fields
+            # Parse the nested model - pass the base_prefix, exclude_fields, and keep paths
+            nested_field_path = current_path_segments + [field_name]
             nested_value = _parse_nested_model_field(
                 field_name,
                 form_data,
@@ -136,6 +159,8 @@ def _parse_non_list_fields(
                 field_info,
                 base_prefix,
                 exclude_fields,
+                keep_skip_json_pathset,
+                nested_field_path,
             )
 
             # Only assign if we got a non-None value or the field is not optional
@@ -276,6 +301,8 @@ def _parse_nested_model_field(
     field_info,
     parent_prefix: str = "",
     exclude_fields: Optional[List[str]] = None,
+    keep_skip_json_pathset: Optional[set[str]] = None,
+    current_field_path: Optional[List[str]] = None,
 ) -> Optional[Dict[str, Any]]:
     """
     Parse a nested Pydantic model field from form data.
@@ -286,6 +313,8 @@ def _parse_nested_model_field(
         nested_model_class: The nested model class
         field_info: The field info from the parent model
         parent_prefix: Prefix from parent form/model to use when constructing keys
+        exclude_fields: Optional list of field names to exclude from parsing
+        keep_skip_json_pathset: Optional set of normalized paths for SkipJsonSchema fields to keep
 
     Returns:
         Dictionary with nested model structure or None/default if no data found
@@ -302,6 +331,16 @@ def _parse_nested_model_field(
             break
 
     if found_any_subfield:
+        # Helper function to check if a SkipJsonSchema field should be kept
+        def _should_keep_skip_field_nested(path_segments: List[str]) -> bool:
+            from fh_pydantic_form.type_helpers import normalize_path_segments
+
+            normalized = normalize_path_segments(path_segments)
+            return bool(normalized) and normalized in (keep_skip_json_pathset or set())
+
+        # Use the passed field path for calculating nested paths
+        nested_path_segments: List[str] = current_field_path or []
+
         # ------------------------------------------------------------------
         # 1. Process each **non-list** field in the nested model
         # ------------------------------------------------------------------
@@ -309,12 +348,14 @@ def _parse_nested_model_field(
             sub_key = f"{current_prefix}{sub_field_name}"
             annotation = getattr(sub_field_info, "annotation", None)
 
-            # Skip SkipJsonSchema fields - they should not be parsed from form data
+            # Skip SkipJsonSchema fields unless they're explicitly kept
             if _is_skip_json_schema_field(sub_field_info):
-                logger.debug(
-                    f"Skipping SkipJsonSchema field in nested model during parsing: {sub_field_name}"
-                )
-                continue
+                sub_field_path_segments = nested_path_segments + [sub_field_name]
+                if not _should_keep_skip_field_nested(sub_field_path_segments):
+                    logger.debug(
+                        f"Skipping SkipJsonSchema field in nested model during parsing: {sub_field_name}"
+                    )
+                    continue
 
             # Handle based on field type, with Optional unwrapping
             is_optional = _is_optional_type(annotation)
@@ -326,9 +367,17 @@ def _parse_nested_model_field(
 
             # Handle nested model fields (including Optional[NestedModel])
             elif isinstance(base_type, type) and hasattr(base_type, "model_fields"):
-                # Pass the current_prefix to the recursive call
+                # Pass the current_prefix and keep paths to the recursive call
+                sub_field_path = nested_path_segments + [sub_field_name]
                 sub_value = _parse_nested_model_field(
-                    sub_field_name, form_data, base_type, sub_field_info, current_prefix
+                    sub_field_name,
+                    form_data,
+                    base_type,
+                    sub_field_info,
+                    current_prefix,
+                    exclude_fields,
+                    keep_skip_json_pathset,
+                    sub_field_path,
                 )
                 if sub_value is not None:
                     nested_data[sub_field_name] = sub_value
@@ -358,6 +407,7 @@ def _parse_nested_model_field(
                 nested_list_defs,
                 current_prefix,  # ← prefix for this nested model
                 exclude_fields,  # Pass through exclude_fields
+                keep_skip_json_pathset,
             )
             # Merge without clobbering keys already set in step 1
             for lf_name, lf_val in list_results.items():
@@ -438,6 +488,7 @@ def _parse_list_fields(
     list_field_defs: Dict[str, Dict[str, Any]],
     base_prefix: str = "",
     exclude_fields: Optional[List[str]] = None,
+    keep_skip_json_pathset: Optional[set[str]] = None,
 ) -> Dict[str, Optional[List[Any]]]:
     """
     Parse list fields from form data by analyzing keys and reconstructing ordered lists.
@@ -447,6 +498,7 @@ def _parse_list_fields(
         list_field_defs: Dictionary of list field definitions
         base_prefix: Prefix to use when looking up field names in form_data
         exclude_fields: Optional list of field names to exclude from parsing
+        keep_skip_json_pathset: Optional set of normalized paths for SkipJsonSchema fields to keep
 
     Returns:
         Dictionary with parsed list fields
@@ -504,7 +556,15 @@ def _parse_list_fields(
             # ------------------------------------------------------------------
             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)
+                # For list items, the field path is the list field name (without index)
+                item_field_path = [field_name]
+                parsed_item = _parse_model_list_item(
+                    form_data,
+                    item_type,
+                    item_prefix,
+                    keep_skip_json_pathset,
+                    item_field_path,
+                )
                 items.append(parsed_item)
                 continue
 
@@ -558,6 +618,8 @@ def _parse_model_list_item(
     form_data: Dict[str, Any],
     item_type,
     item_prefix: str,
+    keep_skip_json_pathset: Optional[set[str]] = None,
+    current_field_path: Optional[List[str]] = None,
 ) -> Dict[str, Any]:
     """
     Fully parse a single BaseModel list item – including its own nested lists.
@@ -568,6 +630,7 @@ def _parse_model_list_item(
         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_")
+        keep_skip_json_pathset: Optional set of normalized paths for SkipJsonSchema fields to keep
 
     Returns:
         Dictionary with fully parsed item data including nested lists
@@ -579,11 +642,18 @@ def _parse_model_list_item(
         item_type,
         nested_list_defs,
         base_prefix=item_prefix,
+        exclude_fields=[],
+        keep_skip_json_pathset=keep_skip_json_pathset,
+        current_field_path=current_field_path,
     )
     # 2. Parse inner lists
     result.update(
         _parse_list_fields(
-            form_data, nested_list_defs, base_prefix=item_prefix, exclude_fields=[]
+            form_data,
+            nested_list_defs,
+            base_prefix=item_prefix,
+            exclude_fields=[],
+            keep_skip_json_pathset=keep_skip_json_pathset,
         )
     )
     return result

fh_pydantic_form/form_renderer.py

@@ -34,6 +34,7 @@ from fh_pydantic_form.registry import FieldRendererRegistry
 from fh_pydantic_form.type_helpers import (
     _is_skip_json_schema_field,
     get_default,
+    normalize_path_segments,
 )
 from fh_pydantic_form.ui_style import (
     SpacingTheme,
@@ -48,6 +49,21 @@ logger = logging.getLogger(__name__)
 ModelType = TypeVar("ModelType", bound=BaseModel)
 
 
+def _compile_keep_paths(paths: Optional[List[str]]) -> set[str]:
+    """Normalize and compile keep paths for fast membership tests."""
+    if not paths:
+        return set()
+
+    compiled: set[str] = set()
+    for raw_path in paths:
+        if not raw_path:
+            continue
+        normalized = raw_path.strip()
+        if normalized:
+            compiled.add(normalized)
+    return compiled
+
+
 def list_manipulation_js():
     return fh.Script("""  
 function moveItem(buttonElement, direction) {
@@ -199,18 +215,46 @@ window.restoreAccordionState = function(containerId) {
     }
 };
 
-// Save all accordion states in the form
+// Save all accordion states in the form (both lists and nested BaseModels)
 window.saveAllAccordionStates = function() {
+    // Save list container states
     document.querySelectorAll('[id$="_items_container"]').forEach(container => {
         window.saveAccordionState(container.id);
     });
+
+    // Save all UIkit accordion item states (nested BaseModels, etc.)
+    document.querySelectorAll('.uk-accordion > li').forEach(item => {
+        if (item.id) {
+            const isOpen = item.classList.contains('uk-open');
+            sessionStorage.setItem('accordion_state_' + item.id, isOpen ? 'open' : 'closed');
+        }
+    });
 };
 
-// Restore all accordion states in the form
+// Restore all accordion states in the form (both lists and nested BaseModels)
 window.restoreAllAccordionStates = function() {
+    // Restore list container states
     document.querySelectorAll('[id$="_items_container"]').forEach(container => {
         window.restoreAccordionState(container.id);
     });
+
+    // Use requestAnimationFrame to ensure DOM has fully updated after swap
+    requestAnimationFrame(() => {
+        setTimeout(() => {
+            // Restore ALL UIkit accordion item states in the entire document (not just swapped area)
+            document.querySelectorAll('.uk-accordion > li').forEach(item => {
+                if (item.id) {
+                    const savedState = sessionStorage.getItem('accordion_state_' + item.id);
+
+                    if (savedState === 'open' && !item.classList.contains('uk-open')) {
+                        item.classList.add('uk-open');
+                    } else if (savedState === 'closed' && item.classList.contains('uk-open')) {
+                        item.classList.remove('uk-open');
+                    }
+                }
+            });
+        }, 150);
+    });
 };
 
 // Wait for the DOM to be fully loaded before initializing
@@ -219,8 +263,8 @@ document.addEventListener('DOMContentLoaded', () => {
     document.querySelectorAll('[id$="_items_container"]').forEach(container => {
         updateMoveButtons(container);
     });
-    
-    // Now it's safe to attach the HTMX event listener to document.body
+
+    // Attach HTMX event listener to document.body for list operations
     document.body.addEventListener('htmx:afterSwap', function(event) {
         // Check if this is an insert (afterend swap)
         const targetElement = event.detail.target;
@@ -281,6 +325,7 @@ class PydanticForm(Generic[ModelType]):
         disabled_fields: Optional[List[str]] = None,
         label_colors: Optional[Dict[str, str]] = None,
         exclude_fields: Optional[List[str]] = None,
+        keep_skip_json_fields: Optional[List[str]] = None,
         spacing: SpacingValue = SpacingTheme.NORMAL,
         metrics_dict: Optional[Dict[str, Any]] = None,
     ):
@@ -298,6 +343,7 @@ class PydanticForm(Generic[ModelType]):
             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
+            keep_skip_json_fields: Optional list of dot-paths for SkipJsonSchema fields to force-keep
             spacing: Spacing theme to use for form layout ("normal", "compact", or SpacingTheme enum)
             metrics_dict: Optional metrics dictionary for field-level visual feedback
         """
@@ -342,6 +388,8 @@ class PydanticForm(Generic[ModelType]):
         self.exclude_fields = exclude_fields or []  # Store excluded fields list
         self.spacing = _normalize_spacing(spacing)  # Store normalized spacing
         self.metrics_dict = metrics_dict or {}  # Store metrics dictionary
+        self.keep_skip_json_fields = keep_skip_json_fields or []
+        self._keep_skip_json_pathset = _compile_keep_paths(self.keep_skip_json_fields)
 
         # Register custom renderers with the global registry if provided
         if custom_renderers:
@@ -363,6 +411,15 @@ class PydanticForm(Generic[ModelType]):
         wrapper_cls = "fhpf-wrapper w-full flex-1"
         return fh.Div(inner, cls=wrapper_cls)
 
+    def _normalized_dot_path(self, path_segments: List[str]) -> str:
+        """Normalize path segments by dropping indices and joining with dots."""
+        return normalize_path_segments(path_segments)
+
+    def _is_kept_skip_field(self, full_path: List[str]) -> bool:
+        """Return True if a SkipJsonSchema field should be kept based on keep list."""
+        normalized = self._normalized_dot_path(full_path)
+        return bool(normalized) and normalized in self._keep_skip_json_pathset
+
     def reset_state(self) -> None:
         """
         Restore the live state of the form to its immutable baseline.
@@ -400,6 +457,7 @@ class PydanticForm(Generic[ModelType]):
             disabled_fields=self.disabled_fields,
             label_colors=self.label_colors,
             exclude_fields=self.exclude_fields,
+            keep_skip_json_fields=self.keep_skip_json_fields,
             spacing=self.spacing,
             metrics_dict=metrics_dict
             if metrics_dict is not None
@@ -423,8 +481,10 @@ class PydanticForm(Generic[ModelType]):
             if field_name in self.exclude_fields:
                 continue
 
-            # Skip SkipJsonSchema fields (they should not be rendered in the form)
-            if _is_skip_json_schema_field(field_info):
+            # Skip SkipJsonSchema fields unless explicitly kept
+            if _is_skip_json_schema_field(field_info) and not self._is_kept_skip_field(
+                [field_name]
+            ):
                 continue
 
             # Only use what was explicitly provided in initial values
@@ -440,24 +500,14 @@ class PydanticForm(Generic[ModelType]):
 
             # 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
-                elif getattr(field_info, "default_factory", None) is not None:
-                    try:
-                        default_factory = field_info.default_factory
-                        if callable(default_factory):
-                            initial_value = default_factory()  # type: ignore[call-arg]
-                        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}"
-                        )
+                # Field not provided - use model defaults in order of priority
+                # 1. Try explicit field default
+                default_val = get_default(field_info)
+                if default_val is not _UNSET:
+                    initial_value = default_val
+                else:
+                    # 2. Fall back to smart defaults for the type
+                    initial_value = default_for_annotation(field_info.annotation)
             # If field was provided (even as None), respect that value
 
             # Get renderer from global registry
@@ -488,6 +538,7 @@ class PydanticForm(Generic[ModelType]):
                 field_path=[field_name],  # Set top-level field path
                 form_name=self.name,  # Pass form name
                 metrics_dict=self.metrics_dict,  # Pass the metrics dict
+                keep_skip_json_pathset=self._keep_skip_json_pathset,
             )
 
             rendered_field = renderer.render()
@@ -654,19 +705,25 @@ class PydanticForm(Generic[ModelType]):
             if field_name not in self.exclude_fields
         }
 
-        # Parse non-list fields first - pass the base_prefix and exclude_fields
+        # Parse non-list fields first - pass the base_prefix, exclude_fields, and keep paths
         result = _parse_non_list_fields(
             form_dict,
             self.model_class,
             list_field_defs,
             self.base_prefix,
             self.exclude_fields,
+            self._keep_skip_json_pathset,
+            None,  # Top-level parsing, no field path
         )
 
-        # Parse list fields based on keys present in form_dict - pass the base_prefix
+        # Parse list fields based on keys present in form_dict - pass the base_prefix and keep paths
         # Use filtered list field definitions to skip excluded list fields
         list_results = _parse_list_fields(
-            form_dict, filtered_list_field_defs, self.base_prefix
+            form_dict,
+            filtered_list_field_defs,
+            self.base_prefix,
+            self.exclude_fields,
+            self._keep_skip_json_pathset,
         )
 
         # Merge list results into the main result
@@ -679,13 +736,14 @@ class PydanticForm(Generic[ModelType]):
 
     def _inject_missing_defaults(self, data: Dict[str, Any]) -> Dict[str, Any]:
         """
-        Ensures all model fields with defaults are present in data if missing.
-        Handles excluded fields, SkipJsonSchema fields, and any other fields
-        not rendered in the form.
+        Ensure missing fields are filled following precedence:
+        1) form value (already in `data`)
+        2) initial_values
+        3) model/default_factory
+        4) sensible default (for SkipJsonSchema fields only)
 
-        Priority order:
-        1. initial_values (if provided during form creation)
-        2. model defaults/default_factory
+        For required fields without defaults or initial_values, they are left missing
+        so that Pydantic validation can properly surface the error.
 
         Args:
             data: Dictionary to modify in-place
@@ -693,22 +751,20 @@ class PydanticForm(Generic[ModelType]):
         Returns:
             The same dictionary instance for method chaining
         """
-        # Process ALL model fields, not just excluded ones
         for field_name, field_info in self.model_class.model_fields.items():
-            # Skip if already present in parsed data
+            # 1) Respect any value already parsed from the form (top priority)
             if field_name in data:
                 continue
 
-            # First priority: check if initial_values_dict has this field
+            # 2) Prefer initial_values for ANY missing field (including hidden SkipJsonSchema fields)
             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
                 continue
 
-            # Second priority: use model defaults
+            # 3) Use model/default_factory if available
             default_val = get_default(field_info)
             if default_val is not _UNSET:
                 # If the default is a BaseModel, convert to dict for consistency
@@ -716,12 +772,11 @@ class PydanticForm(Generic[ModelType]):
                     default_val = default_val.model_dump()
                 data[field_name] = default_val
             else:
-                # Check if this is a SkipJsonSchema field
+                # 4) For SkipJsonSchema fields without defaults, provide sensible defaults
+                # For regular required fields, leave them missing so validation catches them
                 if _is_skip_json_schema_field(field_info):
-                    pass  # Skip fields don't need defaults
-                else:
-                    # No default → leave missing; validation will surface error
-                    pass
+                    data[field_name] = default_for_annotation(field_info.annotation)
+                # else: leave missing, let validation fail
 
         return data
 
@@ -808,6 +863,7 @@ class PydanticForm(Generic[ModelType]):
                 field_path=segments,  # Pass the full path segments
                 form_name=self.name,  # Pass the explicit form name
                 metrics_dict=self.metrics_dict,  # Pass the metrics dict
+                keep_skip_json_pathset=self._keep_skip_json_pathset,
             )
 
             # Generate a unique placeholder index

fh_pydantic_form/type_helpers.py

@@ -5,6 +5,7 @@ __all__ = [
     "_is_literal_type",
     "_is_enum_type",
     "_is_skip_json_schema_field",
+    "normalize_path_segments",
     "MetricEntry",
     "MetricsDict",
     "DecorationScope",
@@ -18,6 +19,7 @@ from typing import (
     Annotated,
     Any,
     Dict,
+    List,
     Literal,
     TypedDict,
     Union,
@@ -38,6 +40,18 @@ class DecorationScope(str, Enum):
     BOTH = "both"
 
 
+def normalize_path_segments(path_segments: List[str]) -> str:
+    """Collapse path segments into a dot path ignoring list indices and placeholders."""
+    normalized: List[str] = []
+    for segment in path_segments:
+        # Coerce to string to avoid surprises from enums or numbers
+        seg_str = str(segment)
+        if seg_str.isdigit() or seg_str.startswith("new_"):
+            continue
+        normalized.append(seg_str)
+    return ".".join(normalized)
+
+
 def _is_skip_json_schema_field(annotation_or_field_info: Any) -> bool:
     """
     Check if a field annotation or field_info indicates it should be skipped in JSON schema.
@@ -101,8 +115,14 @@ def _is_skip_json_schema_field(annotation_or_field_info: Any) -> bool:
             ):
                 return True
 
-    # 3. Fallback – cheap but effective
-    return "SkipJsonSchema" in repr(annotation)
+    # 3. Fallback – cheap but effective, but be more specific to avoid false positives
+    # Only match if SkipJsonSchema appears as a standalone word (not part of a class name)
+    repr_str = repr(annotation)
+    # Look for patterns like "SkipJsonSchema[" or "SkipJsonSchema(" or "SkipJsonSchema]"
+    # but not "SomeClassNameSkipJsonSchema"
+    import re
+
+    return bool(re.search(r"\bSkipJsonSchema\b", repr_str))
 
 
 # Metrics types for field-level annotations