fastapi 0.156.1__tar.gz → 0.156.2__tar.gz

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

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

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

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

@@ -504,6 +504,17 @@ def analyze_param(
             field_info = params.Body(annotation=use_annotation, default=default_value)
         else:
             field_info = params.Query(annotation=use_annotation, default=default_value)
+        if get_origin(use_annotation) is Annotated:
+            inferred_default = field_info.default
+            field_info = copy_field_info(
+                field_info=field_info,
+                annotation=use_annotation,
+            )
+            field_info.default = inferred_default
+            if is_path_param:
+                # A default factory can apply when this endpoint is used without the
+                # path parameter, but path parameters must always be required.
+                field_info.default_factory = None
 
     field = None
     # It's a field_info, not a dependency

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

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

{fastapi-0.156.1 → fastapi-0.156.2}/tests/test_request_params/test_default_validation.py

@@ -247,6 +247,66 @@ def test_parameter_preserves_pydantic_validate_default(field, expected):
     assert response.json() == expected
 
 
+def test_inferred_parameter_preserves_pydantic_default_factory():
+    app = FastAPI()
+    default_factory = Mock(return_value=5)
+
+    @app.get("/")
+    def read_parameter(value: Annotated[int, Field(default_factory=default_factory)]):
+        return value
+
+    default_factory.assert_not_called()
+    client = TestClient(app)
+    response = client.get("/")
+    assert response.status_code == 200
+    assert response.json() == 5
+    default_factory.assert_called_once_with()
+
+    response = client.get("/", params={"value": "10"})
+    assert response.status_code == 200
+    assert response.json() == 10
+    default_factory.assert_called_once_with()
+
+
+def test_inferred_parameters_validate_defaults():
+    app = FastAPI()
+
+    @app.post("/")
+    def read_parameters(
+        values: Annotated[
+            list[int], Field(default_factory=list, min_length=1, validate_default=True)
+        ],
+        count: Annotated[int, Field(gt=0, validate_default=True)] = -1,
+    ):
+        return {"count": count, "values": values}
+
+    client = TestClient(app)
+    response = client.post("/")
+    assert response.status_code == 422
+    assert response.json() == {
+        "detail": [
+            {
+                "type": "greater_than",
+                "loc": ["query", "count"],
+                "msg": "Input should be greater than 0",
+                "input": -1,
+                "ctx": {"gt": 0},
+            },
+            {
+                "type": "too_short",
+                "loc": ["body"],
+                "msg": "List should have at least 1 item after validation, not 0",
+                "input": [],
+                "ctx": {"field_type": "List", "min_length": 1, "actual_length": 0},
+            },
+        ]
+    }
+
+    response = client.post("/", params={"count": "2"}, json=[1, 2])
+    assert response.status_code == 200
+    assert response.json() == {"count": 2, "values": [1, 2]}
+
+
 def test_parameter_rejects_invalid_default():
     app = FastAPI()
 

{fastapi-0.156.1 → fastapi-0.156.2}/tests/test_request_params/test_field_metadata.py

@@ -2,7 +2,7 @@ from typing import Annotated, Literal
 
 import pytest
 from dirty_equals import IsOneOf
-from fastapi import Body, Cookie, FastAPI, File, Form, Header, Path, Query
+from fastapi import Body, Cookie, FastAPI, File, Form, Header, Path, Query, UploadFile
 from fastapi.testclient import TestClient
 from inline_snapshot import snapshot
 from pydantic import BaseModel, Field
@@ -51,6 +51,37 @@ def test_file_field_alias_is_preserved():
     assert response.json() == "hello"
 
 
+def test_inferred_body_aliases_are_preserved():
+    app = FastAPI()
+
+    @app.post("/")
+    def read_values(
+        first: Annotated[list[int], Field(alias="numbers")],
+        second: Annotated[
+            list[int], Field(alias="unused", validation_alias="more_numbers")
+        ],
+    ):
+        return {"first": first, "second": second}
+
+    client = TestClient(app)
+    response = client.post("/", json={"numbers": [1], "more_numbers": [2]})
+    assert response.status_code == 200
+    assert response.json() == {"first": [1], "second": [2]}
+
+
+def test_inferred_file_alias_is_preserved():
+    app = FastAPI()
+
+    @app.post("/")
+    async def read_file(value: Annotated[UploadFile, Field(alias="upload")]):
+        return await value.read()
+
+    client = TestClient(app)
+    response = client.post("/", files={"upload": ("example.txt", b"hello")})
+    assert response.status_code == 200
+    assert response.json() == "hello"
+
+
 def test_field_discriminator_is_preserved():
     class Cat(BaseModel):
         kind: Literal["cat"]
@@ -161,6 +192,22 @@ def read_body(
     return {"preserved": preserved, "replaced": replaced, "cleared": cleared}
 
 
+@app.get("/inferred")
+@app.get("/inferred/{item_id}")
+def read_inferred(
+    item_id: Annotated[
+        int,
+        Field(
+            default_factory=lambda: 5, title="Item ID", description="The item to read"
+        ),
+    ],
+    count: Annotated[
+        int, Field(alias="n", title="Count", description="Number of items")
+    ] = 10,
+):
+    return {"item_id": item_id, "count": count}
+
+
 client = TestClient(app)
 
 
@@ -180,6 +227,20 @@ def test_body_alias_overrides():
     assert response.json() == {"preserved": 1, "replaced": 2, "cleared": 3}
 
 
+def test_inferred_query_alias_is_preserved():
+    response = client.get("/inferred/1", params={"n": "2"})
+    assert response.status_code == 200
+    assert response.json() == {"item_id": 1, "count": 2}
+
+    response = client.get("/inferred/1")
+    assert response.status_code == 200
+    assert response.json() == {"item_id": 1, "count": 10}
+
+    response = client.get("/inferred")
+    assert response.status_code == 200
+    assert response.json() == {"item_id": 5, "count": 10}
+
+
 def test_openapi_schema():
     response = client.get("/openapi.json")
     assert response.status_code == 200
@@ -291,6 +352,100 @@ def test_openapi_schema():
                         },
                     }
                 },
