# Obtenir l'utilisateur actuel { #get-current-user }

Dans le chapitre précédent, le système de sécurité (basé sur le système d'injection de dépendances) fournissait à la *fonction de chemin d'accès* un `token` en tant que `str` :

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

Mais ce n'est pas encore très utile.

Faisons en sorte qu'il nous fournisse l'utilisateur actuel.

## Créer un modèle d'utilisateur { #create-a-user-model }

et vous obtiendriez les objets depuis la base de données en utilisant cette nouvelle session. Puis, au lieu de passer l’objet obtenu depuis la base de données en paramètre à la fonction de tâche d’arrière‑plan, vous passeriez l’identifiant (ID) de cet objet et vous obtiendriez à nouveau l’objet à l’intérieur de la fonction de la tâche d’arrière‑plan....

# Paramètres de requête { #query-parameters }

Quand vous déclarez d'autres paramètres de fonction qui ne font pas partie des paramètres de chemin, ils sont automatiquement interprétés comme des paramètres de « query ».

{* ../../docs_src/query_params/tutorial001_py310.py hl[9] *}

La query est l'ensemble des paires clé-valeur placées après le `?` dans une URL, séparées par des caractères `&`.

Par exemple, dans l'URL :

```

    * Si la donnée est invalide, une erreur propre et claire sera renvoyée, indiquant exactement où et quelle était la donnée incorrecte.
* Passer la donnée reçue dans le paramètre `item`.
    * Ce paramètre ayant été déclaré dans la fonction comme étant de type `Item`, vous aurez aussi tout le support offert par l'éditeur (autocomplétion, etc.) pour tous les attributs de ce paramètre et les types de ces attributs.

L'élément clé est qu'une dépendance doit être un « callable ».

Un « callable » en Python est tout ce que Python peut « appeler » comme une fonction.

Ainsi, si vous avez un objet `something` (qui n'est peut‑être pas une fonction) et que vous pouvez « l'appeler » (l'exécuter) comme :

```Python
something()
```

ou

```Python
something(some_argument, some_keyword_argument="foo")
```

7. Ici, `response_model` utilise une annotation de type correspondant à une liste de dataclasses `Author`.

    Là encore, vous pouvez combiner `dataclasses` avec des annotations de type standard.

8. Notez que cette *fonction de chemin d'accès* utilise un `def` classique au lieu de `async def`.

    Comme toujours, avec FastAPI vous pouvez combiner `def` et `async def` selon vos besoins.

---> 100%
```

</div>

## En détail { #in-detail }

Le marqueur `@pytest.mark.anyio` indique à pytest que cette fonction de test doit être appelée de manière asynchrone :

{* ../../docs_src/async_tests/app_a_py310/test_main.py hl[7] *}

/// tip | Astuce

Notez que la fonction de test est maintenant `async def` au lieu de simplement `def` comme auparavant avec le `TestClient`.

///

Prend un générateur async ou un générateur/itérateur normal (une fonction avec `yield`) et diffuse le corps de la réponse.

{* ../../docs_src/custom_response/tutorial007_py310.py hl[3,16] *}

/// note | Détails techniques

# Corps - Champs { #body-fields }

De la même manière que vous pouvez déclarer des validations supplémentaires et des métadonnées dans les paramètres d'une fonction de chemin d'accès avec `Query`, `Path` et `Body`, vous pouvez déclarer des validations et des métadonnées à l'intérieur des modèles Pydantic en utilisant `Field` de Pydantic.

## Importer `Field` { #import-field }

D'abord, vous devez l'importer :

Par exemple, si vous devez le stocker dans une base de données.

Pour cela, **FastAPI** fournit une fonction `jsonable_encoder()`.

## Utiliser `jsonable_encoder` { #using-the-jsonable-encoder }

Imaginons que vous ayez une base de données `fake_db` qui ne reçoit que des données compatibles JSON.