fh-pydantic-form 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

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,123 @@
+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": "",
+    },
+    SpacingTheme.COMPACT: {
+        "outer_margin": "mb-0.5",
+        "outer_margin_sm": "mb-0.5",
+        "inner_gap": "",
+        "inner_gap_small": "",
+        "stack_gap": "",
+        "padding": "p-2",
+        "padding_sm": "p-1",
+        "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",
+    },
+}
+
+
+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]
+
+
+# CSS override to kill any residual borders in compact mode
+COMPACT_EXTRA_CSS = fh.Style("""
+/* Aggressive margin reduction for all UIkit margin utilities */
+.compact-form .uk-margin-small-bottom,
+.compact-form .uk-margin,
+.compact-form .uk-margin-bottom {
+    margin-bottom: 2px !important;
+}
+
+/* Remove borders and shrink accordion chrome */
+.compact-form .uk-accordion > li,
+.compact-form .uk-accordion .uk-accordion-content {
+    border: 0 !important;
+}
+
+/* Minimize accordion content padding */
+.compact-form .uk-accordion-content {
+    padding-top: 0.25rem !important;
+    padding-bottom: 0.25rem !important;
+}
+
+/* Shrink accordion item title padding */
+.compact-form li.uk-open > a {
+    padding-top: 0.25rem;
+    padding-bottom: 0.25rem;
+}
+
+/* Apply smaller font and reduced padding to all form inputs */
+.compact-form input,
+.compact-form select,
+.compact-form textarea {
+    line-height: 1.25rem !important;   /* ~20px */
+    font-size: 0.8125rem !important;   /* 13px */
+}
+
+/* Legacy overrides for specific UIkit classes */
+.compact-form input.uk-form-small,
+.compact-form select.uk-form-small,
+.compact-form textarea.uk-textarea-small {
+    padding-top: 2px !important;
+    padding-bottom: 2px !important;
+}
+""")