codeforms 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

codeforms/fields.py

@@ -1,9 +1,17 @@
 import re
 from datetime import date, datetime
 from enum import Enum
-from typing import Optional, List, Literal, Union, Dict, Any, Type, Set
+from typing import Any, Dict, List, Literal, Optional, Set, Union
 from uuid import UUID, uuid4
-from pydantic import BaseModel, Field, EmailStr, ConfigDict, field_validator, model_validator
+
+from pydantic import (
+    BaseModel,
+    EmailStr,
+    Field,
+    field_validator,
+    model_validator,
+)
+
 from codeforms.i18n import t
 
 
@@ -22,6 +30,7 @@ class FieldType(str, Enum):
     HIDDEN = "hidden"
     URL = "url"
     LIST = "list"
+    OBJECT_LIST = "object-list"
 
 
 class ValidationRule(BaseModel):
@@ -32,9 +41,12 @@ class ValidationRule(BaseModel):
 
 class VisibilityRule(BaseModel):
     """Regla de visibilidad condicional para un campo."""
-    field: str                    # nombre del campo del que depende
-    operator: str = "equals"      # equals, not_equals, in, not_in, gt, lt, is_empty, is_not_empty
-    value: Any = None             # valor a comparar
+
+    field: str  # nombre del campo del que depende
+    operator: str = (
+        "equals"  # equals, not_equals, in, not_in, gt, lt, is_empty, is_not_empty
+    )
+    value: Any = None  # valor a comparar
 
 
 class SelectOption(BaseModel):
@@ -45,8 +57,9 @@ class SelectOption(BaseModel):
 
 class DependentOptionsConfig(BaseModel):
     """Configuración para opciones dependientes de otro campo."""
-    depends_on: str                              # nombre del campo padre
-    options_map: Dict[str, List[SelectOption]]    # valor_padre → opciones disponibles
+
+    depends_on: str  # nombre del campo padre
+    options_map: Dict[str, List[SelectOption]]  # valor_padre → opciones disponibles
 
 
 class FormFieldBase(BaseModel):
@@ -65,7 +78,7 @@ class FormFieldBase(BaseModel):
     visible_when: Optional[List[VisibilityRule]] = None
     dependent_options: Optional[DependentOptionsConfig] = None
 
-    @field_validator('attributes', mode='before')
+    @field_validator("attributes", mode="before")
     @classmethod
     def coerce_attributes_to_strings(cls, v: Any) -> Dict[str, str]:
         """Coerce all attribute values to strings to handle cases like data_flags=1."""
@@ -79,7 +92,7 @@ class FormFieldBase(BaseModel):
         "json_serializers": {
             UUID: str,
             datetime: lambda v: v.isoformat(),
-            date: lambda v: v.isoformat()
+            date: lambda v: v.isoformat(),
         }
     }
 
@@ -89,9 +102,10 @@ class FormFieldBase(BaseModel):
         ft = self.field_type
         return ft.value if isinstance(ft, FieldType) else ft
 
-    def export(self, output_format: str = 'html', **kwargs) -> str:
+    def export(self, output_format: str = "html", **kwargs) -> str:
         """Método genérico para exportar el campo en diferentes formatos"""
         from codeforms.export import field_exporter
+
         return field_exporter(self, output_format, kwargs=kwargs)
 
 
@@ -100,7 +114,7 @@ class CheckboxField(FormFieldBase):
     checked: bool = False
     value: str = "on"  # Valor por defecto cuando está marcado
 
-    @field_validator('default_value')
+    @field_validator("default_value")
     @classmethod
     def validate_default_value(cls, v: Any) -> Any:
         if v is not None and not isinstance(v, bool):
@@ -113,7 +127,7 @@ class CheckboxGroupField(FormFieldBase):
     options: List[SelectOption]
     inline: bool = False
 
-    @field_validator('default_value')
+    @field_validator("default_value")
     @classmethod
     def validate_default_value(cls, v: Any) -> Any:
         if v is not None and not isinstance(v, list):
@@ -126,7 +140,7 @@ class RadioField(FormFieldBase):
     options: List[SelectOption]
     inline: bool = False
 
-    @field_validator('default_value')
+    @field_validator("default_value")
     @classmethod
     def validate_default_value(cls, v: Any) -> Any:
         if v is not None and not isinstance(v, str):
