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

fh_pydantic_form/list_path.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+import logging
+from typing import List, Tuple, Type, get_origin, get_args
+from pydantic import BaseModel
+from pydantic.fields import FieldInfo
+
+from fh_pydantic_form.type_helpers import _get_underlying_type_if_optional
+
+logger = logging.getLogger(__name__)
+
+
+def walk_path(
+    model: Type[BaseModel], segments: List[str]
+) -> Tuple[FieldInfo, List[str], Type]:
+    """
+    Resolve `segments` against `model`, stopping at the *list* field.
+
+    Args:
+        model: The BaseModel class to traverse
+        segments: Path segments like ["main_address", "tags"] or ["other_addresses", "1", "tags"]
+                 The final segment should always be a list field name.
+
+    Returns:
+        Tuple of:
+        - list_field_info: the FieldInfo for the target list field
+        - html_prefix_parts: segments used to build element IDs (includes indices)
+        - item_type: the concrete python type of items in the list
+
+    Raises:
+        ValueError: if the path is invalid or doesn't lead to a list field
+    """
+    if not segments:
+        raise ValueError("Empty path provided")
+
+    current_model = model
+    html_parts = []
+    i = 0
+
+    # Process all segments except the last one (which should be the list field)
+    while i < len(segments) - 1:
+        segment = segments[i]
+
+        # Check if this segment is a field name
+        if segment in current_model.model_fields:
+            field_info = current_model.model_fields[segment]
+            field_type = _get_underlying_type_if_optional(field_info.annotation)
+            html_parts.append(segment)
+
+            # Check if this is a list field (we're traversing into a list element)
+            if get_origin(field_type) is list:
+                # Next segment should be an index
+                if i + 1 >= len(segments) - 1:
+                    raise ValueError(f"Expected index after list field '{segment}'")
+
+                next_segment = segments[i + 1]
+                if not _is_index_segment(next_segment):
+                    raise ValueError(
+                        f"Expected index after list field '{segment}', got '{next_segment}'"
+                    )
+
+                # Get the item type of the list
+                list_item_type = (
+                    get_args(field_type)[0] if get_args(field_type) else None
+                )
+                if not list_item_type or not hasattr(list_item_type, "model_fields"):
+                    raise ValueError(
+                        f"List field '{segment}' does not contain BaseModel items"
+                    )
+
+                # Add the index to html_parts and update current model
+                html_parts.append(next_segment)
+                current_model = list_item_type
+
+                # Skip the next segment (the index) since we processed it
+                i += 2
+                continue
+
+            # Check if this is a BaseModel field
+            elif hasattr(field_type, "model_fields"):
+                current_model = field_type
+                i += 1
+            else:
+                raise ValueError(f"Field '{segment}' is not a BaseModel or list type")
+
+        elif _is_index_segment(segment):
+            # This should only happen if we're processing an index that wasn't handled above
+            raise ValueError(
+                f"Unexpected index segment '{segment}' without preceding list field"
+            )
+        else:
+            raise ValueError(
+                f"Field '{segment}' not found in model {current_model.__name__}"
+            )
+
+    # Process the final segment (should be a list field)
+    final_field_name = segments[-1]
+    if final_field_name not in current_model.model_fields:
+        raise ValueError(
+            f"Field '{final_field_name}' not found in model {current_model.__name__}"
+        )
+
+    list_field_info = current_model.model_fields[final_field_name]
+    list_field_type = _get_underlying_type_if_optional(list_field_info.annotation)
+
+    # Verify this is actually a list field
+    if get_origin(list_field_type) is not list:
+        raise ValueError(f"Final field '{final_field_name}' is not a list type")
+
+    # Get the item type
+    item_type_args = get_args(list_field_type)
+    if not item_type_args:
+        raise ValueError(
+            f"Cannot determine item type for list field '{final_field_name}'"
+        )
+
+    item_type = item_type_args[0]
+    html_parts.append(final_field_name)
+
+    logger.debug(
+        f"walk_path resolved: {segments} -> field_info={list_field_info}, html_parts={html_parts}, item_type={item_type}"
+    )
+
+    return list_field_info, html_parts, item_type
+
+
+def _is_index_segment(segment: str) -> bool:
+    """
+    Check if a segment represents an index (purely numeric or placeholder like 'new_1234').
+
+    Args:
+        segment: The segment to check
+
+    Returns:
+        True if the segment represents an index
+    """
+    # Pure numeric (like "0", "1", "2")
+    if segment.isdigit():
+        return True
+
+    # Placeholder format (like "new_1234567890")
+    if segment.startswith("new_") and len(segment) > 4:
+        timestamp_part = segment[4:]
+        return timestamp_part.isdigit()
+
+    return False

fh_pydantic_form/type_helpers.py

@@ -1,5 +1,13 @@
+import logging
+from enum import Enum
+from types import UnionType
 from typing import Any, Literal, Union, get_args, get_origin
 
+logger = logging.getLogger(__name__)
+
+# Sentinel value to indicate no default is available
+_UNSET = object()
+
 
 def _is_optional_type(annotation: Any) -> bool:
     """
@@ -12,13 +20,23 @@ def _is_optional_type(annotation: Any) -> bool:
         True if the annotation is Optional[T], False otherwise
     """
     origin = get_origin(annotation)
-    if origin is Union:
+    if origin in (Union, UnionType):
         args = get_args(annotation)
         # Check if NoneType is one of the args and there are exactly two args
         return len(args) == 2 and type(None) in args
     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.
@@ -40,3 +58,92 @@ def _is_literal_type(annotation: Any) -> bool:
     """Check if the underlying type of an annotation is Literal."""
     underlying_type = _get_underlying_type_if_optional(annotation)
     return get_origin(underlying_type) is Literal
