🔖 Release version 0.46.0

The links to post @tiangolo were not working

.github/ISSUE_TEMPLATE/bug_report.md

@@ -7,29 +7,48 @@ assignees: ''
 
 ---
 
-**Describe the bug**
-A clear and concise description of what the bug is.
+### Describe the bug
 
-**To Reproduce**
-Steps to reproduce the behavior:
-1. Create a file with '...'
-2. Add a path operation function with '....'
-3. Open the browser and call it with a payload of '....'
-4. See error
+Write here a clear and concise description of what the bug is.
 
-**Expected behavior**
-A clear and concise description of what you expected to happen.
+### To Reproduce
 
-**Screenshots**
-If applicable, add screenshots to help explain your problem.
+Steps to reproduce the behavior with a minimum self-contained file.
 
-**Environment:**
- - OS: [e.g. Linux / Windows / macOS]
- - FastAPI Version [e.g. 0.3.0], get it with:
+Replace each part with your own scenario:
+
+1. Create a file with:
 
 ```Python
-import fastapi
-print(fastapi.__version__)
+from fastapi import FastAPI
+
+app = FastAPI()
+
+
+@app.get("/")
+def read_root():
+    return {"Hello": "World"}
+```
+
+3. Open the browser and call the endpoint `/`.
+4. It returns a JSON with `{"Hello": "World"}`.
+5. But I expected it to return `{"Hello": "Sara"}`.
+
+### Expected behavior
+
+Add a clear and concise description of what you expected to happen.
+
+### Screenshots
+
+If applicable, add screenshots to help explain your problem.
+
+### Environment
+
+- OS: [e.g. Linux / Windows / macOS]
+- FastAPI Version [e.g. 0.3.0], get it with:
+
+```bash
+python -c "import fastapi; print(fastapi.__version__)"
 ```
 
 - Python version, get it with:
@@ -38,5 +57,6 @@ print(fastapi.__version__)
 python --version
 ```
 
-**Additional context**
+### Additional context
+
 Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -7,14 +7,20 @@ assignees: ''
 
 ---
 
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I want to be able to [...] but I can't because [...]
+### Is your feature request related to a problem
 
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
+Is your feature request related to a problem?
 
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
+Add a clear and concise description of what the problem is. Ex. I want to be able to [...] but I can't because [...]
+
+### The solution you would like
+
+Add a clear and concise description of what you want to happen.
+
+### Describe alternatives you've considered
+
+Add a clear and concise description of any alternative solutions or features you've considered.
+
+### Additional context
 
-**Additional context**
 Add any other context or screenshots about the feature request here.

.github/ISSUE_TEMPLATE/question.md

@@ -7,11 +7,18 @@ assignees: ''
 
 ---
 
-**Description**
+### First check
+
+* [ ] I used the GitHub search to find a similar issue and didn't find it.
+* [ ] I searched the FastAPI documentation, with the integrated search.
+* [ ] I already searched in Google "How to X in FastAPI" and didn't find any information.
+
+### Description
 
 How can I [...]?
 
 Is it possible to [...]?
 
-**Additional context**
+### Additional context
+
 Add any other context or screenshots about the feature request here.

.github/workflows/main.yml

@@ -0,0 +1,19 @@
+on:
+  schedule:
+  - cron: "0 0 * * *"
+
+jobs:
+  issue-manager:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: tiangolo/issue-manager@master
+      with:
+        token: ${{ secrets.GITHUB_TOKEN }}
+        config: >
+            {
+              "answered": {
+                "users": ["tiangolo", "dmontagu"],
+                "delay": 864000,
+                "message": "Assuming the original issue was solved, it will be automatically closed now. But feel free to add more comments or create new issues."
+              }
+            }

.travis.yml

@@ -7,6 +7,12 @@ cache: pip
 python:
     - "3.6"
     - "3.7"
+    - "3.8"
+    - "nightly"
+
+matrix:
+    allow_failures:
+        - python: "nightly"
 
 install:
     - pip install flit
@@ -19,8 +25,8 @@ after_script:
     - bash <(curl -s https://codecov.io/bash)
 
 deploy:
-  provider: script
-  script: bash scripts/deploy.sh
-  on:
-    tags: true
-    python: "3.6"
+    provider: script
+    script: bash scripts/deploy.sh
+    on:
+        tags: true
+        python: "3.6"

Pipfile

@@ -25,10 +25,11 @@ sqlalchemy = "*"
 uvicorn = "*"
 
 [packages]
-starlette = "==0.12.7"
-pydantic = "==0.30.0"
+starlette = "==0.12.9"
+pydantic = "==1.0.0"
 databases = {extras = ["sqlite"],version = "*"}
 hypercorn = "*"
+orjson = "*"
 
 [requires]
 python_version = "3.6"

README.md

@@ -5,8 +5,8 @@
     <em>FastAPI framework, high performance, easy to learn, fast to code, ready for production</em>
 </p>
 <p align="center">
-<a href="https://travis-ci.org/tiangolo/fastapi" target="_blank">
-    <img src="https://travis-ci.org/tiangolo/fastapi.svg?branch=master" alt="Build Status">
+<a href="https://travis-ci.com/tiangolo/fastapi" target="_blank">
+    <img src="https://travis-ci.com/tiangolo/fastapi.svg?branch=master" alt="Build Status">
 </a>
 <a href="https://codecov.io/gh/tiangolo/fastapi" target="_blank">
     <img src="https://codecov.io/gh/tiangolo/fastapi/branch/master/graph/badge.svg" alt="Coverage">
@@ -63,8 +63,19 @@ The key features are:
 
 ---
 
+"*If you're looking to learn one **modern framework** for building REST APIs, check out **FastAPI** [...] It's fast, easy to use and easy to learn [...]*"
 
+"*We've switched over to **FastAPI** for our **APIs** [...] I think you'll like it [...]*"
 
+<div style="text-align: right; margin-right: 10%;">Ines Montani - Matthew Honnibal - <strong><a href="https://explosion.ai" target="_blank">Explosion AI</a> founders - <a href="https://spacy.io" target="_blank">spaCy</a> creators</strong> <a href="https://twitter.com/_inesmontani/status/1144173225322143744" target="_blank"><small>(ref)</small></a> - <a href="https://twitter.com/honnibal/status/1144031421859655680" target="_blank"><small>(ref)</small></a></div>
+
+---
+
+"*We adopted the **FastAPI** library to spawn a **REST** server that can be queried to obtain **predictions**. [for Ludwig]*"
+
+<div style="text-align: right; margin-right: 10%;">Piero Molino, Yaroslav Dudin, and Sai Sumanth Miryala - <strong>Uber</strong> <a href="https://eng.uber.com/ludwig-v0-2/" target="_blank"><small>(ref)</small></a></div>
+
+---
 
 ## Requirements
 
@@ -79,13 +90,13 @@ FastAPI stands on the shoulders of giants:
 ## Installation
 
 ```bash
-$ pip install fastapi
+pip install fastapi
 ```
 
 You will also need an ASGI server, for production such as <a href="http://www.uvicorn.org" target="_blank">Uvicorn</a> or <a href="https://gitlab.com/pgjones/hypercorn" target="_blank">Hypercorn</a>.
 
 ```bash
-$ pip install uvicorn
+pip install uvicorn
 ```
 
 ## Example
@@ -195,8 +206,7 @@ Now modify the file `main.py` to receive a body from a `PUT` request.
 
 Declare the body using standard Python types, thanks to Pydantic.
 
-
-```Python hl_lines="2 7 8 9 10 24"
+```Python hl_lines="2  7 8 9 10  23 24 25"
 from fastapi import FastAPI
 from pydantic import BaseModel
 
@@ -396,7 +406,7 @@ Used by FastAPI / Starlette:
 
 * <a href="http://www.uvicorn.org" target="_blank"><code>uvicorn</code></a> - for the server that loads and serves your application.
 
-You can install all of these with `pip3 install fastapi[all]`.
+You can install all of these with `pip install fastapi[all]`.
 
 ## License
 

docs/alternatives.md

@@ -142,12 +142,12 @@ Another big feature required by APIs is <abbr title="reading and converting to P
 
 Webargs is a tool that was made to provide that on top of several frameworks, including Flask.
 
-It uses Marshmallow underneath to do the data validation. And it was created by the same guys.
+It uses Marshmallow underneath to do the data validation. And it was created by the same developers.
 
 It's a great tool and I have used it a lot too, before having **FastAPI**.
 
 !!! info
-    Webargs was created by the same Marshmallow guys.
+    Webargs was created by the same Marshmallow developers.
 
 !!! check "Inspired **FastAPI** to"
     Have automatic validation of incoming request data.
@@ -171,7 +171,7 @@ But then, we have again the problem of having a micro-syntax, inside of a Python
 The editor can't help much with that. And if we modify parameters or Marshmallow schemas and forget to also modify that YAML docstring, the generated schema would be obsolete.
 
 !!! info
-    APISpec was created by the same Marshmallow guys.
+    APISpec was created by the same Marshmallow developers.
 
 
 !!! check "Inspired **FastAPI** to"
@@ -198,7 +198,7 @@ Using it led to the creation of several Flask full-stack generators. These are t
 And these same full-stack generators were the base of the <a href="/project-generation/" target="_blank">**FastAPI** project generator</a>.
 
 !!! info
-    Flask-apispec was created by the same Marshmallow guys.
+    Flask-apispec was created by the same Marshmallow developers.
 
 !!! check "Inspired **FastAPI** to"
     Generate the OpenAPI schema automatically, from the same code that defines serialization and validation.

docs/deployment.md

@@ -170,32 +170,33 @@ Now, from a developer's perspective, here are several things to have in mind whi
     * So, the certificate and encryption handling is done before HTTP.
 * TCP doesn't know about "domains". Only about IP addresses.
     * The information about the specific domain requested goes in the HTTP data.
-* The HTTPS certificates "certificate" a certain domain, but the protocol and encryption happen at the TCP level, before knowing which domain is being dealt with.
+* The HTTPS certificates "certify" a certain domain, but the protocol and encryption happen at the TCP level, before knowing which domain is being dealt with.
 * By default, that would mean that you can only have one HTTPS certificate per IP address.
-    * No matter how big is your server and how small each application you have there might be. But...
+    * No matter how big your server is or how small each application you have on it might be.
+    * There is a solution to this, however.
 * There's an extension to the TLS protocol (the one handling the encryption at the TCP level, before HTTP) called <a href="https://en.wikipedia.org/wiki/Server_Name_Indication" target="_blank"><abbr title="Server Name Indication">SNI</abbr></a>.
-    * This SNI extension allows one single server (with a single IP address) to have several HTTPS certificates and server multiple HTTPS domains/applications.
-    * For this to work, a single component (program) running in the server, listening in the public IP address, must have all the HTTPS certificates in the server.
-* After having a secure connection, the communication protocol is the same HTTP.
-    * It goes encrypted, but the encrypted contents are the same HTTP protocol.
+    * This SNI extension allows one single server (with a single IP address) to have several HTTPS certificates and serve multiple HTTPS domains/applications.
+    * For this to work, a single component (program) running on the server, listening on the public IP address, must have all the HTTPS certificates in the server.
+* After obtaining a secure connection, the communication protocol is still HTTP.
+    * The contents are encrypted, even though they are being sent with the HTTP protocol.
 
 
-It is a common practice to have one program/HTTP server running in the server (the machine, host, etc) and managing all the HTTPS parts, sending the decrypted HTTP requests to the actual HTTP application running in the same server (the **FastAPI** application, in this case), take the HTTP response from the application, encrypt it using the appropriate certificate and sending it back to the client using HTTPS. This server is ofter called a <a href="https://en.wikipedia.org/wiki/TLS_termination_proxy" target="_blank">TLS Termination Proxy</a>.
+It is a common practice to have one program/HTTP server running on the server (the machine, host, etc.) and managing all the HTTPS parts : sending the decrypted HTTP requests to the actual HTTP application running in the same server (the **FastAPI** application, in this case), take the HTTP response from the application, encrypt it using the appropriate certificate and sending it back to the client using HTTPS. This server is often called a <a href="https://en.wikipedia.org/wiki/TLS_termination_proxy" target="_blank">TLS Termination Proxy</a>.
 
 
 ### Let's Encrypt
 
-Up to some years ago, these HTTPS certificates were sold by trusted third-parties.
+Before Let's Encrypt, these HTTPS certificates were sold by trusted third-parties.
 
 The process to acquire one of these certificates used to be cumbersome, require quite some paperwork and the certificates were quite expensive.
 
 But then <a href="https://letsencrypt.org/" target="_blank">Let's Encrypt</a> was created.
 
-It is a project from the Linux Foundation. It provides HTTPS certificates for free. In an automated way. These certificates use all the standard cryptographic security, and are short lived (about 3 months), so, the security is actually increased, by reducing their lifespan.
+It is a project from the Linux Foundation. It provides HTTPS certificates for free. In an automated way. These certificates use all the standard cryptographic security, and are short lived (about 3 months), so the security is actually better because of their reduced lifespan.
 
-The domains are securely verified and the certificates are generated automatically. This also allows automatizing the renewal of these certificates.
+The domains are securely verified and the certificates are generated automatically. This also allows automating the renewal of these certificates.
 
-The idea is to automatize the acquisition and renewal of these certificates, so that you can have secure HTTPS, free, forever.
+The idea is to automate the acquisition and renewal of these certificates, so that you can have secure HTTPS, for free, forever.
 
 
 ### Traefik
@@ -204,7 +205,7 @@ The idea is to automatize the acquisition and renewal of these certificates, so
 
 It has integration with Let's Encrypt. So, it can handle all the HTTPS parts, including certificate acquisition and renewal.
 
-It also has integrations with Docker. So, you can declare your domains in each application configurations and have it read those configurations, generate the HTTPS certificates and serve HTTPS to your application, all automatically. Without requiring any change in its configuration.
+It also has integrations with Docker. So, you can declare your domains in each application configurations and have it read those configurations, generate the HTTPS certificates and serve HTTPS to your application automatically, without requiring any change in its configuration.
 
 ---
 
@@ -230,7 +231,7 @@ It is designed to be integrated with this Docker Swarm cluster with Traefik and
 
 You can generate a project in about 2 min.
 
-The generated project has instructions to deploy it, doing it takes other 2 min.
+The generated project has instructions to deploy it, doing it takes another 2 min.
 
 
 ## Alternatively, deploy **FastAPI** without Docker

docs/external-links.md

@@ -25,6 +25,18 @@ Here's an incomplete list of some of them.
 
 * <a href="https://blog.bartab.fr/fastapi-logging-on-the-fly/" target="_blank">FastAPI, a simple use case on logging</a> by <a href="https://blog.bartab.fr/" target="_blank">@euri10</a>.
 
+* <a href="https://medium.com/@nico.axtmann95/deploying-a-scikit-learn-model-with-onnx-und-fastapi-1af398268915" target="_blank">Deploying a scikit-learn model with ONNX and FastAPI</a> by <a href="https://www.linkedin.com/in/nico-axtmann" target="_blank">Nico Axtmann</a>.
+
+* <a href="https://geekflare.com/python-asynchronous-web-frameworks/" target="_blank">Top 5 Asynchronous Web Frameworks for Python</a> by <a href="https://geekflare.com/author/ankush/" target="_blank">Ankush Thakur</a> on <a href="https://geekflare.com" target="_blank">GeekFlare</a>.
+
+* <a href="https://medium.com/@gntrm/jwt-authentication-with-fastapi-and-aws-cognito-1333f7f2729e" target="_blank">JWT Authentication with FastAPI and AWS Cognito</a> by <a href="https://twitter.com/gntrm" target="_blank">Johannes Gontrum</a>.
+
+* <a href="https://towardsdatascience.com/how-to-deploy-a-machine-learning-model-dc51200fe8cf" target="_blank">How to Deploy a Machine Learning Model</a> by <a href="https://www.linkedin.com/in/mgrootendorst/" target="_blank">Maarten Grootendorst</a> on <a href="https://towardsdatascience.com/" target="_blank">Towards Data Science</a>.
+
+* <a href="https://eng.uber.com/ludwig-v0-2/" target="_blank">Uber: Ludwig v0.2 Adds New Features and Other Improvements to its Deep Learning Toolbox [including a FastAPI server]</a> on <a href="https://eng.uber.com" target="_blank">Uber Engineering</a>.
+
+* <a href="https://gitlab.com/euri10/fastapi_cheatsheet" target="_blank">A FastAPI and Swagger UI visual cheatsheet</a> by <a href="https://gitlab.com/euri10" target="_blank">@euri10</a>
+
 ### Japanese
 
 * <a href="https://qiita.com/mtitg/items/47770e9a562dd150631d" target="_blank">FastAPI｜DB接続してCRUDするPython製APIサーバーを構築</a> by <a href="https://qiita.com/mtitg" target="_blank">@mtitg</a>.
@@ -39,10 +51,20 @@ Here's an incomplete list of some of them.
 
 * <a href="https://qiita.com/hikarut/items/b178af2e2440c67c6ac4" target="_blank">フロントエンド開発者向けのDockerによるPython開発環境構築</a> by <a href="https://qiita.com/hikarut" target="_blank">Hikaru Takahashi</a>.
 
+* <a href="https://rightcode.co.jp/blog/information-technology/fastapi-tutorial-todo-apps-environment" target="_blank">【第1回】FastAPIチュートリアル: ToDoアプリを作ってみよう【環境構築編】</a> by <a href="https://rightcode.co.jp/author/jun" target="_blank">ライトコードメディア編集部</a>
+
+* <a href="https://rightcode.co.jp/blog/information-technology/fastapi-tutorial-todo-apps-model-building" target="_blank">【第2回】FastAPIチュートリアル: ToDoアプリを作ってみよう【モデル構築編】</a> by <a href="https://rightcode.co.jp/author/jun" target="_blank">ライトコードメディア編集部</a>
+
+* <a href="https://rightcode.co.jp/blog/information-technology/fastapi-tutorial-todo-apps-authentication-user-registration" target="_blank">【第3回】FastAPIチュートリアル: toDoアプリを作ってみよう【認証・ユーザ登録編】</a> by <a href="https://rightcode.co.jp/author/jun" target="_blank">ライトコードメディア編集部</a>
+
+* <a href="https://rightcode.co.jp/blog/information-technology/fastapi-tutorial-todo-apps-admin-page-improvement" target="_blank">【第4回】FastAPIチュートリアル: toDoアプリを作ってみよう【管理者ページ改良編】</a> by <a href="https://rightcode.co.jp/author/jun" target="_blank">ライトコードメディア編集部</a>
+
 ### Chinese
 
 * <a href="https://cloud.tencent.com/developer/article/1431448" target="_blank">使用FastAPI框架快速构建高性能的api服务</a> by <a href="https://cloud.tencent.com/developer/user/5471722" target="_blank">逍遥散人</a>.
 
+* <a href="https://wxq0309.github.io/" target="_blank">FastAPI框架中文文档</a> by <a href="https://wxq0309.github.io/" target="_blank">何大仙</a>.
+
 ### Vietnamese
 
 * <a href="https://fullstackstation.com/fastapi-trien-khai-bang-docker/" target="_blank">FASTAPI: TRIỂN KHAI BẰNG DOCKER</a> by <a href="https://fullstackstation.com/author/figonking/" target="_blank">Nguyễn Nhân</a>.
@@ -51,6 +73,8 @@ Here's an incomplete list of some of them.
 
 * <a href="https://habr.com/ru/post/454440/" target="_blank">Мелкая питонячая радость #2: Starlette - Солидная примочка – FastAPI</a> by <a href="https://habr.com/ru/users/57uff3r/" target="_blank">Andrey Korchak</a>.
 
+* <a href="https://habr.com/ru/post/478620/" target="_blank">Почему Вы должны попробовать FastAPI?</a> by <a href="https://github.com/prostomarkeloff" target="_blank">prostomarkeloff</a>.
+
 ## Podcasts
 
 * <a href="https://pythonbytes.fm/episodes/show/123/time-to-right-the-py-wrongs?time_in_sec=855" target="_blank">FastAPI on PythonBytes</a> by <a href="https://pythonbytes.fm/" target="_blank">Python Bytes FM</a>.

docs/help-fastapi.md

@@ -56,7 +56,7 @@ You can:
 
 ## Tweet about **FastAPI**
 
-<a href="http://twitter.com/home/?status=I'm loving FastAPI because... https://github.com/tiangolo/fastapi cc @tiangolo" target="_blank">Tweet about **FastAPI**</a> and let me and others why you like it.
+<a href="https://twitter.com/compose/tweet?text=I'm loving FastAPI because... https://github.com/tiangolo/fastapi cc @tiangolo" target="_blank">Tweet about **FastAPI**</a> and let me and others know why you like it.
 
 ## Let me know how are you using **FastAPI**
 
@@ -64,7 +64,7 @@ I love to hear about how **FastAPI** is being used, what have you liked in it, i
 
 You can let me know:
 
-* <a href="http://twitter.com/home/?status=Hey @tiangolo, I'm using FastAPI at..." target="_blank">On **Twitter**</a>.
+* <a href="https://twitter.com/compose/tweet?text=Hey @tiangolo, I'm using FastAPI at..." target="_blank">On **Twitter**</a>.
 * <a href="https://www.linkedin.com/in/tiangolo/" target="_blank">On **Linkedin**</a>.
 * <a href="https://medium.com/@tiangolo" target="_blank">On **Medium**</a>.
 

docs/img/github-social-preview.svg

@@ -0,0 +1,98 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   id="svg8"
+   version="1.1"
+   viewBox="0 0 338.66665 169.33332"
+   height="169.33333mm"
+   width="338.66666mm"
+   sodipodi:docname="github-social-preview.svg"
+   inkscape:version="0.92.3 (2405546, 2018-03-11)"
+   inkscape:export-filename="/home/user/code/fastapi/docs/img/github-social-preview.png"
+   inkscape:export-xdpi="96"
+   inkscape:export-ydpi="96">
+  <sodipodi:namedview
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1"
+     objecttolerance="10"
+     gridtolerance="10"
+     guidetolerance="10"
+     inkscape:pageopacity="0"
+     inkscape:pageshadow="2"
+     inkscape:window-width="1920"
+     inkscape:window-height="1025"
+     id="namedview9"
+     showgrid="false"
+     inkscape:zoom="0.52249777"
+     inkscape:cx="565.37328"
+     inkscape:cy="403.61034"
+     inkscape:window-x="0"
+     inkscape:window-y="27"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg8" />
+  <defs
+     id="defs2" />
+  <metadata
+     id="metadata5">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title></dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <rect
+     style="opacity:0.98000004;fill:#ffffff;fill-opacity:1;stroke-width:0.26458332"
+     id="rect853"
+     width="338.66666"
+     height="169.33333"
+     x="-1.0833333e-05"
+     y="0.71613133"
+     inkscape:export-xdpi="96"
+     inkscape:export-ydpi="96" />
+  <g
+     transform="matrix(0.73259569,0,0,0.73259569,64.842852,-4.5763945)"
+     id="layer1">
+    <path
+       style="opacity:0.98000004;fill:#009688;fill-opacity:1;stroke-width:3.20526505"
+       id="path817"
+       d="m 1.4365174,55.50154 c -17.6610514,0 -31.9886064,14.327532 -31.9886064,31.988554 0,17.661036 14.327555,31.988586 31.9886064,31.988586 17.6609756,0 31.9885196,-14.32755 31.9885196,-31.988586 0,-17.661022 -14.327544,-31.988554 -31.9885196,-31.988554 z m -1.66678692,57.63069 V 93.067264 H -11.384533 L 4.6417437,61.847974 V 81.912929 H 15.379405 Z"
+       inkscape:connector-curvature="0" />
+    <text
+       id="text979"
+       y="114.91215"
+       x="52.115433"
+       style="font-style:normal;font-weight:normal;font-size:79.71511078px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#009688;fill-opacity:1;stroke:none;stroke-width:1.99287772"
+       xml:space="preserve"><tspan
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:Ubuntu;-inkscape-font-specification:Ubuntu;fill:#009688;fill-opacity:1;stroke-width:1.99287772"
+         y="114.91215"
+         x="52.115433"
+         id="tspan977">FastAPI</tspan></text>
+  </g>
+  <text
+     xml:space="preserve"
+     style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
+     x="169.60979"
+     y="119.20409"
+     id="text851"><tspan
+       sodipodi:role="line"
+       id="tspan849"
+       x="169.60979"
+       y="119.20409"
+       style="font-style:italic;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:Roboto;-inkscape-font-specification:'Roboto Italic';text-align:center;text-anchor:middle;stroke-width:0.26458332">High performance, easy to learn,</tspan><tspan
+       sodipodi:role="line"
+       x="169.60979"
+       y="132.53661"
+       style="font-style:italic;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:Roboto;-inkscape-font-specification:'Roboto Italic';text-align:center;text-anchor:middle;stroke-width:0.26458332"
+       id="tspan855">fast to code, ready for production</tspan></text>
+</svg>

docs/index.md

@@ -5,8 +5,8 @@
     <em>FastAPI framework, high performance, easy to learn, fast to code, ready for production</em>
 </p>
 <p align="center">
-<a href="https://travis-ci.org/tiangolo/fastapi" target="_blank">
-    <img src="https://travis-ci.org/tiangolo/fastapi.svg?branch=master" alt="Build Status">
+<a href="https://travis-ci.com/tiangolo/fastapi" target="_blank">
+    <img src="https://travis-ci.com/tiangolo/fastapi.svg?branch=master" alt="Build Status">
 </a>
 <a href="https://codecov.io/gh/tiangolo/fastapi" target="_blank">
     <img src="https://codecov.io/gh/tiangolo/fastapi/branch/master/graph/badge.svg" alt="Coverage">
@@ -63,8 +63,19 @@ The key features are:
 
 ---
 
+"*If you're looking to learn one **modern framework** for building REST APIs, check out **FastAPI** [...] It's fast, easy to use and easy to learn [...]*"
 
+"*We've switched over to **FastAPI** for our **APIs** [...] I think you'll like it [...]*"
 
+<div style="text-align: right; margin-right: 10%;">Ines Montani - Matthew Honnibal - <strong><a href="https://explosion.ai" target="_blank">Explosion AI</a> founders - <a href="https://spacy.io" target="_blank">spaCy</a> creators</strong> <a href="https://twitter.com/_inesmontani/status/1144173225322143744" target="_blank"><small>(ref)</small></a> - <a href="https://twitter.com/honnibal/status/1144031421859655680" target="_blank"><small>(ref)</small></a></div>
+
+---
+
+"*We adopted the **FastAPI** library to spawn a **REST** server that can be queried to obtain **predictions**. [for Ludwig]*"
+
+<div style="text-align: right; margin-right: 10%;">Piero Molino, Yaroslav Dudin, and Sai Sumanth Miryala - <strong>Uber</strong> <a href="https://eng.uber.com/ludwig-v0-2/" target="_blank"><small>(ref)</small></a></div>
+
+---
 
 ## Requirements
 
@@ -79,13 +90,13 @@ FastAPI stands on the shoulders of giants:
 ## Installation
 
 ```bash
-$ pip install fastapi
+pip install fastapi
 ```
 
 You will also need an ASGI server, for production such as <a href="http://www.uvicorn.org" target="_blank">Uvicorn</a> or <a href="https://gitlab.com/pgjones/hypercorn" target="_blank">Hypercorn</a>.
 
 ```bash
