Utilisées par Pydantic :

* [`email-validator`](https://github.com/JoshData/python-email-validator) - pour la validation des adresses e-mail.

Utilisées par Starlette :

* [`httpx`](https://www.python-httpx.org) - Obligatoire si vous souhaitez utiliser le `TestClient`.
* [`jinja2`](https://jinja.palletsprojects.com) - Obligatoire si vous souhaitez utiliser la configuration de template par défaut.

# Exécuter un serveur manuellement { #run-a-server-manually }

## Utiliser la commande `fastapi run` { #use-the-fastapi-run-command }

En bref, utilisez `fastapi run` pour servir votre application FastAPI :

<div class="termy">

```console
$ <font color="#4E9A06">fastapi</font> run <u style="text-decoration-style:solid">main.py</u>

  <span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span>  Starting production server 🚀

- This does not apply in URLs, code blocks, and code snippets. Do not remove or add spaces there.

### Headings

- Prefer translating headings using the infinitive form (as is common in the existing French docs): `Créer…`, `Utiliser…`, `Ajouter…`.

- For headings that are instructions written in imperative in English (e.g. `Go check …`), keep them in imperative in French, using the formal grammar (e.g. `Allez voir …`).

Dans le protocole HTTP, vous pouvez communiquer avec chaque chemin en utilisant une (ou plusieurs) de ces « méthodes ».

---

En construisant des APIs, vous utilisez normalement ces méthodes HTTP spécifiques pour effectuer une action précise.

En général, vous utilisez :

* `POST` : pour créer des données.
* `GET` : pour lire des données.
* `PUT` : pour mettre à jour des données.
* `DELETE` : pour supprimer des données.

Vous pourriez donc avoir encore besoin d'utiliser des modèles Pydantic.

Mais si vous avez déjà un ensemble de dataclasses sous la main, c'est une astuce pratique pour les utiliser afin d'alimenter une API Web avec FastAPI. 🤓

///

## Utiliser des dataclasses dans `response_model` { #dataclasses-in-response-model }

Vous pouvez aussi utiliser `dataclasses` dans le paramètre `response_model` :

Vous pouvez définir le `status_code` (HTTP) à utiliser dans la réponse de votre *chemin d'accès*.

Vous pouvez passer directement le code `int`, comme `404`.

Mais si vous ne vous souvenez pas à quoi correspond chaque code numérique, vous pouvez utiliser les constantes abrégées dans `status` :

{* ../../docs_src/path_operation_configuration/tutorial001_py310.py hl[1,15] *}

Ce code d'état sera utilisé dans la réponse et ajouté au schéma OpenAPI.

# Templates { #templates }

Vous pouvez utiliser n'importe quel moteur de templates avec **FastAPI**.

Un choix courant est Jinja2, le même que celui utilisé par Flask et d'autres outils.

Il existe des utilitaires pour le configurer facilement que vous pouvez utiliser directement dans votre application **FastAPI** (fournis par Starlette).

## Installer les dépendances { #install-dependencies }

```

Ainsi, elle peut être utilisée avec `Depends`.

### Utiliser { #use-it }

Vous pouvez maintenant passer ce `oauth2_scheme` en dépendance avec `Depends`.

{* ../../docs_src/security/tutorial001_an_py310.py hl[12] *}

Cette dépendance fournira une `str` qui est affectée au paramètre `token` de la fonction de *chemin d'accès*.

///

#### Utiliser des `list` au lieu de `set` { #using-lists-instead-of-sets }

Si vous oubliez d'utiliser un `set` et utilisez une `list` ou un `tuple` à la place, FastAPI le convertira quand même en `set` et cela fonctionnera correctement :

{* ../../docs_src/response_model/tutorial006_py310.py hl[29,35] *}

## Récapitulatif { #recap }

Et ensuite, Docker pourra **utiliser le cache pour l'étape suivante** qui télécharge et installe ces dépendances. Et c'est là que nous **gagnons beaucoup de temps**. ✨ ... et évitons l'ennui en attendant. 😪😆

Télécharger et installer les dépendances de paquets **peut prendre des minutes**, mais utiliser le **cache** ne **prendra que quelques secondes** au plus.