fh-pydantic-form 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

fh_pydantic_form/__init__.py

@@ -24,7 +24,7 @@ from fh_pydantic_form.ui_style import (
     SpacingTheme,
     SpacingValue,
     spacing,
-    COMPACT_EXTRA_CSS,
+    spacing_many,
 )
 from fh_pydantic_form.defaults import (
     default_dict_for_model,
@@ -119,7 +119,7 @@ __all__ = [
     "SpacingTheme",
     "SpacingValue",
     "spacing",
-    "COMPACT_EXTRA_CSS",
+    "spacing_many",
     "default_dict_for_model",
     "default_for_annotation",
 ]

fh_pydantic_form/constants.py

@@ -0,0 +1,12 @@
+"""
+Shared constants and sentinel values used across the library.
+"""
+
+
+class _Unset:
+    """Sentinel class to indicate an unset value."""
+
+    pass
+
+
+_UNSET = _Unset()

fh_pydantic_form/defaults.py

@@ -2,11 +2,16 @@ from __future__ import annotations
 
 import datetime as _dt
 from enum import Enum
-from typing import Any, get_args, get_origin, Literal
+from typing import Any, Literal, get_args, get_origin
 
 from pydantic import BaseModel
 
-from .type_helpers import _UNSET, get_default, _is_optional_type
+from fh_pydantic_form.constants import _UNSET
+from fh_pydantic_form.type_helpers import (
+    _is_optional_type,
+    _is_skip_json_schema_field,
+    get_default,
+)
 
 
 def _today():
@@ -122,6 +127,23 @@ def default_dict_for_model(model_cls: type[BaseModel]) -> dict[str, Any]:
             continue
         # --------------------------------------------------------------------
 
+        # Check if this is a SkipJsonSchema field - if so, always get its default
+        if _is_skip_json_schema_field(field):
+            default_val = get_default(field)
+            if default_val is not _UNSET:
+                # Handle BaseModel defaults by converting to dict
+                if hasattr(default_val, "model_dump"):
+                    out[name] = default_val.model_dump()
+                # Convert enum instances to their values
+                elif isinstance(default_val, Enum):
+                    out[name] = default_val.value
+                else:
+                    out[name] = default_val
+            else:
+                # No default for SkipJsonSchema field - use smart default
+                out[name] = default_for_annotation(field.annotation)
+            continue
+
         # 1. Check for model-supplied default or factory
         default_val = get_default(field)  # returns _UNSET if no default
         if default_val is not _UNSET:

fh_pydantic_form/field_renderers.py

@@ -15,9 +15,9 @@ from fastcore.xml import FT
 from pydantic import ValidationError
 from pydantic.fields import FieldInfo
 
+from fh_pydantic_form.constants import _UNSET
 from fh_pydantic_form.registry import FieldRendererRegistry
 from fh_pydantic_form.type_helpers import (
-    _UNSET,
     _get_underlying_type_if_optional,
     _is_optional_type,
     get_default,
@@ -27,6 +27,7 @@ from fh_pydantic_form.ui_style import (
     SpacingValue,
     _normalize_spacing,
     spacing,
+    spacing_many,
 )
 
 logger = logging.getLogger(__name__)
@@ -252,6 +253,14 @@ class StringFieldRenderer(BaseFieldRenderer):
         if self.is_optional:
             placeholder_text += " (Optional)"
 
+        input_cls_parts = ["w-full"]
+        input_spacing_cls = spacing_many(
+            ["input_size", "input_padding", "input_line_height", "input_font_size"],
+            self.spacing,
+        )
+        if input_spacing_cls:
+            input_cls_parts.append(input_spacing_cls)
+
         input_attrs = {
             "value": self.value or "",
             "id": self.field_name,
@@ -259,10 +268,7 @@ class StringFieldRenderer(BaseFieldRenderer):
             "type": "text",
             "placeholder": placeholder_text,
             "required": is_field_required,
-            "cls": _merge_cls(
-                "w-full",
-                f"{spacing('input_size', self.spacing)} {spacing('input_padding', self.spacing)}".strip(),
-            ),
+            "cls": " ".join(input_cls_parts),
         }
 
         # Only add the disabled attribute if the field should actually be disabled
@@ -290,6 +296,14 @@ class NumberFieldRenderer(BaseFieldRenderer):
         if self.is_optional:
             placeholder_text += " (Optional)"
 
+        input_cls_parts = ["w-full"]
+        input_spacing_cls = spacing_many(
+            ["input_size", "input_padding", "input_line_height", "input_font_size"],
+            self.spacing,
+        )
+        if input_spacing_cls:
+            input_cls_parts.append(input_spacing_cls)
+
         input_attrs = {
             "value": str(self.value) if self.value is not None else "",
             "id": self.field_name,
@@ -297,10 +311,7 @@ class NumberFieldRenderer(BaseFieldRenderer):
             "type": "number",
             "placeholder": placeholder_text,
             "required": is_field_required,
-            "cls": _merge_cls(
-                "w-full",
-                f"{spacing('input_size', self.spacing)} {spacing('input_padding', self.spacing)}".strip(),
-            ),
+            "cls": " ".join(input_cls_parts),
             "step": "any"
             if self.field_info.annotation is float
             or get_origin(self.field_info.annotation) is float
@@ -386,6 +397,14 @@ class DateFieldRenderer(BaseFieldRenderer):
         if self.is_optional:
             placeholder_text += " (Optional)"
 
+        input_cls_parts = ["w-full"]
+        input_spacing_cls = spacing_many(
+            ["input_size", "input_padding", "input_line_height", "input_font_size"],
+            self.spacing,
+        )
+        if input_spacing_cls:
+            input_cls_parts.append(input_spacing_cls)
+
         input_attrs = {
             "value": formatted_value,
             "id": self.field_name,
@@ -393,10 +412,7 @@ class DateFieldRenderer(BaseFieldRenderer):
             "type": "date",
             "placeholder": placeholder_text,
             "required": is_field_required,
-            "cls": _merge_cls(
-                "w-full",
-                f"{spacing('input_size', self.spacing)} {spacing('input_padding', self.spacing)}".strip(),
-            ),
+            "cls": " ".join(input_cls_parts),
         }
 
         # Only add the disabled attribute if the field should actually be disabled
@@ -433,6 +449,14 @@ class TimeFieldRenderer(BaseFieldRenderer):
         if self.is_optional:
             placeholder_text += " (Optional)"
 
+        input_cls_parts = ["w-full"]
+        input_spacing_cls = spacing_many(
+            ["input_size", "input_padding", "input_line_height", "input_font_size"],
+            self.spacing,
+        )
+        if input_spacing_cls:
+            input_cls_parts.append(input_spacing_cls)
+
         input_attrs = {
             "value": formatted_value,
             "id": self.field_name,
@@ -440,10 +464,7 @@ class TimeFieldRenderer(BaseFieldRenderer):
             "type": "time",
             "placeholder": placeholder_text,
             "required": is_field_required,
-            "cls": _merge_cls(
-                "w-full",
-                f"{spacing('input_size', self.spacing)} {spacing('input_padding', self.spacing)}".strip(),
-            ),
+            "cls": " ".join(input_cls_parts),
         }
 
         # Only add the disabled attribute if the field should actually be disabled
@@ -503,18 +524,22 @@ class LiteralFieldRenderer(BaseFieldRenderer):
             placeholder_text += " (Optional)"
 
         # Prepare attributes dictionary
+        select_cls_parts = ["w-full"]
+        select_spacing_cls = spacing_many(
+            ["input_size", "input_padding", "input_line_height", "input_font_size"],
+            self.spacing,
+        )
+        if select_spacing_cls:
+            select_cls_parts.append(select_spacing_cls)
+
         select_attrs = {
             "id": self.field_name,
             "name": self.field_name,
             "required": is_field_required,
             "placeholder": placeholder_text,
-            "cls": _merge_cls(
-                "w-full",
-                f"{spacing('input_size', self.spacing)} {spacing('input_padding', self.spacing)}".strip(),
-            ),
+            "cls": " ".join(select_cls_parts),
         }
 
-        # Only add the disabled attribute if the field should actually be disabled
         if self.disabled:
             select_attrs["disabled"] = True
 
@@ -667,12 +692,15 @@ class BaseModelFieldRenderer(BaseFieldRenderer):
         )
 
         # 5. Wrap the single AccordionItem in an Accordion container
+        accordion_cls = spacing_many(
+            ["accordion_divider", "accordion_content"], self.spacing
+        )
         accordion_container = mui.Accordion(
             accordion_item,  # The single item to include
             id=accordion_id,  # ID for the accordion container (ul)
             multiple=True,  # Allow multiple open (though only one exists)
             collapsible=True,  # Allow toggling
-            cls=f"{spacing('accordion_divider', self.spacing)} {spacing('accordion_content', self.spacing)} w-full".strip(),
+            cls=f"{accordion_cls} w-full".strip(),
         )
 
         return accordion_container
@@ -987,12 +1015,15 @@ class ListFieldRenderer(BaseFieldRenderer):
         container_id = self._container_id()
 
         # Use mui.Accordion component
+        accordion_cls = spacing_many(
+            ["inner_gap_small", "accordion_content", "accordion_divider"], self.spacing
+        )
         accordion = mui.Accordion(
             *item_elements,
             id=container_id,
             multiple=True,  # Allow multiple items to be open at once
             collapsible=True,  # Make it collapsible
-            cls=f"{spacing('inner_gap_small', self.spacing)} {spacing('accordion_content', self.spacing)}".strip(),  # Add space between items and accordion content styling
+            cls=accordion_cls.strip(),  # Add space between items and accordion content styling
         )
 
         # Empty state message if no items
@@ -1344,10 +1375,19 @@ class ListFieldRenderer(BaseFieldRenderer):
             )
             li_attrs = {"id": full_card_id}
 
-            # Build card classes conditionally based on spacing theme
-            card_cls = "uk-card uk-margin-small-bottom"
+            # Build card classes using spacing tokens
+            card_cls_parts = ["uk-card"]
             if self.spacing == SpacingTheme.NORMAL:
-                card_cls += " uk-card-default"
+                card_cls_parts.append("uk-card-default")
+
+            # Add spacing-based classes
+            card_spacing_cls = spacing_many(
+                ["accordion_item_margin", "card_border_thin"], self.spacing
+            )
+            if card_spacing_cls:
+                card_cls_parts.append(card_spacing_cls)
+
+            card_cls = " ".join(card_cls_parts)
 
             return mui.AccordionItem(
                 title_component,  # Title as first positional argument
@@ -1370,10 +1410,19 @@ class ListFieldRenderer(BaseFieldRenderer):
             t = self.spacing
             content_wrapper = fh.Div(content_component, cls=spacing("card_body_pad", t))
 
-            # Build card classes conditionally based on spacing theme
-            card_cls = "uk-card uk-margin-small-bottom"
+            # Build card classes using spacing tokens
+            card_cls_parts = ["uk-card"]
             if self.spacing == SpacingTheme.NORMAL:
-                card_cls += " uk-card-default"
+                card_cls_parts.append("uk-card-default")
+
+            # Add spacing-based classes
+            card_spacing_cls = spacing_many(
+                ["accordion_item_margin", "card_border_thin"], self.spacing
+            )
+            if card_spacing_cls:
+                card_cls_parts.append(card_spacing_cls)
+
+            card_cls = " ".join(card_cls_parts)
 
             return mui.AccordionItem(
                 title_component,  # Title as first positional argument

fh_pydantic_form/form_parser.py

@@ -14,6 +14,7 @@ from fh_pydantic_form.type_helpers import (
     _is_enum_type,
     _is_literal_type,
     _is_optional_type,
+    _is_skip_json_schema_field,
 )
 
 logger = logging.getLogger(__name__)
@@ -77,6 +78,11 @@ def _parse_non_list_fields(
         if field_name in exclude_fields:
             continue
 
+        # 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
         full_key = f"{base_prefix}{field_name}"
 
@@ -91,11 +97,21 @@ def _parse_non_list_fields(
 
         # Handle Literal fields (including Optional[Literal[...]])
         elif _is_literal_type(annotation):
-            result[field_name] = _parse_literal_field(full_key, form_data, field_info)
+            if full_key in form_data:  # User sent it
+                result[field_name] = _parse_literal_field(
+                    full_key, form_data, field_info
+                )
+            elif _is_optional_type(annotation):  # Optional but omitted
+                result[field_name] = None
+            # otherwise leave the key out – defaults will be injected later
 
         # Handle Enum fields (including Optional[Enum])
         elif _is_enum_type(annotation):
-            result[field_name] = _parse_enum_field(full_key, form_data, field_info)
+            if full_key in form_data:  # User sent it
+                result[field_name] = _parse_enum_field(full_key, form_data, field_info)
+            elif _is_optional_type(annotation):  # Optional but omitted
+                result[field_name] = None
+            # otherwise leave the key out – defaults will be injected later
 
         # Handle nested model fields (including Optional[NestedModel])
         elif (
@@ -126,8 +142,13 @@ def _parse_non_list_fields(
 
         # Handle simple fields
         else:
-            # Use updated _parse_simple_field that handles optionality
-            result[field_name] = _parse_simple_field(full_key, form_data, field_info)
+            if full_key in form_data:  # User sent it
+                result[field_name] = _parse_simple_field(
+                    full_key, form_data, field_info
+                )
+            elif _is_optional_type(annotation):  # Optional but omitted
+                result[field_name] = None
+            # otherwise leave the key out – defaults will be injected later
 
     return result
 
@@ -282,6 +303,13 @@ 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
+            if _is_skip_json_schema_field(sub_field_info):
+                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)
             base_type = _get_underlying_type_if_optional(annotation)
@@ -497,20 +525,9 @@ def _parse_list_fields(
         if items:  # Only add if items were found
             final_lists[field_name] = items
 
-    # For any list field that didn't have form data, use its default
-    for field_name, field_def in list_field_defs.items():
-        if field_name not in final_lists:
-            field_info = field_def["field_info"]
-            if hasattr(field_info, "default") and field_info.default is not None:
-                final_lists[field_name] = field_info.default
-            elif (
-                hasattr(field_info, "default_factory")
-                and field_info.default_factory is not None
-            ):
-                try:
-                    final_lists[field_name] = field_info.default_factory()
-                except Exception:
-                    pass
+    # DON'T set defaults for missing list fields here - let _inject_missing_defaults handle all defaults
+    # This allows the proper default injection mechanism to work for missing list fields
+    # Only keep this section for excluded fields if needed, but don't inject defaults for all missing fields
 
     return final_lists
 

fh_pydantic_form/form_renderer.py

@@ -17,6 +17,7 @@ import monsterui.all as mui
 from fastcore.xml import FT
 from pydantic import BaseModel
 
+from fh_pydantic_form.constants import _UNSET
 from fh_pydantic_form.defaults import default_dict_for_model, default_for_annotation
 from fh_pydantic_form.field_renderers import (
     BaseFieldRenderer,
@@ -30,9 +31,8 @@ from fh_pydantic_form.form_parser import (
 )
 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.type_helpers import _is_skip_json_schema_field, get_default
 from fh_pydantic_form.ui_style import (
-    COMPACT_EXTRA_CSS,
     SpacingTheme,
     SpacingValue,
     _normalize_spacing,
@@ -213,19 +213,10 @@ class PydanticForm(Generic[ModelType]):
 
     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.
+        Wrap inner markup in a wrapper div.
         """
         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,
-        )
+        return fh.Div(inner, cls=wrapper_cls)
 
     def _clone_with_values(self, values: Dict[str, Any]) -> "PydanticForm":
         """
@@ -354,6 +345,11 @@ class PydanticForm(Generic[ModelType]):
                 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
             initial_value = (
                 self.values_dict.get(field_name) if self.values_dict else None
@@ -588,35 +584,30 @@ class PydanticForm(Generic[ModelType]):
         # 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)
+        # Inject defaults for missing fields before returning
+        self._inject_missing_defaults(result)
 
         return result
 
-    def _inject_default_values_for_excluded(
-        self, data: Dict[str, Any]
-    ) -> Dict[str, Any]:
+    def _inject_missing_defaults(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.
+        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.
 
         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)
+        # 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
             if field_name in data:
                 continue
 
@@ -627,17 +618,10 @@ 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 excluded field '{field_name}'"
-                )
+                logger.debug(f"Injected initial value for missing 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
@@ -645,27 +629,17 @@ class PydanticForm(Generic[ModelType]):
                     default_val = default_val.model_dump()
                 data[field_name] = default_val
                 logger.debug(
-                    f"Injected model default value for excluded field '{field_name}'"
+                    f"Injected model default value for missing 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
+                # 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}'"
+                    )
                 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
+                    # No default → leave missing; validation will surface error
+                    logger.debug(f"No default found for field '{field_name}'")
 
         return data
 

fh_pydantic_form/type_helpers.py

@@ -1,12 +1,88 @@
+# Explicit exports for public API
+__all__ = [
+    "_is_optional_type",
+    "_get_underlying_type_if_optional",
+    "_is_literal_type",
+    "_is_enum_type",
+    "_is_skip_json_schema_field",
+    "default_for_annotation",
+]
+
 import logging
 from enum import Enum
 from types import UnionType
-from typing import Any, Literal, Union, get_args, get_origin
+from typing import Annotated, Any, Literal, Union, get_args, get_origin
+
+from fh_pydantic_form.constants import _UNSET
 
 logger = logging.getLogger(__name__)
 
-# Sentinel value to indicate no default is available
-_UNSET = object()
+
+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.
+
+    This handles the pattern where SkipJsonSchema is used with typing.Annotated:
+    - Annotated[str, SkipJsonSchema()]
+    - SkipJsonSchema[str] (which internally uses Annotated)
+    - Field metadata containing SkipJsonSchema (Pydantic 2 behavior)
+
+    Args:
+        annotation_or_field_info: The field annotation or field_info to check
+
+    Returns:
+        True if the field should be skipped in JSON schema
+    """
+    try:
+        from pydantic.json_schema import SkipJsonSchema
+
+        skip_json_schema_cls = SkipJsonSchema
+    except ImportError:  # very old Pydantic
+        skip_json_schema_cls = None
+
+    if skip_json_schema_cls is None:
+        return False
+
+    # Check if it's a field_info object with metadata
+    if hasattr(annotation_or_field_info, "metadata"):
+        metadata = getattr(annotation_or_field_info, "metadata", [])
+        if metadata:
+            for item in metadata:
+                if (
+                    item is skip_json_schema_cls
+                    or isinstance(item, skip_json_schema_cls)
+                    or (
+                        hasattr(item, "__class__")
+                        and item.__class__.__name__ == "SkipJsonSchema"
+                    )
+                ):
+                    return True
+
+    # Fall back to checking annotation (for backward compatibility)
+    annotation = annotation_or_field_info
+    if hasattr(annotation_or_field_info, "annotation"):
+        annotation = getattr(annotation_or_field_info, "annotation")
+
+    # 1. Direct or generic alias
+    if (
+        annotation is skip_json_schema_cls
+        or getattr(annotation, "__origin__", None) is skip_json_schema_cls
+    ):
+        return True
+
+    # 2. Something like Annotated[T, SkipJsonSchema()]
+    if get_origin(annotation) is Annotated:
+        for meta in get_args(annotation)[1:]:
+            meta_class = getattr(meta, "__class__", None)
+            if (
+                meta is skip_json_schema_cls  # plain class
+                or isinstance(meta, skip_json_schema_cls)  # instance
+                or (meta_class is not None and meta_class.__name__ == "SkipJsonSchema")
+            ):
+                return True
+
+    # 3. Fallback – cheap but effective
+    return "SkipJsonSchema" in repr(annotation)
 
 
 def _is_optional_type(annotation: Any) -> bool:
@@ -27,16 +103,6 @@ def _is_optional_type(annotation: Any) -> bool:
     return False
 
 
-# Explicit exports for public API
-__all__ = [
-    "_is_optional_type",
-    "_get_underlying_type_if_optional",
-    "_is_literal_type",
-    "_is_enum_type",
-    "default_for_annotation",
-]
-
-
 def _get_underlying_type_if_optional(annotation: Any) -> Any:
     """
     Extract the type T from Optional[T], otherwise return the original annotation.

fh_pydantic_form/ui_style.py

@@ -1,8 +1,6 @@
 from enum import Enum, auto
 from typing import Dict, Literal, Union
 
-import fasthtml.common as fh
-
 
 class SpacingTheme(Enum):
     NORMAL = auto()
@@ -44,13 +42,19 @@ SPACING_MAP: Dict[SpacingTheme, Dict[str, str]] = {
         "padding_sm": "p-3",
         "padding_card": "px-4 py-3",
         "card_border": "border",
+        "card_border_thin": "",
         "section_divider": "border-t border-gray-200",
         "accordion_divider": "uk-accordion-divider",
+        "accordion_title_pad": "",
+        "accordion_content_pad": "",
+        "accordion_item_margin": "uk-margin-small-bottom",
         "label_gap": "mb-1",
         "card_body_pad": "px-4 py-3",
         "accordion_content": "",
         "input_size": "",
         "input_padding": "",
+        "input_line_height": "",
+        "input_font_size": "",
         "horizontal_gap": "gap-3",
         "label_align": "items-start",
     },
@@ -64,13 +68,19 @@ SPACING_MAP: Dict[SpacingTheme, Dict[str, str]] = {
         "padding_sm": "p-0.5",
         "padding_card": "px-2 py-1",
         "card_border": "",
+        "card_border_thin": "",
         "section_divider": "",
         "accordion_divider": "",
+        "accordion_title_pad": "py-1",
+        "accordion_content_pad": "py-1",
+        "accordion_item_margin": "mb-0",
         "label_gap": "mb-0",
         "card_body_pad": "px-2 py-0.5",
         "accordion_content": "uk-padding-remove-vertical",
         "input_size": "uk-form-small",
-        "input_padding": "p-1",
+        "input_padding": "py-0.5 px-1",
+        "input_line_height": "leading-tight",
+        "input_font_size": "text-sm",
         "horizontal_gap": "gap-2",
         "label_align": "items-start",
     },
@@ -83,72 +93,21 @@ def spacing(token: str, spacing: SpacingValue) -> str:
     return SPACING_MAP[theme][token]
 
 
-# Optional minimal CSS for compact mode - affects only form inputs, not layout
-# Host applications can optionally inject this once at app level if desired
-COMPACT_EXTRA_CSS = fh.Style("""
-/* Compact polish – applies ONLY inside .fhpf-compact ------------------- */
-.fhpf-compact {
-  /* Force full width and left alignment */
-  width: 100% !important;
-  
-  /* Ensure all direct children are full width and left aligned */
-  & > * {
-    width: 100% !important;
-    justify-content: flex-start !important;
-    align-items: flex-start !important;
-  }
-  
-  /* Target the field containers specifically */
-  & > div > div {
-    width: 100% !important;
-    justify-content: flex-start !important;
-  }
-  
-  /* Ensure flex containers don't center */
-  .flex {
-    justify-content: flex-start !important;
-  }
-
-  /* Accordion chrome: remove border and default 20 px gap */
-  .uk-accordion > li,
-  .uk-accordion > li + li {          /* second & later items */
-        border-top: 0 !important;
-        margin-top: 0 !important;
-  }
-  .uk-accordion-title::after {       /* the hair-line we still see */
-        border-top: 0 !important;
-  }
-
-  /* Tighter title and content padding */
-  li > a.uk-accordion-title,
-  .uk-accordion-content {
-        padding-top: 0.25rem !important;
-        padding-bottom: 0.25rem !important;
-  }
-
-  /* Remove residual card outline */
-  .uk-card,
-  .uk-card-body { border: 0 !important; }
+def spacing_many(tokens: list[str], spacing: SpacingValue) -> str:
+    """
+    Return combined Tailwind utility classes for multiple semantic tokens.
 
-  /* Small-size inputs */
-  input, select, textarea {
-        line-height: 1.25rem !important;
-        font-size: 0.8125rem !important;
-        padding-top: 0.25rem !important;
-        padding-bottom: 0.25rem !important;
-  }
+    Args:
+        tokens: List of spacing token names
+        spacing: Spacing theme to use
 
-  /* Legacy uk-form-small support */
-  input.uk-form-small,
-  select.uk-form-small,
-  textarea.uk-textarea-small {
-        padding-top: 2px !important;
-        padding-bottom: 2px !important;
-  }
-
-  /* Kill generic uk-margin utilities inside the form */
-  .uk-margin-small-bottom,
-  .uk-margin,
-  .uk-margin-bottom { margin-bottom: 2px !important; }
-}
-""")
+    Returns:
+        String of space-separated CSS classes
+    """
+    theme = _normalize_spacing(spacing)
+    classes = []
+    for token in tokens:
+        class_value = SPACING_MAP[theme].get(token, "")
+        if class_value:  # Only add non-empty class values
+            classes.append(class_value)
+    return " ".join(classes)

{fh_pydantic_form-0.2.2.dist-info → fh_pydantic_form-0.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fh-pydantic-form
-Version: 0.2.2
+Version: 0.2.4
 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

fh_pydantic_form-0.2.4.dist-info/RECORD

@@ -0,0 +1,15 @@
+fh_pydantic_form/__init__.py,sha256=luxohu6NgZDC0nhSIyw5lJGP2A8JQ51Ge1Ga7DYDkF8,4048
+fh_pydantic_form/constants.py,sha256=-N9wzkibFNn-V6cO8iWTQ7_xBvwSr2hBdq-m3apmW4M,169
+fh_pydantic_form/defaults.py,sha256=Pwv46v7e43cykx4Pt01e4nw-6FBkHmPvTZK36ZTZqgA,6068
+fh_pydantic_form/field_renderers.py,sha256=VYvAmLsLhQttlg97g2KGg-VNlS4ohxrPN1O906EJM6I,54984
+fh_pydantic_form/form_parser.py,sha256=3p4SSLCA7wjuNe1izn5Me7x8z_Vhc8fxcUKtHEGdzrI,25375
+fh_pydantic_form/form_renderer.py,sha256=cPd7NbaPOZC8cTvhEZOsy8sf5fH6FomrsR_r6KAFF54,34573
+fh_pydantic_form/list_path.py,sha256=AA8bmDmaYy4rlGIvQOOZ0fP2tgcimNUB2Re5aVGnYc8,5182
+fh_pydantic_form/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fh_pydantic_form/registry.py,sha256=sufK-85ST3rc3Vu0XmjjjdTqTAqgHr_ZbMGU0xRgTK8,4996
+fh_pydantic_form/type_helpers.py,sha256=FH4yl5FW1KNKvfHzs8TKQinFTC-MUgqDvRTVfPHs1LM,6815
+fh_pydantic_form/ui_style.py,sha256=aIWDWbPBUAQ73nPC5AHZi5cnqA0SIp9ISWwsxFdXXdE,3776
+fh_pydantic_form-0.2.4.dist-info/METADATA,sha256=wkprIEyX02VPPrijmwaTOkmw7XA0TA1P9m2LC6UKc2E,26356
+fh_pydantic_form-0.2.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fh_pydantic_form-0.2.4.dist-info/licenses/LICENSE,sha256=AOi2eNK3D2aDycRHfPRiuACZ7WPBsKHTV2tTYNl7cls,577
+fh_pydantic_form-0.2.4.dist-info/RECORD,,

fh_pydantic_form-0.2.2.dist-info/RECORD

@@ -1,14 +0,0 @@
-fh_pydantic_form/__init__.py,sha256=auqrMQyy6WsEeiMIdXVrjHpSuW_L7CpW2AZ1FOXb8QE,4058
-fh_pydantic_form/defaults.py,sha256=IzBA_soBOdXP_XAUqfFAtniDQaW6N23hiXmWJD2xq0c,5168
-fh_pydantic_form/field_renderers.py,sha256=D0GGqVpUUsJMIyX3tQEgNGPIQ6x8S3OEMj8qp94YDnE,53561
-fh_pydantic_form/form_parser.py,sha256=9jSJya4TR5q2LMGV_PK-xiAjoEhq-FYKDN27lFNn5n0,24389
-fh_pydantic_form/form_renderer.py,sha256=2f1n--_DD891x1-2ci4JFBVmO8yO7X_b5Ol8W5SA42E,35580
-fh_pydantic_form/list_path.py,sha256=AA8bmDmaYy4rlGIvQOOZ0fP2tgcimNUB2Re5aVGnYc8,5182
-fh_pydantic_form/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fh_pydantic_form/registry.py,sha256=sufK-85ST3rc3Vu0XmjjjdTqTAqgHr_ZbMGU0xRgTK8,4996
-fh_pydantic_form/type_helpers.py,sha256=bWHOxu52yh9_79d_x5L3cfMqnZo856OsbL4sTttDoa4,4367
-fh_pydantic_form/ui_style.py,sha256=tJWY3MYO7XLmP0nm5x6qllEywarkoS1R-6jdxxKnYlU,4749
-fh_pydantic_form-0.2.2.dist-info/METADATA,sha256=FSBPbRTJ2FFWxnRPoUHsSnixeeO1L6ZdRTLuZB6q5kA,26356
-fh_pydantic_form-0.2.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fh_pydantic_form-0.2.2.dist-info/licenses/LICENSE,sha256=AOi2eNK3D2aDycRHfPRiuACZ7WPBsKHTV2tTYNl7cls,577
-fh_pydantic_form-0.2.2.dist-info/RECORD,,