Saltar a contenido
Traducción automática supervisada

Este contenido se traduce mediante generación automática guiada por glosarios y guías de estilo revisados por personas. Dado que el texto no se revisa manualmente línea por línea, pueden producirse errores ocasionales o expresiones poco naturales.

En caso de cualquier discrepancia, la versión en inglés constituye la autoridad y la fuente de referencia.

Leer la versión original en inglés

Contrib: SQLModel

Referencia completa de atributos y métodos para el backend de SQLModel (starlette_admin.contrib.sqlmodel), generada a partir de los docstrings. SQLModel se basa en SQLAlchemy por debajo, por lo que Admin y ModelView son subclases ligeras del backend de SQLAlchemy que validan los datos de los formularios a través de la capa Pydantic del modelo. Para una guía orientada a tareas, consulte Integración con SQLModel.

starlette_admin.contrib.sqlmodel.admin.Admin

Bases: Admin

Source code in starlette_admin/contrib/sqlmodel/admin.py 
4
5
class Admin(BaseAdmin):
    pass

starlette_admin.contrib.sqlmodel.view.ModelView

Bases: ModelView

Source code in starlette_admin/contrib/sqlmodel/view.py 
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
class ModelView(BaseModelView):
    def __init__(
        self,
        model: type[SQLModel],
        icon: str | None = None,
        display_name: str | None = None,
        menu_label: str | None = None,
        key: str | None = None,
        converter: BaseSQLAModelConverter | None = None,
    ):
        super().__init__(model, icon, display_name, menu_label, key, converter)

    async def validate(self, request: Request, data: dict[str, Any]) -> None:
        """Validate form data against the SQLModel, excluding file and relation fields.

        File and relation fields hold values (uploads, related objects) that the
        Pydantic model itself cannot validate, so they are stripped from `data`
        before calling `model_validate`.
        """
        fields = self.get_fields_list(request)
        fields_to_exclude = [
            f.name for f in fields if isinstance(f, (FileField, RelationField))
        ]
        payload = {k: v for k, v in data.items() if k not in fields_to_exclude}
        payload.update(_fk_values_from_relations(self.model, fields, data))
        self.model.model_validate(payload)

    async def handle_exception(self, request: Request, exc: Exception) -> None:
        if isinstance(exc, ValidationError):
            key_map = _fk_columns_by_relation(self.model, self.get_fields_list(request))
            raise pydantic_error_to_form_validation_errors(exc, key_map)
        return await super().handle_exception(request, exc)  # pragma: no cover

validate(request, data) async

Validate form data against the SQLModel, excluding file and relation fields.

File and relation fields hold values (uploads, related objects) that the Pydantic model itself cannot validate, so they are stripped from data before calling model_validate.

Source code in starlette_admin/contrib/sqlmodel/view.py 
75
76
77
78
79
80
81
82
83
84
85
86
87
88
async def validate(self, request: Request, data: dict[str, Any]) -> None:
    """Validate form data against the SQLModel, excluding file and relation fields.

    File and relation fields hold values (uploads, related objects) that the
    Pydantic model itself cannot validate, so they are stripped from `data`
    before calling `model_validate`.
    """
    fields = self.get_fields_list(request)
    fields_to_exclude = [
        f.name for f in fields if isinstance(f, (FileField, RelationField))
    ]
    payload = {k: v for k, v in data.items() if k not in fields_to_exclude}
    payload.update(_fk_values_from_relations(self.model, fields, data))
    self.model.model_validate(payload)

starlette_admin.contrib.sqlmodel.view.InlineModelView

Bases: InlineModelView

Inline editing of SQLModel-backed related records inside a parent form.

Inherits FK detection and session logic from the SQLAlchemy InlineModelView and adds SQLModel Pydantic validation on top.

Declare model as a class attribute (a SQLModel table class). fk_attr is optional and is auto-detected from the parent's SQLAlchemy relationship when omitted.

Example:

```python
class CommentInline(InlineModelView):
    model = Comment
    fields = ["id", "author", "body"]
    extra = 1


class PostView(ModelView):
    inlines = [CommentInline]
```
Source code in starlette_admin/contrib/sqlmodel/view.py 
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
class InlineModelView(SQLAInlineModelView):
    """Inline editing of SQLModel-backed related records inside a parent form.

    Inherits FK detection and session logic from the SQLAlchemy
    `InlineModelView` and adds SQLModel Pydantic validation on top.

    Declare `model` as a class attribute (a `SQLModel` table class). `fk_attr`
    is optional and is auto-detected from the parent's SQLAlchemy relationship
    when omitted.

    Example:

        ```python
        class CommentInline(InlineModelView):
            model = Comment
            fields = ["id", "author", "body"]
            extra = 1


        class PostView(ModelView):
            inlines = [CommentInline]
        ```
    """

    model: ClassVar[type[SQLModel]]  # type: ignore[misc]

    async def validate(self, request: Request, data: dict[str, Any]) -> None:
        fields = self.get_fields_list(request)
        fields_to_exclude = [
            f.name for f in fields if isinstance(f, (FileField, RelationField))
        ]
        payload = {k: v for k, v in data.items() if k not in fields_to_exclude}
        payload.update(_fk_values_from_relations(self.model, fields, data))
        self.model.model_validate(payload)

    async def handle_exception(self, request: Request, exc: Exception) -> None:
        if isinstance(exc, ValidationError):
            key_map = _fk_columns_by_relation(self.model, self.get_fields_list(request))
            raise pydantic_error_to_form_validation_errors(exc, key_map)
        return await super().handle_exception(request, exc)  # pragma: no cover