fastapi 0.156.2__tar.gz → 0.156.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi
-Version: 0.156.2
+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.2 → 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.2"
+__version__ = "0.156.4"
 
 from starlette import status as status
 

{fastapi-0.156.2 → fastapi-0.156.4}/fastapi/_compat/v2.py

@@ -259,20 +259,22 @@ def get_schema_from_model_field(
         tuple[ModelField, Literal["validation", "serialization"]], JsonSchemaValue
     ],
     separate_input_output_schemas: bool = True,
+    field_alias: str | None = None,
 ) -> dict[str, Any]:
     override_mode: Literal["validation"] | None = (
         None
         if (separate_input_output_schemas or _has_computed_fields(field))
         else "validation"
     )
-    field_alias = (
-        (field.validation_alias or field.alias)
-        if field.mode == "validation"
-        else (field.serialization_alias or field.alias)
-    )
+    if field_alias is None:
+        field_alias = (
+            (field.validation_alias or field.alias)
+            if field.mode == "validation"
+            else (field.serialization_alias or field.alias)
+        )
 
     # This expects that GenerateJsonSchema was already used to generate the definitions
-    json_schema = field_mapping[(field, override_mode or field.mode)]
+    json_schema = field_mapping[(field, override_mode or field.mode)].copy()
     if "$ref" not in json_schema:
         # TODO remove when deprecating Pydantic v1
         # Ref: https://github.com/pydantic/pydantic/blob/d61792cc42c80b13b23e3ffa74bc37ec7c77f7d1/pydantic/schema.py#L207

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

@@ -769,9 +769,8 @@ def _is_empty_file_input(value: Any) -> bool:
 
 
 def _get_multidict_value(
-    field: ModelField, values: Mapping[str, Any], alias: str | None = None
+    field: ModelField, values: Mapping[str, Any], alias: str
 ) -> Any:
