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

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,
@@ -26,7 +28,16 @@ from fh_pydantic_form.form_parser import (
     _parse_list_fields,
     _parse_non_list_fields,
 )
+from fh_pydantic_form.list_path import walk_path
 from fh_pydantic_form.registry import FieldRendererRegistry
+from fh_pydantic_form.type_helpers import _UNSET, get_default
+from fh_pydantic_form.ui_style import (
+    COMPACT_EXTRA_CSS,
+    SpacingTheme,
+    SpacingValue,
+    _normalize_spacing,
+    spacing,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -181,7 +192,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 +209,68 @@ class PydanticForm(Generic[ModelType]):
     - validating request data against the model
     """
 
+    # --- module-level flag (add near top of file) ---
+
+    def _compact_wrapper(self, inner: FT) -> FT:
+        """
+        Wrap inner markup in a namespaced div.
+        Auto-inject the compact CSS the *first* time any compact form is rendered.
+        """
+        wrapper_cls = "fhpf-wrapper w-full flex-1"
+
+        if self.spacing != SpacingTheme.COMPACT:
+            return fh.Div(inner, cls=wrapper_cls)
+
+        return fh.Div(
+            COMPACT_EXTRA_CSS,
+            fh.Div(inner, cls="fhpf-fields fhpf-compact"),
+            cls=wrapper_cls,
+        )
+
+    def _clone_with_values(self, values: Dict[str, Any]) -> "PydanticForm":
+        """
+        Create a copy of this renderer with the same configuration but different values.
+
+        This preserves all constructor arguments (label_colors, custom_renderers, etc.)
+        to avoid configuration drift during refresh operations.
+
+        Args:
+            values: New values dictionary to use in the cloned renderer
+
+        Returns:
+            A new PydanticForm instance with identical configuration but updated values
+        """
+        # Get custom renderers if they were registered (not stored directly on instance)
+        # We'll rely on global registry state being preserved
+
+        clone = PydanticForm(
+            form_name=self.name,
+            model_class=self.model_class,
+            initial_values=None,  # Will be set via values_dict below
+            custom_renderers=None,  # Registry is global, no need to re-register
+            disabled=self.disabled,
+            disabled_fields=self.disabled_fields,
+            label_colors=self.label_colors,
+            exclude_fields=self.exclude_fields,
+            spacing=self.spacing,
+        )
+
+        # Set the values directly
+        clone.values_dict = values
+
+        return clone
+
     def __init__(
         self,
         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 +278,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 +349,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 +372,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 +433,29 @@ 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
+                field_path=[field_name],  # Set top-level field path
             )
 
             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,23 +485,17 @@ 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)}",
                 cls=mui.AlertT.warning + " mb-4",  # Add margin bottom
             )
 
-        # Create Temporary Renderer instance
-        temp_renderer = PydanticForm(
-            form_name=self.name,
-            model_class=self.model_class,
-            # No initial_data needed here, we set values_dict below
-        )
-        # Set the values based on the parsed (or fallback) data
-        temp_renderer.values_dict = parsed_data
+        # Create temporary renderer with same configuration but updated values
+        temp_renderer = self._clone_with_values(parsed_data)
 
         refreshed_inputs_component = temp_renderer.render_inputs()
 
@@ -395,27 +523,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 +563,112 @@ 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.
+
+        Also ensures all model fields have appropriate defaults if missing.
+
+        Priority order:
+        1. initial_values (if provided during form creation)
+        2. model defaults/default_factory
+
+        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
+        """
+        # Handle excluded fields first
+        for field_name in self.exclude_fields:
+            # Skip if already present (e.g., user provided initial_values)
+            if field_name in data:
+                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}'")
+
+        # Also handle any other missing fields that should have defaults
+        for field_name, field_info in self.model_class.model_fields.items():
+            if field_name not in data:
+                # Try to inject defaults for missing fields
+                if field_name in self.initial_values_dict:
+                    initial_val = self.initial_values_dict[field_name]
+                    if hasattr(initial_val, "model_dump"):
+                        initial_val = initial_val.model_dump()
+                    data[field_name] = initial_val
+                else:
+                    default_val = get_default(field_info)
+                    if default_val is not _UNSET:
+                        if hasattr(default_val, "model_dump"):
+                            default_val = default_val.model_dump()
+                        data[field_name] = default_val
+
+        return data
+
     def register_routes(self, app):
         """
         Register HTMX routes for list manipulation and form refresh
@@ -485,143 +706,76 @@ class PydanticForm(Generic[ModelType]):
             f"Registered reset route for form '{self.name}' at {reset_route_path}"
         )
 
-        @app.route(f"/form/{self.name}/list/add/{{field_name}}")
-        async def post_list_add(req, field_name: str):
+        # Try the route with a more explicit pattern
+        route_pattern = f"/form/{self.name}/list/{{action}}/{{list_path:path}}"
+        logger.debug(f"Registering list action route: {route_pattern}")
+
+        @app.route(route_pattern, methods=["POST", "DELETE"])
+        async def list_action(req, action: str, list_path: str):
             """
