zurückmelden.

Sie können das ormar-Modell anstelle eines pydantischen Modells in einem fastapi response_model verwenden.

Natürlich können Sie ormar. Models auch mit pydantic kombinieren, wenn Sie wollen.

Eine der häufigsten Aufgaben bei Antworten besteht darin, bestimmte Felder auszuschließen, die Sie nicht in die Antwortdaten aufnehmen möchten.

Es gibt mehrere Möglichkeiten, dies in ormar zu erreichen, so dass Sie unten Ihre Optionen überprüfen und die auswählen können, die Ihrer Situation am besten entspricht.

Ausschließen der in der Antwort enthaltenen Worte

Auswählen der Wörter

Beachten Sie, dass keines der optionalen Felder erforderlich ist, was bedeutet, dass Sie sowohl in den Antworten als auch in den Anforderungen überspringen können.

Felder werden nicht benötigt, wenn (ein/viele/alle) der folgende Fall vorliegt:

Felder mit dem Tag nullable = true
Das Feld hat den Standardwert oder bietet eine Funktion namens default ="Test".
Das Feld legt den Wert server_default fest. Das* -Feld ist ein Feld mit autoincrement = Trueprimary_key (beachten Sie, dass ormar. Integercrimary_key standardmäßig autoincrement ist).

Beispiel:

Die Abbildung zeigt die Konfidenzintervalle für die Konfidenzintervalle: (
    Metathek = Metathek
    Datengrundlage = Datenbank
)

