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

fh_pydantic_form/__init__.py

@@ -1,4 +1,5 @@
 import datetime
+from enum import Enum
 from typing import Literal, get_origin
 
 from pydantic import BaseModel
@@ -7,6 +8,7 @@ from fh_pydantic_form.field_renderers import (
     BaseModelFieldRenderer,
     BooleanFieldRenderer,
     DateFieldRenderer,
+    EnumFieldRenderer,
     ListFieldRenderer,
     LiteralFieldRenderer,
     NumberFieldRenderer,
@@ -18,6 +20,16 @@ from fh_pydantic_form.registry import FieldRendererRegistry
 from fh_pydantic_form.type_helpers import (
     _get_underlying_type_if_optional,
 )
+from fh_pydantic_form.ui_style import (
+    SpacingTheme,
+    SpacingValue,
+    spacing,
+    COMPACT_EXTRA_CSS,
+)
+from fh_pydantic_form.defaults import (
+    default_dict_for_model,
+    default_for_annotation,
+)
 
 
 def register_default_renderers() -> None:
@@ -27,7 +39,7 @@ def register_default_renderers() -> None:
     This method sets up:
     - Simple type renderers (str, bool, int, float, date, time)
     - Special field renderers (Detail)
-    - Predicate-based renderers (Literal fields, lists, BaseModels)
+    - Predicate-based renderers (Literal fields, Enum fields, lists, BaseModels)
     """
     # Import renderers by getting them from globals
 
@@ -39,7 +51,20 @@ def register_default_renderers() -> None:
     FieldRendererRegistry.register_type_renderer(datetime.date, DateFieldRenderer)
     FieldRendererRegistry.register_type_renderer(datetime.time, TimeFieldRenderer)
 
-    # Register Literal field renderer
+    # Register Enum field renderer (before Literal to prioritize Enum handling)
+    def is_enum_field(field_info):
+        """Check if field is an Enum type"""
+        annotation = getattr(field_info, "annotation", None)
+        if not annotation:
+            return False
+        underlying_type = _get_underlying_type_if_optional(annotation)
+        return isinstance(underlying_type, type) and issubclass(underlying_type, Enum)
+
+    FieldRendererRegistry.register_type_renderer_with_predicate(
+        is_enum_field, EnumFieldRenderer
+    )
+
+    # Register Literal field renderer (after Enum to avoid conflicts)
     def is_literal_field(field_info):
         """Check if field is a Literal type"""
         annotation = getattr(field_info, "annotation", None)
@@ -87,4 +112,14 @@ def register_default_renderers() -> None:
 register_default_renderers()
 
 
-__all__ = ["PydanticForm", "FieldRendererRegistry", "list_manipulation_js"]
+__all__ = [
+    "PydanticForm",
+    "FieldRendererRegistry",
+    "list_manipulation_js",
+    "SpacingTheme",
+    "SpacingValue",
+    "spacing",
+    "COMPACT_EXTRA_CSS",
+    "default_dict_for_model",
+    "default_for_annotation",
+]

fh_pydantic_form/defaults.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+import datetime as _dt
+from enum import Enum
+from typing import Any, get_args, get_origin, Literal
+
+from pydantic import BaseModel
+
+from .type_helpers import _UNSET, get_default, _is_optional_type
+
+
+def _today():
+    """Wrapper for datetime.date.today() to enable testability."""
+    return _dt.date.today()
+
+
+# Simple type defaults - callables will be invoked to get fresh values
+_SIMPLE_DEFAULTS = {
+    str: "",
+    int: 0,
+    float: 0.0,
+    bool: False,
+    _dt.date: lambda: _today(),  # callable - gets current date (late-bound)
+    _dt.time: lambda: _dt.time(0, 0),  # callable - midnight
+}
+
+
+def _first_literal_choice(annotation):
+    """Get the first literal value from a Literal type annotation."""
+    args = get_args(annotation)
+    return args[0] if args else None
+
+
+def default_for_annotation(annotation: Any) -> Any:
+    """
+    Return a sensible runtime default for type annotations.
+
+    Args:
+        annotation: The type annotation to generate a default for
+
+    Returns:
+        A sensible default value for the given type
+    """
+    origin = get_origin(annotation) or annotation
+
+    # Optional[T] → None
+    if _is_optional_type(annotation):
+        return None
+
+    # Literal[...] → first literal value
+    if origin is Literal:
+        return _first_literal_choice(annotation)
+
+    # Enum → first member value
+    if isinstance(origin, type) and issubclass(origin, Enum):
+        enum_members = list(origin)
+        return enum_members[0].value if enum_members else None
+
+    # Simple primitives & datetime helpers
+    if origin in _SIMPLE_DEFAULTS:
+        default_val = _SIMPLE_DEFAULTS[origin]
+        return default_val() if callable(default_val) else default_val
+
+    # For unknown types, return None as a safe fallback
+    return None
+
+
+def _convert_enum_values(obj: Any) -> Any:
+    """
+    Recursively convert enum instances to their values in nested structures.
+
+    Args:
+        obj: Object that may contain enum instances
+
+    Returns:
+        Object with enum instances converted to their values
+    """
+    if isinstance(obj, Enum):
+        return obj.value
+    elif isinstance(obj, dict):
+        return {key: _convert_enum_values(value) for key, value in obj.items()}
+    elif isinstance(obj, list):
+        return [_convert_enum_values(item) for item in obj]
+    else:
+        return obj
+
+
+def default_dict_for_model(model_cls: type[BaseModel]) -> dict[str, Any]:
+    """
+    Recursively build a dict with sensible defaults for all fields in a Pydantic model.
+
+    Precedence order:
+    1. User-defined @classmethod default() override
+    2. Field.default or Field.default_factory values
+    3. None for Optional fields without explicit defaults
+    4. Smart defaults for primitive types
+
+    Args:
+        model_cls: The Pydantic model class to generate defaults for
+
+    Returns:
+        Dictionary with default values for all model fields
+    """
+    # Check for user-defined default classmethod first
+    if hasattr(model_cls, "default") and callable(model_cls.default):
+        instance = model_cls.default()  # may return model instance or dict
+        result = (
+            instance.model_dump() if isinstance(instance, BaseModel) else dict(instance)
+        )
+        return _convert_enum_values(result)
+
+    out: dict[str, Any] = {}
+
+    for name, field in model_cls.model_fields.items():
+        # --- NEW: recognise "today" factories for date fields early ---------
+        if (get_origin(field.annotation) or field.annotation) is _dt.date and getattr(
+            field, "default_factory", None
+        ) is not None:
+            # Never call the real factory – delegate to our _today() helper so
+            # tests can patch it (freeze_today fixture).
+            out[name] = _today()
+            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:
+            # 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
+            continue
+
+        # 2. Optional fields without explicit default → None
+        if _is_optional_type(field.annotation):
+            out[name] = None
+            continue
+
+        # 3. Handle nested structures
+        ann = field.annotation
+        base_ann = get_origin(ann) or ann
+
+        # List fields start empty
+        if base_ann is list:
+            out[name] = []
+            continue
+
+        # Nested BaseModel - recurse
+        if isinstance(base_ann, type) and issubclass(base_ann, BaseModel):
+            out[name] = default_dict_for_model(base_ann)
+            continue
+
+        # 4. Fallback to smart defaults for primitives
+        out[name] = default_for_annotation(ann)
+
+    return _convert_enum_values(out)