-            Handle adding an item to a list for this specific form
+            Handle list actions (add/delete) for nested lists in this specific form
 
             Args:
                 req: The request object
-                field_name: The name of the list field
+                action: Either "add" or "delete"
+                list_path: Path to the list field (e.g., "tags" or "main_address/tags" or "other_addresses/1/tags")
 
             Returns:
-                A component for the new list item
+                A component for the new list item (add) or empty response (delete)
             """
-            # Find field info
-            field_info = None
-            item_type = None
-
-            if field_name in self.model_class.model_fields:
-                field_info = self.model_class.model_fields[field_name]
-                annotation = getattr(field_info, "annotation", None)
-
-                if (
-                    annotation is not None
-                    and hasattr(annotation, "__origin__")
-                    and annotation.__origin__ is list
-                ):
-                    item_type = annotation.__args__[0]
-
-                if not item_type:
-                    logger.error(
-                        f"Cannot determine item type for list field {field_name}"
-                    )
-                    return mui.Alert(
-                        f"Cannot determine item type for list field {field_name}",
-                        cls=mui.AlertT.error,
-                    )
-
-            # Create a default item
-            default_item = None  # Initialize default_item
+            if action not in {"add", "delete"}:
+                return fh.Response(status_code=400, content="Unknown list action")
+
+            segments = list_path.split("/")
             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:
-                            logger.error(
-                                f"Error constructing model for {field_name}: {e}",
-                                exc_info=True,
-                            )
-                            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  # Other simple types or complex non-models
-                else:
-                    # Case where item_type itself was None (should ideally be caught earlier)
-                    default_item = None
-                    logger.warning(
-                        f"item_type was None when trying to create default for {field_name}"
-                    )
-            except Exception as e:
-                logger.error(
-                    f"Error creating default item for {field_name}: {e}", exc_info=True
-                )
-                return fh.Li(
-                    mui.Alert(
-                        f"Error creating default item: {str(e)}", cls=mui.AlertT.error
-                    ),
-                    cls="mb-2",
+                list_field_info, html_parts, item_type = walk_path(
+                    self.model_class, segments
                 )
+            except ValueError as exc:
+                logger.warning("Bad list path %s – %s", list_path, exc)
+                return mui.Alert(str(exc), cls=mui.AlertT.error)
 
-            # Generate a unique placeholder index
-            placeholder_idx = f"new_{int(pytime.time() * 1000)}"
-
-            # Create a list renderer
-            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
-            )
-
-            # Ensure the item data passed to the renderer is a dict if it's a model instance
-            item_data_for_renderer = None
-            if isinstance(default_item, BaseModel):
-                item_data_for_renderer = default_item.model_dump()
+            if req.method == "DELETE":
                 logger.debug(
-                    f"Add item: Converted model instance to dict for renderer: {item_data_for_renderer}"
+                    f"Received DELETE request for {list_path} for form '{self.name}'"
                 )
-            elif default_item is not None:  # Handle simple types directly
-                item_data_for_renderer = default_item
-                logger.debug(
-                    f"Add item: Passing simple type directly to renderer: {item_data_for_renderer}"
-                )
-            # else: item_data_for_renderer remains None if default_item was None
+                return fh.Response(status_code=200, content="")
 
-            # Render the new item card, set is_open=True to make it expanded by default
-            new_item_card = list_renderer._render_item_card(
-                item_data_for_renderer,  # Pass the dictionary or simple value
-                placeholder_idx,
-                item_type,
-                is_open=True,
+            # === add (POST) ===
+            default_item = (
+                default_dict_for_model(item_type)
+                if hasattr(item_type, "model_fields")
+                else default_for_annotation(item_type)
             )
 
-            return new_item_card
-
-        @app.route(f"/form/{self.name}/list/delete/{{field_name}}", methods=["DELETE"])
-        async def delete_list_item(req, field_name: str):
-            """
-            Handle deleting an item from a list for this specific form
+            # Build prefix **without** the list field itself to avoid duplication
+            parts_before_list = html_parts[:-1]  # drop final segment
+            if parts_before_list:
+                html_prefix = f"{self.base_prefix}{'_'.join(parts_before_list)}_"
+            else:
+                html_prefix = self.base_prefix
+
+            # Create renderer for the list field
+            renderer = ListFieldRenderer(
+                field_name=segments[-1],
+                field_info=list_field_info,
+                value=[],
+                prefix=html_prefix,
+                spacing=self.spacing,
+                disabled=self.disabled,
+                field_path=segments,  # Pass the full path segments
+                form_name=self.name,  # Pass the explicit form name
+            )
 
