fastapi_14246

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

{"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": "./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": "./docs/en/docs/release-notes.md:2577:* \u2728 Add support for disabling the separation of input and output JSON Schemas in OpenAPI with Pydantic v2 with `separate_input_output_schemas=False`. PR [#10145](https://github.com/tiangolo/fastapi/pull/10145) by [@tiangolo](https://github.com/tiangolo).\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "./fastapi/_compat/may_v1.py:65:        separate_input_output_schemas: bool = True,\n./fastapi/_compat/v1.py:243:    separate_input_output_schemas: bool = True,\n./fastapi/_compat/v1.py:259:    separate_input_output_schemas: bool = True,\n./fastapi/_compat/main.py:271:    separate_input_output_schemas: bool = True,\n./fastapi/_compat/main.py:284:            separate_input_output_schemas=separate_input_output_schemas,\n./fastapi/_compat/main.py:295:                separate_input_output_schemas=separate_input_output_schemas,\n./fastapi/_compat/main.py:309:            separate_input_output_schemas=separate_input_output_schemas,\n./fastapi/_compat/main.py:322:    separate_input_output_schemas: bool = True,\n./fastapi/_compat/main.py:331:            separate_input_output_schemas=separate_input_output_schemas,\n./fastapi/_compat/main.py:341:            separate_input_output_schemas=separate_input_output_schemas,\n./fastapi/_compat/v2.py:181:    separate_input_output_schemas: bool = True,\n./fastapi/_compat/v2.py:184:        None if separate_input_output_schemas else \"validation\"\n./fastapi/_compat/v2.py:201:    separate_input_output_schemas: bool = True,\n./fastapi/_compat/v2.py:208:        None if separate_input_output_schemas else \"validation\"\n./fastapi/applications.py:786:        separate_input_output_schemas: Annotated[\n./fastapi/applications.py:870:        self.separate_input_output_schemas = separate_input_output_schemas\n./fastapi/applications.py:1073:                separate_input_output_schemas=self.separate_input_output_schemas,\n./fastapi/openapi/utils.py:102:    separate_input_output_schemas: bool = True,\n./fastapi/openapi/utils.py:133:                separate_input_output_schemas=separate_input_output_schemas,\n./fastapi/openapi/utils.py:175:    separate_input_output_schemas: bool = True,\n./fastapi/openapi/utils.py:184:        separate_input_output_schemas=separate_input_output_schemas,\n./fastapi/openapi/utils.py:258:    se

{"status": "ok", "stdout": "102:    separate_input_output_schemas: bool = True,\n133:                separate_input_output_schemas=separate_input_output_schemas,\n175:    separate_input_output_schemas: bool = True,\n184:        separate_input_output_schemas=separate_input_output_schemas,\n258:    separate_input_output_schemas: bool = True,\n288:                separate_input_output_schemas=separate_input_output_schemas,\n309:                    separate_input_output_schemas=separate_input_output_schemas,\n326:                            separate_input_output_schemas=separate_input_output_schemas,\n356:                            separate_input_output_schemas=separate_input_output_schemas,\n389:                            separate_input_output_schemas=separate_input_output_schemas,\n481:    separate_input_output_schemas: bool = True,\n507:        separate_input_output_schemas=separate_input_output_schemas,\n516:                separate_input_output_schemas=separate_input_output_schemas,\n535:                separate_input_output_schemas=separate_input_output_schemas,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        Tuple[ModelField, Literal[\"validation\", \"serialization\"]], JsonSchemaValue\n    ],\n    separate_input_output_schemas: bool = True,\n) -> List[Dict[str, Any]]:\n    parameters = []\n    flat_dependant = get_flat_dependant(dependant, skip_repeats=True)\n    path_params = _get_flat_fields_from_params(flat_dependant.path_params)\n    query_params = _get_flat_fields_from_params(flat_dependant.query_params)\n    header_params = _get_flat_fields_from_params(flat_dependant.header_params)\n    cookie_params = _get_flat_fields_from_params(flat_dependant.cookie_params)\n    parameter_groups = [\n        (ParamTypes.path, path_params),\n        (ParamTypes.query, query_params),\n        (ParamTypes.header, header_params),\n        (ParamTypes.cookie, cookie_params),\n    ]\n    default_convert_underscores = True\n    if len(flat_dependant.header_params) == 1:\n        first_field = flat_dependant.header_params[0]\n        if lenient_issubclass(first_field.type_, BaseModel):\n            default_convert_underscores = getattr(\n                first_field.field_info, \"convert_underscores\", True\n            )\n    for param_type, param_group in parameter_groups:\n        for param in param_group:\n            field_info = param.field_info\n            # field_info = cast(Param, field_info)\n            if not getattr(field_info, \"include_in_schema\", True):\n                continue\n            param_schema = get_schema_from_model_field(\n                field=param,\n                model_name_map=model_name_map,\n                field_mapping=field_mapping,\n                separate_input_output_schemas=separate_input_output_schemas,\n            )\n            name = param.alias\n            convert_underscores = getattr(\n                param.field_info,\n                \"convert_underscores\",\n                default_convert_underscores,\n            )\n            if (\n                param_type == ParamTypes.header\n        

{"status": "ok", "stdout": "13:    get_schema_from_model_field,\n129:            param_schema = get_schema_from_model_field(\n180:    body_schema = get_schema_from_model_field(\n352:                        response_schema = get_schema_from_model_field(\n385:                        additional_field_schema = get_schema_from_model_field(\n", "stderr": "", "exit_code": 0}

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

{"status": "ok", "stdout": "./fastapi/_compat/v1.py:236:def get_schema_from_model_field(\n./fastapi/_compat/main.py:314:def get_schema_from_model_field(\n./fastapi/_compat/v2.py:174:def get_schema_from_model_field(\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "def _get_model_config(model: BaseModel) -> Any:\n    return model.model_config\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    override_mode: Union[Literal[\"validation\"], None] = (\n        None if separate_input_output_schemas else \"validation\"\n    )\n    # This expects that GenerateJsonSchema was already used to generate the definitions\n    json_schema = field_mapping[(field, override_mode or field.mode)]\n    if \"$ref\" not in json_schema:\n        # TODO remove when deprecating Pydantic v1\n        # Ref: https://github.com/pydantic/pydantic/blob/d61792cc42c80b13b23e3ffa74bc37ec7c77f7d1/pydantic/schema.py#L207\n        json_schema[\"title\"] = field.field_info.title or field.alias.title().replace(\n            \"_\", \" \"\n        )\n    return json_schema\n\n\ndef get_definitions(\n    *,\n    fields: Sequence[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    schema_generator = GenerateJsonSchema(ref_template=REF_TEMPLATE)\n    override_mode: Union[Literal[\"validation\"], None] = (\n        None if separate_input_output_schemas else \"validation\"\n    )\n    flat_models = get_flat_models_from_fields(fields, known_models=set())\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    schema_generator = GenerateJsonSchema(ref_template=REF_TEMPLATE)\n    override_mode: Union[Literal[\"validation\"], None] = (\n        None if separate_input_output_schemas else \"validation\"\n    )\n    flat_models = get_flat_models_from_fields(fields, known_models=set())\n    flat_model_fields = [\n        ModelField(field_info=FieldInfo(annotation=model), name=model.__name__)\n        for model in flat_models\n    ]\n    input_types = {f.type_ for f in fields}\n    unique_flat_model_fields = {\n        f for f in flat_model_fields if f.type_ not in input_types\n    }\n\n    inputs = [\n        (field, override_mode or field.mode, field._type_adapter.core_schema)\n        for field in list(fields) + list(unique_flat_model_fields)\n    ]\n    field_mapping, definitions = schema_generator.generate_definitions(inputs=inputs)\n    for item_def in cast(Dict[str, Dict[str, Any]], definitions).values():\n        if \"description\" in item_def:\n            item_description = cast(str, item_def[\"description\"]).split(\"\\f\")[0]\n            item_def[\"description\"] = item_description\n    new_mapping, new_definitions = _remap_definitions_and_field_mappings(\n        model_name_map=model_name_map,\n        definitions=definitions,  # type: ignore[arg-type]\n        field_mapping=field_mapping,\n    )\n    return new_mapping, new_definitions\n\n\ndef _replace_refs(\n    *,\n    schema: Dict[str, Any],\n    old_name_to_new_name_map: Dict[str, str],\n) -> Dict[str, Any]:\n    new_schema = deepcopy(schema)\n    for key, value in new_schema.items():\n        if key == \"$ref\":\n            ref_name = schema[\"$ref\"].split(\"/\")[-1]\n            if ref_name in old_name_to_new_name_map:\n                new_name = old_nam

{"status": "ok", "stdout": "31:from pydantic.json_schema import GenerateJsonSchema as GenerateJsonSchema\n186:    # This expects that GenerateJsonSchema was already used to generate the definitions\n206:    schema_generator = GenerateJsonSchema(ref_template=REF_TEMPLATE)\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "import re\nimport warnings\nfrom copy import copy, deepcopy\nfrom dataclasses import dataclass\nfrom enum import Enum\nfrom typing import (\n    Any,\n    Dict,\n    List,\n    Sequence,\n    Set,\n    Tuple,\n    Type,\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\nfrom pydantic import BaseModel, 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 Annotated, 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\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "210:    flat_models = get_flat_models_from_fields(fields, known_models=set())\n415:    get_flat_models_from_fields(fields, known_models=known_models)\n450:def get_flat_models_from_fields(\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "def get_flat_models_from_fields(\n    fields: Sequence[ModelField], known_models: TypeModelSet\n) -> TypeModelSet:\n    for field in fields:\n        get_flat_models_from_field(field, known_models=known_models)\n    return known_models\n\n\ndef get_long_model_name(model: TypeModelOrEnum) -> str:\n    return f\"{model.__module__}__{model.__qualname__}\".replace(\".\", \"__\")\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "210:    flat_models = get_flat_models_from_fields(fields, known_models=set())\n415:    get_flat_models_from_fields(fields, known_models=known_models)\n434:def get_flat_models_from_field(\n450:def get_flat_models_from_fields(\n454:        get_flat_models_from_field(field, known_models=known_models)\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "                get_flat_models_from_annotation(arg, known_models=known_models)\n    return known_models\n\n\ndef get_flat_models_from_field(\n    field: ModelField, known_models: TypeModelSet\n) -> TypeModelSet:\n    field_type = field.type_\n    if lenient_issubclass(field_type, BaseModel):\n        if field_type in known_models:\n            return known_models\n        known_models.add(field_type)\n        get_flat_models_from_model(field_type, known_models=known_models)\n    elif lenient_issubclass(field_type, Enum):\n        known_models.add(field_type)\n    else:\n        get_flat_models_from_annotation(field_type, known_models=known_models)\n    return known_models\n\n\ndef get_flat_models_from_fields(\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "410:def get_flat_models_from_model(\n428:                    get_flat_models_from_model(arg, known_models=known_models)\n442:        get_flat_models_from_model(field_type, known_models=known_models)\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        elif model_name in name_model_map:\n            conflicting_names.add(model_name)\n            conflicting_model = name_model_map.pop(model_name)\n            name_model_map[get_long_model_name(conflicting_model)] = conflicting_model\n            name_model_map[get_long_model_name(model)] = model\n        else:\n            name_model_map[model_name] = model\n    return {v: k for k, v in name_model_map.items()}\n\n\ndef get_flat_models_from_model(\n    model: Type[\"BaseModel\"], known_models: Union[TypeModelSet, None] = None\n) -> TypeModelSet:\n    known_models = known_models or set()\n    fields = get_model_fields(model)\n    get_flat_models_from_fields(fields, known_models=known_models)\n    return known_models\n\n\ndef get_flat_models_from_annotation(\n    annotation: Any, known_models: TypeModelSet\n) -> TypeModelSet:\n    origin = get_origin(annotation)\n    if origin is not None:\n        for arg in get_args(annotation):\n            if lenient_issubclass(arg, (BaseModel, Enum)) and arg not in known_models:\n                known_models.add(arg)\n                if lenient_issubclass(arg, BaseModel):\n                    get_flat_models_from_model(arg, known_models=known_models)\n            else:\n                get_flat_models_from_annotation(arg, known_models=known_models)\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "374:def get_model_fields(model: Type[BaseModel]) -> List[ModelField]:\n414:    fields = get_model_fields(model)\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    BodyModel: Type[BaseModel] = create_model(model_name, **field_params)  # type: ignore[call-overload]\n    return BodyModel\n\n\ndef get_model_fields(model: Type[BaseModel]) -> List[ModelField]:\n    return [\n        ModelField(field_info=field_info, name=name)\n        for name, field_info in model.model_fields.items()\n    ]\n\n\n# Duplicate of several schema functions from Pydantic v1 to make them compatible with\n# Pydantic v2 and allow mixing the models\n\nTypeModelOrEnum = Union[Type[\"BaseModel\"], Type[Enum]]\nTypeModelSet = Set[TypeModelOrEnum]\n\n\ndef normalize_name(name: str) -> str:\n    return re.sub(r\"[^a-zA-Z0-9.\\-_]\", \"_\", name)\n\n\ndef get_model_name_map(unique_models: TypeModelSet) -> Dict[TypeModelOrEnum, str]:\n    name_model_map = {}\n    conflicting_names: Set[str] = set()\n    for model in unique_models:\n        model_name = normalize_name(model.__name__)\n        if model_name in conflicting_names:\n            model_name = get_long_model_name(model)\n            name_model_map[model_name] = model\n        elif model_name in name_model_map:\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "63:class ModelField:\n149:        # Each ModelField is unique for our purposes, to allow making a dict from\n150:        # ModelField to its JSON Schema.\n176:    field: ModelField,\n179:        Tuple[ModelField, Literal[\"validation\", \"serialization\"]], JsonSchemaValue\n199:    fields: Sequence[ModelField],\n203:    Dict[Tuple[ModelField, Literal[\"validation\", \"serialization\"]], JsonSchemaValue],\n212:        ModelField(field_info=FieldInfo(annotation=model), name=model.__name__)\n278:        Tuple[ModelField, Literal[\"validation\", \"serialization\"]], JsonSchemaValue\n281:    Dict[Tuple[ModelField, Literal[\"validation\", \"serialization\"]], JsonSchemaValue],\n296:        Tuple[ModelField, Literal[\"validation\", \"serialization\"]], JsonSchemaValue\n319:def is_scalar_field(field: ModelField) -> bool:\n327:def is_sequence_field(field: ModelField) -> bool:\n331:def is_scalar_sequence_field(field: ModelField) -> bool:\n335:def is_bytes_field(field: ModelField) -> bool:\n339:def is_bytes_sequence_field(field: ModelField) -> bool:\n352:def serialize_sequence_value(*, field: ModelField, value: Any) -> Sequence[Any]:\n367:    *, fields: Sequence[ModelField], model_name: str\n374:def get_model_fields(model: Type[BaseModel]) -> List[ModelField]:\n376:        ModelField(field_info=field_info, name=name)\n435:    field: ModelField, known_models: TypeModelSet\n451:    fields: Sequence[ModelField], known_models: TypeModelSet\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "\n\n@dataclass\nclass ModelField:\n    field_info: FieldInfo\n    name: str\n    mode: Literal[\"validation\", \"serialization\"] = \"validation\"\n\n    @property\n    def alias(self) -> str:\n        a = self.field_info.alias\n        return a if a is not None else self.name\n\n    @property\n    def required(self) -> bool:\n        return self.field_info.is_required()\n\n    @property\n    def default(self) -> Any:\n        return self.get_default()\n\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "\n    @property\n    def type_(self) -> Any:\n        return self.field_info.annotation\n\n    def __post_init__(self) -> None:\n        with warnings.catch_warnings():\n            # Pydantic >= 2.12.0 warns about field specific metadata that is unused\n            # (e.g. `TypeAdapter(Annotated[int, Field(alias='b')])`). In some cases, we\n            # end up building the type adapter from a model field annotation so we\n            # need to ignore the warning:\n            if shared.PYDANTIC_VERSION_MINOR_TUPLE >= (2, 12):\n                from pydantic.warnings import UnsupportedFieldAttributeWarning\n\n                warnings.simplefilter(\n                    \"ignore\", category=UnsupportedFieldAttributeWarning\n                )\n            self._type_adapter: TypeAdapter[Any] = TypeAdapter(\n                Annotated[self.field_info.annotation, self.field_info]\n            )\n\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "\n    def get_default(self) -> Any:\n        if self.field_info.is_required():\n            return Undefined\n        return self.field_info.get_default(call_default_factory=True)\n\n    def validate(\n        self,\n        value: Any,\n        values: Dict[str, Any] = {},  # noqa: B006\n        *,\n        loc: Tuple[Union[int, str], ...] = (),\n    ) -> Tuple[Any, Union[List[Dict[str, Any]], None]]:\n        try:\n            return (\n                self._type_adapter.validate_python(value, from_attributes=True),\n                None,\n            )\n        except ValidationError as exc:\n            return None, may_v1._regenerate_error_with_loc(\n                errors=exc.errors(include_url=False), loc_prefix=loc\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "210:    flat_models = get_flat_models_from_fields(fields, known_models=set())\n415:    get_flat_models_from_fields(fields, known_models=known_models)\n450:def get_flat_models_from_fields(\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    schema_generator = GenerateJsonSchema(ref_template=REF_TEMPLATE)\n    override_mode: Union[Literal[\"validation\"], None] = (\n        None if separate_input_output_schemas else \"validation\"\n    )\n    flat_models = get_flat_models_from_fields(fields, known_models=set())\n    flat_model_fields = [\n        ModelField(field_info=FieldInfo(annotation=model), name=model.__name__)\n        for model in flat_models\n    ]\n    input_types = {f.type_ for f in fields}\n    unique_flat_model_fields = {\n        f for f in flat_model_fields if f.type_ not in input_types\n    }\n\n    inputs = [\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    inputs = [\n        (field, override_mode or field.mode, field._type_adapter.core_schema)\n        for field in list(fields) + list(unique_flat_model_fields)\n    ]\n    field_mapping, definitions = schema_generator.generate_definitions(inputs=inputs)\n    for item_def in cast(Dict[str, Dict[str, Any]], definitions).values():\n        if \"description\" in item_def:\n            item_description = cast(str, item_def[\"description\"]).split(\"\\f\")[0]\n            item_def[\"description\"] = item_description\n    new_mapping, new_definitions = _remap_definitions_and_field_mappings(\n        model_name_map=model_name_map,\n        definitions=definitions,  # type: ignore[arg-type]\n        field_mapping=field_mapping,\n    )\n    return new_mapping, new_definitions\n\n\ndef _replace_refs(\n    *,\n    schema: Dict[str, Any],\n    old_name_to_new_name_map: Dict[str, str],\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "210:    flat_models = get_flat_models_from_fields(fields, known_models=set())\n415:    get_flat_models_from_fields(fields, known_models=known_models)\n450:def get_flat_models_from_fields(\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "def get_flat_models_from_fields(\n    fields: Sequence[ModelField], known_models: TypeModelSet\n) -> TypeModelSet:\n    for field in fields:\n        get_flat_models_from_field(field, known_models=known_models)\n    return known_models\n\n\ndef get_long_model_name(model: TypeModelOrEnum) -> str:\n    return f\"{model.__module__}__{model.__qualname__}\".replace(\".\", \"__\")\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "                get_flat_models_from_annotation(arg, known_models=known_models)\n    return known_models\n\n\ndef get_flat_models_from_field(\n    field: ModelField, known_models: TypeModelSet\n) -> TypeModelSet:\n    field_type = field.type_\n    if lenient_issubclass(field_type, BaseModel):\n        if field_type in known_models:\n            return known_models\n        known_models.add(field_type)\n        get_flat_models_from_model(field_type, known_models=known_models)\n    elif lenient_issubclass(field_type, Enum):\n        known_models.add(field_type)\n    else:\n        get_flat_models_from_annotation(field_type, known_models=known_models)\n    return known_models\n\n\ndef get_flat_models_from_fields(\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        elif model_name in name_model_map:\n            conflicting_names.add(model_name)\n            conflicting_model = name_model_map.pop(model_name)\n            name_model_map[get_long_model_name(conflicting_model)] = conflicting_model\n            name_model_map[get_long_model_name(model)] = model\n        else:\n            name_model_map[model_name] = model\n    return {v: k for k, v in name_model_map.items()}\n\n\ndef get_flat_models_from_model(\n    model: Type[\"BaseModel\"], known_models: Union[TypeModelSet, None] = None\n) -> TypeModelSet:\n    known_models = known_models or set()\n    fields = get_model_fields(model)\n    get_flat_models_from_fields(fields, known_models=known_models)\n    return known_models\n\n\ndef get_flat_models_from_annotation(\n    annotation: Any, known_models: TypeModelSet\n) -> TypeModelSet:\n    origin = get_origin(annotation)\n    if origin is not None:\n        for arg in get_args(annotation):\n            if lenient_issubclass(arg, (BaseModel, Enum)) and arg not in known_models:\n                known_models.add(arg)\n                if lenient_issubclass(arg, BaseModel):\n                    get_flat_models_from_model(arg, known_models=known_models)\n            else:\n                get_flat_models_from_annotation(arg, known_models=known_models)\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    BodyModel: Type[BaseModel] = create_model(model_name, **field_params)  # type: ignore[call-overload]\n    return BodyModel\n\n\ndef get_model_fields(model: Type[BaseModel]) -> List[ModelField]:\n    return [\n        ModelField(field_info=field_info, name=name)\n        for name, field_info in model.model_fields.items()\n    ]\n\n\n# Duplicate of several schema functions from Pydantic v1 to make them compatible with\n# Pydantic v2 and allow mixing the models\n\nTypeModelOrEnum = Union[Type[\"BaseModel\"], Type[Enum]]\nTypeModelSet = Set[TypeModelOrEnum]\n\n\ndef normalize_name(name: str) -> str:\n    return re.sub(r\"[^a-zA-Z0-9.\\-_]\", \"_\", name)\n\n\ndef get_model_name_map(unique_models: TypeModelSet) -> Dict[TypeModelOrEnum, str]:\n    name_model_map = {}\n    conflicting_names: Set[str] = set()\n    for model in unique_models:\n        model_name = normalize_name(model.__name__)\n        if model_name in conflicting_names:\n            model_name = get_long_model_name(model)\n            name_model_map[model_name] = model\n        elif model_name in name_model_map:\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "210:    flat_models = get_flat_models_from_fields(fields, known_models=set())\n415:    get_flat_models_from_fields(fields, known_models=known_models)\n450:def get_flat_models_from_fields(\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    schema_generator = GenerateJsonSchema(ref_template=REF_TEMPLATE)\n    override_mode: Union[Literal[\"validation\"], None] = (\n        None if separate_input_output_schemas else \"validation\"\n    )\n    flat_models = get_flat_models_from_fields(fields, known_models=set())\n    flat_model_fields = [\n        ModelField(field_info=FieldInfo(annotation=model), name=model.__name__)\n        for model in flat_models\n    ]\n    input_types = {f.type_ for f in fields}\n    unique_flat_model_fields = {\n        f for f in flat_model_fields if f.type_ not in input_types\n    }\n\n    inputs = [\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    inputs = [\n        (field, override_mode or field.mode, field._type_adapter.core_schema)\n        for field in list(fields) + list(unique_flat_model_fields)\n    ]\n    field_mapping, definitions = schema_generator.generate_definitions(inputs=inputs)\n    for item_def in cast(Dict[str, Dict[str, Any]], definitions).values():\n        if \"description\" in item_def:\n            item_description = cast(str, item_def[\"description\"]).split(\"\\f\")[0]\n            item_def[\"description\"] = item_description\n    new_mapping, new_definitions = _remap_definitions_and_field_mappings(\n        model_name_map=model_name_map,\n        definitions=definitions,  # type: ignore[arg-type]\n        field_mapping=field_mapping,\n    )\n    return new_mapping, new_definitions\n\n\ndef _replace_refs(\n    *,\n    schema: Dict[str, Any],\n    old_name_to_new_name_map: Dict[str, str],\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "210:    flat_models = get_flat_models_from_fields(fields, known_models=set())\n415:    get_flat_models_from_fields(fields, known_models=known_models)\n450:def get_flat_models_from_fields(\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "def get_flat_models_from_fields(\n    fields: Sequence[ModelField], known_models: TypeModelSet\n) -> TypeModelSet:\n    for field in fields:\n        get_flat_models_from_field(field, known_models=known_models)\n    return known_models\n\n\ndef get_long_model_name(model: TypeModelOrEnum) -> str:\n    return f\"{model.__module__}__{model.__qualname__}\".replace(\".\", \"__\")\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "                get_flat_models_from_annotation(arg, known_models=known_models)\n    return known_models\n\n\ndef get_flat_models_from_field(\n    field: ModelField, known_models: TypeModelSet\n) -> TypeModelSet:\n    field_type = field.type_\n    if lenient_issubclass(field_type, BaseModel):\n        if field_type in known_models:\n            return known_models\n        known_models.add(field_type)\n        get_flat_models_from_model(field_type, known_models=known_models)\n    elif lenient_issubclass(field_type, Enum):\n        known_models.add(field_type)\n    else:\n        get_flat_models_from_annotation(field_type, known_models=known_models)\n    return known_models\n\n\ndef get_flat_models_from_fields(\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        elif model_name in name_model_map:\n            conflicting_names.add(model_name)\n            conflicting_model = name_model_map.pop(model_name)\n            name_model_map[get_long_model_name(conflicting_model)] = conflicting_model\n            name_model_map[get_long_model_name(model)] = model\n        else:\n            name_model_map[model_name] = model\n    return {v: k for k, v in name_model_map.items()}\n\n\ndef get_flat_models_from_model(\n    model: Type[\"BaseModel\"], known_models: Union[TypeModelSet, None] = None\n) -> TypeModelSet:\n    known_models = known_models or set()\n    fields = get_model_fields(model)\n    get_flat_models_from_fields(fields, known_models=known_models)\n    return known_models\n\n\ndef get_flat_models_from_annotation(\n    annotation: Any, known_models: TypeModelSet\n) -> TypeModelSet:\n    origin = get_origin(annotation)\n    if origin is not None:\n        for arg in get_args(annotation):\n            if lenient_issubclass(arg, (BaseModel, Enum)) and arg not in known_models:\n                known_models.add(arg)\n                if lenient_issubclass(arg, BaseModel):\n                    get_flat_models_from_model(arg, known_models=known_models)\n            else:\n                get_flat_models_from_annotation(arg, known_models=known_models)\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    BodyModel: Type[BaseModel] = create_model(model_name, **field_params)  # type: ignore[call-overload]\n    return BodyModel\n\n\ndef get_model_fields(model: Type[BaseModel]) -> List[ModelField]:\n    return [\n        ModelField(field_info=field_info, name=name)\n        for name, field_info in model.model_fields.items()\n    ]\n\n\n# Duplicate of several schema functions from Pydantic v1 to make them compatible with\n# Pydantic v2 and allow mixing the models\n\nTypeModelOrEnum = Union[Type[\"BaseModel\"], Type[Enum]]\nTypeModelSet = Set[TypeModelOrEnum]\n\n\ndef normalize_name(name: str) -> str:\n    return re.sub(r\"[^a-zA-Z0-9.\\-_]\", \"_\", name)\n\n\ndef get_model_name_map(unique_models: TypeModelSet) -> Dict[TypeModelOrEnum, str]:\n    name_model_map = {}\n    conflicting_names: Set[str] = set()\n    for model in unique_models:\n        model_name = normalize_name(model.__name__)\n        if model_name in conflicting_names:\n            model_name = get_long_model_name(model)\n            name_model_map[model_name] = model\n        elif model_name in name_model_map:\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "210:    flat_models = get_flat_models_from_fields(fields, known_models=set())\n415:    get_flat_models_from_fields(fields, known_models=known_models)\n450:def get_flat_models_from_fields(\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    schema_generator = GenerateJsonSchema(ref_template=REF_TEMPLATE)\n    override_mode: Union[Literal[\"validation\"], None] = (\n        None if separate_input_output_schemas else \"validation\"\n    )\n    flat_models = get_flat_models_from_fields(fields, known_models=set())\n    flat_model_fields = [\n        ModelField(field_info=FieldInfo(annotation=model), name=model.__name__)\n        for model in flat_models\n    ]\n    input_types = {f.type_ for f in fields}\n    unique_flat_model_fields = {\n        f for f in flat_model_fields if f.type_ not in input_types\n    }\n\n    inputs = [\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    inputs = [\n        (field, override_mode or field.mode, field._type_adapter.core_schema)\n        for field in list(fields) + list(unique_flat_model_fields)\n    ]\n    field_mapping, definitions = schema_generator.generate_definitions(inputs=inputs)\n    for item_def in cast(Dict[str, Dict[str, Any]], definitions).values():\n        if \"description\" in item_def:\n            item_description = cast(str, item_def[\"description\"]).split(\"\\f\")[0]\n            item_def[\"description\"] = item_description\n    new_mapping, new_definitions = _remap_definitions_and_field_mappings(\n        model_name_map=model_name_map,\n        definitions=definitions,  # type: ignore[arg-type]\n        field_mapping=field_mapping,\n    )\n    return new_mapping, new_definitions\n\n\ndef _replace_refs(\n    *,\n    schema: Dict[str, Any],\n    old_name_to_new_name_map: Dict[str, str],\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "210:    flat_models = get_flat_models_from_fields(fields, known_models=set())\n415:    get_flat_models_from_fields(fields, known_models=known_models)\n450:def get_flat_models_from_fields(\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "def get_flat_models_from_fields(\n    fields: Sequence[ModelField], known_models: TypeModelSet\n) -> TypeModelSet:\n    for field in fields:\n        get_flat_models_from_field(field, known_models=known_models)\n    return known_models\n\n\ndef get_long_model_name(model: TypeModelOrEnum) -> str:\n    return f\"{model.__module__}__{model.__qualname__}\".replace(\".\", \"__\")\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "                get_flat_models_from_annotation(arg, known_models=known_models)\n    return known_models\n\n\ndef get_flat_models_from_field(\n    field: ModelField, known_models: TypeModelSet\n) -> TypeModelSet:\n    field_type = field.type_\n    if lenient_issubclass(field_type, BaseModel):\n        if field_type in known_models:\n            return known_models\n        known_models.add(field_type)\n        get_flat_models_from_model(field_type, known_models=known_models)\n    elif lenient_issubclass(field_type, Enum):\n        known_models.add(field_type)\n    else:\n        get_flat_models_from_annotation(field_type, known_models=known_models)\n    return known_models\n\n\ndef get_flat_models_from_fields(\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        elif model_name in name_model_map:\n            conflicting_names.add(model_name)\n            conflicting_model = name_model_map.pop(model_name)\n            name_model_map[get_long_model_name(conflicting_model)] = conflicting_model\n            name_model_map[get_long_model_name(model)] = model\n        else:\n            name_model_map[model_name] = model\n    return {v: k for k, v in name_model_map.items()}\n\n\ndef get_flat_models_from_model(\n    model: Type[\"BaseModel\"], known_models: Union[TypeModelSet, None] = None\n) -> TypeModelSet:\n    known_models = known_models or set()\n    fields = get_model_fields(model)\n    get_flat_models_from_fields(fields, known_models=known_models)\n    return known_models\n\n\ndef get_flat_models_from_annotation(\n    annotation: Any, known_models: TypeModelSet\n) -> TypeModelSet:\n    origin = get_origin(annotation)\n    if origin is not None:\n        for arg in get_args(annotation):\n            if lenient_issubclass(arg, (BaseModel, Enum)) and arg not in known_models:\n                known_models.add(arg)\n                if lenient_issubclass(arg, BaseModel):\n                    get_flat_models_from_model(arg, known_models=known_models)\n            else:\n                get_flat_models_from_annotation(arg, known_models=known_models)\n", "stderr": "", "exit_code": 0, "budget_warning": "Only 10 tool call(s) remaining (50/60 used). Finalize your edits and call submit_patch soon."}