@@ -141,25 +155,25 @@ class SelectField(FormFieldBase):
     min_selected: Optional[int] = None  # Mínimo de opciones a seleccionar
     max_selected: Optional[int] = None  # Máximo de opciones a seleccionar
 
-    @field_validator('min_selected')
+    @field_validator("min_selected")
     @classmethod
     def validate_min_selected(cls, v: Optional[int], info: Any) -> Optional[int]:
         if v is not None:
             if v < 0:
                 raise ValueError(t("select.min_selected_negative"))
-            if not info.data.get('multiple', False):
+            if not info.data.get("multiple", False):
                 raise ValueError(t("select.min_selected_requires_multiple"))
         return v
 
-    @field_validator('max_selected')
+    @field_validator("max_selected")
     @classmethod
     def validate_max_selected(cls, v: Optional[int], info: Any) -> Optional[int]:
         if v is not None:
             if v < 1:
                 raise ValueError(t("select.max_selected_min_value"))
-            if not info.data.get('multiple', False):
+            if not info.data.get("multiple", False):
                 raise ValueError(t("select.max_selected_requires_multiple"))
-            min_selected = info.data.get('min_selected')
+            min_selected = info.data.get("min_selected")
             if min_selected is not None and v < min_selected:
                 raise ValueError(t("select.max_less_than_min"))
         return v
@@ -175,7 +189,7 @@ class TextField(FormFieldBase):
     maxlength: Optional[int] = None
     pattern: Optional[str] = None
 
-    @field_validator('pattern')
+    @field_validator("pattern")
     @classmethod
     def validate_pattern(cls, v: Optional[str]) -> Optional[str]:
         if v is not None:
@@ -206,7 +220,7 @@ class TextField(FormFieldBase):
 class EmailField(FormFieldBase):
     field_type: FieldType = FieldType.EMAIL
 
-    @field_validator('default_value')
+    @field_validator("default_value")
     @classmethod
     def validate_email(cls, v: Any) -> Any:
         if v is not None:
@@ -240,22 +254,24 @@ class HiddenField(FormFieldBase):
 
 class UrlField(FormFieldBase):
     """Campo para URLs"""
+
     field_type: FieldType = FieldType.URL
     minlength: Optional[int] = None
     maxlength: Optional[int] = None
 
-    @field_validator('default_value')
+    @field_validator("default_value")
     @classmethod
     def validate_url(cls, v: Any) -> Any:
         if v is not None and isinstance(v, str):
             # Validación básica de URL
-            if not v.startswith(('http://', 'https://')):
+            if not v.startswith(("http://", "https://")):
                 raise ValueError(t("url.invalid_scheme"))
         return v
 
 
 class TextareaField(FormFieldBase):
     """Campo de texto multilínea"""
+
     field_type: FieldType = FieldType.TEXTAREA
     minlength: Optional[int] = None
     maxlength: Optional[int] = None
@@ -264,15 +280,43 @@ class TextareaField(FormFieldBase):
 
 
 class ListField(FormFieldBase):
-    """Campo para listas de valores (ej: lista de participantes)"""
+    """Campo para listas de valores primitivos (ej: lista de participantes)."""
+
     field_type: FieldType = FieldType.LIST
     min_items: Optional[int] = None
     max_items: Optional[int] = None
     item_type: str = "text"  # Tipo de cada item en la lista
 
 
+class ObjectListField(FormFieldBase):
+    """Campo para listas de objetos homogéneos validados por subcampos."""
+
+    field_type: FieldType = FieldType.OBJECT_LIST
+    min_items: Optional[int] = None
+    max_items: Optional[int] = None
+    fields: List[Any] = Field(default_factory=list)
+
+    @model_validator(mode="before")
+    @classmethod
+    def resolve_object_fields(cls, data: Any) -> Any:
+        if isinstance(data, dict) and "fields" in data:
+            from codeforms.registry import resolve_content_item
+
+            data = data.copy()
+            data["fields"] = [resolve_content_item(item) for item in data["fields"]]
+        return data
+
+    @model_validator(mode="after")
+    def validate_object_fields(self) -> "ObjectListField":
+        names = [field.name for field in self.fields]
+        if len(names) != len(set(names)):
+            raise ValueError(t("form.unique_field_names_in_group", title=self.label or self.name))
+        return self
+
+
 class FieldGroup(BaseModel):
     """Representa un grupo de campos en un formulario para organización en secciones"""