-    alias = alias or get_validation_alias(field)
     if (
         (not _is_json_field(field))
         and field_annotation_is_sequence(field.field_info.annotation)
@@ -831,26 +830,28 @@ def request_params_to_args(
     processed_keys = set()
 
     for field in fields_to_extract:
-        alias = None
-        if isinstance(received_params, Headers):
-            # Handle fields extracted from a Pydantic Model for a header, each field
-            # doesn't have a FieldInfo of type Header with the default convert_underscores=True
-            convert_underscores = getattr(
-                field.field_info, "convert_underscores", default_convert_underscores
-            )
-            if convert_underscores:
-                alias = get_validation_alias(field)
-                if alias == field.name:
-                    alias = alias.replace("_", "-")
-                    header_aliases[field.name] = alias
-        value = _get_multidict_value(field, received_params, alias=alias)
+        convert_underscores = isinstance(received_params, Headers) and getattr(
+            field.field_info, "convert_underscores", default_convert_underscores
+        )
+        aliases = _get_param_aliases(field, convert_underscores=convert_underscores)
+        alias, request_alias = next(
+            (pair for pair in aliases if pair[1] in received_params), aliases[0]
+        )
+        # Only reshape the selected alias. Unused choices can be extra fields
+        # or aliases used by other fields with different types.
+        value = _get_multidict_value(field, received_params, alias=request_alias)
         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
-        # header name and the original field alias as processed to avoid
-        # accepting the original alias as an extra header.
-        processed_keys.add(get_validation_alias(field))
+            params_to_process[alias] = value
+        if isinstance(received_params, Headers):
+            processed_keys.add(request_alias.lower())
+            for validation_alias, header_alias in aliases:
+                if validation_alias != header_alias:
+                    # Do not accept an unconverted field name as an extra header.
+                    processed_keys.add(validation_alias.lower())
+            if alias != request_alias:
+                header_aliases[field.name] = request_alias
+        else:
+            processed_keys.add(request_alias)
 
     for key in received_params.keys():
         if key not in processed_keys:
@@ -887,12 +888,16 @@ def request_params_to_args(
         return {first_field.name: v_}, errors_
 
     for field in fields:
-        value = _get_multidict_value(field, received_params)
+        aliases = _get_param_aliases(field)
+        _, alias = next(
+            (pair for pair in aliases if pair[1] in received_params), aliases[0]
+        )
+        value = _get_multidict_value(field, received_params, alias=alias)
         field_info = field.field_info
         assert isinstance(field_info, params.Param), (
             "Params must be subclasses of Param"
         )
-        loc = (field_info.in_.value, get_validation_alias(field))
+        loc = (field_info.in_.value, alias)
         v_, errors_ = _validate_value_with_model_field(
             field=field, value=value, values=values, loc=loc
         )
@@ -1008,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:
@@ -1041,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)
@@ -1113,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))
@@ -1185,3 +1193,35 @@ def _get_body_field(
 def get_validation_alias(field: ModelField) -> str:
     va = getattr(field, "validation_alias", None)
     return va or field.alias
+
+
+def _get_param_aliases(
+    field: ModelField, *, convert_underscores: bool = False
+) -> list[tuple[str, str]]:
+    """Return (validation alias, request key) pairs in preference order."""
+    alias = get_validation_alias(field)
+    request_alias = alias
+    if convert_underscores and alias == field.name:
+        request_alias = alias.replace("_", "-")
+    validation_alias = field.field_info.validation_alias
+    if (
+        isinstance(field.field_info, params.Path)
+        or not isinstance(validation_alias, AliasChoices)
+        or any(isinstance(alias, AliasPath) for alias in validation_alias.choices)
+    ):
+        return [(alias, request_alias)]
+    choices = cast(list[str], validation_alias.choices)
+    # Explicit choices are literal names, including underscores in headers.
+    aliases = [(choice, choice) for choice in choices]
+    config = field.config or {}
+    if config.get("validate_by_alias") is False or config.get(
+        "validate_by_name", config.get("populate_by_name", False)
+    ):
+        request_name = field.name
+        if convert_underscores:
+            request_name = request_name.replace("_", "-")
+        if config.get("validate_by_alias") is False:
+            return [(field.name, request_name)]
+        if field.name not in choices:
+            aliases.append((field.name, request_name))
+    return aliases

{fastapi-0.156.2 → fastapi-0.156.4}/fastapi/openapi/utils.py

@@ -26,8 +26,8 @@ from fastapi.dependencies.models import (
 )
 from fastapi.dependencies.utils import (
     _get_flat_fields_from_params,
+    _get_param_aliases,
     get_flat_params,
-    get_validation_alias,
 )
 from fastapi.encoders import jsonable_encoder
 from fastapi.exceptions import FastAPIDeprecationWarning
@@ -189,24 +189,19 @@ def _get_openapi_operation_parameters(
             # field_info = cast(Param, field_info)
             if not getattr(field_info, "include_in_schema", True):
                 continue
+            convert_underscores = param_type == ParamTypes.header and getattr(
+                field_info, "convert_underscores", default_convert_underscores
+            )
+            alias, name = _get_param_aliases(
+                param, convert_underscores=convert_underscores
+            )[0]
             param_schema = get_schema_from_model_field(
                 field=param,
                 model_name_map=model_name_map,
                 field_mapping=field_mapping,
                 separate_input_output_schemas=separate_input_output_schemas,
+                field_alias=alias,
             )
-            name = get_validation_alias(param)
-            convert_underscores = getattr(
-                param.field_info,
-                "convert_underscores",
-                default_convert_underscores,
-            )
-            if (
-                param_type == ParamTypes.header
-                and name == param.name
-                and convert_underscores
-            ):
-                name = param.name.replace("_", "-")
 
             parameter = {
                 "name": name,

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

@@ -53,7 +53,7 @@ dependencies = [
     "annotated-doc>=0.0.2",
     "opentelemetry-api>=1.44.0",
 ]
-version = "0.156.2"
+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",
+                    },
+                }
+            },
+        }
+    )