fastapi 0.149.0__tar.gz → 0.151.0__tar.gz

{fastapi-0.149.0 → fastapi-0.151.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi
-Version: 0.149.0
+Version: 0.151.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.149.0 → fastapi-0.151.0}/fastapi/__init__.py

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

{fastapi-0.149.0 → fastapi-0.151.0}/fastapi/dependencies/utils.py

@@ -587,7 +587,7 @@ async def solve_dependencies(
     *,
     request: Request | WebSocket,
     dependant: Dependant,
-    body: dict[str, Any] | FormData | bytes | None = None,
+    body: Any = Undefined,
     background_tasks: StarletteBackgroundTasks | None = None,
     response: Response | None = None,
     dependency_overrides_provider: Any | None = None,
@@ -734,7 +734,7 @@ async def solve_dependencies(
 def _validate_value_with_model_field(
     *, field: ModelField, value: Any, values: dict[str, Any], loc: tuple[str, ...]
 ) -> tuple[Any, list[Any]]:
-    if value is None:
+    if value is Undefined:
         if field.field_info.is_required():
             return None, [get_missing_field_error(loc=loc)]
         value = deepcopy(field.default)
@@ -747,6 +747,11 @@ def _is_json_field(field: ModelField) -> bool:
     return any(type(item) is Json for item in field.field_info.metadata)
 
 
+def _is_empty_file_input(value: Any) -> bool:
+    # Browsers send an empty filename and content when no file is selected.
+    return isinstance(value, UploadFile) and value.filename == "" and value.size == 0
+
+
 def _get_multidict_value(
     field: ModelField, values: Mapping[str, Any], alias: str | None = None
 ) -> Any:
@@ -757,14 +762,17 @@ def _get_multidict_value(
         and isinstance(values, (ImmutableMultiDict, Headers))
     ):
         value = values.getlist(alias)
+        if isinstance(values, FormData):
+            value = [item for item in value if not _is_empty_file_input(item)]
     else:
         value = values.get(alias, None)
     if (
         value is None
         or (
             isinstance(values, FormData)
-            and isinstance(value, str)  # For type checks
-            and value == ""
+            and (
+                (isinstance(value, str) and value == "") or _is_empty_file_input(value)
+            )
         )
         or (
             field_annotation_is_sequence(field.field_info.annotation)
@@ -772,7 +780,7 @@ def _get_multidict_value(
         )
     ):
         # Apply defaults during validation, not while extracting request data.
-        return None
+        return Undefined
     return value
 
 
@@ -818,7 +826,7 @@ def request_params_to_args(
                 if alias == field.name:
                     alias = alias.replace("_", "-")
         value = _get_multidict_value(field, received_params, alias=alias)
-        if value is not None:
+        if value is not Undefined:
             params_to_process[get_validation_alias(field)] = value
         processed_keys.add(alias or get_validation_alias(field))
         # For headers with convert_underscores=True, mark both the converted
@@ -942,7 +950,10 @@ async def _extract_form_body(
         if field.config is None or infer_false_if_missing:
             selected_alias = aliases[0]
             for alias in aliases:
-                if _get_multidict_value(field, received_body, alias=alias) is not None:
+                if (
+                    _get_multidict_value(field, received_body, alias=alias)
+                    is not Undefined
+                ):
                     selected_alias = alias
                     break
             aliases = [selected_alias]
@@ -977,7 +988,7 @@ async def _extract_form_body(
                 # Individual parameters are later looked up by their declared alias.
                 alias = get_validation_alias(field)
                 field_aliases.add(alias)
-            if value is not None:
+            if value is not Undefined:
                 values[alias] = value
     for key in received_body.keys():
         if key not in field_aliases:
@@ -991,7 +1002,7 @@ async def _extract_form_body(
 
 async def request_body_to_args(
     body_fields: list[ModelField],
-    received_body: dict[str, Any] | FormData | bytes | None,
+    received_body: Any,
     embed_body_fields: bool,
 ) -> tuple[dict[str, Any], list[dict[str, Any]]]:
     values: dict[str, Any] = {}
@@ -1021,11 +1032,11 @@ async def request_body_to_args(
         return {first_field.name: v_}, errors_
     for field in body_fields:
         loc = ("body", get_validation_alias(field))
-        value: Any | None = None
-        if body_to_process is not None and not isinstance(body_to_process, bytes):
+        value: Any = Undefined
+        if body_to_process is not Undefined and not isinstance(body_to_process, bytes):
             try:
-                value = body_to_process.get(get_validation_alias(field))
-            # If the received body is a list, not a dict
+                value = body_to_process.get(get_validation_alias(field), Undefined)
+            # Embedded fields require an object, not a list, scalar, or null.
             except AttributeError:
                 errors.append(get_missing_field_error(loc))
                 continue

{fastapi-0.149.0 → fastapi-0.151.0}/fastapi/routing.py

@@ -100,7 +100,7 @@ from starlette import routing
 from starlette._exception_handler import wrap_app_handling_exceptions
 from starlette._utils import get_route_path, is_async_callable
 from starlette.concurrency import iterate_in_threadpool, run_in_threadpool
-from starlette.datastructures import URL, FormData, URLPath
+from starlette.datastructures import URL, URLPath
 from starlette.exceptions import HTTPException
 from starlette.requests import Request
 from starlette.responses import (
@@ -449,7 +449,7 @@ def get_request_handler(
 
         # Read body and auto-close files
         try:
-            body: Any = None
+            body: Any = Undefined
             if body_field:
                 if is_body_form:
                     body = await request.form()
@@ -469,7 +469,7 @@ def get_request_handler(
                                 subtype = message.get_content_subtype()
                                 if subtype == "json" or subtype.endswith("+json"):
                                     json_body = await request.json()
-                        if json_body != Undefined:
+                        if json_body is not Undefined:
                             body = json_body
                         else:
                             body = body_bytes
@@ -499,7 +499,7 @@ def get_request_handler(
             raise http_error from e
 
         if telemetry_data is not None:
-            telemetry_data.body = body
+            telemetry_data.body = None if body is Undefined else body
 
         # Solve dependencies and run path operation function, auto-closing dependencies
         errors: list[Any] = []
@@ -511,7 +511,7 @@ def get_request_handler(
             solved_result = await solve_dependencies(
                 request=request,
                 dependant=dependant,
-                body=cast(dict[str, Any] | FormData | bytes | None, body),
+                body=body,
                 dependency_overrides_provider=dependency_overrides_provider,
                 async_exit_stack=async_exit_stack,
                 embed_body_fields=embed_body_fields,
@@ -790,7 +790,9 @@ def get_request_handler(
                     response.headers.raw.extend(solved_result.response.headers.raw)
         if errors:
             validation_error = RequestValidationError(
-                errors, body=body, endpoint_ctx=endpoint_ctx
+                errors,
+                body=None if body is Undefined else body,
+                endpoint_ctx=endpoint_ctx,
             )
             _validation_failed(validation_error)
             raise validation_error

{fastapi-0.149.0 → fastapi-0.151.0}/pyproject.toml

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

{fastapi-0.149.0 → fastapi-0.151.0}/tests/test_request_params/test_body/test_nullable_and_defaults.py

@@ -1,7 +1,9 @@
 from typing import Annotated
 
 import pytest
-from fastapi import Body, FastAPI
+from fastapi import Body, Depends, FastAPI, Request
+from fastapi.exceptions import RequestValidationError
+from fastapi.responses import JSONResponse
 from fastapi.testclient import TestClient
 from pydantic import BaseModel
 
@@ -102,25 +104,11 @@ 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", None),
         ("/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", None),
         ("/non-null-default-model", ["value"]),
     ],
 )
@@ -192,19 +180,8 @@ def test_absent_bare_body_uses_default(path, expected):
     "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,
-            ),
-        ),
+        "/bare-required",
+        "/bare-int-default",
     ],
 )
 def test_explicit_null_bare_body(path):
@@ -253,25 +230,9 @@ def test_omitted_non_nullable_field_uses_default(path):
 @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", '{"value": null}', ["body", "value"]),
         ("/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,
-            ),
-        ),
+        ("/bare-non-nullable-default", "null", ["body"]),
     ],
 )
 def test_explicit_null_for_non_nullable_body_with_default(path, content, location):
@@ -285,3 +246,179 @@ def test_explicit_null_for_non_nullable_body_with_default(path, content, locatio
     ] == [
         ("int_type", location, None),
     ]
+
+
+@pytest.mark.parametrize(
+    "path",
+    ["/required", "/none-default", "/non-null-default", "/non-nullable-default"],
+)
+def test_explicit_null_is_not_an_embedded_body_object(path):
+    response = client.post(
+        path, content="null", headers={"content-type": "application/json"}
+    )
+    assert response.status_code == 422
+    assert response.json() == {
+        "detail": [
+            {
+                "type": "missing",
+                "loc": ["body", "value"],
+                "msg": "Field required",
+                "input": None,
+            }
+        ]
+    }
+
+
+def test_explicit_null_is_not_an_object_for_multiple_body_parameters():
+    app = FastAPI()
+
+    @app.post("/")
+    def read_values(
+        value: Annotated[int | None, Body()] = 10,
+        other: Annotated[int | None, Body()] = 20,
+    ):
+        return {"value": value, "other": other}
+
+    client = TestClient(app)
+    response = client.post(
+        "/", content="null", headers={"content-type": "application/json"}
+    )
+    assert response.status_code == 422
+    assert [(error["type"], error["loc"]) for error in response.json()["detail"]] == [
+        ("missing", ["body", "value"]),
+        ("missing", ["body", "other"]),
+    ]
+
+    response = client.post("/")
+    assert response.status_code == 200
+    assert response.json() == {"value": 10, "other": 20}
+
+    response = client.post("/", json={})
+    assert response.status_code == 200
+    assert response.json() == {"value": 10, "other": 20}
+
+    response = client.post("/", json={"value": None, "other": None})
+    assert response.status_code == 200
+    assert response.json() == {"value": None, "other": None}
+
+
+@pytest.mark.parametrize(
+    "embed,null_content,missing_content",
+    [(False, "null", ""), (True, '{"value": null}', "{}")],
+)
+def test_explicit_null_does_not_call_default_factory(
+    embed, null_content, missing_content
+):
+    app = FastAPI()
+    calls = 0
+
+    def default_factory():
+        nonlocal calls
+        calls += 1
+        return "10"
+
+    @app.post("/")
+    def read_value(
+        value: Annotated[
+            int | None,
+            Body(embed=embed, default_factory=default_factory, validate_default=True),
+        ],
+    ):
+        return value
+
+    client = TestClient(app)
+    response = client.post(
+        "/", content=null_content, headers={"content-type": "application/json"}
+    )
+    assert response.status_code == 200
+    assert response.json() is None
+    assert calls == 0
+
+    response = client.post(
+        "/", content=missing_content, headers={"content-type": "application/json"}
+    )
+    assert response.status_code == 200
+    assert response.json() == 10
+    assert calls == 1
+
+
+def test_explicit_null_in_body_dependency_uses_alias():
+    app = FastAPI()
+
+    def dependency(value: Annotated[int | None, Body(alias="input")] = 10):
+        return value
+
+    @app.post("/")
+    def read_values(
+        value: Annotated[int | None, Depends(dependency)],
+        other: Annotated[int, Body()] = 20,
+    ):
+        return {"value": value, "other": other}
+
+    client = TestClient(app)
+    response = client.post("/", json={"input": None})
+    assert response.status_code == 200
+    assert response.json() == {"value": None, "other": 20}
+
+    response = client.post("/", json={})
+    assert response.status_code == 200
+    assert response.json() == {"value": 10, "other": 20}
+
+
+@pytest.mark.parametrize(
+    "embed,null_content,missing_content",
+    [(False, "null", ""), (True, '{"params": null}', "{}")],
+)
+def test_explicit_null_for_nullable_model_body(embed, null_content, missing_content):
+    app = FastAPI()
+
+    @app.post("/")
+    def read_model(
+        params: Annotated[RequiredModel | None, Body(embed=embed)] = RequiredModel(
+            value=10
+        ),
+    ):
+        return params
+
+    client = TestClient(app)
+    response = client.post(
+        "/", content=null_content, headers={"content-type": "application/json"}
+    )
+    assert response.status_code == 200
+    assert response.json() is None
+
+    response = client.post(
+        "/", content=missing_content, headers={"content-type": "application/json"}
+    )
+    assert response.status_code == 200
+    assert response.json() == {"value": 10}
+
+
+@pytest.mark.parametrize("content,error_type", [("", "missing"), ("null", "int_type")])
+def test_validation_error_body_for_missing_and_null(content, error_type):
+    app = FastAPI()
+
+    @app.post("/")
+    def read_value(value: Annotated[int, Body()]):
+        return value
+
+    @app.exception_handler(RequestValidationError)
+    def handle_error(request: Request, exc: RequestValidationError):
+        return JSONResponse(
+            status_code=422, content={"body": exc.body, "detail": exc.errors()}
+        )
+
+    client = TestClient(app)
+    response = client.post("/", json=1)
+    assert response.status_code == 200
+    assert response.json() == 1
+
+    response = client.post(
+        "/", content=content, headers={"content-type": "application/json"}
+    )
+    assert response.status_code == 422
+    assert response.json()["body"] is None
+    assert [
+        (error["type"], error["loc"], error["input"])
+        for error in response.json()["detail"]
+    ] == [(error_type, ["body"], None)]

{fastapi-0.149.0 → fastapi-0.151.0}/tests/test_request_params/test_default_validation.py

@@ -99,25 +99,12 @@ def test_explicit_value_equal_to_default_is_validated(parameter, path):
 
 
 @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",
-    ],
-)
+@pytest.mark.parametrize("path", ["/parameter", "/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):
+    def read_parameter(value: Annotated[ValidatedInt, Body(embed=True)] = default):
         return value
 
     class Model(BaseModel):
@@ -134,9 +121,6 @@ def test_explicit_null_is_validated(default, path):
 
 
 @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()
 

{fastapi-0.149.0 → fastapi-0.151.0}/tests/test_request_params/test_file/test_nullable_and_defaults.py

@@ -1,9 +1,10 @@
 from typing import Annotated
 
 import pytest
-from fastapi import FastAPI, File, UploadFile
+from fastapi import FastAPI, File, Form, UploadFile
 from fastapi.testclient import TestClient
 from inline_snapshot import snapshot
+from pydantic import BaseModel, Field
 
 app = FastAPI()
 
@@ -80,14 +81,7 @@ EMPTY_FILE_FORM = (
     "content",
     [
         pytest.param(b"", id="omitted"),
-        pytest.param(
-            EMPTY_FILE_FORM,
-            id="no-selection",
-            marks=pytest.mark.xfail(
-                reason="A file with an empty filename and content is treated as supplied",
-                raises=AssertionError,
-            ),
-        ),
+        pytest.param(EMPTY_FILE_FORM, id="no-selection"),
     ],
 )
 def test_missing_required_nullable_files(path, content):
@@ -108,14 +102,7 @@ def test_missing_required_nullable_files(path, content):
     "content",
     [
         pytest.param(b"", id="omitted"),
-        pytest.param(
-            EMPTY_FILE_FORM,
-            id="no-selection",
-            marks=pytest.mark.xfail(
-                reason="A file with an empty filename and content is treated as supplied",
-                raises=AssertionError,
-            ),
-        ),
+        pytest.param(EMPTY_FILE_FORM, id="no-selection"),
     ],
 )
 def test_missing_optional_nullable_files(path, content):
@@ -158,14 +145,7 @@ def test_named_file_is_supplied_even_when_empty(path, content):
     "content",
     [
         pytest.param(b"", id="omitted"),
-        pytest.param(
-            EMPTY_FILE_FORM,
-            id="no-selection",
-            marks=pytest.mark.xfail(
-                reason="A file with an empty filename and content is treated as supplied",
-                raises=AssertionError,
-            ),
-        ),
+        pytest.param(EMPTY_FILE_FORM, id="no-selection"),
     ],
 )
 def test_missing_files_use_bytes_defaults(content):
@@ -191,6 +171,116 @@ def test_supplied_files_override_bytes_defaults(content, expected):
     assert response.json() == {"file": expected, "files": [expected]}
 
 
+@pytest.mark.parametrize("path", ["/required-bytes", "/required-uploadfile"])
+def test_file_without_a_name_is_supplied_when_it_has_content(path):
+    response = client.post(
+        path,
+        content=(
+            b"--boundary\r\n"
+            b'Content-Disposition: form-data; name="file"; filename=""\r\n'
+            b"Content-Type: application/octet-stream\r\n\r\n"
+            b"hello\r\n--boundary\r\n"
+            b'Content-Disposition: form-data; name="files"; filename=""\r\n'
+            b"Content-Type: application/octet-stream\r\n\r\n"
+            b"hello\r\n--boundary--\r\n"
+        ),
+        headers={"content-type": "multipart/form-data; boundary=boundary"},
+    )
+    assert response.status_code == 200
+    assert response.json() == {"file": 5, "files": [5]}
+
+
+@pytest.mark.parametrize("path", ["/required-bytes", "/required-uploadfile"])
+def test_file_list_ignores_unselected_inputs(path):
+    response = client.post(
+        path,
+        content=(
+            b"--boundary\r\n"
+            b'Content-Disposition: form-data; name="file"; filename="empty.txt"\r\n'
+            b"Content-Type: application/octet-stream\r\n\r\n"
+            b"\r\n--boundary\r\n"
+            b'Content-Disposition: form-data; name="files"; filename="first.txt"\r\n'
+            b"Content-Type: application/octet-stream\r\n\r\n"
+            b"\r\n--boundary\r\n"
+            b'Content-Disposition: form-data; name="files"; filename=""\r\n'
+            b"Content-Type: application/octet-stream\r\n\r\n"
+            b"\r\n--boundary\r\n"
+            b'Content-Disposition: form-data; name="files"; filename="last.txt"\r\n'
+            b"Content-Type: application/octet-stream\r\n\r\n"
+            b"hello\r\n--boundary--\r\n"
+        ),
+        headers={"content-type": "multipart/form-data; boundary=boundary"},
+    )
+    assert response.status_code == 200
+    assert response.json() == {"file": 0, "files": [0, 5]}
+
+
+def test_multipart_text_items_in_bytes_list_are_preserved():
+    response = client.post(
+        "/required-bytes",
+        files=[
+            ("file", ("empty.txt", b"")),
+            ("files", (None, "")),
+            ("files", (None, "text")),
+            ("files", ("selected.txt", b"hello")),
+        ],
+    )
+    assert response.status_code == 200
+    assert response.json() == {"file": 0, "files": [0, 4, 5]}
+
+
+def test_unselected_files_in_form_model_use_defaults_and_remain_unset():
+    app = FastAPI()
+
+    class FileModel(BaseModel):
+        file: UploadFile | None = None
+        files: Annotated[list[UploadFile], Field(default_factory=list)]
+
+    @app.post("/")
+    def upload(params: Annotated[FileModel, Form()]):
+        assert params.file is None
+        assert params.files == []
+        return params.model_dump(exclude_unset=True)
+
+    client = TestClient(app)
+    response = client.post(
+        "/",
+        content=EMPTY_FILE_FORM,
+        headers={"content-type": "multipart/form-data; boundary=boundary"},
+    )
+    assert response.status_code == 200
+    assert response.json() == {}
+
+
+def test_required_non_nullable_files():
+    app = FastAPI()
+
+    @app.post("/")
+    def upload(
+        file: Annotated[UploadFile, File()], files: Annotated[list[bytes], File()]
+    ):
+        return {"file": file.size, "files": [len(value) for value in files]}
+
+    client = TestClient(app)
+    response = client.post(
+        "/",
+        content=EMPTY_FILE_FORM,
+        headers={"content-type": "multipart/form-data; boundary=boundary"},
+    )
+    assert response.status_code == 422
+    assert [(error["type"], error["loc"]) for error in response.json()["detail"]] == [
+        ("missing", ["body", "file"]),
+        ("missing", ["body", "files"]),
+    ]
+
+    response = client.post(
+        "/",
+        files=[("file", ("empty.txt", b"")), ("files", ("empty.txt", b""))],
+    )
+    assert response.status_code == 200
+    assert response.json() == {"file": 0, "files": [0]}
+
+
 def test_openapi_schema():
     response = client.get("/openapi.json")
     assert response.status_code == 200, response.text