fastapi_14246

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

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

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

{"status": "ok", "stdout": "/workspace/fastapi/applications.py\n/workspace/fastapi/utils.py\n/workspace/fastapi/routing.py\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "__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\n/workspace/fastapi/_compat:\n__init__.py\nmain.py\nmay_v1.py\nmodel_field.py\nshared.py\nv1.py\nv2.py\n\n/workspace/fastapi/dependencies:\n__init__.py\nmodels.py\nutils.py\n\n/workspace/fastapi/middleware:\n__init__.py\nasyncexitstack.py\ncors.py\ngzip.py\nhttpsredirect.py\ntrustedhost.py\nwsgi.py\n\n/workspace/fastapi/openapi:\n__init__.py\nconstants.py\ndocs.py\nmodels.py\nutils.py\n\n/workspace/fastapi/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": "/workspace/fastapi/routing.py:300:    response_model_include: Optional[IncEx] = None,\n/workspace/fastapi/routing.py:301:    response_model_exclude: Optional[IncEx] = None,\n/workspace/fastapi/routing.py:302:    response_model_by_alias: bool = True,\n/workspace/fastapi/routing.py:303:    response_model_exclude_unset: bool = False,\n/workspace/fastapi/routing.py:304:    response_model_exclude_defaults: bool = False,\n/workspace/fastapi/routing.py:305:    response_model_exclude_none: bool = False,\n/workspace/fastapi/routing.py:415:                    include=response_model_include,\n/workspace/fastapi/routing.py:416:                    exclude=response_model_exclude,\n/workspace/fastapi/routing.py:417:                    by_alias=response_model_by_alias,\n/workspace/fastapi/routing.py:418:                    exclude_unset=response_model_exclude_unset,\n/workspace/fastapi/routing.py:419:                    exclude_defaults=response_model_exclude_defaults,\n/workspace/fastapi/routing.py:420:                    exclude_none=response_model_exclude_none,\n/workspace/fastapi/routing.py:513:        response_model: Any = Default(None),\n/workspace/fastapi/routing.py:525:        response_model_include: Optional[IncEx] = None,\n/workspace/fastapi/routing.py:526:        response_model_exclude: Optional[IncEx] = None,\n/workspace/fastapi/routing.py:527:        response_model_by_alias: bool = True,\n/workspace/fastapi/routing.py:528:        response_model_exclude_unset: bool = False,\n/workspace/fastapi/routing.py:529:        response_model_exclude_defaults: bool = False,\n/workspace/fastapi/routing.py:530:        response_model_exclude_none: bool = False,\n/workspace/fastapi/routing.py:544:        if isinstance(response_model, DefaultPlaceholder):\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "__init__.py\nmain.py\ntest_additional_properties_bool.py\ntest_additional_properties.py\ntest_additional_response_extra.py\ntest_additional_responses_bad.py\ntest_additional_responses_custom_model_in_callback.py\ntest_additional_responses_custom_validationerror.py\ntest_additional_responses_default_validationerror.py\ntest_additional_responses_response_class.py\ntest_additional_responses_router.py\ntest_allow_inf_nan_in_enforcing.py\ntest_ambiguous_params.py\ntest_annotated.py\ntest_application.py\ntest_callable_endpoint.py\ntest_compat_params_v1.py\ntest_compat.py\ntest_computed_fields.py\ntest_custom_middleware_exception.py\ntest_custom_route_class.py\ntest_custom_schema_fields.py\ntest_custom_swagger_ui_redirect.py\ntest_datastructures.py\ntest_datetime_custom_encoder.py\ntest_default_response_class_router.py\ntest_default_response_class.py\ntest_dependency_after_yield_raise.py\ntest_dependency_after_yield_streaming.py\ntest_dependency_after_yield_websockets.py\ntest_dependency_cache.py\ntest_dependency_class.py\ntest_dependency_contextmanager.py\ntest_dependency_contextvars.py\ntest_dependency_duplicates.py\ntest_dependency_overrides.py\ntest_dependency_security_overrides.py\ntest_dependency_yield_except_httpexception.py\ntest_deprecated_openapi_prefix.py\ntest_duplicate_models_openapi.py\ntest_empty_router.py\ntest_enforce_once_required_parameter.py\ntest_exception_handlers.py\ntest_extra_routes.py\ntest_fastapi_cli.py\ntest_file_and_form_order_issue_9116.py\ntest_filter_pydantic_sub_model\ntest_filter_pydantic_sub_model_pv2.py\ntest_forms_from_non_typing_sequences.py\ntest_forms_single_model.py\ntest_forms_single_param.py\ntest_generate_unique_id_function.py\ntest_generic_parameterless_depends.py\ntest_get_model_definitions_formfeed_escape.py\ntest_get_request_body.py\ntest_http_connection_injection.py\ntest_include_route.py\ntest_include_router_defaults_overrides.py\ntest_infer_param_optionality.py\ntest_inherited_custom_class.py\n

{"status": "ok", "stdout": "============================= test session starts ==============================\nplatform darwin -- Python 3.13.15, pytest-9.1.1, pluggy-1.6.0\ncodspeed: 5.0.3 (disabled, mode: walltime, callgraph: not supported, timer_resolution: 41.7ns)\nrootdir: /private/workspace\nconfigfile: pytest.ini (WARNING: ignoring pytest config in pyproject.toml!)\nplugins: cov-7.1.0, xdist-3.8.0, timeout-2.4.0, codspeed-5.0.3, sugar-1.1.1, anyio-4.15.1, inline-snapshot-0.35.4\ncollected 6 items\n\ntests/test_openapi_separate_input_output_schemas.py ......               [100%]\n\n=============================== warnings summary ===============================\n../../../../../../../Users/jp/repos/kaggle-gemini-coding-agent-post-training/.envs/overlays/starlette-0.49.3-py3-none-any/starlette/testclient.py:51\n  /Users/jp/repos/kaggle-gemini-coding-agent-post-training/.envs/overlays/starlette-0.49.3-py3-none-any/starlette/testclient.py:51: DeprecationWarning: The anyio.abc.BlockingPortal alias is deprecated, use anyio.from_thread.BlockingPortal instead.\n    _PortalFactoryType = Callable[[], AbstractContextManager[anyio.abc.BlockingPortal]]\n\n-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html\n========================= 6 passed, 1 warning in 0.73s =========================\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "from typing import List, Optional\n\nfrom fastapi import FastAPI\nfrom fastapi.testclient import TestClient\nfrom inline_snapshot import snapshot\nfrom pydantic import BaseModel\n\nfrom .utils import PYDANTIC_V2, needs_pydanticv2\n\n\nclass SubItem(BaseModel):\n    subname: str\n    sub_description: Optional[str] = None\n    tags: List[str] = []\n    if PYDANTIC_V2:\n        model_config = {\"json_schema_serialization_defaults_required\": True}\n\n\nclass Item(BaseModel):\n    name: str\n    description: Optional[str] = None\n    sub: Optional[SubItem] = None\n    if PYDANTIC_V2:\n        model_config = {\"json_schema_serialization_defaults_required\": True}\n\n\ndef get_app_client(separate_input_output_schemas: bool = True) -> TestClient:\n    app = FastAPI(separate_input_output_schemas=separate_input_output_schemas)\n\n    @app.post(\"/items/\", responses={402: {\"model\": Item}})\n    def create_item(item: Item) -> Item:\n        return item\n\n    @app.post(\"/items-list/\")\n    def create_item_list(item: List[Item]):\n        return item\n\n    @app.get(\"/items/\")\n    def read_items() -> List[Item]:\n        return [\n            Item(\n                name=\"Portal Gun\",\n                description=\"Device to travel through the multi-rick-verse\",\n                sub=SubItem(subname=\"subname\"),\n            ),\n            Item(name=\"Plumbus\"),\n        ]\n\n    client = TestClient(app)\n    return client\n\n\ndef test_create_item():\n    client = get_app_client()\n    client_no = get_app_client(separate_input_output_schemas=False)\n    response = client.post(\"/items/\", json={\"name\": \"Plumbus\"})\n    response2 = client_no.post(\"/items/\", json={\"name\": \"Plumbus\"})\n    assert response.status_code == response2.status_code == 200, response.text\n    assert (\n        response.json()\n        == response2.json()\n        == {\"name\": \"Plumbus\", \"description\": None, \"sub\": None}\n    )\n\n\ndef test_create_

{"status": "ok", "stdout": "/workspace/fastapi/applications.py:786:        separate_input_output_schemas: Annotated[\n/workspace/fastapi/applications.py:870:        self.separate_input_output_schemas = separate_input_output_schemas\n/workspace/fastapi/applications.py:1073:                separate_input_output_schemas=self.separate_input_output_schemas,\n/workspace/fastapi/openapi/utils.py:102:    separate_input_output_schemas: bool = True,\n/workspace/fastapi/openapi/utils.py:133:                separate_input_output_schemas=separate_input_output_schemas,\n/workspace/fastapi/openapi/utils.py:175:    separate_input_output_schemas: bool = True,\n/workspace/fastapi/openapi/utils.py:184:        separate_input_output_schemas=separate_input_output_schemas,\n/workspace/fastapi/openapi/utils.py:258:    separate_input_output_schemas: bool = True,\n/workspace/fastapi/openapi/utils.py:288:                separate_input_output_schemas=separate_input_output_schemas,\n/workspace/fastapi/openapi/utils.py:309:                    separate_input_output_schemas=separate_input_output_schemas,\n/workspace/fastapi/openapi/utils.py:326:                            separate_input_output_schemas=separate_input_output_schemas,\n/workspace/fastapi/openapi/utils.py:356:                            separate_input_output_schemas=separate_input_output_schemas,\n/workspace/fastapi/openapi/utils.py:389:                            separate_input_output_schemas=separate_input_output_schemas,\n/workspace/fastapi/openapi/utils.py:481:    separate_input_output_schemas: bool = True,\n/workspace/fastapi/openapi/utils.py:507:        separate_input_output_schemas=separate_input_output_schemas,\n/workspace/fastapi/openapi/utils.py:516:                separate_input_output_schemas=separate_input_output_schemas,\n/workspace/fastapi/openapi/utils.py:535:                separate_input_output_schemas=separate_input_output_schemas,\n/workspace/fastapi/_compat/v1.py:243:    separate_input_output_schemas: bool = True,

{"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": "ok", "stdout": "import http.client\nimport inspect\nimport warnings\nfrom typing import Any, Dict, List, Optional, Sequence, Set, Tuple, Type, Union, cast\n\nfrom fastapi import routing\nfrom fastapi._compat import (\n    JsonSchemaValue,\n    ModelField,\n    Undefined,\n    get_compat_model_name_map,\n    get_definitions,\n    get_schema_from_model_field,\n    lenient_issubclass,\n)\nfrom fastapi.datastructures import DefaultPlaceholder\nfrom fastapi.dependencies.models import Dependant\nfrom fastapi.dependencies.utils import (\n    _get_flat_fields_from_params,\n    get_flat_dependant,\n    get_flat_params,\n)\nfrom fastapi.encoders import jsonable_encoder\nfrom fastapi.openapi.constants import METHODS_WITH_BODY, REF_PREFIX\nfrom fastapi.openapi.models import OpenAPI\nfrom fastapi.params import Body, ParamTypes\nfrom fastapi.responses import Response\nfrom fastapi.types import ModelNameMap\nfrom fastapi.utils import (\n    deep_dict_update,\n    generate_operation_id_for_path,\n    is_body_allowed_for_status_code,\n)\nfrom pydantic import BaseModel\nfrom starlette.responses import JSONResponse\nfrom starlette.routing import BaseRoute\nfrom typing_extensions import Literal\n\nfrom .._compat import _is_model_field\n\nvalidation_error_definition = {\n    \"title\": \"ValidationError\",\n    \"type\": \"object\",\n    \"properties\": {\n        \"loc\": {\n            \"title\": \"Location\",\n            \"type\": \"array\",\n            \"items\": {\"anyOf\": [{\"type\": \"string\"}, {\"type\": \"integer\"}]},\n        },\n        \"msg\": {\"title\": \"Message\", \"type\": \"string\"},\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "/workspace/fastapi/_compat/v1.py:236:def get_schema_from_model_field(\n/workspace/fastapi/_compat/__init__.py:23:from .main import get_schema_from_model_field as get_schema_from_model_field\n/workspace/fastapi/_compat/main.py:314:def get_schema_from_model_field(\n/workspace/fastapi/_compat/main.py:327:        return v1.get_schema_from_model_field(\n/workspace/fastapi/_compat/main.py:337:        return v2.get_schema_from_model_field(\n/workspace/fastapi/_compat/v2.py:174:def get_schema_from_model_field(\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        # ModelField to its JSON Schema.\n        return id(self)\n\n\ndef get_annotation_from_field_info(\n    annotation: Any, field_info: FieldInfo, field_name: str\n) -> Any:\n    return annotation\n\n\ndef _model_rebuild(model: Type[BaseModel]) -> None:\n    model.model_rebuild()\n\n\ndef _model_dump(\n    model: BaseModel, mode: Literal[\"json\", \"python\"] = \"json\", **kwargs: Any\n) -> Any:\n    return model.model_dump(mode=mode, **kwargs)\n\n\ndef _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 \"v

{"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) -> 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_name_to_new_name_map[ref_name]\n                new_schema[\"$ref\"] = REF_TEMPLATE.format(model=new_name)\n            else:\n                new_schema[\"$ref\"] = schema[\"$ref\"]\n            continue\n        if isinstance(value, dict):\n            new_schema[key] = _replace_refs(\n                schema=value,\n                old_name_to_new_name_map=old_name_to_new_name_map,\n            )\n        elif isinstance(value, list):\n            new_value = []\n            for item in value:\n                if isinstance(item, dict):\n                    new_item = _replace_refs(\n                        schema=item,\n                        old_name_to_new_name_map=old_name_to_new_name_map,\n                    )\n                    new_value.append(new_item)\n\n                else:\n         

{"status": "ok", "stdout": "            schema=schema,\n            old_name_to_new_name_map=old_name_to_new_name_map,\n        )\n        new_field_mapping[field_key] = new_schema\n\n    new_definitions = {}\n    for key, value in definitions.items():\n        if key in old_name_to_new_name_map:\n            new_key = old_name_to_new_name_map[key]\n        else:\n            new_key = key\n        new_value = _replace_refs(\n            schema=value,\n            old_name_to_new_name_map=old_name_to_new_name_map,\n        )\n        new_definitions[new_key] = new_value\n    return new_field_mapping, new_definitions\n\n\ndef is_scalar_field(field: ModelField) -> bool:\n    from fastapi import params\n\n    return shared.field_annotation_is_scalar(\n        field.field_info.annotation\n    ) and not isinstance(field.field_info, params.Body)\n\n\ndef is_sequence_field(field: ModelField) -> bool:\n    return shared.field_annotation_is_sequence(field.field_info.annotation)\n\n\ndef is_scalar_sequence_field(field: ModelField) -> bool:\n    return shared.field_annotation_is_scalar_sequence(field.field_info.annotation)\n\n\ndef is_bytes_field(field: ModelField) -> bool:\n    return shared.is_bytes_or_nonable_bytes_annotation(field.type_)\n\n\ndef is_bytes_sequence_field(field: ModelField) -> bool:\n    return shared.is_bytes_sequence_annotation(field.type_)\n\n\ndef copy_field_info(*, field_info: FieldInfo, annotation: Any) -> FieldInfo:\n    cls = type(field_info)\n    merged_field_info = cls.from_annotation(annotation)\n    new_field_info = copy(field_info)\n    new_field_info.metadata = merged_field_info.metadata\n    new_field_info.annotation = merged_field_info.annotation\n    return new_field_info\n\n", "stderr": "", "exit_code": 0}

{"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": "    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", "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", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "255:def get_definitions(\n256-    *,\n257-    fields: List[ModelField],\n258-    model_name_map: ModelNameMap,\n259-    separate_input_output_schemas: bool = True,\n260-) -> Tuple[\n261-    Dict[Tuple[ModelField, Literal[\"validation\", \"serialization\"]], JsonSchemaValue],\n262-    Dict[str, Dict[str, Any]],\n263-]:\n264-    models = get_flat_models_from_fields(fields, known_models=set())\n265-    return {}, get_model_definitions(flat_models=models, model_name_map=model_name_map)\n266-\n267-\n268-def is_scalar_field(field: ModelField) -> bool:\n269-    return is_pv1_scalar_field(field)\n270-\n271-\n272-def is_sequence_field(field: ModelField) -> bool:\n273-    return field.shape in sequence_shapes or shared._annotation_is_sequence(field.type_)\n274-\n275-\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "236:def get_schema_from_model_field(\n237-    *,\n238-    field: ModelField,\n239-    model_name_map: ModelNameMap,\n240-    field_mapping: Dict[\n241-        Tuple[ModelField, Literal[\"validation\", \"serialization\"]], JsonSchemaValue\n242-    ],\n243-    separate_input_output_schemas: bool = True,\n244-) -> Dict[str, Any]:\n245-    return field_schema(  # type: ignore[no-any-return]\n246-        field, model_name_map=model_name_map, ref_prefix=REF_PREFIX\n247-    )[0]\n248-\n249-\n250-# def get_compat_model_name_map(fields: List[ModelField]) -> ModelNameMap:\n251-#     models = get_flat_models_from_fields(fields, known_models=set())\n252-#     return get_model_name_map(models)  # type: ignore[no-any-return]\n253-\n254-\n255-def get_definitions(\n256-    *,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "/workspace/fastapi/_compat/v1.py:170:def get_model_definitions(\n/workspace/fastapi/_compat/v1.py:265:    return {}, get_model_definitions(flat_models=models, model_name_map=model_name_map)\n", "stderr": "", "exit_code": 0}

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

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

{"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": "    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", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    ],\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", "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": "                if isinstance(item, dict):\n                    new_item = _replace_refs(\n                        schema=item,\n                        old_name_to_new_name_map=old_name_to_new_name_map,\n                    )\n                    new_value.append(new_item)\n\n                else:\n                    new_value.append(item)\n            new_schema[key] = new_value\n    return new_schema\n\n\ndef _remap_definitions_and_field_mappings(\n    *,\n    model_name_map: ModelNameMap,\n    definitions: Dict[str, Any],\n    field_mapping: Dict[\n        Tuple[ModelField, Literal[\"validation\", \"serialization\"]], JsonSchemaValue\n    ],\n) -> Tuple[\n    Dict[Tuple[ModelField, Literal[\"validation\", \"serialization\"]], JsonSchemaValue],\n    Dict[str, Any],\n]:\n    old_name_to_new_name_map = {}\n    for field_key, schema in field_mapping.items():\n        model = field_key[0].type_\n        if model not in model_name_map:\n            continue\n        new_name = model_name_map[model]\n        old_name = schema[\"$ref\"].split(\"/\")[-1]\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        old_name = schema[\"$ref\"].split(\"/\")[-1]\n        if old_name in {f\"{new_name}-Input\", f\"{new_name}-Output\"}:\n            continue\n        old_name_to_new_name_map[old_name] = new_name\n\n    new_field_mapping: Dict[\n        Tuple[ModelField, Literal[\"validation\", \"serialization\"]], JsonSchemaValue\n    ] = {}\n    for field_key, schema in field_mapping.items():\n        new_schema = _replace_refs(\n            schema=schema,\n            old_name_to_new_name_map=old_name_to_new_name_map,\n        )\n        new_field_mapping[field_key] = new_schema\n\n    new_definitions = {}\n    for key, value in definitions.items():\n        if key in old_name_to_new_name_map:\n            new_key = old_name_to_new_name_map[key]\n        else:\n            new_key = key\n        new_value = _replace_refs(\n            schema=value,\n            old_name_to_new_name_map=old_name_to_new_name_map,\n        )\n        new_definitions[new_key] = new_value\n    return new_field_mapping, new_definitions\n\n\ndef is_scalar_field(field: ModelField) -> bool:\n    from fastapi import params\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": "\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            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

{"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": "    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", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    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_name_to_new_name_map[ref_name]\n                new_schema[\"$ref\"] = REF_TEMPLATE.format(model=new_name)\n            else:\n                new_schema[\"$ref\"] = schema[\"$ref\"]\n            continue\n        if isinstance(value, dict):\n            new_schema[key] = _replace_refs(\n                schema=value,\n                old_name_to_new_name_map=old_name_to_new_name_map,\n            )\n        elif isinstance(value, list):\n            new_value = []\n            for item in value:\n                if isinstance(item, dict):\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        old_name = schema[\"$ref\"].split(\"/\")[-1]\n        if old_name in {f\"{new_name}-Input\", f\"{new_name}-Output\"}:\n            continue\n        old_name_to_new_name_map[old_name] = new_name\n\n    new_field_mapping: Dict[\n        Tuple[ModelField, Literal[\"validation\", \"serialization\"]], JsonSchemaValue\n    ] = {}\n    for field_key, schema in field_mapping.items():\n        new_schema = _replace_refs(\n            schema=schema,\n            old_name_to_new_name_map=old_name_to_new_name_map,\n        )\n        new_field_mapping[field_key] = new_schema\n\n    new_definitions = {}\n    for key, value in definitions.items():\n        if key in old_name_to_new_name_map:\n            new_key = old_name_to_new_name_map[key]\n        else:\n            new_key = key\n        new_value = _replace_refs(\n            schema=value,\n            old_name_to_new_name_map=old_name_to_new_name_map,\n        )\n        new_definitions[new_key] = new_value\n    return new_field_mapping, new_definitions\n\n\ndef is_scalar_field(field: ModelField) -> bool:\n    from fastapi import params\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": ") -> Tuple[\n    Dict[Tuple[ModelField, Literal[\"validation\", \"serialization\"]], JsonSchemaValue],\n    Dict[str, Any],\n]:\n    old_name_to_new_name_map = {}\n    for field_key, schema in field_mapping.items():\n        model = field_key[0].type_\n        if model not in model_name_map:\n            continue\n        new_name = model_name_map[model]\n        old_name = schema[\"$ref\"].split(\"/\")[-1]\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        model = field_key[0].type_\n        if model not in model_name_map:\n            continue\n        new_name = model_name_map[model]\n        old_name = schema[\"$ref\"].split(\"/\")[-1]\n        if old_name in {f\"{new_name}-Input\", f\"{new_name}-Output\"}:\n            continue\n        old_name_to_new_name_map[old_name] = new_name\n\n    new_field_mapping: Dict[\n        Tuple[ModelField, Literal[\"validation\", \"serialization\"]], JsonSchemaValue\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}