+
+
+def _is_enum_type(annotation: Any) -> bool:
+    """Check if the underlying type of an annotation is Enum."""
+    underlying_type = _get_underlying_type_if_optional(annotation)
+    return isinstance(underlying_type, type) and issubclass(underlying_type, Enum)
+
+
+def get_default(field_info: Any) -> Any:
+    """
+    Extract the default value from a Pydantic field definition.
+
+    Handles both literal defaults and default_factory functions.
+
+    Args:
+        field_info: The Pydantic FieldInfo object
+
+    Returns:
+        The default value if available, or _UNSET sentinel if no default exists
+    """
+    # Check for literal default value (including None, but not Undefined)
+    if hasattr(field_info, "default") and not _is_pydantic_undefined(
+        field_info.default
+    ):
+        return field_info.default
+
+    # Check for default_factory
+    default_factory = getattr(field_info, "default_factory", None)
+    if default_factory is not None and callable(default_factory):
+        try:
+            return default_factory()
+        except Exception as exc:
+            logger.warning(f"default_factory failed for field: {exc}")
+            # Don't raise - return sentinel to indicate no usable default
+
+    return _UNSET
+
+
+def _is_pydantic_undefined(value: Any) -> bool:
+    """
+    Check if a value is Pydantic's Undefined sentinel.
+
+    Args:
+        value: The value to check
+
+    Returns:
+        True if the value represents Pydantic's undefined default
+    """
+    # Check if value is None first (common case)
+    if value is None:
+        return False
+
+    # Check for various Pydantic undefined markers
+    if hasattr(value, "__class__"):
+        class_name = value.__class__.__name__
+        if class_name in ("Undefined", "PydanticUndefined"):
+            return True
+
+    # Check string representation as fallback
+    str_repr = str(value)
+    if str_repr in ("PydanticUndefined", "<class 'pydantic_core.PydanticUndefined'>"):
+        return True
+
+    # Check for pydantic.fields.Undefined (older versions)
+    try:
+        from pydantic import fields
+
+        if hasattr(fields, "Undefined") and value is fields.Undefined:
+            return True
+    except ImportError:
+        pass
+
+    # Check for pydantic_core.PydanticUndefined (newer versions)
+    try:
+        import pydantic_core
+
+        if (
+            hasattr(pydantic_core, "PydanticUndefined")
+            and value is pydantic_core.PydanticUndefined
+        ):
+            return True
+    except ImportError:
+        pass
+
+    return False
+
+
+# Local import placed after _UNSET is defined to avoid circular-import problems
+from .defaults import default_for_annotation  # noqa: E402

fh_pydantic_form/ui_style.py

@@ -0,0 +1,134 @@
+from enum import Enum, auto
+from typing import Dict, Literal, Union
+
+import fasthtml.common as fh
+
+
+class SpacingTheme(Enum):
+    NORMAL = auto()
+    COMPACT = auto()
+
+
+# Type alias for spacing values - supports both literal strings and enum values
+SpacingValue = Union[Literal["normal", "compact"], SpacingTheme]
+
+
+def _normalize_spacing(spacing_value: SpacingValue) -> SpacingTheme:
+    """Convert literal string or enum spacing value to SpacingTheme enum."""
+    if isinstance(spacing_value, str):
+        if spacing_value == "compact":
+            return SpacingTheme.COMPACT
+        elif spacing_value == "normal":
+            return SpacingTheme.NORMAL
+        else:
+            # This case shouldn't happen with proper Literal typing, but included for runtime safety
+            raise ValueError(
+                f"Invalid spacing value: {spacing_value}. Must be 'compact', 'normal', or SpacingTheme enum"
+            )
+    elif isinstance(spacing_value, SpacingTheme):
+        return spacing_value
+    else:
+        raise TypeError(
+            f"spacing must be Literal['normal', 'compact'] or SpacingTheme, got {type(spacing_value)}"
+        )
+
+
+SPACING_MAP: Dict[SpacingTheme, Dict[str, str]] = {
+    SpacingTheme.NORMAL: {
+        "outer_margin": "mb-4",
+        "outer_margin_sm": "mb-2",
+        "inner_gap": "space-y-3",
+        "inner_gap_small": "space-y-2",
+        "stack_gap": "space-y-3",
+        "padding": "p-4",
+        "padding_sm": "p-3",
+        "padding_card": "px-4 py-3",
+        "card_border": "border",
+        "section_divider": "border-t border-gray-200",
+        "accordion_divider": "uk-accordion-divider",
+        "label_gap": "mb-1",
+        "card_body_pad": "px-4 py-3",
+        "accordion_content": "",
+        "input_size": "",
+        "input_padding": "",
+        "horizontal_gap": "gap-3",
+        "label_align": "items-start",
+    },
+    SpacingTheme.COMPACT: {
+        "outer_margin": "mb-0",
+        "outer_margin_sm": "mb-0",
+        "inner_gap": "space-y-1",
+        "inner_gap_small": "space-y-0.5",
+        "stack_gap": "space-y-1",
+        "padding": "p-1",
+        "padding_sm": "p-0.5",
+        "padding_card": "px-2 py-1",
+        "card_border": "",
+        "section_divider": "",
+        "accordion_divider": "",
+        "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",
+        "horizontal_gap": "gap-2",
+        "label_align": "items-center",
+    },
+}
+
+
+def spacing(token: str, spacing: SpacingValue) -> str:
+    """Return a Tailwind utility class for the given semantic token."""
+    theme = _normalize_spacing(spacing)
+    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 {
+
+  /* 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; }
+
+  /* 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;
+  }
+
+  /* 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; }
+}
+""")