Chacun de ces `dict` de réponse peut avoir une clé `model`, contenant un modèle Pydantic, tout comme `response_model`.

**FastAPI** prendra ce modèle, générera son schéma JSON et l'inclura au bon endroit dans OpenAPI.

Par exemple, pour déclarer une autre réponse avec un code HTTP `404` et un modèle Pydantic `Message`, vous pouvez écrire :

```Python hl_lines="18 22"

Et nous analysons directement ce contenu YAML, puis nous utilisons à nouveau le même modèle Pydantic pour valider le contenu YAML :

```Python hl_lines="26-33"
{!../../docs_src/path_operation_advanced_configuration/tutorial007.py!}
```

/// tip | "Astuce"

Ici, nous réutilisons le même modèle Pydantic.

Mais nous aurions pu tout aussi bien pu le valider d'une autre manière.

# Renvoyer directement une réponse

Lorsque vous créez une *opération de chemins* **FastAPI**, vous pouvez normalement retourner n'importe quelle donnée : un `dict`, une `list`, un modèle Pydantic, un modèle de base de données, etc.

Par défaut, **FastAPI** convertirait automatiquement cette valeur de retour en JSON en utilisant le `jsonable_encoder` expliqué dans [JSON Compatible Encoder](../tutorial/encoder.md){.internal-link target=_blank}.

     */
    public static final ArtifactStatus CONVERTED = new ArtifactStatus("converted", 2);

    /**
     * Moderate trust - it was deployed directly from a partner.
     */
    public static final ArtifactStatus PARTNER = new ArtifactStatus("partner", 3);

    /**
     * Moderate trust - it was deployed directly by a user.
     */
    public static final ArtifactStatus DEPLOYED = new ArtifactStatus("deployed", 4);

Ancak yukarıdaki adımları takip ederek, bazı performans optimizasyonları yapılabilecektir.

## Teknik Detaylar

Python'un modern versiyonlarında **`async` ve `await`** sözdizimi ile **"coroutines"**  kullanan **"asenkron kod"** desteğine sahiptir.

Bu ifadeyi aşağıdaki bölümlerde daha da ayrıntılı açıklayalım:

* **Asenkron kod**

 * [connection pool][ConnectionPool].
 *
 * Do not confuse this class with the misnamed `HttpURLConnection`, which isn't so much a connection
 * as a single request/response exchange.
 *
 * ## Modern TLS
 *
 * There are trade-offs when selecting which options to include when negotiating a secure connection
 * to a remote host. Newer TLS options are quite useful:
 *

	github.com/minio/md5-simd v1.1.2 // indirect
	github.com/minio/websocket v1.6.0 // indirect
	github.com/mitchellh/mapstructure v1.5.0 // indirect
	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
	github.com/modern-go/reflect2 v1.0.2 // indirect
	github.com/montanaflynn/stats v0.7.1 // indirect
	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect

**Codice Sorgente**: <a href="https://github.com/fastapi/fastapi" target="_blank">https://github.com/fastapi/fastapi</a>

---

FastAPI è un web framework moderno e veloce (a prestazioni elevate) che serve a creare API con Python 3.6+ basato sulle annotazioni di tipo di Python.

Le sue caratteristiche principali sono:

import okhttp3.internal.http2.Settings
import okio.Buffer
import org.junit.Ignore
import org.junit.Test

/**
 * Access every type, function, and property from Kotlin to defend against unexpected regressions in
 * modern 4.0.x kotlin source-compatibility.
 */
@Suppress(
  "ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE",
  "UNUSED_ANONYMOUS_PARAMETER",
  "UNUSED_VALUE",
  "UNUSED_VARIABLE",
  "VARIABLE_WITH_REDUNDANT_INITIALIZER",

```console
$ pip install websockets

---> 100%
```

</div>

## Cliente WebSockets

### Em produção

Em seu sistema de produção, você provavelmente tem um frontend criado com um framework moderno como React, Vue.js ou Angular.

E para comunicar usando WebSockets com seu backend, você provavelmente usaria as utilidades do seu frontend.