fastapi_14186

{"status": "ok", "stdout": "fastapi/dependencies/utils.py:51:from fastapi._compat.shared import annotation_is_pydantic_v1\nfastapi/dependencies/utils.py:79:from .. import temp_pydantic_v1_params\nfastapi/dependencies/utils.py:323:            param_details.field.field_info, (params.Body, temp_pydantic_v1_params.Body)\nfastapi/dependencies/utils.py:392:                    temp_pydantic_v1_params.Param,\nfastapi/dependencies/utils.py:394:                    temp_pydantic_v1_params.Body,\nfastapi/dependencies/utils.py:483:            if annotation_is_pydantic_v1(use_annotation):\nfastapi/dependencies/utils.py:484:                field_info = temp_pydantic_v1_params.Body(\nfastapi/dependencies/utils.py:500:                field_info, (params.Path, temp_pydantic_v1_params.Path)\nfastapi/dependencies/utils.py:506:            isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param))\nfastapi/dependencies/utils.py:515:        if isinstance(field_info, (params.Form, temp_pydantic_v1_params.Form)):\nfastapi/dependencies/utils.py:534:        elif isinstance(field_info, (params.Query, temp_pydantic_v1_params.Query)):\nfastapi/dependencies/utils.py:761:            isinstance(field.field_info, (params.Form, temp_pydantic_v1_params.Form))\nfastapi/dependencies/utils.py:827:        assert isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param)), (\nfastapi/dependencies/utils.py:839:        assert isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param)), (\nfastapi/dependencies/utils.py:888:        isinstance(first_field.field_info, (params.Form, temp_pydantic_v1_params.Form))\nfastapi/dependencies/utils.py:906:            isinstance(field_info, (params.File, temp_pydantic_v1_params.File))\nfastapi/dependencies/utils.py:913:            and isinstance(field_info, (params.File, temp_pydantic_v1_params.File))\nfastapi/dependencies/utils.py:1020:        isinstance(f.field_info, temp_pydantic_v1_params.File)\nfastapi/dependencies/utils.py:1023:       

{"status": "ok", "stdout": "fastapi/dependencies/utils.py:79:from .. import temp_pydantic_v1_params\nfastapi/dependencies/utils.py:323:            param_details.field.field_info, (params.Body, temp_pydantic_v1_params.Body)\nfastapi/dependencies/utils.py:392:                    temp_pydantic_v1_params.Param,\nfastapi/dependencies/utils.py:394:                    temp_pydantic_v1_params.Body,\nfastapi/dependencies/utils.py:484:                field_info = temp_pydantic_v1_params.Body(\nfastapi/dependencies/utils.py:500:                field_info, (params.Path, temp_pydantic_v1_params.Path)\nfastapi/dependencies/utils.py:506:            isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param))\nfastapi/dependencies/utils.py:515:        if isinstance(field_info, (params.Form, temp_pydantic_v1_params.Form)):\nfastapi/dependencies/utils.py:534:        elif isinstance(field_info, (params.Query, temp_pydantic_v1_params.Query)):\nfastapi/dependencies/utils.py:761:            isinstance(field.field_info, (params.Form, temp_pydantic_v1_params.Form))\nfastapi/dependencies/utils.py:827:        assert isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param)), (\nfastapi/dependencies/utils.py:839:        assert isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param)), (\nfastapi/dependencies/utils.py:888:        isinstance(first_field.field_info, (params.Form, temp_pydantic_v1_params.Form))\nfastapi/dependencies/utils.py:906:            isinstance(field_info, (params.File, temp_pydantic_v1_params.File))\nfastapi/dependencies/utils.py:913:            and isinstance(field_info, (params.File, temp_pydantic_v1_params.File))\nfastapi/dependencies/utils.py:1020:        isinstance(f.field_info, temp_pydantic_v1_params.File)\nfastapi/dependencies/utils.py:1023:        BodyFieldInfo: Type[temp_pydantic_v1_params.Body] = temp_pydantic_v1_params.File  # type: ignore[no-redef]\nfastapi/dependencies/utils.py:1027:        isinstance(f.field_info, temp_pydant

{"status": "ok", "stdout": "fastapi/__init__.py\n", "stderr": "", "exit_code": 0}

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

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

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

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

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

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

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

{"status": "ok", "stdout": "    from pydantic.v1.schema import (\n        field_schema,\n        get_flat_models_from_fields,\n        model_process_schema,\n    )\n    from pydantic.v1.schema import (\n        get_annotation_from_field_info as get_annotation_from_field_info,\n    )\n    from pydantic.v1.schema import (\n        get_flat_models_from_field as get_flat_models_from_field,\n    )\n    from pydantic.v1.schema import get_model_name_map as get_model_name_map\n    from pydantic.v1.types import (  # type: ignore[assignment]\n        SecretBytes as SecretBytes,\n    )\n    from pydantic.v1.types import (  # type: ignore[assignment]\n        SecretStr as SecretStr,\n    )\n    from pydantic.v1.typing import evaluate_forwardref as evaluate_forwardref\n    from pydantic.v1.utils import lenient_issubclass as lenient_issubclass\n\n\nGetJsonSchemaHandler = Any\nJsonSchemaValue = Dict[str, Any]\nCoreSchema = Any\nUrl = AnyUrl\n\nsequence_shapes = {\n    SHAPE_LIST,\n    SHAPE_SET,\n    SHAPE_FROZENSET,\n    SHAPE_TUPLE,\n    SHAPE_SEQUENCE,\n    SHAPE_TUPLE_ELLIPSIS,\n}\nsequence_shape_to_type = {\n    SHAPE_LIST: list,\n    SHAPE_SET: set,\n    SHAPE_TUPLE: tuple,\n    SHAPE_SEQUENCE: list,\n    SHAPE_TUPLE_ELLIPSIS: list,\n}\n\n\n@dataclass\nclass GenerateJsonSchema:\n    ref_template: str\n\n\nclass PydanticSchemaGenerationError(Exception):\n    pass\n\n\nRequestErrorModel: Type[BaseModel] = create_model(\"Request\")\n\n\ndef with_info_plain_validator_function(\n    function: Callable[..., Any],\n    *,\n    ref: Union[str, None] = None,\n    metadata: Any = None,\n    serialization: Any = None,\n) -> Any:\n    return {}\n\n\ndef get_model_definitions(\n    *,\n    flat_models: Set[Union[Type[BaseModel], Type[Enum]]],\n    model_name_map: Dict[Union[Type[BaseModel], Type[Enum]], str],\n) -> Dict[str, Any]:\n    definitions: Dict[str, Dict[str, Any]] = {}\n    for model in flat_models:\n        m_schema, m_definitions, m_nested_models = model_process_schema(\n    

{"status": "ok", "stdout": "42:PYDANTIC_VERSION_MINOR_TUPLE = tuple(int(x) for x in PYDANTIC_VERSION.split(\".\")[:2])\n43:PYDANTIC_V2 = PYDANTIC_VERSION_MINOR_TUPLE[0] == 2\n44-\n45-\n46-sequence_annotation_to_type = {\n47-    Sequence: list,\n48-    List: list,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "22:PYDANTIC_VERSION_MINOR_TUPLE = tuple(int(x) for x in PYDANTIC_VERSION.split(\".\")[:2])\n23:PYDANTIC_V2 = PYDANTIC_VERSION_MINOR_TUPLE[0] == 2\n24-# Keeping old \"Required\" functionality from Pydantic V1, without\n25-# shadowing typing.Required.\n26-RequiredParam: Any = Ellipsis\n27-\n28-if not PYDANTIC_V2:\n", "stderr": "", "exit_code": 0}

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

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

{"status": "ok", "stdout": "from typing_extensions import Literal\n\nPYDANTIC_VERSION_MINOR_TUPLE = tuple(int(x) for x in PYDANTIC_VERSION.split(\".\")[:2])\nPYDANTIC_V2 = PYDANTIC_VERSION_MINOR_TUPLE[0] == 2\n# Keeping old \"Required\" functionality from Pydantic V1, without\n# shadowing typing.Required.\nRequiredParam: Any = Ellipsis\n\nif not PYDANTIC_V2:\n    from pydantic import BaseConfig as BaseConfig\n    from pydantic import BaseModel as BaseModel\n    from pydantic import ValidationError as ValidationError\n    from pydantic import create_model as create_model\n    from pydantic.class_validators import Validator as Validator\n    from pydantic.color import Color as Color\n    from pydantic.error_wrappers import ErrorWrapper as ErrorWrapper\n    from pydantic.errors import MissingError\n    from pydantic.fields import (  # type: ignore[attr-defined]\n        SHAPE_FROZENSET,\n        SHAPE_LIST,\n        SHAPE_SEQUENCE,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        SHAPE_SEQUENCE,\n        SHAPE_SET,\n        SHAPE_SINGLETON,\n        SHAPE_TUPLE,\n        SHAPE_TUPLE_ELLIPSIS,\n    )\n    from pydantic.fields import FieldInfo as FieldInfo\n    from pydantic.fields import ModelField as ModelField  # type: ignore[attr-defined]\n    from pydantic.fields import Undefined as Undefined  # type: ignore[attr-defined]\n    from pydantic.fields import (  # type: ignore[attr-defined]\n        UndefinedType as UndefinedType,\n    )\n    from pydantic.networks import AnyUrl as AnyUrl\n    from pydantic.networks import NameEmail as NameEmail\n    from pydantic.schema import TypeModelSet as TypeModelSet\n    from pydantic.schema import (\n        field_schema,\n        get_flat_models_from_fields,\n        model_process_schema,\n    )\n    from pydantic.schema import (\n        get_annotation_from_field_info as get_annotation_from_field_info,\n    )\n    from pydantic.schema import get_flat_models_from_field as get_flat_models_from_field\n    from pydantic.schema import get_model_name_map as get_model_name_map\n    from pydantic.types import SecretBytes as SecretBytes\n    from pydantic.types import SecretStr as SecretStr\n    from pydantic.typing import evaluate_forwardref as evaluate_forwardref\n    from pydantic.utils import lenient_issubclass as lenient_issubclass\n\n\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "\nelse:\n    from pydantic.v1 import BaseConfig as BaseConfig  # type: ignore[assignment]\n    from pydantic.v1 import BaseModel as BaseModel  # type: ignore[assignment]\n    from pydantic.v1 import (  # type: ignore[assignment]\n        ValidationError as ValidationError,\n    )\n    from pydantic.v1 import create_model as create_model  # type: ignore[no-redef]\n    from pydantic.v1.class_validators import Validator as Validator\n    from pydantic.v1.color import Color as Color  # type: ignore[assignment]\n    from pydantic.v1.error_wrappers import ErrorWrapper as ErrorWrapper\n    from pydantic.v1.errors import MissingError\n    from 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    )\n    from pydantic.v1.fields import FieldInfo as FieldInfo  # type: ignore[assignment]\n    from pydantic.v1.fields import ModelField as ModelField\n    from pydantic.v1.fields import Undefined as Undefined\n    from pydantic.v1.fields import UndefinedType as UndefinedType\n    from pydantic.v1.networks import AnyUrl as AnyUrl\n    from pydantic.v1.networks import (  # type: ignore[assignment]\n        NameEmail as NameEmail,\n    )\n    from pydantic.v1.schema import TypeModelSet as TypeModelSet\n    from pydantic.v1.schema import (\n", "stderr": "", "exit_code": 0}

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

{"status": "ok", "stdout": "    SHAPE_FROZENSET,\n    SHAPE_TUPLE,\n    SHAPE_SEQUENCE,\n    SHAPE_TUPLE_ELLIPSIS,\n}\nsequence_shape_to_type = {\n    SHAPE_LIST: list,\n    SHAPE_SET: set,\n    SHAPE_TUPLE: tuple,\n    SHAPE_SEQUENCE: list,\n    SHAPE_TUPLE_ELLIPSIS: list,\n}\n\n\n@dataclass\nclass GenerateJsonSchema:\n    ref_template: str\n\n\nclass PydanticSchemaGenerationError(Exception):\n    pass\n\n\nRequestErrorModel: Type[BaseModel] = create_model(\"Request\")\n\n\ndef with_info_plain_validator_function(\n    function: Callable[..., Any],\n    *,\n    ref: Union[str, None] = None,\n    metadata: Any = None,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    metadata: Any = None,\n    serialization: Any = None,\n) -> Any:\n    return {}\n\n\ndef get_model_definitions(\n    *,\n    flat_models: Set[Union[Type[BaseModel], Type[Enum]]],\n    model_name_map: Dict[Union[Type[BaseModel], Type[Enum]], str],\n) -> Dict[str, Any]:\n    definitions: Dict[str, Dict[str, Any]] = {}\n    for model in flat_models:\n        m_schema, m_definitions, m_nested_models = model_process_schema(\n            model, model_name_map=model_name_map, ref_prefix=REF_PREFIX\n        )\n        definitions.update(m_definitions)\n        model_name = model_name_map[model]\n        definitions[model_name] = m_schema\n    for m_schema in definitions.values():\n        if \"description\" in m_schema:\n            m_schema[\"description\"] = m_schema[\"description\"].split(\"\\f\")[0]\n    return definitions\n\n\ndef is_pv1_scalar_field(field: ModelField) -> bool:\n    from fastapi import params\n\n    field_info = field.field_info\n    if not (\n        field.shape == SHAPE_SINGLETON\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        field.shape == SHAPE_SINGLETON\n        and not lenient_issubclass(field.type_, BaseModel)\n        and not lenient_issubclass(field.type_, dict)\n        and not shared.field_annotation_is_sequence(field.type_)\n        and not is_dataclass(field.type_)\n        and not isinstance(field_info, params.Body)\n    ):\n        return False\n    if field.sub_fields:\n        if not all(is_pv1_scalar_field(f) for f in field.sub_fields):\n            return False\n    return True\n\n\ndef is_pv1_scalar_sequence_field(field: ModelField) -> bool:\n    if (field.shape in sequence_shapes) and not lenient_issubclass(\n        field.type_, BaseModel\n    ):\n        if field.sub_fields is not None:\n            for sub_field in field.sub_fields:\n                if not is_pv1_scalar_field(sub_field):\n                    return False\n        return True\n    if shared._annotation_is_sequence(field.type_):\n        return True\n    return False\n\n\ndef _normalize_errors(errors: Sequence[Any]) -> List[Dict[str, Any]]:\n    use_errors: List[Any] = []\n    for error in errors:\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    for error in errors:\n        if isinstance(error, ErrorWrapper):\n            new_errors = ValidationError(  # type: ignore[call-arg]\n                errors=[error], model=RequestErrorModel\n            ).errors()\n            use_errors.extend(new_errors)\n        elif isinstance(error, list):\n            use_errors.extend(_normalize_errors(error))\n        else:\n            use_errors.append(error)\n    return use_errors\n\n\ndef _regenerate_error_with_loc(\n    *, errors: Sequence[Any], loc_prefix: Tuple[Union[str, int], ...]\n) -> List[Dict[str, Any]]:\n    updated_loc_errors: List[Any] = [\n        {**err, \"loc\": loc_prefix + err.get(\"loc\", ())}\n        for err in _normalize_errors(errors)\n    ]\n\n    return updated_loc_errors\n\n\ndef _model_rebuild(model: Type[BaseModel]) -> None:\n    model.update_forward_refs()\n\n\ndef _model_dump(\n    model: BaseModel, mode: Literal[\"json\", \"python\"] = \"json\", **kwargs: Any\n) -> Any:\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": ") -> Any:\n    return model.dict(**kwargs)\n\n\ndef _get_model_config(model: BaseModel) -> Any:\n    return model.__config__  # type: ignore[attr-defined]\n\n\ndef get_schema_from_model_field(\n    *,\n    field: ModelField,\n    model_name_map: ModelNameMap,\n    field_mapping: Dict[\n        Tuple[ModelField, Literal[\"validation\", \"serialization\"]], JsonSchemaValue\n    ],\n    separate_input_output_schemas: bool = True,\n) -> Dict[str, Any]:\n    return field_schema(  # type: ignore[no-any-return]\n        field, model_name_map=model_name_map, ref_prefix=REF_PREFIX\n    )[0]\n\n\n# def get_compat_model_name_map(fields: List[ModelField]) -> ModelNameMap:\n#     models = get_flat_models_from_fields(fields, known_models=set())\n#     return get_model_name_map(models)  # type: ignore[no-any-return]\n\n\ndef get_definitions(\n    *,\n    fields: List[ModelField],\n    model_name_map: ModelNameMap,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    model_name_map: ModelNameMap,\n    separate_input_output_schemas: bool = True,\n) -> Tuple[\n    Dict[Tuple[ModelField, Literal[\"validation\", \"serialization\"]], JsonSchemaValue],\n    Dict[str, Dict[str, Any]],\n]:\n    models = get_flat_models_from_fields(fields, known_models=set())\n    return {}, get_model_definitions(flat_models=models, model_name_map=model_name_map)\n\n\ndef is_scalar_field(field: ModelField) -> bool:\n    return is_pv1_scalar_field(field)\n\n\ndef is_sequence_field(field: ModelField) -> bool:\n    return field.shape in sequence_shapes or shared._annotation_is_sequence(field.type_)\n\n\ndef is_scalar_sequence_field(field: ModelField) -> bool:\n    return is_pv1_scalar_sequence_field(field)\n\n\ndef is_bytes_field(field: ModelField) -> bool:\n    return lenient_issubclass(field.type_, bytes)  # type: ignore[no-any-return]\n\n\ndef is_bytes_sequence_field(field: ModelField) -> bool:\n    return field.shape in sequence_shapes and lenient_issubclass(field.type_, bytes)\n\n\ndef copy_field_info(*, field_info: FieldInfo, annotation: Any) -> FieldInfo:\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "def copy_field_info(*, field_info: FieldInfo, annotation: Any) -> FieldInfo:\n    return copy(field_info)\n\n\ndef serialize_sequence_value(*, field: ModelField, value: Any) -> Sequence[Any]:\n    return sequence_shape_to_type[field.shape](value)  # type: ignore[no-any-return]\n\n\ndef get_missing_field_error(loc: Tuple[str, ...]) -> Dict[str, Any]:\n    missing_field_error = ErrorWrapper(MissingError(), loc=loc)\n    new_error = ValidationError([missing_field_error], RequestErrorModel)\n    return new_error.errors()[0]  # type: ignore[return-value]\n\n\ndef create_body_model(\n    *, fields: Sequence[ModelField], model_name: str\n) -> Type[BaseModel]:\n    BodyModel = create_model(model_name)\n    for f in fields:\n        BodyModel.__fields__[f.name] = f  # type: ignore[index]\n    return BodyModel\n\n\ndef get_model_fields(model: Type[BaseModel]) -> List[ModelField]:\n    return list(model.__fields__.values())  # type: ignore[attr-defined]\n", "stderr": "", "exit_code": 0}

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

{"status": "ok", "stdout": "334\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "from typing_extensions import Literal\n\nPYDANTIC_VERSION_MINOR_TUPLE = tuple(int(x) for x in PYDANTIC_VERSION.split(\".\")[:2])\nPYDANTIC_V2 = PYDANTIC_VERSION_MINOR_TUPLE[0] == 2\n# Keeping old \"Required\" functionality from Pydantic V1, without\n# shadowing typing.Required.\nRequiredParam: Any = Ellipsis\n\nif not PYDANTIC_V2:\n    from pydantic import BaseConfig as BaseConfig\n    from pydantic import BaseModel as BaseModel\n    from pydantic import ValidationError as ValidationError\n    from pydantic import create_model as create_model\n    from pydantic.class_validators import Validator as Validator\n    from pydantic.color import Color as Color\n    from pydantic.error_wrappers import ErrorWrapper as ErrorWrapper\n    from pydantic.errors import MissingError\n    from pydantic.fields import (  # type: ignore[attr-defined]\n        SHAPE_FROZENSET,\n        SHAPE_LIST,\n        SHAPE_SEQUENCE,\n        SHAPE_SET,\n        SHAPE_SINGLETON,\n        SHAPE_TUPLE,\n        SHAPE_TUPLE_ELLIPSIS,\n    )\n    from pydantic.fields import FieldInfo as FieldInfo\n    from pydantic.fields import ModelField as ModelField  # type: ignore[attr-defined]\n    from pydantic.fields import Undefined as Undefined  # type: ignore[attr-defined]\n    from pydantic.fields import (  # type: ignore[attr-defined]\n        UndefinedType as UndefinedType,\n    )\n    from pydantic.networks import AnyUrl as AnyUrl\n    from pydantic.networks import NameEmail as NameEmail\n    from pydantic.schema import TypeModelSet as TypeModelSet\n    from pydantic.schema import (\n        field_schema,\n        get_flat_models_from_fields,\n        model_process_schema,\n    )\n    from pydantic.schema import (\n        get_annotation_from_field_info as get_annotation_from_field_info,\n    )\n    from pydantic.schema import get_flat_models_from_field as get_flat_models_from_field\n    from pydantic.schema import get_model_name_map as get_model_name_map\n    from pydantic.ty

{"status": "ok", "stdout": "\nelse:\n    from pydantic.v1 import BaseConfig as BaseConfig  # type: ignore[assignment]\n    from pydantic.v1 import BaseModel as BaseModel  # type: ignore[assignment]\n    from pydantic.v1 import (  # type: ignore[assignment]\n        ValidationError as ValidationError,\n    )\n    from pydantic.v1 import create_model as create_model  # type: ignore[no-redef]\n    from pydantic.v1.class_validators import Validator as Validator\n    from pydantic.v1.color import Color as Color  # type: ignore[assignment]\n    from pydantic.v1.error_wrappers import ErrorWrapper as ErrorWrapper\n    from pydantic.v1.errors import MissingError\n    from 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    )\n    from pydantic.v1.fields import FieldInfo as FieldInfo  # type: ignore[assignment]\n    from pydantic.v1.fields import ModelField as ModelField\n    from pydantic.v1.fields import Undefined as Undefined\n    from pydantic.v1.fields import UndefinedType as UndefinedType\n    from pydantic.v1.networks import AnyUrl as AnyUrl\n    from pydantic.v1.networks import (  # type: ignore[assignment]\n        NameEmail as NameEmail,\n    )\n    from pydantic.v1.schema import TypeModelSet as TypeModelSet\n    from pydantic.v1.schema import (\n        field_schema,\n        get_flat_models_from_fields,\n        model_process_schema,\n    )\n    from pydantic.v1.schema import (\n        get_annotation_from_field_info as get_annotation_from_field_info,\n    )\n    from pydantic.v1.schema import (\n        get_flat_models_from_field as get_flat_models_from_field,\n    )\n", "stderr": "", "exit_code": 0}

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

{"status": "ok", "stdout": "    SHAPE_TUPLE_ELLIPSIS: list,\n}\n\n\n@dataclass\nclass GenerateJsonSchema:\n    ref_template: str\n\n\nclass PydanticSchemaGenerationError(Exception):\n    pass\n\n\nRequestErrorModel: Type[BaseModel] = create_model(\"Request\")\n\n\ndef with_info_plain_validator_function(\n    function: Callable[..., Any],\n    *,\n    ref: Union[str, None] = None,\n    metadata: Any = None,\n    serialization: Any = None,\n) -> Any:\n    return {}\n\n\ndef get_model_definitions(\n    *,\n    flat_models: Set[Union[Type[BaseModel], Type[Enum]]],\n    model_name_map: Dict[Union[Type[BaseModel], Type[Enum]], str],\n) -> Dict[str, Any]:\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": ") -> Dict[str, Any]:\n    definitions: Dict[str, Dict[str, Any]] = {}\n    for model in flat_models:\n        m_schema, m_definitions, m_nested_models = model_process_schema(\n            model, model_name_map=model_name_map, ref_prefix=REF_PREFIX\n        )\n        definitions.update(m_definitions)\n        model_name = model_name_map[model]\n        definitions[model_name] = m_schema\n    for m_schema in definitions.values():\n        if \"description\" in m_schema:\n            m_schema[\"description\"] = m_schema[\"description\"].split(\"\\f\")[0]\n    return definitions\n\n\ndef is_pv1_scalar_field(field: ModelField) -> bool:\n    from fastapi import params\n\n    field_info = field.field_info\n    if not (\n        field.shape == SHAPE_SINGLETON\n        and not lenient_issubclass(field.type_, BaseModel)\n        and not lenient_issubclass(field.type_, dict)\n        and not shared.field_annotation_is_sequence(field.type_)\n        and not is_dataclass(field.type_)\n        and not isinstance(field_info, params.Body)\n    ):\n        return False\n    if field.sub_fields:\n        if not all(is_pv1_scalar_field(f) for f in field.sub_fields):\n            return False\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "            return False\n    return True\n\n\ndef is_pv1_scalar_sequence_field(field: ModelField) -> bool:\n    if (field.shape in sequence_shapes) and not lenient_issubclass(\n        field.type_, BaseModel\n    ):\n        if field.sub_fields is not None:\n            for sub_field in field.sub_fields:\n                if not is_pv1_scalar_field(sub_field):\n                    return False\n        return True\n    if shared._annotation_is_sequence(field.type_):\n        return True\n    return False\n\n\ndef _normalize_errors(errors: Sequence[Any]) -> List[Dict[str, Any]]:\n    use_errors: List[Any] = []\n    for error in errors:\n        if isinstance(error, ErrorWrapper):\n            new_errors = ValidationError(  # type: ignore[call-arg]\n                errors=[error], model=RequestErrorModel\n            ).errors()\n            use_errors.extend(new_errors)\n        elif isinstance(error, list):\n            use_errors.extend(_normalize_errors(error))\n        else:\n            use_errors.append(error)\n    return use_errors\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    return use_errors\n\n\ndef _regenerate_error_with_loc(\n    *, errors: Sequence[Any], loc_prefix: Tuple[Union[str, int], ...]\n) -> List[Dict[str, Any]]:\n    updated_loc_errors: List[Any] = [\n        {**err, \"loc\": loc_prefix + err.get(\"loc\", ())}\n        for err in _normalize_errors(errors)\n    ]\n\n    return updated_loc_errors\n\n\ndef _model_rebuild(model: Type[BaseModel]) -> None:\n    model.update_forward_refs()\n\n\ndef _model_dump(\n    model: BaseModel, mode: Literal[\"json\", \"python\"] = \"json\", **kwargs: Any\n) -> Any:\n    return model.dict(**kwargs)\n\n\ndef _get_model_config(model: BaseModel) -> Any:\n    return model.__config__  # type: ignore[attr-defined]\n\n\ndef get_schema_from_model_field(\n    *,\n    field: ModelField,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    field: ModelField,\n    model_name_map: ModelNameMap,\n    field_mapping: Dict[\n        Tuple[ModelField, Literal[\"validation\", \"serialization\"]], JsonSchemaValue\n    ],\n    separate_input_output_schemas: bool = True,\n) -> Dict[str, Any]:\n    return field_schema(  # type: ignore[no-any-return]\n        field, model_name_map=model_name_map, ref_prefix=REF_PREFIX\n    )[0]\n\n\n# def get_compat_model_name_map(fields: List[ModelField]) -> ModelNameMap:\n#     models = get_flat_models_from_fields(fields, known_models=set())\n#     return get_model_name_map(models)  # type: ignore[no-any-return]\n\n\ndef get_definitions(\n    *,\n    fields: List[ModelField],\n    model_name_map: ModelNameMap,\n    separate_input_output_schemas: bool = True,\n) -> Tuple[\n    Dict[Tuple[ModelField, Literal[\"validation\", \"serialization\"]], JsonSchemaValue],\n    Dict[str, Dict[str, Any]],\n]:\n    models = get_flat_models_from_fields(fields, known_models=set())\n    return {}, get_model_definitions(flat_models=models, model_name_map=model_name_map)\n\n\ndef is_scalar_field(field: ModelField) -> bool:\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "def is_scalar_field(field: ModelField) -> bool:\n    return is_pv1_scalar_field(field)\n\n\ndef is_sequence_field(field: ModelField) -> bool:\n    return field.shape in sequence_shapes or shared._annotation_is_sequence(field.type_)\n\n\ndef is_scalar_sequence_field(field: ModelField) -> bool:\n    return is_pv1_scalar_sequence_field(field)\n\n\ndef is_bytes_field(field: ModelField) -> bool:\n    return lenient_issubclass(field.type_, bytes)  # type: ignore[no-any-return]\n\n\ndef is_bytes_sequence_field(field: ModelField) -> bool:\n    return field.shape in sequence_shapes and lenient_issubclass(field.type_, bytes)\n\n\ndef copy_field_info(*, field_info: FieldInfo, annotation: Any) -> FieldInfo:\n    return copy(field_info)\n\n\ndef serialize_sequence_value(*, field: ModelField, value: Any) -> Sequence[Any]:\n    return sequence_shape_to_type[field.shape](value)  # type: ignore[no-any-return]\n\n\ndef get_missing_field_error(loc: Tuple[str, ...]) -> Dict[str, Any]:\n    missing_field_error = ErrorWrapper(MissingError(), loc=loc)\n    new_error = ValidationError([missing_field_error], RequestErrorModel)\n", "stderr": "", "exit_code": 0}