fastapi_14246

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

{"status": "ok", "stdout": "./docs/de/docs/how-to/migrate-from-pydantic-v1-to-pydantic-v2.md:19:Wenn Sie eine \u00e4ltere FastAPI-App mit Pydantic v1 haben, zeige ich Ihnen hier, wie Sie sie zu Pydantic v2 migrieren, und die **neuen Features in FastAPI 0.119.0**, die Ihnen bei einer schrittweisen Migration helfen.\n./docs/de/docs/how-to/migrate-from-pydantic-v1-to-pydantic-v2.md:55:Seit FastAPI 0.119.0 gibt es au\u00dferdem eine teilweise Unterst\u00fctzung f\u00fcr Pydantic v1 innerhalb von Pydantic v2, um die Migration auf v2 zu erleichtern.\n./docs/en/docs/release-notes.md:61:## 0.119.0\n./docs/en/docs/how-to/migrate-from-pydantic-v1-to-pydantic-v2.md:19:If you have an old FastAPI app with Pydantic v1, here I'll show you how to migrate it to Pydantic v2, and the **new features in FastAPI 0.119.0** to help you with a gradual migration.\n./docs/en/docs/how-to/migrate-from-pydantic-v1-to-pydantic-v2.md:55:Since FastAPI 0.119.0, there's also partial support for Pydantic v1 from inside of Pydantic v2, to facilitate the migration to v2.\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "./docs/en/docs/release-notes.md:3916:* \u270f Fix example code with sets in tutorial for body nested models. PR [#3030](https://github.com/tiangolo/fastapi/pull/3030) by [@hitrust](https://github.com/hitrust).\n./docs/en/docs/release-notes.md:5723:* Fix typos in section about nested models and OAuth2 with JWT. PR [#127](https://github.com/tiangolo/fastapi/pull/127) by [@mmcloud](https://github.com/mmcloud).\n./docs/en/docs/alternatives.md:252:It can't handle nested models very well. So, if the JSON body in the request is a JSON object that has inner fields that in turn are nested JSON objects, it cannot be properly documented and validated.\n./docs/en/docs/tutorial/body-nested-models.md:3:With **FastAPI**, you can define, validate, document, and use arbitrarily deeply nested models (thanks to Pydantic).\n./docs/en/docs/tutorial/body-nested-models.md:110:* Editor support (completion, etc.), even for nested models\n./docs/en/docs/tutorial/body-nested-models.md:165:## Deeply nested models { #deeply-nested-models }\n./docs/en/docs/tutorial/body-nested-models.md:167:You can define arbitrarily deeply nested models:\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "", "stderr": "grep: fastapi/fastapi: No such file or directory\n", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/:\n__init__.py\n__main__.py\n_compat\napplications.py\nbackground.py\ncli.py\nconcurrency.py\ndatastructures.py\ndependencies\nencoders.py\nexception_handlers.py\nexceptions.py\nlogger.py\nmiddleware\nopenapi\nparam_functions.py\nparams.py\npy.typed\nrequests.py\nresponses.py\nrouting.py\nsecurity\nstaticfiles.py\ntemp_pydantic_v1_params.py\ntemplating.py\ntestclient.py\ntypes.py\nutils.py\nwebsockets.py\n\nfastapi/_compat:\n__init__.py\nmain.py\nmay_v1.py\nmodel_field.py\nshared.py\nv1.py\nv2.py\n\nfastapi/dependencies:\n__init__.py\nmodels.py\nutils.py\n\nfastapi/middleware:\n__init__.py\nasyncexitstack.py\ncors.py\ngzip.py\nhttpsredirect.py\ntrustedhost.py\nwsgi.py\n\nfastapi/openapi:\n__init__.py\nconstants.py\ndocs.py\nmodels.py\nutils.py\n\nfastapi/security:\n__init__.py\napi_key.py\nbase.py\nhttp.py\noauth2.py\nopen_id_connect_url.py\nutils.py\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/_compat/may_v1.py:76:    from .v1 import AnyUrl as AnyUrl\nfastapi/_compat/may_v1.py:77:    from .v1 import BaseConfig as BaseConfig\nfastapi/_compat/may_v1.py:78:    from .v1 import BaseModel as BaseModel\nfastapi/_compat/may_v1.py:79:    from .v1 import Color as Color\nfastapi/_compat/may_v1.py:80:    from .v1 import CoreSchema as CoreSchema\nfastapi/_compat/may_v1.py:81:    from .v1 import ErrorWrapper as ErrorWrapper\nfastapi/_compat/may_v1.py:82:    from .v1 import FieldInfo as FieldInfo\nfastapi/_compat/may_v1.py:83:    from .v1 import GetJsonSchemaHandler as GetJsonSchemaHandler\nfastapi/_compat/may_v1.py:84:    from .v1 import JsonSchemaValue as JsonSchemaValue\nfastapi/_compat/may_v1.py:85:    from .v1 import ModelField as ModelField\nfastapi/_compat/may_v1.py:86:    from .v1 import NameEmail as NameEmail\nfastapi/_compat/may_v1.py:87:    from .v1 import RequiredParam as RequiredParam\nfastapi/_compat/may_v1.py:88:    from .v1 import SecretBytes as SecretBytes\nfastapi/_compat/may_v1.py:89:    from .v1 import SecretStr as SecretStr\nfastapi/_compat/may_v1.py:90:    from .v1 import Undefined as Undefined\nfastapi/_compat/may_v1.py:91:    from .v1 import UndefinedType as UndefinedType\nfastapi/_compat/may_v1.py:92:    from .v1 import Url as Url\nfastapi/_compat/may_v1.py:93:    from .v1 import ValidationError, create_model\nfastapi/_compat/may_v1.py:94:    from .v1 import get_definitions as get_definitions\nfastapi/_compat/__init__.py:33:from .may_v1 import CoreSchema as CoreSchema\nfastapi/_compat/__init__.py:34:from .may_v1 import GetJsonSchemaHandler as GetJsonSchemaHandler\nfastapi/_compat/__init__.py:35:from .may_v1 import JsonSchemaValue as JsonSchemaValue\nfastapi/_compat/__init__.py:36:from .may_v1 import _normalize_errors as _normalize_errors\nfastapi/_compat/__init__.py:40:from .shared import annotation_is_pydantic_v1 as annotation_is_pydantic_v1\nfastapi/_compat/shared.py:19:from fastapi._compat import may_v1\nfa

{"status": "ok", "stdout": "fastapi/dependencies/utils.py:51:from fastapi._compat.shared import annotation_is_pydantic_v1\nfastapi/dependencies/utils.py:483:            if annotation_is_pydantic_v1(use_annotation):\nfastapi/dependencies/utils.py:1033:        if annotation_is_pydantic_v1(BodyModel):\nfastapi/_compat/__init__.py:40:from .shared import annotation_is_pydantic_v1 as annotation_is_pydantic_v1\nfastapi/_compat/shared.py:199:def annotation_is_pydantic_v1(annotation: Any) -> bool:\nfastapi/_compat/shared.py:209:            if annotation_is_pydantic_v1(sub_annotation):\nfastapi/utils.py:26:    annotation_is_pydantic_v1,\nfastapi/utils.py:104:        annotation_is_pydantic_v1(type_)\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/routing.py:235:            # pydantic v1\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": "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": "28:from fastapi import params, temp_pydantic_v1_params\n63:from pydantic import BaseModel\n235:            # pydantic v1\n312:        body_field.field_info, (params.Form, temp_pydantic_v1_params.Form)\n2161:        from pydantic import BaseModel\n2543:        from pydantic import BaseModel\n3679:        from pydantic import BaseModel\n4061:        from pydantic import BaseModel\n4443:        from pydantic import BaseModel\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    return res\n\n\ndef _merge_lifespan_context(\n    original_context: Lifespan[Any], nested_context: Lifespan[Any]\n) -> Lifespan[Any]:\n    @asynccontextmanager\n    async def merged_lifespan(\n        app: AppType,\n    ) -> AsyncIterator[Optional[Mapping[str, Any]]]:\n        async with original_context(app) as maybe_original_state:\n            async with nested_context(app) as maybe_nested_state:\n                if maybe_nested_state is None and maybe_original_state is None:\n                    yield None  # old ASGI compatibility\n                else:\n                    yield {**(maybe_nested_state or {}), **(maybe_original_state or {})}\n\n    return merged_lifespan  # type: ignore[return-value]\n\n\nasync def serialize_response(\n    *,\n    field: Optional[ModelField] = None,\n    response_content: Any,\n    include: Optional[IncEx] = None,\n    exclude: Optional[IncEx] = None,\n    by_alias: bool = True,\n    exclude_unset: bool = False,\n    exclude_defaults: bool = False,\n    exclude_none: bool = False,\n    is_coroutine: bool = True,\n) -> Any:\n    if field:\n        errors = []\n        if not hasattr(field, \"serialize\"):\n            # pydantic v1\n            response_content = _prepare_response_content(\n                response_content,\n                exclude_unset=exclude_unset,\n                exclude_defaults=exclude_defaults,\n                exclude_none=exclude_none,\n            )\n        if is_coroutine:\n            value, errors_ = field.validate(response_content, {}, loc=(\"response\",))\n        else:\n            value, errors_ = await run_in_threadpool(\n                field.validate, response_content, {}, loc=(\"response\",)\n            )\n        if isinstance(errors_, list):\n            errors.extend(errors_)\n        elif errors_:\n", "stderr": "", "exit_code": 0}

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

{"status": "ok", "stdout": "28:from fastapi import params, temp_pydantic_v1_params\n63:from pydantic import BaseModel\n235:            # pydantic v1\n312:        body_field.field_info, (params.Form, temp_pydantic_v1_params.Form)\n2161:        from pydantic import BaseModel\n2543:        from pydantic import BaseModel\n3679:        from pydantic import BaseModel\n4061:        from pydantic import BaseModel\n4443:        from pydantic import BaseModel\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "61:## 0.119.0\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "## 0.119.0\n\nFastAPI now (temporarily) supports both Pydantic v2 models and `pydantic.v1` models at the same time in the same app, to make it easier for any FastAPI apps still using Pydantic v1 to gradually but quickly **migrate to Pydantic v2**.\n\n```Python\nfrom fastapi import FastAPI\nfrom pydantic import BaseModel as BaseModelV2\nfrom pydantic.v1 import BaseModel\n\n\nclass Item(BaseModel):\n    name: str\n    description: str | None = None\n\n\nclass ItemV2(BaseModelV2):\n    title: str\n    summary: str | None = None\n\n\napp = FastAPI()\n\n\n@app.post(\"/items/\", response_model=ItemV2)\ndef create_item(item: Item):\n    return {\"title\": item.name, \"summary\": item.description}\n```\n\nAdding this feature was a big effort with the main objective of making it easier for the few applications still stuck in Pydantic v1 to migrate to Pydantic v2.\n\nAnd with this, support for **Pydantic v1 is now deprecated** and will be **removed** from FastAPI in a future version soon.\n\n**Note**: have in mind that the Pydantic team already stopped supporting Pydantic v1 for recent versions of Python, starting with Python 3.14.\n\nYou can read in the docs more about how to [Migrate from Pydantic v1 to Pydantic v2](https://fastapi.tiangolo.com/how-to/migrate-from-pydantic-v1-to-pydantic-v2/).\n\n### Features\n\n* \u2728 Add support for `from pydantic.v1 import BaseModel`, mixed Pydantic v1 and v2 models in the same app. PR [#14168](https://github.com/fastapi/fastapi/pull/14168) by [@tiangolo](https://github.com/tiangolo).\n\n## 0.118.3\n\n### Upgrades\n\n* \u2b06\ufe0f Add support for Python 3.14. PR [#14165](https://github.com/fastapi/fastapi/pull/14165) by [@svlandeg](https://github.com/svlandeg).\n\n## 0.118.2\n\n### Fixes\n\n* \ud83d\udc1b Fix tagged discriminated union not recognized as body field. PR [#12942](https://github.com/fastapi/fastapi/pull/12942) by [@frankie567](https://github.com/frankie567).\n\n### Internal\n\n* \u2b06 Bump ast

{"status": "ok", "stdout": "./docs/en/docs/release-notes.md:99:* \u2728 Add support for `from pydantic.v1 import BaseModel`, mixed Pydantic v1 and v2 models in the same app. PR [#14168](https://github.com/fastapi/fastapi/pull/14168) by [@tiangolo](https://github.com/tiangolo).\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "./docs/en/docs/img/sponsors/doist-banner.svg:5:<path d=\"M36.4366 -5.93745C36.4538 -6.0756 36.4433 -6.21716 36.4483 -6.37084L37.1813 -7.07956L37.5635 -6.54123L38.7134 -6.53909C38.7199 -6.93103 38.7074 -7.28321 38.7087 -7.63372C38.8779 -7.64081 39.0489 -7.66172 39.2319 -7.6671C39.2815 -8.06773 39.3364 -8.3976 39.1667 -8.83943C39.0239 -8.36618 38.6254 -8.09289 38.7209 -7.61817C38.448 -7.68003 38.4105 -7.26387 38.1669 -7.33613C37.863 -7.37378 37.7833 -7.63614 37.6019 -7.7568C37.619 -7.89495 37.5912 -8.01066 37.6791 -8.15406C37.9273 -8.57218 38.1859 -8.96096 38.1836 -9.5083C38.1797 -9.92959 38.3949 -10.4219 38.7883 -10.6537C39.6338 -11.1381 40.0233 -11.7912 40.1708 -12.7548C40.2479 -13.2642 40.8846 -13.6482 40.9771 -14.282C41.369 -14.3877 41.6553 -14.6608 41.9312 -14.9633C42.244 -14.7703 42.5118 -14.5547 42.4036 -14.0211L43.2349 -14.8439L43.2326 -15.3912C43.5222 -15.8042 44.0676 -16.0171 44.124 -16.5852C44.7006 -16.598 44.7432 -17.1678 44.9794 -17.4892C45.2673 -17.8884 45.6728 -18.1047 45.9953 -18.4435C46.3178 -18.7823 46.6525 -19.1054 47.006 -19.4684C47.4084 -19.4326 47.7448 -19.6574 48.1003 -19.8098L48.5012 -19.5357C48.7326 -19.479 48.8067 -19.6241 48.9257 -19.6794C49.3882 -19.9027 48.9352 -20.548 49.4149 -20.7971L51.2221 -21.3447L52.4328 -22.6255C52.8195 -22.6898 53.1289 -22.3569 53.3429 -22.3865C54.446 -22.5724 55.5874 -22.5011 56.6488 -22.9167C56.8697 -23.0015 56.8108 -23.2053 56.8641 -23.4091C57.3196 -23.6893 57.9884 -23.1996 58.3814 -23.7681C58.5214 -23.6526 58.6079 -23.4455 58.91 -23.5063C59.2069 -23.6378 59.0768 -24.1729 59.4858 -24.3046C60.432 -24.3557 61.3224 -24.8626 62.3155 -24.6133C62.5469 -24.5566 62.4781 -24.3407 62.5283 -24.1802C62.7116 -23.9611 62.9704 -24.1254 63.2018 -24.0686L63.6571 -24.5734L67.4015 -25.1334C67.5829 -25.0127 68.0008 -24.989 68.21 -24.7527C69.6995 -25.2274 70.9554 -24.7212 72.4755 -24.084L74.019 -24.0892L74.7472 -22.947C75.8675 -23.1588 76.8782 -22.5987 78.006 -22.3047L78.7683 -21.5511L80.2273 -21.5527C80.

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

{"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:535:        elif isinstance(field_info, (params.Query, temp_pydantic_v1_params.Query)):\nfastapi/dependencies/utils.py:762:            isinstance(field.field_info, (params.Form, temp_pydantic_v1_params.Form))\nfastapi/dependencies/utils.py:828:        assert isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param)), (\nfastapi/dependencies/utils.py:840:        assert isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param)), (\nfastapi/dependencies/utils.py:889:        isinstance(first_field.field_info, (params.Form, temp_pydantic_v1_params.Form))\nfastapi/dependencies/utils.py:907:            isinstance(field_info, (params.File, temp_pydantic_v1_params.File))\nfastapi/dependencies/utils.py:914:            and isinstance(field_info, (params.File, temp_pydantic_v1_params.File))\nfastapi/dependencies/utils.py:1021:        isinstance(f.field_info, temp_pydantic_v1_params.File)\nfastapi/dependencies/utils.py:1024:       

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

{"status": "ok", "stdout": "    # Handle default assignations, neither field_info nor depends was not found in Annotated nor default value\n    elif field_info is None and depends is None:\n        default_value = value if value is not inspect.Signature.empty else RequiredParam\n        if is_path_param:\n            # We might check here that `default_value is RequiredParam`, but the fact is that the same\n            # parameter might sometimes be a path parameter and sometimes not. See\n            # `tests/test_infer_param_optionality.py` for an example.\n            field_info = params.Path(annotation=use_annotation)\n        elif is_uploadfile_or_nonable_uploadfile_annotation(\n            type_annotation\n        ) or is_uploadfile_sequence_annotation(type_annotation):\n            field_info = params.File(annotation=use_annotation, default=default_value)\n        elif not field_annotation_is_scalar(annotation=type_annotation):\n            if annotation_is_pydantic_v1(use_annotation):\n                field_info = temp_pydantic_v1_params.Body(\n                    annotation=use_annotation, default=default_value\n                )\n            else:\n                field_info = params.Body(\n                    annotation=use_annotation, default=default_value\n                )\n        else:\n            field_info = params.Query(annotation=use_annotation, default=default_value)\n\n    field = None\n    # It's a field_info, not a dependency\n    if field_info is not None:\n        # Handle field_info.in_\n        if is_path_param:\n            assert isinstance(\n                field_info, (params.Path, temp_pydantic_v1_params.Path)\n            ), (\n                f\"Cannot use `{field_info.__class__.__name__}` for path param\"\n                f\" {param_name!r}\"\n            )\n        elif (\n            isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param))\n            and getattr(field_info, \"in_\", None) is None\n        ):\n   

{"status": "ok", "stdout": "    elif any(\n        isinstance(f.field_info, temp_pydantic_v1_params.File)\n        for f in flat_dependant.body_params\n    ):\n        BodyFieldInfo: Type[temp_pydantic_v1_params.Body] = temp_pydantic_v1_params.File  # type: ignore[no-redef]\n    elif any(isinstance(f.field_info, params.Form) for f in flat_dependant.body_params):\n        BodyFieldInfo = params.Form\n    elif any(\n        isinstance(f.field_info, temp_pydantic_v1_params.Form)\n        for f in flat_dependant.body_params\n    ):\n        BodyFieldInfo = temp_pydantic_v1_params.Form  # type: ignore[assignment]\n    else:\n        if annotation_is_pydantic_v1(BodyModel):\n            BodyFieldInfo = temp_pydantic_v1_params.Body  # type: ignore[assignment]\n        else:\n            BodyFieldInfo = params.Body\n\n        body_param_media_types = [\n            f.field_info.media_type\n            for f in flat_dependant.body_params\n            if isinstance(f.field_info, (params.Body, temp_pydantic_v1_params.Body))\n        ]\n        if len(set(body_param_media_types)) == 1:\n            BodyFieldInfo_kwargs[\"media_type\"] = body_param_media_types[0]\n    final_field = create_model_field(\n        name=\"body\",\n        type_=BodyModel,\n        required=required,\n        alias=\"body\",\n        field_info=BodyFieldInfo(**BodyFieldInfo_kwargs),\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "199:def annotation_is_pydantic_v1(annotation: Any) -> bool:\n209:            if annotation_is_pydantic_v1(sub_annotation):\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "                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}

{"status": "ok", "stdout": "30:    # Pydantic's lenient_issubclass, just for compatibility with v1\n66:def lenient_issubclass(\n78:    if lenient_issubclass(annotation, (str, bytes)):\n80:    return lenient_issubclass(annotation, sequence_types)  # type: ignore[arg-type]\n101:        lenient_issubclass(\n148:    if lenient_issubclass(annotation, bytes):\n153:            if lenient_issubclass(arg, bytes):\n159:    if lenient_issubclass(annotation, UploadFile):\n164:            if lenient_issubclass(arg, UploadFile):\n200:    if lenient_issubclass(annotation, may_v1.BaseModel):\n205:            if lenient_issubclass(arg, may_v1.BaseModel):\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "def 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)  # type: ignore[arg-type]\n\n\ndef field_annotation_is_sequence(annotation: Union[Type[Any], None]) -> bool:\n    origin = get_origin(annotation)\n    if origin is Union or origin is UnionType:\n        for arg in get_args(annotation):\n            if field_annotation_is_sequence(arg):\n                return True\n        return False\n    return _annotation_is_sequence(annotation) or _annotation_is_sequence(\n        get_origin(annotation)\n    )\n\n\ndef value_is_sequence(value: Any) -> bool:\n    return isinstance(value, sequence_types) and not isinstance(value, (str, bytes))  # type: ignore[arg-type]\n\n\ndef _annotation_is_complex(annotation: Union[Type[Any], None]) -> bool:\n    return (\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "602:            # TODO: remove when deprecating Pydantic v1\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "            self.response_field = create_model_field(\n                name=response_name,\n                type_=self.response_model,\n                mode=\"serialization\",\n            )\n            # Create a clone of the field, so that a Pydantic submodel is not returned\n            # as is just because it's an instance of a subclass of a more limited class\n            # e.g. UserInDB (containing hashed_password) could be a subclass of User\n            # that doesn't have the hashed_password. But because it's a subclass, it\n            # would pass the validation and be returned as is.\n            # By being a new field, no inheritance will be passed as is. A new model\n            # will always be created.\n            # TODO: remove when deprecating Pydantic v1\n            self.secure_cloned_response_field: Optional[ModelField] = (\n                create_cloned_field(self.response_field)\n            )\n        else:\n            self.response_field = None  # type: ignore\n            self.secure_cloned_response_field = None\n        self.dependencies = list(dependencies or [])\n        self.description = description or inspect.cleandoc(self.endpoint.__doc__ or \"\")\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/routing.py:57:    create_cloned_field,\nfastapi/routing.py:604:                create_cloned_field(self.response_field)\nfastapi/utils.py:38:# Cache for `create_cloned_field`\nfastapi/utils.py:135:def create_cloned_field(\nfastapi/utils.py:164:                use_type.__fields__[f.name] = create_cloned_field(\nfastapi/utils.py:181:            create_cloned_field(sub_field, cloned_types=cloned_types)\nfastapi/utils.py:185:        new_field.key_field = create_cloned_field(  # type: ignore[attr-defined]\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        return v1.ModelField(**v1_kwargs)  # type: ignore[no-any-return]\n    except RuntimeError:\n        raise fastapi.exceptions.FastAPIError(_invalid_args_message) 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 PYDANTIC_V2:\n        from ._compat import v2\n\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\n    original_type = field.type_\n    if is_dataclass(original_type) and hasattr(original_type, \"__pydantic_model__\"):\n        original_type = original_type.__pydantic_model__\n    use_type = original_type\n    if lenient_issubclass(original_type, v1.BaseModel):\n        original_type = cast(Type[v1.BaseModel], original_type)\n        use_type = cloned_types.get(original_type)\n        if use_type is None:\n            use_type = v1.create_model(original_type.__name__, __base__=original_type)\n            cloned_types[original_type] = use_type\n            for f in original_type.__fields__.values():\n                use_type.__fields__[f.name] = create_cloned_field(\n                    f,\n                    cloned_types=cloned_types,\n                )\n    new_field = create_model_field(name=field.name, type_=use_type, version=\"1\")\n    new_field.has_alias = field.has_alias  # type: ignore[attr-defined]\n    new_field.alias = field.alias  # type: ignore[misc]\n    new_field.class_validators = field.class_validators  # type: ignore[attr-defined]\n    new_field.default = field.default  # type: ignore[misc]\n    new_field.default_factory = field.default_factory  # type: ignore[attr-defined]\n    new_field.required = fi

{"status": "ok", "stdout": "76:def create_model_field(\n168:    new_field = create_model_field(name=field.name, type_=use_type, version=\"1\")\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    \"response model from the type annotation with the path operation decorator \"\n    \"parameter response_model=None. Read more: \"\n    \"https://fastapi.tiangolo.com/tutorial/response-model/\"\n)\n\n\ndef create_model_field(\n    name: str,\n    type_: Any,\n    class_validators: Optional[Dict[str, Validator]] = None,\n    default: Optional[Any] = Undefined,\n    required: Union[bool, UndefinedType] = Undefined,\n    model_config: Union[Type[BaseConfig], None] = None,\n    field_info: Optional[FieldInfo] = None,\n    alias: Optional[str] = None,\n    mode: Literal[\"validation\", \"serialization\"] = \"validation\",\n    version: Literal[\"1\", \"auto\"] = \"auto\",\n) -> ModelField:\n    class_validators = class_validators or {}\n\n    v1_model_config = may_v1.BaseConfig\n    v1_field_info = field_info or may_v1.FieldInfo()\n    v1_kwargs = {\n        \"name\": name,\n        \"field_info\": v1_field_info,\n        \"type_\": type_,\n        \"class_validators\": class_validators,\n        \"default\": default,\n        \"required\": required,\n        \"model_config\": v1_model_config,\n        \"alias\": alias,\n    }\n\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[no-any-return]\n        except RuntimeError:\n            raise fastapi.exceptions.FastAPIError(_invalid_args_message) from None\n    elif PYDANTIC_V2:\n        from ._compat import v2\n\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

{"status": "ok", "stdout": "22:    PydanticSchemaGenerationError,\n123:        except PydanticSchemaGenerationError:\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "import re\nimport warnings\nfrom dataclasses import is_dataclass\nfrom typing import (\n    TYPE_CHECKING,\n    Any,\n    Dict,\n    MutableMapping,\n    Optional,\n    Set,\n    Type,\n    Union,\n    cast,\n)\nfrom weakref import WeakKeyDictionary\n\nimport fastapi\nfrom fastapi._compat import (\n    PYDANTIC_V2,\n    BaseConfig,\n    ModelField,\n    PydanticSchemaGenerationError,\n    Undefined,\n    UndefinedType,\n    Validator,\n    annotation_is_pydantic_v1,\n    lenient_issubclass,\n    may_v1,\n)\nfrom fastapi.datastructures import DefaultPlaceholder, DefaultType\n", "stderr": "", "exit_code": 0}

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

{"status": "ok", "stdout": "602:            # TODO: remove when deprecating Pydantic v1\n", "stderr": "", "exit_code": 0}

{"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            self.response_field = create_model_field(\n                name=response_name,\n                type_=self.response_model,\n                mode=\"serialization\",\n            )\n            # Create a clone of the field, so that a Pydantic submodel is not returned\n            # as is just because it's an instance of a subclass of a more limited class\n            # e.g. UserInDB (containing hashed_password) could be a subclass of User\n            # that doesn't have the hashed_password. But because it's a subclass, it\n            # would pass the validation and be returned as is.\n            # By being a new field, no inheritance will be passed as is. A new model\n            # will always be created.\n            # TODO: remove when deprecating Pydantic v1\n            self.secure_cloned_response_field: Optional[ModelField] = (\n                create_cloned_field(self.response_field)\n            )\n        else:\n            self.response_field = None  # type: ignore\n            self.secure_cloned_response_field = None\n        self.dependencies = list(dependencies or [])\n        self.description = description or inspect.cleandoc(self.endpoint.__doc__ or \"\")\n        # if a \"form feed\" character (page break) is found in the description text,\n        # truncate description text to the content preceding the first \"form feed\"\n        self.description = self.description.split(\"\\f\")[0].strip()\n        respo