fh-pydantic-form 0.3.0__tar.gz → 0.3.2__tar.gz

{fh_pydantic_form-0.3.0 → fh_pydantic_form-0.3.2}/.gitignore

@@ -130,4 +130,7 @@ dmypy.json
 uv.lock
 
 
-.sesskey
+.sesskey
+*.db
+*.db-shm
+*.db-wal

{fh_pydantic_form-0.3.0 → fh_pydantic_form-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fh-pydantic-form
-Version: 0.3.0
+Version: 0.3.2
 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
@@ -30,15 +30,16 @@ Description-Content-Type: text/markdown
 
 **Generate HTML forms from Pydantic models for your FastHTML applications.**
 
-`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.
+`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. This makes it ideal for annotation workflows for structured outputs: when the schema updates, so does your annotation app.
+
+<img width="1072" alt="image" src="https://github.com/user-attachments/assets/9e189266-0118-4de2-a35c-1118f11b0581" />
 
-<img width="1348" alt="image" src="https://github.com/user-attachments/assets/59cc4f10-6858-41cb-80ed-e735a883cf20" />
 
 
 
 <details >
     <summary>show demo screen recording</summary>
-<video src="https://private-user-images.githubusercontent.com/27999937/436237879-feabf388-22af-43e6-b054-f103b8a1b6e6.mp4" controls="controls" style="max-width: 730px;">
+<video src="https://private-user-images.githubusercontent.com/27999937/462832274-a00096d9-47ee-485b-af0a-e74838ec6c6d.mp4" controls="controls">
 </video>
 </details>
 
@@ -867,6 +868,34 @@ form_renderer = PydanticForm("my_form", MyModel, initial_values=initial_values_d
 
 The dictionary does not have to be complete, and we try to handle schema drift gracefully. If you exclude fields from the form, we fill those fields with the initial_values or the default values.
 
+### Reusing Form Configuration with Different Values
+
+The `with_initial_values()` method allows you to create a new form instance with the same configuration but different initial values:
+
+```python
+# Create a base form configuration
+base_form = PydanticForm(
+    "product_form",
+    ProductModel,
+    disabled_fields=["id"],
+    label_colors={"name": "text-blue-600", "price": "text-green-600"},
+    spacing="compact"
+)
+
+# Create forms with different initial values using the same configuration
+form_for_product_a = base_form.with_initial_values({"name": "Product A", "price": 29.99})
+form_for_product_b = base_form.with_initial_values({"name": "Product B", "price": 45.50})
+
+# Or with model instances
+existing_product = ProductModel(name="Existing Product", price=19.99)
+form_for_existing = base_form.with_initial_values(existing_product)
+```
+
+This is particularly useful for:
+- **Editing workflows** where you need the same form configuration for different records
+- **Template forms** where you want to reuse styling and field configurations
+- **Bulk operations** where you process multiple items with the same form structure
+
 
 
 ### Schema Drift Resilience
@@ -996,6 +1025,7 @@ form_renderer = PydanticForm(
 | Method | Purpose |
 |--------|---------|
 | `render_inputs()` | Generate the HTML form inputs (without `<form>` wrapper) |
+| `with_initial_values(initial_values)` | Create a new form instance with same configuration but different initial values |
 | `refresh_button(text=None, **kwargs)` | Create a refresh button component |
 | `reset_button(text=None, **kwargs)` | Create a reset button component |
 | `register_routes(app)` | Register HTMX endpoints for list manipulation |

{fh_pydantic_form-0.3.0 → fh_pydantic_form-0.3.2}/README.md

@@ -5,15 +5,16 @@
 
 **Generate HTML forms from Pydantic models for your FastHTML applications.**
 
-`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.
+`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. This makes it ideal for annotation workflows for structured outputs: when the schema updates, so does your annotation app.
+
+<img width="1072" alt="image" src="https://github.com/user-attachments/assets/9e189266-0118-4de2-a35c-1118f11b0581" />
 
-<img width="1348" alt="image" src="https://github.com/user-attachments/assets/59cc4f10-6858-41cb-80ed-e735a883cf20" />
 
 
 
 <details >
     <summary>show demo screen recording</summary>
-<video src="https://private-user-images.githubusercontent.com/27999937/436237879-feabf388-22af-43e6-b054-f103b8a1b6e6.mp4" controls="controls" style="max-width: 730px;">
+<video src="https://private-user-images.githubusercontent.com/27999937/462832274-a00096d9-47ee-485b-af0a-e74838ec6c6d.mp4" controls="controls">
 </video>
 </details>
 
@@ -842,6 +843,34 @@ form_renderer = PydanticForm("my_form", MyModel, initial_values=initial_values_d
 
 The dictionary does not have to be complete, and we try to handle schema drift gracefully. If you exclude fields from the form, we fill those fields with the initial_values or the default values.
 
+### Reusing Form Configuration with Different Values
+
+The `with_initial_values()` method allows you to create a new form instance with the same configuration but different initial values:
+
+```python
+# Create a base form configuration
+base_form = PydanticForm(
+    "product_form",
+    ProductModel,
+    disabled_fields=["id"],
+    label_colors={"name": "text-blue-600", "price": "text-green-600"},
+    spacing="compact"
+)
+
+# Create forms with different initial values using the same configuration
+form_for_product_a = base_form.with_initial_values({"name": "Product A", "price": 29.99})
+form_for_product_b = base_form.with_initial_values({"name": "Product B", "price": 45.50})
+
+# Or with model instances
+existing_product = ProductModel(name="Existing Product", price=19.99)
+form_for_existing = base_form.with_initial_values(existing_product)
+```
+
+This is particularly useful for:
+- **Editing workflows** where you need the same form configuration for different records
+- **Template forms** where you want to reuse styling and field configurations
+- **Bulk operations** where you process multiple items with the same form structure
+
 
 
 ### Schema Drift Resilience
@@ -971,6 +1000,7 @@ form_renderer = PydanticForm(
 | Method | Purpose |
 |--------|---------|
 | `render_inputs()` | Generate the HTML form inputs (without `<form>` wrapper) |
+| `with_initial_values(initial_values)` | Create a new form instance with same configuration but different initial values |
 | `refresh_button(text=None, **kwargs)` | Create a refresh button component |
 | `reset_button(text=None, **kwargs)` | Create a reset button component |
 | `register_routes(app)` | Register HTMX endpoints for list manipulation |

{fh_pydantic_form-0.3.0 → fh_pydantic_form-0.3.2}/RELEASE_NOTES.md

@@ -1,5 +1,56 @@
 # Release Notes
 
+## Version 0.3.2 (2025-07-05)
+
+### 🔧 UI/UX Improvements
+
+#### Form Interaction Enhancements
+- **IMPROVED**: Better handling of falsy values in StringFieldRenderer for more robust form inputs
+- **ENHANCED**: Accordion state preservation across refresh operations for improved user experience
+- **FIXED**: Dropdown events no longer trigger accordion sync in comparison forms, preventing UI conflicts
+
+#### String Field Enhancements
+- **NEW**: Textarea input support for better handling of longer text fields
+- **IMPROVED**: StringFieldRenderer robustness with better code quality and error handling
+- **ENHANCED**: Fallback handling for string values with comprehensive test coverage
+
+#### List Management Improvements
+- **ENHANCED**: List items now behave like BaseModel accordions for consistent UI patterns
+- **IMPROVED**: Better default values for new list items
+- **FIXED**: Nested list item accordion synchronization in ComparisonForm
+
+### 🐛 Bug Fixes
+
+#### Performance & Logging
+- **FIXED**: Reduced excessive DEBUG logging messages for cleaner console output
+- **IMPROVED**: Overall application performance with optimized refresh operations
+
+#### Scroll & Navigation
+- **NEW**: Scroll position preservation during form refresh operations
+- **ENHANCED**: UI improvements for refresh and reset actions with better visual feedback
+
+### 📚 Documentation & Examples
+
+#### Enhanced Examples
+- **UPDATED**: Annotation example with cleanup and improvements
+- **IMPROVED**: Comparison example with better demonstration of features
+- **ENHANCED**: README.md with updated documentation and usage examples
+
+### 📊 Statistics
+- **24 commits** since v0.3.1
+- Focus on UI polish, form interaction improvements, and string field enhancements
+- Improved logging and performance optimizations
+- Enhanced documentation and examples
+
+**Key Highlights:**
+This release focuses on improving form interaction quality, with particular attention to string field handling, scroll preservation, and accordion state management. The textarea support and better falsy value handling make forms more robust for real-world usage scenarios.
+
+---
+
+## Version 0.3.1 (2025-06-24)
+
+- fix datetime.time renderer when format is not HH:MM 
+
 ## Version 0.3.0 (2025-06-23)
 
 ### 🎉 Major Features

{fh_pydantic_form-0.3.0 → fh_pydantic_form-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fh-pydantic-form"
-version = "0.3.0"
+version = "0.3.2"
 description = "a library to turn any pydantic BaseModel object into a fasthtml/monsterui input form"
 readme = "README.md"
 requires-python = ">=3.10"

{fh_pydantic_form-0.3.0 → fh_pydantic_form-0.3.2}/src/fh_pydantic_form/comparison_form.py

@@ -52,6 +52,16 @@ window.fhpfInitComparisonSync = function initComparisonSync(){
     const sourceLi = ev.target.closest('li');
     if (!sourceLi) return;
 
+    // Skip if this event is from a select/dropdown element
+    if (ev.target.closest('uk-select, select, [uk-select]')) {
+      return;
+    }
+
+    // Skip if this is a nested list item (let mirrorNestedListItems handle it)
+    if (sourceLi.closest('[id$="_items_container"]')) {
+      return;
+    }
+
     // Find our grid-cell wrapper (both left & right share the same data-path)
     const cell = sourceLi.closest('[data-path]');
     if (!cell) return;
@@ -91,7 +101,99 @@ window.fhpfInitComparisonSync = function initComparisonSync(){
       });
   }
 
-  // 3) Wrap the list-toggle so ListFieldRenderer accordions sync too
+  // 3) Sync nested list item accordions (individual items within lists)
+  UIkit.util.on(
+    document,
+    'show hide',
+    '[id$="_items_container"] > li',  // only list items within items containers
+    mirrorNestedListItems
+  );
+
+  function mirrorNestedListItems(ev) {
+    const sourceLi = ev.target.closest('li');
+    if (!sourceLi) return;
+    
+    // Skip if this event is from a select/dropdown element
+    if (ev.target.closest('uk-select, select, [uk-select]')) {
+      return;
+    }
+    
+    // Skip if this event was triggered by our own sync
+    if (sourceLi.dataset.syncDisabled) {
+      return;
+    }
+
+    // Find the list container (items_container) that contains this item
+    const listContainer = sourceLi.closest('[id$="_items_container"]');
+    if (!listContainer) return;
+
+    // Find the grid cell wrapper with data-path
+    const cell = listContainer.closest('[data-path]');
+    if (!cell) return;
+    const path = cell.dataset.path;
+
+    // Determine index of this <li> within its list container
+    const listAccordion = sourceLi.parentElement;
+    const idx = Array.prototype.indexOf.call(listAccordion.children, sourceLi);
+    const opening = ev.type === 'show';
+
+    // Mirror on the other side
+    document
+      .querySelectorAll(`[data-path="${path}"]`)
+      .forEach(peerCell => {
+        if (peerCell === cell) return;
+
+        // Find the peer's list container
+        const peerListContainer = peerCell.querySelector('[id$="_items_container"]');
+        if (!peerListContainer) return;
+
+        // The list container IS the accordion itself (not a wrapper around it)
+        let peerListAccordion;
+        if (peerListContainer.hasAttribute('uk-accordion') && peerListContainer.tagName === 'UL') {
+          peerListAccordion = peerListContainer;
+        } else {
+          peerListAccordion = peerListContainer.querySelector('ul[uk-accordion]');
+        }
+        
+        if (!peerListAccordion || idx >= peerListAccordion.children.length) return;
+
+        const peerLi = peerListAccordion.children[idx];
+        const peerContent = peerLi.querySelector('.uk-accordion-content');
+
+        // Prevent event cascading by temporarily disabling our own event listener
+        if (peerLi.dataset.syncDisabled) {
+          return;
+        }
+
+        // Mark this item as being synced to prevent loops
+        peerLi.dataset.syncDisabled = 'true';
+
+        // Check current state and only sync if different
+        const currentlyOpen = peerLi.classList.contains('uk-open');
+        
+        if (currentlyOpen !== opening) {
+          if (opening) {
+            peerLi.classList.add('uk-open');
+            if (peerContent) {
+              peerContent.hidden = false;
+              peerContent.style.height = 'auto';
+            }
+          } else {
+            peerLi.classList.remove('uk-open');
+            if (peerContent) {
+              peerContent.hidden = true;
+            }
+          }
+        }
+
+        // Re-enable sync after a short delay
+        setTimeout(() => {
+          delete peerLi.dataset.syncDisabled;
+        }, 100);
+      });
+  }
+
+  // 4) Wrap the list-toggle so ListFieldRenderer accordions sync too
   if (typeof window.toggleListItems === 'function' && !window.__listSyncWrapped) {
     // guard to only wrap once
     window.__listSyncWrapped = true;
@@ -455,13 +557,11 @@ class ComparisonForm(Generic[ModelType]):
             reset_path = f"/compare/{self.name}/{side}/reset"
             reset_handler = create_reset_handler(form, side, label)
             app.route(reset_path, methods=["POST"])(reset_handler)
-            logger.debug(f"Registered comparison reset route: {reset_path}")
 
             # Refresh route
             refresh_path = f"/compare/{self.name}/{side}/refresh"
             refresh_handler = create_refresh_handler(form, side, label)
             app.route(refresh_path, methods=["POST"])(refresh_handler)
-            logger.debug(f"Registered comparison refresh route: {refresh_path}")
 
     def form_wrapper(self, content: FT, form_id: Optional[str] = None) -> FT:
         """
@@ -506,6 +606,7 @@ class ComparisonForm(Generic[ModelType]):
         kwargs.setdefault("hx_target", f"#{form.name}-inputs-wrapper")
         kwargs.setdefault("hx_swap", "innerHTML")
         kwargs.setdefault("hx_include", prefix_selector)
+        kwargs.setdefault("hx_preserve", "scroll")
 
         # Delegate to the underlying form's button method
         button_method = getattr(form, f"{action}_button")

{fh_pydantic_form-0.3.0 → fh_pydantic_form-0.3.2}/src/fh_pydantic_form/field_renderers.py

@@ -272,9 +272,6 @@ class MetricsRendererMixin:
                     existing_style = node.attrs.get("style", "")
                     node.attrs["style"] = highlight_css + " " + existing_style
                     highlight_count += 1
-                    logger.debug(
-                        f"Applied highlight to tag={getattr(node, 'tag', 'unknown')}, attrs={list(node.attrs.keys()) if hasattr(node, 'attrs') else []}"
-                    )
 
             # Process children if they exist
             if hasattr(node, "children") and node.children:
@@ -285,7 +282,7 @@ class MetricsRendererMixin:
         apply_highlight(element)
 
         if highlight_count == 0:
-            logger.debug("No form controls found to highlight in element tree")
+            pass  # No form controls found to highlight
 
         return element
 
@@ -603,13 +600,9 @@ class StringFieldRenderer(BaseFieldRenderer):
         Render input element for the field
 
         Returns:
-            A TextInput component appropriate for string values
+            A TextArea component appropriate for string values
         """
-        # is_field_required = (
-        #     not self.is_optional
-        #     and self.field_info.default is None
-        #     and getattr(self.field_info, "default_factory", None) is None
-        # )
+
         has_default = get_default(self.field_info) is not _UNSET
         is_field_required = not self.is_optional and not has_default
 
@@ -625,21 +618,40 @@ class StringFieldRenderer(BaseFieldRenderer):
         if input_spacing_cls:
             input_cls_parts.append(input_spacing_cls)
 
+        # Calculate appropriate number of rows based on content
+        if isinstance(self.value, str) and self.value:
+            # Count line breaks
+            line_count = len(self.value.split("\n"))
+            # Also consider content length for very long single lines (assuming ~60 chars per line)
+            char_count = len(self.value)
+            estimated_lines = max(line_count, (char_count // 60) + 1)
+            # Compact bounds: minimum 1 row, maximum 3 rows
+            rows = min(max(estimated_lines, 1), 3)
+        else:
+            # Single row for empty content
+            rows = 1
+
         input_attrs = {
-            "value": self.value or "",
             "id": self.field_name,
             "name": self.field_name,
-            "type": "text",
             "placeholder": placeholder_text,
             "required": is_field_required,
             "cls": " ".join(input_cls_parts),
+            "rows": rows,
+            "style": "resize: vertical; min-height: 2.5rem; padding: 0.5rem; line-height: 1.25;",
         }
 
         # Only add the disabled attribute if the field should actually be disabled
         if self.disabled:
             input_attrs["disabled"] = True
 
-        return mui.Input(**input_attrs)
+        # Convert value to string representation, handling None and all other types
+        if self.value is None:
+            display_value = ""
+        else:
+            display_value = str(self.value)
+
+        return mui.TextArea(display_value, **input_attrs)
 
 
 class NumberFieldRenderer(BaseFieldRenderer):
@@ -820,11 +832,19 @@ class TimeFieldRenderer(BaseFieldRenderer):
             A TimeInput component appropriate for time values
         """
         formatted_value = ""
-        if (
-            isinstance(self.value, str) and len(self.value) == 5
-        ):  # Basic check for HH:MM format
-            # Assume it's the correct string format from the form
-            formatted_value = self.value
+        if isinstance(self.value, str):
+            # Try to parse the time string using various formats
+            time_formats = ["%H:%M", "%H:%M:%S", "%H:%M:%S.%f"]
+
+            for fmt in time_formats:
+                try:
+                    from datetime import datetime
+
+                    parsed_time = datetime.strptime(self.value, fmt).time()
+                    formatted_value = parsed_time.strftime("%H:%M")
+                    break
+                except ValueError:
+                    continue
         elif isinstance(self.value, time):
             formatted_value = self.value.strftime("%H:%M")  # HH:MM
 
@@ -1386,73 +1406,110 @@ class ListFieldRenderer(BaseFieldRenderer):
             label_span.attrs["uk-tooltip"] = description
             label_span.attrs["title"] = description
 
-        # Decorate the label span with the metric badge (bullet)
-        label_span = self._decorate_label(label_span, self.metric_entry)
+        # Metric decoration will be applied to the title_component below
 
-        # Construct the container ID that will be generated by render_input()
-        container_id = self._container_id()
-
-        # Only add refresh icon if we have a form name
-        if form_name:
+        # Only add refresh icon if we have a form name and field is not disabled
+        if form_name and not self.disabled:
             # Create the smaller icon component
             refresh_icon_component = mui.UkIcon(
                 "refresh-ccw",
                 cls="w-3 h-3 text-gray-500 hover:text-blue-600",  # Smaller size
             )
 
-            # Create the clickable span wrapper for the icon
-            # Use prefix-based selector to include only fields from this form
-            hx_include_selector = (
-                f"form [name^='{self.prefix}']" if self.prefix else "closest form"
-            )
-
             # Use override endpoint if provided (for ComparisonForm), otherwise use standard form refresh
             refresh_url = (
                 self._refresh_endpoint_override or f"/form/{form_name}/refresh"
             )
 
-            refresh_icon_trigger = fh.Span(
+            # Get container ID for accordion state preservation
+            container_id = self._container_id()
+
+            # Create refresh icon as a button with aggressive styling reset
+            refresh_icon_trigger = mui.Button(
                 refresh_icon_component,
-                cls="ml-1 inline-block align-middle cursor-pointer",  # Add margin, ensure inline-like behavior
+                type="button",  # Prevent form submission
                 hx_post=refresh_url,
                 hx_target=f"#{form_name}-inputs-wrapper",
                 hx_swap="innerHTML",
-                hx_include=hx_include_selector,  # Use prefix-based selector
+                hx_trigger="click",  # Explicit trigger on click
+                hx_include="closest form",  # Include all form fields from the enclosing form
+                hx_preserve="scroll",
                 uk_tooltip="Refresh form display to update list summaries",
-                # Prevent 'toggleListItems' on the parent from firing
-                onclick="event.stopPropagation();",
+                style="all: unset; display: inline-flex; align-items: center; cursor: pointer; padding: 0 0.5rem; margin-left: 0.5rem;",
+                **{
+                    "hx-on::before-request": f"window.saveAccordionState && window.saveAccordionState('{container_id}')"
+                },
+                **{
+                    "hx-on::after-swap": f"window.restoreAccordionState && window.restoreAccordionState('{container_id}')"
+                },
             )
 
-            # Combine label and icon
-            label_with_icon = fh.Div(
-                label_span,  # Use the properly styled label span
-                refresh_icon_trigger,
-                cls="flex items-center cursor-pointer",  # Added cursor-pointer
-                onclick=f"toggleListItems('{container_id}'); return false;",  # Add click handler
+            # Combine label and icon - put refresh icon in a separate div to isolate it
+            title_component = fh.Div(
+                fh.Div(
+                    label_span,  # Use the properly styled label span
+                    cls="flex-1",  # Take up remaining space
+                ),
+                fh.Div(
+                    refresh_icon_trigger,
+                    cls="flex-shrink-0 px-1",  # Don't shrink, add horizontal padding for larger click area
+                    onclick="event.stopPropagation();",  # Isolate the refresh icon area
+                ),
+                cls="flex items-center",
             )
         else:
-            # If no form name, just use the styled label but still make it clickable
-            label_with_icon = fh.Div(
+            # If no form name, just use the styled label
+            title_component = fh.Div(
                 label_span,  # Use the properly styled label span
-                cls="flex items-center cursor-pointer",  # Added cursor-pointer
-                onclick=f"toggleListItems('{container_id}'); return false;",  # Add click handler
-                uk_tooltip="Click to toggle all items open/closed",
+                cls="flex items-center",  # Remove cursor-pointer and click handler
             )
 
-        # Return container with label+icon and input
-        field_element = fh.Div(
-            label_with_icon,
-            self.render_input(),
-            cls=f"{spacing('outer_margin', self.spacing)} w-full",
+        # Apply metrics decoration to title (bullet only, no border)
+        title_component = self._decorate_metrics(
+            title_component, self.metric_entry, scope=DecorationScope.BULLET
         )
 
-        # Apply metrics decoration if available
-        return self._decorate_metrics(
-            field_element,
-            self.metric_entry,
-            scope=DecorationScope.BORDER,
+        # Compute border color for the wrapper accordion
+        border_color = self._metric_border_color(self.metric_entry)
+        li_style = {}
+        if border_color:
+            li_style["style"] = (
+                f"border-left: 4px solid {border_color}; padding-left: 0.25rem;"
+            )
+
+        # Create the wrapper AccordionItem that contains all the list items
+        list_content = self.render_input()
+
+        # Define unique IDs for the wrapper accordion
+        wrapper_item_id = f"{self.field_name}_wrapper_item"
+        wrapper_accordion_id = f"{self.field_name}_wrapper_accordion"
+
+        # Create the wrapper AccordionItem
+        wrapper_accordion_item = mui.AccordionItem(
+            title_component,  # Title component with label and refresh icon
+            list_content,  # Content component (the list items)
+            open=True,  # Open by default
+            li_kwargs={
+                "id": wrapper_item_id,
+                **li_style,
+            },
+            cls=spacing("outer_margin", self.spacing),
+        )
+
+        # Wrap in an Accordion container
+        accordion_cls = spacing_many(
+            ["accordion_divider", "accordion_content"], self.spacing
+        )
+        wrapper_accordion = mui.Accordion(
+            wrapper_accordion_item,
+            id=wrapper_accordion_id,
+            multiple=True,
+            collapsible=True,
+            cls=f"{accordion_cls} w-full".strip(),
         )
 
+        return wrapper_accordion
+
     def render_input(self) -> FT:
         """
         Render a list of items with add/delete/move capabilities
@@ -1553,12 +1610,12 @@ class ListFieldRenderer(BaseFieldRenderer):
                 cls=mui.AlertT.info,
             )
 
-        # Return the complete component
+        # Return the complete component (minimal styling since it's now wrapped in an accordion)
         t = self.spacing
         return fh.Div(
             accordion,
             empty_state,
-            cls=f"{spacing('outer_margin', t)} {spacing('card_border', t)} rounded-md {spacing('padding', t)}".strip(),
+            cls=f"{spacing('padding', t)}".strip(),  # Keep padding for content, remove border and margin
         )
 
     def _render_item_card(self, item, idx, item_type, is_open=False) -> FT:
@@ -1590,6 +1647,33 @@ class ListFieldRenderer(BaseFieldRenderer):
             is_model = hasattr(item_type, "model_fields")
 
             # --- Generate item summary for the accordion title ---
+            # Create a user-friendly display index
+            if isinstance(idx, str) and idx.startswith("new_"):
+                # Get the type name for new items
+                if is_model:
+                    # For BaseModel types, use the class name
+                    type_name = item_type.__name__
+                else:
+                    # For simple types, use a friendly name
+                    type_name_map = {
+                        str: "String",
+                        int: "Number",
+                        float: "Number",
+                        bool: "Boolean",
+                        date: "Date",
+                        time: "Time",
+                    }
+                    type_name = type_name_map.get(
+                        item_type,
+                        item_type.__name__
+                        if hasattr(item_type, "__name__")
+                        else str(item_type),
+                    )
+
+                display_idx = f"New {type_name}"
+            else:
+                display_idx = str(idx)
+
             if is_model:
                 try:
                     # Determine how to get the string representation based on item type
@@ -1610,7 +1694,7 @@ class ListFieldRenderer(BaseFieldRenderer):
 
                     if model_for_display is not None:
                         # Use the model's __str__ method
-                        item_summary_text = f"{idx}: {str(model_for_display)}"
+                        item_summary_text = f"{display_idx}: {str(model_for_display)}"
                     else:
                         # Fallback for None or unexpected types
                         item_summary_text = f"{item_type.__name__}: (Unknown format: {type(item).__name__})"
@@ -1635,7 +1719,7 @@ class ListFieldRenderer(BaseFieldRenderer):
                     )
                     item_summary_text = f"{item_type.__name__}: (Error displaying item)"
             else:
-                item_summary_text = f"{idx}: {str(item)}"
+                item_summary_text = f"{display_idx}: {str(item)}"
 
             # --- Render item content elements ---
             item_content_elements = []

{fh_pydantic_form-0.3.0 → fh_pydantic_form-0.3.2}/src/fh_pydantic_form/form_parser.py

@@ -81,7 +81,6 @@ def _parse_non_list_fields(
 
         # Skip SkipJsonSchema fields - they should not be parsed from form data
         if _is_skip_json_schema_field(field_info):
-            logger.debug(f"Skipping SkipJsonSchema field during parsing: {field_name}")
             continue
 
         # Create full key with prefix
@@ -399,7 +398,6 @@ def _parse_nested_model_field(
     ):
         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
@@ -408,7 +406,6 @@ def _parse_nested_model_field(
         try:
             default_value = field_info.default_factory()
             default_applied = True
-            logger.debug(f"Nested field {field_name} using default_factory.")
         except Exception as e:
             logger.warning(
                 f"Error creating default for {field_name} using default_factory: {e}"

{fh_pydantic_form-0.3.0 → fh_pydantic_form-0.3.2}/src/fh_pydantic_form/form_renderer.py

@@ -156,6 +156,63 @@ function toggleListItems(containerId) {
     }
 }
 
+// Simple accordion state preservation using item IDs
+window.saveAccordionState = function(containerId) {
+    const container = document.getElementById(containerId);
+    if (!container) return;
+    
+    const openItemIds = [];
+    container.querySelectorAll('li.uk-open').forEach(item => {
+        if (item.id) {
+            openItemIds.push(item.id);
+        }
+    });
+    
+    // Store in sessionStorage with container-specific key
+    sessionStorage.setItem(`accordion_state_${containerId}`, JSON.stringify(openItemIds));
+};
+
+window.restoreAccordionState = function(containerId) {
+    const container = document.getElementById(containerId);
+    if (!container) return;
+    
+    const savedState = sessionStorage.getItem(`accordion_state_${containerId}`);
+    if (!savedState) return;
+    
+    try {
+        const openItemIds = JSON.parse(savedState);
+        
+        // Restore open state for each saved item by ID
+        openItemIds.forEach(itemId => {
+            const item = document.getElementById(itemId);
+            if (item && container.contains(item)) {
+                item.classList.add('uk-open');
+                const content = item.querySelector('.uk-accordion-content');
+                if (content) {
+                    content.hidden = false;
+                    content.style.height = 'auto';
+                }
+            }
+        });
+    } catch (e) {
+        console.warn('Failed to restore accordion state:', e);
+    }
+};
+
+// Save all accordion states in the form
+window.saveAllAccordionStates = function() {
+    document.querySelectorAll('[id$="_items_container"]').forEach(container => {
+        window.saveAccordionState(container.id);
+    });
+};
+
+// Restore all accordion states in the form
+window.restoreAllAccordionStates = function() {
+    document.querySelectorAll('[id$="_items_container"]').forEach(container => {
+        window.restoreAccordionState(container.id);
+    });
+};
+
 // Wait for the DOM to be fully loaded before initializing
 document.addEventListener('DOMContentLoaded', () => {
     // Initialize button states for elements present on initial load
@@ -306,26 +363,28 @@ class PydanticForm(Generic[ModelType]):
         """
         self.values_dict = self.initial_values_dict.copy()
 
-    def _clone_with_values(self, values: Dict[str, Any]) -> "PydanticForm":
+    def with_initial_values(
+        self, initial_values: Optional[Union[ModelType, Dict[str, Any]]] = None
+    ) -> "PydanticForm":
         """
-        Create a copy of this renderer with the same configuration but different values.
+        Create a new PydanticForm instance with the same configuration but different initial values.
 
-        This preserves all constructor arguments (label_colors, custom_renderers, etc.)
-        to avoid configuration drift during refresh operations.
+        This preserves all constructor arguments (label_colors, custom_renderers, spacing, etc.)
+        while allowing you to specify new initial values. This is useful for reusing form
+        configurations with different data.
 
         Args:
-            values: New values dictionary to use in the cloned renderer
+            initial_values: New initial values as BaseModel instance or dict.
+                           Same format as the constructor accepts.
 
         Returns:
-            A new PydanticForm instance with identical configuration but updated values
+            A new PydanticForm instance with identical configuration but updated initial values
         """
-        # Get custom renderers if they were registered (not stored directly on instance)
-        # We'll rely on global registry state being preserved
-
+        # Create the new instance with the same configuration
         clone = PydanticForm(
             form_name=self.name,
             model_class=self.model_class,
-            initial_values=None,  # Will be set via values_dict below
+            initial_values=initial_values,  # Pass through to constructor for proper handling
             custom_renderers=None,  # Registry is global, no need to re-register
             disabled=self.disabled,
             disabled_fields=self.disabled_fields,
@@ -335,9 +394,6 @@ class PydanticForm(Generic[ModelType]):
             metrics_dict=self.metrics_dict,
         )
 
-        # Set the values directly
-        clone.values_dict = values
-
         return clone
 
     def render_inputs(self) -> FT:
@@ -349,19 +405,14 @@ class PydanticForm(Generic[ModelType]):
         """
         form_inputs = []
         registry = FieldRendererRegistry()  # Get singleton instance
-        logger.debug(
-            f"Starting render_inputs for form '{self.name}' with {len(self.model_class.model_fields)} fields"
-        )
 
         for field_name, field_info in self.model_class.model_fields.items():
             # Skip excluded fields
             if field_name in self.exclude_fields:
-                logger.debug(f"Skipping excluded field: {field_name}")
                 continue
 
             # Skip SkipJsonSchema fields (they should not be rendered in the form)
             if _is_skip_json_schema_field(field_info):
-                logger.debug(f"Skipping SkipJsonSchema field: {field_name}")
                 continue
 
             # Only use what was explicitly provided in initial values
@@ -375,35 +426,16 @@ class PydanticForm(Generic[ModelType]):
                 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__
-                if isinstance(initial_value, (list, dict)):
-                    value_size = f"size={len(initial_value)}"
-                else:
-                    value_size = ""
-                logger.debug(
-                    f"Field '{field_name}': {value_type} {value_size} (provided: {field_was_provided})"
-                )
-            else:
-                logger.debug(
-                    f"Field '{field_name}': None (provided: {field_was_provided})"
-                )
-
             # 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:
                         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(
@@ -428,9 +460,6 @@ class PydanticForm(Generic[ModelType]):
 
             # Determine if this specific field should be disabled
             is_field_disabled = self.disabled or (field_name in self.disabled_fields)
-            logger.debug(
-                f"Field '{field_name}' disabled state: {is_field_disabled} (Global: {self.disabled}, Specific: {field_name in self.disabled_fields})"
-            )
 
             # Get label color for this field if specified
             label_color = self.label_colors.get(field_name)
@@ -460,7 +489,6 @@ class PydanticForm(Generic[ModelType]):
 
         # 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}")
 
         # Create the wrapper div and apply compact styling if needed
         wrapped = self._compact_wrapper(
@@ -490,11 +518,6 @@ class PydanticForm(Generic[ModelType]):
             if key.startswith(self.base_prefix)
         }
 
-        logger.debug(
-            f"Filtered form data for '{self.name}': "
-            f"{len(data)} keys -> {len(filtered)} keys"
-        )
-
         return filtered
 
     # ---- Form Renderer Methods (continued) ----
@@ -551,7 +574,7 @@ class PydanticForm(Generic[ModelType]):
         self.values_dict = parsed_data.copy()
 
         # Create temporary renderer with same configuration but updated values
-        temp_renderer = self._clone_with_values(parsed_data)
+        temp_renderer = self.with_initial_values(parsed_data)
 
         refreshed_inputs_component = temp_renderer.render_inputs()
 
@@ -585,18 +608,7 @@ class PydanticForm(Generic[ModelType]):
         logger.info(f"Resetting form '{self.name}' to initial values")
 
         # Create temporary renderer with original initial dict
-        temp_renderer = PydanticForm(
-            form_name=self.name,
-            model_class=self.model_class,
-            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,
-            metrics_dict=self.metrics_dict,
-        )
+        temp_renderer = self.with_initial_values(self.initial_values_dict)
 
         reset_inputs_component = temp_renderer.render_inputs()
 
@@ -682,7 +694,6 @@ class PydanticForm(Generic[ModelType]):
                 if hasattr(initial_val, "model_dump"):
                     initial_val = initial_val.model_dump()
                 data[field_name] = initial_val
-                logger.debug(f"Injected initial value for missing field '{field_name}'")
                 continue
 
             # Second priority: use model defaults
@@ -692,18 +703,13 @@ class PydanticForm(Generic[ModelType]):
                 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 missing field '{field_name}'"
-                )
             else:
                 # Check if this is a SkipJsonSchema field
                 if _is_skip_json_schema_field(field_info):
-                    logger.debug(
-                        f"No default found for SkipJsonSchema field '{field_name}'"
-                    )
+                    pass  # Skip fields don't need defaults
                 else:
                     # No default → leave missing; validation will surface error
-                    logger.debug(f"No default found for field '{field_name}'")
+                    pass
 
         return data
 
@@ -722,31 +728,20 @@ class PydanticForm(Generic[ModelType]):
         async def _instance_specific_refresh_handler(req):
             """Handle form refresh request for this specific form instance"""
             # Add entry point logging to confirm the route is being hit
-            logger.debug(f"Received POST request on {refresh_route_path}")
             # Calls the instance method to handle the logic
             return await self.handle_refresh_request(req)
 
-        logger.debug(
-            f"Registered refresh route for form '{self.name}' at {refresh_route_path}"
-        )
-
         # --- Register the form-specific reset route ---
         reset_route_path = f"/form/{self.name}/reset"
 
         @app.route(reset_route_path, methods=["POST"])
         async def _instance_specific_reset_handler(req):
             """Handle form reset request for this specific form instance"""
-            logger.debug(f"Received POST request on {reset_route_path}")
             # Calls the instance method to handle the logic
             return await self.handle_reset_request()
 
-        logger.debug(
-            f"Registered reset route for form '{self.name}' at {reset_route_path}"
-        )
-
         # 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):
@@ -774,9 +769,6 @@ class PydanticForm(Generic[ModelType]):
                 return mui.Alert(str(exc), 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="")
 
             # === add (POST) ===
@@ -844,8 +836,15 @@ class PydanticForm(Generic[ModelType]):
             "hx_swap": "innerHTML",
             "hx_trigger": "click",  # Explicit trigger on click
             "hx_include": "closest form",  # Include all form fields from the enclosing form
+            "hx_preserve": "scroll",
             "uk_tooltip": "Update the form display based on current values (e.g., list item titles)",
             "cls": mui.ButtonT.secondary,
+            **{
+                "hx-on::before-request": "window.saveAllAccordionStates && window.saveAllAccordionStates()"
+            },
+            **{
+                "hx-on::after-swap": "window.restoreAllAccordionStates && window.restoreAllAccordionStates()"
+            },
         }
 
         # Update with any additional attributes
@@ -881,6 +880,7 @@ class PydanticForm(Generic[ModelType]):
             "hx_target": f"#{form_content_wrapper_id}",  # Target the wrapper Div ID
             "hx_swap": "innerHTML",
             "hx_confirm": "Are you sure you want to reset the form to its initial values? Any unsaved changes will be lost.",
+            "hx_preserve": "scroll",
             "uk_tooltip": "Reset the form fields to their original values",
             "cls": mui.ButtonT.destructive,  # Use danger style to indicate destructive action
         }
@@ -914,7 +914,6 @@ class PydanticForm(Generic[ModelType]):
         Raises:
             ValidationError: If validation fails based on the model's rules
         """
-        logger.debug(f"Validating request for form '{self.name}'")
         form_data = await req.form()
         form_dict = dict(form_data)
 

{fh_pydantic_form-0.3.0 → fh_pydantic_form-0.3.2}/src/fh_pydantic_form/registry.py

@@ -39,10 +39,7 @@ class FieldRendererRegistry:
 
     def __new__(cls, *args, **kwargs):
         if cls._instance is None:
-            logger.debug("Creating new FieldRendererRegistry singleton instance.")
             cls._instance = super().__new__(cls)
-        else:
-            logger.debug("Returning existing FieldRendererRegistry singleton instance.")
         return cls._instance
 
     @classmethod