← pod_r3_v1g

fastapi_14609

failed CONTEXT UNSUBMITTED agent_error · 30 tool calls · 186 s · fastapi/fastapi

Task input

➖ Drop support for `pydantic.v1`

➖ Drop support for `pydantic.v1`

When trying to use a `pydantic.v1` model with FastAPI, an error is raised.

Tool calls (30)

#ToolArgumentsResult
1run_command
{
 "command": "grep -rn \"pydantic.v1\" ."
}
{"status": "ok", "stdout": "./tests/test_filter_pydantic_sub_model/app_pv1.py:5:from pydantic.v1 import BaseModel, validator\n./tests/test_compat_params_v1.py:1
full
{"status": "ok", "stdout": "./tests/test_filter_pydantic_sub_model/app_pv1.py:5:from pydantic.v1 import BaseModel, validator\n./tests/test_compat_params_v1.py:17:from fastapi.temp_pydantic_v1_params import (\n./tests/test_tutorial/test_pydantic_v1_in_v2/test_tutorial002.py:35:        mod = importlib.import_module(f\"docs_src.pydantic_v1_in_v2.{request.param}\")\n./tests/test_tutorial/test_pydantic_v1_in_v2/test_tutorial003.py:35:        mod = importlib.import_module(f\"docs_src.pydantic_v1_in_v2.{request.param}\")\n./tests/test_tutorial/test_pydantic_v1_in_v2/test_tutorial004.py:35:        mod = importlib.import_module(f\"docs_src.pydantic_v1_in_v2.{request.param}\")\n./tests/test_tutorial/test_pydantic_v1_in_v2/test_tutorial001.py:25:    mod = importlib.import_module(f\"docs_src.pydantic_v1_in_v2.{request.param}\")\n./tests/test_get_model_definitions_formfeed_escape.py:14:        pytest.param(\"pydantic-v1\", marks=needs_pydanticv1),\n./tests/test_get_model_definitions_formfeed_escape.py:19:    if request.param == \"pydantic-v1\":\n./tests/test_get_model_definitions_formfeed_escape.py:20:        from pydantic.v1 import BaseModel\n./tests/test_get_model_definitions_formfeed_escape.py:41:    if request.param == \"pydantic-v1\":\n./tests/test_pydantic_v1_v2_multifile/test_multifile.py:298:                                                \"$ref\": \"#/components/schemas/tests__test_pydantic_v1_v2_multifile__modelsv1__Item\"\n./tests/test_pydantic_v1_v2_multifile/test_multifile.py:313:                                            \"$ref\": \"#/components/schemas/tests__test_pydantic_v1_v2_multifile__modelsv2__Item\"\n./tests/test_pydantic_v1_v2_multifile/test_multifile.py:339:                                        \"$ref\": \"#/components/schemas/tests__test_pydantic_v1_v2_multifile__modelsv2__Item-Input\"\n./tests/test_pydantic_v1_v2_multifile/test_multifile.py:351:                                            \"$ref\": \"#/components/schemas/tests__test_pydantic_v1_v2_mul
2run_command
{
 "command": "grep -rn \"pydantic.v1\" fastapi | head -40"
}
{"status": "ok", "stdout": "fastapi/dependencies/utils.py:47:from fastapi._compat.shared import annotation_is_pydantic_v1\nfastapi/dependencies/utils.py:75:from
full
{"status": "ok", "stdout": "fastapi/dependencies/utils.py:47:from fastapi._compat.shared import annotation_is_pydantic_v1\nfastapi/dependencies/utils.py:75:from .. import temp_pydantic_v1_params\nfastapi/dependencies/utils.py:328:                \"pydantic.v1 is deprecated and will soon stop being supported by FastAPI.\"\nfastapi/dependencies/utils.py:334:            param_details.field.field_info, (params.Body, temp_pydantic_v1_params.Body)\nfastapi/dependencies/utils.py:403:                    temp_pydantic_v1_params.Param,\nfastapi/dependencies/utils.py:405:                    temp_pydantic_v1_params.Body,\nfastapi/dependencies/utils.py:494:            if annotation_is_pydantic_v1(use_annotation):\nfastapi/dependencies/utils.py:495:                field_info = temp_pydantic_v1_params.Body(  # type: ignore[assignment]\nfastapi/dependencies/utils.py:511:                field_info, (params.Path, temp_pydantic_v1_params.Path)\nfastapi/dependencies/utils.py:517:            isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param))\nfastapi/dependencies/utils.py:526:        if isinstance(field_info, (params.Form, temp_pydantic_v1_params.Form)):\nfastapi/dependencies/utils.py:546:        elif isinstance(field_info, (params.Query, temp_pydantic_v1_params.Query)):\nfastapi/dependencies/utils.py:765:            isinstance(field.field_info, (params.Form, temp_pydantic_v1_params.Form))\nfastapi/dependencies/utils.py:835:        assert isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param)), (\nfastapi/dependencies/utils.py:847:        assert isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param)), (\nfastapi/dependencies/utils.py:896:        isinstance(first_field.field_info, (params.Form, temp_pydantic_v1_params.Form))\nfastapi/dependencies/utils.py:914:            isinstance(field_info, (params.File, temp_pydantic_v1_params.File))\nfastapi/dependencies/utils.py:921:            and isinstance(field_info, (params.File, temp_pydantic_v1_
3run_command
{
 "command": "ls -R fastapi/_compat"
}
{"status": "ok", "stdout": "__init__.py\nmain.py\nmay_v1.py\nmodel_field.py\nshared.py\nv1.py\nv2.py\n", "stderr": "", "exit_code": 0}
full
{"status": "ok", "stdout": "__init__.py\nmain.py\nmay_v1.py\nmodel_field.py\nshared.py\nv1.py\nv2.py\n", "stderr": "", "exit_code": 0}
4run_command
{
 "command": "cat fastapi/_compat/shared.py"
}
{"status": "ok", "stdout": "import sys\nimport types\nimport typing\nfrom collections import deque\nfrom collections.abc import Mapping, Sequence\nfrom dataclas
full
{"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],
5run_command
{
 "command": "cat fastapi/_compat/may_v1.py"
}
{"status": "ok", "stdout": "import sys\nfrom collections.abc import Sequence\nfrom typing import Any, Literal, Union\n\nfrom fastapi.types import ModelNameMap\n
full
{"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
6run_command
{
 "command": "cat fastapi/_compat/v1.py"
}
{"status": "ok", "stdout": "from collections.abc import Sequence\nfrom copy import copy\nfrom dataclasses import dataclass, is_dataclass\nfrom enum import Enum\
full
{"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
7run_command
{
 "command": "grep -rn \"annotation_is_pydantic_v1\" ."
}
{"status": "ok", "stdout": "./fastapi/dependencies/utils.py:47:from fastapi._compat.shared import annotation_is_pydantic_v1\n./fastapi/dependencies/utils.py:494
full
{"status": "ok", "stdout": "./fastapi/dependencies/utils.py:47:from fastapi._compat.shared import annotation_is_pydantic_v1\n./fastapi/dependencies/utils.py:494:            if annotation_is_pydantic_v1(use_annotation):\n./fastapi/dependencies/utils.py:1045:        if annotation_is_pydantic_v1(BodyModel):\n./fastapi/utils.py:21:    annotation_is_pydantic_v1,\n./fastapi/utils.py:102:        annotation_is_pydantic_v1(type_)\n./fastapi/routing.py:32:    annotation_is_pydantic_v1,\n./fastapi/routing.py:640:            if annotation_is_pydantic_v1(self.response_model):\n./fastapi/routing.py:680:                if annotation_is_pydantic_v1(model):\n./fastapi/_compat/__init__.py:39:from .shared import annotation_is_pydantic_v1 as annotation_is_pydantic_v1\n./fastapi/_compat/shared.py:182:def annotation_is_pydantic_v1(annotation: Any) -> bool:\n./fastapi/_compat/shared.py:192:            if annotation_is_pydantic_v1(sub_annotation):\n", "stderr": "", "exit_code": 0}
8run_command
{
 "command": "sed -n '170,200p' fastapi/_compat/shared.py"
}
{"status": "ok", "stdout": " at_least_one = False\n for arg in get_args(annotation):\n if is_uploadfile_sequence_annotation(arg):\n at_least_one = True\n contin
full
{"status": "ok", "stdout": "        at_least_one = False\n        for arg in get_args(annotation):\n            if is_uploadfile_sequence_annotation(arg):\n                at_least_one = True\n                continue\n        return at_least_one\n    return field_annotation_is_sequence(annotation) and all(\n        is_uploadfile_or_nonable_uploadfile_annotation(sub_annotation)\n        for sub_annotation in get_args(annotation)\n    )\n\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}
9run_command
{
 "command": "cat fastapi/_compat/v2.py"
}
{"status": "ok", "stdout": "import re\nimport warnings\nfrom collections.abc import Sequence\nfrom copy import copy, deepcopy\nfrom dataclasses import dataclass
full
{"status": "ok", "stdout": "import re\nimport warnings\nfrom collections.abc import Sequence\nfrom copy import copy, deepcopy\nfrom dataclasses import dataclass, is_dataclass\nfrom enum import Enum\nfrom typing import (\n    Annotated,\n    Any,\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, UnionType\nfrom pydantic import BaseModel, ConfigDict, Field, 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 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# TODO: remove when dropping support for Pydantic < v2.12.3\n_Attrs =
10run_command
{
 "command": "cat fastapi/_compat/main.py"
}
{"status": "ok", "stdout": "import sys\nfrom collections.abc import Sequence\nfrom functools import lru_cache\nfrom typing import (\n Any,\n)\n\nfrom fastapi._c
full
{"status": "ok", "stdout": "import sys\nfrom collections.abc import Sequence\nfrom functools import lru_cache\nfrom typing import (\n    Any,\n)\n\nfrom fastapi._compat import may_v1\nfrom fastapi._compat.shared import lenient_issubclass\nfrom fastapi.types import ModelNameMap\nfrom pydantic import BaseModel\nfrom typing_extensions import Literal\n\nfrom . import v2\nfrom .model_field import ModelField\nfrom .v2 import BaseConfig as BaseConfig\nfrom .v2 import FieldInfo as FieldInfo\nfrom .v2 import PydanticSchemaGenerationError as PydanticSchemaGenerationError\nfrom .v2 import RequiredParam as RequiredParam\nfrom .v2 import Undefined as Undefined\nfrom .v2 import UndefinedType as UndefinedType\nfrom .v2 import Url as Url\nfrom .v2 import Validator as Validator\nfrom .v2 import evaluate_forwardref as evaluate_forwardref\nfrom .v2 import get_missing_field_error as get_missing_field_error\nfrom .v2 import (\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, may_v1.BaseModel):\n        from fastapi._compat import v1\n\n        return v1.get_model_fields(model)  # type: ignore[arg-type,return-value]\n    else:\n        from . import v2\n\n        return v2.get_model_fields(model)  # type: ignore[return-value]\n\n\ndef _is_undefined(value: object) -> bool:\n    if isinstance(value, may_v1.UndefinedType):\n        return True\n\n    return isinstance(value, v2.UndefinedType)\n\n\ndef _get_model_config(model: BaseModel) -> Any:\n    if isinstance(model, may_v1.BaseModel):\n        from fastapi._compat import v1\n\n        return v1._get_model_config(model)\n\n    return v2._get_model_config(model)\n\n\ndef _model_dump(\n    model: BaseModel, mode: Literal[\"json\", \"python\"] = \"json\", **kwargs: Any\n) -> Any:\n    if isinstance(model, may_v1.BaseModel):\n        from fastapi._compat import v1\n\n        return v1._mo
11run_command
{
 "command": "cat fastapi/_compat/__init__.py"
}
{"status": "ok", "stdout": "from .main import BaseConfig as BaseConfig\nfrom .main import PydanticSchemaGenerationError as PydanticSchemaGenerationError\nfrom .
full
{"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\
12run_command
{
 "command": "python3 - <<'PY'\nfrom fastapi._compat.shared import annotation_is_pydantic_v1\nfrom pydantic import BaseModel\nfrom pydantic.v1 import BaseModel as BaseModelV1\n\nprint(f\"Pydantic V2 model: {annotation_is_pydantic_v1(BaseModel)}\")\nprint(f\"Pydantic V1 model: {annotation_is_pydantic_v1(BaseModelV1)}\")\nPY\n"
}
{"status": "ok", "stdout": "Pydantic V2 model: False\nPydantic V1 model: True\n", "stderr": "", "exit_code": 0}
full
{"status": "ok", "stdout": "Pydantic V2 model: False\nPydantic V1 model: True\n", "stderr": "", "exit_code": 0}
13run_command
{
 "command": "python3 - <<'PY'\nfrom fastapi._compat.shared import annotation_is_pydantic_v1\nfrom pydantic import BaseModel\nfrom pydantic.v1 import BaseModel as BaseModelV1\n\ndef test_v1_support():\n    print(f\"Pydantic V2 model: {annotation_is_pydantic_v1(BaseModel)}\")\n    print(f\"Pydantic V1 model: {annotation_is_pydantic_v1(BaseModelV1)}\")\n\ntest_v1_support()\nPY\n"
}
{"status": "ok", "stdout": "Pydantic V2 model: False\nPydantic V1 model: True\n", "stderr": "", "exit_code": 0}
full
{"status": "ok", "stdout": "Pydantic V2 model: False\nPydantic V1 model: True\n", "stderr": "", "exit_code": 0}
14run_command
{
 "command": "python3 - <<'PY'\nfrom pathlib import Path\np = Path(\"fastapi/_compat/shared.py\")\ns = p.read_text()\nold = \"\"\"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\"\"\"\nnew = \"\"\"def annotation_is_pydantic_v1(annotation: Any) -> bool:\n    return False\"\"\"\nassert s.count(old) == 1, (\"old text found this many times:\", s.count(old))\nt = s.replace(old, new)\np.write_text(t)\nPY\n"
}
{"status": "ok", "stdout": "", "stderr": "", "exit_code": 0}
full
{"status": "ok", "stdout": "", "stderr": "", "exit_code": 0}
15run_command
{
 "command": "python3 - <<'PY'\nfrom pathlib import Path\np = Path(\"fastapi/_compat/may_v1.py\")\ns = p.read_text()\n# We want to make may_v1.BaseModel always be a Pydantic V2 BaseModel (or something that doesn't trigger V1 paths)\n# Actually, if we look at may_v1.py, it imports from .v1 if sys.version_info < (3, 14).\n# If we want to drop support for pydantic.v1, we should probably make may_v1 always use .v2 or just be empty.\n\n# Let's see how may_v1 is used.\n# In fastapi/_compat/main.py:\n# if lenient_issubclass(model, may_v1.BaseModel):\n#     from fastapi._compat import v1\n#     return v1.get_model_fields(model)\n\n# If we make may_v1.BaseModel be something that is never a subclass of a model passed in,\n# then it will always go to the v2 path.\n\n# However, the task is \"Drop support for pydantic.v1\".\n# This means we should remove all the code that handles pydantic.v1.\n\n# Let's look at may_v1.py again.\nPY\n"
}
{"status": "ok", "stdout": "", "stderr": "", "exit_code": 0}
full
{"status": "ok", "stdout": "", "stderr": "", "exit_code": 0}
16run_command
{
 "command": "cat fastapi/_compat/may_v1.py"
}
{"status": "ok", "stdout": "import sys\nfrom collections.abc import Sequence\nfrom typing import Any, Literal, Union\n\nfrom fastapi.types import ModelNameMap\n
full
{"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
17run_command
{
 "command": "python3 - <<'PY'\nfrom pathlib import Path\np = Path(\"fastapi/_compat/may_v1.py\")\ns = p.read_text()\n# Replace the entire file to remove v1 imports and make everything v2-like or empty.\n# The goal is that may_v1.BaseModel is never a subclass of a model passed in.\n\nnew_content = \"\"\"import sys\nfrom collections.abc import Sequence\nfrom typing import Any, Literal, Union\n\nfrom fastapi.types import ModelNameMap\nfrom . import v2\n\nclass AnyUrl: pass\nclass BaseConfig: pass\nclass BaseModel: pass\nclass Color: pass\nclass CoreSchema: pass\nclass ErrorWrapper: pass\nclass FieldInfo: pass\nclass GetJsonSchemaHandler: pass\nclass JsonSchemaValue: pass\nclass ModelField: pass\nclass NameEmail: pass\nclass RequiredParam: pass\nclass SecretBytes: pass\nclass SecretStr: pass\nclass Undefined: pass\nclass UndefinedType: pass\nclass Url: pass\n\nValidationError = v2.ValidationError\ncreate_model = v2.create_model\n\ndef get_definitions(*, fields, model_name_map, separate_input_output_schemas=True):\n    return {}, {}\n\nRequestErrorModel: type[BaseModel] = create_model(\"Request\")\n\ndef _normalize_errors(errors: Sequence[Any]) -> list[dict[str, Any]]:\n    return []\n\ndef _regenerate_error_with_loc(*, errors, loc_prefix):\n    return []\n\"\"\"\np.write_text(new_content)\nPY\n"
}
{"status": "ok", "stdout": "", "stderr": "", "exit_code": 0}
full
{"status": "ok", "stdout": "", "stderr": "", "exit_code": 0}
18run_command
{
 "command": "python3 - <<'PY'\nfrom pathlib import Path\np = Path(\"fastapi/_compat/v1.py\")\n# We can just empty this file or remove it, but other files might import from it.\n# Let's see who imports from fastapi._compat.v1.\n# fastapi/_compat/main.py imports from .v1 inside functions.\n# fastapi/_compat/may_v1.py used to import from .v1.\n\n# If we make may_v1.BaseModel a dummy class, then fastapi/_compat/main.py will never import v1.\n# Let's check if any other file imports v1.\nPY\n"
}
{"status": "ok", "stdout": "", "stderr": "", "exit_code": 0}
full
{"status": "ok", "stdout": "", "stderr": "", "exit_code": 0}
19run_command
{
 "command": "grep -rn \"from fastapi._compat import v1\" ."
}
{"status": "ok", "stdout": "./tests/test_response_model_as_return_annotation.py:518: from fastapi._compat import v1\n./tests/test_compat.py:31: from fastapi._co
full
{"status": "ok", "stdout": "./tests/test_response_model_as_return_annotation.py:518:    from fastapi._compat import v1\n./tests/test_compat.py:31:    from fastapi._compat import v1\n./tests/test_compat.py:172:    from fastapi._compat import v1\n./tests/test_compat.py:184:    from fastapi._compat import v1\n./fastapi/utils.py:106:        from fastapi._compat import v1\n./fastapi/utils.py:127:    from fastapi._compat import v1\n./fastapi/utils.py:145:    from fastapi._compat import v1\n./fastapi/_compat/main.py:34:        from fastapi._compat import v1\n./fastapi/_compat/main.py:52:        from fastapi._compat import v1\n./fastapi/_compat/main.py:63:        from fastapi._compat import v1\n./fastapi/_compat/main.py:79:        from fastapi._compat import v1\n./fastapi/_compat/main.py:90:        from fastapi._compat import v1\n./fastapi/_compat/main.py:101:        from fastapi._compat import v1\n./fastapi/_compat/main.py:114:        from fastapi._compat import v1\n./fastapi/_compat/main.py:123:        from fastapi._compat import v1\n./fastapi/_compat/main.py:132:        from fastapi._compat import v1\n./fastapi/_compat/main.py:145:        from fastapi._compat import v1\n./fastapi/_compat/main.py:154:        from fastapi._compat import v1\n./fastapi/_compat/main.py:166:        from fastapi._compat import v1\n./fastapi/_compat/main.py:236:        from fastapi._compat import v1\n", "stderr": "", "exit_code": 0}
20run_command
{
 "command": "cat fastapi/utils.py | sed -n '100,150p'"
}
{"status": "ok", "stdout": "\n if (\n annotation_is_pydantic_v1(type_)\n or isinstance(field_info, may_v1.FieldInfo)\n or version == \"1\"\n ):\n from fastapi._
full
{"status": "ok", "stdout": "\n    if (\n        annotation_is_pydantic_v1(type_)\n        or isinstance(field_info, may_v1.FieldInfo)\n        or version == \"1\"\n    ):\n        from fastapi._compat import v1\n\n        try:\n            return v1.ModelField(**v1_kwargs)  # type: ignore[return-value]\n        except RuntimeError:\n            raise fastapi.exceptions.FastAPIError(\n                _invalid_args_message.format(type_=type_)\n            ) from None\n    else:\n        field_info = field_info or FieldInfo(\n            annotation=type_, default=default, alias=alias\n        )\n        kwargs = {\"mode\": mode, \"name\": name, \"field_info\": field_info}\n        try:\n            return v2.ModelField(**kwargs)  # type: ignore[return-value,arg-type]\n        except PydanticSchemaGenerationError:\n            raise fastapi.exceptions.FastAPIError(\n                _invalid_args_message.format(type_=type_)\n            ) from None\n    # Pydantic v2 is not installed, but it's not a Pydantic v1 ModelField, it could be\n    # a Pydantic v1 type, like a constrained int\n    from fastapi._compat import v1\n\n    try:\n        return v1.ModelField(**v1_kwargs)\n    except RuntimeError:\n        raise fastapi.exceptions.FastAPIError(\n            _invalid_args_message.format(type_=type_)\n        ) from None\n\n\ndef create_cloned_field(\n    field: ModelField,\n    *,\n    cloned_types: Optional[MutableMapping[type[BaseModel], type[BaseModel]]] = None,\n) -> ModelField:\n    if isinstance(field, v2.ModelField):\n        return field\n\n    from fastapi._compat import v1\n\n    # cloned_types caches already cloned types to support recursive models and improve\n    # performance by avoiding unnecessary cloning\n    if cloned_types is None:\n        cloned_types = _CLONED_TYPES_CACHE\n", "stderr": "", "exit_code": 0}
21run_command
{
 "command": "python3 - <<'PY'\nfrom pathlib import Path\np = Path(\"fastapi/utils.py\")\ns = p.read_text()\n\n# We need to remove the v1 paths in fastapi/utils.py.\n# This is a bit more complex because it's in multiple places.\n\n# Let's find the blocks that use v1 and replace them.\n# The first block:\n# if (\n#     annotation_is_pydantic_v1(type_)\n#     or isinstance(field_info, may_v1.FieldInfo)\n#     or version == \"1\"\n# ):\n#     from fastapi._compat import v1\n#     ...\n# else:\n#     ...\n\n# We can just remove the if and keep the else block.\n\n# Let's use a simpler approach: replace the whole if/else block.\n# But we need to be careful about the indentation.\n\n# Let's try to find the start and end of the block.\nPY\n"
}
{"status": "ok", "stdout": "", "stderr": "", "exit_code": 0}
full
{"status": "ok", "stdout": "", "stderr": "", "exit_code": 0}
22run_command
{
 "command": "sed -n '100,130p' fastapi/utils.py"
}
{"status": "ok", "stdout": "\n if (\n annotation_is_pydantic_v1(type_)\n or isinstance(field_info, may_v1.FieldInfo)\n or version == \"1\"\n ):\n from fastapi._
full
{"status": "ok", "stdout": "\n    if (\n        annotation_is_pydantic_v1(type_)\n        or isinstance(field_info, may_v1.FieldInfo)\n        or version == \"1\"\n    ):\n        from fastapi._compat import v1\n\n        try:\n            return v1.ModelField(**v1_kwargs)  # type: ignore[return-value]\n        except RuntimeError:\n            raise fastapi.exceptions.FastAPIError(\n                _invalid_args_message.format(type_=type_)\n            ) from None\n    else:\n        field_info = field_info or FieldInfo(\n            annotation=type_, default=default, alias=alias\n        )\n        kwargs = {\"mode\": mode, \"name\": name, \"field_info\": field_info}\n        try:\n            return v2.ModelField(**kwargs)  # type: ignore[return-value,arg-type]\n        except PydanticSchemaGenerationError:\n            raise fastapi.exceptions.FastAPIError(\n                _invalid_args_message.format(type_=type_)\n            ) from None\n    # Pydantic v2 is not installed, but it's not a Pydantic v1 ModelField, it could be\n    # a Pydantic v1 type, like a constrained int\n    from fastapi._compat import v1\n\n    try:\n        return v1.ModelField(**v1_kwargs)\n", "stderr": "", "exit_code": 0}
23run_command
{
 "command": "python3 - <<'PY'\nfrom pathlib import Path\np = Path(\"fastapi/utils.py\")\ns = p.read_text()\n\n# Replace the first if/else block\nold1 = \"\"\"    if (\n        annotation_is_pydantic_v1(type_)\n        or isinstance(field_info, may_v1.FieldInfo)\n        or version == \"1\"\n    ):\n        from fastapi._compat import v1\n\n        try:\n            return v1.ModelField(**v1_kwargs)  # type: ignore[return-value]\n        except RuntimeError:\n            raise fastapi.exceptions.FastAPIError(\n                _invalid_args_message.format(type_=type_)\n            ) from None\n    else:\n        field_info = field_info or FieldInfo(\n            annotation=type_, default=default, alias=alias\n        )\n        kwargs = {\"mode\": mode, \"name\": name, \"field_info\": field_info}\n        try:\n            return v2.ModelField(**kwargs)  # type: ignore[return-value,arg-type]\n        except PydanticSchemaGenerationError:\n            raise fastapi.exceptions.FastAPIError(\n                _invalid_args_message.format(type_=type_)\n            ) from None\"\"\"\n\nnew1 = \"\"\"    field_info = field_info or FieldInfo(\n        annotation=type_, default=default, alias=alias\n    )\n    kwargs = {\"mode\": mode, \"name\": name, \"field_info\": field_info}\n    try:\n        return v2.ModelField(**kwargs)  # type: ignore[return-value,arg-type]\n    except PydanticSchemaGenerationError:\n        raise fastapi.exceptions.FastAPIError(\n            _invalid_args_message.format(type_=type_)\n        ) from None\"\"\"\n\ns = s.replace(old1, new1)\n\n# Also remove the fallback v1.ModelField call\nold2 = \"\"\"    # Pydantic v2 is not installed, but it's not a Pydantic v1 ModelField, it could be\n    # a Pydantic v1 type, like a constrained int\n    from fastapi._compat import v1\n\n    try:\n        return v1.ModelField(**v1_kwargs)\n    except RuntimeError:\n        raise fastapi.exceptions.FastAPIError(\n            _invalid_args_message.format(type_=type_)\n        ) from None\"\"\"\n\n# This block is followed by a blank line or something. Let's be careful.\n# In the sed output, it's:\n#     # Pydantic v2 is not installed, but it's not a Pydantic v1 ModelField, it could be\n#     # a Pydantic v1 type, like a constrained int\n#     from fastapi._compat import v1\n# \n#     try:\n#         return v1.ModelField(**v1_kwargs)\n#     except RuntimeError:\n#         raise fastapi.exceptions.FastAPIError(\n#             _invalid_args_message.format(type_=type_)\n#         ) from None\n\n# Let's just replace it with nothing.\ns = s.replace(old2, \"\")\n\np.write_text(s)\nPY\n"
}
{"status": "ok", "stdout": "", "stderr": "", "exit_code": 0}
full
{"status": "ok", "stdout": "", "stderr": "", "exit_code": 0}
24run_command
{
 "command": "python3 - <<'PY'\nfrom pathlib import Path\np = Path(\"fastapi/utils.py\")\ns = p.read_text()\n\n# Remove the v1 import in create_cloned_field\nold = \"\"\"    from fastapi._compat import v1\n\n    # cloned_types caches already cloned types to support recursive models and improve\n    # performance by avoiding unnecessary cloning\"\"\"\nnew = \"\"\"    # cloned_types caches already cloned types to support recursive models and improve\n    # performance by avoiding unnecessary cloning\"\"\"\ns = s.replace(old, new)\np.write_text(s)\nPY\n"
}
{"status": "ok", "stdout": "", "stderr": "", "exit_code": 0}
full
{"status": "ok", "stdout": "", "stderr": "", "exit_code": 0}
25run_command
{
 "command": "python3 - <<'PY'\nfrom pathlib import Path\np = Path(\"fastapi/utils.py\")\ns = p.read_text()\n\n# There might be more v1 imports in fastapi/utils.py.\n# Let's check for \"from fastapi._compat import v1\"\nimport re\nv1_imports = re.findall(r\"from fastapi._compat import v1\", s)\nprint(f\"Remaining v1 imports: {len(v1_imports)}\")\nPY\n"
}
{"status": "ok", "stdout": "Remaining v1 imports: 0\n", "stderr": "", "exit_code": 0}
full
{"status": "ok", "stdout": "Remaining v1 imports: 0\n", "stderr": "", "exit_code": 0}
26run_command
{
 "command": "python3 - <<'PY'\nfrom pathlib import Path\np = Path(\"fastapi/routing.py\")\ns = p.read_text()\n\n# Remove temp_pydantic_v1_params from imports\nold = \"from fastapi import params, temp_pydantic_v1_params\"\nnew = \"from fastapi import params\"\ns = s.replace(old, new)\n\n# Remove annotation_is_pydantic_v1 from imports\n# It's on line 32: annotation_is_pydantic_v1,\n# Let's find the block.\n# fastapi/routing.py:32:    annotation_is_pydantic_v1,\n\n# Let's just use regex to remove it from the import list.\nimport re\ns = re.sub(r\"    annotation_is_pydantic_v1,\\n\", \"\", s)\n\n# Remove the v1 check in response_model\n# fastapi/routing.py:640:            if annotation_is_pydantic_v1(self.response_model):\n# fastapi/routing.py:642:                    \"pydantic.v1 is deprecated and will soon stop being supported by FastAPI.\"\n\n# This is a bit harder. Let's find the block.\nPY\n"
}
{"status": "ok", "stdout": "", "stderr": "", "exit_code": 0}
full
{"status": "ok", "stdout": "", "stderr": "", "exit_code": 0}
27run_command
{
 "command": "sed -n '630,650p' fastapi/routing.py"
}
{"status": "ok", "stdout": " self.unique_id = self.operation_id or current_generate_unique_id(self)\n # normalize enums e.g. http.HTTPStatus\n if isinstance(sta
full
{"status": "ok", "stdout": "        self.unique_id = self.operation_id or current_generate_unique_id(self)\n        # normalize enums e.g. http.HTTPStatus\n        if isinstance(status_code, IntEnum):\n            status_code = int(status_code)\n        self.status_code = status_code\n        if self.response_model:\n            assert is_body_allowed_for_status_code(status_code), (\n                f\"Status code {status_code} must not have a response body\"\n            )\n            response_name = \"Response_\" + self.unique_id\n            if annotation_is_pydantic_v1(self.response_model):\n                warnings.warn(\n                    \"pydantic.v1 is deprecated and will soon stop being supported by FastAPI.\"\n                    f\" Please update the response model {self.response_model!r}.\",\n                    category=FastAPIDeprecationWarning,\n                    stacklevel=4,\n                )\n            self.response_field = create_model_field(\n                name=response_name,\n                type_=self.response_model,\n                mode=\"serialization\",\n", "stderr": "", "exit_code": 0}
28run_command
{
 "command": "python3 - <<'PY'\nfrom pathlib import Path\np = Path(\"fastapi/routing.py\")\ns = p.read_text()\n\nold = \"\"\"            if annotation_is_pydantic_v1(self.response_model):\n                warnings.warn(\n                    \"pydantic.v1 is deprecated and will soon stop being supported by FastAPI.\"\n                    f\" Please update the response model {self.response_model!r}.\",\n                    category=FastAPIDeprecationWarning,\n                    stacklevel=4,\n                )\"\"\"\nnew = \"\"\ns = s.replace(old, new)\np.write_text(s)\nPY\n"
}
{"status": "ok", "stdout": "", "stderr": "", "exit_code": 0}
full
{"status": "ok", "stdout": "", "stderr": "", "exit_code": 0}
29run_command
{
 "command": "sed -n '670,690p' fastapi/routing.py"
}
{"status": "ok", "stdout": " assert is_body_allowed_for_status_code(additional_status_code), (\n f\"Status code {additional_status_code} must not have a respons
full
{"status": "ok", "stdout": "                assert is_body_allowed_for_status_code(additional_status_code), (\n                    f\"Status code {additional_status_code} must not have a response body\"\n                )\n                response_name = f\"Response_{additional_status_code}_{self.unique_id}\"\n                if annotation_is_pydantic_v1(model):\n                    warnings.warn(\n                        \"pydantic.v1 is deprecated and will soon stop being supported by FastAPI.\"\n                        f\" In responses={{}}, please update {model}.\",\n                        category=FastAPIDeprecationWarning,\n                        stacklevel=4,\n                    )\n                response_field = create_model_field(\n                    name=response_name, type_=model, mode=\"serialization\"\n                )\n                response_fields[additional_status_code] = response_field\n        if response_fields:\n            self.response_fields: dict[Union[int, str], ModelField] = response_fields\n        else:\n            self.response_fields = {}\n\n        assert callable(endpoint), \"An endpoint must be a callable\"\n", "stderr": "", "exit_code": 0}
30run_command
{
 "command": "python3 - <<'PY'\nfrom pathlib import Path\np = Path(\"fastapi/routing.py\")\ns = p.read_text()\n\nold = \"\"\"                if annotation_is_pydantic_v1(model):\n                    warnings.warn(\n                        \"pydantic.v1 is deprecated and will soon stop being supported by FastAPI.\"\n                        f\" In responses={{}}, please update {model}.\",\n                        category=FastAPIDeprecationWarning,\n                        stacklevel=4,\n                    )\"\"\"\nnew = \"\"\ns = s.replace(old, new)\np.write_text(s)\nPY\n"
}
{"status": "ok", "stdout": "", "stderr": "", "exit_code": 0}
full
{"status": "ok", "stdout": "", "stderr": "", "exit_code": 0}

Patch

diff --git a/fastapi/_compat/may_v1.py b/fastapi/_compat/may_v1.py
index 3ac86aa9..b0fac7a8 100644
--- a/fastapi/_compat/may_v1.py
+++ b/fastapi/_compat/may_v1.py
@@ -3,122 +3,36 @@ from collections.abc import Sequence
 from typing import Any, Literal, Union
 
 from fastapi.types import ModelNameMap
-
-if sys.version_info >= (3, 14):
-
-    class AnyUrl:
-        pass
-
-    class BaseConfig:
-        pass
-
-    class BaseModel:
-        pass
-
-    class Color:
-        pass
-
-    class CoreSchema:
-        pass
-
-    class ErrorWrapper:
-        pass
-
-    class FieldInfo:
-        pass
-
-    class GetJsonSchemaHandler:
-        pass
-
-    class JsonSchemaValue:
-        pass
-
-    class ModelField:
-        pass
-
-    class NameEmail:
-        pass
-
-    class RequiredParam:
-        pass
-
-    class SecretBytes:
-        pass
-
-    class SecretStr:
-        pass
-
-    class Undefined:
-        pass
-
-    class UndefinedType:
-        pass
-
-    class Url:
-        pass
-
-    from .v2 import ValidationError, create_model
-
-    def get_definitions(
-        *,
-        fields: list[ModelField],
-        model_name_map: ModelNameMap,
-        separate_input_output_schemas: bool = True,
-    ) -> tuple[
-        dict[
-            tuple[ModelField, Literal["validation", "serialization"]], JsonSchemaValue
-        ],
-        dict[str, dict[str, Any]],
-    ]:
-        return {}, {}  # pragma: no cover
-
-
-else:
-    from .v1 import AnyUrl as AnyUrl
-    from .v1 import BaseConfig as BaseConfig
-    from .v1 import BaseModel as BaseModel
-    from .v1 import Color as Color
-    from .v1 import CoreSchema as CoreSchema
-    from .v1 import ErrorWrapper as ErrorWrapper
-    from .v1 import FieldInfo as FieldInfo
-    from .v1 import GetJsonSchemaHandler as GetJsonSchemaHandler
-    from .v1 import JsonSchemaValue as JsonSchemaValue
-    from .v1 import ModelField as ModelField
-    from .v1 import NameEmail as NameEmail
-    from .v1 import RequiredParam as RequiredParam
-    from .v1 import SecretBytes as SecretBytes
-    from .v1 import SecretStr as SecretStr
-    from .v1 import Undefined as Undefined
-    from .v1 import UndefinedType as UndefinedType
-    from .v1 import Url as Url
-    from .v1 import ValidationError, create_model
-    from .v1 import get_definitions as get_definitions
-
+from . import v2
+
+class AnyUrl: pass
+class BaseConfig: pass
+class BaseModel: pass
+class Color: pass
+class CoreSchema: pass
+class ErrorWrapper: pass
+class FieldInfo: pass
+class GetJsonSchemaHandler: pass
+class JsonSchemaValue: pass
+class ModelField: pass
+class NameEmail: pass
+class RequiredParam: pass
+class SecretBytes: pass
+class SecretStr: pass
+class Undefined: pass
+class UndefinedType: pass
+class Url: pass
+
+ValidationError = v2.ValidationError
+create_model = v2.create_model
+
+def get_definitions(*, fields, model_name_map, separate_input_output_schemas=True):
+    return {}, {}
 
 RequestErrorModel: type[BaseModel] = create_model("Request")
 
-
 def _normalize_errors(errors: Sequence[Any]) -> list[dict[str, Any]]:
-    use_errors: list[Any] = []
-    for error in errors:
-        if isinstance(error, ErrorWrapper):
-            new_errors = ValidationError(
-                errors=[error], model=RequestErrorModel
-            ).errors()
-            use_errors.extend(new_errors)
-        elif isinstance(error, list):
-            use_errors.extend(_normalize_errors(error))
-        else:
-            use_errors.append(error)
-    return use_errors
-
-
-def _regenerate_error_with_loc(
-    *, errors: Sequence[Any], loc_prefix: tuple[Union[str, int], ...]
-) -> list[dict[str, Any]]:
-    updated_loc_errors: list[Any] = [
-        {**err, "loc": loc_prefix + err.get("loc", ())}
-        for err in _normalize_errors(errors)
-    ]
+    return []
 
-    return updated_loc_errors
+def _regenerate_error_with_loc(*, errors, loc_prefix):
+    return []
diff --git a/fastapi/_compat/shared.py b/fastapi/_compat/shared.py
index 3a11e88a..3910c059 100644
--- a/fastapi/_compat/shared.py
+++ b/fastapi/_compat/shared.py
@@ -180,15 +180,4 @@ def is_uploadfile_sequence_annotation(annotation: Any) -> bool:
 
 
 def annotation_is_pydantic_v1(annotation: Any) -> bool:
-    if lenient_issubclass(annotation, may_v1.BaseModel):
-        return True
-    origin = get_origin(annotation)
-    if origin is Union or origin is UnionType:
-        for arg in get_args(annotation):
-            if lenient_issubclass(arg, may_v1.BaseModel):
-                return True
-    if field_annotation_is_sequence(annotation):
-        for sub_annotation in get_args(annotation):
-            if annotation_is_pydantic_v1(sub_annotation):
-                return True
     return False
diff --git a/fastapi/routing.py b/fastapi/routing.py
index 3f78e93e..01909bcf 100644
--- a/fastapi/routing.py
+++ b/fastapi/routing.py
@@ -637,13 +637,7 @@ class APIRoute(routing.Route):
                 f"Status code {status_code} must not have a response body"
             )
             response_name = "Response_" + self.unique_id
-            if annotation_is_pydantic_v1(self.response_model):
-                warnings.warn(
-                    "pydantic.v1 is deprecated and will soon stop being supported by FastAPI."
-                    f" Please update the response model {self.response_model!r}.",
-                    category=FastAPIDeprecationWarning,
-                    stacklevel=4,
-                )
+
             self.response_field = create_model_field(
                 name=response_name,
                 type_=self.response_model,
@@ -677,13 +671,7 @@ class APIRoute(routing.Route):
                     f"Status code {additional_status_code} must not have a response body"
                 )
                 response_name = f"Response_{additional_status_code}_{self.unique_id}"
-                if annotation_is_pydantic_v1(model):
-                    warnings.warn(
-                        "pydantic.v1 is deprecated and will soon stop being supported by FastAPI."
-                        f" In responses={{}}, please update {model}.",
-                        category=FastAPIDeprecationWarning,
-                        stacklevel=4,
-                    )
+
                 response_field = create_model_field(
                     name=response_name, type_=model, mode="serialization"
                 )
diff --git a/fastapi/utils.py b/fastapi/utils.py
index 8ae50aa1..504a32f5 100644
--- a/fastapi/utils.py
+++ b/fastapi/utils.py
@@ -98,42 +98,19 @@ def create_model_field(
         "alias": alias,
     }
 
-    if (
-        annotation_is_pydantic_v1(type_)
-        or isinstance(field_info, may_v1.FieldInfo)
-        or version == "1"
-    ):
-        from fastapi._compat import v1
-
-        try:
-            return v1.ModelField(**v1_kwargs)  # type: ignore[return-value]
-        except RuntimeError:
-            raise fastapi.exceptions.FastAPIError(
-                _invalid_args_message.format(type_=type_)
-            ) from None
-    else:
-        field_info = field_info or FieldInfo(
-            annotation=type_, default=default, alias=alias
-        )
-        kwargs = {"mode": mode, "name": name, "field_info": field_info}
-        try:
-            return v2.ModelField(**kwargs)  # type: ignore[return-value,arg-type]
-        except PydanticSchemaGenerationError:
-            raise fastapi.exceptions.FastAPIError(
-                _invalid_args_message.format(type_=type_)
-            ) from None
-    # Pydantic v2 is not installed, but it's not a Pydantic v1 ModelField, it could be
-    # a Pydantic v1 type, like a constrained int
-    from fastapi._compat import v1
-
+    field_info = field_info or FieldInfo(
+        annotation=type_, default=default, alias=alias
+    )
+    kwargs = {"mode": mode, "name": name, "field_info": field_info}
     try:
-        return v1.ModelField(**v1_kwargs)
-    except RuntimeError:
+        return v2.ModelField(**kwargs)  # type: ignore[return-value,arg-type]
+    except PydanticSchemaGenerationError:
         raise fastapi.exceptions.FastAPIError(
             _invalid_args_message.format(type_=type_)
         ) from None
 
 
+
 def create_cloned_field(
     field: ModelField,
     *,
@@ -142,8 +119,6 @@ def create_cloned_field(
     if isinstance(field, v2.ModelField):
         return field
 
-    from fastapi._compat import v1
-
     # cloned_types caches already cloned types to support recursive models and improve
     # performance by avoiding unnecessary cloning
     if cloned_types is None:

Test output

show
==================================== ERRORS ====================================
_______________ ERROR collecting tests/test_jsonable_encoder.py ________________
ImportError while importing test module '/private/tmp/swe_work/pod_r3_v1g/fastapi_14609/b/workspace/tests/test_jsonable_encoder.py'.
Hint: make sure your test modules/packages have valid Python names.
Traceback:
/Users/jp/.local/share/uv/python/cpython-3.13.15-macos-aarch64-none/lib/python3.13/importlib/__init__.py:88: in import_module
    return _bootstrap._gcd_import(name[level:], package, level)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
tests/test_jsonable_encoder.py:14: in <module>
    from fastapi.exceptions import PydanticV1NotSupportedError
E   ImportError: cannot import name 'PydanticV1NotSupportedError' from 'fastapi.exceptions' (/private/tmp/swe_work/pod_r3_v1g/fastapi_14609/b/workspace/fastapi/exceptions.py)
=============================== warnings summary ===============================
../../../../../../../Users/jp/repos/kaggle-gemini-coding-agent-post-training/.envs/overlays/starlette-0.50.0-py3-none-any/starlette/testclient.py:45
  /Users/jp/repos/kaggle-gemini-coding-agent-post-training/.envs/overlays/starlette-0.50.0-py3-none-any/starlette/testclient.py:45: DeprecationWarning: The anyio.abc.BlockingPortal alias is deprecated, use anyio.from_thread.BlockingPortal instead.
    _PortalFactoryType = Callable[[], AbstractContextManager[anyio.abc.BlockingPortal]]

-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!!!!!!!!!! Interrupted: 1 error during collection !!!!!!!!!!!!!!!!!!!!
1 warning, 1 error in 0.49s