Skip to content

Contrib: SQLModel

Full attribute and method reference for the SQLModel backend (starlette_admin.contrib.sqlmodel), generated from docstrings. SQLModel is SQLAlchemy underneath, so Admin and ModelView are thin subclasses of the SQLAlchemy backend that validate form data through the model's Pydantic layer. For a task-oriented walkthrough, see SQLModel Integration.

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