fastapi 0.156.3__tar.gz → 0.156.4__tar.gz

{fastapi-0.156.3 → fastapi-0.156.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi
-Version: 0.156.3
+Version: 0.156.4
 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.156.3 → fastapi-0.156.4}/fastapi/__init__.py

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

{fastapi-0.156.3 → fastapi-0.156.4}/fastapi/dependencies/utils.py

@@ -1013,27 +1013,19 @@ def _extract_form_items(
             if isinstance(validation_alias, AliasChoices):
                 aliases = list(cast(list[str], validation_alias.choices))
             config = field.config or {}
-            if config.get("validate_by_name", config.get("populate_by_name", False)):
-                if config.get("validate_by_alias") is False:
-                    aliases = [field.name]
-                elif field.name not in aliases:
-                    aliases.append(field.name)
+            if config.get("validate_by_alias") is False:
+                aliases = [field.name]
+            elif (
+                config.get("validate_by_name", config.get("populate_by_name", False))
+                and field.name not in aliases
+            ):
+                aliases.append(field.name)
         # Interpret missing boolean form fields as unchecked HTML checkboxes.
         infer_false_if_missing = (
             not has_alias_path
             and field.field_info.annotation in (bool, bool | None)
             and not any(alias in received_body for alias in aliases)
         )
-        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 Undefined
-                ):
-                    selected_alias = alias
-                    break
-            aliases = [selected_alias]
         for alias in aliases:
             field_aliases.add(alias)
             if infer_false_if_missing:
@@ -1046,6 +1038,8 @@ def _extract_form_items(
                 field_aliases.add(alias)
             if value is not Undefined:
                 yield alias, value, field
+                # Leave later aliases unchanged for other fields or extra validation.
+                break
     for key in received_body.keys():
         if key not in field_aliases:
             param_values = received_body.getlist(key)
@@ -1118,11 +1112,20 @@ async def request_body_to_args(
         )
         return {first_field.name: v_}, errors_
     for field in body_fields:
-        loc = ("body", get_validation_alias(field))
+        if isinstance(received_body, FormData):
+            # Form values have already been extracted using their canonical aliases.
+            aliases = [get_validation_alias(field)]
+        else:
+            aliases = [alias for alias, _ in _get_param_aliases(field)]
+        loc = ("body", aliases[0])
         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), Undefined)
+                for alias in aliases:
+                    value = body_to_process.get(alias, Undefined)
+                    if value is not Undefined:
+                        loc = ("body", alias)
+                        break
             # Embedded fields require an object, not a list, scalar, or null.
             except AttributeError:
                 errors.append(get_missing_field_error(loc))

{fastapi-0.156.3 → fastapi-0.156.4}/pyproject.toml

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

fastapi-0.156.4/tests/test_body_alias_choices.py

