增加环绕侦察场景适配

backend_service/venv/lib/python3.13/site-packages/fastapi/utils.py

@@ -1,22 +1,16 @@
 import re
 import warnings
-from dataclasses import is_dataclass
+from collections.abc import MutableMapping
 from typing import (
     TYPE_CHECKING,
     Any,
-    Dict,
-    MutableMapping,
     Optional,
-    Set,
-    Type,
     Union,
-    cast,
 )
 from weakref import WeakKeyDictionary
 
 import fastapi
 from fastapi._compat import (
-    PYDANTIC_V2,
     BaseConfig,
     ModelField,
     PydanticSchemaGenerationError,
@@ -24,19 +18,20 @@ from fastapi._compat import (
     UndefinedType,
     Validator,
     annotation_is_pydantic_v1,
-    lenient_issubclass,
-    may_v1,
 )
 from fastapi.datastructures import DefaultPlaceholder, DefaultType
+from fastapi.exceptions import FastAPIDeprecationWarning, PydanticV1NotSupportedError
 from pydantic import BaseModel
 from pydantic.fields import FieldInfo
 from typing_extensions import Literal
 
+from ._compat import v2
+
 if TYPE_CHECKING:  # pragma: nocover
     from .routing import APIRoute
 
 # Cache for `create_cloned_field`
-_CLONED_TYPES_CACHE: MutableMapping[Type[BaseModel], Type[BaseModel]] = (
+_CLONED_TYPES_CACHE: MutableMapping[type[BaseModel], type[BaseModel]] = (
     WeakKeyDictionary()
 )
 
@@ -58,7 +53,7 @@ def is_body_allowed_for_status_code(status_code: Union[int, str, None]) -> bool:
     return not (current_status_code < 200 or current_status_code in {204, 205, 304})
 
 
-def get_path_param_names(path: str) -> Set[str]:
+def get_path_param_names(path: str) -> set[str]:
     return set(re.findall("{(.*?)}", path))
 
 
@@ -76,132 +71,47 @@ _invalid_args_message = (
 def create_model_field(
     name: str,
     type_: Any,
-    class_validators: Optional[Dict[str, Validator]] = None,
+    class_validators: Optional[dict[str, Validator]] = None,
     default: Optional[Any] = Undefined,
     required: Union[bool, UndefinedType] = Undefined,
-    model_config: Union[Type[BaseConfig], None] = None,
+    model_config: Union[type[BaseConfig], None] = None,
     field_info: Optional[FieldInfo] = None,
     alias: Optional[str] = None,
     mode: Literal["validation", "serialization"] = "validation",
     version: Literal["1", "auto"] = "auto",
 ) -> ModelField:
+    if annotation_is_pydantic_v1(type_):
+        raise PydanticV1NotSupportedError(
+            "pydantic.v1 models are no longer supported by FastAPI."
+            f" Please update the response model {type_!r}."
+        )
     class_validators = class_validators or {}
 
-    v1_model_config = may_v1.BaseConfig
-    v1_field_info = field_info or may_v1.FieldInfo()
-    v1_kwargs = {
-        "name": name,
-        "field_info": v1_field_info,
-        "type_": type_,
-        "class_validators": class_validators,
-        "default": default,
-        "required": required,
-        "model_config": v1_model_config,
-        "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[no-any-return]
-        except RuntimeError:
-            raise fastapi.exceptions.FastAPIError(_invalid_args_message) from None
-    elif PYDANTIC_V2:
-        from ._compat import v2
-
-        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) 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)  # type: ignore[no-any-return]
-    except RuntimeError:
-        raise fastapi.exceptions.FastAPIError(_invalid_args_message) from None
+        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,
     *,
-    cloned_types: Optional[MutableMapping[Type[BaseModel], Type[BaseModel]]] = None,
+    cloned_types: Optional[MutableMapping[type[BaseModel], type[BaseModel]]] = None,
 ) -> ModelField:
-    if PYDANTIC_V2:
-        from ._compat import v2
-
-        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:
-        cloned_types = _CLONED_TYPES_CACHE
-
-    original_type = field.type_
-    if is_dataclass(original_type) and hasattr(original_type, "__pydantic_model__"):
-        original_type = original_type.__pydantic_model__
-    use_type = original_type
-    if lenient_issubclass(original_type, v1.BaseModel):
-        original_type = cast(Type[v1.BaseModel], original_type)
-        use_type = cloned_types.get(original_type)
-        if use_type is None:
-            use_type = v1.create_model(original_type.__name__, __base__=original_type)
-            cloned_types[original_type] = use_type
-            for f in original_type.__fields__.values():
-                use_type.__fields__[f.name] = create_cloned_field(
-                    f,
-                    cloned_types=cloned_types,
-                )
-    new_field = create_model_field(name=field.name, type_=use_type, version="1")
-    new_field.has_alias = field.has_alias  # type: ignore[attr-defined]
-    new_field.alias = field.alias  # type: ignore[misc]
-    new_field.class_validators = field.class_validators  # type: ignore[attr-defined]
-    new_field.default = field.default  # type: ignore[misc]
-    new_field.default_factory = field.default_factory  # type: ignore[attr-defined]
-    new_field.required = field.required  # type: ignore[misc]
-    new_field.model_config = field.model_config  # type: ignore[attr-defined]
-    new_field.field_info = field.field_info
-    new_field.allow_none = field.allow_none  # type: ignore[attr-defined]
-    new_field.validate_always = field.validate_always  # type: ignore[attr-defined]
-    if field.sub_fields:  # type: ignore[attr-defined]
-        new_field.sub_fields = [  # type: ignore[attr-defined]
-            create_cloned_field(sub_field, cloned_types=cloned_types)
-            for sub_field in field.sub_fields  # type: ignore[attr-defined]
-        ]
-    if field.key_field:  # type: ignore[attr-defined]
-        new_field.key_field = create_cloned_field(  # type: ignore[attr-defined]
-            field.key_field,  # type: ignore[attr-defined]
-            cloned_types=cloned_types,
-        )
-    new_field.validators = field.validators  # type: ignore[attr-defined]
-    new_field.pre_validators = field.pre_validators  # type: ignore[attr-defined]
-    new_field.post_validators = field.post_validators  # type: ignore[attr-defined]
-    new_field.parse_json = field.parse_json  # type: ignore[attr-defined]
-    new_field.shape = field.shape  # type: ignore[attr-defined]
-    new_field.populate_validators()  # type: ignore[attr-defined]
-    return new_field
+    return field
 
 
 def generate_operation_id_for_path(
     *, name: str, path: str, method: str
 ) -> str:  # pragma: nocover
     warnings.warn(
-        "fastapi.utils.generate_operation_id_for_path() was deprecated, "
+        message="fastapi.utils.generate_operation_id_for_path() was deprecated, "
         "it is not used internally, and will be removed soon",
-        DeprecationWarning,
+        category=FastAPIDeprecationWarning,
         stacklevel=2,
     )
     operation_id = f"{name}{path}"
@@ -218,7 +128,7 @@ def generate_unique_id(route: "APIRoute") -> str:
     return operation_id
 
 
-def deep_dict_update(main_dict: Dict[Any, Any], update_dict: Dict[Any, Any]) -> None:
+def deep_dict_update(main_dict: dict[Any, Any], update_dict: dict[Any, Any]) -> None:
     for key, value in update_dict.items():
         if (
             key in main_dict