fastapi_14609

{"status": "ok", "stdout": "./fastapi/dependencies/utils.py:47:from fastapi._compat.shared import annotation_is_pydantic_v1\n./fastapi/dependencies/utils.py:75:from .. import temp_pydantic_v1_params\n./fastapi/dependencies/utils.py:328:                \"pydantic.v1 is deprecated and will soon stop being supported by FastAPI.\"\n./fastapi/dependencies/utils.py:334:            param_details.field.field_info, (params.Body, temp_pydantic_v1_params.Body)\n./fastapi/dependencies/utils.py:403:                    temp_pydantic_v1_params.Param,\n./fastapi/dependencies/utils.py:405:                    temp_pydantic_v1_params.Body,\n./fastapi/dependencies/utils.py:494:            if annotation_is_pydantic_v1(use_annotation):\n./fastapi/dependencies/utils.py:495:                field_info = temp_pydantic_v1_params.Body(  # type: ignore[assignment]\n./fastapi/dependencies/utils.py:511:                field_info, (params.Path, temp_pydantic_v1_params.Path)\n./fastapi/dependencies/utils.py:517:            isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param))\n./fastapi/dependencies/utils.py:526:        if isinstance(field_info, (params.Form, temp_pydantic_v1_params.Form)):\n./fastapi/dependencies/utils.py:546:        elif isinstance(field_info, (params.Query, temp_pydantic_v1_params.Query)):\n./fastapi/dependencies/utils.py:765:            isinstance(field.field_info, (params.Form, temp_pydantic_v1_params.Form))\n./fastapi/dependencies/utils.py:835:        assert isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param)), (\n./fastapi/dependencies/utils.py:847:        assert isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param)), (\n./fastapi/dependencies/utils.py:896:        isinstance(first_field.field_info, (params.Form, temp_pydantic_v1_params.Form))\n./fastapi/dependencies/utils.py:914:            isinstance(field_info, (params.File, temp_pydantic_v1_params.File))\n./fastapi/dependencies/utils.py:921:            and isinstance(field_i

{"status": "ok", "stdout": "__init__.py\nmain.py\nmay_v1.py\nmodel_field.py\nshared.py\nv1.py\nv2.py\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "./fastapi/dependencies/utils.py:75:from .. import temp_pydantic_v1_params\n./fastapi/dependencies/utils.py:334:            param_details.field.field_info, (params.Body, temp_pydantic_v1_params.Body)\n./fastapi/dependencies/utils.py:403:                    temp_pydantic_v1_params.Param,\n./fastapi/dependencies/utils.py:405:                    temp_pydantic_v1_params.Body,\n./fastapi/dependencies/utils.py:495:                field_info = temp_pydantic_v1_params.Body(  # type: ignore[assignment]\n./fastapi/dependencies/utils.py:511:                field_info, (params.Path, temp_pydantic_v1_params.Path)\n./fastapi/dependencies/utils.py:517:            isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param))\n./fastapi/dependencies/utils.py:526:        if isinstance(field_info, (params.Form, temp_pydantic_v1_params.Form)):\n./fastapi/dependencies/utils.py:546:        elif isinstance(field_info, (params.Query, temp_pydantic_v1_params.Query)):\n./fastapi/dependencies/utils.py:765:            isinstance(field.field_info, (params.Form, temp_pydantic_v1_params.Form))\n./fastapi/dependencies/utils.py:835:        assert isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param)), (\n./fastapi/dependencies/utils.py:847:        assert isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param)), (\n./fastapi/dependencies/utils.py:896:        isinstance(first_field.field_info, (params.Form, temp_pydantic_v1_params.Form))\n./fastapi/dependencies/utils.py:914:            isinstance(field_info, (params.File, temp_pydantic_v1_params.File))\n./fastapi/dependencies/utils.py:921:            and isinstance(field_info, (params.File, temp_pydantic_v1_params.File))\n./fastapi/dependencies/utils.py:1033:        isinstance(f.field_info, temp_pydantic_v1_params.File)\n./fastapi/dependencies/utils.py:1036:        BodyFieldInfo: type[temp_pydantic_v1_params.Body] = temp_pydantic_v1_params.File  # type: ignore[no-redef]\n./fastapi/depende

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

{"status": "ok", "stdout": "\n\ndef 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": "import sys\nfrom collections.abc import Sequence\nfrom typing import Any, Literal, 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 Undef

{"status": "ok", "stdout": "from collections.abc import Sequence\nfrom copy import copy\nfrom dataclasses import dataclass, is_dataclass\nfrom enum import Enum\nfrom typing import (\n    Any,\n    Callable,\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.v1 import BaseConfig as BaseConfig\nfrom pydantic.v1 import BaseModel as BaseModel\nfrom pydantic.v1 import ValidationError as ValidationError\nfrom pydantic.v1 import create_model as create_model\nfrom pydantic.v1.class_validators import Validator as Validator\nfrom pydantic.v1.color import Color as Color\nfrom pydantic.v1.error_wrappers import ErrorWrapper as ErrorWrapper\nfrom pydantic.v1.fields import (\n    SHAPE_FROZENSET,\n    SHAPE_LIST,\n    SHAPE_SEQUENCE,\n    SHAPE_SET,\n    SHAPE_SINGLETON,\n    SHAPE_TUPLE,\n    SHAPE_TUPLE_ELLIPSIS,\n)\nfrom pydantic.v1.fields import FieldInfo as FieldInfo\nfrom pydantic.v1.fields import ModelField as ModelField\nfrom pydantic.v1.fields import Undefined as Undefined\nfrom pydantic.v1.fields import UndefinedType as UndefinedType\nfrom pydantic.v1.networks import AnyUrl as AnyUrl\nfrom pydantic.v1.networks import NameEmail as NameEmail\nfrom pydantic.v1.schema import TypeModelSet as TypeModelSet\nfrom pydantic.v1.schema import field_schema, model_process_schema\nfrom pydantic.v1.schema import (\n    get_annotation_from_field_info as get_annotation_from_field_info,\n)\nfrom pydantic.v1.schema import (\n    get_flat_models_from_field as get_flat_models_from_field,\n)\nfrom pydantic.v1.schema import (\n    get_flat_models_from_fields as get_flat_models_from_fields,\n)\nfrom pydantic.v1.schema import get_model_name_map as get_model_name_map\nfrom pydantic.v1.types import SecretBytes as SecretBytes\nfrom pydantic.v1.types import SecretStr as SecretStr\nfrom pydantic.v1.typing import evaluate_forwardref as evaluate_forwardref\nfrom pydantic.v1.utils impo

{"status": "ok", "stdout": "import warnings\nfrom typing import Annotated, Any, Callable, Optional, Union\n\nfrom fastapi.exceptions import FastAPIDeprecationWarning\nfrom fastapi.openapi.models import Example\nfrom fastapi.params import ParamTypes\nfrom typing_extensions import deprecated\n\nfrom ._compat.may_v1 import FieldInfo, Undefined\n\n_Unset: Any = Undefined\n\n\nclass Param(FieldInfo):\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                \"Deprecated in OpenAPI 3.1.0 that now uses J

{"status": "ok", "stdout": "47:from fastapi._compat.shared import annotation_is_pydantic_v1\n494:            if annotation_is_pydantic_v1(use_annotation):\n1045:        if annotation_is_pydantic_v1(BodyModel):\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "            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(  # type: ignore[assignment]\n                    annotation=use_annotation, default=default_value\n                )\n            else:\n                field_info = params.Body(\n                    annotation=use_annotation, default=default_value\n                )\n        else:\n            field_info = params.Query(annotation=use_annotation, default=default_value)\n\n    field = None\n    # It's a field_info, not a dependency\n    if field_info is not None:\n        # Handle field_info.in_\n        if is_path_param:\n            assert isinstance(\n                field_info, (params.Path, temp_pydantic_v1_params.Path)\n            ), (\n                f\"Cannot use `{field_info.__class__.__name__}` for path param\"\n                f\" {param_name!r}\"\n            )\n        elif (\n            isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param))\n            and getattr(field_info, \"in_\", None) is None\n        ):\n            field_info.in_ = params.ParamTypes.query\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        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            if isinstance(f.field_info, (params.Body, temp_pydantic_v1_params.Body))\n        ]\n        if len(set(body_param_media_types)) == 1:\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        ):\n            assert param_details.field is None, (\n                f\"Cannot specify multiple FastAPI annotations for {param_name!r}\"\n            )\n            continue\n        assert param_details.field is not None\n        if isinstance(param_details.field, may_v1.ModelField):\n            warnings.warn(\n                \"pydantic.v1 is deprecated and will soon stop being supported by FastAPI.\"\n                f\" Please update the param {param_name}: {param_details.type_annotation!r}.\",\n                category=FastAPIDeprecationWarning,\n                stacklevel=5,\n            )\n        if isinstance(\n            param_details.field.field_info, (params.Body, temp_pydantic_v1_params.Body)\n        ):\n            dependant.body_params.append(param_details.field)\n        else:\n            add_param_to_fields(field=param_details.field, dependant=dependant)\n    return dependant\n\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "1033\n1036\n1040\n1043\n1046\n1053\n334\n403\n405\n495\n511\n517\n526\n546\n75\n765\n835\n847\n896\n914\n921\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "from starlette.requests import HTTPConnection, Request\nfrom starlette.responses import Response\nfrom starlette.websockets import WebSocket\nfrom typing_extensions import Literal, get_args, get_origin\n\nfrom .. import temp_pydantic_v1_params\n\nmultipart_not_installed_error = (\n    'Form data requires \"python-multipart\" to be installed. \\n'\n    'You can install \"python-multipart\" with: \\n\\n'\n    \"pip install python-multipart\\n\"\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    Optional,\n    Union,\n)\n\nfrom annotated_doc import Doc\nfrom fastapi import params, temp_pydantic_v1_params\nfrom fastapi._compat import (\n    ModelField,\n    Undefined,\n    _get_model_config,\n    _model_dump,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    dependency_overrides_provider: Optional[Any] = None,\n    embed_body_fields: bool = False,\n) -> Callable[[Request], Coroutine[Any, Any, Response]]:\n    assert dependant.call is not None, \"dependant.call must be a function\"\n    is_coroutine = dependant.is_coroutine_callable\n    is_body_form = body_field and isinstance(\n        body_field.field_info, (params.Form, temp_pydantic_v1_params.Form)\n    )\n    if isinstance(response_class, DefaultPlaceholder):\n        actual_response_class: type[Response] = response_class.value\n    else:\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "                arg,\n                (\n                    params.Param,\n                    temp_pydantic_v1_params.Param,\n                    params.Body,\n                    temp_pydantic_v1_params.Body,\n                    params.Depends,\n                ),\n            )\n        ]\n        if fastapi_specific_annotations:\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "            assert isinstance(\n                field_info, (params.Path, temp_pydantic_v1_params.Path)\n            ), (\n                f\"Cannot use `{field_info.__class__.__name__}` for path param\"\n                f\" {param_name!r}\"\n            )\n        elif (\n            isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param))\n            and getattr(field_info, \"in_\", None) is None\n        ):\n            field_info.in_ = params.ParamTypes.query\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "            field_info.in_ = params.ParamTypes.query\n        use_annotation_from_field_info = get_annotation_from_field_info(\n            use_annotation,\n            field_info,\n            param_name,\n        )\n        if isinstance(field_info, (params.Form, temp_pydantic_v1_params.Form)):\n            ensure_multipart_is_installed()\n        if not field_info.alias and getattr(field_info, \"convert_underscores\", None):\n            alias = param_name.replace(\"_\", \"-\")\n        else:\n            alias = field_info.alias or param_name\n        field_info.alias = alias\n        field = create_model_field(\n            name=param_name,\n            type_=use_annotation_from_field_info,\n            default=field_info.default,\n            alias=alias,\n            required=field_info.default\n            in (RequiredParam, may_v1.RequiredParam, Undefined),\n            field_info=field_info,\n        )\n        if is_path_param:\n            assert is_scalar_field(field=field), (\n                \"Path params must be of one of the supported types\"\n            )\n        elif isinstance(field_info, (params.Query, temp_pydantic_v1_params.Query)):\n            assert (\n                is_scalar_field(field)\n                or is_scalar_sequence_field(field)\n                or (\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    else:\n        value = values.get(alias, None)\n    if (\n        value is None\n        or (\n            isinstance(field.field_info, (params.Form, temp_pydantic_v1_params.Form))\n            and isinstance(value, str)  # For type checks\n            and value == \"\"\n        )\n        or (is_sequence_field(field) and len(value) == 0)\n    ):\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "            else:\n                params_to_process[key] = received_params.get(key)\n\n    if single_not_embedded_field:\n        field_info = first_field.field_info\n        assert isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param)), (\n            \"Params must be subclasses of Param\"\n        )\n        loc: tuple[str, ...] = (field_info.in_.value,)\n        v_, errors_ = _validate_value_with_model_field(\n            field=first_field, value=params_to_process, values=values, loc=loc\n        )\n        return {first_field.name: v_}, errors_\n\n    for field in fields:\n        value = _get_multidict_value(field, received_params)\n        field_info = field.field_info\n        assert isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param)), (\n            \"Params must be subclasses of Param\"\n        )\n        loc = (field_info.in_.value, get_validation_alias(field))\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    # If it explicitly specifies it is embedded, it has to be embedded\n    if getattr(first_field.field_info, \"embed\", None):\n        return True\n    # If it's a Form (or File) field, it has to be a BaseModel (or a union of BaseModels) to be top level\n    # otherwise it has to be embedded, so that the key value pair can be extracted\n    if (\n        isinstance(first_field.field_info, (params.Form, temp_pydantic_v1_params.Form))\n        and not _is_model_class(first_field.type_)\n        and not is_union_of_base_models(first_field.type_)\n    ):\n        return True\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    for field in body_fields:\n        value = _get_multidict_value(field, received_body)\n        field_info = field.field_info\n        if (\n            isinstance(field_info, (params.File, temp_pydantic_v1_params.File))\n            and is_bytes_field(field)\n            and isinstance(value, UploadFile)\n        ):\n            value = await value.read()\n        elif (\n            is_bytes_sequence_field(field)\n            and isinstance(field_info, (params.File, temp_pydantic_v1_params.File))\n            and value_is_sequence(value)\n        ):\n            # For types\n            assert isinstance(value, sequence_types)\n            results: list[Union[bytes, str]] = []\n\n            async def process_fn(\n                fn: Callable[[], Coroutine[Any, Any, Any]],\n            ) -> None:\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    if any(isinstance(f.field_info, params.File) for f in flat_dependant.body_params):\n        BodyFieldInfo: type[params.Body] = params.File\n    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            if isinstance(f.field_info, (params.Body, temp_pydantic_v1_params.Body))\n        ]\n        if len(set(body_param_media_types)) == 1:\n            BodyFieldInfo_kwargs[\"media_type\"] = body_param_media_types[0]\n    final_field = create_model_field(\n        name=\"body\",\n        type_=BodyModel,\n        required=required,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "\n\ndef 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": "from .main import BaseConfig as BaseConfig\nfrom .main import PydanticSchemaGenerationError as PydanticSchemaGenerationError\nfrom .main import RequiredParam as RequiredParam\nfrom .main import Undefined as Undefined\nfrom .main import UndefinedType as UndefinedType\nfrom .main import Url as Url\nfrom .main import Validator as Validator\nfrom .main import _get_model_config as _get_model_config\nfrom .main import _is_error_wrapper as _is_error_wrapper\nfrom .main import _is_model_class as _is_model_class\nfrom .main import _is_model_field as _is_model_field\nfrom .main import _is_undefined as _is_undefined\nfrom .main import _model_dump as _model_dump\nfrom .main import copy_field_info as copy_field_info\nfrom .main import create_body_model as create_body_model\nfrom .main import evaluate_forwardref as evaluate_forwardref\nfrom .main import get_annotation_from_field_info as get_annotation_from_field_info\nfrom .main import get_cached_model_fields as get_cached_model_fields\nfrom .main import get_compat_model_name_map as get_compat_model_name_map\nfrom .main import get_definitions as get_definitions\nfrom .main import get_missing_field_error as get_missing_field_error\nfrom .main import get_schema_from_model_field as get_schema_from_model_field\nfrom .main import is_bytes_field as is_bytes_field\nfrom .main import is_bytes_sequence_field as is_bytes_sequence_field\nfrom .main import is_scalar_field as is_scalar_field\nfrom .main import is_scalar_sequence_field as is_scalar_sequence_field\nfrom .main import is_sequence_field as is_sequence_field\nfrom .main import serialize_sequence_value as serialize_sequence_value\nfrom .main import (\n    with_info_plain_validator_function as with_info_plain_validator_function,\n)\nfrom .may_v1 import CoreSchema as CoreSchema\nfrom .may_v1 import GetJsonSchemaHandler as GetJsonSchemaHandler\nfrom .may_v1 import JsonSchemaValue as JsonSchemaValue\nfrom .may_v1 import _normalize_errors as _normalize_errors\

{"status": "ok", "stdout": "import sys\nimport types\nimport typing\nfrom collections import deque\nfrom collections.abc import Mapping, Sequence\nfrom dataclasses import is_dataclass\nfrom typing import (\n    Annotated,\n    Any,\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 get_args, get_origin\n\n# Copy from Pydantic v2, compatible with v1\nif 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    tuple: tuple,\n    set: set,\n    frozenset: frozenset,\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 isinstance(cls, type) and issubclass(cls, class_or_tuple)  # type: ignore[arg-type]\n    except TypeError:  # pragma: no cover\n        if isinstance(cls, WithArgsTypes):\n            return False\n        raise  # pragma: no cover\n\n\ndef _annotation_is_sequence(annotation: Union[type[Any], None]) -> bool:\n    if lenient_issubclass(annotation, (str, bytes)):\n        return False\n    return lenient_issubclass(annotation, sequence_types)\n\n\ndef field_annotation_is_sequence(annotation: Union[type[Any], 

{"status": "ok", "filepath": "fastapi/_compat/shared.py", "occurrences": 1, "strategy": "exact", "diff": "--- a/fastapi/_compat/shared.py\n+++ b/fastapi/_compat/shared.py\n@@ -180,15 +180,4 @@\n \n \n 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", "is_truncated": false}

{"status": "ok", "filepath": "fastapi/dependencies/utils.py", "occurrences": 1, "strategy": "exact", "diff": "--- a/fastapi/dependencies/utils.py\n+++ b/fastapi/dependencies/utils.py\n@@ -491,14 +491,9 @@\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(  # type: ignore[assignment]\n-                    annotation=use_annotation, default=default_value\n-                )\n-            else:\n-                field_info = params.Body(\n-                    annotation=use_annotation, default=default_value\n-                )\n+            field_info = params.Body(\n+                annotation=use_annotation, default=default_value\n+            )\n         else:\n             field_info = params.Query(annotation=use_annotation, default=default_value)\n \n", "is_truncated": false}

{"status": "ok", "filepath": "fastapi/dependencies/utils.py", "occurrences": 1, "strategy": "exact", "diff": "--- a/fastapi/dependencies/utils.py\n+++ b/fastapi/dependencies/utils.py\n@@ -1031,14 +1031,8 @@\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+        if isinstance(f.field_info, params.Form):\n+            BodyFieldInfo = params.Form  # type: ignore[assignment]\n         else:\n             BodyFieldInfo = params.Body\n \n", "is_truncated": false}

{"status": "ok", "stdout": "    ):\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        if isinstance(f.field_info, params.Form):\n            BodyFieldInfo = params.Form  # 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            if isinstance(f.field_info, (params.Body, temp_pydantic_v1_params.Body))\n        ]\n        if len(set(body_param_media_types)) == 1:\n            BodyFieldInfo_kwargs[\"media_type\"] = body_param_media_types[0]\n    final_field = create_model_field(\n        name=\"body\",\n        type_=BodyModel,\n        required=required,\n        alias=\"body\",\n", "stderr": "", "exit_code": 0}

{"status": "ok", "filepath": "fastapi/dependencies/utils.py", "occurrences": 1, "strategy": "exact", "diff": "--- a/fastapi/dependencies/utils.py\n+++ b/fastapi/dependencies/utils.py\n@@ -1031,10 +1031,8 @@\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-        if isinstance(f.field_info, params.Form):\n-            BodyFieldInfo = params.Form  # type: ignore[assignment]\n-        else:\n-            BodyFieldInfo = params.Body\n+    else:\n+        BodyFieldInfo = params.Body\n \n         body_param_media_types = [\n             f.field_info.media_type\n", "is_truncated": false}

{"status": "ok", "filepath": "fastapi/dependencies/utils.py", "occurrences": 1, "strategy": "exact", "diff": "--- a/fastapi/dependencies/utils.py\n+++ b/fastapi/dependencies/utils.py\n@@ -1037,7 +1037,7 @@\n         body_param_media_types = [\n             f.field_info.media_type\n             for f in flat_dependant.body_params\n-            if isinstance(f.field_info, (params.Body, temp_pydantic_v1_params.Body))\n+            if isinstance(f.field_info, params.Body)\n         ]\n         if len(set(body_param_media_types)) == 1:\n             BodyFieldInfo_kwargs[\"media_type\"] = body_param_media_types[0]\n", "is_truncated": false}

{"status": "ok", "stdout": "75:from .. import temp_pydantic_v1_params\n334:            param_details.field.field_info, (params.Body, temp_pydantic_v1_params.Body)\n403:                    temp_pydantic_v1_params.Param,\n405:                    temp_pydantic_v1_params.Body,\n506:                field_info, (params.Path, temp_pydantic_v1_params.Path)\n512:            isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param))\n521:        if isinstance(field_info, (params.Form, temp_pydantic_v1_params.Form)):\n541:        elif isinstance(field_info, (params.Query, temp_pydantic_v1_params.Query)):\n760:            isinstance(field.field_info, (params.Form, temp_pydantic_v1_params.Form))\n830:        assert isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param)), (\n842:        assert isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param)), (\n891:        isinstance(first_field.field_info, (params.Form, temp_pydantic_v1_params.Form))\n909:            isinstance(field_info, (params.File, temp_pydantic_v1_params.File))\n916:            and isinstance(field_info, (params.File, temp_pydantic_v1_params.File))\n1028:        isinstance(f.field_info, temp_pydantic_v1_params.File)\n1031:        BodyFieldInfo: type[temp_pydantic_v1_params.Body] = temp_pydantic_v1_params.File  # type: ignore[no-redef]\n", "stderr": "", "exit_code": 0}

{"status": "ok", "filepath": "fastapi/dependencies/utils.py", "occurrences": 1, "strategy": "exact", "diff": "--- a/fastapi/dependencies/utils.py\n+++ b/fastapi/dependencies/utils.py\n@@ -330,9 +330,7 @@\n                 category=FastAPIDeprecationWarning,\n                 stacklevel=5,\n             )\n-        if isinstance(\n-            param_details.field.field_info, (params.Body, temp_pydantic_v1_params.Body)\n-        ):\n+        if isinstance(param_details.field.field_info, params.Body):\n             dependant.body_params.append(param_details.field)\n         else:\n             add_param_to_fields(field=param_details.field, dependant=dependant)\n", "is_truncated": false}