fastapi 0.145.0__tar.gz → 0.147.0__tar.gz

{fastapi-0.145.0 → fastapi-0.147.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi
-Version: 0.145.0
+Version: 0.147.0
 Summary: FastAPI framework, high performance, easy to learn, fast to code, ready for production
 Author-Email: Sebastián Ramírez <tiangolo@gmail.com>
 License-Expression: MIT

{fastapi-0.145.0 → fastapi-0.147.0}/docs_src/behind_a_proxy/tutorial003_py310.py

@@ -5,7 +5,6 @@ app = FastAPI(
         {"url": "https://stag.example.com", "description": "Staging environment"},
         {"url": "https://prod.example.com", "description": "Production environment"},
     ],
-    root_path="/api/v1",
 )
 
 

{fastapi-0.145.0 → fastapi-0.147.0}/docs_src/behind_a_proxy/tutorial004_py310.py

@@ -5,7 +5,6 @@ app = FastAPI(
         {"url": "https://stag.example.com", "description": "Staging environment"},
         {"url": "https://prod.example.com", "description": "Production environment"},
     ],
-    root_path="/api/v1",
     root_path_in_servers=False,
 )
 

{fastapi-0.145.0 → fastapi-0.147.0}/fastapi/__init__.py

@@ -1,6 +1,6 @@
 """FastAPI framework, high performance, easy to learn, fast to code, ready for production"""
 
-__version__ = "0.145.0"
+__version__ = "0.147.0"
 
 from starlette import status as status
 

{fastapi-0.145.0 → fastapi-0.147.0}/fastapi/applications.py

@@ -1,4 +1,5 @@
 import os
+import warnings
 from collections.abc import Awaitable, Callable, Coroutine, Sequence
 from enum import Enum
 from typing import Annotated, Any, Literal, TypeVar
@@ -11,7 +12,11 @@ from fastapi.exception_handlers import (
     request_validation_exception_handler,
     websocket_request_validation_exception_handler,
 )
-from fastapi.exceptions import RequestValidationError, WebSocketRequestValidationError
+from fastapi.exceptions import (
+    FastAPIDeprecationWarning,
+    RequestValidationError,
+    WebSocketRequestValidationError,
+)
 from fastapi.middleware.asyncexitstack import AsyncExitStackMiddleware
 from fastapi.openapi.docs import (
     get_redoc_html,
@@ -644,19 +649,18 @@ class FastAPI(Starlette):
             str,
             Doc(
                 """
-                A path prefix handled by a proxy that is not seen by the application
-                but is seen by external clients, which affects things like Swagger UI.
+                Deprecated. Configure the server with
+                `fastapi run --root-path /api/v1` instead.
 
-                Read more about it at the
+                Read more in the
                 [FastAPI docs for Behind a Proxy](https://fastapi.tiangolo.com/advanced/behind-a-proxy/).
-
-                **Example**
-
-                ```python
-                from fastapi import FastAPI
-
-                app = FastAPI(root_path="/api/v1")
-                ```
+                """
+            ),
+            deprecated(
+                """
+                The `root_path` parameter is deprecated. Configure the server's
+                root path instead, for example with
+                `fastapi run --root-path /api/v1`.
                 """
             ),
         ] = "",