@@ -0,0 +1,392 @@
+from typing import Annotated, Any
+
+import pytest
+from fastapi import Body, FastAPI
+from fastapi.testclient import TestClient
+from inline_snapshot import snapshot
+from pydantic import AliasChoices, AliasPath, BaseModel
+
+app = FastAPI()
+
+
+@app.post("/embedded")
+def read_embedded(
+    value: Annotated[
+        int,
+        Body(
+            embed=True,
+            alias="ignored",
+            validation_alias=AliasChoices("first", "second"),
+        ),
+    ],
+):
+    return value
+
+
+@app.post("/multiple")
+def read_multiple(
+    items: Annotated[
+        list[int],
+        Body(default_factory=list, validation_alias=AliasChoices("items", "tags")),
+    ],
+    value: Annotated[
+        int | None,
+        Body(alias="ignored", validation_alias=AliasChoices("first", "second")),
+    ] = 10,
+):
+    return {"value": value, "items": items}
+
+
+client = TestClient(app)
+
+
+@pytest.mark.parametrize(
+    "body, expected",
+    [
+        ({"first": 1}, 1),
+        ({"second": 2}, 2),
+        ({"second": 2, "first": 0}, 0),
+    ],
+)
+def test_embedded_body_alias_choices(body: dict[str, int], expected: int):
+    response = client.post("/embedded", json=body)
+    assert response.status_code == 200
+    assert response.json() == expected
+
+
+@pytest.mark.parametrize("path", ["/embedded", "/multiple"])
+@pytest.mark.parametrize(
+    "body, alias, value",
+    [
+        ({"first": "invalid", "second": 2}, "first", "invalid"),
+        ({"first": "", "second": 2}, "first", ""),
+        ({"second": "invalid"}, "second", "invalid"),
+    ],
+)
+def test_invalid_choice_uses_selected_alias(path, body, alias, value):
+    response = client.post(path, json=body)
+    assert response.status_code == 422
+    assert response.json() == {
+        "detail": [
+            {
+                "type": "int_parsing",
+                "loc": ["body", alias],
+                "msg": "Input should be a valid integer, unable to parse string as an integer",
+                "input": value,
+            }
+        ]
+    }
+
+
+@pytest.mark.parametrize("body", [{}, {"value": 1}, {"ignored": 1}])
+def test_required_body_missing_uses_first_alias(body: dict[str, int]):
+    response = client.post("/embedded", json=body)
+    assert response.status_code == 422
+    assert response.json() == {
+        "detail": [
+            {
+                "type": "missing",
+                "loc": ["body", "first"],
+                "msg": "Field required",
+                "input": None,
+            }
+        ]
+    }
+
+
+@pytest.mark.parametrize(
+    "body, expected",
+    [
+        ({}, {"value": 10, "items": []}),
+        ({"value": 1, "ignored": 2}, {"value": 10, "items": []}),
+        ({"first": 1, "items": [2, 3]}, {"value": 1, "items": [2, 3]}),
+        ({"second": 2, "tags": [3, 4]}, {"value": 2, "items": [3, 4]}),
+        (
+            {"second": 2, "first": 0, "tags": [3], "items": []},
+            {"value": 0, "items": []},
+        ),
+        ({"first": None, "second": 2}, {"value": None, "items": []}),
+        ({"second": None}, {"value": None, "items": []}),
+    ],
+)
+def test_multiple_body_alias_choices(body: dict[str, Any], expected: dict[str, Any]):
+    response = client.post("/multiple", json=body)
+    assert response.status_code == 200
+    assert response.json() == expected
+
+
+def test_list_error_uses_selected_alias():
+    response = client.post("/multiple", json={"tags": [1, "invalid"]})
+    assert response.status_code == 422
+    assert response.json() == {
+        "detail": [
+            {
+                "type": "int_parsing",
+                "loc": ["body", "tags", 1],
+                "msg": "Input should be a valid integer, unable to parse string as an integer",
+                "input": "invalid",
+            }
+        ]
+    }
+
+
+@pytest.mark.parametrize("body", ["null", "[]", "1", '"first"'])
+def test_embedded_body_requires_an_object(body: str):
+    response = client.post(
+        "/multiple", content=body, headers={"content-type": "application/json"}
+    )
+    assert response.status_code == 422
+    assert [(error["type"], error["loc"]) for error in response.json()["detail"]] == [
+        ("missing", ["body", "items"]),
+        ("missing", ["body", "first"]),
+    ]
+
+
+def test_absent_body_uses_defaults():
+    response = client.post("/multiple")
+    assert response.status_code == 200
+    assert response.json() == {"value": 10, "items": []}
+
+
+@pytest.mark.parametrize(
+    "body, alias",
+    [({"first": None, "second": 2}, "first"), ({"second": None}, "second")],
+)
+def test_explicit_null_does_not_use_another_alias_or_default(body, alias):
+    app = FastAPI()
+    calls = []
+
+    def default_factory():
+        calls.append(True)
+        return 10
+
+    @app.post("/")
+    def read(
+        value: Annotated[
+            int,
+            Body(
+                embed=True,
+                default_factory=default_factory,
+                validation_alias=AliasChoices("first", "second"),
+            ),
+        ],
+    ):
+        return value
+
+    client = TestClient(app)
+    response = client.post("/", json=body)
+    assert response.status_code == 422
+    assert response.json() == {
+        "detail": [
+            {
+                "type": "int_type",
+                "loc": ["body", alias],
+                "msg": "Input should be a valid integer",
+                "input": None,
+            }
+        ]
+    }
+    assert calls == []
+    response = client.post("/", json={})
+    assert response.status_code == 200
+    assert response.json() == 10
+    assert calls == [True]
+
+
+def test_model_body_alias_choice_preserves_nested_errors():
+    app = FastAPI()
+
+    class Item(BaseModel):
+        count: int
+
+    @app.post("/")
+    def read(
+        item: Annotated[
+            Item, Body(embed=True, validation_alias=AliasChoices("item", "data"))
+        ],
+    ):
+        return item
+
+    client = TestClient(app)
+    response = client.post("/", json={"data": {"count": 1}})
+    assert response.status_code == 200
+    assert response.json() == {"count": 1}
+    response = client.post("/", json={"data": {"count": "invalid"}})
+    assert response.status_code == 422
+    assert response.json() == {
+        "detail": [
+            {
+                "type": "int_parsing",
+                "loc": ["body", "data", "count"],
+                "msg": "Input should be a valid integer, unable to parse string as an integer",
+                "input": "invalid",
+            }
+        ]
+    }
+
+
+def test_unembedded_body_alias_choices_do_not_wrap_the_value():
+    app = FastAPI()
+
+    @app.post("/")
+    def read(
+        value: Annotated[int, Body(validation_alias=AliasChoices("first", "second"))],
+    ):
+        return value
+
+    client = TestClient(app)
+    response = client.post("/", json=1)
+    assert response.status_code == 200
+    assert response.json() == 1
+
+
+@pytest.mark.parametrize(
+    "validation_alias",
+    [AliasPath("nested", "value"), AliasChoices("first", AliasPath("nested", "value"))],
+)
+def test_alias_path_extraction_is_unchanged(validation_alias):
+    app = FastAPI()
+
+    @app.post("/")
+    def read(
+        value: Annotated[int, Body(embed=True, validation_alias=validation_alias)],
+    ):
+        return value
+
+    client = TestClient(app)
+    response = client.post("/", json={"value": 1, "first": 2, "nested": {"value": 3}})
+    assert response.status_code == 200
+    assert response.json() == 1
+
+
+def test_openapi():
+    response = client.get("/openapi.json")
+    assert response.status_code == 200
+    assert response.json() == snapshot(
+        {
+            "openapi": "3.1.0",
+            "info": {"title": "FastAPI", "version": "0.1.0"},
+            "paths": {
+                "/embedded": {
+                    "post": {
+                        "summary": "Read Embedded",
+                        "operationId": "read_embedded_embedded_post",
+                        "requestBody": {
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/Body_read_embedded_embedded_post"
+                                    }
+                                }
+                            },
+                            "required": True,
+                        },
+                        "responses": {
+                            "200": {
+                                "description": "Successful Response",
+                                "content": {"application/json": {"schema": {}}},
+                            },
+                            "422": {
+                                "description": "Validation Error",
+                                "content": {
+                                    "application/json": {
+                                        "schema": {
+                                            "$ref": "#/components/schemas/HTTPValidationError"
+                                        }
+                                    }
+                                },
+                            },
+                        },
+                    }
+                },
+                "/multiple": {
+                    "post": {
+                        "summary": "Read Multiple",
+                        "operationId": "read_multiple_multiple_post",
+                        "requestBody": {
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/Body_read_multiple_multiple_post"
+                                    }
+                                }
+                            }
+                        },
+                        "responses": {
+                            "200": {
+                                "description": "Successful Response",
+                                "content": {"application/json": {"schema": {}}},
+                            },
+                            "422": {
+                                "description": "Validation Error",
+                                "content": {
+                                    "application/json": {
+                                        "schema": {
+                                            "$ref": "#/components/schemas/HTTPValidationError"
+                                        }
+                                    }
+                                },
+                            },
+                        },
+                    }
+                },
+            },
+            "components": {
+                "schemas": {
+                    "Body_read_embedded_embedded_post": {
+                        "properties": {"first": {"type": "integer", "title": "First"}},
+                        "type": "object",
+                        "required": ["first"],
+                        "title": "Body_read_embedded_embedded_post",
+                    },
+                    "Body_read_multiple_multiple_post": {
+                        "properties": {
+                            "items": {
+                                "items": {"type": "integer"},
+                                "type": "array",
+                                "title": "Items",
+                            },
+                            "first": {
+                                "anyOf": [{"type": "integer"}, {"type": "null"}],
+                                "title": "First",
+                                "default": 10,
+                            },
+                        },
+                        "type": "object",
+                        "title": "Body_read_multiple_multiple_post",
+                    },
+                    "HTTPValidationError": {
+                        "properties": {
+                            "detail": {
+                                "items": {
+                                    "$ref": "#/components/schemas/ValidationError"
+                                },
+                                "type": "array",
+                                "title": "Detail",
+                            }
+                        },
+                        "type": "object",
+                        "title": "HTTPValidationError",
+                    },
+                    "ValidationError": {
+                        "properties": {
+                            "loc": {
+                                "items": {
+                                    "anyOf": [{"type": "string"}, {"type": "integer"}]
+                                },
+                                "type": "array",
+                                "title": "Location",
+                            },
+                            "msg": {"type": "string", "title": "Message"},
+                            "type": {"type": "string", "title": "Error Type"},
+                            "input": {"title": "Input"},
+                            "ctx": {"type": "object", "title": "Context"},
+                        },
+                        "type": "object",
+                        "required": ["loc", "msg", "type"],
+                        "title": "ValidationError",
+                    },
+                }
+            },
+        }
+    )