-$ pip install uvicorn
+pip install uvicorn
 ```
 
 ## Example
@@ -195,8 +206,7 @@ Now modify the file `main.py` to receive a body from a `PUT` request.
 
 Declare the body using standard Python types, thanks to Pydantic.
 
-
-```Python hl_lines="2 7 8 9 10 24"
+```Python hl_lines="2  7 8 9 10  23 24 25"
 from fastapi import FastAPI
 from pydantic import BaseModel
 
@@ -396,7 +406,7 @@ Used by FastAPI / Starlette:
 
 * <a href="http://www.uvicorn.org" target="_blank"><code>uvicorn</code></a> - for the server that loads and serves your application.
 
-You can install all of these with `pip3 install fastapi[all]`.
+You can install all of these with `pip install fastapi[all]`.
 
 ## License
 

docs/release-notes.md

@@ -1,5 +1,150 @@
 ## Latest changes
 
+## 0.46.0
+
+* Fix typos and tweak configs. PR [#837](https://github.com/tiangolo/fastapi/pull/837).
+* Add link to Chinese article in [External Links](https://fastapi.tiangolo.com/external-links/). PR [810](https://github.com/tiangolo/fastapi/pull/810) by [@wxq0309](https://github.com/wxq0309).
+* Implement `OAuth2AuthorizationCodeBearer` class. PR [#797](https://github.com/tiangolo/fastapi/pull/797) by [@kuwv](https://github.com/kuwv).
+* Update example upgrade in docs main page. PR [#795](https://github.com/tiangolo/fastapi/pull/795) by [@cdeil](https://github.com/cdeil).
+* Fix callback handling for sub-routers. PR [#792](https://github.com/tiangolo/fastapi/pull/792) by [@jekirl](https://github.com/jekirl).
+* Fix typos. PR [#784](https://github.com/tiangolo/fastapi/pull/784) by [@kkinder](https://github.com/kkinder).
+* Add 4 Japanese articles to [External Links](https://fastapi.tiangolo.com/external-links/). PR [#783](https://github.com/tiangolo/fastapi/pull/783) by [@HymanZHAN](https://github.com/HymanZHAN).
+* Add support for subtypes of main types in `jsonable_encoder`, e.g. asyncpg's UUIDs. PR [#756](https://github.com/tiangolo/fastapi/pull/756) by [@RmStorm](https://github.com/RmStorm).
+* Fix usage of Pydantic's `HttpUrl` in docs. PR [#832](https://github.com/tiangolo/fastapi/pull/832) by [@Dustyposa](https://github.com/Dustyposa).
+* Fix Twitter links in docs. PR [#813](https://github.com/tiangolo/fastapi/pull/813) by [@justindujardin](https://github.com/justindujardin).
+* Add docs for correctly [using FastAPI with Peewee ORM](https://fastapi.tiangolo.com/tutorial/sql-databases-peewee/). Including how to overwrite parts of Peewee to correctly handle async threads. PR [#789](https://github.com/tiangolo/fastapi/pull/789).
+
+## 0.45.0
+
+* Add support for OpenAPI Callbacks:
+    * New docs: [OpenAPI Callbacks](https://fastapi.tiangolo.com/tutorial/openapi-callbacks/).
+    * Refactor generation of `operationId`s to be valid Python names (also valid variables in most languages).
+    * Add `default_response_class` parameter to `APIRouter`.
+    * Original PR [#722](https://github.com/tiangolo/fastapi/pull/722) by [@booooh](https://github.com/booooh).
+* Refactor logging to use the same logger everywhere, update log strings and levels. PR [#781](https://github.com/tiangolo/fastapi/pull/781).
+* Add article to [External Links](https://fastapi.tiangolo.com/external-links/): [Почему Вы должны попробовать FastAPI?](https://habr.com/ru/post/478620/). PR [#766](https://github.com/tiangolo/fastapi/pull/766) by [@prostomarkeloff](https://github.com/prostomarkeloff).
+* Remove gender bias in docs for handling errors. PR [#780](https://github.com/tiangolo/fastapi/pull/780). Original idea in PR [#761](https://github.com/tiangolo/fastapi/pull/761) by [@classywhetten](https://github.com/classywhetten).
+* Rename docs and references to `body-schema` to `body-fields` to keep in line with Pydantic. PR [#746](https://github.com/tiangolo/fastapi/pull/746) by [@prostomarkeloff](https://github.com/prostomarkeloff).
+
+## 0.44.1
+
+* Add GitHub social preview images to git. PR [#752](https://github.com/tiangolo/fastapi/pull/752).
+* Update PyPI "trove classifiers". PR [#751](https://github.com/tiangolo/fastapi/pull/751).
+* Add full support for Python 3.8. Enable Python 3.8 in full in Travis. PR [749](https://github.com/tiangolo/fastapi/pull/749).
+* Update "new issue" templates. PR [#749](https://github.com/tiangolo/fastapi/pull/749).
+* Fix serialization of errors for exotic Pydantic types. PR [#748](https://github.com/tiangolo/fastapi/pull/748) by [@dmontagu](https://github.com/dmontagu).
+
+## 0.44.0
+
+* Add GitHub action [Issue Manager](https://github.com/tiangolo/issue-manager). PR [#742](https://github.com/tiangolo/fastapi/pull/742).
+* Fix typos in docs. PR [734](https://github.com/tiangolo/fastapi/pull/734) by [@bundabrg](https://github.com/bundabrg).
+* Fix usage of `custom_encoder` in `jsonable_encoder`. PR [#715](https://github.com/tiangolo/fastapi/pull/715) by [@matrixise](https://github.com/matrixise).
+* Fix invalid XML example. PR [710](https://github.com/tiangolo/fastapi/pull/710) by [@OcasoProtal](https://github.com/OcasoProtal).
+* Fix typos and update wording in deployment docs. PR [#700](https://github.com/tiangolo/fastapi/pull/700) by [@marier-nico](https://github.com/tiangolo/fastapi/pull/700).
+* Add note about dependencies in `APIRouter` docs. PR [#698](https://github.com/tiangolo/fastapi/pull/698) by [@marier-nico](https://github.com/marier-nico).
+* Add support for async class methods as dependencies [#681](https://github.com/tiangolo/fastapi/pull/681) by [@frankie567](https://github.com/frankie567).
+* Add FastAPI with Swagger UI cheatsheet to external links. PR [#671](https://github.com/tiangolo/fastapi/pull/671) by [@euri10](https://github.com/euri10).
+* Fix typo in HTTP protocol in CORS example. PR [#647](https://github.com/tiangolo/fastapi/pull/647) by [@forestmonster](https://github.com/forestmonster).
+* Add support for Pydantic versions `1.0.0` and above, with temporary (deprecated) backwards compatibility for Pydantic `0.32.2`. PR [#646](https://github.com/tiangolo/fastapi/pull/646) by [@dmontagu](https://github.com/dmontagu).
+
+## 0.43.0
+
+* Update docs to reduce gender bias. PR [#645](https://github.com/tiangolo/fastapi/pull/645) by [@ticosax](https://github.com/ticosax).
+* Add docs about [overriding the `operationId` for all the *path operations*](https://fastapi.tiangolo.com/tutorial/path-operation-advanced-configuration/#using-the-path-operation-function-name-as-the-operationid) based on their function name. PR [#642](https://github.com/tiangolo/fastapi/pull/642) by [@SKalt](https://github.com/SKalt).
+* Fix validators in models generating an incorrect key order. PR [#637](https://github.com/tiangolo/fastapi/pull/637) by [@jaddison](https://github.com/jaddison).
+* Generate correct OpenAPI docs for responses with no content. PR [#621](https://github.com/tiangolo/fastapi/pull/621) by [@brotskydotcom](https://github.com/brotskydotcom).
+* Remove `$` from Bash code blocks in docs for consistency. PR [#613](https://github.com/tiangolo/fastapi/pull/613) by [@nstapelbroek](https://github.com/nstapelbroek).
+* Add docs for [self-serving docs' (Swagger UI) static assets](https://fastapi.tiangolo.com/tutorial/extending-openapi/#self-hosting-javascript-and-css-for-docs), e.g. to use the docs offline, or without Internet. Initial PR [#557](https://github.com/tiangolo/fastapi/pull/557) by [@svalouch](https://github.com/svalouch).
+* Fix `black` linting after upgrade. PR [#682](https://github.com/tiangolo/fastapi/pull/682) by [@frankie567](https://github.com/frankie567).
+
+## 0.42.0
+
+* Add dependencies with `yield`, a.k.a. exit steps, context managers, cleanup, teardown, ...
+    * This allows adding extra code after a dependency is done. It can be used, for example, to close database connections.
+    * Dependencies with `yield` can be normal or `async`, **FastAPI** will run normal dependencies in a threadpool.
+    * They can be combined with normal dependencies.
+    * It's possible to have arbitrary trees/levels of dependencies with `yield` and exit steps are handled in the correct order automatically.
+    * It works by default in Python 3.7 or above. For Python 3.6, it requires the extra backport dependencies:
+        * `async-exit-stack`
+        * `async-generator`
+    * New docs at [Dependencies with `yield`](https://fastapi.tiangolo.com/tutorial/dependencies/dependencies-with-yield/).
+    * Updated database docs [SQL (Relational) Databases: Main **FastAPI** app](https://fastapi.tiangolo.com/tutorial/sql-databases/#main-fastapi-app).
+    * PR [#595](https://github.com/tiangolo/fastapi/pull/595).
+* Fix `sitemap.xml` in website. PR [#598](https://github.com/tiangolo/fastapi/pull/598) by [@samuelcolvin](https://github.com/samuelcolvin).
+
+## 0.41.0
+
+* Upgrade required Starlette to `0.12.9`, the new range is `>=0.12.9,<=0.12.9`.
+    * Add `State` to FastAPI apps at `app.state`.
+    * PR [#593](https://github.com/tiangolo/fastapi/pull/593).
+* Improve handling of custom classes for `Request`s and `APIRoute`s.
+    * This helps to more easily solve use cases like:
+        * Reading a body before and/or after a request (equivalent to a middleware).
+        * Run middleware-like code only for a subset of *path operations*.
+        * Process a request before passing it to a *path operation function*. E.g. decompressing, deserializing, etc.
+        * Processing a response after being generated by *path operation functions* but before returning it. E.g. adding custom headers, logging, adding extra metadata.
+    * New docs section: [Custom Request and APIRoute class](https://fastapi.tiangolo.com/tutorial/custom-request-and-route/).
+    * PR [#589](https://github.com/tiangolo/fastapi/pull/589) by [@dmontagu](https://github.com/dmontagu).
+* Fix preserving custom route class in routers when including other sub-routers. PR [#538](https://github.com/tiangolo/fastapi/pull/538) by [@dmontagu](https://github.com/dmontagu).
+
+## 0.40.0
+
+* Add notes to docs about installing `python-multipart` when using forms. PR [#574](https://github.com/tiangolo/fastapi/pull/574) by [@sliptonic](https://github.com/sliptonic).
+* Generate OpenAPI schemas in alphabetical order. PR [#554](https://github.com/tiangolo/fastapi/pull/554) by [@dmontagu](https://github.com/dmontagu).
+* Add support for truncating docstrings from *path operation functions*.
+    * New docs at [Advanced description from docstring](https://fastapi.tiangolo.com/tutorial/path-operation-advanced-configuration/#advanced-description-from-docstring).
+    * PR [#556](https://github.com/tiangolo/fastapi/pull/556) by [@svalouch](https://github.com/svalouch).
+* Fix `DOCTYPE` in HTML files generated for Swagger UI and ReDoc. PR [#537](https://github.com/tiangolo/fastapi/pull/537) by [@Trim21](https://github.com/Trim21).
+* Fix handling `4XX` responses overriding default `422` validation error responses. PR [#517](https://github.com/tiangolo/fastapi/pull/517) by [@tsouvarev](https://github.com/tsouvarev).
+* Fix typo in documentation for [Simple HTTP Basic Auth](https://fastapi.tiangolo.com/tutorial/security/http-basic-auth/#simple-http-basic-auth). PR [#514](https://github.com/tiangolo/fastapi/pull/514) by [@prostomarkeloff](https://github.com/prostomarkeloff).
+* Fix incorrect documentation example in [first steps](https://fastapi.tiangolo.com/tutorial/first-steps/). PR [#511](https://github.com/tiangolo/fastapi/pull/511) by [@IgnatovFedor](https://github.com/IgnatovFedor).
+* Add support for Swagger UI [initOauth](https://github.com/swagger-api/swagger-ui/blob/master/docs/usage/oauth2.md) settings with the parameter `swagger_ui_init_oauth`. PR [#499](https://github.com/tiangolo/fastapi/pull/499) by [@zamiramir](https://github.com/zamiramir).
+
+## 0.39.0
+
+* Allow path parameters to have default values (e.g. `None`) and discard them instead of raising an error.
+    * This allows declaring a parameter like `user_id: str = None` that can be taken from a query parameter, but the same path operation can be included in a router with a path `/users/{user_id}`, in which case will be taken from the path and will be required.
+    * PR [#464](https://github.com/tiangolo/fastapi/pull/464) by [@jonathanunderwood](https://github.com/jonathanunderwood).
+* Add support for setting a `default_response_class` in the `FastAPI` instance or in `include_router`. Initial PR [#467](https://github.com/tiangolo/fastapi/pull/467) by [@toppk](https://github.com/toppk).
+* Add support for type annotations using strings and `from __future__ import annotations`. PR [#451](https://github.com/tiangolo/fastapi/pull/451) by [@dmontagu](https://github.com/dmontagu).
+
+## 0.38.1
+
+* Fix incorrect `Request` class import. PR [#493](https://github.com/tiangolo/fastapi/pull/493) by [@kamalgill](https://github.com/kamalgill).
+
+## 0.38.0
+
+* Add recent articles to [External Links](https://fastapi.tiangolo.com/external-links/) and recent opinions. PR [#490](https://github.com/tiangolo/fastapi/pull/490).
+* Upgrade support range for Starlette to include `0.12.8`. The new range is `>=0.11.1,<=0.12.8"`. PR [#477](https://github.com/tiangolo/fastapi/pull/477) by [@dmontagu](https://github.com/dmontagu).
+* Upgrade support to Pydantic version 0.32.2 and update internal code to use it (breaking change). PR [#463](https://github.com/tiangolo/fastapi/pull/463) by [@dmontagu](https://github.com/dmontagu).
+
+## 0.37.0
+
+* Add support for custom route classes for advanced use cases. PR [#468](https://github.com/tiangolo/fastapi/pull/468) by [@dmontagu](https://github.com/dmontagu).
+* Allow disabling Google fonts in ReDoc. PR [#481](https://github.com/tiangolo/fastapi/pull/481) by [@b1-luettje](https://github.com/b1-luettje).
+* Fix security issue: when returning a sub-class of a response model and using `skip_defaults` it could leak information. PR [#485](https://github.com/tiangolo/fastapi/pull/485) by [@dmontagu](https://github.com/dmontagu).
+* Enable tests for Python 3.8-dev. PR [#465](https://github.com/tiangolo/fastapi/pull/465) by [@Jamim](https://github.com/Jamim).
+* Add support and tests for Pydantic dataclasses in `response_model`. PR [#454](https://github.com/tiangolo/fastapi/pull/454) by [@dconathan](https://github.com/dconathan).
+* Fix typo in OAuth2 JWT tutorial. PR [#447](https://github.com/tiangolo/fastapi/pull/447) by [@pablogamboa](https://github.com/pablogamboa).
+* Use the `media_type` parameter in `Body()` params to set the media type in OpenAPI for `requestBody`. PR [#439](https://github.com/tiangolo/fastapi/pull/439) by [@divums](https://github.com/divums).
+* Add article [Deploying a scikit-learn model with ONNX and FastAPI](https://medium.com/@nico.axtmann95/deploying-a-scikit-learn-model-with-onnx-und-fastapi-1af398268915) by [https://www.linkedin.com/in/nico-axtmann](Nico Axtmann). PR [#438](https://github.com/tiangolo/fastapi/pull/438) by [@naxty](https://github.com/naxty).
+* Allow setting custom `422` (validation error) response/schema in OpenAPI.
+    * And use media type from response class instead of fixed `application/json` (the default).
+    * PR [#437](https://github.com/tiangolo/fastapi/pull/437) by [@divums](https://github.com/divums).
+* Fix using `"default"` extra response with status codes at the same time. PR [#489](https://github.com/tiangolo/fastapi/pull/489).
+* Allow additional responses to use status code ranges (like `5XX` and `4XX`) and `"default"`. PR [#435](https://github.com/tiangolo/fastapi/pull/435) by [@divums](https://github.com/divums).
+
+## 0.36.0
+
+* Fix implementation for `skip_defaults` when returning a Pydantic model. PR [#422](https://github.com/tiangolo/fastapi/pull/422) by [@dmontagu](https://github.com/dmontagu).
+* Fix OpenAPI generation when using the same dependency in multiple places for the same *path operation*. PR [#417](https://github.com/tiangolo/fastapi/pull/417) by [@dmontagu](https://github.com/dmontagu).
+* Allow having empty paths in *path operations* used with `include_router` and a `prefix`.
+    * This allows having a router for `/cats` and all its *path operations*, while having one of them for `/cats`.
+    * Now it doesn't have to be only `/cats/` (with a trailing slash).
+    * To use it, declare the path in the *path operation* as the empty string (`""`).
+    * PR [#415](https://github.com/tiangolo/fastapi/pull/415) by [@vitalik](https://github.com/vitalik).
+* Fix mypy error after merging PR #415. PR [#462](https://github.com/tiangolo/fastapi/pull/462).
+
 ## 0.35.0
 
 * Fix typo in routing `assert`. PR [#419](https://github.com/tiangolo/fastapi/pull/419) by [@pablogamboa](https://github.com/pablogamboa).

docs/src/body_fields/tutorial001.py

@@ -1,13 +1,13 @@
 from fastapi import Body, FastAPI
-from pydantic import BaseModel, Schema
+from pydantic import BaseModel, Field
 
 app = FastAPI()
 
 
 class Item(BaseModel):
     name: str
-    description: str = Schema(None, title="The description of the item", max_length=300)
-    price: float = Schema(..., gt=0, description="The price must be greater than zero")
+    description: str = Field(None, title="The description of the item", max_length=300)
+    price: float = Field(..., gt=0, description="The price must be greater than zero")
     tax: float = None
 
 

docs/src/body_nested_models/tutorial005.py

@@ -1,13 +1,13 @@
 from typing import Set
 
 from fastapi import FastAPI
-from pydantic import BaseModel, UrlStr
+from pydantic import BaseModel, HttpUrl
 
 app = FastAPI()
 
 
 class Image(BaseModel):
-    url: UrlStr
+    url: HttpUrl
     name: str
 
 

docs/src/body_nested_models/tutorial006.py

@@ -1,13 +1,13 @@
 from typing import List, Set
 
 from fastapi import FastAPI
-from pydantic import BaseModel, UrlStr
+from pydantic import BaseModel, HttpUrl
 
 app = FastAPI()
 
 
 class Image(BaseModel):
-    url: UrlStr
+    url: HttpUrl
     name: str
 
 

docs/src/body_nested_models/tutorial007.py

@@ -1,13 +1,13 @@
 from typing import List, Set
 
 from fastapi import FastAPI
-from pydantic import BaseModel, UrlStr
+from pydantic import BaseModel, HttpUrl
 
 app = FastAPI()
 
 
 class Image(BaseModel):
-    url: UrlStr
+    url: HttpUrl
     name: str
 
 

docs/src/body_nested_models/tutorial008.py

@@ -1,13 +1,13 @@
 from typing import List
 
 from fastapi import FastAPI
-from pydantic import BaseModel, UrlStr
+from pydantic import BaseModel, HttpUrl
 
 app = FastAPI()
 
 
 class Image(BaseModel):
-    url: UrlStr
+    url: HttpUrl
     name: str
 
 

docs/src/body_updates/tutorial002.py

@@ -31,7 +31,7 @@ async def read_item(item_id: str):
 async def update_item(item_id: str, item: Item):
     stored_item_data = items[item_id]
     stored_item_model = Item(**stored_item_data)
-    update_data = item.dict(skip_defaults=True)
+    update_data = item.dict(exclude_unset=True)
     updated_item = stored_item_model.copy(update=update_data)
     items[item_id] = jsonable_encoder(updated_item)
     return updated_item

docs/src/cors/tutorial001.py

@@ -6,8 +6,8 @@ app = FastAPI()
 origins = [
     "http://localhost.tiangolo.com",
     "https://localhost.tiangolo.com",
-    "http:localhost",
-    "http:localhost:8080",
+    "http://localhost",
+    "http://localhost:8080",
 ]
 
 app.add_middleware(

docs/src/custom_request_and_route/tutorial001.py

@@ -0,0 +1,37 @@
+import gzip
+from typing import Callable, List
+
+from fastapi import Body, FastAPI
+from fastapi.routing import APIRoute
+from starlette.requests import Request
+from starlette.responses import Response
+
+
+class GzipRequest(Request):
+    async def body(self) -> bytes:
+        if not hasattr(self, "_body"):
+            body = await super().body()
+            if "gzip" in self.headers.getlist("Content-Encoding"):
+                body = gzip.decompress(body)
+            self._body = body
+        return self._body
+
+
+class GzipRoute(APIRoute):
+    def get_route_handler(self) -> Callable:
+        original_route_handler = super().get_route_handler()
+
+        async def custom_route_handler(request: Request) -> Response:
+            request = GzipRequest(request.scope, request.receive)
+            return await original_route_handler(request)
+
+        return custom_route_handler
+
+
+app = FastAPI()
+app.router.route_class = GzipRoute
+
+
+@app.post("/sum")
+async def sum_numbers(numbers: List[int] = Body(...)):
+    return {"sum": sum(numbers)}

docs/src/custom_request_and_route/tutorial002.py

@@ -0,0 +1,31 @@
+from typing import Callable, List
+
+from fastapi import Body, FastAPI, HTTPException
+from fastapi.exceptions import RequestValidationError
+from fastapi.routing import APIRoute
+from starlette.requests import Request
+from starlette.responses import Response
+
+
+class ValidationErrorLoggingRoute(APIRoute):
+    def get_route_handler(self) -> Callable:
+        original_route_handler = super().get_route_handler()
+
+        async def custom_route_handler(request: Request) -> Response:
+            try:
+                return await original_route_handler(request)
+            except RequestValidationError as exc:
+                body = await request.body()
+                detail = {"errors": exc.errors(), "body": body.decode()}
+                raise HTTPException(status_code=422, detail=detail)
+
+        return custom_route_handler
+
+
+app = FastAPI()
+app.router.route_class = ValidationErrorLoggingRoute
+
+
+@app.post("/")
+async def sum_numbers(numbers: List[int] = Body(...)):
+    return sum(numbers)

docs/src/custom_request_and_route/tutorial003.py

@@ -0,0 +1,41 @@
+import time
+from typing import Callable
+
+from fastapi import APIRouter, FastAPI
+from fastapi.routing import APIRoute
+from starlette.requests import Request
+from starlette.responses import Response
+
+
+class TimedRoute(APIRoute):
+    def get_route_handler(self) -> Callable:
+        original_route_handler = super().get_route_handler()
+
+        async def custom_route_handler(request: Request) -> Response:
+            before = time.time()
+            response: Response = await original_route_handler(request)
+            duration = time.time() - before
+            response.headers["X-Response-Time"] = str(duration)
+            print(f"route duration: {duration}")
+            print(f"route response: {response}")
+            print(f"route response headers: {response.headers}")
+            return response
+
+        return custom_route_handler
+
+
+app = FastAPI()
+router = APIRouter(route_class=TimedRoute)
+
+
+@app.get("/")
+async def not_timed():
+    return {"message": "Not timed"}
+
+
+@router.get("/timed")
+async def timed():
+    return {"message": "It's the time of my life"}
+
+
+app.include_router(router)

docs/src/dependencies/tutorial007.py

@@ -1,21 +1,6 @@
-from fastapi import Depends, FastAPI
-
-app = FastAPI()
-
-
-class FixedContentQueryChecker:
-    def __init__(self, fixed_content: str):
-        self.fixed_content = fixed_content
-
-    def __call__(self, q: str = ""):
-        if q:
-            return self.fixed_content in q
-        return False
-
-
-checker = FixedContentQueryChecker("bar")
-
-
-@app.get("/query-checker/")
-async def read_query_check(fixed_content_included: bool = Depends(checker)):
-    return {"fixed_content_in_query": fixed_content_included}
+async def get_db():
+    db = DBSession()
+    try:
+        yield db
+    finally:
+        db.close()

docs/src/dependencies/tutorial008.py

@@ -0,0 +1,25 @@
+from fastapi import Depends
+
+
+async def dependency_a():
+    dep_a = generate_dep_a()
+    try:
+        yield dep_a
+    finally:
+        dep_a.close()
+
+
+async def dependency_b(dep_a=Depends(dependency_a)):
+    dep_b = generate_dep_b()
+    try:
+        yield dep_b
+    finally:
+        dep_b.close(dep_a)
+
+
+async def dependency_c(dep_b=Depends(dependency_b)):
+    dep_c = generate_dep_c()
+    try:
+        yield dep_c
+    finally:
+        dep_c.close(dep_b)

docs/src/dependencies/tutorial009.py

@@ -0,0 +1,25 @@
+from fastapi import Depends
+
+
+async def dependency_a():
+    dep_a = generate_dep_a()
+    try:
+        yield dep_a
+    finally:
+        dep_a.close()
+
+
+async def dependency_b(dep_a=Depends(dependency_a)):
+    dep_b = generate_dep_b()
+    try:
+        yield dep_b
+    finally:
+        dep_b.close(dep_a)
+
+
+async def dependency_c(dep_b=Depends(dependency_b)):
+    dep_c = generate_dep_c()
+    try:
+        yield dep_c
+    finally:
+        dep_c.close(dep_b)

docs/src/dependencies/tutorial010.py

@@ -0,0 +1,14 @@
+class MySuperContextManager:
+    def __init__(self):
+        self.db = DBSession()
+
+    def __enter__(self):
+        return self.db
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.db.close()
+
+
+async def get_db():
+    with MySuperContextManager() as db:
+        yield db

docs/src/dependencies/tutorial011.py

@@ -0,0 +1,21 @@
+from fastapi import Depends, FastAPI
+
+app = FastAPI()
+
+
+class FixedContentQueryChecker:
+    def __init__(self, fixed_content: str):
+        self.fixed_content = fixed_content
+
+    def __call__(self, q: str = ""):
+        if q:
+            return self.fixed_content in q
+        return False
+
+
+checker = FixedContentQueryChecker("bar")
+
+
+@app.get("/query-checker/")
+async def read_query_check(fixed_content_included: bool = Depends(checker)):
+    return {"fixed_content_in_query": fixed_content_included}

docs/src/extending_openapi/tutorial002.py

@@ -0,0 +1,41 @@
+from fastapi import FastAPI
+from fastapi.openapi.docs import (
+    get_redoc_html,
+    get_swagger_ui_html,
+    get_swagger_ui_oauth2_redirect_html,
+)
+from starlette.staticfiles import StaticFiles
+
+app = FastAPI(docs_url=None, redoc_url=None)
+
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+
+@app.get("/docs", include_in_schema=False)
+async def custom_swagger_ui_html():
+    return get_swagger_ui_html(
+        openapi_url=app.openapi_url,
+        title=app.title + " - Swagger UI",
+        oauth2_redirect_url=app.swagger_ui_oauth2_redirect_url,
+        swagger_js_url="/static/swagger-ui-bundle.js",
+        swagger_css_url="/static/swagger-ui.css",
+    )
+
+
+@app.get(app.swagger_ui_oauth2_redirect_url, include_in_schema=False)
+async def swagger_ui_redirect():
+    return get_swagger_ui_oauth2_redirect_html()
+
+
+@app.get("/redoc", include_in_schema=False)
+async def redoc_html():
+    return get_redoc_html(
+        openapi_url=app.openapi_url,
+        title=app.title + " - ReDoc",
+        redoc_js_url="/static/redoc.standalone.js",
+    )
+
+
+@app.get("/users/{username}")
+async def read_user(username: str):
+    return {"message": f"Hello {username}"}

docs/src/extra_models/tutorial001.py

@@ -1,6 +1,5 @@
 from fastapi import FastAPI
-from pydantic import BaseModel
-from pydantic.types import EmailStr
+from pydantic import BaseModel, EmailStr
 
 app = FastAPI()
 

docs/src/extra_models/tutorial002.py

@@ -1,6 +1,5 @@
 from fastapi import FastAPI
-from pydantic import BaseModel
-from pydantic.types import EmailStr
+from pydantic import BaseModel, EmailStr
 
 app = FastAPI()
 

docs/src/openapi_callbacks/tutorial001.py

@@ -0,0 +1,52 @@
+from fastapi import APIRouter, FastAPI
+from pydantic import BaseModel, HttpUrl
+from starlette.responses import JSONResponse
+
+app = FastAPI()
+
+
+class Invoice(BaseModel):
+    id: str
+    title: str = None
+    customer: str
+    total: float
+
+
+class InvoiceEvent(BaseModel):
+    description: str
+    paid: bool
+
+
+class InvoiceEventReceived(BaseModel):
+    ok: bool
+
+
+invoices_callback_router = APIRouter(default_response_class=JSONResponse)
+
+
+@invoices_callback_router.post(
+    "{$callback_url}/invoices/{$request.body.id}", response_model=InvoiceEventReceived,
+)
+def invoice_notification(body: InvoiceEvent):
+    pass
+
+
+@app.post("/invoices/", callbacks=invoices_callback_router.routes)
+def create_invoice(invoice: Invoice, callback_url: HttpUrl = None):
+    """
+    Create an invoice.
+
+    This will (let's imagine) let the API user (some external developer) create an
+    invoice.
+
+    And this path operation will:
+
+    * Send the invoice to the client.
+    * Collect the money from the client.
+    * Send a notification back to the API user (the external developer), as a callback.
+        * At this point is that the API will somehow send a POST request to the
+            external API with the notification of the invoice event
+            (e.g. "payment successful").
+    """
+    # Send the invoice, collect the money, send the notification (the callback)
+    return {"msg": "Invoice received"}

docs/src/path_operation_advanced_configuration/tutorial002.py

@@ -1,8 +1,24 @@
 from fastapi import FastAPI
+from fastapi.routing import APIRoute
 
 app = FastAPI()
 
 
-@app.get("/items/", include_in_schema=False)
+@app.get("/items/")
 async def read_items():
     return [{"item_id": "Foo"}]
+
+
+def use_route_names_as_operation_ids(app: FastAPI) -> None:
+    """
+    Simplify operation IDs so that generated API clients have simpler function
+    names.
+
+    Should be called only after all routes have been added.
+    """
+    for route in app.routes:
+        if isinstance(route, APIRoute):
+            route.operation_id = route.name  # in this case, 'read_items'
+
+
+use_route_names_as_operation_ids(app)

docs/src/path_operation_advanced_configuration/tutorial003.py

@@ -0,0 +1,8 @@
+from fastapi import FastAPI
+
+app = FastAPI()
+
+
+@app.get("/items/", include_in_schema=False)
+async def read_items():
+    return [{"item_id": "Foo"}]

docs/src/path_operation_advanced_configuration/tutorial004.py

@@ -0,0 +1,30 @@
+from typing import Set
+
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+app = FastAPI()
+
+
+class Item(BaseModel):
+    name: str
+    description: str = None
+    price: float
+    tax: float = None
+    tags: Set[str] = []
+
+
+@app.post("/items/", response_model=Item, summary="Create an item")
+async def create_item(*, item: Item):
+    """
+    Create an item with all the information:
+
+    - **name**: each item must have a name
+    - **description**: a long description
+    - **price**: required
+    - **tax**: if the item doesn't have tax, you can omit this
+    - **tags**: a set of unique tag strings for this item
+    \f
+    :param item: User input.
+    """
+    return item

docs/src/response_directly/tutorial002.py

@@ -6,12 +6,11 @@ app = FastAPI()
 
 @app.get("/legacy/")
 def get_legacy_data():
-    data = """
-    <?xml version="1.0"?>
+    data = """<?xml version="1.0"?>
     <shampoo>
     <Header>
         Apply shampoo here.
-    <Header>
+    </Header>
     <Body>
         You'll have to use soap here.
     </Body>

docs/src/response_model/tutorial002.py

@@ -1,6 +1,5 @@
 from fastapi import FastAPI
-from pydantic import BaseModel
-from pydantic.types import EmailStr
+from pydantic import BaseModel, EmailStr
 
 app = FastAPI()
 

docs/src/response_model/tutorial003.py

@@ -1,6 +1,5 @@
 from fastapi import FastAPI
-from pydantic import BaseModel
-from pydantic.types import EmailStr
+from pydantic import BaseModel, EmailStr
 
 app = FastAPI()
 

docs/src/response_model/tutorial004.py

@@ -21,6 +21,6 @@ items = {
 }
 
 
-@app.get("/items/{item_id}", response_model=Item, response_model_skip_defaults=True)
+@app.get("/items/{item_id}", response_model=Item, response_model_exclude_unset=True)
 async def read_item(item_id: str):
     return items[item_id]

docs/src/sql_databases/sql_app/alt_main.py

@@ -0,0 +1,64 @@
+from typing import List
+
+from fastapi import Depends, FastAPI, HTTPException
+from sqlalchemy.orm import Session
+from starlette.requests import Request
+from starlette.responses import Response
+
+from . import crud, models, schemas
+from .database import SessionLocal, engine
+
+models.Base.metadata.create_all(bind=engine)
+
+app = FastAPI()
+
+
+@app.middleware("http")
+async def db_session_middleware(request: Request, call_next):
+    response = Response("Internal server error", status_code=500)
+    try:
+        request.state.db = SessionLocal()
+        response = await call_next(request)
+    finally:
+        request.state.db.close()
+    return response
+
+
+# Dependency
+def get_db(request: Request):
+    return request.state.db
+
+
+@app.post("/users/", response_model=schemas.User)
+def create_user(user: schemas.UserCreate, db: Session = Depends(get_db)):
+    db_user = crud.get_user_by_email(db, email=user.email)
+    if db_user:
+        raise HTTPException(status_code=400, detail="Email already registered")
+    return crud.create_user(db=db, user=user)
+
+
+@app.get("/users/", response_model=List[schemas.User])
+def read_users(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
+    users = crud.get_users(db, skip=skip, limit=limit)
+    return users
+
+
+@app.get("/users/{user_id}", response_model=schemas.User)
+def read_user(user_id: int, db: Session = Depends(get_db)):
+    db_user = crud.get_user(db, user_id=user_id)
+    if db_user is None:
+        raise HTTPException(status_code=404, detail="User not found")
+    return db_user
+
+
+@app.post("/users/{user_id}/items/", response_model=schemas.Item)
+def create_item_for_user(
+    user_id: int, item: schemas.ItemCreate, db: Session = Depends(get_db)
+):
+    return crud.create_user_item(db=db, item=item, user_id=user_id)
+
+
+@app.get("/items/", response_model=List[schemas.Item])
+def read_items(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
+    items = crud.get_items(db, skip=skip, limit=limit)
+    return items

docs/src/sql_databases/sql_app/main.py

@@ -2,8 +2,6 @@ from typing import List
 
 from fastapi import Depends, FastAPI, HTTPException
 from sqlalchemy.orm import Session
-from starlette.requests import Request
-from starlette.responses import Response
 
 from . import crud, models, schemas
 from .database import SessionLocal, engine
@@ -13,20 +11,13 @@ models.Base.metadata.create_all(bind=engine)
 app = FastAPI()
 
 
-@app.middleware("http")
-async def db_session_middleware(request: Request, call_next):
-    response = Response("Internal server error", status_code=500)
-    try:
-        request.state.db = SessionLocal()
-        response = await call_next(request)
-    finally:
-        request.state.db.close()
-    return response
-
-
 # Dependency
-def get_db(request: Request):
-    return request.state.db
+def get_db():
+    try:
+        db = SessionLocal()
+        yield db
+    finally:
+        db.close()
 
 
 @app.post("/users/", response_model=schemas.User)

docs/src/sql_databases_peewee/sql_app/crud.py

@@ -0,0 +1,30 @@
+from . import models, schemas
+
+
+def get_user(user_id: int):
+    return models.User.filter(models.User.id == user_id).first()
+
+
+def get_user_by_email(email: str):
+    return models.User.filter(models.User.email == email).first()
+
+
+def get_users(skip: int = 0, limit: int = 100):
+    return list(models.User.select().offset(skip).limit(limit))
+
+
+def create_user(user: schemas.UserCreate):
+    fake_hashed_password = user.password + "notreallyhashed"
+    db_user = models.User(email=user.email, hashed_password=fake_hashed_password)
+    db_user.save()
+    return db_user
+
+
+def get_items(skip: int = 0, limit: int = 100):
+    return list(models.Item.select().offset(skip).limit(limit))
+
+
+def create_user_item(item: schemas.ItemCreate, user_id: int):
+    db_item = models.Item(**item.dict(), owner_id=user_id)
+    db_item.save()
+    return db_item

docs/src/sql_databases_peewee/sql_app/database.py

@@ -0,0 +1,26 @@
+from contextvars import ContextVar
+
+import peewee
+
+DATABASE_NAME = "test.db"
+
+
+class PeeweeConnectionState(peewee._ConnectionState):
+    def __init__(self, **kwargs):
+        super().__setattr__("_state", {})
+        self._state["closed"] = ContextVar("closed", default=True)
+        self._state["conn"] = ContextVar("conn", default=None)
+        self._state["ctx"] = ContextVar("ctx", default=[])
+        self._state["transactions"] = ContextVar("transactions", default=[])
+        super().__init__(**kwargs)
+
+    def __setattr__(self, name, value):
+        self._state[name].set(value)
+
+    def __getattr__(self, name):
+        return self._state[name].get()
+
+
+db = peewee.SqliteDatabase(DATABASE_NAME, check_same_thread=False)
+
+db._state = PeeweeConnectionState()

docs/src/sql_databases_peewee/sql_app/main.py

@@ -0,0 +1,70 @@
+import time
+from typing import List
+
+from fastapi import Depends, FastAPI, HTTPException
+
+from . import crud, database, models, schemas
+
+database.db.connect()
+database.db.create_tables([models.User, models.Item])
+database.db.close()
+
+app = FastAPI()
+
+
+# Dependency
+def get_db():
+    try:
+        database.db.connect()
+        yield
+    finally:
+        if not database.db.is_closed():
+            database.db.close()
+
+
+@app.post("/users/", response_model=schemas.User, dependencies=[Depends(get_db)])
+def create_user(user: schemas.UserCreate):
+    db_user = crud.get_user_by_email(email=user.email)
+    if db_user:
+        raise HTTPException(status_code=400, detail="Email already registered")
+    return crud.create_user(user=user)
+
+
+@app.get("/users/", response_model=List[schemas.User], dependencies=[Depends(get_db)])
+def read_users(skip: int = 0, limit: int = 100):
+    users = crud.get_users(skip=skip, limit=limit)
+    return users
+
+
+@app.get(
+    "/users/{user_id}", response_model=schemas.User, dependencies=[Depends(get_db)]
+)
+def read_user(user_id: int):
+    db_user = crud.get_user(user_id=user_id)
+    if db_user is None:
+        raise HTTPException(status_code=404, detail="User not found")
+    return db_user
+
+
+@app.post(
+    "/users/{user_id}/items/",
+    response_model=schemas.Item,
+    dependencies=[Depends(get_db)],
+)
+def create_item_for_user(user_id: int, item: schemas.ItemCreate):
+    return crud.create_user_item(item=item, user_id=user_id)
+
+
+@app.get("/items/", response_model=List[schemas.Item], dependencies=[Depends(get_db)])
+def read_items(skip: int = 0, limit: int = 100):
+    items = crud.get_items(skip=skip, limit=limit)
+    return items
+
+
+@app.get(
+    "/slowusers/", response_model=List[schemas.User], dependencies=[Depends(get_db)]
+)
+def read_slow_users(skip: int = 0, limit: int = 100):
+    time.sleep(15)  # Fake long processing request
+    users = crud.get_users(skip=skip, limit=limit)
+    return users

docs/src/sql_databases_peewee/sql_app/models.py

@@ -0,0 +1,21 @@
+import peewee
+
+from .database import db
+
+
+class User(peewee.Model):
+    email = peewee.CharField(unique=True, index=True)
+    hashed_password = peewee.CharField()
+    is_active = peewee.BooleanField(default=True)
+
+    class Meta:
+        database = db
+
+
+class Item(peewee.Model):
+    title = peewee.CharField(index=True)
+    description = peewee.CharField(index=True)
+    owner = peewee.ForeignKeyField(User, backref="items")
+
+    class Meta:
+        database = db

docs/src/sql_databases_peewee/sql_app/schemas.py

@@ -0,0 +1,49 @@
+from typing import Any, List
+
+import peewee
+from pydantic import BaseModel
+from pydantic.utils import GetterDict
+
+
+class PeeweeGetterDict(GetterDict):
+    def get(self, key: Any, default: Any = None):
+        res = getattr(self._obj, key, default)
+        if isinstance(res, peewee.ModelSelect):
+            return list(res)
+        return res
+
+
+class ItemBase(BaseModel):
+    title: str
+    description: str = None
+
+
+class ItemCreate(ItemBase):
+    pass
+
+
+class Item(ItemBase):
+    id: int
+    owner_id: int
+
+    class Config:
+        orm_mode = True
+        getter_dict = PeeweeGetterDict
+
+
+class UserBase(BaseModel):
+    email: str
+
+
+class UserCreate(UserBase):
+    password: str
+
+
+class User(UserBase):
+    id: int
+    is_active: bool
+    items: List[Item] = []
+
+    class Config:
+        orm_mode = True
+        getter_dict = PeeweeGetterDict

docs/tutorial/additional-responses.md

@@ -174,6 +174,11 @@ For example, you can add an additional media type of `image/png`, declaring that
 !!! note
     Notice that you have to return the image using a `FileResponse` directly.
 
+!!! info
+    Unless you specify a different media type explicitly in your `responses` parameter, FastAPI will assume the response has the same media type as the main response class (default `application/json`).
+
+    But if you have specified a custom response class with `None` as its media type, FastAPI will use `application/json` for any additional response that has an associated model.
+
 ## Combining information
 
 You can also combine response information from multiple places, including the `response_model`, `status_code`, and `responses` parameters.

docs/tutorial/async-sql-databases.md

@@ -41,7 +41,7 @@ Later, for your production application, you might want to use a database server
 ```
 
 !!! tip
-    If you where connecting to a different database (e.g. PostgreSQL), you would need to change the `DATABASE_URL`.
+    If you were connecting to a different database (e.g. PostgreSQL), you would need to change the `DATABASE_URL`.
 
 ## Create the tables
 

docs/tutorial/bigger-applications.md

@@ -246,7 +246,7 @@ We can also add a list of `tags` that will be applied to all the *path operation
 
 And we can add predefined `responses` that will be included in all the *path operations* too.
 
-And we can add a list of `dependencies` that will be added to all the *path operations* in the router and will be executed/solved for each request made to them.
+And we can add a list of `dependencies` that will be added to all the *path operations* in the router and will be executed/solved for each request made to them. Note that, much like dependencies in *path operation decorators*, no value will be passed to your *path operation function*.
 
 ```Python hl_lines="8 9 10 14 15 16 17 18 19 20"
 {!./src/bigger_applications/app/main.py!}

docs/tutorial/body-fields.md

@@ -0,0 +1,62 @@
+The same way you can declare additional validation and metadata in path operation function parameters with `Query`, `Path` and `Body`, you can declare validation and metadata inside of Pydantic models using Pydantic's `Field`.
+
+## Import `Field`
+
+First, you have to import it:
+
+```Python hl_lines="2"
+{!./src/body_fields/tutorial001.py!}
+```
+
+!!! warning
+    Notice that `Field` is imported directly from `pydantic`, not from `fastapi` as are all the rest (`Query`, `Path`, `Body`, etc).
+
+
+## Declare model attributes
+
+You can then use `Field` with model attributes:
+
+```Python hl_lines="9 10"
+{!./src/body_fields/tutorial001.py!}
+```
+
+`Field` works the same way as `Query`, `Path` and `Body`, it has all the same parameters, etc.
+
+!!! note "Technical Details"
+    Actually, `Query`, `Path` and others you'll see next create objects of subclasses of a common `Param` class, which is itself a subclass of Pydantic's `FieldInfo` class.
+
+    And Pydantic's `Field` returns an instance of `FieldInfo` as well.
+
+    `Body` also returns objects of a subclass of `FieldInfo` directly. And there are others you will see later that are subclasses of the `Body` class.
+
+    Remember that when you import `Query`, `Path`, and others from `fastapi`, <a href="https://fastapi.tiangolo.com/tutorial/path-params-numeric-validations/#recap" target="_blank">those are actually functions that return classes of the same name</a>.
+
+!!! tip
+    Notice how each model's attribute with a type, default value and `Field` has the same structure as a path operation function's parameter, with `Field` instead of `Path`, `Query` and `Body`.
+
+## JSON Schema extras
+
+In `Field`, `Path`, `Query`, `Body` and others you'll see later, you can declare extra parameters apart from those described before.
+
+Those parameters will be added as-is to the output JSON Schema.
+
+If you know JSON Schema and want to add extra information apart from what we have discussed here, you can pass that as extra keyword arguments.
+
+!!! warning
+    Have in mind that extra parameters passed won't add any validation, only annotation, for documentation purposes.
+
+For example, you can use that functionality to pass a <a href="http://json-schema.org/latest/json-schema-validation.html#rfc.section.8.5" target="_blank">JSON Schema example</a> field to a body request JSON Schema:
+
+```Python hl_lines="20 21 22 23 24 25"
+{!./src/body_fields/tutorial002.py!}
+```
+
+And it would look in the `/docs` like this:
+
+<img src="/img/tutorial/body-fields/image01.png">
+
+## Recap
+
+You can use Pydantic's `Field` to declare extra validations and metadata for model attributes.
+
+You can also use the extra keyword arguments to pass additional JSON Schema metadata.

docs/tutorial/body-nested-models.md

@@ -118,7 +118,7 @@ Apart from normal singular types like `str`, `int`, `float`, etc. You can use mo
 
 To see all the options you have, checkout the docs for <a href="https://pydantic-docs.helpmanual.io/#exotic-types" target="_blank">Pydantic's exotic types</a>. You will see some examples in the next chapter.
 
-For example, as in the `Image` model we have a `url` field, we can declare it to be instead of a `str`, a Pydantic's `UrlStr`:
+For example, as in the `Image` model we have a `url` field, we can declare it to be instead of a `str`, a Pydantic's `HttpUrl`:
 
 ```Python hl_lines="4 10"
 {!./src/body_nested_models/tutorial005.py!}

docs/tutorial/body-schema.md

@@ -1,60 +0,0 @@
-The same way you can declare additional validation and metadata in path operation function parameters with `Query`, `Path` and `Body`, you can declare validation and metadata inside of Pydantic models using `Schema`.
-
-## Import Schema
-
-First, you have to import it:
-
-```Python hl_lines="2"
-{!./src/body_schema/tutorial001.py!}
-```
-
-!!! warning
-    Notice that `Schema` is imported directly from `pydantic`, not from `fastapi` as are all the rest (`Query`, `Path`, `Body`, etc).
-
-
-## Declare model attributes
-
-You can then use `Schema` with model attributes:
-
-```Python hl_lines="9 10"
-{!./src/body_schema/tutorial001.py!}
-```
-
-`Schema` works the same way as `Query`, `Path` and `Body`, it has all the same parameters, etc.
-
-!!! note "Technical Details"
-    Actually, `Query`, `Path` and others you'll see next are subclasses of a common `Param` which is itself a subclass of Pydantic's `Schema`.
-
-    `Body` is also a subclass of `Schema` directly. And there are others you will see later that are subclasses of `Body`.
-
-    But remember that when you import `Query`, `Path` and others from `fastapi`, <a href="https://fastapi.tiangolo.com/tutorial/path-params-numeric-validations/#recap" target="_blank">those are actually functions that return classes of the same name</a>.
-
-!!! tip
-    Notice how each model's attribute with a type, default value and `Schema` has the same structure as a path operation function's parameter, with `Schema` instead of `Path`, `Query` and `Body`.
-
-## Schema extras
-
-In `Schema`, `Path`, `Query`, `Body` and others you'll see later, you can declare extra parameters apart from those described before.
-
-Those parameters will be added as-is to the output JSON Schema.
-
-If you know JSON Schema and want to add extra information apart from what we have discussed here, you can pass that as extra keyword arguments.
-
-!!! warning
-    Have in mind that extra parameters passed won't add any validation, only annotation, for documentation purposes.
-
-For example, you can use that functionality to pass a <a href="http://json-schema.org/latest/json-schema-validation.html#rfc.section.8.5" target="_blank">JSON Schema example</a> field to a body request JSON Schema:
-
-```Python hl_lines="20 21 22 23 24 25"
-{!./src/body_schema/tutorial002.py!}
-```
-
-And it would look in the `/docs` like this:
-
-<img src="/img/tutorial/body-schema/image01.png">
-
-## Recap
-
-You can use Pydantic's `Schema` to declare extra validations and metadata for model attributes.
-
-You can also use the extra keyword arguments to pass additional JSON Schema metadata.

docs/tutorial/body-updates.md

@@ -41,15 +41,15 @@ This means that you can send only the data that you want to update, leaving the
 
     But this guide shows you, more or less, how they are intended to be used.
 
-### Using Pydantic's `skip_defaults` parameter
+### Using Pydantic's `exclude_unset` parameter
 
-If you want to receive partial updates, it's very useful to use the parameter `skip_defaults` in Pydantic's model's `.dict()`.
+If you want to receive partial updates, it's very useful to use the parameter `exclude_unset` in Pydantic's model's `.dict()`.
 
-Like `item.dict(skip_defaults=True)`.
+Like `item.dict(exclude_unset=True)`.
 
 That would generate a `dict` with only the data that was set when creating the `item` model, excluding default values.
 
-Then you can use this to generate a `dict` with only the data that was set, omitting default values:
+Then you can use this to generate a `dict` with only the data that was set (sent in the request), omitting default values:
 
 ```Python hl_lines="34"
 {!./src/body_updates/tutorial002.py!}
@@ -72,7 +72,7 @@ In summary, to apply partial updates you would:
 * (Optionally) use `PATCH` instead of `PUT`.
 * Retrieve the stored data.
 * Put that data in a Pydantic model.
-* Generate a `dict` without default values from the input model (using `skip_defaults`).
+* Generate a `dict` without default values from the input model (using `exclude_unset`).
     * This way you can update only the values actually set by the user, instead of overriding values already stored with default values in your model.
 * Create a copy of the stored model, updating it's attributes with the received partial updates (using the `update` parameter).
 * Convert the copied model to something that can be stored in your DB (for example, using the `jsonable_encoder`).

docs/tutorial/custom-request-and-route.md

@@ -0,0 +1,100 @@
+In some cases, you may want to override the logic used by the `Request` and `APIRoute` classes.
+
+In particular, this may be a good alternative to logic in a middleware.
+
+For example, if you want to read or manipulate the request body before it is processed by your application.
+
+!!! danger
+    This is an "advanced" feature.
+
+    If you are just starting with **FastAPI** you might want to skip this section.
+
+## Use cases
+
+Some use cases include:
+
+* Converting non-JSON request bodies to JSON (e.g. [`msgpack`](https://msgpack.org/index.html)).
+* Decompressing gzip-compressed request bodies.
+* Automatically logging all request bodies.
+* Accessing the request body in an exception handler.
+
+## Handling custom request body encodings
+
+Let's see how to make use of a custom `Request` subclass to decompress gzip requests.
+
+And an `APIRoute` subclass to use that custom request class.
+
+### Create a custom `GzipRequest` class
+
+First, we create a `GzipRequest` class, which will overwrite the `Request.body()` method to decompress the body in the presence of an appropriate header.
+
+If there's no `gzip` in the header, it will not try to decompress the body.
+
+That way, the same route class can handle gzip compressed or uncompressed requests.
+
+```Python hl_lines="10 11 12 13 14 15 16 17"
+{!./src/custom_request_and_route/tutorial001.py!}
+```
+
+### Create a custom `GzipRoute` class
+
+Next, we create a custom subclass of `fastapi.routing.APIRoute` that will make use of the `GzipRequest`.
+
+This time, it will overwrite the method `APIRoute.get_route_handler()`.
+
+This method returns a function. And that function is what will receive a request and return a response.
+
+Here we use it to create a `GzipRequest` from the original request.
+
+```Python hl_lines="20 21 22 23 24 25 26 27 28"
+{!./src/custom_request_and_route/tutorial001.py!}
+```
+
+!!! note "Technical Details"
+    A `Request` has a `request.scope` attribute, that's just a Python `dict` containing the metadata related to the request.
+
+    A `Request` also has a `request.receive`, that's a function to "receive" the body of the request.
+
+    The `scope` `dict` and `receive` function are both part of the ASGI specification.
+
+    And those two things, `scope` and `receive`, are what is needed to create a new `Request` instance.
+
+    To learn more about the `Request` check <a href="https://www.starlette.io/requests/" target="_blank">Starlette's docs about Requests</a>.
+
+The only thing the function returned by `GzipRequest.get_route_handler` does differently is convert the `Request` to a `GzipRequest`.
+
+Doing this, our `GzipRequest` will take care of decompressing the data (if necessary) before passing it to our *path operations*.
+
+After that, all of the processing logic is the same.
+
+But because of our changes in `GzipRequest.body`, the request body will be automatically decompressed when it is loaded by **FastAPI** when needed.
+
+## Accessing the request body in an exception handler
+
+We can also use this same approach to access the request body in an exception handler.
+
+All we need to do is handle the request inside a `try`/`except` block:
+
+```Python hl_lines="15 17"
+{!./src/custom_request_and_route/tutorial002.py!}
+```
+
+If an exception occurs, the`Request` instance will still be in scope, so we can read and make use of the request body when handling the error:
+
+```Python hl_lines="18 19 20"
+{!./src/custom_request_and_route/tutorial002.py!}
+```
+
+## Custom `APIRoute` class in a router
+
+You can also set the `route_class` parameter of an `APIRouter`:
+
+```Python hl_lines="25"
+{!./src/custom_request_and_route/tutorial003.py!}
+```
+
+In this example, the *path operations* under the `router` will use the custom `TimedRoute` class, and will have an extra `X-Response-Time` header in the response with the time it took to generate the response:
+
+```Python hl_lines="15 16 17 18 19"
+{!./src/custom_request_and_route/tutorial003.py!}
+```

docs/tutorial/custom-response.md

@@ -15,6 +15,9 @@ The contents that you return from your *path operation function* will be put ins
 
 And if that `Response` has a JSON media type (`application/json`), like is the case with the `JSONResponse` and `UJSONResponse`, the data you return will be automatically converted (and filtered) with any Pydantic `response_model` that you declared in the *path operation decorator*.
 
+!!! note
+    If you use a response class with no media type, FastAPI will expect your response to have no content, so it will not document the response format in its generated OpenAPI docs.
+
 ## Use `UJSONResponse`
 
 For example, if you are squeezing performance, you can install and use `ujson` and set the response to be Starlette's `UJSONResponse`.

docs/tutorial/dependencies/advanced-dependencies.md

@@ -1,4 +1,4 @@
-!!! danger
+!!! warning
     This is, more or less, an "advanced" chapter.
     
     If you are just starting with **FastAPI** you might want to skip this chapter and come back to it later.
@@ -22,7 +22,7 @@ Not the class itself (which is already a callable), but an instance of that clas
 To do that, we declare a method `__call__`:
 
 ```Python hl_lines="10"
-{!./src/dependencies/tutorial007.py!}
+{!./src/dependencies/tutorial011.py!}
 ```
 
 In this case, this `__call__` is what **FastAPI** will use to check for additional parameters and sub-dependencies, and this is what will be called to pass a value to the parameter in your *path operation function* later.
@@ -32,7 +32,7 @@ In this case, this `__call__` is what **FastAPI** will use to check for addition
 And now, we can use `__init__` to declare the parameters of the instance that we can use to "parameterize" the dependency:
 
 ```Python hl_lines="7"
-{!./src/dependencies/tutorial007.py!}
+{!./src/dependencies/tutorial011.py!}
 ```
 
 In this case, **FastAPI** won't ever touch or care about `__init__`, we will use it directly in our code.
@@ -42,7 +42,7 @@ In this case, **FastAPI** won't ever touch or care about `__init__`, we will use
 We could create an instance of this class with:
 
 ```Python hl_lines="16"
-{!./src/dependencies/tutorial007.py!}
+{!./src/dependencies/tutorial011.py!}
 ```
 
 And that way we are able to "parameterize" our dependency, that now has `"bar"` inside of it, as the attribute `checker.fixed_content`.
@@ -60,7 +60,7 @@ checker(q="somequery")
 ...and pass whatever that returns as the value of the dependency in our path operation function as the parameter `fixed_content_included`:
 
 ```Python hl_lines="20"
-{!./src/dependencies/tutorial007.py!}
+{!./src/dependencies/tutorial011.py!}
 ```
 
 !!! tip

docs/tutorial/dependencies/classes-as-dependencies.md

@@ -2,7 +2,7 @@ Before diving deeper into the **Dependency Injection** system, let's upgrade the
 
 ## A `dict` from the previous example
 
-In the previous example, we where returning a `dict` from our dependency ("dependable"):
+In the previous example, we are returning a `dict` from our dependency ("dependable"):
 
 ```Python hl_lines="7"
 {!./src/dependencies/tutorial001.py!}

docs/tutorial/dependencies/dependencies-with-yield.md

@@ -0,0 +1,153 @@
+# Dependencies with `yield`
+
+FastAPI supports dependencies that do some <abbr title='sometimes also called "exit", "cleanup", "teardown", "close", "context managers", ...'>extra steps after finishing</abbr>.
+
+To do this, use `yield` instead of `return`, and write the extra steps after.
+
+!!! tip
+    Make sure to use `yield` one single time.
+
+!!! info
+    For this to work, you need to use **Python 3.7** or above, or in **Python 3.6**, install the "backports":
+
+    ```bash
+    pip install async-exit-stack async-generator
+    ```
+
+    This installs <a href="https://github.com/sorcio/async_exit_stack" target="_blank">async-exit-stack</a> and <a href="https://github.com/python-trio/async_generator" target="_blank">async-generator</a>.
+
+!!! note "Technical Details"
+    Any function that is valid to use with:
+
+    * <a href="https://docs.python.org/3/library/contextlib.html#contextlib.contextmanager" target="_blank">`@contextlib.contextmanager`</a> or 
+    * <a href="https://docs.python.org/3/library/contextlib.html#contextlib.asynccontextmanager" target="_blank">`@contextlib.asynccontextmanager`</a>
+
+    would be valid to use as a **FastAPI** dependency.
+
+    In fact, FastAPI uses those two decorators internally.
+
+## A database dependency with `yield`
+
+For example, you could use this to create a database session and close it after finishing.
+
+Only the code prior to and including the `yield` statement is executed before sending a response:
+
+```Python hl_lines="2 3 4"
+{!./src/dependencies/tutorial007.py!}
+```
+
+The yielded value is what is injected into *path operations* and other dependencies:
+
+```Python hl_lines="4"
+{!./src/dependencies/tutorial007.py!}
+```
+
+The code following the `yield` statement is executed after the response has been delivered:
+
+```Python hl_lines="5 6"
+{!./src/dependencies/tutorial007.py!}
+```
+
+!!! tip
+    You can use `async` or normal functions.
+
+    **FastAPI** will do the right thing with each, the same as with normal dependencies.
+
+## A dependency with `yield` and `try`
+
+If you use a `try` block in a dependency with `yield`, you'll receive any exception that was thrown when using the dependency.
+
+For example, if some code at some point in the middle, in another dependency or in a *path operation*, made a database transaction "rollback" or create any other error, you will receive the exception in your dependency.
+
+So, you can look for that specific exception inside the dependency with `except SomeException`.
+
+In the same way, you can use `finally` to make sure the exit steps are executed, no matter if there was an exception or not.
+
+```Python hl_lines="3 5"
+{!./src/dependencies/tutorial007.py!}
+```
+
+## Sub-dependencies with `yield`
+
+You can have sub-dependencies and "trees" of sub-dependencies of any size and shape, and any or all of them can use `yield`.
+
+**FastAPI** will make sure that the "exit code" in each dependency with `yield` is run in the correct order.
+
+For example, `dependency_c` can have a dependency on `dependency_b`, and `dependency_b` on `dependency_a`:
+
+```Python hl_lines="4 12 20"
+{!./src/dependencies/tutorial008.py!}
+```
+
+And all of them can use `yield`.
+
+In this case `dependency_c`, to execute its exit code, needs the value from `dependency_b` (here named `dep_b`) to still be available.
+
+And, in turn, `dependency_b` needs the value from `dependency_a` (here named `dep_a`) to be available for its exit code.
+
+```Python hl_lines="16 17 24 25"
+{!./src/dependencies/tutorial008.py!}
+```
+
+The same way, you could have dependencies with `yield` and `return` mixed.
+
+And you could have a single dependency that requires several other dependencies with `yield`, etc.
+
+You can have any combinations of dependencies that you want.
+
+**FastAPI** will make sure everything is run in the correct order.
+
+!!! note "Technical Details"
+    This works thanks to Python's <a href="https://docs.python.org/3/library/contextlib.html" target="_blank">Context Managers</a>.
+
+    **FastAPI** uses them internally to achieve this.
+
+## Context Managers
+
+### What are "Context Managers"
+
+"Context Managers" are any of those Python objects that you can use in a `with` statement.
+
+For example, <a href="https://docs.python.org/3/tutorial/inputoutput.html#reading-and-writing-files" target="_blank">you can use `with` to read a file</a>:
+
+```Python
+with open("./somefile.txt") as f:
+    contents = f.read()
+    print(contents)
+```
+
+Underneath, the `open("./somefile.txt")` returns an object that is a called a "Context Manager".
+
+When the `with` block finishes, it makes sure to close the file, even if there were exceptions.
+
+When you create a dependency with `yield`, **FastAPI** will internally convert it to a context manager, and combine it with some other related tools.
+
+### Using context managers in dependencies with `yield`
+
+!!! warning
+    This is, more or less, an "advanced" idea.
+
+    If you are just starting with **FastAPI** you might want to skip it for now.
+
+In Python, you can create context managers by <a href="https://docs.python.org/3/reference/datamodel.html#context-managers" target="_blank">creating a class with two methods: `__enter__()` and `__exit__()`</a>.
+
+You can also use them with **FastAPI** dependencies with `yield` by using
+`with` or `async with` statements inside of the dependency function:
+
+```Python hl_lines="1 2 3 4 5 6 7 8 9 13"
+{!./src/dependencies/tutorial010.py!}
+```
+
+!!! tip
+    Another way to create a context manager is with:
+
+    * <a href="https://docs.python.org/3/library/contextlib.html#contextlib.contextmanager" target="_blank">`@contextlib.contextmanager`</a> or 
+    * <a href="https://docs.python.org/3/library/contextlib.html#contextlib.asynccontextmanager" target="_blank">`@contextlib.asynccontextmanager`</a>
+
+    using them to decorate a function with a single `yield`.
+
+    That's what **FastAPI** uses internally for dependencies with `yield`.
+
+    But you don't have to use the decorators for FastAPI dependencies (and you shouldn't).
+
+    FastAPI will do it for you internally.

docs/tutorial/extending-openapi.md

@@ -88,3 +88,156 @@ Now you can replace the `.openapi()` method with your new function.
 Once you go to <a href="http://127.0.0.1:8000/redoc" target="_blank">http://127.0.0.1:8000/redoc</a> you will see that you are using your custom logo (in this example, **FastAPI**'s logo):
 
 <img src="/img/tutorial/extending-openapi/image01.png">
+
+## Self-hosting JavaScript and CSS for docs
+
+The API docs use **Swagger UI** and **ReDoc**, and each of those need some JavaScript and CSS files.
+
+By default, those files are served from a <abbr title="Content Delivery Network: A service, normally composed of several servers, that provides static files, like JavaScript and CSS. It's commonly used to serve those files from the server closer to the client, improving performance.">CDN</abbr>.
+
+But it's possible to customize it, you can set a specific CDN, or serve the files yourself.
+
+That's useful, for example, if you need your app to keep working even while offline, without open Internet access, or in a local network.
+
+Here you'll see how to serve those files yourself, in the same FastAPI app, and configure the docs to use them.
+
+### Project file structure
+
+Let's say your project file structure looks like this:
+
+```
+.
+├── app
+│   ├── __init__.py
+│   ├── main.py
+```
+
+Now create a directory to store those static files.
+
+Your new file structure could look like this:
+
+```
+.
+├── app
+│   ├── __init__.py
+│   ├── main.py
+└── static/
+```
+
+### Download the files
+
+Download the static files needed for the docs and put them on that `static/` directory.
+
+You can probably right-click each link and select an option similar to `Save link as...`.
+
+**Swagger UI** uses the files:
+
+* <a href="https://cdn.jsdelivr.net/npm/swagger-ui-dist@3/swagger-ui-bundle.js">`swagger-ui-bundle.js`</a>
+* <a href="https://cdn.jsdelivr.net/npm/swagger-ui-dist@3/swagger-ui.css" target="_blank">`swagger-ui.css`</a>
+
+And **ReDoc** uses the file:
+
+* <a href="https://cdn.jsdelivr.net/npm/redoc@next/bundles/redoc.standalone.js" target="_blank">`redoc.standalone.js`</a>
+
+After that, your file structure could look like:
+
+```
+.
+├── app
+│   ├── __init__.py
+│   ├── main.py
+└── static
+    ├── redoc.standalone.js
+    ├── swagger-ui-bundle.js
+    └── swagger-ui.css
+```
+
+### Install `aiofiles`
+
+Now you need to install `aiofiles`:
+
+```bash
+pip install aiofiles
+```
+
+### Serve the static files
+
+* Import `StaticFiles` from Starlette.
+* "Mount" it the same way you would <a href="https://fastapi.tiangolo.com/tutorial/sub-applications-proxy/" target="_blank">mount a Sub-Application</a>.
+
+```Python hl_lines="7 11"
+{!./src/extending_openapi/tutorial002.py!}
+```
+
+### Test the static files
+
+Start your application and go to <a href="http://127.0.0.1:8000/static/redoc.standalone.js" target="_blank">http://127.0.0.1:8000/static/redoc.standalone.js</a>.
+
+You should see a very long JavaScript file for **ReDoc**.
+
+It could start with something like:
+
+```JavaScript
+/*!
+ * ReDoc - OpenAPI/Swagger-generated API Reference Documentation
+ * -------------------------------------------------------------
+ *   Version: "2.0.0-rc.18"
+ *   Repo: https://github.com/Redocly/redoc
+ */
+!function(e,t){"object"==typeof exports&&"object"==typeof m
+
+...
+```
+
+That confirms that you are being able to serve static files from your app, and that you placed the static files for the docs in the correct place.
+
+Now we can configure the app to use those static files for the docs.
+
+### Disable the automatic docs
+
+The first step is to disable the automatic docs, as those use the CDN by default.
+
+To disable them, set their URLs to `None` when creating your `FastAPI` app:
+
+```Python hl_lines="9"
+{!./src/extending_openapi/tutorial002.py!}
+```
+
+### Include the custom docs
+
+Now you can create the *path operations* for the custom docs.
+
+You can re-use FastAPI's internal functions to create the HTML pages for the docs, and pass them the needed arguments:
+
+* `openapi_url`: the URL where the HTML page for the docs can get the OpenAPI schema for your API. You can use here the attribute `app.openapi_url`.
+* `title`: the title of your API.
+* `oauth2_redirect_url`: you can use `app.swagger_ui_oauth2_redirect_url` here to use the default.
+* `swagger_js_url`: the URL where the HTML for your Swagger UI docs can get the **JavaScript** file. This is the one that your own app is now serving.
+* `swagger_css_url`: the URL where the HTML for your Swagger UI docs can get the **CSS** file. This is the one that your own app is now serving.
+
+And similarly for ReDoc...
+
+```Python hl_lines="2 3 4 5 6   14 15 16 17 18 19 20 21 22    25 26 27   30 31 32 33 34 35 36"
+{!./src/extending_openapi/tutorial002.py!}
+```
+
+!!! tip
+    The *path operation* for `swagger_ui_redirect` is a helper for when you use OAuth2.
+
+    If you integrate your API with an OAuth2 provider, you will be able to authenticate and come back to the API docs with the acquired credentials. And interact with it using the real OAuth2 authentication.
+
+    Swagger UI will handle it behind the scenes for you, but it needs this "redirect" helper.
+
+### Create a *path operation* to test it
+
+Now, to be able to test that everything works, create a path operation:
+
+```Python hl_lines="39 40 41"
+{!./src/extending_openapi/tutorial002.py!}
+```
+
+### Test it
+
+Now, you should be able to disconnect your WiFi, go to your docs at <a href="http://127.0.0.1:8000/docs" target="_blank">http://127.0.0.1:8000/docs</a>, and reload the page.
+
+And even without Internet, you would be able to see the docs for your API and interact with it.

docs/tutorial/extra-models.md

@@ -15,7 +15,7 @@ This is especially the case for user models, because:
 
 Here's a general idea of how the models could look like with their password fields and the places where they are used:
 
-```Python hl_lines="8 10 15 21 23 32 34 39 40"
+```Python hl_lines="7 9  14   20 22  27 28  31 32 33  38 39"
 {!./src/extra_models/tutorial001.py!}
 ```
 
@@ -148,7 +148,7 @@ All the data conversion, validation, documentation, etc. will still work as norm
 
 That way, we can declare just the differences between the models (with plaintext `password`, with `hashed_password` and without password):
 
-```Python hl_lines="8 14 15 18 19 22 23"
+```Python hl_lines="7  13 14  17 18  21 22"
 {!./src/extra_models/tutorial002.py!}
 ```
 

docs/tutorial/first-steps.md

@@ -37,7 +37,7 @@ Open your browser at <a href="http://127.0.0.1:8000" target="_blank">http://127.
 You will see the JSON response as:
 
 ```JSON
-{"hello": "world"}
+{"message": "Hello World"}
 ```
 
 ### Interactive API docs

docs/tutorial/handling-errors.md

@@ -4,9 +4,9 @@ This client could be a browser with a frontend, the code from someone else, an I
 
 You could need to tell that client that:
 
-* He doesn't have enough privileges for that operation.
-* He doesn't have access to that resource.
-* The item he was trying to access doesn't exist.
+* The client doesn't have enough privileges for that operation.
+* The client doesn't have access to that resource.
+* The item the client was trying to access doesn't exist.
 * etc.
 
 In these cases, you would normally return an **HTTP status code** in the range of **400** (from 400 to 499).

docs/tutorial/openapi-callbacks.md

@@ -0,0 +1,186 @@
+You could create an API with a *path operation* that could trigger a request to an *external API* created by someone else (probably the same developer that would be *using* your API).
+
+The process that happens when your API app calls the *external API* is named a "callback". Because the software that the external developer wrote sends a request to your API and then your API *calls back*, sending a request to an *external API* (that was probably created by the same developer).
+
+In this case, you could want to document how that external API *should* look like. What *path operation* it should have, what body it should expect, what response it should return, etc.
+
+## An app with callbacks
+
+Let's see all this with an example.
+
+Imagine you develop an app that allows creating invoices.
+
+These invoices will have an `id`, `title` (optional), `customer`, and `total`.
+
+The user of your API (an external developer) will create an invoice in your API with a POST request.
+
+Then your API will (let's imagine):
+
+* Send the invoice to some customer of the external developer.
+* Collect the money.
+* Send a notification back to the API user (the external developer).
+    * This will be done by sending a POST request (from *your API*) to some *external API* provided by that external developer (this is the "callback").
+
+## The normal **FastAPI** app
+
+Let's first see how the normal API app would look like before adding the callback.
+
+It will have a *path operation* that will receive an `Invoice` body, and a query parameter `callback_url` that will contain the URL for the callback.
+
+This part is pretty normal, most of the code is probably already familiar to you:
+
+```Python hl_lines="8 9 10 11 12  34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53"
+{!./src/openapi_callbacks/tutorial001.py!}
+```
+
+!!! tip
+    The `callback_url` query parameter uses a Pydantic <a href="https://pydantic-docs.helpmanual.io/usage/types/#urls" target="_blank">URL</a> type.
+
+The only new thing is the `callbacks=messages_callback_router.routes` as an argument to the *path operation decorator*. We'll see what that is next.
+
+## Documenting the callback
+
+The actual callback code will depend heavily on your own API app.
+
+And it will probably vary a lot from one app to the next.
+
+It could be just one or two lines of code, like:
+
+```Python
+callback_url = "https://example.com/api/v1/invoices/events/"
+requests.post(callback_url, json={"description": "Invoice paid", "paid": True})
+```
+
+But possibly the most important part of the callback is making sure that your API user (the external developer) implements the *external API* correctly, according to the data that *your API* is going to send in the request body of the callback, etc.
+
+So, what we will do next is add the code to document how that *external API* should look like to receive the callback from *your API*.
+
+That documentation will show up in the Swagger UI at `/docs` in your API, and it will let external developers know how to build the *external API*.
+
+This example doesn't implement the callback itself (that could be just a line of code), only the documentation part.
+
+!!! tip
+    The actual callback is just an HTTP request.
+
+    When implementing the callback yourself, you could use something like <a href="https://www.encode.io/httpx/" target="_blank">HTTPX</a> or <a href="https://requests.readthedocs.io/" target="_blank">Requests</a>.
+
+## Write the callback documentation code
+
+This code won't be executed in your app, we only need it to *document* how that *external API* should look like.
+
+But, you already know how to easily create automatic documentation for an API with **FastAPI**.
+
+So we are going to use that same knowledge to document how the *external API* should look like... by creating the *path operation(s)* that the external API should implement (the ones your API will call).
+
+!!! tip
+    When writing the code to document a callback, it might be useful to imagine that you are that *external developer*. And that you are currently implementing the *external API*, not *your API*.
+
+    Temporarily adopting this point of view (of the *external developer*) can help you feel like it's more obvious where to put the parameters, the Pydantic model for the body, for the response, etc. for that *external API*.
+
+### Create a callback `APIRouter`
+
+First create a new `APIRouter` that will contain one or more callbacks.
+
+This router will never be added to an actual `FastAPI` app (i.e. it will never be passed to `app.include_router(...)`).
+
+Because of that, you need to declare what will be the `default_response_class`, and set it to `JSONResponse`.
+
+!!! Note "Technical Details"
+    The `response_class` is normally set by the `FastAPI` app during the call to `app.include_router(some_router)`.
+
+    But as we are never calling `app.include_router(some_router)`, we need to set the `default_response_class` during creation of the `APIRouter`.
+
+```Python hl_lines="3 24"
+{!./src/openapi_callbacks/tutorial001.py!}
+```
+
+### Create the callback *path operation*
+
+To create the callback *path operation* use the same `APIRouter` you created above.
+
+It should look just like a normal FastAPI *path operation*:
+
+* It should probably have a declaration of the body it should receive, e.g. `body: InvoiceEvent`.
+* And it could also have a declaration of the response it should return, e.g. `response_model=InvoiceEventReceived`.
+
+```Python hl_lines="15 16 17  20 21  27 28 29 30 31"
+{!./src/openapi_callbacks/tutorial001.py!}
+```
+
+There are 2 main differences from a normal *path operation*:
+
+* It doesn't need to have any actual code, because your app will never call this code. It's only used to document the *external API*. So, the function could just have `pass`.
+* The *path* can contain an <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#key-expression" target="_blank">OpenAPI 3 expression</a> (see more below) where it can use variables with parameters and parts of the original request sent to *your API*.
+
+### The callback path expression
+
+The callback *path* can have an <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#key-expression" target="_blank">OpenAPI 3 expression</a> that can contain parts of the original request sent to *your API*.
+
+In this case, it's the `str`:
+
+```Python
+"{$callback_url}/invoices/{$request.body.id}"
+```
+
+So, if your API user (the external developer) sends a request to *your API* to:
+
+```
+https://yourapi.com/invoices/?callback_url=https://www.external.org/events
+```
+
+with a JSON body of:
+
+```JSON
+{
+    "id": "2expen51ve",
+    "customer": "Mr. Richie Rich",
+    "total": "9999"
+}
+```
+
+Then *your API* will process the invoice, and at some point later, send a callback request to the `callback_url` (the *external API*):
+
+```
+https://www.external.org/events/invoices/2expen51ve
+```
+
+with a JSON body containing something like:
+
+```JSON
+{
+    "description": "Payment celebration",
+    "paid": true
+}
+```
+
+and it would expect a response from that *external API* with a JSON body like:
+
+```JSON
+{
+    "ok": true
+}
+```
+
+!!! tip
+    Notice how the callback URL used contains the URL received as a query parameter in `callback_url` (`https://www.external.org/events`) and also the invoice `id` from inside of the JSON body (`2expen51ve`).
+
+### Add the callback router
+
+At this point you have the *callback path operation(s)* needed (the one(s) that the *external developer*  should implement in the *external API*) in the callback router you created above.
+
+Now use the parameter `callbacks` in *your API's path operation decorator* to pass the attribute `.routes` (that's actually just a `list` of routes/*path operations*) from that callback router:
+
+```Python hl_lines="34"
+{!./src/openapi_callbacks/tutorial001.py!}
+```
+
+!!! tip
+    Notice that you are not passing the router itself (`invoices_callback_router`) to `callback=`, but the attribute `.routes`, as in `invoices_callback_router.routes`.
+
+### Check the docs
+
+Now you can start your app with Uvicorn and go to <a href="http://127.0.0.1:8000/docs" target="_blank">http://127.0.0.1:8000/docs</a>.
+
+You will see your docs including a "Callback" section for your *path operation* that shows how the *external API* should look like:
+
+<img src="/img/tutorial/openapi-callbacks/image01.png">

docs/tutorial/path-operation-advanced-configuration.md

@@ -11,10 +11,40 @@ You would have to make sure that it is unique for each operation.
 {!./src/path_operation_advanced_configuration/tutorial001.py!}
 ```
 
+### Using the *path operation function* name as the operationId
+
+If you want to use your APIs' function names as `operationId`s, you can iterate over all of them and override each *path operation's* `operation_id` using their `APIRoute.name`.
+
+You should do it after adding all your *path operations*.
+
+```Python hl_lines="2 12 13 14 15 16 17 18 19 20 21 24"
+{!./src/path_operation_advanced_configuration/tutorial002.py!}
+```
+
+!!! tip
+    If you manually call `app.openapi()`, you should update the `operationId`s before that.
+
+!!! warning
+    If you do this, you have to make sure each one of your *path operation functions* has a unique name.
+
+    Even if they are in different modules (Python files).
+
 ## Exclude from OpenAPI
 
 To exclude a path operation from the generated OpenAPI schema (and thus, from the automatic documentation systems), use the parameter `include_in_schema` and set it to `False`;
 
 ```Python hl_lines="6"
-{!./src/path_operation_advanced_configuration/tutorial002.py!}
+{!./src/path_operation_advanced_configuration/tutorial003.py!}
+```
+
+## Advanced description from docstring
+
+You can limit the lines used from the docstring of a *path operation function* for OpenAPI.
+
+Adding an `\f` (an escaped "form feed" character) causes **FastAPI** to truncate the output used for OpenAPI at this point.
+
+It won't show up in the documentation, but other tools (such as Sphinx) will be able to use the rest.
+
+```Python hl_lines="19 20 21 22 23 24 25 26 27 28 29"
+{!./src/path_operation_advanced_configuration/tutorial004.py!}
 ```

docs/tutorial/request-files.md

@@ -1,5 +1,12 @@
 You can define files to be uploaded by the client using `File`.
 
+!!! info
+    To receive uploaded files, first install [`python-multipart`](https://andrew-d.github.io/python-multipart/).
+
+    E.g. `pip install python-multipart`.
+
+    This is because uploaded files are sent as "form data".
+
 ## Import `File`
 
 Import `File` and `UploadFile` from `fastapi`:

docs/tutorial/request-forms-and-files.md

@@ -1,5 +1,10 @@
 You can define files and form fields at the same time using `File` and `Form`.
 
+!!! info
+    To receive uploaded files and/or form data, first install [`python-multipart`](https://andrew-d.github.io/python-multipart/).
+
+    E.g. `pip install python-multipart`.
+
 ## Import `File` and `Form`
 
 ```Python hl_lines="1"

docs/tutorial/request-forms.md

@@ -1,5 +1,10 @@
 When you need to receive form fields instead of JSON, you can use `Form`.
 
+!!! info
+    To use forms, first install [`python-multipart`](https://andrew-d.github.io/python-multipart/).
+
+    E.g. `pip install python-multipart`.
+
 ## Import `Form`
 
 Import `Form` from `fastapi`:

docs/tutorial/response-model.md

@@ -33,13 +33,13 @@ But most importantly:
 
 Here we are declaring a `UserIn` model, it will contain a plaintext password:
 
-```Python hl_lines="8 10"
+```Python hl_lines="7 9"
 {!./src/response_model/tutorial002.py!}
 ```
 
 And we are using this model to declare our input and the same model to declare our output:
 
-```Python hl_lines="16 17"
+```Python hl_lines="15 16"
 {!./src/response_model/tutorial002.py!}
 ```
 
@@ -56,19 +56,19 @@ But if we use the same model for another path operation, we could be sending our
 
 We can instead create an input model with the plaintext password and an output model without it:
 
-```Python hl_lines="8 10 15"
+```Python hl_lines="7 9 14"
 {!./src/response_model/tutorial003.py!}
 ```
 
 Here, even though our path operation function is returning the same input user that contains the password:
 
-```Python hl_lines="23"
+```Python hl_lines="22"
 {!./src/response_model/tutorial003.py!}
 ```
 
 ...we declared the `response_model` to be our model `UserOut`, that doesn't include the password:
 
-```Python hl_lines="21"
+```Python hl_lines="20"
 {!./src/response_model/tutorial003.py!}
 ```
 
@@ -100,15 +100,15 @@ but you might want to omit them from the result if they were not actually stored
 
 For example, if you have models with many optional attributes in a NoSQL database, but you don't want to send very long JSON responses full of default values.
 
-### Use the `response_model_skip_defaults` parameter
+### Use the `response_model_exclude_unset` parameter
 
-You can set the *path operation decorator* parameter `response_model_skip_defaults=True`:
+You can set the *path operation decorator* parameter `response_model_exclude_unset=True`:
 
 ```Python hl_lines="24"
 {!./src/response_model/tutorial004.py!}
 ```
 
-and those default values won't be included in the response.
+and those default values won't be included in the response, only the values actually set.
 
 So, if you send a request to that *path operation* for the item with ID `foo`, the response (not including default values) will be:
 
@@ -120,7 +120,7 @@ So, if you send a request to that *path operation* for the item with ID `foo`, t
 ```
 
 !!! info
-    FastAPI uses Pydantic model's `.dict()` with <a href="https://pydantic-docs.helpmanual.io/#copying" target="_blank">its `skip_defaults` parameter</a> to achieve this.
+    FastAPI uses Pydantic model's `.dict()` with <a href="https://pydantic-docs.helpmanual.io/usage/exporting_models/#modeldict" target="_blank">its `exclude_unset` parameter</a> to achieve this.
 
 #### Data with values for fields with defaults
 
@@ -194,4 +194,4 @@ If you forget to use a `set` and use a `list` or `tuple` instead, FastAPI will s
 
 Use the path operation decorator's parameter `response_model` to define response models and especially to ensure private data is filtered out.
 
-Use `response_model_skip_defaults` to return only the values explicitly set.
+Use `response_model_exclude_unset` to return only the values explicitly set.

docs/tutorial/response-status-code.md

@@ -22,6 +22,10 @@ It will:
 
 <img src="/img/tutorial/response-status-code/image01.png">
 
+!!! note
+    Some response codes (see the next section) indicate that the response does not have a body.
+
+    FastAPI knows this, and will produce OpenAPI docs that state there is no response body.
 
 ## About HTTP status codes
 
@@ -34,11 +38,12 @@ These status codes have a name associated to recognize them, but the important p
 
 In short:
 
-* `100` and above are for "Information". You rarely use them directly.
+* `100` and above are for "Information". You rarely use them directly.  Responses with these status codes cannot have a body.
 * **`200`** and above are for "Successful" responses. These are the ones you would use the most.
     * `200` is the default status code, which means everything was "OK".
     * Another example would be `201`, "Created". It is commonly used after creating a new record in the database.
-* `300` and above are for "Redirection". 
+    * A special case is `204`, "No Content".  This response is used when there is no content to return to the client, and so the response must not have a body.
+* **`300`** and above are for "Redirection".  Responses with these status codes may or may not have a body, except for `304`, "Not Modified", which must not have one.
 * **`400`** and above are for "Client error" responses. These are the second type you would probably use the most.
     * An example is `404`, for a "Not Found" response.
     * For generic errors from the client, you can just use `400`.

docs/tutorial/security/first-steps.md

@@ -24,6 +24,13 @@ Copy the example in a file `main.py`:
 
 ## Run it
 
+!!! info
+    First install [`python-multipart`](https://andrew-d.github.io/python-multipart/).
+
+    E.g. `pip install python-multipart`.
+
+    This is because **OAuth2** uses "form data" for sending the `username` and `password`.
+
 Run the example with:
 
 ```bash

docs/tutorial/security/http-basic-auth.md

@@ -12,8 +12,8 @@ Then, when you type that username and password, the browser sends them in the he
 
 ## Simple HTTP Basic Auth
 
-* Import `HTTPBAsic` and `HTTPBasicCredentials`.
-* Create a "`security` scheme" using `HTTPBAsic`.
+* Import `HTTPBasic` and `HTTPBasicCredentials`.
+* Create a "`security` scheme" using `HTTPBasic`.
 * Use that `security` with a dependency in your *path operation*.
 * It returns an object of type `HTTPBasicCredentials`:
     * It contains the `username` and `password` sent.

docs/tutorial/security/oauth2-jwt.md

@@ -156,7 +156,7 @@ Then you could add permissions about that entity, like "drive" (for the car) or
 
 And then, you could give that JWT token to a user (or bot), and he could use it to perform those actions (drive the car, or edit the blog post) without even needing to have an account, just with the JWT token your API generated for that.
 
-Using these ideas, JWT can be used for way more sophisticate scenarios.
+Using these ideas, JWT can be used for way more sophisticated scenarios.
 
 In those cases, several of those entities could have the same ID, let's say `foo` (a user `foo`, a car `foo`, and a blog post `foo`).
 

docs/tutorial/sql-databases-peewee.md

@@ -0,0 +1,408 @@
+!!! warning
+    If you are just starting, the <a href="https://fastapi.tiangolo.com/tutorial/sql-databases/" target="_blank">SQLAlchemy tutorial</a> should be enough.
+
+    Feel free to skip this.
+
+If you are starting a project from scratch, you are probably better off with <a href="https://fastapi.tiangolo.com/tutorial/sql-databases/" target="_blank">SQLAlchemy ORM</a>, or any other async ORM.
+
+If you already have a code base that uses <a href="http://docs.peewee-orm.com/en/latest/" target="_blank">Peewee ORM</a>, you can check here how to use it with **FastAPI**.
+
+!!! warning "Python 3.7+ required"
+    You will need Python 3.7 or above to safely use Peewee with FastAPI.
+
+## Peewee for async
+
+Peewee was not designed for async frameworks, or with them in mind.
+
+Peewee has some heavy assumptions about its defaults and about how it should be used.
+
+If you are developing an application with an older non-async framework, and can work with all its defaults, **it can be a great tool**.
+
+But if you need to change some of the defaults, support more than one predefined database, work with an async framework (like FastAPI), etc, you will need to add quite some complex extra code to override those defaults.
+
+Nevertheless, it's possible to do it, and here you'll see exactly what code you have to add to be able to use Peewee with FastAPI.
+
+!!! note "Technical Details"
+    You can read more about Peewee's stand about async in Python <a href="http://docs.peewee-orm.com/en/latest/peewee/database.html#async-with-gevent" target="_blank">in the docs</a>, <a href="https://github.com/coleifer/peewee/issues/263#issuecomment-517347032" target="_blank">an issue</a>, <a href="https://github.com/coleifer/peewee/pull/2072#issuecomment-563215132" target="_blank">a PR</a>.
+
+## The same app
+
+We are going to create the same application as in the <a href="https://fastapi.tiangolo.com/tutorial/sql-databases/" target="_blank">SQLAlchemy tutorial</a>.
+
+Most of the code is actually the same.
+
+So, we are going to focus only on the differences.
+
+## File structure
+
+Let's say you have a directory named `my_super_project` that contains a sub-directory called `sql_app` with a structure like this:
+
+```
+.
+└── sql_app
+    ├── __init__.py
+    ├── crud.py
+    ├── database.py
+    ├── main.py
+    └── schemas.py
+```
+
+This is almost the same structure as we had for the SQLAlchemy tutorial.
+
+Now let's see what each file/module does.
+
+## Create the Peewee parts
+
+Let's refer to the file `sql_app/database.py`.
+
+### The standard Peewee code
+
+Let's first check all the normal Peewee code, create a Peewee database:
+
+```Python hl_lines="3  5  24"
+{!./src/sql_databases_peewee/sql_app/database.py!}
+```
+
+!!! tip
+    Have in mind that if you wanted to use a different database, like PostgreSQL, you couldn't just change the string. You would need to use a different Peewee database class.
+
+#### Note
+
+The argument:
+
+```Python
+check_same_thread=False
+```
+
+is equivalent to the one in the SQLAlchemy tutorial:
+
+```Python
+connect_args={"check_same_thread": False}
+```
+
+...it is needed only for `SQLite`.
+
+!!! info "Technical Details"
+
+    Exactly the same technical details as in the <a href="https://fastapi.tiangolo.com/tutorial/sql-databases/#note" target="_blank">SQLAlchemy tutorial</a> apply.
+
+### Make Peewee async-compatible `PeeweeConnectionState`
+
+The main issue with Peewee and FastAPI is that Peewee relies heavily on <a href="https://docs.python.org/3/library/threading.html#thread-local-data" target="_blank">Python's `threading.local`</a>, and it doesn't have a direct way to override it or let you handle connections/sessions directly (as is done in the SQLAlchemy tutorial).
+
+And `threading.local` is not compatible with the new async features of modern Python.
+
+!!! note "Technical Details"
+    `threading.local` is used to have a "magic" variable that has a different value for each thread.
+
+    This was useful in older frameworks designed to have one single thread per request, no more, no less.
+
+    Using this, each request would have its own database connection/session, which is the actual final goal.
+
+    But FastAPI, using the new async features, could handle more than one request on the same thread. And at the same time, for a single request, it could run multiple things in different threads (in a threadpool), depending on if you use `async def` or normal `def`. This is what gives all the performance improvements to FastAPI.
+
+But Python 3.7 and above provide a more advanced alternative to `threading.local`, that can also be used in the places where `threading.local` would be used, but is compatible with the new async features.
+
+We are going to use that. It's called <a href="https://docs.python.org/3/library/contextvars.html" target="_blank">`contextvars`</a>.
+
+We are going to override the internal parts of Peewee that use `threading.local` and replace them with `contextvars`, with the corresponding updates.
+
+This might seem a bit complex (and it actually is), you don't really need to completely understand how it works to use it.
+
+We will create a `PeeweeConnectionState`:
+
+```Python hl_lines="8 9 10 11 12 13 14 15 16 17 18 19 20 21"
+{!./src/sql_databases_peewee/sql_app/database.py!}
+```
+
+This class inherits from a special internal class used by Peewee.
+
+It has all the logic to make Peewee use `contextvars` instead of `threading.local`.
+
+`contextvars` works a bit differently than `threading.local`. But the rest of Peewee's internal code assumes that this class works with `threading.local`.
+
+So, we need to do some extra tricks to make it work as if it was just using `threading.local`. The `__init__`, `__setattr__`, and `__getattr__` implement all the required tricks for this to be used by Peewee without knowing that it is now compatible with FastAPI.
+
+!!! tip
+    This will just make Peewee behave correctly when used with FastAPI. Not randomly opening or closing connections that are being used, creating errors, etc.
+
+    But it doesn't give Peewee async super-powers. You should still use normal `def` functions and not `async def`.
+
+### Use the custom `PeeweeConnectionState` class
+
+Now, overwrite the `._state` internal attribute in the Peewee database `db` object using the new `PeeweeConnectionState`:
+
+```Python hl_lines="26"
+{!./src/sql_databases_peewee/sql_app/database.py!}
+```
+
+!!! tip
+    Make sure you overwrite `db._state` *after* creating `db`.
+
+!!! tip
+    You would do the same for any other Peewee database, including `PostgresqlDatabase`, `MySQLDatabase`, etc.
+
+## Create the database models
+
+Let's now see the file `sql_app/models.py`.
+
+### Create Peewee models for our data
+
+Now create the Peewee models (classes) for `User` and `Item`.
+
+This is the same you would do if you followed the Peewee tutorial and updated the models to have the same data as in the SQLAlchemy tutorial.
+
+!!! tip
+    Peewee also uses the term "**model**" to refer to these classes and instances that interact with the database.
+
+    But Pydantic also uses the term "**model**" to refer to something different, the data validation, conversion, and documentation classes and instances.
+
+Import `db` from `database` (the file `database.py` from above) and use it here.
+
+```Python hl_lines="3  6 7 8 9 10 11 12  15 16 17 18 19 20 21"
+{!./src/sql_databases_peewee/sql_app/models.py!}
+```
+
+!!! tip
+    Peewee creates several magic attributes.
+
+    It will automatically add an `id` attribute as an integer to be the primary key.
+
+    It will chose the name of the tables based on the class names.
+
+    For the `Item`, it will create an attribute `owner_id` with the integer ID of the `User`. But we don't declare it anywhere.
+
+## Create the Pydantic models
+
+Now let's check the file `sql_app/schemas.py`.
+
+!!! tip
+    To avoid confusion between the Peewee *models* and the Pydantic *models*, we will have the file `models.py` with the Peewee models, and the file `schemas.py` with the Pydantic models.
+
+    These Pydantic models define more or less a "schema" (a valid data shape).
+    
+    So this will help us avoiding confusion while using both.
+
+### Create the Pydantic *models* / schemas
+
+Create all the same Pydantic models as in the SQLAlchemy tutorial:
+
+```Python hl_lines="16 17 18  21 22  25 26 27 28 29 30  34 35  38 39  42 43 44 45 46 47 48"
+{!./src/sql_databases_peewee/sql_app/schemas.py!}
+```
+
+!!! tip
+    Here we are creating the models with an `id`.
+
+    We didn't explicitly specify an `id` attribute in the Peewee models, but Peewee adds one automatically.
+
+    We are also adding the magic `owner_id` attribute to `Item`.
+
+### Create a `PeeweeGetterDict` for the Pydantic *models* / schemas
+
+When you access a relationship in a Peewee object, like in `some_user.items`, Peewee doesn't provide a `list` of `Item`.
+
+It provides a special custom object of class `ModelSelect`.
+
+It's possible to create a `list` of its items with `list(some_user.items)`.
+
+But the object itself is not a `list`. And it's also not an actual Python <a href="https://docs.python.org/3/glossary.html#term-generator" target="_blank">generator</a>. Because of this, Pydantic doesn't know by default how to convert it to a `list` of Pydantic *models* / schemas.
+
+But recent versions of Pydantic allow providing a custom class that inherits from `pydantic.utils.GetterDict`, to provide the functionality used when using the `orm_mode = True` to retrieve the values for ORM model attributes.
+
+We are going to create a custom `PeeweeGetterDict` class and use it in all the same Pydantic *models* / schemas that use `orm_mode`:
+
+```Python hl_lines="3 8 9 10 11 12 13  31  49"
+{!./src/sql_databases_peewee/sql_app/schemas.py!}
+```
+
+Here we are checking if the attribute that is being accessed (e.g. `.items` in `some_user.items`) is an instance of `peewee.ModelSelect`.
+
+And if that's the case, just return a `list` with it.
+
+And then we use it in the Pydantic *models* / schemas that use `orm_mode = True`, with the configuration variable `getter_dict = PeeweeGetterDict`.
+
+!!! tip
+    We only need to create one `PeeweeGetterDict` class, and we can use it in all the Pydantic *models* / schemas.
+
+## CRUD utils
+
+Now let's see the file `sql_app/crud.py`.
+
+### Create all the CRUD utils
+
+Create all the same CRUD utils as in the SQLAlchemy tutorial, all the code is very similar:
+
+```Python hl_lines="1  4 5  8 9  12 13  16 17 18 19 20  23 24  27 28 29 30"
+{!./src/sql_databases_peewee/sql_app/crud.py!}
+```
+
+There are some differences with the code for the SQLAlchemy tutorial.
+
+We don't pass a `db` attribute around. Instead we use the models directly. This is because the `db` object is a global object, that includes all the connection logic. That's why we had to do all the `contextvars` updates above.
+
+Aso, when returning several objects, like in `get_users`, we directly call `list`, like in:
+
+```Python
+list(models.User.select())
+```
+
+This is for the same reason that we had to create a custom `PeeweeGetterDict`. But by returning something that is already a `list` instead of the `peewee.ModelSelect` the `response_model` in the path operation with `List[models.User]` (that we'll see later) will work correctly.
+
+## Main **FastAPI** app
+
+And now in the file `sql_app/main.py` let's integrate and use all the other parts we created before.
+
+### Create the database tables
+
+In a very simplistic way create the database tables:
+
+```Python hl_lines="8 9 10"
+{!./src/sql_databases_peewee/sql_app/main.py!}
+```
+
+### Create a dependency
+
+Create a dependency that will connect the database right at the beginning of a request and disconnect it at the end:
+
+```Python hl_lines="15 16 17 18 19 20 21 22"
+{!./src/sql_databases_peewee/sql_app/main.py!}
+```
+
+Here we have an empty `yield` because we are actually not using the database object directly.
+
+It is connecting to the database and storing the connection data in an internal variable that is independent for each request (using the `contextvars` tricks from above).
+
+And then, in each *path operation function* that needs to access the database we add it as a dependency.
+
+But we are not using the value given by this dependency (it actually doesn't give any value, as it has an empty `yield`). So, we don't add it to the *path operation function* but to the *path operation decorator* in the `dependencies` parameter:
+
+```Python hl_lines="25  33  40  52  58  65"
+{!./src/sql_databases_peewee/sql_app/main.py!}
+```
+
+### Create your **FastAPI** *path operations*
+
+Now, finally, here's the standard **FastAPI** *path operations* code.
+
+```Python hl_lines="25 26 27 28 29 30  33 34 35 36  39 40 41 42 43 44 45 46  49 50 51 52 53 54 55  58 59 60 61  64 65 66 67 68 69 70"
+{!./src/sql_databases_peewee/sql_app/main.py!}
+```
+
+### About `def` vs `async def`
+
+The same as with SQLAlchemy, we are not doing something like:
+
+```Python
+user = await models.User.select().first()
+```
+
+...but instead we are using:
+
+```Python
+user = models.User.select().first()
+```
+
+So, again, we should declare the *path operation functions* and the dependency without `async def`, just with a normal `def`, as:
+
+```Python hl_lines="2"
+# Something goes here
+def read_users(skip: int = 0, limit: int = 100):
+    # Something goes here
+```
+
+## Testing Peewee with async
+
+This example includes an extra *path operation* that simulates a long processing request with `time.sleep(15)`.
+
+It will have the database connection open at the beginning and will just wait 15 seconds before replying back.
+
+This will easily let you test that your app with Peewee and FastAPI is behaving correctly with all the stuff about threads.
+
+If you want to check how Peewee would break your app if used without modification, go the the `sql_app/database.py` file and comment the line:
+
+```Python
+# db._state = PeeweeConnectionState()
+```
+
+Then run your app with Uvicorn:
+
+```bash
+uvicorn sql_app.main:app --reload
+```
+
+Open your browser at <a href="http://127.0.0.1:8000/docs" target="_blank">http://127.0.0.1:8000/docs</a>  and create a couple of users.
+
+Then open 10 tabs at <a href="http://127.0.0.1:8000/docs#/default/read_slow_users_slowusers__get" target="_blank">http://127.0.0.1:8000/docs#/default/read_slow_users_slowusers__get</a> at the same time.
+
+Go to the *path operation* "Get `/slowusers/`" in all of the tabs. Use the "Try it out" button and execute the request in each tab, one right after the other.
+
+The tabs will wait for a bit and then some of them will show `Internal Server Error`.
+
+### What happens
+
+The first tab will make your app create a connection to the database and wait for 15 seconds before replying back and closing the connection.
+
+Then one of the other tabs will try to open a database connection, but as one of those requests for the other tabs will probably be handled in the same thread as the first one, it will have the same database connection that is already open, and Peewee will throw an error and you will see it in the terminal, and the response will have an `Internal Server Error`.
+
+This will probably happen for more than one of those tabs.
+
+If you had multiple clients talking to your app exactly at the same time, this is what could happen.
+
+And as your app starts to handle more and more clients at the same time, the waiting time in a single requests needs to be shorter and shorter to trigger the error.
+
+### Fix Peewee with FastAPI
+
+Now go back to the file `sql_app/database.py`, and uncomment the line:
+
+```Python
+db._state = PeeweeConnectionState()
+```
+
+Terminate your running app and start it again.
+
+Repeat the same process with the 10 tabs. This time all of them will wait and you will get all the results without errors.
+
+...You fixed it!
+
+## Review all the files
+
+ Remember you should have a directory named `my_super_project` that contains a sub-directory called `sql_app`.
+
+`sql_app` should have the following files:
+
+* `sql_app/__init__.py`: is an empty file.
+
+* `sql_app/database.py`:
+
+```Python hl_lines=""
+{!./src/sql_databases_peewee/sql_app/database.py!}
+```
+
+* `sql_app/models.py`:
+
+```Python hl_lines=""
+{!./src/sql_databases_peewee/sql_app/models.py!}
+```
+
+* `sql_app/schemas.py`:
+
+```Python hl_lines=""
+{!./src/sql_databases_peewee/sql_app/schemas.py!}
+```
+
+* `sql_app/crud.py`:
+
+```Python hl_lines=""
+{!./src/sql_databases_peewee/sql_app/crud.py!}
+```
+
+* `sql_app/main.py`:
+
+```Python hl_lines=""
+{!./src/sql_databases_peewee/sql_app/main.py!}
+```
+
+## Technical Details
+
+If you want to go deeper into the technical details related to Peewee with FastAPI, you can <a href="https://github.com/coleifer/peewee/pull/2072" target="_blank">read more about it here</a>.

docs/tutorial/sql-databases.md

@@ -55,20 +55,24 @@ Common ORMs are for example: Django-ORM (part of the Django framework), SQLAlche
 
 Here we will see how to work with **SQLAlchemy ORM**.
 
-The same way, you could use Peewee or any other.
+In a similar way you could use any other ORM.
+
+!!! tip
+    There's an equivalent article using Peewee here in the docs.
 
 ## File structure
 
 For these examples, let's say you have a directory named `my_super_project` that contains a sub-directory called `sql_app` with a structure like this:
 
 ```
-├── sql_app
-│   ├── __init__.py
-│   ├── crud.py
-│   ├── database.py
-│   ├── main.py
-│   ├── models.py
-│   ├── schemas.py
+.
+└── sql_app
+    ├── __init__.py
+    ├── crud.py
+    ├── database.py
+    ├── main.py
+    ├── models.py
+    └── schemas.py
 ```
 
 The file `__init__.py` is just an empty file, but it tells Python that `sql_app` with all its modules (Python files) is a package.
@@ -131,12 +135,17 @@ connect_args={"check_same_thread": False}
 
 !!! info "Technical Details"
 
-    That argument `check_same_thread` is there mainly to be able to run the tests that cover this example.
-    
+    By default SQLite will only allow one thread to communicate with it, assuming that each thread would handle an independent request.
+
+    This is to prevent accidentally sharing the same connection for different things (for different requests).
+
+    But in FastAPI, using normal functions (`def`) more than one thread could interact with the database for the same request, so we need to make SQLite know that it should allow that with `connect_args={"check_same_thread": False}`.
+
+    Also, we will make sure each request gets its own database connection session in a dependency, so there's no need for that default mechanism.
 
 ### Create a `SessionLocal` class
 
-Each instance of the `SessionLocal` class will be a database session. The class itself is not a database session yet. 
+Each instance of the `SessionLocal` class will be a database session. The class itself is not a database session yet.
 
 But once we create an instance of the `SessionLocal` class, this instance will be the actual database session.
 
@@ -413,9 +422,9 @@ And now in the file `sql_app/main.py` let's integrate and use all the other part
 
 ### Create the database tables
 
-In a very simplistic way, create the database tables:
+In a very simplistic way create the database tables:
 
-```Python hl_lines="11"
+```Python hl_lines="9"
 {!./src/sql_databases/sql_app/main.py!}
 ```
 
@@ -427,21 +436,30 @@ And you would also use Alembic for "migrations" (that's its main job).
 
 A "migration" is the set of steps needed whenever you change the structure of your SQLAlchemy models, add a new attribute, etc. to replicate those changes in the database, add a new column, a new table, etc.
 
-### Create a middleware to handle sessions
+### Create a dependency
 
-Now use the `SessionLocal` class we created in the `sql_app/databases.py` file.
+!!! info
+    For this to work, you need to use **Python 3.7** or above, or in **Python 3.6**, install the "backports":
+
+    ```bash
+    pip install async-exit-stack async-generator
+    ```
+
+    This installs <a href="https://github.com/sorcio/async_exit_stack" target="_blank">async-exit-stack</a> and <a href="https://github.com/python-trio/async_generator" target="_blank">async-generator</a>.
+
+    You can also use the alternative method with a "middleware" explained at the end.
+
+Now use the `SessionLocal` class we created in the `sql_app/databases.py` file to create a dependency.
 
 We need to have an independent database session/connection (`SessionLocal`) per request, use the same session through all the request and then close it after the request is finished.
 
 And then a new session will be created for the next request.
 
-For that, we will create a new middleware.
+For that, we will create a new dependency with `yield`, as explained before in the section about <a href="https://fastapi.tiangolo.com/tutorial/dependencies/dependencies-with-yield/" target="_blank">Dependencies with `yield`</a>.
 
-A "middleware" is a function that is always executed for each request, and have code before and after the request.
+Our dependency will create a new SQLAlchemy `SessionLocal` that will be used in a single request, and then close it once the request is finished.
 
-This middleware (just a function) will create a new SQLAlchemy `SessionLocal` for each request, add it to the request and then close it once the request is finished.
-
-```Python hl_lines="16 17 18 19 20 21 22 23 24"
+```Python hl_lines="15 16 17 18 19 20"
 {!./src/sql_databases/sql_app/main.py!}
 ```
 
@@ -452,21 +470,11 @@ This middleware (just a function) will create a new SQLAlchemy `SessionLocal` fo
     
     This way we make sure the database session is always closed after the request. Even if there was an exception while processing the request.
 
-#### About `request.state`
+And then, when using the dependency in a *path operation function*, we declare it with the type `Session` we imported directly from SQLAlchemy.
 
-<a href="https://www.starlette.io/requests/#other-state" target="_blank">`request.state` is a property of each Starlette `Request` object</a>, it is there to store arbitrary objects attached to the request itself, like the database session in this case.
+This will then give us better editor support inside the *path operation function*, because the editor will know that the `db` parameter is of type `Session`:
 
-For us in this case, it helps us ensuring a single database session is used through all the request, and then closed afterwards (in the middleware).
-
-### Create a dependency
-
-To simplify the code, reduce repetition and get better editor support, we will create a dependency that returns this same database session from the request.
-
-And when using the dependency in a path operation function, we declare it with the type `Session` we imported directly from SQLAlchemy.
-
-This will then give us better editor support inside the path operation function, because the editor will know that the `db` parameter is of type `Session`.
-
-```Python hl_lines="28 29"
+```Python hl_lines="24  32  38  47  53"
 {!./src/sql_databases/sql_app/main.py!}
 ```
 
@@ -479,22 +487,16 @@ This will then give us better editor support inside the path operation function,
 
 Now, finally, here's the standard **FastAPI** *path operations* code.
 
-```Python hl_lines="32 33 34 35 36 37 40 41 42 43 46 47 48 49 50 51 54 55 56 57 58 61 62 63 64 65"
+```Python hl_lines="23 24 25 26 27 28  31 32 33 34  37 38 39 40 41 42  45 46 47 48 49  52 53 54 55"
 {!./src/sql_databases/sql_app/main.py!}
 ```
 
-We are creating the database session before each request, attaching it to the request, and then closing it afterwards.
+We are creating the database session before each request in the dependency with `yield`, and then closing it afterwards.
 
-All of this is done in the middleware explained above.
-
-Then, in the dependency `get_db()` we are extracting the database session from the request.
-
-And then we can create the dependency in the path operation function, to get that session directly.
+And then we can create the required dependency in the path operation function, to get that session directly.
 
 With that, we can just call `crud.get_user` directly from inside of the path operation function and use that session.
 
-Having this 3-step process (middleware, dependency, path operation) you get better support/checks/completion in all the path operation functions while reducing code repetition.
-
 !!! tip
     Notice that the values you return are SQLAlchemy models, or lists of SQLAlchemy models.
 
@@ -507,7 +509,7 @@ Having this 3-step process (middleware, dependency, path operation) you get bett
 
 ### About `def` vs `async def`
 
-Here we are using SQLAlchemy code inside of the path operation function, and, in turn, it will go and communicate with an external database.
+Here we are using SQLAlchemy code inside of the path operation function and in the dependency, and, in turn, it will go and communicate with an external database.
 
 That could potentially require some "waiting".
 
@@ -523,7 +525,7 @@ user = await db.query(User).first()
 user = db.query(User).first()
 ```
 
-Then we should declare the path operation without `async def`, just with a normal `def`, as:
+Then we should declare the *path operation functions* and the dependency without `async def`, just with a normal `def`, as:
 
 ```Python hl_lines="2"
 @app.get("/users/{user_id}", response_model=schemas.User)
@@ -548,8 +550,8 @@ For example, in a background task worker with <a href="http://www.celeryproject.
 ## Review all the files
 
  Remember you should have a directory named `my_super_project` that contains a sub-directory called `sql_app`.
- 
- `sql_app` should have the following files:
+
+`sql_app` should have the following files:
 
 * `sql_app/__init__.py`: is an empty file.
 
@@ -591,9 +593,6 @@ You can copy this code and use it as is.
 
     In fact, the code shown here is part of the tests. As most of the code in these docs.
 
-
-You can copy it as is.
-
 Then you can run it with Uvicorn:
 
 ```bash
@@ -615,3 +614,51 @@ It will look like this:
 <img src="/img/tutorial/sql-databases/image02.png">
 
 You can also use an online SQLite browser like <a href="https://inloop.github.io/sqlite-viewer/" target="_blank">SQLite Viewer</a> or <a href="https://extendsclass.com/sqlite-browser.html" target="_blank">ExtendsClass</a>.
+
+## Alternative DB session with middleware
+
+If you can't use dependencies with `yield` -- for example, if you are not using **Python 3.7** and can't install the "backports" mentioned above for **Python 3.6** -- you can set up the session in a "middleware" in a similar way.
+
+A "middleware" is basically a function that is always executed for each request, with some code executed before, and some code executed after the endpoint function.
+
+### Create a middleware
+
+The middleware we'll add (just a function) will create a new SQLAlchemy `SessionLocal` for each request, add it to the request and then close it once the request is finished.
+
+```Python hl_lines="16 17 18 19 20 21 22 23 24"
+{!./src/sql_databases/sql_app/alt_main.py!}
+```
+
+!!! info
+    We put the creation of the `SessionLocal()` and handling of the requests in a `try` block.
+
+    And then we close it in the `finally` block.
+    
+    This way we make sure the database session is always closed after the request. Even if there was an exception while processing the request.
+
+### About `request.state`
+
+<a href="https://www.starlette.io/requests/#other-state" target="_blank">`request.state` is a property of each Starlette `Request` object</a>. It is there to store arbitrary objects attached to the request itself, like the database session in this case.
+
+For us in this case, it helps us ensure a single database session is used through all the request, and then closed afterwards (in the middleware).
+
+### Dependencies with `yield` or middleware
+
+Adding a **middleware** here is similar to what a dependency with `yield` does, with some differences:
+
+* It requires more code and is a bit more complex.
+* The middleware has to be an `async` function.
+    * If there is code in it that has to "wait" for the network, it could "block" your application there and degrade performance a bit.
+    * Although it's probably not very problematic here with the way `SQLAlchemy` works.
+    * But if you added more code to the middleware that had a lot of <abbr title="input and output">I/O</abbr> waiting, it could then be problematic.
+* A middleware is run for *every* request.
+    * So, a connection will be created for every request.
+    * Even when the *path operation* that handles that request didn't need the DB.
+
+!!! tip
+    It's probably better to use dependencies with `yield` when they are enough for the use case.
+
+!!! info
+    Dependencies with `yield` were added recently to **FastAPI**.
+
+    A previous version of this tutorial only had the examples with a middleware and there are probably several applications using the middleware for database session management.

fastapi/__init__.py

@@ -1,6 +1,6 @@
 """FastAPI framework, high performance, easy to learn, fast to code, ready for production"""
 
-__version__ = "0.35.0"
+__version__ = "0.46.0"
 
 from starlette.background import BackgroundTasks
 

fastapi/applications.py

@@ -1,6 +1,8 @@
-from typing import Any, Callable, Dict, List, Optional, Sequence, Set, Type, Union
+from typing import Any, Callable, Dict, List, Optional, Sequence, Type, Union
 
 from fastapi import routing
+from fastapi.concurrency import AsyncExitStack
+from fastapi.encoders import DictIntStrAny, SetIntStr
 from fastapi.exception_handlers import (
     http_exception_handler,
     request_validation_exception_handler,
@@ -13,12 +15,15 @@ from fastapi.openapi.docs import (
 )
 from fastapi.openapi.utils import get_openapi
 from fastapi.params import Depends
+from fastapi.utils import warning_response_model_skip_defaults_deprecated
 from starlette.applications import Starlette
+from starlette.datastructures import State
 from starlette.exceptions import ExceptionMiddleware, HTTPException
 from starlette.middleware.errors import ServerErrorMiddleware
 from starlette.requests import Request
 from starlette.responses import HTMLResponse, JSONResponse, Response
 from starlette.routing import BaseRoute
+from starlette.types import Receive, Scope, Send
 
 
 class FastAPI(Starlette):
@@ -32,12 +37,16 @@ class FastAPI(Starlette):
         version: str = "0.1.0",
         openapi_url: Optional[str] = "/openapi.json",
         openapi_prefix: str = "",
+        default_response_class: Type[Response] = JSONResponse,
         docs_url: Optional[str] = "/docs",
         redoc_url: Optional[str] = "/redoc",
         swagger_ui_oauth2_redirect_url: Optional[str] = "/docs/oauth2-redirect",
+        swagger_ui_init_oauth: Optional[dict] = None,
         **extra: Dict[str, Any],
     ) -> None:
+        self.default_response_class = default_response_class
         self._debug = debug
+        self.state = State()
         self.router: routing.APIRouter = routing.APIRouter(
             routes, dependency_overrides_provider=self
         )
@@ -54,6 +63,7 @@ class FastAPI(Starlette):
         self.docs_url = docs_url
         self.redoc_url = redoc_url
         self.swagger_ui_oauth2_redirect_url = swagger_ui_oauth2_redirect_url
+        self.swagger_ui_init_oauth = swagger_ui_init_oauth
         self.extra = extra
         self.dependency_overrides: Dict[Callable, Callable] = {}
 
@@ -95,6 +105,7 @@ class FastAPI(Starlette):
                     openapi_url=openapi_url,
                     title=self.title + " - Swagger UI",
                     oauth2_redirect_url=self.swagger_ui_oauth2_redirect_url,
+                    init_oauth=self.swagger_ui_init_oauth,
                 )
 
             self.add_route(self.docs_url, swagger_ui_html, include_in_schema=False)
@@ -122,6 +133,14 @@ class FastAPI(Starlette):
             RequestValidationError, request_validation_exception_handler
         )
 
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if AsyncExitStack:
+            async with AsyncExitStack() as stack:
+                scope["fastapi_astack"] = stack
+                await super().__call__(scope, receive, send)
+        else:
+            await super().__call__(scope, receive, send)  # pragma: no cover
+
     def add_api_route(
         self,
         path: str,
@@ -138,14 +157,17 @@ class FastAPI(Starlette):
         deprecated: bool = None,
         methods: List[str] = None,
         operation_id: str = None,
-        response_model_include: Set[str] = None,
-        response_model_exclude: Set[str] = set(),
+        response_model_include: Union[SetIntStr, DictIntStrAny] = None,
+        response_model_exclude: Union[SetIntStr, DictIntStrAny] = set(),
         response_model_by_alias: bool = True,
-        response_model_skip_defaults: bool = False,
+        response_model_skip_defaults: bool = None,
+        response_model_exclude_unset: bool = False,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
     ) -> None:
+        if response_model_skip_defaults is not None:
+            warning_response_model_skip_defaults_deprecated()  # pragma: nocover
         self.router.add_api_route(
             path,
             endpoint=endpoint,
@@ -163,9 +185,11 @@ class FastAPI(Starlette):
             response_model_include=response_model_include,
             response_model_exclude=response_model_exclude,
             response_model_by_alias=response_model_by_alias,
-            response_model_skip_defaults=response_model_skip_defaults,
+            response_model_exclude_unset=bool(
+                response_model_exclude_unset or response_model_skip_defaults
+            ),
             include_in_schema=include_in_schema,
-            response_class=response_class,
+            response_class=response_class or self.default_response_class,
             name=name,
         )
 
@@ -184,14 +208,18 @@ class FastAPI(Starlette):
         deprecated: bool = None,
         methods: List[str] = None,
         operation_id: str = None,
-        response_model_include: Set[str] = None,
-        response_model_exclude: Set[str] = set(),
+        response_model_include: Union[SetIntStr, DictIntStrAny] = None,
+        response_model_exclude: Union[SetIntStr, DictIntStrAny] = set(),
         response_model_by_alias: bool = True,
-        response_model_skip_defaults: bool = False,
+        response_model_skip_defaults: bool = None,
+        response_model_exclude_unset: bool = False,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
     ) -> Callable:
+        if response_model_skip_defaults is not None:
+            warning_response_model_skip_defaults_deprecated()  # pragma: nocover
+
         def decorator(func: Callable) -> Callable:
             self.router.add_api_route(
                 path,
@@ -210,9 +238,11 @@ class FastAPI(Starlette):
                 response_model_include=response_model_include,
                 response_model_exclude=response_model_exclude,
                 response_model_by_alias=response_model_by_alias,
-                response_model_skip_defaults=response_model_skip_defaults,
+                response_model_exclude_unset=bool(
+                    response_model_exclude_unset or response_model_skip_defaults
+                ),
                 include_in_schema=include_in_schema,
-                response_class=response_class,
+                response_class=response_class or self.default_response_class,
                 name=name,
             )
             return func
@@ -239,6 +269,7 @@ class FastAPI(Starlette):
         tags: List[str] = None,
         dependencies: Sequence[Depends] = None,
         responses: Dict[Union[int, str], Dict[str, Any]] = None,
+        default_response_class: Optional[Type[Response]] = None,
     ) -> None:
         self.router.include_router(
             router,
@@ -246,6 +277,8 @@ class FastAPI(Starlette):
             tags=tags,
             dependencies=dependencies,
             responses=responses or {},
+            default_response_class=default_response_class
+            or self.default_response_class,
         )
 
     def get(
@@ -262,14 +295,18 @@ class FastAPI(Starlette):
         responses: Dict[Union[int, str], Dict[str, Any]] = None,
         deprecated: bool = None,
         operation_id: str = None,
-        response_model_include: Set[str] = None,
-        response_model_exclude: Set[str] = set(),
+        response_model_include: Union[SetIntStr, DictIntStrAny] = None,
+        response_model_exclude: Union[SetIntStr, DictIntStrAny] = set(),
         response_model_by_alias: bool = True,
-        response_model_skip_defaults: bool = False,
+        response_model_skip_defaults: bool = None,
+        response_model_exclude_unset: bool = False,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
+        callbacks: List[routing.APIRoute] = None,
     ) -> Callable:
+        if response_model_skip_defaults is not None:
+            warning_response_model_skip_defaults_deprecated()  # pragma: nocover
         return self.router.get(
             path,
             response_model=response_model,
@@ -285,10 +322,13 @@ class FastAPI(Starlette):
             response_model_include=response_model_include,
             response_model_exclude=response_model_exclude,
             response_model_by_alias=response_model_by_alias,
-            response_model_skip_defaults=response_model_skip_defaults,
+            response_model_exclude_unset=bool(
+                response_model_exclude_unset or response_model_skip_defaults
+            ),
             include_in_schema=include_in_schema,
-            response_class=response_class,
+            response_class=response_class or self.default_response_class,
             name=name,
+            callbacks=callbacks,
         )
 
     def put(
@@ -305,14 +345,18 @@ class FastAPI(Starlette):
         responses: Dict[Union[int, str], Dict[str, Any]] = None,
         deprecated: bool = None,
         operation_id: str = None,
-        response_model_include: Set[str] = None,
-        response_model_exclude: Set[str] = set(),
+        response_model_include: Union[SetIntStr, DictIntStrAny] = None,
+        response_model_exclude: Union[SetIntStr, DictIntStrAny] = set(),
         response_model_by_alias: bool = True,
-        response_model_skip_defaults: bool = False,
+        response_model_skip_defaults: bool = None,
+        response_model_exclude_unset: bool = False,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
+        callbacks: List[routing.APIRoute] = None,
     ) -> Callable:
+        if response_model_skip_defaults is not None:
+            warning_response_model_skip_defaults_deprecated()  # pragma: nocover
         return self.router.put(
             path,
             response_model=response_model,
@@ -328,10 +372,13 @@ class FastAPI(Starlette):
             response_model_include=response_model_include,
             response_model_exclude=response_model_exclude,
             response_model_by_alias=response_model_by_alias,
-            response_model_skip_defaults=response_model_skip_defaults,
+            response_model_exclude_unset=bool(
+                response_model_exclude_unset or response_model_skip_defaults
+            ),
             include_in_schema=include_in_schema,
-            response_class=response_class,
+            response_class=response_class or self.default_response_class,
             name=name,
+            callbacks=callbacks,
         )
 
     def post(
@@ -348,14 +395,18 @@ class FastAPI(Starlette):
         responses: Dict[Union[int, str], Dict[str, Any]] = None,
         deprecated: bool = None,
         operation_id: str = None,
-        response_model_include: Set[str] = None,
-        response_model_exclude: Set[str] = set(),
+        response_model_include: Union[SetIntStr, DictIntStrAny] = None,
+        response_model_exclude: Union[SetIntStr, DictIntStrAny] = set(),
         response_model_by_alias: bool = True,
-        response_model_skip_defaults: bool = False,
+        response_model_skip_defaults: bool = None,
+        response_model_exclude_unset: bool = False,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
+        callbacks: List[routing.APIRoute] = None,
     ) -> Callable:
+        if response_model_skip_defaults is not None:
+            warning_response_model_skip_defaults_deprecated()  # pragma: nocover
         return self.router.post(
             path,
             response_model=response_model,
@@ -371,10 +422,13 @@ class FastAPI(Starlette):
             response_model_include=response_model_include,
             response_model_exclude=response_model_exclude,
             response_model_by_alias=response_model_by_alias,
-            response_model_skip_defaults=response_model_skip_defaults,
+            response_model_exclude_unset=bool(
+                response_model_exclude_unset or response_model_skip_defaults
+            ),
             include_in_schema=include_in_schema,
-            response_class=response_class,
+            response_class=response_class or self.default_response_class,
             name=name,
+            callbacks=callbacks,
         )
 
     def delete(
@@ -391,14 +445,18 @@ class FastAPI(Starlette):
         responses: Dict[Union[int, str], Dict[str, Any]] = None,
         deprecated: bool = None,
         operation_id: str = None,
-        response_model_include: Set[str] = None,
-        response_model_exclude: Set[str] = set(),
+        response_model_include: Union[SetIntStr, DictIntStrAny] = None,
+        response_model_exclude: Union[SetIntStr, DictIntStrAny] = set(),
         response_model_by_alias: bool = True,
-        response_model_skip_defaults: bool = False,
+        response_model_skip_defaults: bool = None,
+        response_model_exclude_unset: bool = False,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
+        callbacks: List[routing.APIRoute] = None,
     ) -> Callable:
+        if response_model_skip_defaults is not None:
+            warning_response_model_skip_defaults_deprecated()  # pragma: nocover
         return self.router.delete(
             path,
             response_model=response_model,
@@ -414,10 +472,13 @@ class FastAPI(Starlette):
             response_model_exclude=response_model_exclude,
             response_model_by_alias=response_model_by_alias,
             operation_id=operation_id,
-            response_model_skip_defaults=response_model_skip_defaults,
+            response_model_exclude_unset=bool(
+                response_model_exclude_unset or response_model_skip_defaults
+            ),
             include_in_schema=include_in_schema,
-            response_class=response_class,
+            response_class=response_class or self.default_response_class,
             name=name,
+            callbacks=callbacks,
         )
 
     def options(
@@ -434,14 +495,18 @@ class FastAPI(Starlette):
         responses: Dict[Union[int, str], Dict[str, Any]] = None,
         deprecated: bool = None,
         operation_id: str = None,
-        response_model_include: Set[str] = None,
-        response_model_exclude: Set[str] = set(),
+        response_model_include: Union[SetIntStr, DictIntStrAny] = None,
+        response_model_exclude: Union[SetIntStr, DictIntStrAny] = set(),
         response_model_by_alias: bool = True,
-        response_model_skip_defaults: bool = False,
+        response_model_skip_defaults: bool = None,
+        response_model_exclude_unset: bool = False,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
+        callbacks: List[routing.APIRoute] = None,
     ) -> Callable:
+        if response_model_skip_defaults is not None:
+            warning_response_model_skip_defaults_deprecated()  # pragma: nocover
         return self.router.options(
             path,
             response_model=response_model,
@@ -457,10 +522,13 @@ class FastAPI(Starlette):
             response_model_include=response_model_include,
             response_model_exclude=response_model_exclude,
             response_model_by_alias=response_model_by_alias,
-            response_model_skip_defaults=response_model_skip_defaults,
+            response_model_exclude_unset=bool(
+                response_model_exclude_unset or response_model_skip_defaults
+            ),
             include_in_schema=include_in_schema,
-            response_class=response_class,
+            response_class=response_class or self.default_response_class,
             name=name,
+            callbacks=callbacks,
         )
 
     def head(
@@ -477,14 +545,18 @@ class FastAPI(Starlette):
         responses: Dict[Union[int, str], Dict[str, Any]] = None,
         deprecated: bool = None,
         operation_id: str = None,
-        response_model_include: Set[str] = None,
-        response_model_exclude: Set[str] = set(),
+        response_model_include: Union[SetIntStr, DictIntStrAny] = None,
+        response_model_exclude: Union[SetIntStr, DictIntStrAny] = set(),
         response_model_by_alias: bool = True,
-        response_model_skip_defaults: bool = False,
+        response_model_skip_defaults: bool = None,
+        response_model_exclude_unset: bool = False,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
+        callbacks: List[routing.APIRoute] = None,
     ) -> Callable:
+        if response_model_skip_defaults is not None:
+            warning_response_model_skip_defaults_deprecated()  # pragma: nocover
         return self.router.head(
             path,
             response_model=response_model,
@@ -500,10 +572,13 @@ class FastAPI(Starlette):
             response_model_include=response_model_include,
             response_model_exclude=response_model_exclude,
             response_model_by_alias=response_model_by_alias,
-            response_model_skip_defaults=response_model_skip_defaults,
+            response_model_exclude_unset=bool(
+                response_model_exclude_unset or response_model_skip_defaults
+            ),
             include_in_schema=include_in_schema,
-            response_class=response_class,
+            response_class=response_class or self.default_response_class,
             name=name,
+            callbacks=callbacks,
         )
 
     def patch(
@@ -520,14 +595,18 @@ class FastAPI(Starlette):
         responses: Dict[Union[int, str], Dict[str, Any]] = None,
         deprecated: bool = None,
         operation_id: str = None,
-        response_model_include: Set[str] = None,
-        response_model_exclude: Set[str] = set(),
+        response_model_include: Union[SetIntStr, DictIntStrAny] = None,
+        response_model_exclude: Union[SetIntStr, DictIntStrAny] = set(),
         response_model_by_alias: bool = True,
-        response_model_skip_defaults: bool = False,
+        response_model_skip_defaults: bool = None,
+        response_model_exclude_unset: bool = False,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
+        callbacks: List[routing.APIRoute] = None,
     ) -> Callable:
+        if response_model_skip_defaults is not None:
+            warning_response_model_skip_defaults_deprecated()  # pragma: nocover
         return self.router.patch(
             path,
             response_model=response_model,
@@ -543,10 +622,13 @@ class FastAPI(Starlette):
             response_model_include=response_model_include,
             response_model_exclude=response_model_exclude,
             response_model_by_alias=response_model_by_alias,
-            response_model_skip_defaults=response_model_skip_defaults,
+            response_model_exclude_unset=bool(
+                response_model_exclude_unset or response_model_skip_defaults
+            ),
             include_in_schema=include_in_schema,
-            response_class=response_class,
+            response_class=response_class or self.default_response_class,
             name=name,
+            callbacks=callbacks,
         )
 
     def trace(
@@ -563,14 +645,18 @@ class FastAPI(Starlette):
         responses: Dict[Union[int, str], Dict[str, Any]] = None,
         deprecated: bool = None,
         operation_id: str = None,
-        response_model_include: Set[str] = None,
-        response_model_exclude: Set[str] = set(),
+        response_model_include: Union[SetIntStr, DictIntStrAny] = None,
+        response_model_exclude: Union[SetIntStr, DictIntStrAny] = set(),
         response_model_by_alias: bool = True,
-        response_model_skip_defaults: bool = False,
+        response_model_skip_defaults: bool = None,
+        response_model_exclude_unset: bool = False,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
+        callbacks: List[routing.APIRoute] = None,
     ) -> Callable:
+        if response_model_skip_defaults is not None:
+            warning_response_model_skip_defaults_deprecated()  # pragma: nocover
         return self.router.trace(
             path,
             response_model=response_model,
@@ -586,8 +672,11 @@ class FastAPI(Starlette):
             response_model_include=response_model_include,
             response_model_exclude=response_model_exclude,
             response_model_by_alias=response_model_by_alias,
-            response_model_skip_defaults=response_model_skip_defaults,
+            response_model_exclude_unset=bool(
+                response_model_exclude_unset or response_model_skip_defaults
+            ),
             include_in_schema=include_in_schema,
-            response_class=response_class,
+            response_class=response_class or self.default_response_class,
             name=name,
+            callbacks=callbacks,
         )

fastapi/concurrency.py

@@ -0,0 +1,46 @@
+from typing import Any, Callable
+
+from starlette.concurrency import iterate_in_threadpool  # noqa
+from starlette.concurrency import run_in_threadpool
+
+asynccontextmanager_error_message = """
+FastAPI's contextmanager_in_threadpool require Python 3.7 or above,
+or the backport for Python 3.6, installed with:
+    pip install async-generator
+"""
+
+
+def _fake_asynccontextmanager(func: Callable) -> Callable:
+    def raiser(*args: Any, **kwargs: Any) -> Any:
+        raise RuntimeError(asynccontextmanager_error_message)
+
+    return raiser
+
+
+try:
+    from contextlib import asynccontextmanager  # type: ignore
+except ImportError:
+    try:
+        from async_generator import asynccontextmanager  # type: ignore
+    except ImportError:  # pragma: no cover
+        asynccontextmanager = _fake_asynccontextmanager
+
+try:
+    from contextlib import AsyncExitStack  # type: ignore
+except ImportError:
+    try:
+        from async_exit_stack import AsyncExitStack  # type: ignore
+    except ImportError:  # pragma: no cover
+        AsyncExitStack = None  # type: ignore
+
+
+@asynccontextmanager
+async def contextmanager_in_threadpool(cm: Any) -> Any:
+    try:
+        yield await run_in_threadpool(cm.__enter__)
+    except Exception as e:
+        ok = await run_in_threadpool(cm.__exit__, type(e), e, None)
+        if not ok:
+            raise e
+    else:
+        await run_in_threadpool(cm.__exit__, None, None, None)

fastapi/dependencies/models.py

@@ -1,7 +1,12 @@
 from typing import Callable, List, Sequence
 
 from fastapi.security.base import SecurityBase
-from pydantic.fields import Field
+
+try:
+    from pydantic.fields import ModelField
+except ImportError:  # pragma: nocover
+    # TODO: remove when removing support for Pydantic < 1.0.0
+    from pydantic.fields import Field as ModelField  # type: ignore
 
 param_supported_types = (str, int, float, bool)
 
@@ -16,11 +21,11 @@ class Dependant:
     def __init__(
         self,
         *,
-        path_params: List[Field] = None,
-        query_params: List[Field] = None,
-        header_params: List[Field] = None,
-        cookie_params: List[Field] = None,
-        body_params: List[Field] = None,
+        path_params: List[ModelField] = None,
+        query_params: List[ModelField] = None,
+        header_params: List[ModelField] = None,
+        cookie_params: List[ModelField] = None,
+        body_params: List[ModelField] = None,
         dependencies: List["Dependant"] = None,
         security_schemes: List[SecurityRequirement] = None,
         name: str = None,

fastapi/dependencies/utils.py

@@ -1,5 +1,6 @@
 import asyncio
 import inspect
+from contextlib import contextmanager
 from copy import deepcopy
 from typing import (
     Any,
@@ -16,16 +17,20 @@ from typing import (
 )
 
 from fastapi import params
+from fastapi.concurrency import (
+    AsyncExitStack,
+    _fake_asynccontextmanager,
+    asynccontextmanager,
+    contextmanager_in_threadpool,
+)
 from fastapi.dependencies.models import Dependant, SecurityRequirement
 from fastapi.security.base import SecurityBase
 from fastapi.security.oauth2 import OAuth2, SecurityScopes
 from fastapi.security.open_id_connect_url import OpenIdConnect
-from fastapi.utils import get_path_param_names
-from pydantic import BaseConfig, BaseModel, Schema, create_model
+from fastapi.utils import PYDANTIC_1, get_field_info, get_path_param_names
+from pydantic import BaseConfig, BaseModel, create_model
 from pydantic.error_wrappers import ErrorWrapper
 from pydantic.errors import MissingError
-from pydantic.fields import Field, Required, Shape
-from pydantic.schema import get_annotation_from_schema
 from pydantic.utils import lenient_issubclass
 from starlette.background import BackgroundTasks
 from starlette.concurrency import run_in_threadpool
@@ -34,20 +39,55 @@ from starlette.requests import Request
 from starlette.responses import Response
 from starlette.websockets import WebSocket
 
+try:
+    from pydantic.fields import (
+        SHAPE_LIST,
+        SHAPE_SEQUENCE,
+        SHAPE_SET,
+        SHAPE_SINGLETON,
+        SHAPE_TUPLE,
+        SHAPE_TUPLE_ELLIPSIS,
+        FieldInfo,
+        ModelField,
+        Required,
+    )
+    from pydantic.schema import get_annotation_from_field_info
+    from pydantic.typing import ForwardRef, evaluate_forwardref
+except ImportError:  # pragma: nocover
+    # TODO: remove when removing support for Pydantic < 1.0.0
+    from pydantic.fields import Field as ModelField  # type: ignore
+    from pydantic.fields import Required, Shape  # type: ignore
+    from pydantic import Schema as FieldInfo  # type: ignore
+    from pydantic.schema import get_annotation_from_schema  # type: ignore
+    from pydantic.utils import ForwardRef, evaluate_forwardref  # type: ignore
+
+    SHAPE_LIST = Shape.LIST
+    SHAPE_SEQUENCE = Shape.SEQUENCE
+    SHAPE_SET = Shape.SET
+    SHAPE_SINGLETON = Shape.SINGLETON
+    SHAPE_TUPLE = Shape.TUPLE
+    SHAPE_TUPLE_ELLIPSIS = Shape.TUPLE_ELLIPS
+
+    def get_annotation_from_field_info(
+        annotation: Any, field_info: FieldInfo, field_name: str
+    ) -> Type[Any]:
+        return get_annotation_from_schema(annotation, field_info)
+
+
 sequence_shapes = {
-    Shape.LIST,
-    Shape.SET,
-    Shape.TUPLE,
-    Shape.SEQUENCE,
-    Shape.TUPLE_ELLIPS,
+    SHAPE_LIST,
+    SHAPE_SET,
+    SHAPE_TUPLE,
+    SHAPE_SEQUENCE,
+    SHAPE_TUPLE_ELLIPSIS,
 }
 sequence_types = (list, set, tuple)
 sequence_shape_to_type = {
-    Shape.LIST: list,
-    Shape.SET: set,
-    Shape.TUPLE: tuple,
-    Shape.SEQUENCE: list,
-    Shape.TUPLE_ELLIPS: list,
+    SHAPE_LIST: list,
+    SHAPE_SET: set,
+    SHAPE_TUPLE: tuple,
+    SHAPE_SEQUENCE: list,
+    SHAPE_TUPLE_ELLIPSIS: list,
 }
 
 
@@ -108,7 +148,16 @@ def get_sub_dependant(
     return sub_dependant
 
 
-def get_flat_dependant(dependant: Dependant) -> Dependant:
+CacheKey = Tuple[Optional[Callable], Tuple[str, ...]]
+
+
+def get_flat_dependant(
+    dependant: Dependant, *, skip_repeats: bool = False, visited: List[CacheKey] = None
+) -> Dependant:
+    if visited is None:
+        visited = []
+    visited.append(dependant.cache_key)
+
     flat_dependant = Dependant(
         path_params=dependant.path_params.copy(),
         query_params=dependant.query_params.copy(),
@@ -120,7 +169,11 @@ def get_flat_dependant(dependant: Dependant) -> Dependant:
         path=dependant.path,
     )
     for sub_dependant in dependant.dependencies:
-        flat_sub = get_flat_dependant(sub_dependant)
+        if skip_repeats and sub_dependant.cache_key in visited:
+            continue
+        flat_sub = get_flat_dependant(
+            sub_dependant, skip_repeats=skip_repeats, visited=visited
+        )
         flat_dependant.path_params.extend(flat_sub.path_params)
         flat_dependant.query_params.extend(flat_sub.query_params)
         flat_dependant.header_params.extend(flat_sub.header_params)
@@ -130,12 +183,13 @@ def get_flat_dependant(dependant: Dependant) -> Dependant:
     return flat_dependant
 
 
-def is_scalar_field(field: Field) -> bool:
+def is_scalar_field(field: ModelField) -> bool:
+    field_info = get_field_info(field)
     if not (
-        field.shape == Shape.SINGLETON
+        field.shape == SHAPE_SINGLETON
         and not lenient_issubclass(field.type_, BaseModel)
         and not lenient_issubclass(field.type_, sequence_types + (dict,))
-        and not isinstance(field.schema, params.Body)
+        and not isinstance(field_info, params.Body)
     ):
         return False
     if field.sub_fields:
@@ -144,7 +198,7 @@ def is_scalar_field(field: Field) -> bool:
     return True
 
 
-def is_scalar_sequence_field(field: Field) -> bool:
+def is_scalar_sequence_field(field: ModelField) -> bool:
     if (field.shape in sequence_shapes) and not lenient_issubclass(
         field.type_, BaseModel
     ):
@@ -158,6 +212,42 @@ def is_scalar_sequence_field(field: Field) -> bool:
     return False
 
 
+def get_typed_signature(call: Callable) -> inspect.Signature:
+    signature = inspect.signature(call)
+    globalns = getattr(call, "__globals__", {})
+    typed_params = [
+        inspect.Parameter(
+            name=param.name,
+            kind=param.kind,
+            default=param.default,
+            annotation=get_typed_annotation(param, globalns),
+        )
+        for param in signature.parameters.values()
+    ]
+    typed_signature = inspect.Signature(typed_params)
+    return typed_signature
+
+
+def get_typed_annotation(param: inspect.Parameter, globalns: Dict[str, Any]) -> Any:
+    annotation = param.annotation
+    if isinstance(annotation, str):
+        annotation = ForwardRef(annotation)
+        annotation = evaluate_forwardref(annotation, globalns, globalns)
+    return annotation
+
+
+async_contextmanager_dependencies_error = """
+FastAPI dependencies with yield require Python 3.7 or above,
+or the backports for Python 3.6, installed with:
+    pip install async-exit-stack async-generator
+"""
+
+
+def check_dependency_contextmanagers() -> None:
+    if AsyncExitStack is None or asynccontextmanager == _fake_asynccontextmanager:
+        raise RuntimeError(async_contextmanager_dependencies_error)  # pragma: no cover
+
+
 def get_dependant(
     *,
     path: str,
@@ -167,8 +257,10 @@ def get_dependant(
     use_cache: bool = True,
 ) -> Dependant:
     path_param_names = get_path_param_names(path)
-    endpoint_signature = inspect.signature(call)
+    endpoint_signature = get_typed_signature(call)
     signature_params = endpoint_signature.parameters
+    if inspect.isgeneratorfunction(call) or inspect.isasyncgenfunction(call):
+        check_dependency_contextmanagers()
     dependant = Dependant(call=call, name=name, path=path, use_cache=use_cache)
     for param_name, param in signature_params.items():
         if isinstance(param.default, params.Depends):
@@ -181,18 +273,23 @@ def get_dependant(
             continue
         if add_non_field_param_to_dependency(param=param, dependant=dependant):
             continue
-        param_field = get_param_field(param=param, default_schema=params.Query)
+        param_field = get_param_field(
+            param=param, default_field_info=params.Query, param_name=param_name
+        )
         if param_name in path_param_names:
-            assert param.default == param.empty or isinstance(
-                param.default, params.Path
-            ), "Path params must have no defaults or use Path(...)"
             assert is_scalar_field(
                 field=param_field
             ), f"Path params must be of one of the supported types"
+            if isinstance(param.default, params.Path):
+                ignore_default = False
+            else:
+                ignore_default = True
             param_field = get_param_field(
                 param=param,
-                default_schema=params.Path,
+                param_name=param_name,
+                default_field_info=params.Path,
                 force_type=params.ParamTypes.path,
+                ignore_default=ignore_default,
             )
             add_param_to_fields(field=param_field, dependant=dependant)
         elif is_scalar_field(field=param_field):
@@ -202,8 +299,9 @@ def get_dependant(
         ) and is_scalar_sequence_field(param_field):
             add_param_to_fields(field=param_field, dependant=dependant)
         else:
+            field_info = get_field_info(param_field)
             assert isinstance(
-                param_field.schema, params.Body
+                field_info, params.Body
             ), f"Param: {param_field.name} can only be a request body, using Body(...)"
             dependant.body_params.append(param_field)
     return dependant
@@ -233,64 +331,88 @@ def add_non_field_param_to_dependency(
 def get_param_field(
     *,
     param: inspect.Parameter,
-    default_schema: Type[params.Param] = params.Param,
+    param_name: str,
+    default_field_info: Type[params.Param] = params.Param,
     force_type: params.ParamTypes = None,
-) -> Field:
+    ignore_default: bool = False,
+) -> ModelField:
     default_value = Required
     had_schema = False
-    if not param.default == param.empty:
+    if not param.default == param.empty and ignore_default is False:
         default_value = param.default
-    if isinstance(default_value, Schema):
+    if isinstance(default_value, FieldInfo):
         had_schema = True
-        schema = default_value
-        default_value = schema.default
-        if isinstance(schema, params.Param) and getattr(schema, "in_", None) is None:
-            schema.in_ = default_schema.in_
+        field_info = default_value
+        default_value = field_info.default
+        if (
+            isinstance(field_info, params.Param)
+            and getattr(field_info, "in_", None) is None
+        ):
+            field_info.in_ = default_field_info.in_
         if force_type:
-            schema.in_ = force_type  # type: ignore
+            field_info.in_ = force_type  # type: ignore
     else:
-        schema = default_schema(default_value)
+        field_info = default_field_info(default_value)
     required = default_value == Required
     annotation: Any = Any
     if not param.annotation == param.empty:
         annotation = param.annotation
-    annotation = get_annotation_from_schema(annotation, schema)
-    if not schema.alias and getattr(schema, "convert_underscores", None):
+    annotation = get_annotation_from_field_info(annotation, field_info, param_name)
+    if not field_info.alias and getattr(field_info, "convert_underscores", None):
         alias = param.name.replace("_", "-")
     else:
-        alias = schema.alias or param.name
-    field = Field(
-        name=param.name,
-        type_=annotation,
-        default=None if required else default_value,
-        alias=alias,
-        required=required,
-        model_config=BaseConfig,
-        class_validators={},
-        schema=schema,
-    )
+        alias = field_info.alias or param.name
+    if PYDANTIC_1:
+        field = ModelField(
+            name=param.name,
+            type_=annotation,
+            default=None if required else default_value,
+            alias=alias,
+            required=required,
+            model_config=BaseConfig,
+            class_validators={},
+            field_info=field_info,
+        )
+        # TODO: remove when removing support for Pydantic < 1.2.0
+        field.required = required
+    else:  # pragma: nocover
+        field = ModelField(  # type: ignore
+            name=param.name,
+            type_=annotation,
+            default=None if required else default_value,
+            alias=alias,
+            required=required,
+            model_config=BaseConfig,
+            class_validators={},
+            schema=field_info,
+        )
+        field.required = required
     if not had_schema and not is_scalar_field(field=field):
-        field.schema = params.Body(schema.default)
+        if PYDANTIC_1:
+            field.field_info = params.Body(field_info.default)
+        else:
+            field.schema = params.Body(field_info.default)  # type: ignore  # pragma: nocover
+
     return field
 
 
-def add_param_to_fields(*, field: Field, dependant: Dependant) -> None:
-    field.schema = cast(params.Param, field.schema)
-    if field.schema.in_ == params.ParamTypes.path:
+def add_param_to_fields(*, field: ModelField, dependant: Dependant) -> None:
+    field_info = cast(params.Param, get_field_info(field))
+    if field_info.in_ == params.ParamTypes.path:
         dependant.path_params.append(field)
-    elif field.schema.in_ == params.ParamTypes.query:
+    elif field_info.in_ == params.ParamTypes.query:
         dependant.query_params.append(field)
-    elif field.schema.in_ == params.ParamTypes.header:
+    elif field_info.in_ == params.ParamTypes.header:
         dependant.header_params.append(field)
     else:
         assert (
-            field.schema.in_ == params.ParamTypes.cookie
+            field_info.in_ == params.ParamTypes.cookie
         ), f"non-body parameters must be in path, query, header or cookie: {field.name}"
         dependant.cookie_params.append(field)
 
 
 def is_coroutine_callable(call: Callable) -> bool:
-    if inspect.isfunction(call):
+    if inspect.isroutine(call):
         return asyncio.iscoroutinefunction(call)
     if inspect.isclass(call):
         return False
@@ -298,6 +420,16 @@ def is_coroutine_callable(call: Callable) -> bool:
     return asyncio.iscoroutinefunction(call)
 
 
+async def solve_generator(
+    *, call: Callable, stack: AsyncExitStack, sub_values: Dict[str, Any]
+) -> Any:
+    if inspect.isgeneratorfunction(call):
+        cm = contextmanager_in_threadpool(contextmanager(call)(**sub_values))
+    elif inspect.isasyncgenfunction(call):
+        cm = asynccontextmanager(call)(**sub_values)
+    return await stack.enter_async_context(cm)
+
+
 async def solve_dependencies(
     *,
     request: Union[Request, WebSocket],
@@ -316,8 +448,12 @@ async def solve_dependencies(
 ]:
     values: Dict[str, Any] = {}
     errors: List[ErrorWrapper] = []
-    response = response or Response(  # type: ignore
-        content=None, status_code=None, headers=None, media_type=None, background=None
+    response = response or Response(
+        content=None,
+        status_code=None,  # type: ignore
+        headers=None,
+        media_type=None,
+        background=None,
     )
     dependency_cache = dependency_cache or {}
     sub_dependant: Dependant
@@ -353,9 +489,13 @@ async def solve_dependencies(
             dependency_overrides_provider=dependency_overrides_provider,
             dependency_cache=dependency_cache,
         )
-        sub_values, sub_errors, background_tasks, sub_response, sub_dependency_cache = (
-            solved_result
-        )
+        (
+            sub_values,
+            sub_errors,
+            background_tasks,
+            sub_response,
+            sub_dependency_cache,
+        ) = solved_result
         sub_response = cast(Response, sub_response)
         response.headers.raw.extend(sub_response.headers.raw)
         if sub_response.status_code:
@@ -366,6 +506,15 @@ async def solve_dependencies(
             continue
         if sub_dependant.use_cache and sub_dependant.cache_key in dependency_cache:
             solved = dependency_cache[sub_dependant.cache_key]
+        elif inspect.isgeneratorfunction(call) or inspect.isasyncgenfunction(call):
+            stack = request.scope.get("fastapi_astack")
+            if stack is None:
+                raise RuntimeError(
+                    async_contextmanager_dependencies_error
+                )  # pragma: no cover
+            solved = await solve_generator(
+                call=call, stack=stack, sub_values=sub_values
+            )
         elif is_coroutine_callable(call):
             solved = await call(**sub_values)
         else:
@@ -392,7 +541,10 @@ async def solve_dependencies(
     values.update(cookie_values)
     errors += path_errors + query_errors + header_errors + cookie_errors
     if dependant.body_params:
-        body_values, body_errors = await request_body_to_args(  # type: ignore # body_params checked above
+        (
+            body_values,
+            body_errors,
+        ) = await request_body_to_args(  # body_params checked above
             required_params=dependant.body_params, received_body=body
         )
         values.update(body_values)
@@ -415,7 +567,7 @@ async def solve_dependencies(
 
 
 def request_params_to_args(
-    required_params: Sequence[Field],
+    required_params: Sequence[ModelField],
     received_params: Union[Mapping[str, Any], QueryParams, Headers],
 ) -> Tuple[Dict[str, Any], List[ErrorWrapper]]:
     values = {}
@@ -427,21 +579,32 @@ def request_params_to_args(
             value = received_params.getlist(field.alias) or field.default
         else:
             value = received_params.get(field.alias)
-        schema = field.schema
-        assert isinstance(schema, params.Param), "Params must be subclasses of Param"
+        field_info = get_field_info(field)
+        assert isinstance(
+            field_info, params.Param
+        ), "Params must be subclasses of Param"
         if value is None:
             if field.required:
-                errors.append(
-                    ErrorWrapper(
-                        MissingError(),
-                        loc=(schema.in_.value, field.alias),
-                        config=BaseConfig,
+                if PYDANTIC_1:
+                    errors.append(
+                        ErrorWrapper(
+                            MissingError(), loc=(field_info.in_.value, field.alias)
+                        )
+                    )
+                else:  # pragma: nocover
+                    errors.append(
+                        ErrorWrapper(  # type: ignore
+                            MissingError(),
+                            loc=(field_info.in_.value, field.alias),
+                            config=BaseConfig,
+                        )
                     )
-                )
             else:
                 values[field.name] = deepcopy(field.default)
             continue
-        v_, errors_ = field.validate(value, values, loc=(schema.in_.value, field.alias))
+        v_, errors_ = field.validate(
+            value, values, loc=(field_info.in_.value, field.alias)
+        )
         if isinstance(errors_, ErrorWrapper):
             errors.append(errors_)
         elif isinstance(errors_, list):
@@ -452,14 +615,15 @@ def request_params_to_args(
 
 
 async def request_body_to_args(
-    required_params: List[Field],
+    required_params: List[ModelField],
     received_body: Optional[Union[Dict[str, Any], FormData]],
 ) -> Tuple[Dict[str, Any], List[ErrorWrapper]]:
     values = {}
     errors = []
     if required_params:
         field = required_params[0]
-        embed = getattr(field.schema, "embed", None)
+        field_info = get_field_info(field)
+        embed = getattr(field_info, "embed", None)
         if len(required_params) == 1 and not embed:
             received_body = {field.alias: received_body}
         for field in required_params:
@@ -473,31 +637,38 @@ async def request_body_to_args(
                     value = received_body.get(field.alias)
             if (
                 value is None
-                or (isinstance(field.schema, params.Form) and value == "")
+                or (isinstance(field_info, params.Form) and value == "")
                 or (
-                    isinstance(field.schema, params.Form)
+                    isinstance(field_info, params.Form)
                     and field.shape in sequence_shapes
                     and len(value) == 0
                 )
             ):
                 if field.required:
-                    errors.append(
-                        ErrorWrapper(
-                            MissingError(), loc=("body", field.alias), config=BaseConfig
+                    if PYDANTIC_1:
+                        errors.append(
+                            ErrorWrapper(MissingError(), loc=("body", field.alias))
+                        )
+                    else:  # pragma: nocover
+                        errors.append(
+                            ErrorWrapper(  # type: ignore
+                                MissingError(),
+                                loc=("body", field.alias),
+                                config=BaseConfig,
+                            )
                         )
-                    )
                 else:
                     values[field.name] = deepcopy(field.default)
                 continue
             if (
-                isinstance(field.schema, params.File)
+                isinstance(field_info, params.File)
                 and lenient_issubclass(field.type_, bytes)
                 and isinstance(value, UploadFile)
             ):
                 value = await value.read()
             elif (
                 field.shape in sequence_shapes
-                and isinstance(field.schema, params.File)
+                and isinstance(field_info, params.File)
                 and lenient_issubclass(field.type_, bytes)
                 and isinstance(value, sequence_types)
             ):
@@ -514,31 +685,45 @@ async def request_body_to_args(
     return values, errors
 
 
-def get_schema_compatible_field(*, field: Field) -> Field:
+def get_schema_compatible_field(*, field: ModelField) -> ModelField:
     out_field = field
     if lenient_issubclass(field.type_, UploadFile):
         use_type: type = bytes
         if field.shape in sequence_shapes:
             use_type = List[bytes]
-        out_field = Field(
-            name=field.name,
-            type_=use_type,
-            class_validators=field.class_validators,
-            model_config=field.model_config,
-            default=field.default,
-            required=field.required,
-            alias=field.alias,
-            schema=field.schema,
-        )
+        if PYDANTIC_1:
+            out_field = ModelField(
+                name=field.name,
+                type_=use_type,
+                class_validators=field.class_validators,
+                model_config=field.model_config,
+                default=field.default,
+                required=field.required,
+                alias=field.alias,
+                field_info=field.field_info,
+            )
+        else:  # pragma: nocover
+            out_field = ModelField(  # type: ignore
+                name=field.name,
+                type_=use_type,
+                class_validators=field.class_validators,
+                model_config=field.model_config,
+                default=field.default,
+                required=field.required,
+                alias=field.alias,
+                schema=field.schema,  # type: ignore
+            )
+
     return out_field
 
 
-def get_body_field(*, dependant: Dependant, name: str) -> Optional[Field]:
+def get_body_field(*, dependant: Dependant, name: str) -> Optional[ModelField]:
     flat_dependant = get_flat_dependant(dependant)
     if not flat_dependant.body_params:
         return None
     first_param = flat_dependant.body_params[0]
-    embed = getattr(first_param.schema, "embed", None)
+    field_info = get_field_info(first_param)
+    embed = getattr(field_info, "embed", None)
     if len(flat_dependant.body_params) == 1 and not embed:
         return get_schema_compatible_field(field=first_param)
     model_name = "Body_" + name
@@ -546,21 +731,46 @@ def get_body_field(*, dependant: Dependant, name: str) -> Optional[Field]:
     for f in flat_dependant.body_params:
         BodyModel.__fields__[f.name] = get_schema_compatible_field(field=f)
     required = any(True for f in flat_dependant.body_params if f.required)
-    if any(isinstance(f.schema, params.File) for f in flat_dependant.body_params):
-        BodySchema: Type[params.Body] = params.File
-    elif any(isinstance(f.schema, params.Form) for f in flat_dependant.body_params):
-        BodySchema = params.Form
-    else:
-        BodySchema = params.Body
 
-    field = Field(
-        name="body",
-        type_=BodyModel,
-        default=None,
-        required=required,
-        model_config=BaseConfig,
-        class_validators={},
-        alias="body",
-        schema=BodySchema(None),
-    )
+    BodyFieldInfo_kwargs: Dict[str, Any] = dict(default=None)
+    if any(
+        isinstance(get_field_info(f), params.File) for f in flat_dependant.body_params
+    ):
+        BodyFieldInfo: Type[params.Body] = params.File
+    elif any(
+        isinstance(get_field_info(f), params.Form) for f in flat_dependant.body_params
+    ):
+        BodyFieldInfo = params.Form
+    else:
+        BodyFieldInfo = params.Body
+
+        body_param_media_types = [
+            getattr(get_field_info(f), "media_type")
+            for f in flat_dependant.body_params
+            if isinstance(get_field_info(f), params.Body)
+        ]
+        if len(set(body_param_media_types)) == 1:
+            BodyFieldInfo_kwargs["media_type"] = body_param_media_types[0]
+    if PYDANTIC_1:
+        field = ModelField(
+            name="body",
+            type_=BodyModel,
+            default=None,
+            required=required,
+            model_config=BaseConfig,
+            class_validators={},
+            alias="body",
+            field_info=BodyFieldInfo(**BodyFieldInfo_kwargs),
+        )
+    else:  # pragma: nocover
+        field = ModelField(  # type: ignore
+            name="body",
+            type_=BodyModel,
+            default=None,
+            required=required,
+            model_config=BaseConfig,
+            class_validators={},
+            alias="body",
+            schema=BodyFieldInfo(**BodyFieldInfo_kwargs),
+        )
     return field

fastapi/encoders.py

@@ -1,34 +1,72 @@
 from enum import Enum
 from types import GeneratorType
-from typing import Any, List, Set
+from typing import Any, Callable, Dict, List, Set, Tuple, Union
 
+from fastapi.logger import logger
+from fastapi.utils import PYDANTIC_1
 from pydantic import BaseModel
 from pydantic.json import ENCODERS_BY_TYPE
 
+SetIntStr = Set[Union[int, str]]
+DictIntStrAny = Dict[Union[int, str], Any]
+
+
+def generate_encoders_by_class_tuples(
+    type_encoder_map: Dict[Any, Callable]
+) -> Dict[Callable, Tuple]:
+    encoders_by_classes: Dict[Callable, List] = {}
+    for type_, encoder in type_encoder_map.items():
+        encoders_by_classes.setdefault(encoder, []).append(type_)
+    encoders_by_class_tuples: Dict[Callable, Tuple] = {}
+    for encoder, classes in encoders_by_classes.items():
+        encoders_by_class_tuples[encoder] = tuple(classes)
+    return encoders_by_class_tuples
+
+
+encoders_by_class_tuples = generate_encoders_by_class_tuples(ENCODERS_BY_TYPE)
+
 
 def jsonable_encoder(
     obj: Any,
-    include: Set[str] = None,
-    exclude: Set[str] = set(),
+    include: Union[SetIntStr, DictIntStrAny] = None,
+    exclude: Union[SetIntStr, DictIntStrAny] = set(),
     by_alias: bool = True,
-    skip_defaults: bool = False,
+    skip_defaults: bool = None,
+    exclude_unset: bool = False,
     include_none: bool = True,
     custom_encoder: dict = {},
     sqlalchemy_safe: bool = True,
 ) -> Any:
+    if skip_defaults is not None:
+        logger.warning(  # pragma: nocover
+            "skip_defaults in jsonable_encoder has been deprecated in favor of "
+            "exclude_unset to keep in line with Pydantic v1, support for it will be "
+            "removed soon."
+        )
     if include is not None and not isinstance(include, set):
         include = set(include)
     if exclude is not None and not isinstance(exclude, set):
         exclude = set(exclude)
     if isinstance(obj, BaseModel):
-        encoder = getattr(obj.Config, "json_encoders", custom_encoder)
-        return jsonable_encoder(
-            obj.dict(
+        encoder = getattr(obj.Config, "json_encoders", {})
+        if custom_encoder:
+            encoder.update(custom_encoder)
+        if PYDANTIC_1:
+            obj_dict = obj.dict(
                 include=include,
                 exclude=exclude,
                 by_alias=by_alias,
-                skip_defaults=skip_defaults,
-            ),
+                exclude_unset=bool(exclude_unset or skip_defaults),
+            )
+        else:  # pragma: nocover
+            obj_dict = obj.dict(
+                include=include,
+                exclude=exclude,
+                by_alias=by_alias,
+                skip_defaults=bool(exclude_unset or skip_defaults),
+            )
+        return jsonable_encoder(
+            obj_dict,
             include_none=include_none,
             custom_encoder=encoder,
             sqlalchemy_safe=sqlalchemy_safe,
@@ -52,7 +90,7 @@ def jsonable_encoder(
                 encoded_key = jsonable_encoder(
                     key,
                     by_alias=by_alias,
-                    skip_defaults=skip_defaults,
+                    exclude_unset=exclude_unset,
                     include_none=include_none,
                     custom_encoder=custom_encoder,
                     sqlalchemy_safe=sqlalchemy_safe,
@@ -60,7 +98,7 @@ def jsonable_encoder(
                 encoded_value = jsonable_encoder(
                     value,
                     by_alias=by_alias,
-                    skip_defaults=skip_defaults,
+                    exclude_unset=exclude_unset,
                     include_none=include_none,
                     custom_encoder=custom_encoder,
                     sqlalchemy_safe=sqlalchemy_safe,
@@ -76,35 +114,42 @@ def jsonable_encoder(
                     include=include,
                     exclude=exclude,
                     by_alias=by_alias,
-                    skip_defaults=skip_defaults,
+                    exclude_unset=exclude_unset,
                     include_none=include_none,
                     custom_encoder=custom_encoder,
                     sqlalchemy_safe=sqlalchemy_safe,
                 )
             )
         return encoded_list
+
+    if custom_encoder:
+        if type(obj) in custom_encoder:
+            return custom_encoder[type(obj)](obj)
+        else:
+            for encoder_type, encoder in custom_encoder.items():
+                if isinstance(obj, encoder_type):
+                    return encoder(obj)
+
+    if type(obj) in ENCODERS_BY_TYPE:
+        return ENCODERS_BY_TYPE[type(obj)](obj)
+    for encoder, classes_tuple in encoders_by_class_tuples.items():
+        if isinstance(obj, classes_tuple):
+            return encoder(obj)
+
     errors: List[Exception] = []
     try:
-        if custom_encoder and type(obj) in custom_encoder:
-            encoder = custom_encoder[type(obj)]
-        else:
-            encoder = ENCODERS_BY_TYPE[type(obj)]
-        return encoder(obj)
-    except KeyError as e:
+        data = dict(obj)
+    except Exception as e:
         errors.append(e)
         try:
-            data = dict(obj)
+            data = vars(obj)
         except Exception as e:
             errors.append(e)
-            try:
-                data = vars(obj)
-            except Exception as e:
-                errors.append(e)
-                raise ValueError(errors)
+            raise ValueError(errors)
     return jsonable_encoder(
         data,
         by_alias=by_alias,
-        skip_defaults=skip_defaults,
+        exclude_unset=exclude_unset,
         include_none=include_none,
         custom_encoder=custom_encoder,
         sqlalchemy_safe=sqlalchemy_safe,

fastapi/exception_handlers.py

@@ -1,3 +1,4 @@
+from fastapi.encoders import jsonable_encoder
 from fastapi.exceptions import RequestValidationError
 from starlette.exceptions import HTTPException
 from starlette.requests import Request
@@ -19,5 +20,6 @@ async def request_validation_exception_handler(
     request: Request, exc: RequestValidationError
 ) -> JSONResponse:
     return JSONResponse(
-        status_code=HTTP_422_UNPROCESSABLE_ENTITY, content={"detail": exc.errors()}
+        status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+        content={"detail": jsonable_encoder(exc.errors())},
     )

fastapi/exceptions.py

@@ -1,7 +1,11 @@
-from typing import Any
+from typing import Any, Sequence
 
-from pydantic import ValidationError
+from fastapi.utils import PYDANTIC_1
+from pydantic import ValidationError, create_model
+from pydantic.error_wrappers import ErrorList
 from starlette.exceptions import HTTPException as StarletteHTTPException
+from starlette.requests import Request
+from starlette.websockets import WebSocket
 
 
 class HTTPException(StarletteHTTPException):
@@ -12,9 +16,21 @@ class HTTPException(StarletteHTTPException):
         self.headers = headers
 
 
+RequestErrorModel = create_model("Request")
+WebSocketErrorModel = create_model("WebSocket")
+
+
 class RequestValidationError(ValidationError):
-    pass
+    def __init__(self, errors: Sequence[ErrorList]) -> None:
+        if PYDANTIC_1:
+            super().__init__(errors, RequestErrorModel)
+        else:
+            super().__init__(errors, Request)  # type: ignore  # pragma: nocover
 
 
 class WebSocketRequestValidationError(ValidationError):
-    pass
+    def __init__(self, errors: Sequence[ErrorList]) -> None:
+        if PYDANTIC_1:
+            super().__init__(errors, WebSocketErrorModel)
+        else:
+            super().__init__(errors, WebSocket)  # type: ignore  # pragma: nocover

fastapi/logger.py

@@ -0,0 +1,3 @@
+import logging
+
+logger = logging.getLogger("fastapi")

fastapi/openapi/constants.py

@@ -1,2 +1,3 @@
 METHODS_WITH_BODY = set(("POST", "PUT", "DELETE", "PATCH"))
+STATUS_CODES_WITH_NO_BODY = set((100, 101, 102, 103, 204, 304))
 REF_PREFIX = "#/components/schemas/"

fastapi/openapi/docs.py

@@ -1,5 +1,7 @@
+import json
 from typing import Optional
 
+from fastapi.encoders import jsonable_encoder
 from starlette.responses import HTMLResponse
 
 
@@ -11,10 +13,11 @@ def get_swagger_ui_html(
     swagger_css_url: str = "https://cdn.jsdelivr.net/npm/swagger-ui-dist@3/swagger-ui.css",
     swagger_favicon_url: str = "https://fastapi.tiangolo.com/img/favicon.png",
     oauth2_redirect_url: Optional[str] = None,
+    init_oauth: Optional[dict] = None,
 ) -> HTMLResponse:
 
     html = f"""
-    <! doctype html>
+    <!DOCTYPE html>
     <html>
     <head>
     <link type="text/css" rel="stylesheet" href="{swagger_css_url}">
@@ -42,7 +45,14 @@ def get_swagger_ui_html(
         ],
         layout: "BaseLayout",
         deepLinking: true
-    })
+    })"""
+
+    if init_oauth:
+        html += f"""
+        ui.initOAuth({json.dumps(jsonable_encoder(init_oauth))})
+        """
+
+    html += """
     </script>
     </body>
     </html>
@@ -56,6 +66,7 @@ def get_redoc_html(
     title: str,
     redoc_js_url: str = "https://cdn.jsdelivr.net/npm/redoc@next/bundles/redoc.standalone.js",
     redoc_favicon_url: str = "https://fastapi.tiangolo.com/img/favicon.png",
+    with_google_fonts: bool = True,
 ) -> HTMLResponse:
     html = f"""
     <!DOCTYPE html>
@@ -65,7 +76,12 @@ def get_redoc_html(
     <!-- needed for adaptive design -->
     <meta charset="utf-8"/>
     <meta name="viewport" content="width=device-width, initial-scale=1">
+    """
+    if with_google_fonts:
+        html += """
     <link href="https://fonts.googleapis.com/css?family=Montserrat:300,400,700|Roboto:300,400,700" rel="stylesheet">
+    """
+    html += f"""
     <link rel="shortcut icon" href="{redoc_favicon_url}">
     <!--
     ReDoc doesn't change outer page styles
@@ -88,7 +104,7 @@ def get_redoc_html(
 
 def get_swagger_ui_oauth2_redirect_html() -> HTMLResponse:
     html = """
-    <!doctype html>
+    <!DOCTYPE html>
     <html lang="en-US">
     <body onload="run()">
     </body>

fastapi/openapi/models.py

@@ -1,21 +1,29 @@
-import logging
 from enum import Enum
 from typing import Any, Dict, List, Optional, Union
 
-from pydantic import BaseModel, Schema as PSchema
-from pydantic.types import UrlStr
+from fastapi.logger import logger
+from pydantic import BaseModel
 
-logger = logging.getLogger("fastapi")
+try:
+    from pydantic import AnyUrl, Field
+except ImportError:  # pragma: nocover
+    # TODO: remove when removing support for Pydantic < 1.0.0
+    from pydantic import Schema as Field  # type: ignore
+    from pydantic import UrlStr as AnyUrl  # type: ignore
 
 try:
     import email_validator
 
     assert email_validator  # make autoflake ignore the unused import
-    from pydantic.types import EmailStr  # type: ignore
+    try:
+        from pydantic import EmailStr
+    except ImportError:  # pragma: nocover
+        # TODO: remove when removing support for Pydantic < 1.0.0
+        from pydantic.types import EmailStr  # type: ignore
 except ImportError:  # pragma: no cover
-    logger.warning(
+    logger.info(
         "email-validator not installed, email fields will be treated as str.\n"
-        + "To install, run: pip install email-validator"
+        "To install, run: pip install email-validator"
     )
 
     class EmailStr(str):  # type: ignore
@@ -24,13 +32,13 @@ except ImportError:  # pragma: no cover
 
 class Contact(BaseModel):
     name: Optional[str] = None
-    url: Optional[UrlStr] = None
+    url: Optional[AnyUrl] = None
     email: Optional[EmailStr] = None
 
 
 class License(BaseModel):
     name: str
-    url: Optional[UrlStr] = None
+    url: Optional[AnyUrl] = None
 
 
 class Info(BaseModel):
@@ -49,13 +57,13 @@ class ServerVariable(BaseModel):
 
 
 class Server(BaseModel):
-    url: UrlStr
+    url: AnyUrl
     description: Optional[str] = None
     variables: Optional[Dict[str, ServerVariable]] = None
 
 
 class Reference(BaseModel):
-    ref: str = PSchema(..., alias="$ref")  # type: ignore
+    ref: str = Field(..., alias="$ref")
 
 
 class Discriminator(BaseModel):
@@ -73,32 +81,32 @@ class XML(BaseModel):
 
 class ExternalDocumentation(BaseModel):
     description: Optional[str] = None
-    url: UrlStr
+    url: AnyUrl
 
 
 class SchemaBase(BaseModel):
-    ref: Optional[str] = PSchema(None, alias="$ref")  # type: ignore
+    ref: Optional[str] = Field(None, alias="$ref")
     title: Optional[str] = None
     multipleOf: Optional[float] = None
     maximum: Optional[float] = None
     exclusiveMaximum: Optional[float] = None
     minimum: Optional[float] = None
     exclusiveMinimum: Optional[float] = None
-    maxLength: Optional[int] = PSchema(None, gte=0)  # type: ignore
-    minLength: Optional[int] = PSchema(None, gte=0)  # type: ignore
+    maxLength: Optional[int] = Field(None, gte=0)
+    minLength: Optional[int] = Field(None, gte=0)
     pattern: Optional[str] = None
-    maxItems: Optional[int] = PSchema(None, gte=0)  # type: ignore
-    minItems: Optional[int] = PSchema(None, gte=0)  # type: ignore
+    maxItems: Optional[int] = Field(None, gte=0)
+    minItems: Optional[int] = Field(None, gte=0)
     uniqueItems: Optional[bool] = None
-    maxProperties: Optional[int] = PSchema(None, gte=0)  # type: ignore
-    minProperties: Optional[int] = PSchema(None, gte=0)  # type: ignore
+    maxProperties: Optional[int] = Field(None, gte=0)
+    minProperties: Optional[int] = Field(None, gte=0)
     required: Optional[List[str]] = None
     enum: Optional[List[str]] = None
     type: Optional[str] = None
     allOf: Optional[List[Any]] = None
     oneOf: Optional[List[Any]] = None
     anyOf: Optional[List[Any]] = None
-    not_: Optional[List[Any]] = PSchema(None, alias="not")  # type: ignore
+    not_: Optional[List[Any]] = Field(None, alias="not")
     items: Optional[Any] = None
     properties: Optional[Dict[str, Any]] = None
     additionalProperties: Optional[Union[Dict[str, Any], bool]] = None
@@ -119,17 +127,17 @@ class Schema(SchemaBase):
     allOf: Optional[List[SchemaBase]] = None
     oneOf: Optional[List[SchemaBase]] = None
     anyOf: Optional[List[SchemaBase]] = None
-    not_: Optional[List[SchemaBase]] = PSchema(None, alias="not")  # type: ignore
+    not_: Optional[List[SchemaBase]] = Field(None, alias="not")
     items: Optional[SchemaBase] = None
     properties: Optional[Dict[str, SchemaBase]] = None
-    additionalProperties: Optional[Union[SchemaBase, bool]] = None  # type: ignore
+    additionalProperties: Optional[Union[Dict[str, Any], bool]] = None
 
 
 class Example(BaseModel):
     summary: Optional[str] = None
     description: Optional[str] = None
     value: Optional[Any] = None
-    externalValue: Optional[UrlStr] = None
+    externalValue: Optional[AnyUrl] = None
 
 
 class ParameterInType(Enum):
@@ -149,9 +157,7 @@ class Encoding(BaseModel):
 
 
 class MediaType(BaseModel):
-    schema_: Optional[Union[Schema, Reference]] = PSchema(  # type: ignore
-        None, alias="schema"
-    )
+    schema_: Optional[Union[Schema, Reference]] = Field(None, alias="schema")
     example: Optional[Any] = None
     examples: Optional[Dict[str, Union[Example, Reference]]] = None
     encoding: Optional[Dict[str, Encoding]] = None
@@ -165,9 +171,7 @@ class ParameterBase(BaseModel):
     style: Optional[str] = None
     explode: Optional[bool] = None
     allowReserved: Optional[bool] = None
-    schema_: Optional[Union[Schema, Reference]] = PSchema(  # type: ignore
-        None, alias="schema"
-    )
+    schema_: Optional[Union[Schema, Reference]] = Field(None, alias="schema")
     example: Optional[Any] = None
     examples: Optional[Dict[str, Union[Example, Reference]]] = None
     # Serialization rules for more complex scenarios
@@ -176,7 +180,7 @@ class ParameterBase(BaseModel):
 
 class Parameter(ParameterBase):
     name: str
-    in_: ParameterInType = PSchema(..., alias="in")  # type: ignore
+    in_: ParameterInType = Field(..., alias="in")
 
 
 class Header(ParameterBase):
@@ -210,10 +214,6 @@ class Response(BaseModel):
     links: Optional[Dict[str, Union[Link, Reference]]] = None
 
 
-class Responses(BaseModel):
-    default: Response
-
-
 class Operation(BaseModel):
     tags: Optional[List[str]] = None
     summary: Optional[str] = None
@@ -222,7 +222,7 @@ class Operation(BaseModel):
     operationId: Optional[str] = None
     parameters: Optional[List[Union[Parameter, Reference]]] = None
     requestBody: Optional[Union[RequestBody, Reference]] = None
-    responses: Union[Responses, Dict[str, Response]]
+    responses: Dict[str, Response]
     # Workaround OpenAPI recursive reference
     callbacks: Optional[Dict[str, Union[Dict[str, Any], Reference]]] = None
     deprecated: Optional[bool] = None
@@ -231,7 +231,7 @@ class Operation(BaseModel):
 
 
 class PathItem(BaseModel):
-    ref: Optional[str] = PSchema(None, alias="$ref")  # type: ignore
+    ref: Optional[str] = Field(None, alias="$ref")
     summary: Optional[str] = None
     description: Optional[str] = None
     get: Optional[Operation] = None
@@ -259,7 +259,7 @@ class SecuritySchemeType(Enum):
 
 
 class SecurityBase(BaseModel):
-    type_: SecuritySchemeType = PSchema(..., alias="type")  # type: ignore
+    type_: SecuritySchemeType = Field(..., alias="type")
     description: Optional[str] = None
 
 
@@ -270,13 +270,13 @@ class APIKeyIn(Enum):
 
 
 class APIKey(SecurityBase):
-    type_ = PSchema(SecuritySchemeType.apiKey, alias="type")  # type: ignore
-    in_: APIKeyIn = PSchema(..., alias="in")  # type: ignore
+    type_ = Field(SecuritySchemeType.apiKey, alias="type")
+    in_: APIKeyIn = Field(..., alias="in")
     name: str
 
 
 class HTTPBase(SecurityBase):
-    type_ = PSchema(SecuritySchemeType.http, alias="type")  # type: ignore
+    type_ = Field(SecuritySchemeType.http, alias="type")
     scheme: str
 
 
@@ -315,12 +315,12 @@ class OAuthFlows(BaseModel):
 
 
 class OAuth2(SecurityBase):
-    type_ = PSchema(SecuritySchemeType.oauth2, alias="type")  # type: ignore
+    type_ = Field(SecuritySchemeType.oauth2, alias="type")
     flows: OAuthFlows
 
 
 class OpenIdConnect(SecurityBase):
-    type_ = PSchema(SecuritySchemeType.openIdConnect, alias="type")  # type: ignore
+    type_ = Field(SecuritySchemeType.openIdConnect, alias="type")
     openIdConnectUrl: str
 
 

fastapi/openapi/utils.py

@@ -5,21 +5,32 @@ from fastapi import routing
 from fastapi.dependencies.models import Dependant
 from fastapi.dependencies.utils import get_flat_dependant
 from fastapi.encoders import jsonable_encoder
-from fastapi.openapi.constants import METHODS_WITH_BODY, REF_PREFIX
+from fastapi.openapi.constants import (
+    METHODS_WITH_BODY,
+    REF_PREFIX,
+    STATUS_CODES_WITH_NO_BODY,
+)
 from fastapi.openapi.models import OpenAPI
 from fastapi.params import Body, Param
 from fastapi.utils import (
     generate_operation_id_for_path,
+    get_field_info,
     get_flat_models_from_routes,
     get_model_definitions,
 )
-from pydantic.fields import Field
+from pydantic import BaseModel
 from pydantic.schema import field_schema, get_model_name_map
 from pydantic.utils import lenient_issubclass
 from starlette.responses import JSONResponse
 from starlette.routing import BaseRoute
 from starlette.status import HTTP_422_UNPROCESSABLE_ENTITY
 
+try:
+    from pydantic.fields import ModelField
+except ImportError:  # pragma: nocover
+    # TODO: remove when removing support for Pydantic < 1.0.0
+    from pydantic.fields import Field as ModelField  # type: ignore
+
 validation_error_definition = {
     "title": "ValidationError",
     "type": "object",
@@ -43,9 +54,18 @@ validation_error_response_definition = {
     },
 }
 
+status_code_ranges: Dict[str, str] = {
+    "1XX": "Information",
+    "2XX": "Success",
+    "3XX": "Redirection",
+    "4XX": "Client Error",
+    "5XX": "Server Error",
+    "DEFAULT": "Default Response",
+}
 
-def get_openapi_params(dependant: Dependant) -> List[Field]:
-    flat_dependant = get_flat_dependant(dependant)
+
+def get_openapi_params(dependant: Dependant) -> List[ModelField]:
+    flat_dependant = get_flat_dependant(dependant, skip_repeats=True)
     return (
         flat_dependant.path_params
         + flat_dependant.query_params
@@ -70,41 +90,37 @@ def get_openapi_security_definitions(flat_dependant: Dependant) -> Tuple[Dict, L
 
 
 def get_openapi_operation_parameters(
-    all_route_params: Sequence[Field]
-) -> Tuple[Dict[str, Dict], List[Dict[str, Any]]]:
-    definitions: Dict[str, Dict] = {}
+    all_route_params: Sequence[ModelField],
+) -> List[Dict[str, Any]]:
     parameters = []
     for param in all_route_params:
-        schema = param.schema
-        schema = cast(Param, schema)
-        if "ValidationError" not in definitions:
-            definitions["ValidationError"] = validation_error_definition
-            definitions["HTTPValidationError"] = validation_error_response_definition
+        field_info = get_field_info(param)
+        field_info = cast(Param, field_info)
         parameter = {
             "name": param.alias,
-            "in": schema.in_.value,
+            "in": field_info.in_.value,
             "required": param.required,
             "schema": field_schema(param, model_name_map={})[0],
         }
-        if schema.description:
-            parameter["description"] = schema.description
-        if schema.deprecated:
-            parameter["deprecated"] = schema.deprecated
+        if field_info.description:
+            parameter["description"] = field_info.description
+        if field_info.deprecated:
+            parameter["deprecated"] = field_info.deprecated
         parameters.append(parameter)
-    return definitions, parameters
+    return parameters
 
 
 def get_openapi_operation_request_body(
-    *, body_field: Optional[Field], model_name_map: Dict[Type, str]
+    *, body_field: Optional[ModelField], model_name_map: Dict[Type[BaseModel], str]
 ) -> Optional[Dict]:
     if not body_field:
         return None
-    assert isinstance(body_field, Field)
+    assert isinstance(body_field, ModelField)
     body_schema, _, _ = field_schema(
         body_field, model_name_map=model_name_map, ref_prefix=REF_PREFIX
     )
-    body_field.schema = cast(Body, body_field.schema)
-    request_media_type = body_field.schema.media_type
+    field_info = cast(Body, get_field_info(body_field))
+    request_media_type = field_info.media_type
     required = body_field.required
     request_body_oai: Dict[str, Any] = {}
     if required:
@@ -146,11 +162,13 @@ def get_openapi_path(
     security_schemes: Dict[str, Any] = {}
     definitions: Dict[str, Any] = {}
     assert route.methods is not None, "Methods must be a list"
+    assert route.response_class, "A response class is needed to generate OpenAPI"
+    route_response_media_type: Optional[str] = route.response_class.media_type
     if route.include_in_schema:
         for method in route.methods:
             operation = get_openapi_operation_metadata(route=route, method=method)
             parameters: List[Dict] = []
-            flat_dependant = get_flat_dependant(route.dependant)
+            flat_dependant = get_flat_dependant(route.dependant, skip_repeats=True)
             security_definitions, operation_security = get_openapi_security_definitions(
                 flat_dependant=flat_dependant
             )
@@ -159,10 +177,7 @@ def get_openapi_path(
             if security_definitions:
                 security_schemes.update(security_definitions)
             all_route_params = get_openapi_params(route.dependant)
-            validation_definitions, operation_parameters = get_openapi_operation_parameters(
-                all_route_params=all_route_params
-            )
-            definitions.update(validation_definitions)
+            operation_parameters = get_openapi_operation_parameters(all_route_params)
             parameters.extend(operation_parameters)
             if parameters:
                 operation["parameters"] = parameters
@@ -172,11 +187,14 @@ def get_openapi_path(
                 )
                 if request_body_oai:
                     operation["requestBody"] = request_body_oai
-                    if "ValidationError" not in definitions:
-                        definitions["ValidationError"] = validation_error_definition
-                        definitions[
-                            "HTTPValidationError"
-                        ] = validation_error_response_definition
+            if route.callbacks:
+                callbacks = {}
+                for callback in route.callbacks:
+                    cb_path, cb_security_schemes, cb_definitions, = get_openapi_path(
+                        route=callback, model_name_map=model_name_map
+                    )
+                    callbacks[callback.name] = {callback.path: cb_path}
+                operation["callbacks"] = callbacks
             if route.responses:
                 for (additional_status_code, response) in route.responses.items():
                     assert isinstance(
@@ -188,36 +206,50 @@ def get_openapi_path(
                             field, model_name_map=model_name_map, ref_prefix=REF_PREFIX
                         )
                         response.setdefault("content", {}).setdefault(
-                            "application/json", {}
+                            route_response_media_type or "application/json", {}
                         )["schema"] = response_schema
-                    status_text = http.client.responses.get(int(additional_status_code))
+                    status_text: Optional[str] = status_code_ranges.get(
+                        str(additional_status_code).upper()
+                    ) or http.client.responses.get(int(additional_status_code))
                     response.setdefault(
                         "description", status_text or "Additional Response"
                     )
-                    operation.setdefault("responses", {})[
-                        str(additional_status_code)
-                    ] = response
+                    status_code_key = str(additional_status_code).upper()
+                    if status_code_key == "DEFAULT":
+                        status_code_key = "default"
+                    operation.setdefault("responses", {})[status_code_key] = response
             status_code = str(route.status_code)
-            response_schema = {"type": "string"}
-            if lenient_issubclass(route.response_class, JSONResponse):
-                if route.response_field:
-                    response_schema, _, _ = field_schema(
-                        route.response_field,
-                        model_name_map=model_name_map,
-                        ref_prefix=REF_PREFIX,
-                    )
-                else:
-                    response_schema = {}
             operation.setdefault("responses", {}).setdefault(status_code, {})[
                 "description"
             ] = route.response_description
-            operation.setdefault("responses", {}).setdefault(
-                status_code, {}
-            ).setdefault("content", {}).setdefault(route.response_class.media_type, {})[
-                "schema"
-            ] = response_schema
-            if all_route_params or route.body_field:
-                operation["responses"][str(HTTP_422_UNPROCESSABLE_ENTITY)] = {
+            if (
+                route_response_media_type
+                and route.status_code not in STATUS_CODES_WITH_NO_BODY
+            ):
+                response_schema = {"type": "string"}
+                if lenient_issubclass(route.response_class, JSONResponse):
+                    if route.response_field:
+                        response_schema, _, _ = field_schema(
+                            route.response_field,
+                            model_name_map=model_name_map,
+                            ref_prefix=REF_PREFIX,
+                        )
+                    else:
+                        response_schema = {}
+                operation.setdefault("responses", {}).setdefault(
+                    status_code, {}
+                ).setdefault("content", {}).setdefault(route_response_media_type, {})[
+                    "schema"
+                ] = response_schema
+
+            http422 = str(HTTP_422_UNPROCESSABLE_ENTITY)
+            if (all_route_params or route.body_field) and not any(
+                [
+                    status in operation["responses"]
+                    for status in [http422, "4XX", "default"]
+                ]
+            ):
+                operation["responses"][http422] = {
                     "description": "Validation Error",
                     "content": {
                         "application/json": {
@@ -225,6 +257,13 @@ def get_openapi_path(
                         }
                     },
                 }
+                if "ValidationError" not in definitions:
+                    definitions.update(
+                        {
+                            "ValidationError": validation_error_definition,
+                            "HTTPValidationError": validation_error_response_definition,
+                        }
+                    )
             path[method.lower()] = operation
     return path, security_schemes, definitions
 
@@ -265,7 +304,7 @@ def get_openapi(
                 if path_definitions:
                     definitions.update(path_definitions)
     if definitions:
-        components.setdefault("schemas", {}).update(definitions)
+        components["schemas"] = {k: definitions[k] for k in sorted(definitions)}
     if components:
         output["components"] = components
     output["paths"] = paths

fastapi/params.py

@@ -1,7 +1,11 @@
 from enum import Enum
 from typing import Any, Callable, Sequence
 
-from pydantic import Schema
+try:
+    from pydantic.fields import FieldInfo
+except ImportError:  # pragma: nocover
+    # TODO: remove when removing support for Pydantic < 1.0.0
+    from pydantic import Schema as FieldInfo  # type: ignore
 
 
 class ParamTypes(Enum):
@@ -11,7 +15,7 @@ class ParamTypes(Enum):
     cookie = "cookie"
 
 
-class Param(Schema):
+class Param(FieldInfo):
     in_: ParamTypes
 
     def __init__(
@@ -199,7 +203,7 @@ class Cookie(Param):
         )
 
 
-class Body(Schema):
+class Body(FieldInfo):
     def __init__(
         self,
         default: Any,

fastapi/routing.py

@@ -1,6 +1,5 @@
 import asyncio
 import inspect
-import logging
 from typing import Any, Callable, Dict, List, Optional, Sequence, Set, Type, Union
 
 from fastapi import params
@@ -11,12 +10,19 @@ from fastapi.dependencies.utils import (
     get_parameterless_sub_dependant,
     solve_dependencies,
 )
-from fastapi.encoders import jsonable_encoder
+from fastapi.encoders import DictIntStrAny, SetIntStr, jsonable_encoder
 from fastapi.exceptions import RequestValidationError, WebSocketRequestValidationError
-from fastapi.utils import create_cloned_field, generate_operation_id_for_path
-from pydantic import BaseConfig, BaseModel, Schema
+from fastapi.logger import logger
+from fastapi.openapi.constants import STATUS_CODES_WITH_NO_BODY
+from fastapi.utils import (
+    PYDANTIC_1,
+    create_cloned_field,
+    generate_operation_id_for_path,
+    get_field_info,
+    warning_response_model_skip_defaults_deprecated,
+)
+from pydantic import BaseConfig, BaseModel
 from pydantic.error_wrappers import ErrorWrapper, ValidationError
-from pydantic.fields import Field
 from pydantic.utils import lenient_issubclass
 from starlette import routing
 from starlette.concurrency import run_in_threadpool
@@ -33,51 +39,63 @@ from starlette.status import WS_1008_POLICY_VIOLATION
 from starlette.types import ASGIApp
 from starlette.websockets import WebSocket
 
+try:
+    from pydantic.fields import FieldInfo, ModelField
+except ImportError:  # pragma: nocover
+    # TODO: remove when removing support for Pydantic < 1.0.0
+    from pydantic import Schema as FieldInfo  # type: ignore
+    from pydantic.fields import Field as ModelField  # type: ignore
+
 
 def serialize_response(
     *,
-    field: Field = None,
+    field: ModelField = None,
     response: Response,
-    include: Set[str] = None,
-    exclude: Set[str] = set(),
+    include: Union[SetIntStr, DictIntStrAny] = None,
+    exclude: Union[SetIntStr, DictIntStrAny] = set(),
     by_alias: bool = True,
-    skip_defaults: bool = False,
+    exclude_unset: bool = False,
 ) -> Any:
     if field:
         errors = []
+        if exclude_unset and isinstance(response, BaseModel):
+            if PYDANTIC_1:
+                response = response.dict(exclude_unset=exclude_unset)
+            else:
+                response = response.dict(skip_defaults=exclude_unset)  # pragma: nocover
         value, errors_ = field.validate(response, {}, loc=("response",))
         if isinstance(errors_, ErrorWrapper):
             errors.append(errors_)
         elif isinstance(errors_, list):
             errors.extend(errors_)
         if errors:
-            raise ValidationError(errors)
+            raise ValidationError(errors, field.type_)
         return jsonable_encoder(
             value,
             include=include,
             exclude=exclude,
             by_alias=by_alias,
-            skip_defaults=skip_defaults,
+            exclude_unset=exclude_unset,
         )
     else:
         return jsonable_encoder(response)
 
 
-def get_app(
+def get_request_handler(
     dependant: Dependant,
-    body_field: Field = None,
+    body_field: ModelField = None,
     status_code: int = 200,
     response_class: Type[Response] = JSONResponse,
-    response_field: Field = None,
-    response_model_include: Set[str] = None,
-    response_model_exclude: Set[str] = set(),
+    response_field: ModelField = None,
+    response_model_include: Union[SetIntStr, DictIntStrAny] = None,
+    response_model_exclude: Union[SetIntStr, DictIntStrAny] = set(),
     response_model_by_alias: bool = True,
-    response_model_skip_defaults: bool = False,
+    response_model_exclude_unset: bool = False,
     dependency_overrides_provider: Any = None,
 ) -> Callable:
     assert dependant.call is not None, "dependant.call must be a function"
     is_coroutine = asyncio.iscoroutinefunction(dependant.call)
-    is_body_form = body_field and isinstance(body_field.schema, params.Form)
+    is_body_form = body_field and isinstance(get_field_info(body_field), params.Form)
 
     async def app(request: Request) -> Response:
         try:
@@ -90,7 +108,7 @@ def get_app(
                     if body_bytes:
                         body = await request.json()
         except Exception as e:
-            logging.error(f"Error getting request body: {e}")
+            logger.error(f"Error getting request body: {e}")
             raise HTTPException(
                 status_code=400, detail="There was an error parsing the body"
             ) from e
@@ -119,7 +137,7 @@ def get_app(
                 include=response_model_include,
                 exclude=response_model_exclude,
                 by_alias=response_model_by_alias,
-                skip_defaults=response_model_skip_defaults,
+                exclude_unset=response_model_exclude_unset,
             )
             response = response_class(
                 content=response_data,
@@ -193,15 +211,15 @@ class APIRoute(routing.Route):
         name: str = None,
         methods: Optional[Union[Set[str], List[str]]] = None,
         operation_id: str = None,
-        response_model_include: Set[str] = None,
-        response_model_exclude: Set[str] = set(),
+        response_model_include: Union[SetIntStr, DictIntStrAny] = None,
+        response_model_exclude: Union[SetIntStr, DictIntStrAny] = set(),
         response_model_by_alias: bool = True,
-        response_model_skip_defaults: bool = False,
+        response_model_exclude_unset: bool = False,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Optional[Type[Response]] = None,
         dependency_overrides_provider: Any = None,
+        callbacks: Optional[List["APIRoute"]] = None,
     ) -> None:
-        assert path.startswith("/"), "Routed paths must always start with '/'"
         self.path = path
         self.endpoint = endpoint
         self.name = get_name(endpoint) if name is None else name
@@ -214,19 +232,30 @@ class APIRoute(routing.Route):
         )
         self.response_model = response_model
         if self.response_model:
-            assert lenient_issubclass(
-                response_class, JSONResponse
-            ), "To declare a type the response must be a JSON response"
+            assert (
+                status_code not in STATUS_CODES_WITH_NO_BODY
+            ), f"Status code {status_code} must not have a response body"
             response_name = "Response_" + self.unique_id
-            self.response_field: Optional[Field] = Field(
-                name=response_name,
-                type_=self.response_model,
-                class_validators={},
-                default=None,
-                required=False,
-                model_config=BaseConfig,
-                schema=Schema(None),
-            )
+            if PYDANTIC_1:
+                self.response_field: Optional[ModelField] = ModelField(
+                    name=response_name,
+                    type_=self.response_model,
+                    class_validators={},
+                    default=None,
+                    required=False,
+                    model_config=BaseConfig,
+                    field_info=FieldInfo(None),
+                )
+            else:
+                self.response_field: Optional[ModelField] = ModelField(  # type: ignore  # pragma: nocover
+                    name=response_name,
+                    type_=self.response_model,
+                    class_validators={},
+                    default=None,
+                    required=False,
+                    model_config=BaseConfig,
+                    schema=FieldInfo(None),
+                )
             # Create a clone of the field, so that a Pydantic submodel is not returned
             # as is just because it's an instance of a subclass of a more limited class
             # e.g. UserInDB (containing hashed_password) could be a subclass of User
@@ -234,9 +263,9 @@ class APIRoute(routing.Route):
             # would pass the validation and be returned as is.
             # By being a new field, no inheritance will be passed as is. A new model
             # will be always created.
-            self.secure_cloned_response_field: Optional[Field] = create_cloned_field(
-                self.response_field
-            )
+            self.secure_cloned_response_field: Optional[
+                ModelField
+            ] = create_cloned_field(self.response_field)
         else:
             self.response_field = None
             self.secure_cloned_response_field = None
@@ -248,6 +277,9 @@ class APIRoute(routing.Route):
             self.dependencies = []
         self.summary = summary
         self.description = description or inspect.cleandoc(self.endpoint.__doc__ or "")
+        # if a "form feed" character (page break) is found in the description text,
+        # truncate description text to the content preceding the first "form feed"
+        self.description = self.description.split("\f")[0]
         self.response_description = response_description
         self.responses = responses or {}
         response_fields = {}
@@ -255,22 +287,36 @@ class APIRoute(routing.Route):
             assert isinstance(response, dict), "An additional response must be a dict"
             model = response.get("model")
             if model:
+                assert (
+                    additional_status_code not in STATUS_CODES_WITH_NO_BODY
+                ), f"Status code {additional_status_code} must not have a response body"
                 assert lenient_issubclass(
                     model, BaseModel
                 ), "A response model must be a Pydantic model"
                 response_name = f"Response_{additional_status_code}_{self.unique_id}"
-                response_field = Field(
-                    name=response_name,
-                    type_=model,
-                    class_validators=None,
-                    default=None,
-                    required=False,
-                    model_config=BaseConfig,
-                    schema=Schema(None),
-                )
+                if PYDANTIC_1:
+                    response_field = ModelField(
+                        name=response_name,
+                        type_=model,
+                        class_validators=None,
+                        default=None,
+                        required=False,
+                        model_config=BaseConfig,
+                        field_info=FieldInfo(None),
+                    )
+                else:
+                    response_field = ModelField(  # type: ignore  # pragma: nocover
+                        name=response_name,
+                        type_=model,
+                        class_validators=None,
+                        default=None,
+                        required=False,
+                        model_config=BaseConfig,
+                        schema=FieldInfo(None),
+                    )
                 response_fields[additional_status_code] = response_field
         if response_fields:
-            self.response_fields: Dict[Union[int, str], Field] = response_fields
+            self.response_fields: Dict[Union[int, str], ModelField] = response_fields
         else:
             self.response_fields = {}
         self.deprecated = deprecated
@@ -278,7 +324,7 @@ class APIRoute(routing.Route):
         self.response_model_include = response_model_include
         self.response_model_exclude = response_model_exclude
         self.response_model_by_alias = response_model_by_alias
-        self.response_model_skip_defaults = response_model_skip_defaults
+        self.response_model_exclude_unset = response_model_exclude_unset
         self.include_in_schema = include_in_schema
         self.response_class = response_class
 
@@ -293,19 +339,21 @@ class APIRoute(routing.Route):
             )
         self.body_field = get_body_field(dependant=self.dependant, name=self.unique_id)
         self.dependency_overrides_provider = dependency_overrides_provider
-        self.app = request_response(
-            get_app(
-                dependant=self.dependant,
-                body_field=self.body_field,
-                status_code=self.status_code,
-                response_class=self.response_class,
-                response_field=self.secure_cloned_response_field,
-                response_model_include=self.response_model_include,
-                response_model_exclude=self.response_model_exclude,
-                response_model_by_alias=self.response_model_by_alias,
-                response_model_skip_defaults=self.response_model_skip_defaults,
-                dependency_overrides_provider=self.dependency_overrides_provider,
-            )
+        self.callbacks = callbacks
+        self.app = request_response(self.get_route_handler())
+
+    def get_route_handler(self) -> Callable:
+        return get_request_handler(
+            dependant=self.dependant,
+            body_field=self.body_field,
+            status_code=self.status_code,
+            response_class=self.response_class or JSONResponse,
+            response_field=self.secure_cloned_response_field,
+            response_model_include=self.response_model_include,
+            response_model_exclude=self.response_model_exclude,
+            response_model_by_alias=self.response_model_by_alias,
+            response_model_exclude_unset=self.response_model_exclude_unset,
+            dependency_overrides_provider=self.dependency_overrides_provider,
         )
 
 
@@ -316,11 +364,15 @@ class APIRouter(routing.Router):
         redirect_slashes: bool = True,
         default: ASGIApp = None,
         dependency_overrides_provider: Any = None,
+        route_class: Type[APIRoute] = APIRoute,
+        default_response_class: Type[Response] = None,
     ) -> None:
         super().__init__(
             routes=routes, redirect_slashes=redirect_slashes, default=default
         )
         self.dependency_overrides_provider = dependency_overrides_provider
+        self.route_class = route_class
+        self.default_response_class = default_response_class
 
     def add_api_route(
         self,
@@ -338,15 +390,21 @@ class APIRouter(routing.Router):
         deprecated: bool = None,
         methods: Optional[Union[Set[str], List[str]]] = None,
         operation_id: str = None,
-        response_model_include: Set[str] = None,
-        response_model_exclude: Set[str] = set(),
+        response_model_include: Union[SetIntStr, DictIntStrAny] = None,
+        response_model_exclude: Union[SetIntStr, DictIntStrAny] = set(),
         response_model_by_alias: bool = True,
-        response_model_skip_defaults: bool = False,
+        response_model_skip_defaults: bool = None,
+        response_model_exclude_unset: bool = False,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
+        route_class_override: Optional[Type[APIRoute]] = None,
+        callbacks: List[APIRoute] = None,
     ) -> None:
-        route = APIRoute(
+        if response_model_skip_defaults is not None:
+            warning_response_model_skip_defaults_deprecated()  # pragma: nocover
+        route_class = route_class_override or self.route_class
+        route = route_class(
             path,
             endpoint=endpoint,
             response_model=response_model,
@@ -363,11 +421,14 @@ class APIRouter(routing.Router):
             response_model_include=response_model_include,
             response_model_exclude=response_model_exclude,
             response_model_by_alias=response_model_by_alias,
-            response_model_skip_defaults=response_model_skip_defaults,
+            response_model_exclude_unset=bool(
+                response_model_exclude_unset or response_model_skip_defaults
+            ),
             include_in_schema=include_in_schema,
-            response_class=response_class,
+            response_class=response_class or self.default_response_class,
             name=name,
             dependency_overrides_provider=self.dependency_overrides_provider,
+            callbacks=callbacks,
         )
         self.routes.append(route)
 
@@ -386,14 +447,19 @@ class APIRouter(routing.Router):
         deprecated: bool = None,
         methods: List[str] = None,
         operation_id: str = None,
-        response_model_include: Set[str] = None,
-        response_model_exclude: Set[str] = set(),
+        response_model_include: Union[SetIntStr, DictIntStrAny] = None,
+        response_model_exclude: Union[SetIntStr, DictIntStrAny] = set(),
         response_model_by_alias: bool = True,
-        response_model_skip_defaults: bool = False,
+        response_model_skip_defaults: bool = None,
+        response_model_exclude_unset: bool = False,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
+        callbacks: List[APIRoute] = None,
     ) -> Callable:
+        if response_model_skip_defaults is not None:
+            warning_response_model_skip_defaults_deprecated()  # pragma: nocover
+
         def decorator(func: Callable) -> Callable:
             self.add_api_route(
                 path,
@@ -412,10 +478,13 @@ class APIRouter(routing.Router):
                 response_model_include=response_model_include,
                 response_model_exclude=response_model_exclude,
                 response_model_by_alias=response_model_by_alias,
-                response_model_skip_defaults=response_model_skip_defaults,
+                response_model_exclude_unset=bool(
+                    response_model_exclude_unset or response_model_skip_defaults
+                ),
                 include_in_schema=include_in_schema,
-                response_class=response_class,
+                response_class=response_class or self.default_response_class,
                 name=name,
+                callbacks=callbacks,
             )
             return func
 
@@ -442,12 +511,21 @@ class APIRouter(routing.Router):
         tags: List[str] = None,
         dependencies: Sequence[params.Depends] = None,
         responses: Dict[Union[int, str], Dict[str, Any]] = None,
+        default_response_class: Optional[Type[Response]] = None,
     ) -> None:
         if prefix:
             assert prefix.startswith("/"), "A path prefix must start with '/'"
             assert not prefix.endswith(
                 "/"
             ), "A path prefix must not end with '/', as the routes will start with '/'"
+        else:
+            for r in router.routes:
+                path = getattr(r, "path")
+                name = getattr(r, "name", "unknown")
+                if path is not None and not path:
+                    raise Exception(
+                        f"Prefix and path cannot be both empty (path operation: {name})"
+                    )
         if responses is None:
             responses = {}
         for route in router.routes:
@@ -471,10 +549,12 @@ class APIRouter(routing.Router):
                     response_model_include=route.response_model_include,
                     response_model_exclude=route.response_model_exclude,
                     response_model_by_alias=route.response_model_by_alias,
-                    response_model_skip_defaults=route.response_model_skip_defaults,
+                    response_model_exclude_unset=route.response_model_exclude_unset,
                     include_in_schema=route.include_in_schema,
-                    response_class=route.response_class,
+                    response_class=route.response_class or default_response_class,
                     name=route.name,
+                    route_class_override=type(route),
+                    callbacks=route.callbacks,
                 )
             elif isinstance(route, routing.Route):
                 self.add_route(
@@ -507,15 +587,18 @@ class APIRouter(routing.Router):
         responses: Dict[Union[int, str], Dict[str, Any]] = None,
         deprecated: bool = None,
         operation_id: str = None,
-        response_model_include: Set[str] = None,
-        response_model_exclude: Set[str] = set(),
+        response_model_include: Union[SetIntStr, DictIntStrAny] = None,
+        response_model_exclude: Union[SetIntStr, DictIntStrAny] = set(),
         response_model_by_alias: bool = True,
-        response_model_skip_defaults: bool = False,
+        response_model_skip_defaults: bool = None,
+        response_model_exclude_unset: bool = False,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
+        callbacks: List[APIRoute] = None,
     ) -> Callable:
-
+        if response_model_skip_defaults is not None:
+            warning_response_model_skip_defaults_deprecated()  # pragma: nocover
         return self.api_route(
             path=path,
             response_model=response_model,
@@ -532,10 +615,13 @@ class APIRouter(routing.Router):
             response_model_include=response_model_include,
             response_model_exclude=response_model_exclude,
             response_model_by_alias=response_model_by_alias,
-            response_model_skip_defaults=response_model_skip_defaults,
+            response_model_exclude_unset=bool(
+                response_model_exclude_unset or response_model_skip_defaults
+            ),
             include_in_schema=include_in_schema,
-            response_class=response_class,
+            response_class=response_class or self.default_response_class,
             name=name,
+            callbacks=callbacks,
         )
 
     def put(
@@ -552,14 +638,18 @@ class APIRouter(routing.Router):
         responses: Dict[Union[int, str], Dict[str, Any]] = None,
         deprecated: bool = None,
         operation_id: str = None,
-        response_model_include: Set[str] = None,
-        response_model_exclude: Set[str] = set(),
+        response_model_include: Union[SetIntStr, DictIntStrAny] = None,
+        response_model_exclude: Union[SetIntStr, DictIntStrAny] = set(),
         response_model_by_alias: bool = True,
-        response_model_skip_defaults: bool = False,
+        response_model_skip_defaults: bool = None,
+        response_model_exclude_unset: bool = False,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
+        callbacks: List[APIRoute] = None,
     ) -> Callable:
+        if response_model_skip_defaults is not None:
+            warning_response_model_skip_defaults_deprecated()  # pragma: nocover
         return self.api_route(
             path=path,
             response_model=response_model,
@@ -576,10 +666,13 @@ class APIRouter(routing.Router):
             response_model_include=response_model_include,
             response_model_exclude=response_model_exclude,
             response_model_by_alias=response_model_by_alias,
-            response_model_skip_defaults=response_model_skip_defaults,
+            response_model_exclude_unset=bool(
+                response_model_exclude_unset or response_model_skip_defaults
+            ),
             include_in_schema=include_in_schema,
-            response_class=response_class,
+            response_class=response_class or self.default_response_class,
             name=name,
+            callbacks=callbacks,
         )
 
     def post(
@@ -596,14 +689,18 @@ class APIRouter(routing.Router):
         responses: Dict[Union[int, str], Dict[str, Any]] = None,
         deprecated: bool = None,
         operation_id: str = None,
-        response_model_include: Set[str] = None,
-        response_model_exclude: Set[str] = set(),
+        response_model_include: Union[SetIntStr, DictIntStrAny] = None,
+        response_model_exclude: Union[SetIntStr, DictIntStrAny] = set(),
         response_model_by_alias: bool = True,
-        response_model_skip_defaults: bool = False,
+        response_model_skip_defaults: bool = None,
+        response_model_exclude_unset: bool = False,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
+        callbacks: List[APIRoute] = None,
     ) -> Callable:
+        if response_model_skip_defaults is not None:
+            warning_response_model_skip_defaults_deprecated()  # pragma: nocover
         return self.api_route(
             path=path,
             response_model=response_model,
@@ -620,10 +717,13 @@ class APIRouter(routing.Router):
             response_model_include=response_model_include,
             response_model_exclude=response_model_exclude,
             response_model_by_alias=response_model_by_alias,
-            response_model_skip_defaults=response_model_skip_defaults,
+            response_model_exclude_unset=bool(
+                response_model_exclude_unset or response_model_skip_defaults
+            ),
             include_in_schema=include_in_schema,
-            response_class=response_class,
+            response_class=response_class or self.default_response_class,
             name=name,
+            callbacks=callbacks,
         )
 
     def delete(
@@ -640,14 +740,18 @@ class APIRouter(routing.Router):
         responses: Dict[Union[int, str], Dict[str, Any]] = None,
         deprecated: bool = None,
         operation_id: str = None,
-        response_model_include: Set[str] = None,
-        response_model_exclude: Set[str] = set(),
+        response_model_include: Union[SetIntStr, DictIntStrAny] = None,
+        response_model_exclude: Union[SetIntStr, DictIntStrAny] = set(),
         response_model_by_alias: bool = True,
-        response_model_skip_defaults: bool = False,
+        response_model_skip_defaults: bool = None,
+        response_model_exclude_unset: bool = False,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
+        callbacks: List[APIRoute] = None,
     ) -> Callable:
+        if response_model_skip_defaults is not None:
+            warning_response_model_skip_defaults_deprecated()  # pragma: nocover
         return self.api_route(
             path=path,
             response_model=response_model,
@@ -664,10 +768,13 @@ class APIRouter(routing.Router):
             response_model_include=response_model_include,
             response_model_exclude=response_model_exclude,
             response_model_by_alias=response_model_by_alias,
-            response_model_skip_defaults=response_model_skip_defaults,
+            response_model_exclude_unset=bool(
+                response_model_exclude_unset or response_model_skip_defaults
+            ),
             include_in_schema=include_in_schema,
-            response_class=response_class,
+            response_class=response_class or self.default_response_class,
             name=name,
+            callbacks=callbacks,
         )
 
     def options(
@@ -684,14 +791,18 @@ class APIRouter(routing.Router):
         responses: Dict[Union[int, str], Dict[str, Any]] = None,
         deprecated: bool = None,
         operation_id: str = None,
-        response_model_include: Set[str] = None,
-        response_model_exclude: Set[str] = set(),
+        response_model_include: Union[SetIntStr, DictIntStrAny] = None,
+        response_model_exclude: Union[SetIntStr, DictIntStrAny] = set(),
         response_model_by_alias: bool = True,
-        response_model_skip_defaults: bool = False,
+        response_model_skip_defaults: bool = None,
+        response_model_exclude_unset: bool = False,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
+        callbacks: List[APIRoute] = None,
     ) -> Callable:
+        if response_model_skip_defaults is not None:
+            warning_response_model_skip_defaults_deprecated()  # pragma: nocover
         return self.api_route(
             path=path,
             response_model=response_model,
@@ -708,10 +819,13 @@ class APIRouter(routing.Router):
             response_model_include=response_model_include,
             response_model_exclude=response_model_exclude,
             response_model_by_alias=response_model_by_alias,
-            response_model_skip_defaults=response_model_skip_defaults,
+            response_model_exclude_unset=bool(
+                response_model_exclude_unset or response_model_skip_defaults
+            ),
             include_in_schema=include_in_schema,
-            response_class=response_class,
+            response_class=response_class or self.default_response_class,
             name=name,
+            callbacks=callbacks,
         )
 
     def head(
@@ -728,14 +842,18 @@ class APIRouter(routing.Router):
         responses: Dict[Union[int, str], Dict[str, Any]] = None,
         deprecated: bool = None,
         operation_id: str = None,
-        response_model_include: Set[str] = None,
-        response_model_exclude: Set[str] = set(),
+        response_model_include: Union[SetIntStr, DictIntStrAny] = None,
+        response_model_exclude: Union[SetIntStr, DictIntStrAny] = set(),
         response_model_by_alias: bool = True,
-        response_model_skip_defaults: bool = False,
+        response_model_skip_defaults: bool = None,
+        response_model_exclude_unset: bool = False,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
+        callbacks: List[APIRoute] = None,
     ) -> Callable:
+        if response_model_skip_defaults is not None:
+            warning_response_model_skip_defaults_deprecated()  # pragma: nocover
         return self.api_route(
             path=path,
             response_model=response_model,
@@ -752,10 +870,13 @@ class APIRouter(routing.Router):
             response_model_include=response_model_include,
             response_model_exclude=response_model_exclude,
             response_model_by_alias=response_model_by_alias,
-            response_model_skip_defaults=response_model_skip_defaults,
+            response_model_exclude_unset=bool(
+                response_model_exclude_unset or response_model_skip_defaults
+            ),
             include_in_schema=include_in_schema,
-            response_class=response_class,
+            response_class=response_class or self.default_response_class,
             name=name,
+            callbacks=callbacks,
         )
 
     def patch(
@@ -772,14 +893,18 @@ class APIRouter(routing.Router):
         responses: Dict[Union[int, str], Dict[str, Any]] = None,
         deprecated: bool = None,
         operation_id: str = None,
-        response_model_include: Set[str] = None,
-        response_model_exclude: Set[str] = set(),
+        response_model_include: Union[SetIntStr, DictIntStrAny] = None,
+        response_model_exclude: Union[SetIntStr, DictIntStrAny] = set(),
         response_model_by_alias: bool = True,
-        response_model_skip_defaults: bool = False,
+        response_model_skip_defaults: bool = None,
+        response_model_exclude_unset: bool = False,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
+        callbacks: List[APIRoute] = None,
     ) -> Callable:
+        if response_model_skip_defaults is not None:
+            warning_response_model_skip_defaults_deprecated()  # pragma: nocover
         return self.api_route(
             path=path,
             response_model=response_model,
@@ -796,10 +921,13 @@ class APIRouter(routing.Router):
             response_model_include=response_model_include,
             response_model_exclude=response_model_exclude,
             response_model_by_alias=response_model_by_alias,
-            response_model_skip_defaults=response_model_skip_defaults,
+            response_model_exclude_unset=bool(
+                response_model_exclude_unset or response_model_skip_defaults
+            ),
             include_in_schema=include_in_schema,
-            response_class=response_class,
+            response_class=response_class or self.default_response_class,
             name=name,
+            callbacks=callbacks,
         )
 
     def trace(
@@ -816,14 +944,18 @@ class APIRouter(routing.Router):
         responses: Dict[Union[int, str], Dict[str, Any]] = None,
         deprecated: bool = None,
         operation_id: str = None,
-        response_model_include: Set[str] = None,
-        response_model_exclude: Set[str] = set(),
+        response_model_include: Union[SetIntStr, DictIntStrAny] = None,
+        response_model_exclude: Union[SetIntStr, DictIntStrAny] = set(),
         response_model_by_alias: bool = True,
-        response_model_skip_defaults: bool = False,
+        response_model_skip_defaults: bool = None,
+        response_model_exclude_unset: bool = False,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
+        callbacks: List[APIRoute] = None,
     ) -> Callable:
+        if response_model_skip_defaults is not None:
+            warning_response_model_skip_defaults_deprecated()  # pragma: nocover
         return self.api_route(
             path=path,
             response_model=response_model,
@@ -840,8 +972,11 @@ class APIRouter(routing.Router):
             response_model_include=response_model_include,
             response_model_exclude=response_model_exclude,
             response_model_by_alias=response_model_by_alias,
-            response_model_skip_defaults=response_model_skip_defaults,
+            response_model_exclude_unset=bool(
+                response_model_exclude_unset or response_model_skip_defaults
+            ),
             include_in_schema=include_in_schema,
-            response_class=response_class,
+            response_class=response_class or self.default_response_class,
             name=name,
+            callbacks=callbacks,
         )

fastapi/security/__init__.py

@@ -8,6 +8,7 @@ from .http import (
 )
 from .oauth2 import (
     OAuth2,
+    OAuth2AuthorizationCodeBearer,
     OAuth2PasswordBearer,
     OAuth2PasswordRequestForm,
     SecurityScopes,

fastapi/security/oauth2.py

@@ -163,6 +163,43 @@ class OAuth2PasswordBearer(OAuth2):
         return param
 
 
+class OAuth2AuthorizationCodeBearer(OAuth2):
+    def __init__(
+        self,
+        authorizationUrl: str,
+        tokenUrl: str,
+        refreshUrl: str = None,
+        scheme_name: str = None,
+        scopes: dict = None,
+        auto_error: bool = True,
+    ):
+        if not scopes:
+            scopes = {}
+        flows = OAuthFlowsModel(
+            authorizationCode={
+                "authorizationUrl": authorizationUrl,
+                "tokenUrl": tokenUrl,
+                "refreshUrl": refreshUrl,
+                "scopes": scopes,
+            }
+        )
+        super().__init__(flows=flows, scheme_name=scheme_name, auto_error=auto_error)
+
+    async def __call__(self, request: Request) -> Optional[str]:
+        authorization: str = request.headers.get("Authorization")
+        scheme, param = get_authorization_scheme_param(authorization)
+        if not authorization or scheme.lower() != "bearer":
+            if self.auto_error:
+                raise HTTPException(
+                    status_code=HTTP_401_UNAUTHORIZED,
+                    detail="Not authenticated",
+                    headers={"WWW-Authenticate": "Bearer"},
+                )
+            else:
+                return None  # pragma: nocover
+        return param
+
+
 class SecurityScopes:
     def __init__(self, scopes: List[str] = None):
         self.scopes = scopes or []

fastapi/utils.py

@@ -1,32 +1,68 @@
 import re
+from dataclasses import is_dataclass
 from typing import Any, Dict, List, Sequence, Set, Type, cast
 
 from fastapi import routing
+from fastapi.logger import logger
 from fastapi.openapi.constants import REF_PREFIX
-from pydantic import BaseConfig, BaseModel, Schema, create_model
-from pydantic.fields import Field
+from pydantic import BaseConfig, BaseModel, create_model
 from pydantic.schema import get_flat_models_from_fields, model_process_schema
 from pydantic.utils import lenient_issubclass
 from starlette.routing import BaseRoute
 
+try:
+    from pydantic.fields import FieldInfo, ModelField
+
+    PYDANTIC_1 = True
+except ImportError:  # pragma: nocover
+    # TODO: remove when removing support for Pydantic < 1.0.0
+    from pydantic.fields import Field as ModelField  # type: ignore
+    from pydantic import Schema as FieldInfo  # type: ignore
+
+    logger.warning(
+        "Pydantic versions < 1.0.0 are deprecated in FastAPI and support will be "
+        "removed soon."
+    )
+    PYDANTIC_1 = False
+
+
+# TODO: remove when removing support for Pydantic < 1.0.0
+def get_field_info(field: ModelField) -> FieldInfo:
+    if PYDANTIC_1:
+        return field.field_info  # type: ignore
+    else:
+        return field.schema  # type: ignore  # pragma: nocover
+
+
+# TODO: remove when removing support for Pydantic < 1.0.0
+def warning_response_model_skip_defaults_deprecated() -> None:
+    logger.warning(  # pragma: nocover
+        "response_model_skip_defaults has been deprecated in favor of "
+        "response_model_exclude_unset to keep in line with Pydantic v1, support for "
+        "it will be removed soon."
+    )
+
 
 def get_flat_models_from_routes(routes: Sequence[BaseRoute]) -> Set[Type[BaseModel]]:
-    body_fields_from_routes: List[Field] = []
-    responses_from_routes: List[Field] = []
+    body_fields_from_routes: List[ModelField] = []
+    responses_from_routes: List[ModelField] = []
+    callback_flat_models: Set[Type[BaseModel]] = set()
     for route in routes:
         if getattr(route, "include_in_schema", None) and isinstance(
             route, routing.APIRoute
         ):
             if route.body_field:
                 assert isinstance(
-                    route.body_field, Field
+                    route.body_field, ModelField
                 ), "A request body must be a Pydantic Field"
                 body_fields_from_routes.append(route.body_field)
             if route.response_field:
                 responses_from_routes.append(route.response_field)
             if route.response_fields:
                 responses_from_routes.extend(route.response_fields.values())
-    flat_models = get_flat_models_from_fields(
+            if route.callbacks:
+                callback_flat_models |= get_flat_models_from_routes(route.callbacks)
+    flat_models = callback_flat_models | get_flat_models_from_fields(
         body_fields_from_routes + responses_from_routes, known_models=set()
     )
     return flat_models
@@ -50,34 +86,49 @@ def get_path_param_names(path: str) -> Set[str]:
     return {item.strip("{}") for item in re.findall("{[^}]*}", path)}
 
 
-def create_cloned_field(field: Field) -> Field:
+def create_cloned_field(field: ModelField) -> ModelField:
     original_type = field.type_
+    if is_dataclass(original_type) and hasattr(original_type, "__pydantic_model__"):
+        original_type = original_type.__pydantic_model__  # type: ignore
     use_type = original_type
     if lenient_issubclass(original_type, BaseModel):
         original_type = cast(Type[BaseModel], original_type)
-        use_type = create_model(  # type: ignore
-            original_type.__name__,
-            __config__=original_type.__config__,
-            __validators__=original_type.__validators__,
+        use_type = create_model(
+            original_type.__name__, __config__=original_type.__config__
         )
         for f in original_type.__fields__.values():
             use_type.__fields__[f.name] = f
-    new_field = Field(
-        name=field.name,
-        type_=use_type,
-        class_validators={},
-        default=None,
-        required=False,
-        model_config=BaseConfig,
-        schema=Schema(None),
-    )
+        use_type.__validators__ = original_type.__validators__
+    if PYDANTIC_1:
+        new_field = ModelField(
+            name=field.name,
+            type_=use_type,
+            class_validators={},
+            default=None,
+            required=False,
+            model_config=BaseConfig,
+            field_info=FieldInfo(None),
+        )
+    else:  # pragma: nocover
+        new_field = ModelField(  # type: ignore
+            name=field.name,
+            type_=use_type,
+            class_validators={},
+            default=None,
+            required=False,
+            model_config=BaseConfig,
+            schema=FieldInfo(None),
+        )
     new_field.has_alias = field.has_alias
     new_field.alias = field.alias
     new_field.class_validators = field.class_validators
     new_field.default = field.default
     new_field.required = field.required
     new_field.model_config = field.model_config
-    new_field.schema = field.schema
+    if PYDANTIC_1:
+        new_field.field_info = field.field_info
+    else:  # pragma: nocover
+        new_field.schema = field.schema  # type: ignore
     new_field.allow_none = field.allow_none
     new_field.validate_always = field.validate_always
     if field.sub_fields:
@@ -87,16 +138,24 @@ def create_cloned_field(field: Field) -> Field:
     if field.key_field:
         new_field.key_field = create_cloned_field(field.key_field)
     new_field.validators = field.validators
-    new_field.whole_pre_validators = field.whole_pre_validators
-    new_field.whole_post_validators = field.whole_post_validators
+    if PYDANTIC_1:
+        new_field.pre_validators = field.pre_validators
+        new_field.post_validators = field.post_validators
+    else:  # pragma: nocover
+        new_field.whole_pre_validators = field.whole_pre_validators  # type: ignore
+        new_field.whole_post_validators = field.whole_post_validators  # type: ignore
     new_field.parse_json = field.parse_json
     new_field.shape = field.shape
-    new_field._populate_validators()
+    try:
+        new_field.populate_validators()
+    except AttributeError:  # pragma: nocover
+        # TODO: remove when removing support for Pydantic < 1.0.0
+        new_field._populate_validators()  # type: ignore
     return new_field
 
 
 def generate_operation_id_for_path(*, name: str, path: str, method: str) -> str:
     operation_id = name + path
-    operation_id = operation_id.replace("{", "_").replace("}", "_").replace("/", "_")
+    operation_id = re.sub("[^0-9a-zA-Z_]", "_", operation_id)
     operation_id = operation_id + "_" + method.lower()
     return operation_id

mkdocs.yml

@@ -1,11 +1,12 @@
 site_name: FastAPI
 site_description: FastAPI framework, high performance, easy to learn, fast to code, ready for production
+site_url: https://fastapi.tiangolo.com/
 
 theme:
     name: 'material'
     palette:
-      primary: 'teal'
-      accent: 'amber'
+        primary: 'teal'
+        accent: 'amber'
     logo: 'img/icon-white.svg'
     favicon: 'img/favicon.png'
 
@@ -29,7 +30,7 @@ nav:
         - Query Parameters and String Validations: 'tutorial/query-params-str-validations.md'
         - Path Parameters and Numeric Validations: 'tutorial/path-params-numeric-validations.md'
         - Body - Multiple Parameters: 'tutorial/body-multiple-params.md'
-        - Body - Schema: 'tutorial/body-schema.md'
+        - Body - Fields: 'tutorial/body-fields.md'
         - Body - Nested Models: 'tutorial/body-nested-models.md'
         - Extra data types: 'tutorial/extra-data-types.md'
         - Cookie Parameters: 'tutorial/cookie-params.md'
@@ -57,6 +58,7 @@ nav:
             - Classes as Dependencies: 'tutorial/dependencies/classes-as-dependencies.md'
             - Sub-dependencies: 'tutorial/dependencies/sub-dependencies.md'
             - Dependencies in path operation decorators: 'tutorial/dependencies/dependencies-in-path-operation-decorators.md'
+            - Dependencies with yield: 'tutorial/dependencies/dependencies-with-yield.md'
             - Advanced Dependencies: 'tutorial/dependencies/advanced-dependencies.md'
         - Security: 
             - Security Intro: 'tutorial/security/intro.md'
@@ -70,6 +72,7 @@ nav:
         - CORS (Cross-Origin Resource Sharing): 'tutorial/cors.md'    
         - Using the Request Directly: 'tutorial/using-request-directly.md'    
         - SQL (Relational) Databases: 'tutorial/sql-databases.md'
+        - SQL (Relational) Databases with Peewee: 'tutorial/sql-databases-peewee.md'
         - Async SQL (Relational) Databases: 'tutorial/async-sql-databases.md'
         - NoSQL (Distributed / Big Data) Databases: 'tutorial/nosql-databases.md'
         - Bigger Applications - Multiple Files: 'tutorial/bigger-applications.md'
@@ -81,10 +84,12 @@ nav:
         - GraphQL: 'tutorial/graphql.md'
         - WebSockets: 'tutorial/websockets.md'
         - 'Events: startup - shutdown': 'tutorial/events.md'
+        - Custom Request and APIRoute class: 'tutorial/custom-request-and-route.md'
         - Testing: 'tutorial/testing.md'
         - Testing Dependencies with Overrides: 'tutorial/testing-dependencies.md'
         - Debugging: 'tutorial/debugging.md'
         - Extending OpenAPI: 'tutorial/extending-openapi.md'
+        - OpenAPI Callbacks: 'tutorial/openapi-callbacks.md'
     - Concurrency and async / await: 'async.md'
     - Deployment: 'deployment.md'
     - Project Generation - Template: 'project-generation.md'
@@ -97,10 +102,27 @@ nav:
     - Release Notes: release-notes.md
 
 markdown_extensions:
-  - markdown.extensions.codehilite:
-      guess_lang: false
-  - markdown_include.include:
-      base_path: docs
-  - admonition
-  - codehilite
-  - extra
+    - toc:
+        permalink: true
+    - markdown.extensions.codehilite:
+        guess_lang: false
+    - markdown_include.include:
+        base_path: docs
+    - admonition
+    - codehilite
+    - extra
+
+extra:
+    social:
+        - type: 'github'
+          link: 'https://github.com/tiangolo/typer'
+        - type: 'twitter'
+          link: 'https://twitter.com/tiangolo'
+        - type: 'linkedin'
+          link: 'https://www.linkedin.com/in/tiangolo'
+        - type: 'rss'
+          link: 'https://dev.to/tiangolo'
+        - type: 'medium'
+          link: 'https://medium.com/@tiangolo'
+        - type: 'globe'
+          link: 'https://tiangolo.com'