fastapi_14246

{"status": "ok", "stdout": "./docs/de/docs/how-to/migrate-from-pydantic-v1-to-pydantic-v2.md:19:Wenn Sie eine \u00e4ltere FastAPI-App mit Pydantic v1 haben, zeige ich Ihnen hier, wie Sie sie zu Pydantic v2 migrieren, und die **neuen Features in FastAPI 0.119.0**, die Ihnen bei einer schrittweisen Migration helfen.\n./docs/de/docs/how-to/migrate-from-pydantic-v1-to-pydantic-v2.md:55:Seit FastAPI 0.119.0 gibt es au\u00dferdem eine teilweise Unterst\u00fctzung f\u00fcr Pydantic v1 innerhalb von Pydantic v2, um die Migration auf v2 zu erleichtern.\n./docs/en/docs/release-notes.md:61:## 0.119.0\n./docs/en/docs/how-to/migrate-from-pydantic-v1-to-pydantic-v2.md:19:If you have an old FastAPI app with Pydantic v1, here I'll show you how to migrate it to Pydantic v2, and the **new features in FastAPI 0.119.0** to help you with a gradual migration.\n./docs/en/docs/how-to/migrate-from-pydantic-v1-to-pydantic-v2.md:55:Since FastAPI 0.119.0, there's also partial support for Pydantic v1 from inside of Pydantic v2, to facilitate the migration to v2.\n", "stderr": "", "exit_code": 0}

{"status": "error", "error_type": "CommandError", "error_message": "", "details": {"stdout": "", "stderr": "", "exit_code": 1}}