@@ -931,6 +935,14 @@ class FastAPI(Starlette):
                 """
             ),
         ] = webhooks or routing.APIRouter()
+        if root_path:
+            warnings.warn(
+                "The `root_path` parameter is deprecated. Configure the "
+                "server's root path instead, for example with "
+                "`fastapi run --root-path /api/v1`.",
+                category=FastAPIDeprecationWarning,
+                stacklevel=2,
+            )
         self.root_path = root_path
         self.state: Annotated[
             State,

{fastapi-0.145.0 → fastapi-0.147.0}/fastapi/dependencies/utils.py

@@ -69,7 +69,7 @@ from fastapi.logger import logger
 from fastapi.security.oauth2 import SecurityScopes
 from fastapi.types import DependencyCacheKey
 from fastapi.utils import create_model_field, get_path_param_names
-from pydantic import BaseModel, Json
+from pydantic import AliasChoices, BaseModel, Json
 from pydantic.fields import FieldInfo
 from starlette.background import BackgroundTasks as StarletteBackgroundTasks
 from starlette.concurrency import run_in_threadpool
@@ -913,10 +913,42 @@ async def _extract_form_body(
     body_fields: list[ModelField],
     received_body: FormData,
 ) -> dict[str, Any]:
-    values = {}
+    values: dict[str, Any] = {}
+    field_aliases: set[str] = set()
 
     for field in body_fields:
-        value = _get_multidict_value(field, received_body)
+        alias = get_validation_alias(field)
+        validation_alias = field.field_info.validation_alias
+        # Interpret missing boolean form fields as unchecked HTML checkboxes.
+        infer_false_if_missing = field.field_info.annotation in (
+            bool,
+            bool | None,
+        ) and (
+            validation_alias is None
+            or isinstance(validation_alias, str)
+            or (
+                isinstance(validation_alias, AliasChoices)
+                and all(isinstance(choice, str) for choice in validation_alias.choices)
+            )
+        )
+        if infer_false_if_missing:
+            if isinstance(validation_alias, AliasChoices):
+                aliases = cast(list[str], validation_alias.choices)
+                alias = next(
+                    (name for name in aliases if name in received_body), aliases[0]
+                )
+            config = field.config or {}
+            if config.get(
+                "validate_by_name", config.get("populate_by_name", False)
+            ) and (
+                alias not in received_body or config.get("validate_by_alias") is False
+            ):
+                alias = field.name
+        field_aliases.add(alias)
+        if infer_false_if_missing and alias not in received_body:
+            value: Any = False
+        else:
+            value = _get_multidict_value(field, received_body, alias=alias)
         field_info = field.field_info
         if (
             isinstance(field_info, params.File)
@@ -938,9 +970,12 @@ async def _extract_form_body(
                 else:
                     results.append(sub_value)
             value = serialize_sequence_value(field=field, value=results)
+        if field.config is None:
+            # Individual parameters are later looked up by their declared alias.
+            alias = get_validation_alias(field)
+            field_aliases.add(alias)
         if value is not None:
-            values[get_validation_alias(field)] = value
-    field_aliases = {get_validation_alias(field) for field in body_fields}
+            values[alias] = value
     for key in received_body.keys():
         if key not in field_aliases:
             param_values = received_body.getlist(key)

{fastapi-0.145.0 → fastapi-0.147.0}/pyproject.toml

@@ -53,7 +53,7 @@ dependencies = [
     "annotated-doc>=0.0.2",
     "opentelemetry-api>=1.44.0",
 ]
-version = "0.145.0"
+version = "0.147.0"
 
 [project.urls]
 Homepage = "https://github.com/fastapi/fastapi"

fastapi-0.147.0/tests/test_request_params/test_body/test_nullable_and_defaults.py

@@ -0,0 +1,287 @@
+from typing import Annotated
+
+import pytest
+from fastapi import Body, FastAPI
+from fastapi.testclient import TestClient
+from pydantic import BaseModel
+
+app = FastAPI()
+
+
+class RequiredModel(BaseModel):
+    value: int | None
+
+
+class NoneDefaultModel(BaseModel):
+    value: int | None = None
+
+
+class NonNullDefaultModel(BaseModel):
+    value: int | None = 10
+
+
+class NonNullableDefaultModel(BaseModel):
+    value: int = 10
+
+
+@app.post("/required")
+def read_required(value: Annotated[int | None, Body(embed=True)]):
+    return {"value": value, "fields_set": None}
+
+
+@app.post("/required-model")
+def read_required_model(params: Annotated[RequiredModel, Body()]):
+    return {"value": params.value, "fields_set": sorted(params.model_fields_set)}
+
+
+@app.post("/none-default")
+def read_none_default(value: Annotated[int | None, Body(embed=True)] = None):
+    return {"value": value, "fields_set": None}
+
+
+@app.post("/none-default-model")
+def read_none_default_model(params: Annotated[NoneDefaultModel, Body()]):
+    return {"value": params.value, "fields_set": sorted(params.model_fields_set)}
+
+
+@app.post("/non-null-default")
+def read_non_null_default(value: Annotated[int | None, Body(embed=True)] = 10):
+    return {"value": value, "fields_set": None}
+
+
+@app.post("/non-null-default-model")
+def read_non_null_default_model(params: Annotated[NonNullDefaultModel, Body()]):
+    return {"value": params.value, "fields_set": sorted(params.model_fields_set)}
+
+
+@app.post("/non-nullable-default")
+def read_non_nullable_default(value: Annotated[int, Body(embed=True)] = 10):
+    return {"value": value, "fields_set": None}
+
+
+@app.post("/non-nullable-default-model")
+def read_non_nullable_default_model(params: Annotated[NonNullableDefaultModel, Body()]):
+    return {"value": params.value, "fields_set": sorted(params.model_fields_set)}
+
+
+@app.post("/bare-required")
+def read_bare_required(value: Annotated[int | None, Body()]):
+    return value
+
+
+@app.post("/bare-none-default")
+def read_bare_none_default(value: Annotated[int | None, Body()] = None):
+    return value
+
+
+@app.post("/bare-int-default")
+def read_bare_int_default(value: Annotated[int | None, Body()] = 10):
+    return value
+
+
+@app.post("/bare-non-nullable-default")
+def read_bare_non_nullable_default(value: Annotated[int, Body()] = 10):
+    return value
+
+
+@app.post("/bare-str-default")
+def read_bare_str_default(value: Annotated[str | None, Body()] = "default"):
+    return value
+
+
+@app.post("/bare-list-default")
+def read_bare_list_default(
+    value: Annotated[list[int] | None, Body(default_factory=lambda: [10])],
+):
+    return value
+
+
+client = TestClient(app)
+
+
+@pytest.mark.parametrize(
+    "path,fields_set",
+    [
+        pytest.param(
+            "/required",
+            None,
+            marks=pytest.mark.xfail(
+                reason="Explicit null is treated as missing for a required Body parameter",
+                raises=AssertionError,
+            ),
+        ),
+        ("/required-model", ["value"]),
+        ("/none-default", None),
+        ("/none-default-model", ["value"]),
+        pytest.param(
+            "/non-null-default",
+            None,
+            marks=pytest.mark.xfail(
+                reason="Explicit null is replaced with the Body parameter default",
+                raises=AssertionError,
+            ),
+        ),
+        ("/non-null-default-model", ["value"]),
+    ],
+)
+def test_explicit_null(path, fields_set):
+    supplied = client.post(path, json={"value": 0})
+    assert supplied.status_code == 200
+    assert supplied.json()["value"] == 0
+    response = client.post(path, json={"value": None})
+    assert response.status_code == 200
+    assert response.json() == {"value": None, "fields_set": fields_set}
+
+
+@pytest.mark.parametrize(
+    "path,location",
+    [
+        ("/required", ["body", "value"]),
+        ("/required-model", ["body"]),
+        ("/none-default-model", ["body"]),
+        ("/non-null-default-model", ["body"]),
+    ],
+)
+def test_absent_body_for_required_argument(path, location):
+    # A model argument is required even when its fields have defaults.
+    response = client.post(path)
+    assert response.status_code == 422
+    assert [(error["type"], error["loc"]) for error in response.json()["detail"]] == [
+        ("missing", location),
+    ]
+
+
+@pytest.mark.parametrize(
+    "path,expected",
+    [
+        ("/none-default", None),
+        ("/non-null-default", 10),
+        ("/non-nullable-default", 10),
+    ],
+)
+def test_absent_body_uses_parameter_default(path, expected):
+    response = client.post(path)
+    assert response.status_code == 200
+    assert response.json() == {"value": expected, "fields_set": None}
+
+
+def test_absent_required_bare_body():
+    supplied = client.post("/bare-required", json=0)
+    assert supplied.status_code == 200
+    assert supplied.json() == 0
+    response = client.post("/bare-required")
+    assert response.status_code == 422
+    assert response.json()["detail"][0]["type"] == "missing"
+
+
+@pytest.mark.parametrize(
+    "path,expected",
+    [
+        ("/bare-none-default", None),
+        ("/bare-int-default", 10),
+        ("/bare-non-nullable-default", 10),
+    ],
+)
+def test_absent_bare_body_uses_default(path, expected):
+    response = client.post(path)
+    assert response.status_code == 200
+    assert response.json() == expected
+
+
+@pytest.mark.parametrize(
+    "path",
+    [
+        "/bare-none-default",
+        pytest.param(
+            "/bare-required",
+            marks=pytest.mark.xfail(
+                reason="Explicit null-body is treated as missing", raises=AssertionError
+            ),
+        ),
+        pytest.param(
+            "/bare-int-default",
+            marks=pytest.mark.xfail(
+                reason="Explicit null-body is replaced with the default",
+                raises=AssertionError,
+            ),
+        ),
+    ],
+)
+def test_explicit_null_bare_body(path):
+    response = client.post(
+        path, content="null", headers={"content-type": "application/json"}
+    )
+    assert response.status_code == 200
+    assert response.json() is None
+
+
+@pytest.mark.parametrize(
+    "path,value",
+    [("/bare-int-default", 0), ("/bare-str-default", ""), ("/bare-list-default", [])],
+)
+def test_falsey_bare_body_is_not_missing(path, value):
+    response = client.post(path, json=value)
+    assert response.status_code == 200
+    assert response.json() == value
+
+
+@pytest.mark.parametrize(
+    "path,error_type",
+    [
+        ("/bare-int-default", "int_type"),
+        ("/bare-str-default", "string_type"),
+        ("/bare-list-default", "list_type"),
+    ],
+)
+def test_object_is_not_a_valid_nullable_scalar_or_list(path, error_type):
+    response = client.post(path, json={})
+    assert response.status_code == 422
+    assert [(error["type"], error["loc"]) for error in response.json()["detail"]] == [
+        (error_type, ["body"]),
+    ]
+
+
+@pytest.mark.parametrize(
+    "path", ["/non-nullable-default", "/non-nullable-default-model"]
+)
+def test_omitted_non_nullable_field_uses_default(path):
+    response = client.post(path, json={})
+    assert response.status_code == 200
+    assert response.json()["value"] == 10
+
+
+@pytest.mark.parametrize(
+    "path,content,location",
+    [
+        pytest.param(
+            "/non-nullable-default",
+            '{"value": null}',
+            ["body", "value"],
+            marks=pytest.mark.xfail(
+                reason="Explicit null is replaced with the Body parameter default",
+                raises=AssertionError,
+            ),
+        ),
+        ("/non-nullable-default-model", '{"value": null}', ["body", "value"]),
+        pytest.param(
+            "/bare-non-nullable-default",
+            "null",
+            ["body"],
+            marks=pytest.mark.xfail(
+                reason="Explicit null-body is replaced with the default",
+                raises=AssertionError,
+            ),
+        ),
+    ],
+)
+def test_explicit_null_for_non_nullable_body_with_default(path, content, location):
+    response = client.post(
+        path, content=content, headers={"content-type": "application/json"}
+    )
+    assert response.status_code == 422
+    assert [
+        (error["type"], error["loc"], error["input"])
+        for error in response.json()["detail"]
+    ] == [
+        ("int_type", location, None),
+    ]

fastapi-0.147.0/tests/test_request_params/test_default_validation.py

@@ -0,0 +1,185 @@
+from typing import Annotated
+
+import pytest
+from fastapi import Body, Cookie, FastAPI, Form, Header, Query
+from fastapi.testclient import TestClient
+from pydantic import BaseModel, BeforeValidator, Field
+
+
+def double(value):
+    return 0 if value is None else int(value) * 2
+
+
+ValidatedInt = Annotated[int | None, BeforeValidator(double)]
+
+
+@pytest.mark.parametrize(
+    "parameter",
+    [
+        pytest.param(
+            parameter,
+            marks=pytest.mark.xfail(
+                reason="Missing values are validated as explicitly supplied defaults",
+                raises=AssertionError,
+            ),
+        )
+        for parameter in (Query, Header, Cookie, Form)
+    ]
+    + [Body],
+)
+@pytest.mark.parametrize("path", ["/parameter", "/model"])
+def test_missing_value_uses_default_without_validation(parameter, path):
+    app = FastAPI()
+    field = Body(embed=True) if parameter is Body else parameter()
+
+    @app.post("/parameter")
+    def read_parameter(value: Annotated[ValidatedInt, field] = 10):
+        return value
+
+    class Model(BaseModel):
+        value: ValidatedInt = 10
+
+    @app.post("/model")
+    def read_model(value: Annotated[Model, parameter()]):
+        return value.value
+
+    client = TestClient(app)
+    if parameter is Body:
+        response = client.post(path, json={})
+    else:
+        response = client.post(path)
+    assert response.status_code == 200
+    assert response.json() == 10
+
+
+@pytest.mark.parametrize("parameter", [Query, Header, Cookie, Form, Body])
+@pytest.mark.parametrize("path", ["/parameter", "/model"])
+def test_missing_value_uses_none_default_without_validation(parameter, path):
+    app = FastAPI()
+    field = Body(embed=True) if parameter is Body else parameter()
+
+    @app.post("/parameter")
+    def read_parameter(value: Annotated[ValidatedInt, field] = None):
+        return value
+
+    class Model(BaseModel):
+        value: ValidatedInt = None
+
+    @app.post("/model")
+    def read_model(value: Annotated[Model, parameter()]):
+        return value.value
+
+    client = TestClient(app)
+    if parameter is Body:
+        response = client.post(path, json={})
+    else:
+        response = client.post(path)
+    assert response.status_code == 200
+    assert response.json() is None
+
+
+@pytest.mark.parametrize("parameter", [Query, Header, Cookie, Form, Body])
+@pytest.mark.parametrize("path", ["/parameter", "/model"])
+def test_explicit_value_equal_to_default_is_validated(parameter, path):
+    app = FastAPI()
+    field = Body(embed=True) if parameter is Body else parameter()
+
+    @app.post("/parameter")
+    def read_parameter(value: Annotated[ValidatedInt, field] = 10):
+        return value
+
+    class Model(BaseModel):
+        value: ValidatedInt = 10
+
+    @app.post("/model")
+    def read_model(value: Annotated[Model, parameter()]):
+        return value.value
+
+    client = TestClient(app)
+    if parameter is Query:
+        response = client.post(path, params={"value": "10"})
+    elif parameter is Header:
+        response = client.post(path, headers={"value": "10"})
+    elif parameter is Cookie:
+        response = client.post(path, headers={"cookie": "value=10"})
+    elif parameter is Form:
+        response = client.post(path, data={"value": "10"})
+    else:
+        response = client.post(path, json={"value": 10})
+    assert response.status_code == 200
+    assert response.json() == 20
+
+
+@pytest.mark.parametrize("default", [None, 10])
+@pytest.mark.parametrize(
+    "path",
+    [
+        pytest.param(
+            "/parameter",
+            marks=pytest.mark.xfail(
+                reason="Explicit null is treated as missing for individual Body parameters",
+                raises=AssertionError,
+            ),
+        ),
+        "/model",
+    ],
+)
+def test_explicit_null_is_validated(default, path):
+    app = FastAPI()
+    field = Body(embed=True)
+
+    @app.post("/parameter")
+    def read_parameter(value: Annotated[ValidatedInt, field] = default):
+        return value
+
+    class Model(BaseModel):
+        value: ValidatedInt = default
+
+    @app.post("/model")
+    def read_model(value: Annotated[Model, Body()]):
+        return value.value
+
+    client = TestClient(app)
+    response = client.post(path, json={"value": None})
+    assert response.status_code == 200
+    assert response.json() == 0
+
+
+@pytest.mark.parametrize("default", [None, 10])
+@pytest.mark.xfail(
+    reason="Explicit null-body is treated as missing", raises=AssertionError
+)
+def test_explicit_null_body_is_validated(default):
+    app = FastAPI()
+
+    @app.post("/")
+    def read_body(value: Annotated[ValidatedInt, Body()] = default):
+        return value
+
+    client = TestClient(app)
+    response = client.post(
+        "/", content="null", headers={"content-type": "application/json"}
+    )
+    assert response.status_code == 200
+    assert response.json() == 0
+
+
+@pytest.mark.parametrize("parameter", [Query, Header, Cookie, Form, Body])
+@pytest.mark.parametrize("default,expected", [(None, 0), (10, 20)])
+def test_model_can_validate_default(parameter, default, expected):
+    app = FastAPI()
+
+    class Model(BaseModel):
+        value: Annotated[ValidatedInt, Field(validate_default=True)] = default
+
+    @app.post("/")
+    def read_model(value: Annotated[Model, parameter()]):
+        return value.value
+
+    client = TestClient(app)
+    if parameter is Body:
+        response = client.post("/", json={})
+    else:
+        response = client.post("/")
+    assert response.status_code == 200
+    assert response.json() == expected