{fastapi-0.156.3 → fastapi-0.156.4}/tests/test_request_params/test_file/test_nullable_and_defaults.py

@@ -281,6 +281,25 @@ def test_required_non_nullable_files():
     assert response.json() == {"file": 0, "files": [0]}
 
 
+@pytest.mark.parametrize("alias", ["primary", "secondary"])
+def test_individual_file_alias_choices(alias: str):
+    app = FastAPI()
+
+    @app.post("/")
+    def read_file(
+        file: Annotated[
+            bytes,
+            File(alias="legacy", validation_alias=AliasChoices("primary", "secondary")),
+        ],
+    ):
+        return file.decode()
+
+    client = TestClient(app)
+    response = client.post("/", files={alias: ("hello.txt", b"hello")})
+    assert response.status_code == 200
+    assert response.json() == "hello"
+
+
 @pytest.mark.parametrize(
     "file_alias,files_alias",
     [("primary", "primary-files"), ("secondary", "secondary-files"), ("file", "files")],
@@ -318,6 +337,37 @@ def test_model_bytes_files_use_validation_aliases(file_alias, files_alias):
     assert response.json() == {"file": "one", "files": ["two", "three"]}
 
 
+def test_model_files_can_share_an_unused_alias_choice():
+    app = FastAPI()
+
+    class FileModel(BaseModel):
+        files: Annotated[
+            list[UploadFile], Field(validation_alias=AliasChoices("files", "legacy"))
+        ]
+        file: Annotated[
+            UploadFile, Field(validation_alias=AliasChoices("file", "legacy"))
+        ]
+
+    @app.post("/")
+    def read_form(data: Annotated[FileModel, Form()]):
+        return {
+            "files": [file.filename for file in data.files],
+            "file": data.file.filename,
+        }
+
+    client = TestClient(app)
+    response = client.post(
+        "/",
+        files=[
+            ("legacy", ("one.txt", b"one")),
+            ("legacy", ("two.txt", b"two")),
+            ("file", ("hello.txt", b"hello")),
+        ],
+    )
+    assert response.status_code == 200
+    assert response.json() == {"files": ["one.txt", "two.txt"], "file": "hello.txt"}
+
+
 def test_openapi_schema():
     response = client.get("/openapi.json")
     assert response.status_code == 200, response.text

{fastapi-0.156.3 → fastapi-0.156.4}/tests/test_request_params/test_form/test_nullable_and_defaults.py

@@ -228,10 +228,10 @@ def test_empty_form_model_value_uses_alias(field):
     [
         ConfigDict(populate_by_name=True, extra="forbid"),
         pytest.param(
-            ConfigDict(validate_by_name=True, validate_by_alias=False, extra="forbid"),
+            ConfigDict(validate_by_alias=False, extra="forbid"),
             marks=pytest.mark.skipif(
                 PYDANTIC_VERSION_MINOR_TUPLE < (2, 11),
-                reason="validate_by_name and validate_by_alias require Pydantic 2.11",
+                reason="validate_by_alias requires Pydantic 2.11",
             ),
         ),
     ],
@@ -396,6 +396,86 @@ def test_form_list_alias_choices_preserve_empty_items(path, data, expected):
     assert response.json() == {"value": expected}
 
 
+@pytest.mark.parametrize("encoding", ["urlencoded", "multipart"])
+def test_form_model_fields_can_share_an_unused_alias_choice(encoding):
+    app = FastAPI()
+
+    class Model(BaseModel):
+        names: Annotated[
+            list[str], Field(validation_alias=AliasChoices("names", "legacy"))
+        ]
+        text: Annotated[str, Field(validation_alias=AliasChoices("text", "legacy"))]
+
+    @app.post("/")
+    def read_model(params: Annotated[Model, Form()]):
+        return params
+
+    client = TestClient(app)
+    if encoding == "urlencoded":
+        response = client.post("/", data={"legacy": ["one", "two"], "text": "hello"})
+    else:
+        response = client.post(
+            "/",
+            files=[
+                ("legacy", (None, "one")),
+                ("legacy", (None, "two")),
+                ("text", (None, "hello")),
+            ],
+        )
+    assert response.status_code == 200
+    assert response.json() == {"names": ["one", "two"], "text": "hello"}
+
+
+@pytest.mark.parametrize("encoding", ["urlencoded", "multipart"])
+@pytest.mark.parametrize("unused", ["unused", ""])
+def test_unused_form_alias_choice_keeps_extra_value_shape(encoding, unused):
+    app = FastAPI()
+
+    class Model(BaseModel):
+        model_config = ConfigDict(extra="allow")
+        names: Annotated[
+            list[str], Field(validation_alias=AliasChoices("names", "legacy-names"))
+        ]
+        text: Annotated[
+            str, Field(validation_alias=AliasChoices("text", "legacy-text"))
+        ]
+
+    @app.post("/")
+    def read_model(params: Annotated[Model, Form()]):
+        return params
+
+    client = TestClient(app)
+    if encoding == "urlencoded":
+        response = client.post(
+            "/",
+            data={
+                "names": ["one", "two"],
+                "text": "hello",
+                "legacy-names": unused,
+                "legacy-text": ["", "unused"],
+            },
+        )
+    else:
+        response = client.post(
+            "/",
+            files=[
+                ("names", (None, "one")),
+                ("names", (None, "two")),
+                ("text", (None, "hello")),
+                ("legacy-names", (None, unused)),
+                ("legacy-text", (None, "")),
+                ("legacy-text", (None, "unused")),
+            ],
+        )
+    assert response.status_code == 200
+    assert response.json() == {
+        "names": ["one", "two"],
+        "text": "hello",
+        "legacy-names": unused,
+        "legacy-text": ["", "unused"],
+    }
+
+
 def test_empty_form_model_value_preserves_extra_and_json_strings():
     app = FastAPI()
 
@@ -749,10 +829,10 @@ def test_checkbox_uses_alias(path, alias, validation_alias, data, expected):
     [
         ConfigDict(populate_by_name=True, extra="forbid"),
         pytest.param(
-            ConfigDict(validate_by_name=True, validate_by_alias=False, extra="forbid"),
+            ConfigDict(validate_by_alias=False, extra="forbid"),
             marks=pytest.mark.skipif(
                 PYDANTIC_VERSION_MINOR_TUPLE < (2, 11),
-                reason="validate_by_name and validate_by_alias require Pydantic 2.11",
+                reason="validate_by_alias requires Pydantic 2.11",
             ),
         ),
     ],
@@ -820,11 +900,24 @@ def test_checkbox_with_alias_choices(path, data, expected):
     assert response.json() == {"value": expected}
 
 
-def test_unchecked_checkbox_with_alias_choices_overrides_defaults():
+@pytest.mark.parametrize(
+    "config",
+    [
+        ConfigDict(extra="forbid"),
+        pytest.param(
+            ConfigDict(validate_by_alias=False, extra="forbid"),
+            marks=pytest.mark.skipif(
+                PYDANTIC_VERSION_MINOR_TUPLE < (2, 11),
+                reason="validate_by_alias requires Pydantic 2.11",
+            ),
+        ),
+    ],
+)
+def test_unchecked_checkbox_with_alias_choices_overrides_defaults(config):
     app = FastAPI()
 
     class Model(BaseModel):
-        model_config = ConfigDict(extra="forbid")
+        model_config = config
         value: Annotated[
             bool, Field(validation_alias=AliasChoices("enabled", "checkbox"))
         ] = True