{"status": "ok", "stdout": "", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/routing.py\nfastapi/_compat/v1.py\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "204:    original_context: Lifespan[Any], nested_context: Lifespan[Any]\n211:            async with nested_context(app) as maybe_nested_state:\n212:                if maybe_nested_state is None and maybe_original_state is None:\n215:                    yield {**(maybe_nested_state or {}), **(maybe_original_state or {})}\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/params.py:36:        # TODO: update when deprecating Pydantic v1, import these types\nfastapi/params.py:150:        # TODO: update when deprecating Pydantic v1, import these types\nfastapi/params.py:236:        # TODO: update when deprecating Pydantic v1, import these types\nfastapi/params.py:320:        # TODO: update when deprecating Pydantic v1, import these types\nfastapi/params.py:406:        # TODO: update when deprecating Pydantic v1, import these types\nfastapi/params.py:490:        # TODO: update when deprecating Pydantic v1, import these types\nfastapi/params.py:606:        # TODO: update when deprecating Pydantic v1, import these types\nfastapi/params.py:690:        # TODO: update when deprecating Pydantic v1, import these types\nfastapi/dependencies/utils.py:541:                    # For Pydantic v1\nfastapi/encoders.py:32:# Taken from Pydantic v1 as is\nfastapi/encoders.py:37:# Taken from Pydantic v1 as is\nfastapi/encoders.py:225:        # TODO: remove when deprecating Pydantic v1\nfastapi/encoders.py:247:            # TODO: remove when deprecating Pydantic v1\nfastapi/openapi/models.py:153:    # TODO: uncomment and remove below when deprecating Pydantic v1\nfastapi/utils.py:125:    # Pydantic v2 is not installed, but it's not a Pydantic v1 ModelField, it could be\nfastapi/utils.py:126:    # a Pydantic v1 type, like a constrained int\nfastapi/routing.py:602:            # TODO: remove when deprecating Pydantic v1\nfastapi/temp_pydantic_v1_params.py:25:        # TODO: update when deprecating Pydantic v1, import these types\nfastapi/temp_pydantic_v1_params.py:126:        # TODO: update when deprecating Pydantic v1, import these types\nfastapi/temp_pydantic_v1_params.py:212:        # TODO: update when deprecating Pydantic v1, import these types\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "temp_pydantic_v1_params.py\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "__init__.py\n__main__.py\n_compat/\napplications.py\nbackground.py\ncli.py\nconcurrency.py\ndatastructures.py\ndependencies/\nencoders.py\nexception_handlers.py\nexceptions.py\nlogger.py\nmiddleware/\nopenapi/\nparam_functions.py\nparams.py\npy.typed\nrequests.py\nresponses.py\nrouting.py\nsecurity/\nstaticfiles.py\ntemp_pydantic_v1_params.py\ntemplating.py\ntestclient.py\ntypes.py\nutils.py\nwebsockets.py\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/temp_pydantic_v1_params.py:25:        # TODO: update when deprecating Pydantic v1, import these types\nfastapi/temp_pydantic_v1_params.py:126:        # TODO: update when deprecating Pydantic v1, import these types\nfastapi/temp_pydantic_v1_params.py:212:        # TODO: update when deprecating Pydantic v1, import these types\nfastapi/temp_pydantic_v1_params.py:296:        # TODO: update when deprecating Pydantic v1, import these types\nfastapi/temp_pydantic_v1_params.py:382:        # TODO: update when deprecating Pydantic v1, import these types\nfastapi/temp_pydantic_v1_params.py:466:        # TODO: update when deprecating Pydantic v1, import these types\nfastapi/temp_pydantic_v1_params.py:569:        # TODO: update when deprecating Pydantic v1, import these types\nfastapi/temp_pydantic_v1_params.py:653:        # TODO: update when deprecating Pydantic v1, import these types\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "import warnings\nfrom typing import Any, Callable, Dict, List, Optional, Union\n\nfrom fastapi.openapi.models import Example\nfrom fastapi.params import ParamTypes\nfrom typing_extensions import Annotated, deprecated\n\nfrom ._compat.may_v1 import FieldInfo, Undefined\nfrom ._compat.shared import PYDANTIC_VERSION_MINOR_TUPLE\n\n_Unset: Any = Undefined\n\n\nclass Param(FieldInfo):  # type: ignore[misc]\n    in_: ParamTypes\n\n    def __init__(\n        self,\n        default: Any = Undefined,\n        *,\n        default_factory: Union[Callable[[], Any], None] = _Unset,\n        annotation: Optional[Any] = None,\n        alias: Optional[str] = None,\n        alias_priority: Union[int, None] = _Unset,\n        # TODO: update when deprecating Pydantic v1, import these types\n        # validation_alias: str | AliasPath | AliasChoices | None\n        validation_alias: Union[str, None] = None,\n        serialization_alias: Union[str, None] = None,\n        title: Optional[str] = None,\n        description: Optional[str] = None,\n        gt: Optional[float] = None,\n        ge: Optional[float] = None,\n        lt: Optional[float] = None,\n        le: Optional[float] = None,\n        min_length: Optional[int] = None,\n        max_length: Optional[int] = None,\n        pattern: Optional[str] = None,\n        regex: Annotated[\n            Optional[str],\n            deprecated(\n                \"Deprecated in FastAPI 0.100.0 and Pydantic v2, use `pattern` instead.\"\n            ),\n        ] = None,\n        discriminator: Union[str, None] = None,\n        strict: Union[bool, None] = _Unset,\n        multiple_of: Union[float, None] = _Unset,\n        allow_inf_nan: Union[bool, None] = _Unset,\n        max_digits: Union[int, None] = _Unset,\n        decimal_places: Union[int, None] = _Unset,\n        examples: Optional[List[Any]] = None,\n        example: Annotated[\n            Optional[Any],\n            deprecated(\n                \"Deprecate

{"status": "error", "error_type": "CommandError", "error_message": "", "details": {"stdout": "", "stderr": "", "exit_code": 1}}

{"status": "ok", "stdout": "docs/en/docs/release-notes.md:61:## 0.119.0\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "## 0.119.0\n\nFastAPI now (temporarily) supports both Pydantic v2 models and `pydantic.v1` models at the same time in the same app, to make it easier for any FastAPI apps still using Pydantic v1 to gradually but quickly **migrate to Pydantic v2**.\n\n```Python\nfrom fastapi import FastAPI\nfrom pydantic import BaseModel as BaseModelV2\nfrom pydantic.v1 import BaseModel\n\n\nclass Item(BaseModel):\n    name: str\n    description: str | None = None\n\n\nclass ItemV2(BaseModelV2):\n    title: str\n    summary: str | None = None\n\n\napp = FastAPI()\n\n\n@app.post(\"/items/\", response_model=ItemV2)\ndef create_item(item: Item):\n    return {\"title\": item.name, \"summary\": item.description}\n```\n\nAdding this feature was a big effort with the main objective of making it easier for the few applications still stuck in Pydantic v1 to migrate to Pydantic v2.\n\nAnd with this, support for **Pydantic v1 is now deprecated** and will be **removed** from FastAPI in a future version soon.\n\n**Note**: have in mind that the Pydantic team already stopped supporting Pydantic v1 for recent versions of Python, starting with Python 3.14.\n\nYou can read in the docs more about how to [Migrate from Pydantic v1 to Pydantic v2](https://fastapi.tiangolo.com/how-to/migrate-from-pydantic-v1-to-pydantic-v2/).\n\n### Features\n\n* \u2728 Add support for `from pydantic.v1 import BaseModel`, mixed Pydantic v1 and v2 models in the same app. PR [#14168](https://github.com/fastapi/fastapi/pull/14168) by [@tiangolo](https://github.com/tiangolo).\n\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/dependencies/utils.py:51:from fastapi._compat.shared import annotation_is_pydantic_v1\nfastapi/dependencies/utils.py:79:from .. import temp_pydantic_v1_params\nfastapi/dependencies/utils.py:323:            param_details.field.field_info, (params.Body, temp_pydantic_v1_params.Body)\nfastapi/dependencies/utils.py:392:                    temp_pydantic_v1_params.Param,\nfastapi/dependencies/utils.py:394:                    temp_pydantic_v1_params.Body,\nfastapi/dependencies/utils.py:483:            if annotation_is_pydantic_v1(use_annotation):\nfastapi/dependencies/utils.py:484:                field_info = temp_pydantic_v1_params.Body(\nfastapi/dependencies/utils.py:500:                field_info, (params.Path, temp_pydantic_v1_params.Path)\nfastapi/dependencies/utils.py:506:            isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param))\nfastapi/dependencies/utils.py:515:        if isinstance(field_info, (params.Form, temp_pydantic_v1_params.Form)):\nfastapi/dependencies/utils.py:535:        elif isinstance(field_info, (params.Query, temp_pydantic_v1_params.Query)):\nfastapi/dependencies/utils.py:762:            isinstance(field.field_info, (params.Form, temp_pydantic_v1_params.Form))\nfastapi/dependencies/utils.py:828:        assert isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param)), (\nfastapi/dependencies/utils.py:840:        assert isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param)), (\nfastapi/dependencies/utils.py:889:        isinstance(first_field.field_info, (params.Form, temp_pydantic_v1_params.Form))\nfastapi/dependencies/utils.py:907:            isinstance(field_info, (params.File, temp_pydantic_v1_params.File))\nfastapi/dependencies/utils.py:914:            and isinstance(field_info, (params.File, temp_pydantic_v1_params.File))\nfastapi/dependencies/utils.py:1021:        isinstance(f.field_info, temp_pydantic_v1_params.File)\nfastapi/dependencies/utils.py:1024:       

{"status": "ok", "stdout": "fastapi/dependencies/utils.py:51:from fastapi._compat.shared import annotation_is_pydantic_v1\nfastapi/dependencies/utils.py:483:            if annotation_is_pydantic_v1(use_annotation):\nfastapi/dependencies/utils.py:1033:        if annotation_is_pydantic_v1(BodyModel):\nfastapi/utils.py:26:    annotation_is_pydantic_v1,\nfastapi/utils.py:104:        annotation_is_pydantic_v1(type_)\nfastapi/_compat/__init__.py:40:from .shared import annotation_is_pydantic_v1 as annotation_is_pydantic_v1\nfastapi/_compat/shared.py:199:def annotation_is_pydantic_v1(annotation: Any) -> bool:\nfastapi/_compat/shared.py:209:            if annotation_is_pydantic_v1(sub_annotation):\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "import sys\nimport types\nimport typing\nfrom collections import deque\nfrom dataclasses import is_dataclass\nfrom typing import (\n    Any,\n    Deque,\n    FrozenSet,\n    List,\n    Mapping,\n    Sequence,\n    Set,\n    Tuple,\n    Type,\n    Union,\n)\n\nfrom fastapi._compat import may_v1\nfrom fastapi.types import UnionType\nfrom pydantic import BaseModel\nfrom pydantic.version import VERSION as PYDANTIC_VERSION\nfrom starlette.datastructures import UploadFile\nfrom typing_extensions import Annotated, get_args, get_origin\n\n# Copy from Pydantic v2, compatible with v1\nif sys.version_info < (3, 9):\n    # Pydantic no longer supports Python 3.8, this might be incorrect, but the code\n    # this is used for is also never reached in this codebase, as it's a copy of\n    # Pydantic's lenient_issubclass, just for compatibility with v1\n    # TODO: remove when dropping support for Python 3.8\n    WithArgsTypes: Tuple[Any, ...] = ()\nelif sys.version_info < (3, 10):\n    WithArgsTypes: tuple[Any, ...] = (typing._GenericAlias, types.GenericAlias)  # type: ignore[attr-defined]\nelse:\n    WithArgsTypes: tuple[Any, ...] = (\n        typing._GenericAlias,  # type: ignore[attr-defined]\n        types.GenericAlias,\n        types.UnionType,\n    )  # pyright: ignore[reportAttributeAccessIssue]\n\nPYDANTIC_VERSION_MINOR_TUPLE = tuple(int(x) for x in PYDANTIC_VERSION.split(\".\")[:2])\nPYDANTIC_V2 = PYDANTIC_VERSION_MINOR_TUPLE[0] == 2\n\n\nsequence_annotation_to_type = {\n    Sequence: list,\n    List: list,\n    list: list,\n    Tuple: tuple,\n    tuple: tuple,\n    Set: set,\n    set: set,\n    FrozenSet: frozenset,\n    frozenset: frozenset,\n    Deque: deque,\n    deque: deque,\n}\n\nsequence_types = tuple(sequence_annotation_to_type.keys())\n\nUrl: Type[Any]\n\n\n# Copy of Pydantic v2, compatible with v1\ndef lenient_issubclass(\n    cls: Any, class_or_tuple: Union[Type[Any], Tuple[Type[Any], ...], None]\n) -> bool:\n    try:\n        return

{"status": "ok", "stdout": "def annotation_is_pydantic_v1(annotation: Any) -> bool:\n    if lenient_issubclass(annotation, may_v1.BaseModel):\n        return True\n    origin = get_origin(annotation)\n    if origin is Union or origin is UnionType:\n        for arg in get_args(annotation):\n            if lenient_issubclass(arg, may_v1.BaseModel):\n                return True\n    if field_annotation_is_sequence(annotation):\n        for sub_annotation in get_args(annotation):\n            if annotation_is_pydantic_v1(sub_annotation):\n                return True\n    return False\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/dependencies/utils.py:51:from fastapi._compat.shared import annotation_is_pydantic_v1\nfastapi/dependencies/utils.py:483:            if annotation_is_pydantic_v1(use_annotation):\nfastapi/dependencies/utils.py:1033:        if annotation_is_pydantic_v1(BodyModel):\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    # Handle default assignations, neither field_info nor depends was not found in Annotated nor default value\n    elif field_info is None and depends is None:\n        default_value = value if value is not inspect.Signature.empty else RequiredParam\n        if is_path_param:\n            # We might check here that `default_value is RequiredParam`, but the fact is that the same\n            # parameter might sometimes be a path parameter and sometimes not. See\n            # `tests/test_infer_param_optionality.py` for an example.\n            field_info = params.Path(annotation=use_annotation)\n        elif is_uploadfile_or_nonable_uploadfile_annotation(\n            type_annotation\n        ) or is_uploadfile_sequence_annotation(type_annotation):\n            field_info = params.File(annotation=use_annotation, default=default_value)\n        elif not field_annotation_is_scalar(annotation=type_annotation):\n            if annotation_is_pydantic_v1(use_annotation):\n                field_info = temp_pydantic_v1_params.Body(\n                    annotation=use_annotation, default=default_value\n                )\n            else:\n                field_info = params.Body(\n                    annotation=use_annotation, default=default_value\n                )\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    elif any(\n        isinstance(f.field_info, temp_pydantic_v1_params.File)\n        for f in flat_dependant.body_params\n    ):\n        BodyFieldInfo: Type[temp_pydantic_v1_params.Body] = temp_pydantic_v1_params.File  # type: ignore[no-redef]\n    elif any(isinstance(f.field_info, params.Form) for f in flat_dependant.body_params):\n        BodyFieldInfo = params.Form\n    elif any(\n        isinstance(f.field_info, temp_pydantic_v1_params.Form)\n        for f in flat_dependant.body_params\n    ):\n        BodyFieldInfo = temp_pydantic_v1_params.Form  # type: ignore[assignment]\n    else:\n        if annotation_is_pydantic_v1(BodyModel):\n            BodyFieldInfo = temp_pydantic_v1_params.Body  # type: ignore[assignment]\n        else:\n            BodyFieldInfo = params.Body\n\n        body_param_media_types = [\n            f.field_info.media_type\n            for f in flat_dependant.body_params\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "import sys\nfrom typing import Any, Dict, List, Literal, Sequence, Tuple, Type, Union\n\nfrom fastapi.types import ModelNameMap\n\nif sys.version_info >= (3, 14):\n\n    class AnyUrl:\n        pass\n\n    class BaseConfig:\n        pass\n\n    class BaseModel:\n        pass\n\n    class Color:\n        pass\n\n    class CoreSchema:\n        pass\n\n    class ErrorWrapper:\n        pass\n\n    class FieldInfo:\n        pass\n\n    class GetJsonSchemaHandler:\n        pass\n\n    class JsonSchemaValue:\n        pass\n\n    class ModelField:\n        pass\n\n    class NameEmail:\n        pass\n\n    class RequiredParam:\n        pass\n\n    class SecretBytes:\n        pass\n\n    class SecretStr:\n        pass\n\n    class Undefined:\n        pass\n\n    class UndefinedType:\n        pass\n\n    class Url:\n        pass\n\n    from .v2 import ValidationError, create_model\n\n    def get_definitions(\n        *,\n        fields: List[ModelField],\n        model_name_map: ModelNameMap,\n        separate_input_output_schemas: bool = True,\n    ) -> Tuple[\n        Dict[\n            Tuple[ModelField, Literal[\"validation\", \"serialization\"]], JsonSchemaValue\n        ],\n        Dict[str, Dict[str, Any]],\n    ]:\n        return {}, {}  # pragma: no cover\n\n\nelse:\n    from .v1 import AnyUrl as AnyUrl\n    from .v1 import BaseConfig as BaseConfig\n    from .v1 import BaseModel as BaseModel\n    from .v1 import Color as Color\n    from .v1 import CoreSchema as CoreSchema\n    from .v1 import ErrorWrapper as ErrorWrapper\n    from .v1 import FieldInfo as FieldInfo\n    from .v1 import GetJsonSchemaHandler as GetJsonSchemaHandler\n    from .v1 import JsonSchemaValue as JsonSchemaValue\n    from .v1 import ModelField as ModelField\n    from .v1 import NameEmail as NameEmail\n    from .v1 import RequiredParam as RequiredParam\n    from .v1 import SecretBytes as SecretBytes\n    from .v1 import SecretStr as SecretStr\n    from .v1 import Undefine

{"status": "ok", "stdout": "from copy import copy\nfrom dataclasses import dataclass, is_dataclass\nfrom enum import Enum\nfrom typing import (\n    Any,\n    Callable,\n    Dict,\n    List,\n    Sequence,\n    Set,\n    Tuple,\n    Type,\n    Union,\n)\n\nfrom fastapi._compat import shared\nfrom fastapi.openapi.constants import REF_PREFIX as REF_PREFIX\nfrom fastapi.types import ModelNameMap\nfrom pydantic.version import VERSION as PYDANTIC_VERSION\nfrom typing_extensions import Literal\n\nPYDANTIC_VERSION_MINOR_TUPLE = tuple(int(x) for x in PYDANTIC_VERSION.split(\".\")[:2])\nPYDANTIC_V2 = PYDANTIC_VERSION_MINOR_TUPLE[0] == 2\n# Keeping old \"Required\" functionality from Pydantic V1, without\n# shadowing typing.Required.\nRequiredParam: Any = Ellipsis\n\nif not PYDANTIC_V2:\n    from pydantic import BaseConfig as BaseConfig\n    from pydantic import BaseModel as BaseModel\n    from pydantic import ValidationError as ValidationError\n    from pydantic import create_model as create_model\n    from pydantic.class_validators import Validator as Validator\n    from pydantic.color import Color as Color\n    from pydantic.error_wrappers import ErrorWrapper as ErrorWrapper\n    from pydantic.errors import MissingError\n    from pydantic.fields import (  # type: ignore[attr-defined]\n        SHAPE_FROZENSET,\n        SHAPE_LIST,\n        SHAPE_SEQUENCE,\n        SHAPE_SET,\n        SHAPE_SINGLETON,\n        SHAPE_TUPLE,\n        SHAPE_TUPLE_ELLIPSIS,\n    )\n    from pydantic.fields import FieldInfo as FieldInfo\n    from pydantic.fields import ModelField as ModelField  # type: ignore[attr-defined]\n    from pydantic.fields import Undefined as Undefined  # type: ignore[attr-defined]\n    from pydantic.fields import (  # type: ignore[attr-defined]\n        UndefinedType as UndefinedType,\n    )\n    from pydantic.networks import AnyUrl as AnyUrl\n    from pydantic.networks import NameEmail as NameEmail\n    from pydantic.schema import TypeModelSet as TypeModelSet\n    from

{"status": "ok", "stdout": "    )\n    from pydantic.v1.schema import TypeModelSet as TypeModelSet\n    from pydantic.v1.schema import (\n        field_schema,\n        model_process_schema,\n    )\n    from pydantic.v1.schema import (\n        get_annotation_from_field_info as get_annotation_from_field_info,\n    )\n    from pydantic.v1.schema import (\n        get_flat_models_from_field as get_flat_models_from_field,\n    )\n    from pydantic.v1.schema import (\n        get_flat_models_from_fields as get_flat_models_from_fields,\n    )\n    from pydantic.v1.schema import get_model_name_map as get_model_name_map\n    from pydantic.v1.types import (  # type: ignore[assignment]\n        SecretBytes as SecretBytes,\n    )\n    from pydantic.v1.types import (  # type: ignore[assignment]\n        SecretStr as SecretStr,\n    )\n    from pydantic.v1.typing import evaluate_forwardref as evaluate_forwardref\n    from pydantic.v1.utils import lenient_issubclass as lenient_issubclass\n\n\nGetJsonSchemaHandler = Any\nJsonSchemaValue = Dict[str, Any]\nCoreSchema = Any\nUrl = AnyUrl\n\nsequence_shapes = {\n    SHAPE_LIST,\n    SHAPE_SET,\n    SHAPE_FROZENSET,\n    SHAPE_TUPLE,\n    SHAPE_SEQUENCE,\n    SHAPE_TUPLE_ELLIPSIS,\n}\nsequence_shape_to_type = {\n    SHAPE_LIST: list,\n    SHAPE_SET: set,\n    SHAPE_TUPLE: tuple,\n    SHAPE_SEQUENCE: list,\n    SHAPE_TUPLE_ELLIPSIS: list,\n}\n\n\n@dataclass\nclass GenerateJsonSchema:\n    ref_template: str\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/_compat/v1.py:255:def get_definitions(\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "def get_definitions(\n    *,\n    fields: List[ModelField],\n    model_name_map: ModelNameMap,\n    separate_input_output_schemas: bool = True,\n) -> Tuple[\n    Dict[Tuple[ModelField, Literal[\"validation\", \"serialization\"]], JsonSchemaValue],\n    Dict[str, Dict[str, Any]],\n]:\n    models = get_flat_models_from_fields(fields, known_models=set())\n    return {}, get_model_definitions(flat_models=models, model_name_map=model_name_map)\n\n\ndef is_scalar_field(field: ModelField) -> bool:\n    return is_pv1_scalar_field(field)\n\n\ndef is_sequence_field(field: ModelField) -> bool:\n    return field.shape in sequence_shapes or shared._annotation_is_sequence(field.type_)\n\n\ndef is_scalar_sequence_field(field: ModelField) -> bool:\n    return is_pv1_scalar_sequence_field(field)\n\n\ndef is_bytes_field(field: ModelField) -> bool:\n    return lenient_issubclass(field.type_, bytes)  # type: ignore[no-any-return]\n\n\ndef is_bytes_sequence_field(field: ModelField) -> bool:\n    return field.shape in sequence_shapes and lenient_issubclass(field.type_, bytes)\n\n\ndef copy_field_info(*, field_info: FieldInfo, annotation: Any) -> FieldInfo:\n    return copy(field_info)\n\n\ndef serialize_sequence_value(*, field: ModelField, value: Any) -> Sequence[Any]:\n    return sequence_shape_to_type[field.shape](value)  # type: ignore[no-any-return]\n\n\ndef get_missing_field_error(loc: Tuple[str, ...]) -> Dict[str, Any]:\n    missing_field_error = ErrorWrapper(MissingError(), loc=loc)\n    new_error = ValidationError([missing_field_error], RequestErrorModel)\n    return new_error.errors()[0]  # type: ignore[return-value]\n\n\ndef create_body_model(\n    *, fields: Sequence[ModelField], model_name: str\n) -> Type[BaseModel]:\n    BodyModel = create_model(model_name)\n    for f in fields:\n        BodyModel.__fields__[f.name] = f  # type: ignore[index]\n    return BodyModel\n\n\ndef get_model_fields(model: Type[BaseModel]) -> List[ModelField]:\n    return l

{"status": "ok", "stdout": "fastapi/_compat/v1.py:170:def get_model_definitions(\nfastapi/_compat/v1.py:265:    return {}, get_model_definitions(flat_models=models, model_name_map=model_name_map)\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "def get_model_definitions(\n    *,\n    flat_models: Set[Union[Type[BaseModel], Type[Enum]]],\n    model_name_map: Dict[Union[Type[BaseModel], Type[Enum]], str],\n) -> Dict[str, Any]:\n    definitions: Dict[str, Dict[str, Any]] = {}\n    for model in flat_models:\n        m_schema, m_definitions, m_nested_models = model_process_schema(\n            model, model_name_map=model_name_map, ref_prefix=REF_PREFIX\n        )\n        definitions.update(m_definitions)\n        model_name = model_name_map[model]\n        definitions[model_name] = m_schema\n    for m_schema in definitions.values():\n        if \"description\" in m_schema:\n            m_schema[\"description\"] = m_schema[\"description\"].split(\"\\f\")[0]\n    return definitions\n\n\ndef is_pv1_scalar_field(field: ModelField) -> bool:\n    from fastapi import params\n\n    field_info = field.field_info\n    if not (\n        field.shape == SHAPE_SINGLETON\n        and not lenient_issubclass(field.type_, BaseModel)\n        and not lenient_issubclass(field.type_, dict)\n        and not shared.field_annotation_is_sequence(field.type_)\n        and not is_dataclass(field.type_)\n        and not isinstance(field_info, params.Body)\n    ):\n        return False\n    if field.sub_fields:\n        if not all(is_pv1_scalar_field(f) for f in field.sub_fields):\n            return False\n    return True\n\n\ndef is_pv1_scalar_sequence_field(field: ModelField) -> bool:\n    if (field.shape in sequence_shapes) and not lenient_issubclass(\n        field.type_, BaseModel\n    ):\n        if field.sub_fields is not None:\n            for sub_field in field.sub_fields:\n                if not is_pv1_scalar_field(sub_field):\n                    return False\n        return True\n    if shared._annotation_is_sequence(field.type_):\n        return True\n    return False\n\n\ndef _model_rebuild(model: Type[BaseModel]) -> None:\n    model.update_forward_refs()\n\n\ndef _model_dump(\n    model: BaseMod

{"status": "ok", "stdout": "fastapi/openapi/utils.py:12:    get_definitions,\nfastapi/openapi/utils.py:504:    field_mapping, definitions = get_definitions(\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    webhook_paths: Dict[str, Dict[str, Any]] = {}\n    operation_ids: Set[str] = set()\n    all_fields = get_fields_from_routes(list(routes or []) + list(webhooks or []))\n    model_name_map = get_compat_model_name_map(all_fields)\n    field_mapping, definitions = get_definitions(\n        fields=all_fields,\n        model_name_map=model_name_map,\n        separate_input_output_schemas=separate_input_output_schemas,\n    )\n    for route in routes or []:\n        if isinstance(route, routing.APIRoute):\n            result = get_openapi_path(\n                route=route,\n                operation_ids=operation_ids,\n                model_name_map=model_name_map,\n                field_mapping=field_mapping,\n                separate_input_output_schemas=separate_input_output_schemas,\n            )\n            if result:\n                path, security_schemes, path_definitions = result\n                if path:\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "import http.client\nimport inspect\nimport warnings\nfrom typing import Any, Dict, List, Optional, Sequence, Set, Tuple, Type, Union, cast\n\nfrom fastapi import routing\nfrom fastapi._compat import (\n    JsonSchemaValue,\n    ModelField,\n    Undefined,\n    get_compat_model_name_map,\n    get_definitions,\n    get_schema_from_model_field,\n    lenient_issubclass,\n)\nfrom fastapi.datastructures import DefaultPlaceholder\nfrom fastapi.dependencies.models import Dependant\nfrom fastapi.dependencies.utils import (\n    _get_flat_fields_from_params,\n    get_flat_dependant,\n    get_flat_params,\n)\nfrom fastapi.encoders import jsonable_encoder\nfrom fastapi.openapi.constants import METHODS_WITH_BODY, REF_PREFIX\nfrom fastapi.openapi.models import OpenAPI\nfrom fastapi.params import Body, ParamTypes\nfrom fastapi.responses import Response\nfrom fastapi.types import ModelNameMap\nfrom fastapi.utils import (\n    deep_dict_update,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/_compat/__init__.py:21:from .main import get_definitions as get_definitions\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "import sys\nfrom functools import lru_cache\nfrom typing import (\n    Any,\n    Dict,\n    List,\n    Sequence,\n    Tuple,\n    Type,\n)\n\nfrom fastapi._compat import may_v1\nfrom fastapi._compat.shared import PYDANTIC_V2, lenient_issubclass\nfrom fastapi.types import ModelNameMap\nfrom pydantic import BaseModel\nfrom typing_extensions import Literal\n\nfrom .model_field import ModelField\n\nif PYDANTIC_V2:\n    from .v2 import BaseConfig as BaseConfig\n    from .v2 import FieldInfo as FieldInfo\n    from .v2 import PydanticSchemaGenerationError as PydanticSchemaGenerationError\n    from .v2 import RequiredParam as RequiredParam\n    from .v2 import Undefined as Undefined\n    from .v2 import UndefinedType as UndefinedType\n    from .v2 import Url as Url\n    from .v2 import Validator as Validator\n    from .v2 import evaluate_forwardref as evaluate_forwardref\n    from .v2 import get_missing_field_error as get_missing_field_error\n    from .v2 import (\n        with_info_plain_validator_function as with_info_plain_validator_function,\n    )\nelse:\n    from .v1 import BaseConfig as BaseConfig  # type: ignore[assignment]\n    from .v1 import FieldInfo as FieldInfo\n    from .v1 import (  # type: ignore[assignment]\n        PydanticSchemaGenerationError as PydanticSchemaGenerationError,\n    )\n    from .v1 import RequiredParam as RequiredParam\n    from .v1 import Undefined as Undefined\n    from .v1 import UndefinedType as UndefinedType\n    from .v1 import Url as Url  # type: ignore[assignment]\n    from .v1 import Validator as Validator\n    from .v1 import evaluate_forwardref as evaluate_forwardref\n    from .v1 import get_missing_field_error as get_missing_field_error\n    from .v1 import (  # type: ignore[assignment]\n        with_info_plain_validator_function as with_info_plain_validator_function,\n    )\n\n\n@lru_cache\ndef get_cached_model_fields(model: Type[BaseModel]) -> List[ModelField]:\n    if lenient_issubclass(model, ma

{"status": "ok", "stdout": "        return True\n    elif PYDANTIC_V2:\n        from . import v2\n\n        return isinstance(exc, v2.ErrorWrapper)\n    return False\n\n\ndef copy_field_info(*, field_info: FieldInfo, annotation: Any) -> FieldInfo:\n    if isinstance(field_info, may_v1.FieldInfo):\n        from fastapi._compat import v1\n\n        return v1.copy_field_info(field_info=field_info, annotation=annotation)\n    else:\n        assert PYDANTIC_V2\n        from . import v2\n\n        return v2.copy_field_info(field_info=field_info, annotation=annotation)\n\n\ndef create_body_model(\n    *, fields: Sequence[ModelField], model_name: str\n) -> Type[BaseModel]:\n    if fields and isinstance(fields[0], may_v1.ModelField):\n        from fastapi._compat import v1\n\n        return v1.create_body_model(fields=fields, model_name=model_name)\n    else:\n        assert PYDANTIC_V2\n        from . import v2\n\n        return v2.create_body_model(fields=fields, model_name=model_name)  # type: ignore[arg-type]\n\n\ndef get_annotation_from_field_info(\n    annotation: Any, field_info: FieldInfo, field_name: str\n) -> Any:\n    if isinstance(field_info, may_v1.FieldInfo):\n        from fastapi._compat import v1\n\n        return v1.get_annotation_from_field_info(\n            annotation=annotation, field_info=field_info, field_name=field_name\n        )\n    else:\n        assert PYDANTIC_V2\n        from . import v2\n\n        return v2.get_annotation_from_field_info(\n            annotation=annotation, field_info=field_info, field_name=field_name\n        )\n\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "\n\ndef is_bytes_field(field: ModelField) -> bool:\n    if isinstance(field, may_v1.ModelField):\n        from fastapi._compat import v1\n\n        return v1.is_bytes_field(field)\n    else:\n        assert PYDANTIC_V2\n        from . import v2\n\n        return v2.is_bytes_field(field)  # type: ignore[arg-type]\n\n\ndef is_bytes_sequence_field(field: ModelField) -> bool:\n    if isinstance(field, may_v1.ModelField):\n        from fastapi._compat import v1\n\n        return v1.is_bytes_sequence_field(field)\n    else:\n        assert PYDANTIC_V2\n        from . import v2\n\n        return v2.is_bytes_sequence_field(field)  # type: ignore[arg-type]\n\n\ndef is_scalar_field(field: ModelField) -> bool:\n    if isinstance(field, may_v1.ModelField):\n        from fastapi._compat import v1\n\n        return v1.is_scalar_field(field)\n    else:\n        assert PYDANTIC_V2\n        from . import v2\n\n        return v2.is_scalar_field(field)  # type: ignore[arg-type]\n\n\ndef is_scalar_sequence_field(field: ModelField) -> bool:\n    if isinstance(field, may_v1.ModelField):\n        from fastapi._compat import v1\n\n        return v1.is_scalar_sequence_field(field)\n    else:\n        assert PYDANTIC_V2\n        from . import v2\n\n        return v2.is_scalar_sequence_field(field)  # type: ignore[arg-type]\n\n\ndef is_sequence_field(field: ModelField) -> bool:\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "def is_sequence_field(field: ModelField) -> bool:\n    if isinstance(field, may_v1.ModelField):\n        from fastapi._compat import v1\n\n        return v1.is_sequence_field(field)\n    else:\n        assert PYDANTIC_V2\n        from . import v2\n\n        return v2.is_sequence_field(field)  # type: ignore[arg-type]\n\n\ndef serialize_sequence_value(*, field: ModelField, value: Any) -> Sequence[Any]:\n    if isinstance(field, may_v1.ModelField):\n        from fastapi._compat import v1\n\n        return v1.serialize_sequence_value(field=field, value=value)\n    else:\n        assert PYDANTIC_V2\n        from . import v2\n\n        return v2.serialize_sequence_value(field=field, value=value)  # type: ignore[arg-type]\n\n\ndef _model_rebuild(model: Type[BaseModel]) -> None:\n    if lenient_issubclass(model, may_v1.BaseModel):\n        from fastapi._compat import v1\n\n        v1._model_rebuild(model)\n    elif PYDANTIC_V2:\n        from . import v2\n\n        v2._model_rebuild(model)\n\n\ndef get_compat_model_name_map(fields: List[ModelField]) -> ModelNameMap:\n    v1_model_fields = [\n        field for field in fields if isinstance(field, may_v1.ModelField)\n    ]\n    if v1_model_fields:\n        from fastapi._compat import v1\n\n        v1_flat_models = v1.get_flat_models_from_fields(\n            v1_model_fields, known_models=set()\n        )\n        all_flat_models = v1_flat_models\n    else:\n        all_flat_models = set()\n    if PYDANTIC_V2:\n        from . import v2\n\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "\n        v2_model_fields = [\n            field for field in fields if isinstance(field, v2.ModelField)\n        ]\n        v2_flat_models = v2.get_flat_models_from_fields(\n            v2_model_fields, known_models=set()\n        )\n        all_flat_models = all_flat_models.union(v2_flat_models)\n\n        model_name_map = v2.get_model_name_map(all_flat_models)\n        return model_name_map\n    from fastapi._compat import v1\n\n    model_name_map = v1.get_model_name_map(all_flat_models)\n    return model_name_map\n\n\ndef get_definitions(\n    *,\n    fields: List[ModelField],\n    model_name_map: ModelNameMap,\n    separate_input_output_schemas: bool = True,\n) -> Tuple[\n    Dict[\n        Tuple[ModelField, Literal[\"validation\", \"serialization\"]],\n        may_v1.JsonSchemaValue,\n    ],\n    Dict[str, Dict[str, Any]],\n]:\n    if sys.version_info < (3, 14):\n        v1_fields = [field for field in fields if isinstance(field, may_v1.ModelField)]\n        v1_field_maps, v1_definitions = may_v1.get_definitions(\n            fields=v1_fields,\n            model_name_map=model_name_map,\n            separate_input_output_schemas=separate_input_output_schemas,\n        )\n        if not PYDANTIC_V2:\n            return v1_field_maps, v1_definitions\n        else:\n            from . import v2\n\n            v2_fields = [field for field in fields if isinstance(field, v2.ModelField)]\n            v2_field_maps, v2_definitions = v2.get_definitions(\n                fields=v2_fields,\n                model_name_map=model_name_map,\n                separate_input_output_schemas=separate_input_output_schemas,\n            )\n            all_definitions = {**v1_definitions, **v2_definitions}\n            all_field_maps = {**v1_field_maps, **v2_field_maps}\n            return all_field_maps, all_definitions\n\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "\n    # Pydantic v1 is not supported since Python 3.14\n    else:\n        from . import v2\n\n        v2_fields = [field for field in fields if isinstance(field, v2.ModelField)]\n        v2_field_maps, v2_definitions = v2.get_definitions(\n            fields=v2_fields,\n            model_name_map=model_name_map,\n            separate_input_output_schemas=separate_input_output_schemas,\n        )\n        return v2_field_maps, v2_definitions\n\n\ndef get_schema_from_model_field(\n    *,\n    field: ModelField,\n    model_name_map: ModelNameMap,\n    field_mapping: Dict[\n        Tuple[ModelField, Literal[\"validation\", \"serialization\"]],\n        may_v1.JsonSchemaValue,\n    ],\n    separate_input_output_schemas: bool = True,\n) -> Dict[str, Any]:\n    if isinstance(field, may_v1.ModelField):\n        from fastapi._compat import v1\n\n        return v1.get_schema_from_model_field(\n            field=field,\n            model_name_map=model_name_map,\n            field_mapping=field_mapping,\n            separate_input_output_schemas=separate_input_output_schemas,\n        )\n    else:\n        assert PYDANTIC_V2\n        from . import v2\n\n        return v2.get_schema_from_model_field(\n            field=field,  # type: ignore[arg-type]\n            model_name_map=model_name_map,\n            field_mapping=field_mapping,  # type: ignore[arg-type]\n            separate_input_output_schemas=separate_input_output_schemas,\n        )\n\n\ndef _is_model_field(value: Any) -> bool:\n    if isinstance(value, may_v1.ModelField):\n        return True\n    elif PYDANTIC_V2:\n        from . import v2\n\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "import re\nimport warnings\nfrom copy import copy, deepcopy\nfrom dataclasses import dataclass\nfrom enum import Enum\nfrom typing import (\n    Any,\n    Dict,\n    List,\n    Sequence,\n    Set,\n    Tuple,\n    Type,\n    Union,\n    cast,\n)\n\nfrom fastapi._compat import may_v1, shared\nfrom fastapi.openapi.constants import REF_TEMPLATE\nfrom fastapi.types import IncEx, ModelNameMap\nfrom pydantic import BaseModel, TypeAdapter, create_model\nfrom pydantic import PydanticSchemaGenerationError as PydanticSchemaGenerationError\nfrom pydantic import PydanticUndefinedAnnotation as PydanticUndefinedAnnotation\nfrom pydantic import ValidationError as ValidationError\nfrom pydantic._internal._schema_generation_shared import (  # type: ignore[attr-defined]\n    GetJsonSchemaHandler as GetJsonSchemaHandler,\n)\nfrom pydantic._internal._typing_extra import eval_type_lenient\nfrom pydantic._internal._utils import lenient_issubclass as lenient_issubclass\nfrom pydantic.fields import FieldInfo as FieldInfo\nfrom pydantic.json_schema import GenerateJsonSchema as GenerateJsonSchema\nfrom pydantic.json_schema import JsonSchemaValue as JsonSchemaValue\nfrom pydantic_core import CoreSchema as CoreSchema\nfrom pydantic_core import PydanticUndefined, PydanticUndefinedType\nfrom pydantic_core import Url as Url\nfrom typing_extensions import Annotated, Literal, get_args, get_origin\n\ntry:\n    from pydantic_core.core_schema import (\n        with_info_plain_validator_function as with_info_plain_validator_function,\n    )\nexcept ImportError:  # pragma: no cover\n    from pydantic_core.core_schema import (\n        general_plain_validator_function as with_info_plain_validator_function,  # noqa: F401\n    )\n\nRequiredParam = PydanticUndefined\nUndefined = PydanticUndefined\nUndefinedType = PydanticUndefinedType\nevaluate_forwardref = eval_type_lenient\nValidator = Any\n\n\nclass BaseConfig:\n    pass\n\n\nclass ErrorWrapper(Exception):\n    pass\n\n\n@data