🔖 Release 0.39.0

This allows using parameters that can have defaults (e.g. `None`) that can be used as query parameters.

But can also be used in routers with that include those parameters as part of the path.

Pipfile

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

README.md

@@ -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
 

docs/external-links.md

@@ -27,6 +27,14 @@ Here's an incomplete list of some of them.
 
 * <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>.
+
 ### 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>.

docs/index.md

@@ -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
 

docs/release-notes.md

@@ -1,5 +1,23 @@
 ## Latest changes
 
+## 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).

fastapi/__init__.py

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

fastapi/applications.py

@@ -1,6 +1,7 @@
-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.encoders import DictIntStrAny, SetIntStr
 from fastapi.exception_handlers import (
     http_exception_handler,
     request_validation_exception_handler,
@@ -32,11 +33,13 @@ 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",
         **extra: Dict[str, Any],
     ) -> None:
+        self.default_response_class = default_response_class
         self._debug = debug
         self.router: routing.APIRouter = routing.APIRouter(
             routes, dependency_overrides_provider=self
@@ -138,12 +141,12 @@ 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,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
     ) -> None:
         self.router.add_api_route(
@@ -165,7 +168,7 @@ class FastAPI(Starlette):
             response_model_by_alias=response_model_by_alias,
             response_model_skip_defaults=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,12 +187,12 @@ 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,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
     ) -> Callable:
         def decorator(func: Callable) -> Callable:
@@ -212,7 +215,7 @@ class FastAPI(Starlette):
                 response_model_by_alias=response_model_by_alias,
                 response_model_skip_defaults=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 +242,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 +250,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,12 +268,12 @@ 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,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
     ) -> Callable:
         return self.router.get(
@@ -287,7 +293,7 @@ class FastAPI(Starlette):
             response_model_by_alias=response_model_by_alias,
             response_model_skip_defaults=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,
         )
 
@@ -305,12 +311,12 @@ 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,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
     ) -> Callable:
         return self.router.put(
@@ -330,7 +336,7 @@ class FastAPI(Starlette):
             response_model_by_alias=response_model_by_alias,
             response_model_skip_defaults=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,
         )
 
@@ -348,12 +354,12 @@ 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,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
     ) -> Callable:
         return self.router.post(
@@ -373,7 +379,7 @@ class FastAPI(Starlette):
             response_model_by_alias=response_model_by_alias,
             response_model_skip_defaults=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,
         )
 
@@ -391,12 +397,12 @@ 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,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
     ) -> Callable:
         return self.router.delete(
@@ -416,7 +422,7 @@ class FastAPI(Starlette):
             operation_id=operation_id,
             response_model_skip_defaults=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,
         )
 
@@ -434,12 +440,12 @@ 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,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
     ) -> Callable:
         return self.router.options(
@@ -459,7 +465,7 @@ class FastAPI(Starlette):
             response_model_by_alias=response_model_by_alias,
             response_model_skip_defaults=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,
         )
 
@@ -477,12 +483,12 @@ 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,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
     ) -> Callable:
         return self.router.head(
@@ -502,7 +508,7 @@ class FastAPI(Starlette):
             response_model_by_alias=response_model_by_alias,
             response_model_skip_defaults=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,
         )
 
@@ -520,12 +526,12 @@ 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,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
     ) -> Callable:
         return self.router.patch(
@@ -545,7 +551,7 @@ class FastAPI(Starlette):
             response_model_by_alias=response_model_by_alias,
             response_model_skip_defaults=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,
         )
 
@@ -563,12 +569,12 @@ 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,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
     ) -> Callable:
         return self.router.trace(
@@ -588,6 +594,6 @@ class FastAPI(Starlette):
             response_model_by_alias=response_model_by_alias,
             response_model_skip_defaults=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,
         )

fastapi/dependencies/utils.py

@@ -26,7 +26,7 @@ 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 pydantic.utils import ForwardRef, evaluate_forwardref, lenient_issubclass
 from starlette.background import BackgroundTasks
 from starlette.concurrency import run_in_threadpool
 from starlette.datastructures import FormData, Headers, QueryParams, UploadFile
