diff --git a/docs/es/docs/features.md b/docs/es/docs/features.md
index 3c59eb88c0..5d6b6509a7 100644
--- a/docs/es/docs/features.md
+++ b/docs/es/docs/features.md
@@ -167,7 +167,7 @@ Con **FastAPI** obtienes todas las características de **Starlette** (porque Fas
* Soporte para **GraphQL**.
* Tareas en background.
* Eventos de startup y shutdown.
-* Cliente de pruebas construido con `requests`.
+* Cliente de pruebas construido con HTTPX.
* **CORS**, GZip, Static Files, Streaming responses.
* Soporte para **Session and Cookie**.
* Cobertura de pruebas al 100%.
diff --git a/docs/es/docs/index.md b/docs/es/docs/index.md
index aa3fa22280..727a6617b5 100644
--- a/docs/es/docs/index.md
+++ b/docs/es/docs/index.md
@@ -418,7 +418,7 @@ Para un ejemplo más completo que incluye más características ve el requests - Requerido si quieres usar el `TestClient`.
+*
httpx - Requerido si quieres usar el `TestClient`.
*
jinja2 - Requerido si quieres usar la configuración por defecto de templates.
*
python-multipart - Requerido si quieres dar soporte a
"parsing" de formularios, con `request.form()`.
*
itsdangerous - Requerido para dar soporte a `SessionMiddleware`.
diff --git a/docs/fa/docs/index.md b/docs/fa/docs/index.md
index 0f7cd569ae..dfc4d24e33 100644
--- a/docs/fa/docs/index.md
+++ b/docs/fa/docs/index.md
@@ -421,7 +421,7 @@ item: Item
* قابلیتهای اضافی دیگر (بر اساس Starlette) شامل:
* **
وبسوکت**
* **GraphQL**
- * تستهای خودکار آسان مبتنی بر `requests` و `pytest`
+ * تستهای خودکار آسان مبتنی بر HTTPX و `pytest`
* **CORS**
* **Cookie Sessions**
* و موارد بیشمار دیگر.
@@ -441,7 +441,7 @@ item: Item
استفاده شده توسط Starlette:
-*
requests - در صورتی که میخواهید از `TestClient` استفاده کنید.
+*
HTTPX - در صورتی که میخواهید از `TestClient` استفاده کنید.
*
aiofiles - در صورتی که میخواهید از `FileResponse` و `StaticFiles` استفاده کنید.
*
jinja2 - در صورتی که بخواهید از پیکربندی پیشفرض برای قالبها استفاده کنید.
*
python-multipart - در صورتی که بخواهید با استفاده از `request.form()` از قابلیت
"تجزیه (parse)" فرم استفاده کنید.
diff --git a/docs/fr/docs/advanced/additional-responses.md b/docs/fr/docs/advanced/additional-responses.md
new file mode 100644
index 0000000000..35b57594d5
--- /dev/null
+++ b/docs/fr/docs/advanced/additional-responses.md
@@ -0,0 +1,240 @@
+# Réponses supplémentaires dans OpenAPI
+
+!!! Attention
+ Ceci concerne un sujet plutôt avancé.
+
+ Si vous débutez avec **FastAPI**, vous n'en aurez peut-être pas besoin.
+
+Vous pouvez déclarer des réponses supplémentaires, avec des codes HTTP, des types de médias, des descriptions, etc.
+
+Ces réponses supplémentaires seront incluses dans le schéma OpenAPI, elles apparaîtront donc également dans la documentation de l'API.
+
+Mais pour ces réponses supplémentaires, vous devez vous assurer de renvoyer directement une `Response` comme `JSONResponse`, avec votre code HTTP et votre contenu.
+
+## Réponse supplémentaire avec `model`
+
+Vous pouvez ajouter à votre décorateur de *paramètre de chemin* un paramètre `responses`.
+
+Il prend comme valeur un `dict` dont les clés sont des codes HTTP pour chaque réponse, comme `200`, et la valeur de ces clés sont d'autres `dict` avec des informations pour chacun d'eux.
+
+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"
+{!../../../docs_src/additional_responses/tutorial001.py!}
+```
+
+!!! Remarque
+ Gardez à l'esprit que vous devez renvoyer directement `JSONResponse`.
+
+!!! Info
+ La clé `model` ne fait pas partie d'OpenAPI.
+
+ **FastAPI** prendra le modèle Pydantic à partir de là, générera le `JSON Schema` et le placera au bon endroit.
+
+ Le bon endroit est :
+
+ * Dans la clé `content`, qui a pour valeur un autre objet JSON (`dict`) qui contient :
+ * Une clé avec le type de support, par ex. `application/json`, qui contient comme valeur un autre objet JSON, qui contient :
+ * Une clé `schema`, qui a pour valeur le schéma JSON du modèle, voici le bon endroit.
+ * **FastAPI** ajoute ici une référence aux schémas JSON globaux à un autre endroit de votre OpenAPI au lieu de l'inclure directement. De cette façon, d'autres applications et clients peuvent utiliser ces schémas JSON directement, fournir de meilleurs outils de génération de code, etc.
+
+Les réponses générées au format OpenAPI pour cette *opération de chemin* seront :
+
+```JSON hl_lines="3-12"
+{
+ "responses": {
+ "404": {
+ "description": "Additional Response",
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/Message"
+ }
+ }
+ }
+ },
+ "200": {
+ "description": "Successful Response",
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/Item"
+ }
+ }
+ }
+ },
+ "422": {
+ "description": "Validation Error",
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/HTTPValidationError"
+ }
+ }
+ }
+ }
+ }
+}
+```
+
+Les schémas sont référencés à un autre endroit du modèle OpenAPI :
+
+```JSON hl_lines="4-16"
+{
+ "components": {
+ "schemas": {
+ "Message": {
+ "title": "Message",
+ "required": [
+ "message"
+ ],
+ "type": "object",
+ "properties": {
+ "message": {
+ "title": "Message",
+ "type": "string"
+ }
+ }
+ },
+ "Item": {
+ "title": "Item",
+ "required": [
+ "id",
+ "value"
+ ],
+ "type": "object",
+ "properties": {
+ "id": {
+ "title": "Id",
+ "type": "string"
+ },
+ "value": {
+ "title": "Value",
+ "type": "string"
+ }
+ }
+ },
+ "ValidationError": {
+ "title": "ValidationError",
+ "required": [
+ "loc",
+ "msg",
+ "type"
+ ],
+ "type": "object",
+ "properties": {
+ "loc": {
+ "title": "Location",
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ },
+ "msg": {
+ "title": "Message",
+ "type": "string"
+ },
+ "type": {
+ "title": "Error Type",
+ "type": "string"
+ }
+ }
+ },
+ "HTTPValidationError": {
+ "title": "HTTPValidationError",
+ "type": "object",
+ "properties": {
+ "detail": {
+ "title": "Detail",
+ "type": "array",
+ "items": {
+ "$ref": "#/components/schemas/ValidationError"
+ }
+ }
+ }
+ }
+ }
+ }
+}
+```
+
+## Types de médias supplémentaires pour la réponse principale
+
+Vous pouvez utiliser ce même paramètre `responses` pour ajouter différents types de médias pour la même réponse principale.
+
+Par exemple, vous pouvez ajouter un type de média supplémentaire `image/png`, en déclarant que votre *opération de chemin* peut renvoyer un objet JSON (avec le type de média `application/json`) ou une image PNG :
+
+```Python hl_lines="19-24 28"
+{!../../../docs_src/additional_responses/tutorial002.py!}
+```
+
+!!! Remarque
+ Notez que vous devez retourner l'image en utilisant directement un `FileResponse`.
+
+!!! Info
+ À moins que vous ne spécifiiez explicitement un type de média différent dans votre paramètre `responses`, FastAPI supposera que la réponse a le même type de média que la classe de réponse principale (par défaut `application/json`).
+
+ Mais si vous avez spécifié une classe de réponse personnalisée avec `None` comme type de média, FastAPI utilisera `application/json` pour toute réponse supplémentaire associée à un modèle.
+
+## Combinaison d'informations
+
+Vous pouvez également combiner des informations de réponse provenant de plusieurs endroits, y compris les paramètres `response_model`, `status_code` et `responses`.
+
+Vous pouvez déclarer un `response_model`, en utilisant le code HTTP par défaut `200` (ou un code personnalisé si vous en avez besoin), puis déclarer des informations supplémentaires pour cette même réponse dans `responses`, directement dans le schéma OpenAPI.
+
+**FastAPI** conservera les informations supplémentaires des `responses` et les combinera avec le schéma JSON de votre modèle.
+
+Par exemple, vous pouvez déclarer une réponse avec un code HTTP `404` qui utilise un modèle Pydantic et a une `description` personnalisée.
+
+Et une réponse avec un code HTTP `200` qui utilise votre `response_model`, mais inclut un `example` personnalisé :
+
+```Python hl_lines="20-31"
+{!../../../docs_src/additional_responses/tutorial003.py!}
+```
+
+Tout sera combiné et inclus dans votre OpenAPI, et affiché dans la documentation de l'API :
+
+
+
+## Combinez les réponses prédéfinies et les réponses personnalisées
+
+Vous voulez peut-être avoir des réponses prédéfinies qui s'appliquent à de nombreux *paramètre de chemin*, mais vous souhaitez les combiner avec des réponses personnalisées nécessaires à chaque *opération de chemin*.
+
+Dans ces cas, vous pouvez utiliser la technique Python "d'affection par décomposition" (appelé _unpacking_ en anglais) d'un `dict` avec `**dict_to_unpack` :
+
+``` Python
+old_dict = {
+ "old key": "old value",
+ "second old key": "second old value",
+}
+new_dict = {**old_dict, "new key": "new value"}
+```
+
+Ici, `new_dict` contiendra toutes les paires clé-valeur de `old_dict` plus la nouvelle paire clé-valeur :
+
+``` Python
+{
+ "old key": "old value",
+ "second old key": "second old value",
+ "new key": "new value",
+}
+```
+
+Vous pouvez utiliser cette technique pour réutiliser certaines réponses prédéfinies dans vos *paramètres de chemin* et les combiner avec des réponses personnalisées supplémentaires.
+
+Par exemple:
+
+```Python hl_lines="13-17 26"
+{!../../../docs_src/additional_responses/tutorial004.py!}
+```
+
+## Plus d'informations sur les réponses OpenAPI
+
+Pour voir exactement ce que vous pouvez inclure dans les réponses, vous pouvez consulter ces sections dans la spécification OpenAPI :
+
+*
Objet Responses de OpenAPI , il inclut le `Response Object`.
+*
Objet Response de OpenAPI , vous pouvez inclure n'importe quoi directement dans chaque réponse à l'intérieur de votre paramètre `responses`. Y compris `description`, `headers`, `content` (à l'intérieur de cela, vous déclarez différents types de médias et schémas JSON) et `links`.
diff --git a/docs/fr/docs/advanced/additional-status-codes.md b/docs/fr/docs/advanced/additional-status-codes.md
new file mode 100644
index 0000000000..e7b003707b
--- /dev/null
+++ b/docs/fr/docs/advanced/additional-status-codes.md
@@ -0,0 +1,37 @@
+# Codes HTTP supplémentaires
+
+Par défaut, **FastAPI** renverra les réponses à l'aide d'une structure de données `JSONResponse`, en plaçant la réponse de votre *chemin d'accès* à l'intérieur de cette `JSONResponse`.
+
+Il utilisera le code HTTP par défaut ou celui que vous avez défini dans votre *chemin d'accès*.
+
+## Codes HTTP supplémentaires
+
+Si vous souhaitez renvoyer des codes HTTP supplémentaires en plus du code principal, vous pouvez le faire en renvoyant directement une `Response`, comme une `JSONResponse`, et en définissant directement le code HTTP supplémentaire.
+
+Par exemple, disons que vous voulez avoir un *chemin d'accès* qui permet de mettre à jour les éléments et renvoie les codes HTTP 200 "OK" en cas de succès.
+
+Mais vous voulez aussi qu'il accepte de nouveaux éléments. Et lorsque les éléments n'existaient pas auparavant, il les crée et renvoie un code HTTP de 201 "Créé".
+
+Pour y parvenir, importez `JSONResponse` et renvoyez-y directement votre contenu, en définissant le `status_code` que vous souhaitez :
+
+```Python hl_lines="4 25"
+{!../../../docs_src/additional_status_codes/tutorial001.py!}
+```
+
+!!! Attention
+ Lorsque vous renvoyez une `Response` directement, comme dans l'exemple ci-dessus, elle sera renvoyée directement.
+
+ Elle ne sera pas sérialisée avec un modèle.
+
+ Assurez-vous qu'il contient les données souhaitées et que les valeurs soient dans un format JSON valides (si vous utilisez une `JSONResponse`).
+
+!!! note "Détails techniques"
+ Vous pouvez également utiliser `from starlette.responses import JSONResponse`.
+
+ Pour plus de commodités, **FastAPI** fournit les objets `starlette.responses` sous forme d'un alias accessible par `fastapi.responses`. Mais la plupart des réponses disponibles proviennent directement de Starlette. Il en est de même avec l'objet `statut`.
+
+## Documents OpenAPI et API
+
+Si vous renvoyez directement des codes HTTP et des réponses supplémentaires, ils ne seront pas inclus dans le schéma OpenAPI (la documentation de l'API), car FastAPI n'a aucun moyen de savoir à l'avance ce que vous allez renvoyer.
+
+Mais vous pouvez documenter cela dans votre code, en utilisant : [Réponses supplémentaires dans OpenAPI](additional-responses.md){.internal-link target=_blank}.
diff --git a/docs/fr/docs/index.md b/docs/fr/docs/index.md
index 6952044588..e7fb9947d5 100644
--- a/docs/fr/docs/index.md
+++ b/docs/fr/docs/index.md
@@ -426,7 +426,7 @@ For a more complete example including more features, see the
requests - Required if you want to use the `TestClient`.
+*
HTTPX - Required if you want to use the `TestClient`.
*
jinja2 - Required if you want to use the default template configuration.
*
python-multipart - Required if you want to support form
"parsing", with `request.form()`.
*
itsdangerous - Required for `SessionMiddleware` support.
diff --git a/docs/fr/mkdocs.yml b/docs/fr/mkdocs.yml
index 1c4f45682f..7dce4b1276 100644
--- a/docs/fr/mkdocs.yml
+++ b/docs/fr/mkdocs.yml
@@ -67,6 +67,9 @@ nav:
- tutorial/query-params.md
- tutorial/body.md
- tutorial/background-tasks.md
+- Guide utilisateur avancé:
+ - advanced/additional-status-codes.md
+ - advanced/additional-responses.md
- async.md
- Déploiement:
- deployment/index.md
diff --git a/docs/he/docs/index.md b/docs/he/docs/index.md
index fa63d8cb7c..19f2f20413 100644
--- a/docs/he/docs/index.md
+++ b/docs/he/docs/index.md
@@ -445,7 +445,7 @@ item: Item
בשימוש Starlette:
--
requests - דרוש אם ברצונכם להשתמש ב - `TestClient`.
+-
httpx - דרוש אם ברצונכם להשתמש ב - `TestClient`.
-
jinja2 - דרוש אם ברצונכם להשתמש בברירת המחדל של תצורת הטמפלייטים.
-
python-multipart - דרוש אם ברצונכם לתמוך ב
"פרסור" טפסים, באצמעות
request.form().
-
itsdangerous - דרוש אם ברצונכם להשתמש ב - `SessionMiddleware`.
diff --git a/docs/id/docs/index.md b/docs/id/docs/index.md
index 3129f9dc6d..66fc2859e7 100644
--- a/docs/id/docs/index.md
+++ b/docs/id/docs/index.md
@@ -426,7 +426,7 @@ For a more complete example including more features, see the
requests - Required if you want to use the `TestClient`.
+*
httpx - Required if you want to use the `TestClient`.
*
jinja2 - Required if you want to use the default template configuration.
*
python-multipart - Required if you want to support form
"parsing", with `request.form()`.
*
itsdangerous - Required for `SessionMiddleware` support.
diff --git a/docs/it/docs/index.md b/docs/it/docs/index.md
index 852a5e56e8..9d95dd6d72 100644
--- a/docs/it/docs/index.md
+++ b/docs/it/docs/index.md
@@ -423,7 +423,7 @@ For a more complete example including more features, see the
requests - Required if you want to use the `TestClient`.
+*
httpx - Required if you want to use the `TestClient`.
*
jinja2 - Required if you want to use the default template configuration.
*
python-multipart - Required if you want to support form
"parsing", with `request.form()`.
*
itsdangerous - Required for `SessionMiddleware` support.
diff --git a/docs/ja/docs/advanced/websockets.md b/docs/ja/docs/advanced/websockets.md
new file mode 100644
index 0000000000..65e4112a6b
--- /dev/null
+++ b/docs/ja/docs/advanced/websockets.md
@@ -0,0 +1,186 @@
+# WebSocket
+
+**FastAPI**で
WebSocketが使用できます。
+
+## `WebSockets`のインストール
+
+まず `WebSockets`のインストールが必要です。
+
+
+
+```console
+$ pip install websockets
+
+---> 100%
+```
+
+
+
+## WebSocket クライアント
+
+### 本番環境
+
+本番環境では、React、Vue.js、Angularなどの最新のフレームワークで作成されたフロントエンドを使用しているでしょう。
+
+そして、バックエンドとWebSocketを使用して通信するために、おそらくフロントエンドのユーティリティを使用することになるでしょう。
+
+または、ネイティブコードでWebSocketバックエンドと直接通信するネイティブモバイルアプリケーションがあるかもしれません。
+
+他にも、WebSocketのエンドポイントと通信する方法があるかもしれません。
+
+---
+
+ただし、この例では非常にシンプルなHTML文書といくつかのJavaScriptを、すべてソースコードの中に入れて使用することにします。
+
+もちろん、これは最適な方法ではありませんし、本番環境で使うことはないでしょう。
+
+本番環境では、上記の方法のいずれかの選択肢を採用することになるでしょう。
+
+しかし、これはWebSocketのサーバーサイドに焦点を当て、実用的な例を示す最も簡単な方法です。
+
+```Python hl_lines="2 6-38 41-43"
+{!../../../docs_src/websockets/tutorial001.py!}
+```
+
+## `websocket` を作成する
+
+**FastAPI** アプリケーションで、`websocket` を作成します。
+
+```Python hl_lines="1 46-47"
+{!../../../docs_src/websockets/tutorial001.py!}
+```
+
+!!! note "技術詳細"
+ `from starlette.websockets import WebSocket` を使用しても構いません.
+
+ **FastAPI** は開発者の利便性のために、同じ `WebSocket` を提供します。しかし、こちらはStarletteから直接提供されるものです。
+
+## メッセージの送受信
+
+WebSocketルートでは、 `await` を使ってメッセージの送受信ができます。
+
+```Python hl_lines="48-52"
+{!../../../docs_src/websockets/tutorial001.py!}
+```
+
+バイナリやテキストデータ、JSONデータを送受信できます。
+
+## 試してみる
+
+ファイル名が `main.py` である場合、以下の方法でアプリケーションを実行します。
+
+
+
+```console
+$ uvicorn main:app --reload
+
+INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+```
+
+
+
+ブラウザで
http://127.0.0.1:8000 を開きます。
+
+次のようなシンプルなページが表示されます。
+
+
+
+入力ボックスにメッセージを入力して送信できます。
+
+
+
+そして、 WebSocketを使用した**FastAPI**アプリケーションが応答します。
+
+
+
+複数のメッセージを送信（および受信）できます。
+
+
+
+そして、これらの通信はすべて同じWebSocket接続を使用します。
+
+## 依存関係
+
+WebSocketエンドポイントでは、`fastapi` から以下をインポートして使用できます。
+
+* `Depends`
+* `Security`
+* `Cookie`
+* `Header`
+* `Path`
+* `Query`
+
+これらは、他のFastAPI エンドポイント/*path operation* の場合と同じように機能します。
+
+```Python hl_lines="58-65 68-83"
+{!../../../docs_src/websockets/tutorial002.py!}
+```
+
+!!! info "情報"
+ WebSocket で `HTTPException` を発生させることはあまり意味がありません。したがって、WebSocketの接続を直接閉じる方がよいでしょう。
+
+ クロージングコードは、
仕様で定義された有効なコードの中から使用することができます。
+
+ 将来的には、どこからでも `raise` できる `WebSocketException` が用意され、専用の例外ハンドラを追加できるようになる予定です。これは、Starlette の
PR #527 に依存するものです。
+
+### 依存関係を用いてWebSocketsを試してみる
+
+ファイル名が `main.py` である場合、以下の方法でアプリケーションを実行します。
+
+
+
+```console
+$ uvicorn main:app --reload
+
+INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+```
+
+
+
+ブラウザで
http://127.0.0.1:8000 を開きます。
+
+クライアントが設定できる項目は以下の通りです。
+
+* パスで使用される「Item ID」
+* クエリパラメータとして使用される「Token」
+
+!!! tip "豆知識"
+ クエリ `token` は依存パッケージによって処理されることに注意してください。
+
+これにより、WebSocketに接続してメッセージを送受信できます。
+
+
+
+## 切断や複数クライアントへの対応
+
+WebSocket接続が閉じられると、 `await websocket.receive_text()` は例外 `WebSocketDisconnect` を発生させ、この例のようにキャッチして処理することができます。
+
+```Python hl_lines="81-83"
+{!../../../docs_src/websockets/tutorial003.py!}
+```
+
+試してみるには、
+
+* いくつかのブラウザタブでアプリを開きます。
+* それらのタブでメッセージを記入してください。
+* そして、タブのうち1つを閉じてください。
+
+これにより例外 `WebSocketDisconnect` が発生し、他のすべてのクライアントは次のようなメッセージを受信します。
+
+```
+Client #1596980209979 left the chat
+```
+
+!!! tip "豆知識"
+ 上記のアプリは、複数の WebSocket 接続に対してメッセージを処理し、ブロードキャストする方法を示すための最小限のシンプルな例です。
+
+ しかし、すべての接続がメモリ内の単一のリストで処理されるため、プロセスの実行中にのみ機能し、単一のプロセスでのみ機能することに注意してください。
+
+ もしFastAPIと簡単に統合できて、RedisやPostgreSQLなどでサポートされている、より堅牢なものが必要なら、
encode/broadcaster を確認してください。
+
+## その他のドキュメント
+
+オプションの詳細については、Starletteのドキュメントを確認してください。
+
+*
`WebSocket` クラス
+*
クラスベースのWebSocket処理
diff --git a/docs/ja/docs/features.md b/docs/ja/docs/features.md
index 5ea68515da..a40b48cf0e 100644
--- a/docs/ja/docs/features.md
+++ b/docs/ja/docs/features.md
@@ -169,7 +169,7 @@ FastAPIには非常に使いやすく、非常に強力な
requests - 使用 `TestClient` 时安装。
+* httpx - 使用 `TestClient` 时安装。
* jinja2 - 使用默认模板配置时安装。
* python-multipart - 需要通过 `request.form()` 对表单进行「解析」时安装。
* itsdangerous - 需要 `SessionMiddleware` 支持时安装。
diff --git a/docs/zh/docs/python-types.md b/docs/zh/docs/python-types.md
index 67a1612f00..6cdb4b5883 100644
--- a/docs/zh/docs/python-types.md
+++ b/docs/zh/docs/python-types.md
@@ -194,7 +194,7 @@ John Doe
这表示：
-* 变量 `items_t` 是一个 `tuple`，其中的每个元素都是 `int` 类型。
+* 变量 `items_t` 是一个 `tuple`，其中的前两个元素都是 `int` 类型, 最后一个元素是 `str` 类型。
* 变量 `items_s` 是一个 `set`，其中的每个元素都是 `bytes` 类型。
#### 字典
diff --git a/docs/zh/docs/tutorial/security/oauth2-jwt.md b/docs/zh/docs/tutorial/security/oauth2-jwt.md
index 82ef9b897e..054198545e 100644
--- a/docs/zh/docs/tutorial/security/oauth2-jwt.md
+++ b/docs/zh/docs/tutorial/security/oauth2-jwt.md
@@ -1,34 +1,34 @@
-# 使用（哈希）密码和 JWT Bearer 令牌的 OAuth2
+# OAuth2 实现密码哈希与 Bearer JWT 令牌验证
-既然我们已经有了所有的安全流程，就让我们来使用 JWT 令牌和安全哈希密码让应用程序真正地安全吧。
+至此，我们已经编写了所有安全流，本章学习如何使用 JWT 令牌（Token）和安全密码哈希（Hash）实现真正的安全机制。
-你可以在应用程序中真正地使用这些代码，在数据库中保存密码哈希值，等等。
+本章的示例代码真正实现了在应用的数据库中保存哈希密码等功能。
-我们将从上一章结束的位置开始，然后对示例进行扩充。
+接下来，我们紧接上一章，继续完善安全机制。
-## 关于 JWT
+## JWT 简介
-JWT 表示 「JSON Web Tokens」。
+JWT 即**JSON 网络令牌**（JSON Web Tokens）。
-它是一个将 JSON 对象编码为密集且没有空格的长字符串的标准。字符串看起来像这样：
+JWT 是一种将 JSON 对象编码为没有空格，且难以理解的长字符串的标准。JWT 的内容如下所示：
```
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c
```
-它没有被加密，因此任何人都可以从字符串内容中还原数据。
+JWT 字符串没有加密，任何人都能用它恢复原始信息。
-但它经过了签名。因此，当你收到一个由你发出的令牌时，可以校验令牌是否真的由你发出。
+但 JWT 使用了签名机制。接受令牌时，可以用签名校验令牌。
-通过这种方式，你可以创建一个有效期为 1 周的令牌。然后当用户第二天使用令牌重新访问时，你知道该用户仍然处于登入状态。
+使用 JWT 创建有效期为一周的令牌。第二天，用户持令牌再次访问时，仍为登录状态。
-一周后令牌将会过期，用户将不会通过认证，必须再次登录才能获得一个新令牌。而且如果用户（或第三方）试图修改令牌以篡改过期时间，你将因为签名不匹配而能够发觉。
+令牌于一周后过期，届时，用户身份验证就会失败。只有再次登录，才能获得新的令牌。如果用户（或第三方）篡改令牌的过期时间，因为签名不匹配会导致身份验证失败。
-如果你想上手体验 JWT 令牌并了解其工作方式，可访问 https://jwt.io。
+如需深入了解 JWT 令牌，了解它的工作方式，请参阅 https://jwt.io。
## 安装 `python-jose`
-我们需要安装 `python-jose` 以在 Python 中生成和校验 JWT 令牌：
+安装 `python-jose`，在 Python 中生成和校验 JWT 令牌：
@@ -40,38 +40,39 @@ $ pip install python-jose[cryptography]
-Python-jose 需要一个额外的加密后端。
+Python-jose 需要安装配套的加密后端。
-这里我们使用的是推荐的后端：pyca/cryptography。
+本教程推荐的后端是：pyca/cryptography。
-!!! tip
- 本教程曾经使用过 PyJWT。
+!!! tip "提示"
- 但是后来更新为使用 Python-jose，因为它提供了 PyJWT 的所有功能，以及之后与其他工具进行集成时你可能需要的一些其他功能。
+ 本教程以前使用 PyJWT。
-## 哈希密码
+ 但后来换成了 Python-jose，因为 Python-jose 支持 PyJWT 的所有功能，还支持与其它工具集成时可能会用到的一些其它功能。
-「哈希」的意思是：将某些内容（在本例中为密码）转换为看起来像乱码的字节序列（只是一个字符串）。
+## 密码哈希
-每次你传入完全相同的内容（完全相同的密码）时，你都会得到完全相同的乱码。
+**哈希**是指把特定内容（本例中为密码）转换为乱码形式的字节序列（其实就是字符串）。
-但是你不能从乱码转换回密码。
+每次传入完全相同的内容时（比如，完全相同的密码），返回的都是完全相同的乱码。
-### 为什么使用哈希密码
+但这个乱码无法转换回传入的密码。
-如果你的数据库被盗，小偷将无法获得用户的明文密码，只能拿到哈希值。
+### 为什么使用密码哈希
-因此，小偷将无法尝试在另一个系统中使用这些相同的密码（由于许多用户在任何地方都使用相同的密码，因此这很危险）。
+原因很简单，假如数据库被盗，窃贼无法获取用户的明文密码，得到的只是哈希值。
+
+这样一来，窃贼就无法在其它应用中使用窃取的密码，要知道，很多用户在所有系统中都使用相同的密码，风险超大）。
## 安装 `passlib`
-PassLib 是一个用于处理哈希密码的很棒的 Python 包。
+Passlib 是处理密码哈希的 Python 包。
-它支持许多安全哈希算法以及配合算法使用的实用程序。
+它支持很多安全哈希算法及配套工具。
-推荐的算法是 「Bcrypt」。
+本教程推荐的算法是 **Bcrypt**。
-因此，安装附带 Bcrypt 的 PassLib：
+因此，请先安装附带 Bcrypt 的 PassLib：
@@ -83,46 +84,49 @@ $ pip install passlib[bcrypt]
-!!! tip
- 使用 `passlib`，你甚至可以将其配置为能够读取 Django，Flask 的安全扩展或许多其他工具创建的密码。
+!!! tip "提示"
- 因此，你将能够，举个例子，将数据库中来自 Django 应用的数据共享给一个 FastAPI 应用。或者使用同一数据库但逐渐将应用从 Django 迁移到 FastAPI。
+ `passlib` 甚至可以读取 Django、Flask 的安全插件等工具创建的密码。
- 而你的用户将能够同时从 Django 应用或 FastAPI 应用登录。
+ 例如，把 Django 应用的数据共享给 FastAPI 应用的数据库。或利用同一个数据库，可以逐步把应用从 Django 迁移到 FastAPI。
-## 哈希并校验密码
+ 并且，用户可以同时从 Django 应用或 FastAPI 应用登录。
-从 `passlib` 导入我们需要的工具。
+## 密码哈希与校验
-创建一个 PassLib 「上下文」。这将用于哈希和校验密码。
+从 `passlib` 导入所需工具。
-!!! tip
- PassLib 上下文还具有使用不同哈希算法的功能，包括仅允许用于校验的已弃用的旧算法等。
+创建用于密码哈希和身份校验的 PassLib **上下文**。
- 例如，你可以使用它来读取和校验由另一个系统（例如Django）生成的密码，但是使用其他算法例如 Bcrypt 生成新的密码哈希值。
+!!! tip "提示"
- 并同时兼容所有的这些功能。
+ PassLib 上下文还支持使用不同哈希算法的功能，包括只能校验的已弃用旧算法等。
-创建一个工具函数以哈希来自用户的密码。
+ 例如，用它读取和校验其它系统（如 Django）生成的密码，但要使用其它算法，如 Bcrypt，生成新的哈希密码。
-然后创建另一个工具函数，用于校验接收的密码是否与存储的哈希值匹配。
+ 同时，这些功能都是兼容的。
-再创建另一个工具函数用于认证并返回用户。
+接下来，创建三个工具函数，其中一个函数用于哈希用户的密码。
+
+第一个函数用于校验接收的密码是否匹配存储的哈希值。
+
+第三个函数用于身份验证，并返回用户。
```Python hl_lines="7 48 55-56 59-60 69-75"
{!../../../docs_src/security/tutorial004.py!}
```
-!!! note
- 如果你查看新的（伪）数据库 `fake_users_db`，你将看到哈希后的密码现在的样子：`"$2b$12$EixZaYVK1fsbw1ZfbX3OXePaWxn96p36WQoeG6Lruj3vjPGga31lW"`。
+!!! note "笔记"
+
+ 查看新的（伪）数据库 `fake_users_db`，就能看到哈希后的密码：`"$2b$12$EixZaYVK1fsbw1ZfbX3OXePaWxn96p36WQoeG6Lruj3vjPGga31lW"`。
## 处理 JWT 令牌
导入已安装的模块。
-创建一个随机密钥，该密钥将用于对 JWT 令牌进行签名。
+创建用于 JWT 令牌签名的随机密钥。
-要生成一个安全的随机密钥，可使用以下命令：
+使用以下命令，生成安全的随机密钥：
@@ -134,15 +138,15 @@ $ openssl rand -hex 32
-然后将输出复制到变量 「SECRET_KEY」 中（不要使用示例中的这个）。
+然后，把生成的密钥复制到变量**SECRET_KEY**，注意，不要使用本例所示的密钥。
-创建用于设定 JWT 令牌签名算法的变量 「ALGORITHM」，并将其设置为 `"HS256"`。
+创建指定 JWT 令牌签名算法的变量 **ALGORITHM**，本例中的值为 `"HS256"`。
-创建一个设置令牌过期时间的变量。
+创建设置令牌过期时间的变量。
-定义一个将在令牌端点中用于响应的 Pydantic 模型。
+定义令牌端点响应的 Pydantic 模型。
-创建一个生成新的访问令牌的工具函数。
+创建生成新的访问令牌的工具函数。
```Python hl_lines="6 12-14 28-30 78-86"
{!../../../docs_src/security/tutorial004.py!}
@@ -150,11 +154,11 @@ $ openssl rand -hex 32
## 更新依赖项
-更新 `get_current_user` 以接收与之前相同的令牌，但这次使用的是 JWT 令牌。
+更新 `get_current_user` 以接收与之前相同的令牌，但这里用的是 JWT 令牌。
-解码接收到的令牌，对其进行校验，然后返回当前用户。
+解码并校验接收到的令牌，然后，返回当前用户。
-如果令牌无效，立即返回一个 HTTP 错误。
+如果令牌无效，则直接返回 HTTP 错误。
```Python hl_lines="89-106"
{!../../../docs_src/security/tutorial004.py!}
@@ -162,57 +166,57 @@ $ openssl rand -hex 32
## 更新 `/token` *路径操作*
-使用令牌的过期时间创建一个 `timedelta` 对象。
+用令牌过期时间创建 `timedelta` 对象。
-创建一个真实的 JWT 访问令牌并返回它。
+创建并返回真正的 JWT 访问令牌。
```Python hl_lines="115-128"
{!../../../docs_src/security/tutorial004.py!}
```
-### 关于 JWT 「主题」 `sub` 的技术细节
+### JWT `sub` 的技术细节
-JWT 的规范中提到有一个 `sub` 键，值为该令牌的主题。
+JWT 规范还包括 `sub` 键，值是令牌的主题。
-使用它并不是必须的，但这是你放置用户标识的地方，所以我们在示例中使用了它。
+该键是可选的，但要把用户标识放在这个键里，所以本例使用了该键。
-除了识别用户并允许他们直接在你的 API 上执行操作之外，JWT 还可以用于其他事情。
+除了识别用户与许可用户在 API 上直接执行操作之外，JWT 还可能用于其它事情。
-例如，你可以识别一个 「汽车」 或 「博客文章」。
+例如，识别**汽车**或**博客**。
-然后你可以添加关于该实体的权限，比如「驾驶」（汽车）或「编辑」（博客）。
+接着，为实体添加权限，比如**驾驶**（汽车）或**编辑**（博客）。
-然后，你可以将 JWT 令牌交给用户（或机器人），他们可以使用它来执行这些操作（驾驶汽车，或编辑博客文章），甚至不需要有一个账户，只需使用你的 API 为其生成的 JWT 令牌。
+然后，把 JWT 令牌交给用户（或机器人），他们就可以执行驾驶汽车，或编辑博客等操作。无需注册账户，只要有 API 生成的 JWT 令牌就可以。
-使用这样的思路，JWT 可以用于更复杂的场景。
+同理，JWT 可以用于更复杂的场景。
-在这些情况下，几个实体可能有相同的 ID，比如说 `foo`（一个用户 `foo`，一辆车 `foo`，一篇博客文章 `foo`）。
+在这些情况下，多个实体的 ID 可能是相同的，以 ID `foo` 为例，用户的 ID 是 `foo`，车的 ID 是 `foo`，博客的 ID 也是 `foo`。
-因此，为了避免 ID 冲突，当为用户创建 JWT 令牌时，你可以在 `sub` 键的值前加上前缀，例如 `username:`。所以，在这个例子中，`sub` 的值可以是：`username:johndoe`。
+为了避免 ID 冲突，在给用户创建 JWT 令牌时，可以为 `sub` 键的值加上前缀，例如 `username:`。因此，在本例中，`sub` 的值可以是：`username:johndoe`。
-要记住的重点是，`sub` 键在整个应用程序中应该有一个唯一的标识符，而且应该是一个字符串。
+注意，划重点，`sub` 键在整个应用中应该只有一个唯一的标识符，而且应该是字符串。
-## 检查效果
+## 检查
运行服务器并访问文档： http://127.0.0.1:8000/docs。
-你会看到如下用户界面：
+可以看到如下用户界面：
-像以前一样对应用程序进行认证。
+用与上一章同样的方式实现应用授权。
使用如下凭证：
-用户名: `johndoe`
-密码: `secret`
+用户名: `johndoe` 密码: `secret`
-!!! check
- 请注意，代码中没有任何地方记录了明文密码 「`secret`」，我们只保存了其哈希值。
+!!! check "检查"
+
+ 注意，代码中没有明文密码**`secret`**，只保存了它的哈希值。
-访问 `/users/me/` 端点，你将获得如下响应：
+调用 `/users/me/` 端点，收到下面的响应：
```JSON
{
@@ -225,41 +229,42 @@ JWT 的规范中提到有一个 `sub` 键，值为该令牌的主题。
-如果你打开开发者工具，将看到数据是如何发送的并且其中仅包含了令牌，只有在第一个请求中发送了密码以校验用户身份并获取该访问令牌，但之后都不会再发送密码：
+打开浏览器的开发者工具，查看数据是怎么发送的，而且数据里只包含了令牌，只有验证用户的第一个请求才发送密码，并获取访问令牌，但之后不会再发送密码：
-!!! note
- 注意请求中的 `Authorization` 首部，其值以 `Bearer` 开头。
+!!! note "笔记"
-## 使用 `scopes` 的进阶用法
+ 注意，请求中 `Authorization` 响应头的值以 `Bearer` 开头。
-OAuth2 具有「作用域」的概念。
+## `scopes` 高级用法
-你可以使用它们向 JWT 令牌添加一组特定的权限。
+OAuth2 支持**`scopes`**（作用域）。
-然后，你可以将此令牌直接提供给用户或第三方，使其在一些限制下与你的 API 进行交互。
+**`scopes`**为 JWT 令牌添加指定权限。
-你可以在之后的**进阶用户指南**中了解如何使用它们以及如何将它们集成到 **FastAPI** 中。
+让持有令牌的用户或第三方在指定限制条件下与 API 交互。
-## 总结
+**高级用户指南**中将介绍如何使用 `scopes`，及如何把 `scopes` 集成至 **FastAPI**。
-通过目前你所看到的，你可以使用像 OAuth2 和 JWT 这样的标准来构建一个安全的 **FastAPI** 应用程序。
+## 小结
-在几乎所有的框架中，处理安全性问题都很容易成为一个相当复杂的话题。
+至此，您可以使用 OAuth2 和 JWT 等标准配置安全的 **FastAPI** 应用。
-许多高度简化了安全流程的软件包不得不在数据模型、数据库和可用功能上做出很多妥协。而这些过于简化流程的软件包中，有些其实隐含了安全漏洞。
+几乎在所有框架中，处理安全问题很快都会变得非常复杂。
+
+有些包为了简化安全流，不得不在数据模型、数据库和功能上做出妥协。而有些过于简化的软件包其实存在了安全隐患。
---
-**FastAPI** 不对任何数据库、数据模型或工具做任何妥协。
+**FastAPI** 不向任何数据库、数据模型或工具做妥协。
-它给了你所有的灵活性来选择最适合你项目的前者。
+开发者可以灵活选择最适合项目的安全机制。
-你可以直接使用许多维护良好且使用广泛的包，如 `passlib` 和 `python-jose`，因为 **FastAPI** 不需要任何复杂的机制来集成外部包。
+还可以直接使用 `passlib` 和 `python-jose` 等维护良好、使用广泛的包，这是因为 **FastAPI** 不需要任何复杂机制，就能集成外部的包。
-但它为你提供了一些工具，在不影响灵活性、健壮性和安全性的前提下，尽可能地简化这个过程。
+而且，**FastAPI** 还提供了一些工具，在不影响灵活、稳定和安全的前提下，尽可能地简化安全机制。
-而且你可以用相对简单的方式使用和实现安全、标准的协议，比如 OAuth2。
+**FastAPI** 还支持以相对简单的方式，使用 OAuth2 等安全、标准的协议。
-你可以在**进阶用户指南**中了解更多关于如何使用 OAuth2 「作用域」的信息，以实现更精细的权限系统，并同样遵循这些标准。带有作用域的 OAuth2 是很多大的认证提供商使用的机制，比如 Facebook、Google、GitHub、微软、Twitter 等，授权第三方应用代表用户与他们的 API 进行交互。
+**高级用户指南**中详细介绍了 OAuth2**`scopes`**的内容，遵循同样的标准，实现更精密的权限系统。OAuth2 的作用域是脸书、谷歌、GitHub、微软、推特等第三方身份验证应用使用的机制，让用户授权第三方应用与 API 交互。
diff --git a/docs_src/security/tutorial005.py b/docs_src/security/tutorial005.py
index ab3af9a6a9..bd0a33581c 100644
--- a/docs_src/security/tutorial005.py
+++ b/docs_src/security/tutorial005.py
@@ -107,7 +107,7 @@ async def get_current_user(
if security_scopes.scopes:
authenticate_value = f'Bearer scope="{security_scopes.scope_str}"'
else:
- authenticate_value = f"Bearer"
+ authenticate_value = "Bearer"
credentials_exception = HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Could not validate credentials",
diff --git a/docs_src/security/tutorial005_py310.py b/docs_src/security/tutorial005_py310.py
index c6a095d2cc..ba756ef4f4 100644
--- a/docs_src/security/tutorial005_py310.py
+++ b/docs_src/security/tutorial005_py310.py
@@ -106,7 +106,7 @@ async def get_current_user(
if security_scopes.scopes:
authenticate_value = f'Bearer scope="{security_scopes.scope_str}"'
else:
- authenticate_value = f"Bearer"
+ authenticate_value = "Bearer"
credentials_exception = HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Could not validate credentials",
diff --git a/docs_src/security/tutorial005_py39.py b/docs_src/security/tutorial005_py39.py
index 38391308af..9e4dbcffba 100644
--- a/docs_src/security/tutorial005_py39.py
+++ b/docs_src/security/tutorial005_py39.py
@@ -107,7 +107,7 @@ async def get_current_user(
if security_scopes.scopes:
authenticate_value = f'Bearer scope="{security_scopes.scope_str}"'
else:
- authenticate_value = f"Bearer"
+ authenticate_value = "Bearer"
credentials_exception = HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Could not validate credentials",
diff --git a/docs_src/websockets/tutorial002.py b/docs_src/websockets/tutorial002.py
index cf5c7e805a..cab749e4db 100644
--- a/docs_src/websockets/tutorial002.py
+++ b/docs_src/websockets/tutorial002.py
@@ -1,6 +1,14 @@
from typing import Union
-from fastapi import Cookie, Depends, FastAPI, Query, WebSocket, status
+from fastapi import (
+ Cookie,
+ Depends,
+ FastAPI,
+ Query,
+ WebSocket,
+ WebSocketException,
+ status,
+)
from fastapi.responses import HTMLResponse
app = FastAPI()
@@ -61,7 +69,7 @@ async def get_cookie_or_token(
token: Union[str, None] = Query(default=None),
):
if session is None and token is None:
- await websocket.close(code=status.WS_1008_POLICY_VIOLATION)
+ raise WebSocketException(code=status.WS_1008_POLICY_VIOLATION)
return session or token
diff --git a/fastapi/__init__.py b/fastapi/__init__.py
index cb1b063aae..037d9804b5 100644
--- a/fastapi/__init__.py
+++ b/fastapi/__init__.py
@@ -1,6 +1,6 @@
"""FastAPI framework, high performance, easy to learn, fast to code, ready for production"""
-__version__ = "0.85.2"
+__version__ = "0.88.0"
from starlette import status as status
@@ -8,6 +8,7 @@ from .applications import FastAPI as FastAPI
from .background import BackgroundTasks as BackgroundTasks
from .datastructures import UploadFile as UploadFile
from .exceptions import HTTPException as HTTPException
+from .exceptions import WebSocketException as WebSocketException
from .param_functions import Body as Body
from .param_functions import Cookie as Cookie
from .param_functions import Depends as Depends
diff --git a/fastapi/dependencies/utils.py b/fastapi/dependencies/utils.py
index 64a6c12765..4c817d5d0b 100644
--- a/fastapi/dependencies/utils.py
+++ b/fastapi/dependencies/utils.py
@@ -105,10 +105,10 @@ def check_file_field(field: ModelField) -> None:
assert parse_options_header
except ImportError:
logger.error(multipart_incorrect_install_error)
- raise RuntimeError(multipart_incorrect_install_error)
+ raise RuntimeError(multipart_incorrect_install_error) from None
except ImportError:
logger.error(multipart_not_installed_error)
- raise RuntimeError(multipart_not_installed_error)
+ raise RuntimeError(multipart_not_installed_error) from None
def get_param_sub_dependant(
@@ -426,21 +426,21 @@ def is_coroutine_callable(call: Callable[..., Any]) -> bool:
return inspect.iscoroutinefunction(call)
if inspect.isclass(call):
return False
- dunder_call = getattr(call, "__call__", None)
+ dunder_call = getattr(call, "__call__", None) # noqa: B004
return inspect.iscoroutinefunction(dunder_call)
def is_async_gen_callable(call: Callable[..., Any]) -> bool:
if inspect.isasyncgenfunction(call):
return True
- dunder_call = getattr(call, "__call__", None)
+ dunder_call = getattr(call, "__call__", None) # noqa: B004
return inspect.isasyncgenfunction(dunder_call)
def is_gen_callable(call: Callable[..., Any]) -> bool:
if inspect.isgeneratorfunction(call):
return True
- dunder_call = getattr(call, "__call__", None)
+ dunder_call = getattr(call, "__call__", None) # noqa: B004
return inspect.isgeneratorfunction(dunder_call)
@@ -724,14 +724,14 @@ def get_body_field(*, dependant: Dependant, name: str) -> Optional[ModelField]:
# in case a sub-dependency is evaluated with a single unique body field
# That is combined (embedded) with other body fields
for param in flat_dependant.body_params:
- setattr(param.field_info, "embed", True)
+ setattr(param.field_info, "embed", True) # noqa: B010
model_name = "Body_" + name
BodyModel: Type[BaseModel] = create_model(model_name)
for f in flat_dependant.body_params:
BodyModel.__fields__[f.name] = f
required = any(True for f in flat_dependant.body_params if f.required)
- BodyFieldInfo_kwargs: Dict[str, Any] = dict(default=None)
+ BodyFieldInfo_kwargs: Dict[str, Any] = {"default": None}
if any(isinstance(f.field_info, params.File) for f in flat_dependant.body_params):
BodyFieldInfo: Type[params.Body] = params.File
elif any(isinstance(f.field_info, params.Form) for f in flat_dependant.body_params):
@@ -740,7 +740,7 @@ def get_body_field(*, dependant: Dependant, name: str) -> Optional[ModelField]:
BodyFieldInfo = params.Body
body_param_media_types = [
- getattr(f.field_info, "media_type")
+ f.field_info.media_type
for f in flat_dependant.body_params
if isinstance(f.field_info, params.Body)
]
diff --git a/fastapi/encoders.py b/fastapi/encoders.py
index 6bde9f4abf..2f95bcbf66 100644
--- a/fastapi/encoders.py
+++ b/fastapi/encoders.py
@@ -157,7 +157,7 @@ def jsonable_encoder(
data = vars(obj)
except Exception as e:
errors.append(e)
- raise ValueError(errors)
+ raise ValueError(errors) from e
return jsonable_encoder(
data,
include=include,
diff --git a/fastapi/exceptions.py b/fastapi/exceptions.py
index 0f50acc6c5..ca097b1cef 100644
--- a/fastapi/exceptions.py
+++ b/fastapi/exceptions.py
@@ -3,6 +3,7 @@ from typing import Any, Dict, Optional, Sequence, Type
from pydantic import BaseModel, ValidationError, create_model
from pydantic.error_wrappers import ErrorList
from starlette.exceptions import HTTPException as StarletteHTTPException
+from starlette.exceptions import WebSocketException as WebSocketException # noqa: F401
class HTTPException(StarletteHTTPException):
diff --git a/fastapi/routing.py b/fastapi/routing.py
index 7caf018b55..9a7d88efc8 100644
--- a/fastapi/routing.py
+++ b/fastapi/routing.py
@@ -3,6 +3,7 @@ import dataclasses
import email.message
import inspect
import json
+from contextlib import AsyncExitStack
from enum import Enum, IntEnum
from typing import (
Any,
@@ -190,6 +191,9 @@ def get_request_handler(
if body_field:
if is_body_form:
body = await request.form()
+ stack = request.scope.get("fastapi_astack")
+ assert isinstance(stack, AsyncExitStack)
+ stack.push_async_callback(body.close)
else:
body_bytes = await request.body()
if body_bytes:
@@ -697,7 +701,7 @@ class APIRouter(routing.Router):
), "A path prefix must not end with '/', as the routes will start with '/'"
else:
for r in router.routes:
- path = getattr(r, "path")
+ path = getattr(r, "path") # noqa: B009
name = getattr(r, "name", "unknown")
if path is not None and not path:
raise Exception(
diff --git a/fastapi/security/api_key.py b/fastapi/security/api_key.py
index bca5c721a6..24ddbf4825 100644
--- a/fastapi/security/api_key.py
+++ b/fastapi/security/api_key.py
@@ -54,7 +54,7 @@ class APIKeyHeader(APIKeyBase):
self.auto_error = auto_error
async def __call__(self, request: Request) -> Optional[str]:
- api_key: str = request.headers.get(self.model.name)
+ api_key = request.headers.get(self.model.name)
if not api_key:
if self.auto_error:
raise HTTPException(
diff --git a/fastapi/security/http.py b/fastapi/security/http.py
index 1b473c69e7..8b677299dd 100644
--- a/fastapi/security/http.py
+++ b/fastapi/security/http.py
@@ -38,7 +38,7 @@ class HTTPBase(SecurityBase):
async def __call__(
self, request: Request
) -> Optional[HTTPAuthorizationCredentials]:
- authorization: str = request.headers.get("Authorization")
+ authorization = request.headers.get("Authorization")
scheme, credentials = get_authorization_scheme_param(authorization)
if not (authorization and scheme and credentials):
if self.auto_error:
@@ -67,7 +67,7 @@ class HTTPBasic(HTTPBase):
async def __call__( # type: ignore
self, request: Request
) -> Optional[HTTPBasicCredentials]:
- authorization: str = request.headers.get("Authorization")
+ authorization = request.headers.get("Authorization")
scheme, param = get_authorization_scheme_param(authorization)
if self.realm:
unauthorized_headers = {"WWW-Authenticate": f'Basic realm="{self.realm}"'}
@@ -113,7 +113,7 @@ class HTTPBearer(HTTPBase):
async def __call__(
self, request: Request
) -> Optional[HTTPAuthorizationCredentials]:
- authorization: str = request.headers.get("Authorization")
+ authorization = request.headers.get("Authorization")
scheme, credentials = get_authorization_scheme_param(authorization)
if not (authorization and scheme and credentials):
if self.auto_error:
@@ -148,7 +148,7 @@ class HTTPDigest(HTTPBase):
async def __call__(
self, request: Request
) -> Optional[HTTPAuthorizationCredentials]:
- authorization: str = request.headers.get("Authorization")
+ authorization = request.headers.get("Authorization")
scheme, credentials = get_authorization_scheme_param(authorization)
if not (authorization and scheme and credentials):
if self.auto_error:
diff --git a/fastapi/security/oauth2.py b/fastapi/security/oauth2.py
index 653c3010e5..eb6b4277cf 100644
--- a/fastapi/security/oauth2.py
+++ b/fastapi/security/oauth2.py
@@ -126,7 +126,7 @@ class OAuth2(SecurityBase):
self.auto_error = auto_error
async def __call__(self, request: Request) -> Optional[str]:
- authorization: str = request.headers.get("Authorization")
+ authorization = request.headers.get("Authorization")
if not authorization:
if self.auto_error:
raise HTTPException(
@@ -157,7 +157,7 @@ class OAuth2PasswordBearer(OAuth2):
)
async def __call__(self, request: Request) -> Optional[str]:
- authorization: str = request.headers.get("Authorization")
+ authorization = request.headers.get("Authorization")
scheme, param = get_authorization_scheme_param(authorization)
if not authorization or scheme.lower() != "bearer":
if self.auto_error:
@@ -200,7 +200,7 @@ class OAuth2AuthorizationCodeBearer(OAuth2):
)
async def __call__(self, request: Request) -> Optional[str]:
- authorization: str = request.headers.get("Authorization")
+ authorization = request.headers.get("Authorization")
scheme, param = get_authorization_scheme_param(authorization)
if not authorization or scheme.lower() != "bearer":
if self.auto_error:
diff --git a/fastapi/security/open_id_connect_url.py b/fastapi/security/open_id_connect_url.py
index dfe9f7b255..393614f7cb 100644
--- a/fastapi/security/open_id_connect_url.py
+++ b/fastapi/security/open_id_connect_url.py
@@ -23,7 +23,7 @@ class OpenIdConnect(SecurityBase):
self.auto_error = auto_error
async def __call__(self, request: Request) -> Optional[str]:
- authorization: str = request.headers.get("Authorization")
+ authorization = request.headers.get("Authorization")
if not authorization:
if self.auto_error:
raise HTTPException(
diff --git a/fastapi/security/utils.py b/fastapi/security/utils.py
index 2da0dd20f3..fa7a450b74 100644
--- a/fastapi/security/utils.py
+++ b/fastapi/security/utils.py
@@ -1,7 +1,9 @@
-from typing import Tuple
+from typing import Optional, Tuple
-def get_authorization_scheme_param(authorization_header_value: str) -> Tuple[str, str]:
+def get_authorization_scheme_param(
+ authorization_header_value: Optional[str],
+) -> Tuple[str, str]:
if not authorization_header_value:
return "", ""
scheme, _, param = authorization_header_value.partition(" ")
diff --git a/fastapi/utils.py b/fastapi/utils.py
index b94dacecc5..b15f6a2cfb 100644
--- a/fastapi/utils.py
+++ b/fastapi/utils.py
@@ -89,7 +89,7 @@ def create_response_field(
except RuntimeError:
raise fastapi.exceptions.FastAPIError(
f"Invalid args for response field! Hint: check that {type_} is a valid pydantic field type"
- )
+ ) from None
def create_cloned_field(
diff --git a/pyproject.toml b/pyproject.toml
index 543ba15c1d..be3080ae83 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -34,11 +34,12 @@ classifiers = [
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
+ "Programming Language :: Python :: 3.11",
"Topic :: Internet :: WWW/HTTP :: HTTP Servers",
"Topic :: Internet :: WWW/HTTP",
]
dependencies = [
- "starlette==0.20.4",
+ "starlette==0.22.0",
"pydantic >=1.6.2,!=1.7,!=1.7.1,!=1.7.2,!=1.7.3,!=1.8,!=1.8.1,<2.0.0",
]
dynamic = ["version"]
@@ -50,12 +51,11 @@ Documentation = "https://fastapi.tiangolo.com/"
[project.optional-dependencies]
test = [
"pytest >=7.1.3,<8.0.0",
- "pytest-cov >=2.12.0,<5.0.0",
+ "coverage[toml] >= 6.5.0,<7.0",
"mypy ==0.982",
- "flake8 >=3.8.3,<6.0.0",
- "black == 22.8.0",
+ "ruff ==0.0.138",
+ "black == 22.10.0",
"isort >=5.0.6,<6.0.0",
- "requests >=2.24.0,<3.0.0",
"httpx >=0.23.0,<0.24.0",
"email_validator >=1.1.1,<2.0.0",
# TODO: once removing databases from tutorial, upgrade SQLAlchemy
@@ -83,25 +83,24 @@ doc = [
"mkdocs-markdownextradata-plugin >=0.1.7,<0.3.0",
# TODO: upgrade and enable typer-cli once it supports Click 8.x.x
# "typer-cli >=0.0.12,<0.0.13",
- "typer[all] >=0.6.1,<0.7.0",
+ "typer[all] >=0.6.1,<0.8.0",
"pyyaml >=5.3.1,<7.0.0",
]
dev = [
- "autoflake >=1.4.0,<2.0.0",
- "flake8 >=3.8.3,<6.0.0",
+ "ruff ==0.0.138",
"uvicorn[standard] >=0.12.0,<0.19.0",
"pre-commit >=2.17.0,<3.0.0",
]
all = [
- "requests >=2.24.0,<3.0.0",
- "jinja2 >=2.11.2,<4.0.0",
- "python-multipart >=0.0.5,<0.0.6",
- "itsdangerous >=1.1.0,<3.0.0",
- "pyyaml >=5.3.1,<7.0.0",
- "ujson >=4.0.1,!=4.0.2,!=4.1.0,!=4.2.0,!=4.3.0,!=5.0.0,!=5.1.0,<6.0.0",
- "orjson >=3.2.1,<4.0.0",
- "email_validator >=1.1.1,<2.0.0",
- "uvicorn[standard] >=0.12.0,<0.19.0",
+ "httpx >=0.23.0",
+ "jinja2 >=2.11.2",
+ "python-multipart >=0.0.5",
+ "itsdangerous >=1.1.0",
+ "pyyaml >=5.3.1",
+ "ujson >=4.0.1,!=4.0.2,!=4.1.0,!=4.2.0,!=4.3.0,!=5.0.0,!=5.1.0",
+ "orjson >=3.2.1",
+ "email_validator >=1.1.1",
+ "uvicorn[standard] >=0.12.0",
]
[tool.hatch.version]
@@ -136,9 +135,52 @@ filterwarnings = [
# TODO: needed by asyncio in Python 3.9.7 https://bugs.python.org/issue45097, try to remove on 3.9.8
'ignore:The loop argument is deprecated since Python 3\.8, and scheduled for removal in Python 3\.10:DeprecationWarning:asyncio',
'ignore:starlette.middleware.wsgi is deprecated and will be removed in a future release\..*:DeprecationWarning:starlette',
+ # TODO: remove after upgrading HTTPX to a version newer than 0.23.0
+ # Including PR: https://github.com/encode/httpx/pull/2309
+ "ignore:'cgi' is deprecated:DeprecationWarning",
+ # For passlib
+ "ignore:'crypt' is deprecated and slated for removal in Python 3.13:DeprecationWarning",
# see https://trio.readthedocs.io/en/stable/history.html#trio-0-22-0-2022-09-28
"ignore:You seem to already have a custom.*:RuntimeWarning:trio",
"ignore::trio.TrioDeprecationWarning",
# TODO remove pytest-cov
'ignore::pytest.PytestDeprecationWarning:pytest_cov',
]
+
+[tool.coverage.run]
+parallel = true
+source = [
+ "docs_src",
+ "tests",
+ "fastapi"
+]
+context = '${CONTEXT}'
+
+[tool.ruff]
+select = [
+ "E", # pycodestyle errors
+ "W", # pycodestyle warnings
+ "F", # pyflakes
+ # "I", # isort
+ "C", # flake8-comprehensions
+ "B", # flake8-bugbear
+]
+ignore = [
+ "E501", # line too long, handled by black
+ "B008", # do not perform function calls in argument defaults
+ "C901", # too complex
+]
+
+[tool.ruff.per-file-ignores]
+"__init__.py" = ["F401"]
+"docs_src/dependencies/tutorial007.py" = ["F821"]
+"docs_src/dependencies/tutorial008.py" = ["F821"]
+"docs_src/dependencies/tutorial009.py" = ["F821"]
+"docs_src/dependencies/tutorial010.py" = ["F821"]
+"docs_src/custom_response/tutorial007.py" = ["B007"]
+"docs_src/dataclasses/tutorial003.py" = ["I001"]
+"docs_src/path_operation_advanced_configuration/tutorial007.py" = ["B904"]
+"docs_src/custom_request_and_route/tutorial002.py" = ["B904"]
+
+[tool.ruff.isort]
+known-third-party = ["fastapi", "pydantic", "starlette"]
diff --git a/scripts/docs.py b/scripts/docs.py
index d5fbacf59d..e0953b8edb 100644
--- a/scripts/docs.py
+++ b/scripts/docs.py
@@ -284,7 +284,9 @@ def build_all():
continue
langs.append(lang.name)
cpu_count = os.cpu_count() or 1
- with Pool(cpu_count * 2) as p:
+ process_pool_size = cpu_count * 4
+ typer.echo(f"Using process pool size: {process_pool_size}")
+ with Pool(process_pool_size) as p:
p.map(build_lang, langs)
@@ -332,7 +334,7 @@ def serve():
os.chdir("site")
server_address = ("", 8008)
server = HTTPServer(server_address, SimpleHTTPRequestHandler)
- typer.echo(f"Serving at: http://127.0.0.1:8008")
+ typer.echo("Serving at: http://127.0.0.1:8008")
server.serve_forever()
@@ -420,7 +422,7 @@ def get_file_to_nav_map(nav: list) -> Dict[str, Tuple[str, ...]]:
file_to_nav = {}
for item in nav:
if type(item) is str:
- file_to_nav[item] = tuple()
+ file_to_nav[item] = ()
elif type(item) is dict:
item_key = list(item.keys())[0]
sub_nav = item[item_key]
diff --git a/scripts/format.sh b/scripts/format.sh
index ee4fbf1a5b..3ac1fead86 100755
--- a/scripts/format.sh
+++ b/scripts/format.sh
@@ -1,6 +1,6 @@
#!/bin/sh -e
set -x
-autoflake --remove-all-unused-imports --recursive --remove-unused-variables --in-place docs_src fastapi tests scripts --exclude=__init__.py
+ruff fastapi tests docs_src scripts --fix
black fastapi tests docs_src scripts
isort fastapi tests docs_src scripts
diff --git a/scripts/lint.sh b/scripts/lint.sh
index 2e2072cf18..0feb973a87 100755
--- a/scripts/lint.sh
+++ b/scripts/lint.sh
@@ -4,6 +4,6 @@ set -e
set -x
mypy fastapi
-flake8 fastapi tests
+ruff fastapi tests docs_src scripts
black fastapi tests --check
isort fastapi tests docs_src scripts --check-only
diff --git a/scripts/test-cov-html.sh b/scripts/test-cov-html.sh
index 7957277fc3..d1bdfced2a 100755
--- a/scripts/test-cov-html.sh
+++ b/scripts/test-cov-html.sh
@@ -3,4 +3,7 @@
set -e
set -x
-bash scripts/test.sh --cov-report=html ${@}
+bash scripts/test.sh ${@}
+coverage combine
+coverage report --show-missing
+coverage html
diff --git a/scripts/test.sh b/scripts/test.sh
index d445ca1742..62449ea415 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -6,4 +6,4 @@ set -x
# Check README.md is up to date
python ./scripts/docs.py verify-readme
export PYTHONPATH=./docs_src
-pytest --cov=fastapi --cov=tests --cov=docs_src --cov-report=term-missing:skip-covered --cov-report=xml tests ${@}
+coverage run -m pytest tests ${@}
diff --git a/scripts/zip-docs.sh b/scripts/zip-docs.sh
index f2b7ba3be3..69315f5ddd 100644
--- a/scripts/zip-docs.sh
+++ b/scripts/zip-docs.sh
@@ -3,7 +3,9 @@
set -x
set -e
+cd ./site
+
if [ -f docs.zip ]; then
rm -rf docs.zip
fi
-zip -r docs.zip ./site
+zip -r docs.zip ./
diff --git a/tests/test_custom_route_class.py b/tests/test_custom_route_class.py
index 1a9ea7199a..2e8d9c6de5 100644
--- a/tests/test_custom_route_class.py
+++ b/tests/test_custom_route_class.py
@@ -110,6 +110,6 @@ def test_route_classes():
for r in app.router.routes:
assert isinstance(r, Route)
routes[r.path] = r
- assert getattr(routes["/a/"], "x_type") == "A"
- assert getattr(routes["/a/b/"], "x_type") == "B"
- assert getattr(routes["/a/b/c/"], "x_type") == "C"
+ assert getattr(routes["/a/"], "x_type") == "A" # noqa: B009
+ assert getattr(routes["/a/b/"], "x_type") == "B" # noqa: B009
+ assert getattr(routes["/a/b/c/"], "x_type") == "C" # noqa: B009
diff --git a/tests/test_datastructures.py b/tests/test_datastructures.py
index 43f1a116cb..2e6217d34e 100644
--- a/tests/test_datastructures.py
+++ b/tests/test_datastructures.py
@@ -1,6 +1,10 @@
+from pathlib import Path
+from typing import List
+
import pytest
-from fastapi import UploadFile
+from fastapi import FastAPI, UploadFile
from fastapi.datastructures import Default
+from fastapi.testclient import TestClient
def test_upload_file_invalid():
@@ -20,3 +24,25 @@ def test_default_placeholder_bool():
placeholder_b = Default("")
assert placeholder_a
assert not placeholder_b
+
+
+def test_upload_file_is_closed(tmp_path: Path):
+ path = tmp_path / "test.txt"
+ path.write_bytes(b"")
+ app = FastAPI()
+
+ testing_file_store: List[UploadFile] = []
+
+ @app.post("/uploadfile/")
+ def create_upload_file(file: UploadFile):
+ testing_file_store.append(file)
+ return {"filename": file.filename}
+
+ client = TestClient(app)
+ with path.open("rb") as file:
+ response = client.post("/uploadfile/", files={"file": file})
+ assert response.status_code == 200, response.text
+ assert response.json() == {"filename": "test.txt"}
+
+ assert testing_file_store
+ assert testing_file_store[0].file.closed
diff --git a/tests/test_enforce_once_required_parameter.py b/tests/test_enforce_once_required_parameter.py
index ba8c7353fa..bf05aa5852 100644
--- a/tests/test_enforce_once_required_parameter.py
+++ b/tests/test_enforce_once_required_parameter.py
@@ -101,7 +101,7 @@ def test_schema():
def test_get_invalid():
- response = client.get("/foo", params={"client_id": None})
+ response = client.get("/foo")
assert response.status_code == status.HTTP_422_UNPROCESSABLE_ENTITY
diff --git a/tests/test_extra_routes.py b/tests/test_extra_routes.py
index 491ba61c68..e979628a5c 100644
--- a/tests/test_extra_routes.py
+++ b/tests/test_extra_routes.py
@@ -333,7 +333,7 @@ def test_get_api_route_not_decorated():
def test_delete():
- response = client.delete("/items/foo", json={"name": "Foo"})
+ response = client.request("DELETE", "/items/foo", json={"name": "Foo"})
assert response.status_code == 200, response.text
assert response.json() == {"item_id": "foo", "item": {"name": "Foo", "price": None}}
diff --git a/tests/test_get_request_body.py b/tests/test_get_request_body.py
index 88b9d839f5..52a052faab 100644
--- a/tests/test_get_request_body.py
+++ b/tests/test_get_request_body.py
@@ -104,5 +104,5 @@ def test_openapi_schema():
def test_get_with_body():
body = {"name": "Foo", "description": "Some description", "price": 5.5}
- response = client.get("/product", json=body)
+ response = client.request("GET", "/product", json=body)
assert response.json() == body
diff --git a/tests/test_param_include_in_schema.py b/tests/test_param_include_in_schema.py
index 214f039b67..cb182a1cd4 100644
--- a/tests/test_param_include_in_schema.py
+++ b/tests/test_param_include_in_schema.py
@@ -33,8 +33,6 @@ async def hidden_query(
return {"hidden_query": hidden_query}
-client = TestClient(app)
-
openapi_shema = {
"openapi": "3.0.2",
"info": {"title": "FastAPI", "version": "0.1.0"},
@@ -161,6 +159,7 @@ openapi_shema = {
def test_openapi_schema():
+ client = TestClient(app)
response = client.get("/openapi.json")
assert response.status_code == 200
assert response.json() == openapi_shema
@@ -184,7 +183,8 @@ def test_openapi_schema():
],
)
def test_hidden_cookie(path, cookies, expected_status, expected_response):
- response = client.get(path, cookies=cookies)
+ client = TestClient(app, cookies=cookies)
+ response = client.get(path)
assert response.status_code == expected_status
assert response.json() == expected_response
@@ -207,12 +207,14 @@ def test_hidden_cookie(path, cookies, expected_status, expected_response):
],
)
def test_hidden_header(path, headers, expected_status, expected_response):
+ client = TestClient(app)
response = client.get(path, headers=headers)
assert response.status_code == expected_status
assert response.json() == expected_response
def test_hidden_path():
+ client = TestClient(app)
response = client.get("/hidden_path/hidden_path")
assert response.status_code == 200
assert response.json() == {"hidden_path": "hidden_path"}
@@ -234,6 +236,7 @@ def test_hidden_path():
],
)
def test_hidden_query(path, expected_status, expected_response):
+ client = TestClient(app)
response = client.get(path)
assert response.status_code == expected_status
assert response.json() == expected_response
diff --git a/tests/test_security_api_key_cookie.py b/tests/test_security_api_key_cookie.py
index a5b2e44f0c..0bf4e9bb3a 100644
--- a/tests/test_security_api_key_cookie.py
+++ b/tests/test_security_api_key_cookie.py
@@ -22,8 +22,6 @@ def read_current_user(current_user: User = Depends(get_current_user)):
return current_user
-client = TestClient(app)
-
openapi_schema = {
"openapi": "3.0.2",
"info": {"title": "FastAPI", "version": "0.1.0"},
@@ -51,18 +49,21 @@ openapi_schema = {
def test_openapi_schema():
+ client = TestClient(app)
response = client.get("/openapi.json")
assert response.status_code == 200, response.text
assert response.json() == openapi_schema
def test_security_api_key():
- response = client.get("/users/me", cookies={"key": "secret"})
+ client = TestClient(app, cookies={"key": "secret"})
+ response = client.get("/users/me")
assert response.status_code == 200, response.text
assert response.json() == {"username": "secret"}
def test_security_api_key_no_key():
+ client = TestClient(app)
response = client.get("/users/me")
assert response.status_code == 403, response.text
assert response.json() == {"detail": "Not authenticated"}
diff --git a/tests/test_security_api_key_cookie_description.py b/tests/test_security_api_key_cookie_description.py
index 2cd3565b43..ed4e652394 100644
--- a/tests/test_security_api_key_cookie_description.py
+++ b/tests/test_security_api_key_cookie_description.py
@@ -22,8 +22,6 @@ def read_current_user(current_user: User = Depends(get_current_user)):
return current_user
-client = TestClient(app)
-
openapi_schema = {
"openapi": "3.0.2",
"info": {"title": "FastAPI", "version": "0.1.0"},
@@ -56,18 +54,21 @@ openapi_schema = {
def test_openapi_schema():
+ client = TestClient(app)
response = client.get("/openapi.json")
assert response.status_code == 200, response.text
assert response.json() == openapi_schema
def test_security_api_key():
- response = client.get("/users/me", cookies={"key": "secret"})
+ client = TestClient(app, cookies={"key": "secret"})
+ response = client.get("/users/me")
assert response.status_code == 200, response.text
assert response.json() == {"username": "secret"}
def test_security_api_key_no_key():
+ client = TestClient(app)
response = client.get("/users/me")
assert response.status_code == 403, response.text
assert response.json() == {"detail": "Not authenticated"}
diff --git a/tests/test_security_api_key_cookie_optional.py b/tests/test_security_api_key_cookie_optional.py
index 96a64f09a6..3e7aa81c07 100644
--- a/tests/test_security_api_key_cookie_optional.py
+++ b/tests/test_security_api_key_cookie_optional.py
@@ -29,8 +29,6 @@ def read_current_user(current_user: User = Depends(get_current_user)):
return current_user
-client = TestClient(app)
-
openapi_schema = {
"openapi": "3.0.2",
"info": {"title": "FastAPI", "version": "0.1.0"},
@@ -58,18 +56,21 @@ openapi_schema = {
def test_openapi_schema():
+ client = TestClient(app)
response = client.get("/openapi.json")
assert response.status_code == 200, response.text
assert response.json() == openapi_schema
def test_security_api_key():
- response = client.get("/users/me", cookies={"key": "secret"})
+ client = TestClient(app, cookies={"key": "secret"})
+ response = client.get("/users/me")
assert response.status_code == 200, response.text
assert response.json() == {"username": "secret"}
def test_security_api_key_no_key():
+ client = TestClient(app)
response = client.get("/users/me")
assert response.status_code == 200, response.text
assert response.json() == {"msg": "Create an account first"}
diff --git a/tests/test_security_http_basic_optional.py b/tests/test_security_http_basic_optional.py
index 289bd5c74c..91824d2234 100644
--- a/tests/test_security_http_basic_optional.py
+++ b/tests/test_security_http_basic_optional.py
@@ -4,7 +4,6 @@ from typing import Optional
from fastapi import FastAPI, Security
from fastapi.security import HTTPBasic, HTTPBasicCredentials
from fastapi.testclient import TestClient
-from requests.auth import HTTPBasicAuth
app = FastAPI()
@@ -51,8 +50,7 @@ def test_openapi_schema():
def test_security_http_basic():
- auth = HTTPBasicAuth(username="john", password="secret")
- response = client.get("/users/me", auth=auth)
+ response = client.get("/users/me", auth=("john", "secret"))
assert response.status_code == 200, response.text
assert response.json() == {"username": "john", "password": "secret"}
diff --git a/tests/test_security_http_basic_realm.py b/tests/test_security_http_basic_realm.py
index 54867c2e01..6d760c0f92 100644
--- a/tests/test_security_http_basic_realm.py
+++ b/tests/test_security_http_basic_realm.py
@@ -3,7 +3,6 @@ from base64 import b64encode
from fastapi import FastAPI, Security
from fastapi.security import HTTPBasic, HTTPBasicCredentials
from fastapi.testclient import TestClient
-from requests.auth import HTTPBasicAuth
app = FastAPI()
@@ -48,8 +47,7 @@ def test_openapi_schema():
def test_security_http_basic():
- auth = HTTPBasicAuth(username="john", password="secret")
- response = client.get("/users/me", auth=auth)
+ response = client.get("/users/me", auth=("john", "secret"))
assert response.status_code == 200, response.text
assert response.json() == {"username": "john", "password": "secret"}
diff --git a/tests/test_security_http_basic_realm_description.py b/tests/test_security_http_basic_realm_description.py
index 6ff9d9d07f..7cc5475614 100644
--- a/tests/test_security_http_basic_realm_description.py
+++ b/tests/test_security_http_basic_realm_description.py
@@ -3,7 +3,6 @@ from base64 import b64encode
from fastapi import FastAPI, Security
from fastapi.security import HTTPBasic, HTTPBasicCredentials
from fastapi.testclient import TestClient
-from requests.auth import HTTPBasicAuth
app = FastAPI()
@@ -54,8 +53,7 @@ def test_openapi_schema():
def test_security_http_basic():
- auth = HTTPBasicAuth(username="john", password="secret")
- response = client.get("/users/me", auth=auth)
+ response = client.get("/users/me", auth=("john", "secret"))
assert response.status_code == 200, response.text
assert response.json() == {"username": "john", "password": "secret"}
diff --git a/tests/test_starlette_exception.py b/tests/test_starlette_exception.py
index 2b6712f7b6..418ddff7dd 100644
--- a/tests/test_starlette_exception.py
+++ b/tests/test_starlette_exception.py
@@ -47,10 +47,10 @@ openapi_schema = {
"responses": {
"200": {
"content": {"application/json": {"schema": {}}},
- "description": "Successful " "Response",
+ "description": "Successful Response",
}
},
- "summary": "No Body " "Status " "Code " "Exception",
+ "summary": "No Body Status Code Exception",
}
},
"/http-no-body-statuscode-with-detail-exception": {
@@ -59,7 +59,7 @@ openapi_schema = {
"responses": {
"200": {
"content": {"application/json": {"schema": {}}},
- "description": "Successful " "Response",
+ "description": "Successful Response",
}
},
"summary": "No Body Status Code With Detail Exception",
diff --git a/tests/test_starlette_urlconvertors.py b/tests/test_starlette_urlconvertors.py
index 5a980cbf6d..5ef1b819cd 100644
--- a/tests/test_starlette_urlconvertors.py
+++ b/tests/test_starlette_urlconvertors.py
@@ -1,4 +1,4 @@
-from fastapi import FastAPI, Path
+from fastapi import FastAPI, Path, Query
from fastapi.testclient import TestClient
app = FastAPI()
@@ -19,6 +19,11 @@ def path_convertor(param: str = Path()):
return {"path": param}
+@app.get("/query/")
+def query_convertor(param: str = Query()):
+ return {"query": param}
+
+
client = TestClient(app)
@@ -45,6 +50,13 @@ def test_route_converters_path():
assert response.json() == {"path": "some/example"}
+def test_route_converters_query():
+ # Test query conversion
+ response = client.get("/query", params={"param": "Qué tal!"})
+ assert response.status_code == 200, response.text
+ assert response.json() == {"query": "Qué tal!"}
+
+
def test_url_path_for_path_convertor():
assert (
app.url_path_for("path_convertor", param="some/example") == "/path/some/example"
diff --git a/tests/test_tuples.py b/tests/test_tuples.py
index 18ec2d0489..6e2cc0db67 100644
--- a/tests/test_tuples.py
+++ b/tests/test_tuples.py
@@ -252,16 +252,14 @@ def test_tuple_with_model_invalid():
def test_tuple_form_valid():
- response = client.post("/tuple-form/", data=[("values", "1"), ("values", "2")])
+ response = client.post("/tuple-form/", data={"values": ("1", "2")})
assert response.status_code == 200, response.text
assert response.json() == [1, 2]
def test_tuple_form_invalid():
- response = client.post(
- "/tuple-form/", data=[("values", "1"), ("values", "2"), ("values", "3")]
- )
+ response = client.post("/tuple-form/", data={"values": ("1", "2", "3")})
assert response.status_code == 422, response.text
- response = client.post("/tuple-form/", data=[("values", "1")])
+ response = client.post("/tuple-form/", data={"values": ("1")})
assert response.status_code == 422, response.text
diff --git a/tests/test_tutorial/test_advanced_middleware/test_tutorial001.py b/tests/test_tutorial/test_advanced_middleware/test_tutorial001.py
index 17165c0fc6..157fa5caf1 100644
--- a/tests/test_tutorial/test_advanced_middleware/test_tutorial001.py
+++ b/tests/test_tutorial/test_advanced_middleware/test_tutorial001.py
@@ -9,6 +9,6 @@ def test_middleware():
assert response.status_code == 200, response.text
client = TestClient(app)
- response = client.get("/", allow_redirects=False)
+ response = client.get("/", follow_redirects=False)
assert response.status_code == 307, response.text
assert response.headers["location"] == "https://testserver/"
diff --git a/tests/test_tutorial/test_body/test_tutorial001.py b/tests/test_tutorial/test_body/test_tutorial001.py
index 8dbaf15dbe..65cdc758ad 100644
--- a/tests/test_tutorial/test_body/test_tutorial001.py
+++ b/tests/test_tutorial/test_body/test_tutorial001.py
@@ -176,7 +176,7 @@ def test_post_broken_body():
response = client.post(
"/items/",
headers={"content-type": "application/json"},
- data="{some broken json}",
+ content="{some broken json}",
)
assert response.status_code == 422, response.text
assert response.json() == {
@@ -214,7 +214,7 @@ def test_post_form_for_json():
def test_explicit_content_type():
response = client.post(
"/items/",
- data='{"name": "Foo", "price": 50.5}',
+ content='{"name": "Foo", "price": 50.5}',
headers={"Content-Type": "application/json"},
)
assert response.status_code == 200, response.text
@@ -223,7 +223,7 @@ def test_explicit_content_type():
def test_geo_json():
response = client.post(
"/items/",
- data='{"name": "Foo", "price": 50.5}',
+ content='{"name": "Foo", "price": 50.5}',
headers={"Content-Type": "application/geo+json"},
)
assert response.status_code == 200, response.text
@@ -232,7 +232,7 @@ def test_geo_json():
def test_no_content_type_is_json():
response = client.post(
"/items/",
- data='{"name": "Foo", "price": 50.5}',
+ content='{"name": "Foo", "price": 50.5}',
)
assert response.status_code == 200, response.text
assert response.json() == {
@@ -255,17 +255,19 @@ def test_wrong_headers():
]
}
- response = client.post("/items/", data=data, headers={"Content-Type": "text/plain"})
+ response = client.post(
+ "/items/", content=data, headers={"Content-Type": "text/plain"}
+ )
assert response.status_code == 422, response.text
assert response.json() == invalid_dict
response = client.post(
- "/items/", data=data, headers={"Content-Type": "application/geo+json-seq"}
+ "/items/", content=data, headers={"Content-Type": "application/geo+json-seq"}
)
assert response.status_code == 422, response.text
assert response.json() == invalid_dict
response = client.post(
- "/items/", data=data, headers={"Content-Type": "application/not-really-json"}
+ "/items/", content=data, headers={"Content-Type": "application/not-really-json"}
)
assert response.status_code == 422, response.text
assert response.json() == invalid_dict
diff --git a/tests/test_tutorial/test_body/test_tutorial001_py310.py b/tests/test_tutorial/test_body/test_tutorial001_py310.py
index dd9d9911e4..83bcb68f30 100644
--- a/tests/test_tutorial/test_body/test_tutorial001_py310.py
+++ b/tests/test_tutorial/test_body/test_tutorial001_py310.py
@@ -185,7 +185,7 @@ def test_post_broken_body(client: TestClient):
response = client.post(
"/items/",
headers={"content-type": "application/json"},
- data="{some broken json}",
+ content="{some broken json}",
)
assert response.status_code == 422, response.text
assert response.json() == {
@@ -225,7 +225,7 @@ def test_post_form_for_json(client: TestClient):
def test_explicit_content_type(client: TestClient):
response = client.post(
"/items/",
- data='{"name": "Foo", "price": 50.5}',
+ content='{"name": "Foo", "price": 50.5}',
headers={"Content-Type": "application/json"},
)
assert response.status_code == 200, response.text
@@ -235,7 +235,7 @@ def test_explicit_content_type(client: TestClient):
def test_geo_json(client: TestClient):
response = client.post(
"/items/",
- data='{"name": "Foo", "price": 50.5}',
+ content='{"name": "Foo", "price": 50.5}',
headers={"Content-Type": "application/geo+json"},
)
assert response.status_code == 200, response.text
@@ -245,7 +245,7 @@ def test_geo_json(client: TestClient):
def test_no_content_type_is_json(client: TestClient):
response = client.post(
"/items/",
- data='{"name": "Foo", "price": 50.5}',
+ content='{"name": "Foo", "price": 50.5}',
)
assert response.status_code == 200, response.text
assert response.json() == {
@@ -269,17 +269,19 @@ def test_wrong_headers(client: TestClient):
]
}
- response = client.post("/items/", data=data, headers={"Content-Type": "text/plain"})
+ response = client.post(
+ "/items/", content=data, headers={"Content-Type": "text/plain"}
+ )
assert response.status_code == 422, response.text
assert response.json() == invalid_dict
response = client.post(
- "/items/", data=data, headers={"Content-Type": "application/geo+json-seq"}
+ "/items/", content=data, headers={"Content-Type": "application/geo+json-seq"}
)
assert response.status_code == 422, response.text
assert response.json() == invalid_dict
response = client.post(
- "/items/", data=data, headers={"Content-Type": "application/not-really-json"}
+ "/items/", content=data, headers={"Content-Type": "application/not-really-json"}
)
assert response.status_code == 422, response.text
assert response.json() == invalid_dict
diff --git a/tests/test_tutorial/test_cookie_params/test_tutorial001.py b/tests/test_tutorial/test_cookie_params/test_tutorial001.py
index edccffec1e..38ae211db3 100644
--- a/tests/test_tutorial/test_cookie_params/test_tutorial001.py
+++ b/tests/test_tutorial/test_cookie_params/test_tutorial001.py
@@ -3,8 +3,6 @@ from fastapi.testclient import TestClient
from docs_src.cookie_params.tutorial001 import app
-client = TestClient(app)
-
openapi_schema = {
"openapi": "3.0.2",
"info": {"title": "FastAPI", "version": "0.1.0"},
@@ -88,6 +86,7 @@ openapi_schema = {
],
)
def test(path, cookies, expected_status, expected_response):
- response = client.get(path, cookies=cookies)
+ client = TestClient(app, cookies=cookies)
+ response = client.get(path)
assert response.status_code == expected_status
assert response.json() == expected_response
diff --git a/tests/test_tutorial/test_cookie_params/test_tutorial001_py310.py b/tests/test_tutorial/test_cookie_params/test_tutorial001_py310.py
index 5caa5c4400..5ad52fb5e1 100644
--- a/tests/test_tutorial/test_cookie_params/test_tutorial001_py310.py
+++ b/tests/test_tutorial/test_cookie_params/test_tutorial001_py310.py
@@ -70,14 +70,6 @@ openapi_schema = {
}
-@pytest.fixture(name="client")
-def get_client():
- from docs_src.cookie_params.tutorial001_py310 import app
-
- client = TestClient(app)
- return client
-
-
@needs_py310
@pytest.mark.parametrize(
"path,cookies,expected_status,expected_response",
@@ -94,7 +86,10 @@ def get_client():
("/items", {"session": "cookiesession"}, 200, {"ads_id": None}),
],
)
-def test(path, cookies, expected_status, expected_response, client: TestClient):
- response = client.get(path, cookies=cookies)
+def test(path, cookies, expected_status, expected_response):
+ from docs_src.cookie_params.tutorial001_py310 import app
+
+ client = TestClient(app, cookies=cookies)
+ response = client.get(path)
assert response.status_code == expected_status
assert response.json() == expected_response
diff --git a/tests/test_tutorial/test_custom_request_and_route/test_tutorial001.py b/tests/test_tutorial/test_custom_request_and_route/test_tutorial001.py
index 3eb5822e28..e6da630e88 100644
--- a/tests/test_tutorial/test_custom_request_and_route/test_tutorial001.py
+++ b/tests/test_tutorial/test_custom_request_and_route/test_tutorial001.py
@@ -26,7 +26,7 @@ def test_gzip_request(compress):
data = gzip.compress(data)
headers["Content-Encoding"] = "gzip"
headers["Content-Type"] = "application/json"
- response = client.post("/sum", data=data, headers=headers)
+ response = client.post("/sum", content=data, headers=headers)
assert response.json() == {"sum": n}
diff --git a/tests/test_tutorial/test_custom_response/test_tutorial006.py b/tests/test_tutorial/test_custom_response/test_tutorial006.py
index 72bbfd2777..9b10916e58 100644
--- a/tests/test_tutorial/test_custom_response/test_tutorial006.py
+++ b/tests/test_tutorial/test_custom_response/test_tutorial006.py
@@ -32,6 +32,6 @@ def test_openapi_schema():
def test_get():
- response = client.get("/typer", allow_redirects=False)
+ response = client.get("/typer", follow_redirects=False)
assert response.status_code == 307, response.text
assert response.headers["location"] == "https://typer.tiangolo.com"
diff --git a/tests/test_tutorial/test_custom_response/test_tutorial006b.py b/tests/test_tutorial/test_custom_response/test_tutorial006b.py
index ac5a76d34d..b3e60e86a3 100644
--- a/tests/test_tutorial/test_custom_response/test_tutorial006b.py
+++ b/tests/test_tutorial/test_custom_response/test_tutorial006b.py
@@ -27,6 +27,6 @@ def test_openapi_schema():
def test_redirect_response_class():
- response = client.get("/fastapi", allow_redirects=False)
+ response = client.get("/fastapi", follow_redirects=False)
assert response.status_code == 307
assert response.headers["location"] == "https://fastapi.tiangolo.com"
diff --git a/tests/test_tutorial/test_custom_response/test_tutorial006c.py b/tests/test_tutorial/test_custom_response/test_tutorial006c.py
index 009225e8c5..0cb6ddaa33 100644
--- a/tests/test_tutorial/test_custom_response/test_tutorial006c.py
+++ b/tests/test_tutorial/test_custom_response/test_tutorial006c.py
@@ -27,6 +27,6 @@ def test_openapi_schema():
def test_redirect_status_code():
- response = client.get("/pydantic", allow_redirects=False)
+ response = client.get("/pydantic", follow_redirects=False)
assert response.status_code == 302
assert response.headers["location"] == "https://pydantic-docs.helpmanual.io/"
diff --git a/tests/test_tutorial/test_path_operation_advanced_configurations/test_tutorial006.py b/tests/test_tutorial/test_path_operation_advanced_configurations/test_tutorial006.py
index 5533b29571..330b4e2c79 100644
--- a/tests/test_tutorial/test_path_operation_advanced_configurations/test_tutorial006.py
+++ b/tests/test_tutorial/test_path_operation_advanced_configurations/test_tutorial006.py
@@ -47,7 +47,7 @@ def test_openapi_schema():
def test_post():
- response = client.post("/items/", data=b"this is actually not validated")
+ response = client.post("/items/", content=b"this is actually not validated")
assert response.status_code == 200, response.text
assert response.json() == {
"size": 30,
diff --git a/tests/test_tutorial/test_path_operation_advanced_configurations/test_tutorial007.py b/tests/test_tutorial/test_path_operation_advanced_configurations/test_tutorial007.py
index cb5dbc8eb0..076f60b2f0 100644
--- a/tests/test_tutorial/test_path_operation_advanced_configurations/test_tutorial007.py
+++ b/tests/test_tutorial/test_path_operation_advanced_configurations/test_tutorial007.py
@@ -58,7 +58,7 @@ def test_post():
- x-men
- x-avengers
"""
- response = client.post("/items/", data=yaml_data)
+ response = client.post("/items/", content=yaml_data)
assert response.status_code == 200, response.text
assert response.json() == {
"name": "Deadpoolio",
@@ -74,7 +74,7 @@ def test_post_broken_yaml():
x - x-men
x - x-avengers
"""
- response = client.post("/items/", data=yaml_data)
+ response = client.post("/items/", content=yaml_data)
assert response.status_code == 422, response.text
assert response.json() == {"detail": "Invalid YAML"}
@@ -88,7 +88,7 @@ def test_post_invalid():
- x-avengers
- sneaky: object
"""
- response = client.post("/items/", data=yaml_data)
+ response = client.post("/items/", content=yaml_data)
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
diff --git a/tests/test_tutorial/test_security/test_tutorial006.py b/tests/test_tutorial/test_security/test_tutorial006.py
index 3b0a36ebca..bbfef9f7c4 100644
--- a/tests/test_tutorial/test_security/test_tutorial006.py
+++ b/tests/test_tutorial/test_security/test_tutorial006.py
@@ -1,7 +1,6 @@
from base64 import b64encode
from fastapi.testclient import TestClient
-from requests.auth import HTTPBasicAuth
from docs_src.security.tutorial006 import app
@@ -38,8 +37,7 @@ def test_openapi_schema():
def test_security_http_basic():
- auth = HTTPBasicAuth(username="john", password="secret")
- response = client.get("/users/me", auth=auth)
+ response = client.get("/users/me", auth=("john", "secret"))
assert response.status_code == 200, response.text
assert response.json() == {"username": "john", "password": "secret"}
diff --git a/tests/test_tutorial/test_websockets/test_tutorial002.py b/tests/test_tutorial/test_websockets/test_tutorial002.py
index a8523c9c4f..bb5ccbf8ef 100644
--- a/tests/test_tutorial/test_websockets/test_tutorial002.py
+++ b/tests/test_tutorial/test_websockets/test_tutorial002.py
@@ -4,20 +4,18 @@ from fastapi.websockets import WebSocketDisconnect
from docs_src.websockets.tutorial002 import app
-client = TestClient(app)
-
def test_main():
+ client = TestClient(app)
response = client.get("/")
assert response.status_code == 200, response.text
assert b"" in response.content
def test_websocket_with_cookie():
+ client = TestClient(app, cookies={"session": "fakesession"})
with pytest.raises(WebSocketDisconnect):
- with client.websocket_connect(
- "/items/foo/ws", cookies={"session": "fakesession"}
- ) as websocket:
+ with client.websocket_connect("/items/foo/ws") as websocket:
message = "Message one"
websocket.send_text(message)
data = websocket.receive_text()
@@ -33,6 +31,7 @@ def test_websocket_with_cookie():
def test_websocket_with_header():
+ client = TestClient(app)
with pytest.raises(WebSocketDisconnect):
with client.websocket_connect("/items/bar/ws?token=some-token") as websocket:
message = "Message one"
@@ -50,6 +49,7 @@ def test_websocket_with_header():
def test_websocket_with_header_and_query():
+ client = TestClient(app)
with pytest.raises(WebSocketDisconnect):
with client.websocket_connect("/items/2/ws?q=3&token=some-token") as websocket:
message = "Message one"
@@ -71,6 +71,7 @@ def test_websocket_with_header_and_query():
def test_websocket_no_credentials():
+ client = TestClient(app)
with pytest.raises(WebSocketDisconnect):
with client.websocket_connect("/items/foo/ws"):
pytest.fail(
@@ -79,6 +80,7 @@ def test_websocket_no_credentials():
def test_websocket_invalid_data():
+ client = TestClient(app)
with pytest.raises(WebSocketDisconnect):
with client.websocket_connect("/items/foo/ws?q=bar&token=some-token"):
pytest.fail(
diff --git a/tests/test_ws_router.py b/tests/test_ws_router.py
index 206d743bac..c312821e96 100644
--- a/tests/test_ws_router.py
+++ b/tests/test_ws_router.py
@@ -111,7 +111,7 @@ def test_router_ws_depends():
def test_router_ws_depends_with_override():
client = TestClient(app)
- app.dependency_overrides[ws_dependency] = lambda: "Override"
+ app.dependency_overrides[ws_dependency] = lambda: "Override" # noqa: E731
with client.websocket_connect("/router-ws-depends/") as websocket:
assert websocket.receive_text() == "Override"
+
+ 
@@ -427,7 +427,7 @@ For a more complete example including more features, see the Strawberry and other libraries.
* Many extra features (thanks to Starlette) as:
* **WebSockets**
- * extremely easy tests based on `requests` and `pytest`
+ * extremely easy tests based on HTTPX and `pytest`
* **CORS**
* **Cookie Sessions**
* ...and more.
@@ -447,7 +447,7 @@ Used by Pydantic:
Used by Starlette:
-* 
-If you open the developer tools, you could see how the data sent and only includes the token, the password is only sent in the first request to authenticate the user and get that access token, but not afterwards:
+If you open the developer tools, you could see how the data sent only includes the token, the password is only sent in the first request to authenticate the user and get that access token, but not afterwards:
diff --git a/docs/en/docs/tutorial/testing.md b/docs/en/docs/tutorial/testing.md
index d2ccd7dc77..be07aab37d 100644
--- a/docs/en/docs/tutorial/testing.md
+++ b/docs/en/docs/tutorial/testing.md
@@ -2,16 +2,16 @@
Thanks to Starlette, testing **FastAPI** applications is easy and enjoyable.
-It is based on Requests, so it's very familiar and intuitive.
+It is based on HTTPX, which in turn is designed based on Requests, so it's very familiar and intuitive.
With it, you can use pytest directly with **FastAPI**.
## Using `TestClient`
!!! info
- To use `TestClient`, first install `requests`.
+ To use `TestClient`, first install `httpx`.
- E.g. `pip install requests`.
+ E.g. `pip install httpx`.
Import `TestClient`.
@@ -19,7 +19,7 @@ Create a `TestClient` by passing your **FastAPI** application to it.
Create functions with a name that starts with `test_` (this is standard `pytest` conventions).
-Use the `TestClient` object the same way as you do with `requests`.
+Use the `TestClient` object the same way as you do with `httpx`.
Write simple `assert` statements with the standard Python expressions that you need to check (again, standard `pytest`).
@@ -130,7 +130,7 @@ You could then update `test_main.py` with the extended tests:
{!> ../../../docs_src/app_testing/app_b/test_main.py!}
```
-Whenever you need the client to pass information in the request and you don't know how to, you can search (Google) how to do it in `requests`.
+Whenever you need the client to pass information in the request and you don't know how to, you can search (Google) how to do it in `httpx`, or even how to do it with `requests`, as HTTPX's design is based on Requests' design.
Then you just do the same in your tests.
@@ -142,7 +142,7 @@ E.g.:
* To pass *headers*, use a `dict` in the `headers` parameter.
* For *cookies*, a `dict` in the `cookies` parameter.
-For more information about how to pass data to the backend (using `requests` or the `TestClient`) check the Requests documentation.
+For more information about how to pass data to the backend (using `httpx` or the `TestClient`) check the HTTPX documentation.
!!! info
Note that the `TestClient` receives data that can be converted to JSON, not Pydantic models.
diff --git a/docs/en/overrides/main.html b/docs/en/overrides/main.html
index c5eb94870d..e9b9f60eb6 100644
--- a/docs/en/overrides/main.html
+++ b/docs/en/overrides/main.html
@@ -22,12 +22,6 @@
-
- 