Zum Inhalt
Überwachte maschinelle Übersetzung

Dieser Inhalt wurde maschinell übersetzt und basiert auf von Menschen kuratierten Glossaren und Styleguides. Da der Text nicht zeilenweise manuell überprüft wird, können gelegentlich Fehler oder unklare Formulierungen auftreten.

Bei etwaigen Abweichungen ist die ursprüngliche englische Version die maßgebliche Quelle.

Lesen Sie die ursprüngliche englische Version

Contrib: SQLModel

Vollständige Referenz aller Attribute und Methoden des SQLModel-Backends (starlette_admin.contrib.sqlmodel), generiert aus den Docstrings. SQLModel basiert auf SQLAlchemy, daher sind Admin und ModelView schlanke Subklassen des SQLAlchemy-Backends, die Formulardaten über die Pydantic-Schicht des Modells validieren. Eine aufgabensorientierte Anleitung finden Sie unter 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