+                "/inferred/{item_id}": {
+                    "get": {
+                        "summary": "Read Inferred",
+                        "operationId": "read_inferred_inferred__item_id__get",
+                        "parameters": [
+                            {
+                                "name": "item_id",
+                                "in": "path",
+                                "required": True,
+                                "schema": {
+                                    "type": "integer",
+                                    "title": "Item ID",
+                                    "description": "The item to read",
+                                },
+                                "description": "The item to read",
+                            },
+                            {
+                                "name": "n",
+                                "in": "query",
+                                "required": False,
+                                "schema": {
+                                    "type": "integer",
+                                    "title": "Count",
+                                    "description": "Number of items",
+                                    "default": 10,
+                                },
+                                "description": "Number of items",
+                            },
+                        ],
+                        "responses": {
+                            "200": {
+                                "description": "Successful Response",
+                                "content": {"application/json": {"schema": {}}},
+                            },
+                            "422": {
+                                "description": "Validation Error",
+                                "content": {
+                                    "application/json": {
+                                        "schema": {
+                                            "$ref": "#/components/schemas/HTTPValidationError"
+                                        }
+                                    }
+                                },
+                            },
+                        },
+                    }
+                },
+                "/inferred": {
+                    "get": {
+                        "summary": "Read Inferred",
+                        "operationId": "read_inferred_inferred_get",
+                        "parameters": [
+                            {
+                                "name": "item_id",
+                                "in": "query",
+                                "required": False,
+                                "schema": {
+                                    "type": "integer",
+                                    "title": "Item ID",
+                                    "description": "The item to read",
+                                },
+                                "description": "The item to read",
+                            },
+                            {
+                                "name": "n",
+                                "in": "query",
+                                "required": False,
+                                "schema": {
+                                    "type": "integer",
+                                    "title": "Count",
+                                    "description": "Number of items",
+                                    "default": 10,
+                                },
+                                "description": "Number of items",
+                            },
+                        ],
+                        "responses": {
+                            "200": {
+                                "description": "Successful Response",
+                                "content": {"application/json": {"schema": {}}},
+                            },
+                            "422": {
+                                "description": "Validation Error",
+                                "content": {
+                                    "application/json": {
+                                        "schema": {
+                                            "$ref": "#/components/schemas/HTTPValidationError"
+                                        }
+                                    }
+                                },
+                            },
+                        },
+                    }
+                },
             },
             "components": {
                 "schemas": {

{fastapi-0.156.1 → fastapi-0.156.2}/tests/test_union_body_discriminator.py

@@ -61,6 +61,7 @@ def test_discriminator_pydantic_v2() -> None:
                                     "description": "Query string",
                                     "title": "Q",
                                 },
+                                "description": "Query string",
                             }
                         ],
                         "requestBody": {