@@ -171,6 +171,30 @@ 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
+
+
 def get_dependant(
     *,
     path: str,
@@ -180,7 +204,7 @@ 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
     dependant = Dependant(call=call, name=name, path=path, use_cache=use_cache)
     for param_name, param in signature_params.items():
@@ -196,16 +220,18 @@ def get_dependant(
             continue
         param_field = get_param_field(param=param, default_schema=params.Query)
         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,
                 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):
@@ -248,10 +274,11 @@ def get_param_field(
     param: inspect.Parameter,
     default_schema: Type[params.Param] = params.Param,
     force_type: params.ParamTypes = None,
+    ignore_default: bool = False,
 ) -> Field:
     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):
         had_schema = True
@@ -329,8 +356,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
@@ -405,7 +436,7 @@ 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)

fastapi/encoders.py

@@ -1,15 +1,18 @@
 from enum import Enum
 from types import GeneratorType
-from typing import Any, List, Set
+from typing import Any, Dict, List, Set, Union
 
 from pydantic import BaseModel
 from pydantic.json import ENCODERS_BY_TYPE
 
+SetIntStr = Set[Union[int, str]]
+DictIntStrAny = Dict[Union[int, str], Any]
+
 
 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,
     include_none: bool = True,

fastapi/exceptions.py

@@ -1,7 +1,10 @@
-from typing import Any
+from typing import Any, Sequence
 
 from pydantic import ValidationError
+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):
@@ -13,8 +16,10 @@ class HTTPException(StarletteHTTPException):
 
 
 class RequestValidationError(ValidationError):
-    pass
+    def __init__(self, errors: Sequence[ErrorList]) -> None:
+        super().__init__(errors, Request)
 
 
 class WebSocketRequestValidationError(ValidationError):
-    pass
+    def __init__(self, errors: Sequence[ErrorList]) -> None:
+        super().__init__(errors, WebSocket)

fastapi/openapi/models.py

@@ -11,7 +11,7 @@ try:
     import email_validator
 
     assert email_validator  # make autoflake ignore the unused import