Klasse Benutzer (ormar. Modell):
    ormar_config = base_ormar_config. copy ()(= Grundeinheit von ormar_config. copy)

    id: int = ormar. Integer (primary_key = true)(nicht bekannt)
    E-Mail: str = ormar. String (max_length = 255)
    Passwort: str = ormar. String (max_length = 255)
    first_name: str = ormar. String (max_length = 255, nullable = true)(string = ormar. String (max_length = 255, nullable = true) ist ein
    last_name: str = ormar. String (max_length = 255) string = ormar. string (max_length = 255) ist ein
    Kategorie: str = ormar. String (max_length = 255, default ="Benutzer")

Im obigen Beispiel sind die Felder id (eine automatisch inkrementelle Ganzzahl) , first \ _ name (mit nullable = True) und class (mit dem Standardwert) optional , können in der Antwort übersprungen werden und das Modell wird weiterhin validiert .

Wenn das Feld leer sein kann , muss es nicht während der Erstellung und in der Antwort in die Nutzlast einbezogen werden , sodass Sie anhand des obigen Beispiels Folgendes tun können :

Hinweis : Diese App ist eine FastApi App
@app.post("/users/" , response _ model = User) # hier verwenden wir ormar .
async def create _ user (Benutzer : Benutzer) : # Hier verwenden wir ormar . Model in request Parameter
    return await Zurückuser.save()

Dies bedeutet , dass , wenn Sie in der Anforderung nicht " ie first \ _ name " übergeben , es ordnungsgemäß überprüft wird (da das Feld optional ist) , in der Datenbank gespeichert wird und einen gespeicherten Datensatz ohne dieses Feld zurückgibt (der ebenfalls verifiziert wird) .

!!!Note Beachten Sie , dass , obwohl Sie keinen Feldwert übergeben , das Feld selbst immer noch im response \ _ model vorhanden ist , was bedeutet , dass es in den Antwortdaten erscheint und auf None gesetzt ist .

Wenn Sie möchten , dass Sie das Feld aus dem Ergebnis Lesen Sie weiter unten .

FastApi Antwort _ix Modell _Ausschlussmöglichkeiten

Fastapi hat eine Antwort \ _ model \ _ exclude , die einen Satz (oder Liste) - Feldnamen akzeptiert .

Dies hat seine Grenzen , da ormar und pydantic auch Dictionaries akzeptieren , in denen Sie ausgeschlossene/include-Spalten setzen können und die auch auf verschachtelten Modellen funktionieren (mehr dazu unten) .

Beachten Sie , dass bei der Verwendung von response \ _ model ein Pflichtfeld nicht ausgeschlossen werden kann , da dies zu einem Fehler bei der Überprüfung führt .

@app.post("/users/" , response _ model = Benutzer , response _ model _ exclude ={"password"})
async def create _ user (Benutzer : Benutzer) :
    return await Zurückuser.save()

Der obere Teil kann so abgefragt werden :

von starlette . testclient import TestClient

client = Testclient (App) Bearbeiten

Für Kunden als Kunden :
        Hinweis : Es gibt kein PK
        Benutzer : {
            Deine E-Mail : >test@domain.com",
            ^*^ % A*DA * IAAA " , oder
            Vorname : " John " ,
            Letzter Name : " Doe " ,
        }
        Antwort =client.post("/users/" , json = Benutzer)
        # Hinweis , dass das excluded field durch die antwort verloren gegangen ist .
        assert " password " not in response . json () nicht antworten
        Lesen Sie die Antwort und Initialisierung Modell aus der
        created _ user = Benutzer (* * response . json ())
        # pk note ist von Autoincrement beliebt
        assert created _ user . pk ist keine
        # Hinweis , dass das Passwort in einem initialisierten Modell auch fehlt
        assert created _ user . password ist None

Beachten Sie , wie das Kennwortfeld im obigen Beispiel vollständig aus den Antwortdaten verschwindet .

Beachten Sie , dass Sie diese Methode nur für nicht erforderliche Felder verwenden können .

Verschachteltes Modell ausschließen

Obwohl fastapi nur die Weitergabe einer Gruppe von Feldnamen erlaubt , die einfach ausgeschlossen werden , ist ormar bei der Verwendung von response \ _ model \ _ exclude intelligenter .

In ormar können Sie verschachtelte Modelle mit zwei Arten von Symbolen ausschließen .

Das erste ist ein Wörterbuch mit verschachtelten Feldern , die die Struktur des Modellbaums darstellen , und das zweite ist ein durch zwei Unterstriche getrennter Feldnamenpfad .

Nehmen wir an , dass unsere Benutzerkategorie ein separates Modell ist :

Die Abbildung zeigt die Konfidenzintervalle für die Konfidenzintervalle (
    Metathek = Metathek
    Datengrundlage = Datenbank
)

Klasse Kategorie (ormar . Modell) :
    ormar _ config = base _ ormar _ config . copy (tablename = " Kategorien ")

    id : int = ormar . Integer (primary _ key = true) (nicht bekannt)
    name : str = ormar . String (max _ length = 255) [ Bearbeiten | Quelltext bearbeiten ]    
    priority : int = ormar . Integer (nullable = true) [ Bearbeiten | Quelltext bearbeiten ]


Klasse Benutzer (ormar . Model) :
    ormar _ config = base _ ormar _ config . copy () (= Grundeinheit von ormar _ config . copy)

    id : int = ormar . Integer (primary _ key = true) (nicht bekannt)
    E-Mail : str = ormar . String (max _ length = 255)
    Passwort : str = ormar . String (max _ length = 255)
    first _ name : str = ormar . String (max _ length = 255 , nullable = true) (string = ormar . String (max _ length = 255 , nullable = true) ist ein
    last _ name : str = ormar . String (max _ length = 255) string = ormar . string (max _ length = 255) ist ein
    Category : Optional [ Category ] = ormar . ForeignKey (Category , related _ name = " categories ") [ Bearbeiten | Quelltext bearbeiten ]

Wenn Sie die Priorität von den Kategorien in der Antwort ausschließen möchten , können Sie den fastapi-Parameter trotzdem verwenden .

@app.post("/users/" , response _ model = Benutzer , response _ model _ exclude ={"category__priority"}) ("/Benutzer/" , response _ model = Benutzer , response _ model _ exclude ={"category__priority"}")
async def create _ user (Benutzer : User) :
    return await Zurückuser.save()

Beachten Sie , dass Sie in ein tieferes Modell mit zwei Unterstrichen einsteigen können , und wenn Sie mehrere Felder von einem verschachtelten Modell ausschließen möchten , müssen Sie ihnen einen vollständigen Pfad voranstellen response_model_exclude={"category__priority", "category__other_field", category__nested_model__nested_model_field} ETC im Beispiel .

!!!Hinweis Um mehr über mögliche Ausschlüsse zu lesen und wie man ein Ausschlusswörterbuch oder eine Einstellung erstellt , besuchen Sie den Abschnitt Felder des Dokuments .

Beachten Sie , dass fastapi zusätzlich zum Parameter response \ _ model \ _ exclude auch andere Parameter unterstützt , die von pydantic geerbt werden und auch für ormar gelten , aber möglicherweise einige Nuancen haben , so dass es am besten ist , den dict-Abschnitt des Dokuments zu lesen .

Model . model _ dump () ausschließen

Alternativ können Sie einfach ein Wörterbuch von ormar . Model zurückgeben und es verwenden .

Auf diese Weise können Sie auch Ausschlüsse/Einschließlich als Wörterbuch festlegen und Felder auf verschachtelten Modellen ausschließen .

!!!Die Warnung , kein response \ _ model zu verwenden , führt dazu , dass API-Dokumente keine Antwortbeispiele und - muster haben , da die Antworten theoretisch jedes beliebige Format haben können .

@app.post("/users2/" ; response _ model = Benutzer)
async def create_user2 (Benutzer : Benutzer) :
    Benutzer = Awaituser.save()
    return user . model _ dump (exclude ={'password'}) [ Bearbeiten ]
    Model _ dump (exclude = Æ'category':{'priority'}}) to exclude category priority (auch etwas wie die Rückgabe eines Benutzers sein könnte) to exclude category priority

!!!Beachten Sie, dass selbst wenn Sie das Kennwortfeld in der Anforderung übergeben, das obige Beispiel das Kennwortfeld ungültig macht, das Feld jedoch weiterhin vorhanden ist, da es Teil des Antwortschemas ist und der Wert auf None festgelegt wird.

Wenn Sie das Feld mit dieser Methode vollständig ausschließen möchten , verwenden Sie einfach nicht response \ _ model und schließen Sie es aus model \ _ dump () aus .

Alternativ können Sie einfach ein Wörterbuch aus dem ormar-Modell zurückgeben , wie dies der Fall ist , und Sie können auch Ausschlüsse/Includes als Wörterbuch festlegen und Felder auf verschachtelten Modellen ausschließen .

!!!Beachten Sie, dass Sie in der Theorie die Antwortvalidierung hier verlieren, aber da Sie auf ormar. Models arbeiten, werden die Antwortdaten bereits nach einer Datenbankabfrage validiert (da das ormar-Modell ein pydantisches Modell ist).

Wenn Sie also response \ _ model vollständig überspringen , können Sie Folgendes tun :

@app.post("/users4/") # note no response _ model ("/users4/") # note keine Antwort _ model
async def create_user4 (Benutzer : Benutzer) :
    Benutzer = Awaituser.save()
    return user . model _ dump (exclude ={'last_name'}) [ Bearbeiten | Quelltext bearbeiten ]

!!!Beachten Sie , dass Sie beim Überspringen von response \ _ model auch Pflichtfelder ausschließen können , da die Antwort nach der Rückkehr nicht mehr überprüft wird .

Der Preis dieser Lösung ist , dass Sie auch die Dokumentation als Antwort auf das Schema in unbekanntem Sinne aus der Fastapi-Perspektive lieben .

Erzeugen eines pydantischen Modells aus einem ormar . Model

Da das Ausschließen von Feldern üblich ist , bietet ormar eine spezielle Möglichkeit , pydantische Modelle aus vorhandenen ormar . Models zu generieren , ohne alle Felder erneut eingeben zu müssen .

Die Methode ist die get _ pydantic () - Methode , die in allen Modellklassen verfügbar ist .

Erstellen Sie einen Baum von Modellen ohne Passwort für den Benutzer und ohne Priorität für die angegebene Kategorie .
ResponseUser = User . get _ pydantic (exclude = {" password " : ... , " category " :{"priority"}}) (Übersetzung)
@app.post("/users3/" , response _ model = ResponseUser) # use the generated model here ("/users3/" , response _ model = ResponseUser) # benutze das generierte Modell hier
async def create_user3 (Benutzer : Benutzer) :
    return await Zurückuser.save()

Um mehr Beispiele zu sehen und mehr zu lesen , besuchen Sie bitte den Abschnitt get _ pydantic der Dokumentation .

Die get _ pydantic-Methode generiert alle Modelle in einem verschachtelten Modellbaum basierend auf Algorithmen , die es ermöglichen , Schleifen in einem Modell zu vermeiden (dieselben Algorithmen , die in model _ dump () , select \ _ all () usw . verwendet werden) .

Das bedeutet , dass nicht verwandte Modelle keine Referenz zu einem parent-Modell haben werden (nach der voreingestellten ormar-Beziehung ist bidirectional) .

Auch wenn das Modell mehr in einem Baum existiert , als einmal , wird es in pydantischen Modellen verdoppelt (jede Abweichung wird ein eigenes Modell haben) .

Eigenständiges Ausleger-Modell

Die endgültige Lösung besteht darin , separate Pydantic-Modelle manuell zu erstellen , die genau wie normale Fastapi-Anwendungen funktionieren , sodass Sie unter anderem unterschiedliche Antworten und Anfragemodelle verwenden können .

Sample sein :

Import von Pydantik

class UserBase (pydantisch . BaseModel) :
    model _ config = pydantic . ConfigDict (von _ attributes = True)

    E-Mail schreiben : str
    Vorname : str
    Vorname : str


@app.post("/users3/" , response _ model = UserBase) # use pydantisches Modell hier
async def create_user3 (user : user) : # use ormar model here (aber natürlich können Sie pydantisch auch hier verwenden)
    return await Zurückuser.save()