+
     container_type: str = "group"  # Discriminador explícito para distinguir de FormStep
     id: UUID = Field(default_factory=uuid4)
     title: str
@@ -281,37 +325,39 @@ class FieldGroup(BaseModel):
     css_classes: Optional[str] = None
     attributes: Dict[str, str] = Field(default_factory=dict)
     collapsible: bool = False  # Si el grupo puede colapsarse
-    collapsed: bool = False    # Si el grupo está colapsado por defecto
+    collapsed: bool = False  # Si el grupo está colapsado por defecto
 
     model_config = {
         "json_serializers": {
             UUID: str,
             datetime: lambda v: v.isoformat(),
-            date: lambda v: v.isoformat()
+            date: lambda v: v.isoformat(),
         }
     }
 
-    @model_validator(mode='before')
+    @model_validator(mode="before")
     @classmethod
     def resolve_group_fields(cls, data: Any) -> Any:
         """Resolve field dicts to instances using the registry."""
-        if isinstance(data, dict) and 'fields' in data:
+        if isinstance(data, dict) and "fields" in data:
             from codeforms.registry import resolve_content_item
+
             data = data.copy()
-            data['fields'] = [resolve_content_item(item) for item in data['fields']]
+            data["fields"] = [resolve_content_item(item) for item in data["fields"]]
         return data
 
-    @model_validator(mode='after')
-    def validate_field_names_in_group(self) -> 'FieldGroup':
+    @model_validator(mode="after")
+    def validate_field_names_in_group(self) -> "FieldGroup":
         """Valida que los nombres de campos dentro del grupo sean únicos"""
         names = [field.name for field in self.fields]
         if len(names) != len(set(names)):
             raise ValueError(t("form.unique_field_names_in_group", title=self.title))
         return self
 
-    def export(self, output_format: str = 'html', **kwargs) -> str:
+    def export(self, output_format: str = "html", **kwargs) -> str:
         """Método para exportar el grupo de campos en diferentes formatos"""
         from codeforms.export import group_exporter
+
         return group_exporter(self, output_format, kwargs=kwargs)
 
 
@@ -321,6 +367,7 @@ class FormStep(BaseModel):
     Agrupa campos y/o grupos de campos en una secuencia lógica.
     Se diferencia de FieldGroup mediante el discriminador explícito type="step".
     """
+
     type: Literal["step"] = "step"  # Discriminador explícito (RISK-1)
     id: UUID = Field(default_factory=uuid4)
     title: str
@@ -335,11 +382,11 @@ class FormStep(BaseModel):
         "json_serializers": {
             UUID: str,
             datetime: lambda v: v.isoformat(),
-            date: lambda v: v.isoformat()
+            date: lambda v: v.isoformat(),
         }
     }
 
-    @field_validator('attributes', mode='before')
+    @field_validator("attributes", mode="before")
     @classmethod
     def coerce_attributes_to_strings(cls, v: Any) -> Dict[str, str]:
         if v is None:
@@ -348,14 +395,15 @@ class FormStep(BaseModel):
             return {str(k): str(val) for k, val in v.items()}
         return v
 
-    @model_validator(mode='before')
+    @model_validator(mode="before")
     @classmethod
     def resolve_step_content(cls, data: Any) -> Any:
         """Resolver items del contenido del paso usando el registry."""
-        if isinstance(data, dict) and 'content' in data:
+        if isinstance(data, dict) and "content" in data:
             from codeforms.registry import resolve_content_item
+
             data = data.copy()
-            data['content'] = [resolve_content_item(item) for item in data['content']]
+            data["content"] = [resolve_content_item(item) for item in data["content"]]
         return data
 
     @property
@@ -370,8 +418,8 @@ class FormStep(BaseModel):
                 all_fields.append(item)
         return all_fields
 
-    def export(self, output_format: str = 'html', **kwargs) -> str:
+    def export(self, output_format: str = "html", **kwargs) -> str:
         """Exportar el paso en diferentes formatos."""
         from codeforms.export import step_exporter
-        return step_exporter(self, output_format, kwargs=kwargs)
 
+        return step_exporter(self, output_format, kwargs=kwargs)