♻️ Cleanup more functions and unused code

fastapi/_compat/__init__.py

@@ -16,7 +16,6 @@ from .main import evaluate_forwardref as evaluate_forwardref
 from .main import get_annotation_from_field_info as get_annotation_from_field_info
 from .main import get_cached_model_fields as get_cached_model_fields
 from .main import get_compat_model_name_map as get_compat_model_name_map
-from .main import get_definitions as get_definitions
 from .main import get_missing_field_error as get_missing_field_error
 from .main import get_schema_from_model_field as get_schema_from_model_field
 from .main import is_bytes_field as is_bytes_field
@@ -28,7 +27,6 @@ from .main import serialize_sequence_value as serialize_sequence_value
 from .main import (
     with_info_plain_validator_function as with_info_plain_validator_function,
 )
-from .may_v1 import _normalize_errors as _normalize_errors
 from .shared import PYDANTIC_V2 as PYDANTIC_V2
 from .shared import PYDANTIC_VERSION_MINOR_TUPLE as PYDANTIC_VERSION_MINOR_TUPLE
 from .shared import annotation_is_pydantic_v1 as annotation_is_pydantic_v1
@@ -43,3 +41,4 @@ from .shared import lenient_issubclass as lenient_issubclass
 from .shared import sequence_types as sequence_types
 from .shared import value_is_sequence as value_is_sequence
 from .v2 import ModelField as ModelField
+from .v2 import get_definitions as get_definitions

fastapi/_compat/main.py

@@ -1,11 +1,9 @@
-import sys
 from collections.abc import Sequence
 from functools import lru_cache
 from typing import (
     Any,
 )
 
-from fastapi._compat import may_v1
 from fastapi._compat.shared import lenient_issubclass
 from fastapi.types import ModelNameMap
 from pydantic import BaseModel
@@ -101,37 +99,6 @@ def get_compat_model_name_map(fields: list[ModelField]) -> ModelNameMap:
     return model_name_map
 
 
-def get_definitions(
-    *,
-    fields: list[ModelField],
-    model_name_map: ModelNameMap,
-    separate_input_output_schemas: bool = True,
-) -> tuple[
-    dict[tuple[ModelField, Literal["validation", "serialization"]], dict[str, Any]],
-    dict[str, dict[str, Any]],
-]:
-    if sys.version_info < (3, 14):
-        v2_fields = [field for field in fields if isinstance(field, v2.ModelField)]
-        v2_field_maps, v2_definitions = v2.get_definitions(
-            fields=v2_fields,
-            model_name_map=model_name_map,
-            separate_input_output_schemas=separate_input_output_schemas,
-        )
-        all_definitions = {**v2_definitions}
-        all_field_maps = {**v2_field_maps}  # type: ignore[misc]
-        return all_field_maps, all_definitions
-
-    # Pydantic v1 is not supported since Python 3.14
-    else:
-        v2_fields = [field for field in fields if isinstance(field, v2.ModelField)]
-        v2_field_maps, v2_definitions = v2.get_definitions(
-            fields=v2_fields,
-            model_name_map=model_name_map,
-            separate_input_output_schemas=separate_input_output_schemas,
-        )
-        return v2_field_maps, v2_definitions
-
-
 def get_schema_from_model_field(
     *,
     field: ModelField,
@@ -151,14 +118,8 @@ def get_schema_from_model_field(
 
 
 def _is_model_field(value: Any) -> bool:
-    if isinstance(value, may_v1.ModelField):
-        return True
-
     return isinstance(value, v2.ModelField)
 
 
 def _is_model_class(value: Any) -> bool:
-    if lenient_issubclass(value, may_v1.BaseModel):
-        return True
-
     return lenient_issubclass(value, v2.BaseModel)  # type: ignore[attr-defined]

fastapi/_compat/may_v1.py

@@ -5,22 +5,11 @@ from pydantic.v1 import BaseModel as BaseModel
 from pydantic.v1.fields import ModelField as ModelField
 
 
-def _normalize_errors(errors: Sequence[Any]) -> list[dict[str, Any]]:
-    use_errors: list[Any] = []
-    for error in errors:
-        if 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)
+        {**err, "loc": loc_prefix + err.get("loc", ())} for err in errors
     ]
 
     return updated_loc_errors

fastapi/routing.py

@@ -25,7 +25,6 @@ from fastapi import params
 from fastapi._compat import (
     ModelField,
     Undefined,
-    _normalize_errors,
     annotation_is_pydantic_v1,
     lenient_issubclass,
 )
@@ -214,7 +213,7 @@ async def serialize_response(
         if errors:
             ctx = endpoint_ctx or EndpointContext()
             raise ResponseValidationError(
-                errors=_normalize_errors(errors),
+                errors=errors,
                 body=response_content,
                 endpoint_ctx=ctx,
             )
@@ -393,7 +392,7 @@ def get_request_handler(
                 response.headers.raw.extend(solved_result.response.headers.raw)
         if errors:
             validation_error = RequestValidationError(
-                _normalize_errors(errors), body=body, endpoint_ctx=endpoint_ctx
+                errors, body=body, endpoint_ctx=endpoint_ctx
             )
             raise validation_error
 
@@ -432,7 +431,7 @@ def get_websocket_app(
         )
         if solved_result.errors:
             raise WebSocketRequestValidationError(
-                _normalize_errors(solved_result.errors),
+                solved_result.errors,
                 endpoint_ctx=endpoint_ctx,
             )
         assert dependant.call is not None, "dependant.call must be a function"