fastapi 0.147.0__tar.gz → 0.149.0__tar.gz

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

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

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

{fastapi-0.147.0 → fastapi-0.149.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 AliasChoices, BaseModel, Json
+from pydantic import AliasChoices, AliasPath, BaseModel, Json
 from pydantic.fields import FieldInfo
 from starlette.background import BackgroundTasks as StarletteBackgroundTasks
 from starlette.concurrency import run_in_threadpool
@@ -737,8 +737,9 @@ def _validate_value_with_model_field(
     if value is None:
         if field.field_info.is_required():
             return None, [get_missing_field_error(loc=loc)]
-        else:
-            return deepcopy(field.default), []
+        value = deepcopy(field.default)
+        if not field.field_info.validate_default:
+            return value, []
     return field.validate(value, values, loc=loc)
 
 
@@ -761,7 +762,7 @@ def _get_multidict_value(
     if (
         value is None
         or (
-            isinstance(field.field_info, params.Form)
+            isinstance(values, FormData)
             and isinstance(value, str)  # For type checks
             and value == ""
         )
@@ -770,10 +771,8 @@ def _get_multidict_value(
             and len(value) == 0
         )
     ):
-        if field.field_info.is_required():
-            return
-        else:
-            return deepcopy(field.default)
+        # Apply defaults during validation, not while extracting request data.
+        return None
     return value
 
 
@@ -917,65 +916,69 @@ async def _extract_form_body(
     field_aliases: set[str] = set()
 
     for field in body_fields:
-        alias = get_validation_alias(field)
+        aliases = [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)
+        has_alias_path = isinstance(validation_alias, AliasPath) or (
+            isinstance(validation_alias, AliasChoices)
+            and any(
+                isinstance(choice, AliasPath) for choice in validation_alias.choices
             )
         )
-        if infer_false_if_missing:
+        if not has_alias_path:
             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]
-                )
+                aliases = list(cast(list[str], validation_alias.choices))
             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)
-            and is_bytes_or_nonable_bytes_annotation(field.field_info.annotation)
-            and isinstance(value, UploadFile)
-        ):
-            value = await value.read()
-        elif (
-            is_bytes_sequence_annotation(field.field_info.annotation)
-            and isinstance(field_info, params.File)
-            and value_is_sequence(value)
-        ):
-            # For types
-            assert isinstance(value, sequence_types)
-            results: list[bytes | str] = []
-            for sub_value in value:
-                if isinstance(sub_value, UploadFile):
-                    results.append(await sub_value.read())
-                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)
+            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)
+        # 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 None:
+                    selected_alias = alias
+                    break
+            aliases = [selected_alias]
+        for alias in aliases:
             field_aliases.add(alias)
-        if value is not None:
-            values[alias] = value
+            if infer_false_if_missing:
+                value: Any = False
+            else:
+                value = _get_multidict_value(field, received_body, alias=alias)
+            field_info = field.field_info
+            if (
+                isinstance(field_info, params.File)
+                and is_bytes_or_nonable_bytes_annotation(field.field_info.annotation)
+                and isinstance(value, UploadFile)
+            ):
+                value = await value.read()
+            elif (
+                is_bytes_sequence_annotation(field.field_info.annotation)
+                and isinstance(field_info, params.File)
+                and value_is_sequence(value)
+            ):
+                # For types
+                assert isinstance(value, sequence_types)
+                results: list[bytes | str] = []
+                for sub_value in value:
+                    if isinstance(sub_value, UploadFile):
+                        results.append(await sub_value.read())
+                    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[alias] = value
     for key in received_body.keys():
         if key not in field_aliases:
             param_values = received_body.getlist(key)

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

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

{fastapi-0.147.0 → fastapi-0.149.0}/tests/test_forms_single_model.py

@@ -99,13 +99,13 @@ def test_no_data():
                 "type": "missing",
                 "loc": ["body", "username"],
                 "msg": "Field required",
-                "input": {"tags": ["foo", "bar"], "with": "nothing"},
+                "input": {},
             },
             {
                 "type": "missing",
                 "loc": ["body", "lastname"],
                 "msg": "Field required",
-                "input": {"tags": ["foo", "bar"], "with": "nothing"},
+                "input": {},
             },
         ]
     }

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

@@ -1,4 +1,5 @@
 from typing import Annotated
+from unittest.mock import Mock
 
 import pytest
 from fastapi import Body, Cookie, FastAPI, Form, Header, Query
@@ -13,20 +14,7 @@ def double(value):
 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("parameter", [Query, Header, Cookie, Form, Body])
 @pytest.mark.parametrize("path", ["/parameter", "/model"])
 def test_missing_value_uses_default_without_validation(parameter, path):
     app = FastAPI()
@@ -183,3 +171,78 @@ def test_model_can_validate_default(parameter, default, expected):
         response = client.post("/")
     assert response.status_code == 200
     assert response.json() == expected
+
+
+@pytest.mark.parametrize("parameter", [Query, Header, Cookie, Form, Body])
+@pytest.mark.parametrize("default,expected", [(None, 0), (10, 20)])
+def test_parameter_can_validate_default(parameter, default, expected):
+    app = FastAPI()
+    field = (
+        Body(embed=True, validate_default=True)
+        if parameter is Body
+        else parameter(validate_default=True)
+    )
+
+    @app.post("/")
+    def read_parameter(value: Annotated[ValidatedInt, field] = default):
+        return 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
+
+
+@pytest.mark.parametrize("parameter", [Query, Header, Cookie, Form, Body])
+@pytest.mark.parametrize("default,expected", [(None, 0), (10, 20)])
+def test_parameter_validates_default_factory_once(parameter, default, expected):
+    app = FastAPI()
+    default_factory = Mock(return_value=default)
+    field = (
+        Body(embed=True, default_factory=default_factory, validate_default=True)
+        if parameter is Body
+        else parameter(default_factory=default_factory, validate_default=True)
+    )
+
+    @app.post("/")
+    def read_parameter(value: Annotated[ValidatedInt, field]):
+        return value
+
+    default_factory.assert_not_called()
+    client = TestClient(app)
+    if parameter is Body:
+        response = client.post("/", json={})
+    else:
+        response = client.post("/")
+    assert response.status_code == 200
+    assert response.json() == expected
+    default_factory.assert_called_once_with()
+
+
+def test_parameter_rejects_invalid_default():
+    app = FastAPI()
+
+    @app.get("/")
+    def read_parameter(value: Annotated[int, Query(gt=0, validate_default=True)] = -1):
+        return value
+
+    client = TestClient(app)
+    response = client.get("/")
+    assert response.status_code == 422
+    assert response.json() == {
+        "detail": [
+            {
+                "type": "greater_than",
+                "loc": ["query", "value"],
+                "msg": "Input should be greater than 0",
+                "input": -1,
+                "ctx": {"gt": 0},
+            }
+        ]
+    }
+    response = client.get("/", params={"value": "1"})
+    assert response.status_code == 200
+    assert response.json() == 1