-            Args:
-                req: The request object
-                field_name: The name of the list field
+            # Generate a unique placeholder index
+            placeholder_idx = f"new_{int(pytime.time() * 1000)}"
 
-            Returns:
-                Empty string to delete the target element
-            """
-            # Return empty string to delete the target element
-            logger.debug(
-                f"Received DELETE request for {field_name} for form '{self.name}'"
+            # Render the new item card, set is_open=True to make it expanded by default
+            new_card = renderer._render_item_card(
+                default_item, placeholder_idx, item_type, is_open=True
             )
-            return fh.Response(status_code=200, content="")
+
+            return new_card
 
     def refresh_button(self, text: Optional[str] = None, **kwargs) -> FT:
         """
@@ -640,9 +794,6 @@ class PydanticForm(Generic[ModelType]):
         # Define the target wrapper ID
         form_content_wrapper_id = f"{self.name}-inputs-wrapper"
 
-        # Define the form ID to include
-        form_id = f"{self.name}-form"
-
         # Define the target URL
         refresh_url = f"/form/{self.name}/refresh"
 
@@ -653,7 +804,7 @@ class PydanticForm(Generic[ModelType]):
             "hx_target": f"#{form_content_wrapper_id}",  # Target the wrapper Div ID
             "hx_swap": "innerHTML",
             "hx_trigger": "click",  # Explicit trigger on click
-            "hx_include": f"#{form_id}",  # Include all form fields in the request
+            "hx_include": "closest form",  # Include all form fields from the enclosing form
             "uk_tooltip": "Update the form display based on current values (e.g., list item titles)",
             "cls": mui.ButtonT.secondary,
         }
@@ -736,3 +887,12 @@ class PydanticForm(Generic[ModelType]):
         logger.info(f"Request validation successful for form '{self.name}'")
 
         return validated_model
+
+    def form_id(self) -> str:
+        """
+        Get the standard form ID for this renderer.
+
+        Returns:
+            The form ID string that should be used for the HTML form element
+        """
+        return f"{self.name}-form"