-    from pydantic.types import EmailStr  # type: ignore
+    from pydantic.types import EmailStr
 except ImportError:  # pragma: no cover
     logger.warning(
         "email-validator not installed, email fields will be treated as str.\n"

fastapi/openapi/utils.py

@@ -151,6 +151,10 @@ 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 and route.response_class.media_type
+    ), "A response class with media_type is needed to generate OpenAPI"
+    route_response_media_type: 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)
@@ -185,7 +189,7 @@ def get_openapi_path(
                             field, model_name_map=model_name_map, ref_prefix=REF_PREFIX
                         )
                         response.setdefault("content", {}).setdefault(
-                            route.response_class.media_type, {}
+                            route_response_media_type, {}
                         )["schema"] = response_schema
                     status_text: Optional[str] = status_code_ranges.get(
                         str(additional_status_code).upper()
@@ -213,7 +217,7 @@ def get_openapi_path(
             ] = route.response_description
             operation.setdefault("responses", {}).setdefault(
                 status_code, {}
-            ).setdefault("content", {}).setdefault(route.response_class.media_type, {})[
+            ).setdefault("content", {}).setdefault(route_response_media_type, {})[
                 "schema"
             ] = response_schema
 

fastapi/routing.py

@@ -11,7 +11,7 @@ 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
@@ -38,8 +38,8 @@ def serialize_response(
     *,
     field: Field = 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,
 ) -> Any:
@@ -53,7 +53,7 @@ def serialize_response(
         elif isinstance(errors_, list):
             errors.extend(errors_)
         if errors:
-            raise ValidationError(errors)
+            raise ValidationError(errors, field.type_)
         return jsonable_encoder(
             value,
             include=include,
@@ -71,8 +71,8 @@ def get_app(
     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_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,
     dependency_overrides_provider: Any = None,
@@ -195,12 +195,12 @@ 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,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Optional[Type[Response]] = None,
         dependency_overrides_provider: Any = None,
     ) -> None:
         self.path = path
@@ -215,9 +215,6 @@ 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"
             response_name = "Response_" + self.unique_id
             self.response_field: Optional[Field] = Field(
                 name=response_name,
@@ -299,7 +296,7 @@ class APIRoute(routing.Route):
                 dependant=self.dependant,
                 body_field=self.body_field,
                 status_code=self.status_code,
-                response_class=self.response_class,
+                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,
@@ -341,12 +338,12 @@ 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,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
     ) -> None:
         route = self.route_class(
@@ -389,12 +386,12 @@ 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,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
     ) -> Callable:
         def decorator(func: Callable) -> Callable:
@@ -445,6 +442,7 @@ 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 '/'"
@@ -484,7 +482,7 @@ class APIRouter(routing.Router):
                     response_model_by_alias=route.response_model_by_alias,
                     response_model_skip_defaults=route.response_model_skip_defaults,
                     include_in_schema=route.include_in_schema,
-                    response_class=route.response_class,
+                    response_class=route.response_class or default_response_class,
                     name=route.name,
                 )
             elif isinstance(route, routing.Route):
@@ -518,15 +516,14 @@ 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,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
     ) -> Callable:
-
         return self.api_route(
             path=path,
             response_model=response_model,
@@ -563,12 +560,12 @@ 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,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
     ) -> Callable:
         return self.api_route(
@@ -607,12 +604,12 @@ 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,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
     ) -> Callable:
         return self.api_route(
@@ -651,12 +648,12 @@ 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,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
     ) -> Callable:
         return self.api_route(
@@ -695,12 +692,12 @@ 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,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
     ) -> Callable:
         return self.api_route(
@@ -739,12 +736,12 @@ 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,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
     ) -> Callable:
         return self.api_route(
@@ -783,12 +780,12 @@ 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,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
     ) -> Callable:
         return self.api_route(
@@ -827,12 +824,12 @@ 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,
         include_in_schema: bool = True,
-        response_class: Type[Response] = JSONResponse,
+        response_class: Type[Response] = None,
         name: str = None,
     ) -> Callable:
         return self.api_route(

fastapi/utils.py

@@ -58,10 +58,10 @@ def create_cloned_field(field: Field) -> Field:
     use_type = original_type
     if lenient_issubclass(original_type, BaseModel):
         original_type = cast(Type[BaseModel], original_type)
-        use_type = create_model(  # type: ignore
+        use_type = create_model(
             original_type.__name__,
             __config__=original_type.__config__,
-            __validators__=original_type.__validators__,
+            __validators__=original_type.__validators__,  # type: ignore
         )
         for f in original_type.__fields__.values():
             use_type.__fields__[f.name] = f

pyproject.toml

@@ -19,8 +19,8 @@ classifiers = [
     "Topic :: Internet :: WWW/HTTP :: HTTP Servers",
 ]
 requires = [
-    "starlette >=0.11.1,<=0.12.7",
-    "pydantic >=0.30,<=0.30.0"
+    "starlette >=0.11.1,<=0.12.8",
+    "pydantic >=0.32.2,<=0.32.2"
 ]
 description-file = "README.md"
 requires-python = ">=3.6"
@@ -39,6 +39,7 @@ test = [
     "email_validator",
     "sqlalchemy",
     "databases[sqlite]",
+    "orjson"
 ]
 doc = [
     "mkdocs",

tests/test_default_response_class.py

@@ -0,0 +1,216 @@
+from typing import Any
+
+import orjson
+from fastapi import APIRouter, FastAPI
+from starlette.responses import HTMLResponse, JSONResponse, PlainTextResponse
+from starlette.testclient import TestClient
+
+
+class ORJSONResponse(JSONResponse):
+    media_type = "application/x-orjson"
+
+    def render(self, content: Any) -> bytes:
+        return orjson.dumps(content)
+
+
+class OverrideResponse(JSONResponse):
+    media_type = "application/x-override"
+
+
+app = FastAPI(default_response_class=ORJSONResponse)
+router_a = APIRouter()
+router_a_a = APIRouter()
+router_a_b_override = APIRouter()  # Overrides default class
+router_b_override = APIRouter()  # Overrides default class
+router_b_a = APIRouter()
+router_b_a_c_override = APIRouter()  # Overrides default class again
+
+
+@app.get("/")
+def get_root():
+    return {"msg": "Hello World"}
+
+
+@app.get("/override", response_class=PlainTextResponse)
+def get_path_override():
+    return "Hello World"
+
+
+@router_a.get("/")
+def get_a():
+    return {"msg": "Hello A"}
+
+
+@router_a.get("/override", response_class=PlainTextResponse)
+def get_a_path_override():
+    return "Hello A"
+
+
+@router_a_a.get("/")
+def get_a_a():
+    return {"msg": "Hello A A"}
+
+
+@router_a_a.get("/override", response_class=PlainTextResponse)
+def get_a_a_path_override():
+    return "Hello A A"
+
+
+@router_a_b_override.get("/")
+def get_a_b():
+    return "Hello A B"
+
+
+@router_a_b_override.get("/override", response_class=HTMLResponse)
+def get_a_b_path_override():
+    return "Hello A B"
+
+
+@router_b_override.get("/")
+def get_b():
+    return "Hello B"
+
+
+@router_b_override.get("/override", response_class=HTMLResponse)
+def get_b_path_override():
+    return "Hello B"
+
+
+@router_b_a.get("/")
+def get_b_a():
+    return "Hello B A"
+
+
+@router_b_a.get("/override", response_class=HTMLResponse)
+def get_b_a_path_override():
+    return "Hello B A"
+
+
+@router_b_a_c_override.get("/")
+def get_b_a_c():
+    return "Hello B A C"
+
+
+@router_b_a_c_override.get("/override", response_class=OverrideResponse)
+def get_b_a_c_path_override():
+    return {"msg": "Hello B A C"}
+
+
+router_b_a.include_router(
+    router_b_a_c_override, prefix="/c", default_response_class=HTMLResponse
+)
+router_b_override.include_router(router_b_a, prefix="/a")
+router_a.include_router(router_a_a, prefix="/a")
+router_a.include_router(
+    router_a_b_override, prefix="/b", default_response_class=PlainTextResponse
+)
+app.include_router(router_a, prefix="/a")
+app.include_router(
+    router_b_override, prefix="/b", default_response_class=PlainTextResponse
+)
+
+
+client = TestClient(app)
+
+orjson_type = "application/x-orjson"
+text_type = "text/plain; charset=utf-8"
+html_type = "text/html; charset=utf-8"
+override_type = "application/x-override"
+
+
+def test_app():
+    with client:
+        response = client.get("/")
+    assert response.json() == {"msg": "Hello World"}
+    assert response.headers["content-type"] == orjson_type
+
+
+def test_app_override():
+    with client:
+        response = client.get("/override")
+    assert response.content == b"Hello World"
+    assert response.headers["content-type"] == text_type
+
+
+def test_router_a():
+    with client:
+        response = client.get("/a")
+    assert response.json() == {"msg": "Hello A"}
+    assert response.headers["content-type"] == orjson_type
+
+
+def test_router_a_override():
+    with client:
+        response = client.get("/a/override")
+    assert response.content == b"Hello A"
+    assert response.headers["content-type"] == text_type
+
+
+def test_router_a_a():
+    with client:
+        response = client.get("/a/a")
+    assert response.json() == {"msg": "Hello A A"}
+    assert response.headers["content-type"] == orjson_type
+
+
+def test_router_a_a_override():
+    with client:
+        response = client.get("/a/a/override")
+    assert response.content == b"Hello A A"
+    assert response.headers["content-type"] == text_type
+
+
+def test_router_a_b():
+    with client:
+        response = client.get("/a/b")
+    assert response.content == b"Hello A B"
+    assert response.headers["content-type"] == text_type
+
+
+def test_router_a_b_override():
+    with client:
+        response = client.get("/a/b/override")
+    assert response.content == b"Hello A B"
+    assert response.headers["content-type"] == html_type
+
+
+def test_router_b():
+    with client:
+        response = client.get("/b")
+    assert response.content == b"Hello B"
+    assert response.headers["content-type"] == text_type
+
+
+def test_router_b_override():
+    with client:
+        response = client.get("/b/override")
+    assert response.content == b"Hello B"
+    assert response.headers["content-type"] == html_type
+
+
+def test_router_b_a():
+    with client:
+        response = client.get("/b/a")
+    assert response.content == b"Hello B A"
+    assert response.headers["content-type"] == text_type
+
+
+def test_router_b_a_override():
+    with client:
+        response = client.get("/b/a/override")
+    assert response.content == b"Hello B A"
+    assert response.headers["content-type"] == html_type
+
+
+def test_router_b_a_c():
+    with client:
+        response = client.get("/b/a/c")
+    assert response.content == b"Hello B A C"
+    assert response.headers["content-type"] == html_type
+
+
+def test_router_b_a_c_override():
+    with client:
+        response = client.get("/b/a/c/override")
+    assert response.json() == {"msg": "Hello B A C"}
+    assert response.headers["content-type"] == override_type

tests/test_default_response_class_router.py

@@ -0,0 +1,206 @@
+from fastapi import APIRouter, FastAPI
+from starlette.responses import HTMLResponse, JSONResponse, PlainTextResponse
+from starlette.testclient import TestClient
+
+
+class OverrideResponse(JSONResponse):
+    media_type = "application/x-override"
+
+
+app = FastAPI()
+router_a = APIRouter()
+router_a_a = APIRouter()
+router_a_b_override = APIRouter()  # Overrides default class
+router_b_override = APIRouter()  # Overrides default class
+router_b_a = APIRouter()
+router_b_a_c_override = APIRouter()  # Overrides default class again
+
+
+@app.get("/")
+def get_root():
+    return {"msg": "Hello World"}
+
+
+@app.get("/override", response_class=PlainTextResponse)
+def get_path_override():
+    return "Hello World"
+
+
+@router_a.get("/")
+def get_a():
+    return {"msg": "Hello A"}
+
+
+@router_a.get("/override", response_class=PlainTextResponse)
+def get_a_path_override():
+    return "Hello A"
+
+
+@router_a_a.get("/")
+def get_a_a():
+    return {"msg": "Hello A A"}
+
+
+@router_a_a.get("/override", response_class=PlainTextResponse)
+def get_a_a_path_override():
+    return "Hello A A"
+
+
+@router_a_b_override.get("/")
+def get_a_b():
+    return "Hello A B"
+
+
+@router_a_b_override.get("/override", response_class=HTMLResponse)
+def get_a_b_path_override():
+    return "Hello A B"
+
+
+@router_b_override.get("/")
+def get_b():
+    return "Hello B"
+
+
+@router_b_override.get("/override", response_class=HTMLResponse)
+def get_b_path_override():
+    return "Hello B"
+
+
+@router_b_a.get("/")
+def get_b_a():
+    return "Hello B A"
+
+
+@router_b_a.get("/override", response_class=HTMLResponse)
+def get_b_a_path_override():
+    return "Hello B A"
+
+
+@router_b_a_c_override.get("/")
+def get_b_a_c():
+    return "Hello B A C"
+
+
+@router_b_a_c_override.get("/override", response_class=OverrideResponse)
+def get_b_a_c_path_override():
+    return {"msg": "Hello B A C"}
+
+
+router_b_a.include_router(
+    router_b_a_c_override, prefix="/c", default_response_class=HTMLResponse
+)
+router_b_override.include_router(router_b_a, prefix="/a")
+router_a.include_router(router_a_a, prefix="/a")
+router_a.include_router(
+    router_a_b_override, prefix="/b", default_response_class=PlainTextResponse
+)
+app.include_router(router_a, prefix="/a")
+app.include_router(
+    router_b_override, prefix="/b", default_response_class=PlainTextResponse
+)
+
+
+client = TestClient(app)
+
+json_type = "application/json"
+text_type = "text/plain; charset=utf-8"
+html_type = "text/html; charset=utf-8"
+override_type = "application/x-override"
+
+
+def test_app():
+    with client:
+        response = client.get("/")
+    assert response.json() == {"msg": "Hello World"}
+    assert response.headers["content-type"] == json_type
+
+
+def test_app_override():
+    with client:
+        response = client.get("/override")
+    assert response.content == b"Hello World"
+    assert response.headers["content-type"] == text_type
+
+
+def test_router_a():
+    with client:
+        response = client.get("/a")
+    assert response.json() == {"msg": "Hello A"}
+    assert response.headers["content-type"] == json_type
+
+
+def test_router_a_override():
+    with client:
+        response = client.get("/a/override")
+    assert response.content == b"Hello A"
+    assert response.headers["content-type"] == text_type
+
+
+def test_router_a_a():
+    with client:
+        response = client.get("/a/a")
+    assert response.json() == {"msg": "Hello A A"}
+    assert response.headers["content-type"] == json_type
+
+
+def test_router_a_a_override():
+    with client:
+        response = client.get("/a/a/override")
+    assert response.content == b"Hello A A"
+    assert response.headers["content-type"] == text_type
+
+
+def test_router_a_b():
+    with client:
+        response = client.get("/a/b")
+    assert response.content == b"Hello A B"
+    assert response.headers["content-type"] == text_type
+
+
+def test_router_a_b_override():
+    with client:
+        response = client.get("/a/b/override")
+    assert response.content == b"Hello A B"
+    assert response.headers["content-type"] == html_type
+
+
+def test_router_b():
+    with client:
+        response = client.get("/b")
+    assert response.content == b"Hello B"
+    assert response.headers["content-type"] == text_type
+
+
+def test_router_b_override():
+    with client:
+        response = client.get("/b/override")
+    assert response.content == b"Hello B"
+    assert response.headers["content-type"] == html_type
+
+
+def test_router_b_a():
+    with client:
+        response = client.get("/b/a")
+    assert response.content == b"Hello B A"
+    assert response.headers["content-type"] == text_type
+
+
+def test_router_b_a_override():
+    with client:
+        response = client.get("/b/a/override")
+    assert response.content == b"Hello B A"
+    assert response.headers["content-type"] == html_type
+
+
+def test_router_b_a_c():
+    with client:
+        response = client.get("/b/a/c")
+    assert response.content == b"Hello B A C"
+    assert response.headers["content-type"] == html_type
+
+
+def test_router_b_a_c_override():
+    with client:
+        response = client.get("/b/a/c/override")
+    assert response.json() == {"msg": "Hello B A C"}
+    assert response.headers["content-type"] == override_type

tests/test_infer_param_optionality.py

@@ -0,0 +1,136 @@
+from fastapi import APIRouter, FastAPI
+from starlette.testclient import TestClient
+
+app = FastAPI()
+
+
+user_router = APIRouter()
+item_router = APIRouter()
+
+
+@user_router.get("/")
+def get_users():
+    return [{"user_id": "u1"}, {"user_id": "u2"}]
+
+
+@user_router.get("/{user_id}")
+def get_user(user_id: str):
+    return {"user_id": user_id}
+
+
+@item_router.get("/")
+def get_items(user_id: str = None):
+    if user_id is None:
+        return [{"item_id": "i1", "user_id": "u1"}, {"item_id": "i2", "user_id": "u2"}]
+    else:
+        return [{"item_id": "i2", "user_id": user_id}]
+
+
+@item_router.get("/{item_id}")
+def get_item(item_id: str, user_id: str = None):
+    if user_id is None:
+        return {"item_id": item_id}
+    else:
+        return {"item_id": item_id, "user_id": user_id}
+
+
+app.include_router(user_router, prefix="/users")
+app.include_router(item_router, prefix="/items")
+
+app.include_router(item_router, prefix="/users/{user_id}/items")
+
+
+client = TestClient(app)
+
+
+def test_get_users():
+    """Check that /users returns expected data"""
+    response = client.get("/users")
+    assert response.status_code == 200
+    assert response.json() == [{"user_id": "u1"}, {"user_id": "u2"}]
+
+
+def test_get_user():
+    """Check that /users/{user_id} returns expected data"""
+    response = client.get("/users/abc123")
+    assert response.status_code == 200
+    assert response.json() == {"user_id": "abc123"}
+
+
+def test_get_items_1():
+    """Check that /items returns expected data"""
+    response = client.get("/items")
+    assert response.status_code == 200
+    assert response.json() == [
+        {"item_id": "i1", "user_id": "u1"},
+        {"item_id": "i2", "user_id": "u2"},
+    ]
+
+
+def test_get_items_2():
+    """Check that /items returns expected data with user_id specified"""
+    response = client.get("/items?user_id=abc123")
+    assert response.status_code == 200
+    assert response.json() == [{"item_id": "i2", "user_id": "abc123"}]
+
+
+def test_get_item_1():
+    """Check that /items/{item_id} returns expected data"""
+    response = client.get("/items/item01")
+    assert response.status_code == 200
+    assert response.json() == {"item_id": "item01"}
+
+
+def test_get_item_2():
+    """Check that /items/{item_id} returns expected data with user_id specified"""
+    response = client.get("/items/item01?user_id=abc123")
+    assert response.status_code == 200
+    assert response.json() == {"item_id": "item01", "user_id": "abc123"}
+
+
+def test_get_users_items():
+    """Check that /users/{user_id}/items returns expected data"""
+    response = client.get("/users/abc123/items")
+    assert response.status_code == 200
+    assert response.json() == [{"item_id": "i2", "user_id": "abc123"}]
+
+
+def test_get_users_item():
+    """Check that /users/{user_id}/items returns expected data"""
+    response = client.get("/users/abc123/items/item01")
+    assert response.status_code == 200
+    assert response.json() == {"item_id": "item01", "user_id": "abc123"}
+
+
+def test_schema_1():
+    """Check that the user_id is a required path parameter under /users"""
+    response = client.get("/openapi.json")
+    assert response.status_code == 200
+    r = response.json()
+
+    d = {
+        "required": True,
+        "schema": {"title": "User_Id", "type": "string"},
+        "name": "user_id",
+        "in": "path",
+    }
+
+    assert d in r["paths"]["/users/{user_id}"]["get"]["parameters"]
+    assert d in r["paths"]["/users/{user_id}/items/"]["get"]["parameters"]
+
+
+def test_schema_2():
+    """Check that the user_id is an optional query parameter under /items"""
+    response = client.get("/openapi.json")
+    assert response.status_code == 200
+    r = response.json()
+
+    d = {
+        "required": False,
+        "schema": {"title": "User_Id", "type": "string"},
+        "name": "user_id",
+        "in": "query",
+    }
+
+    assert d in r["paths"]["/items/{item_id}"]["get"]["parameters"]
+    assert d in r["paths"]["/items/"]["get"]["parameters"]

tests/test_security_oauth2.py

@@ -21,18 +21,21 @@ class User(BaseModel):
     username: str
 
 
-def get_current_user(oauth_header: str = Security(reusable_oauth2)):
+# Here we use string annotations to test them
+def get_current_user(oauth_header: "str" = Security(reusable_oauth2)):
     user = User(username=oauth_header)
     return user
 
 
 @app.post("/login")
-def read_current_user(form_data: OAuth2PasswordRequestFormStrict = Depends()):
+# Here we use string annotations to test them
+def read_current_user(form_data: "OAuth2PasswordRequestFormStrict" = Depends()):
     return form_data
 
 
 @app.get("/users/me")
-def read_current_user(current_user: User = Depends(get_current_user)):
+# Here we use string annotations to test them
+def read_current_user(current_user: "User" = Depends(get_current_user)):
     return current_user
 
 

tests/test_tutorial/test_handling_errors/test_tutorial004.py

@@ -81,7 +81,7 @@ def test_get_validation_error():
     response = client.get("/items/foo")
     assert response.status_code == 400
     validation_error_str_lines = [
-        b"1 validation error",
+        b"1 validation error for Request",
         b"path -> item_id",
         b"  value is not a valid integer (type=type_error.integer)",
     ]

tests/test_tutorial/test_path_params/test_tutorial005.py

@@ -106,8 +106,9 @@ def test_openapi():
             {
                 "detail": [
                     {
+                        "ctx": {"enum_values": ["alexnet", "resnet", "lenet"]},
                         "loc": ["path", "model_name"],
-                        "msg": "value is not a valid enumeration member",
+                        "msg": "value is not a valid enumeration member; permitted: 'alexnet', 'resnet', 'lenet'",
                         "type": "type_error.enum",
                     }
                 ]