fastapi_13207

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

{"status": "ok", "filepath": "fastapi/openapi/utils.py", "content": "        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                

{"status": "ok", "stdout": "fastapi/_compat/__init__.py:23:from .main import get_schema_from_model_field as get_schema_from_model_field\nfastapi/_compat/v1.py:236:def get_schema_from_model_field(\nfastapi/_compat/main.py:314:def get_schema_from_model_field(\nfastapi/_compat/main.py:327:        return v1.get_schema_from_model_field(\nfastapi/_compat/main.py:337:        return v2.get_schema_from_model_field(\nfastapi/_compat/v2.py:174:def get_schema_from_model_field(\nfastapi/openapi/utils.py:13:    get_schema_from_model_field,\nfastapi/openapi/utils.py:129:            param_schema = get_schema_from_model_field(\nfastapi/openapi/utils.py:180:    body_schema = get_schema_from_model_field(\nfastapi/openapi/utils.py:352:                        response_schema = get_schema_from_model_field(\nfastapi/openapi/utils.py:385:                        additional_field_schema = get_schema_from_model_field(\n", "exit_code": 0}

{"status": "ok", "filepath": "fastapi/_compat/v2.py", "content": "        # 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 

{"status": "ok", "filepath": "fastapi/_compat/v2.py", "content": "            name=model.__name__,\n            mode=\"validation\",\n        )\n        for model in flat_validation_models\n    ]\n    flat_serialization_model_fields = [\n        ModelField(\n            field_info=FieldInfo(annotation=model),\n            name=model.__name__,\n            mode=\"serialization\",\n        )\n        for model in flat_serialization_models\n    ]\n    flat_model_fields = flat_validation_model_fields + flat_serialization_model_fields\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            value = schema[\"$ref\"]\n            if isinstance(value, str):\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_s

{"status": "ok", "filepath": "fastapi/_compat/v1.py", "content": "    SHAPE_LIST: list,\n    SHAPE_SET: set,\n    SHAPE_TUPLE: tuple,\n    SHAPE_SEQUENCE: list,\n    SHAPE_TUPLE_ELLIPSIS: list,\n}\n\n\n@dataclass\nclass GenerateJsonSchema:\n    ref_template: str\n\n\nclass PydanticSchemaGenerationError(Exception):\n    pass\n\n\nRequestErrorModel: Type[BaseModel] = create_model(\"Request\")\n\n\ndef with_info_plain_validator_function(\n    function: Callable[..., Any],\n    *,\n    ref: Union[str, None] = None,\n    metadata: Any = None,\n    serialization: Any = None,\n) -> Any:\n    return {}\n\n\ndef get_model_definitions(\n    *,\n    flat_models: Set[Union[Type[BaseModel], Type[Enum]]],\n    model_name_map: Dict[Union[Type[BaseModel], Type[Enum]], str],\n) -> Dict[str, Any]:\n    definitions: Dict[str, Dict[str, Any]] = {}\n    for model in flat_models:\n        m_schema, m_definitions, m_nested_models = model_process_schema(\n            model, model_name_map=model_name_map, ref_prefix=REF_PREFIX\n        )\n        definitions.update(m_definitions)\n", "start_line": 140, "end_line": 180, "total_lines": 312, "is_truncated": false}

{"status": "ok", "filepath": "fastapi/_compat/v1.py", "content": "\n\ndef _get_model_config(model: BaseModel) -> Any:\n    return model.__config__  # type: ignore[attr-defined]\n\n\ndef get_schema_from_model_field(\n    *,\n    field: ModelField,\n    model_name_map: ModelNameMap,\n    field_mapping: Dict[\n        Tuple[ModelField, Literal[\"validation\", \"serialization\"]], JsonSchemaValue\n    ],\n    separate_input_output_schemas: bool = True,\n) -> Dict[str, Any]:\n    return field_schema(  # type: ignore[no-any-return]\n        field, model_name_map=model_name_map, ref_prefix=REF_PREFIX\n    )[0]\n\n\n# def get_compat_model_name_map(fields: List[ModelField]) -> ModelNameMap:\n#     models = get_flat_models_from_fields(fields, known_models=set())\n#     return get_model_name_map(models)  # type: ignore[no-any-return]\n\n\ndef get_definitions(\n    *,\n    fields: List[ModelField],\n    model_name_map: ModelNameMap,\n    separate_input_output_schemas: bool = True,\n) -> Tuple[\n", "start_line": 230, "end_line": 260, "total_lines": 312, "is_truncated": false}

{"status": "error", "error_type": "CommandError", "error_message": "Command failed with exit code 1", "details": {"stdout": "", "stderr": "Traceback (most recent call last):\n  File \"/tmp/swe_work/eval3_submission/fastapi_13207/a/tmp/repro.py\", line 37, in <module>\n    test_openapi_schema()\n    ~~~~~~~~~~~~~~~~~~~^^\n  File \"/tmp/swe_work/eval3_submission/fastapi_13207/a/tmp/repro.py\", line 27, in test_openapi_schema\n    response_ref = path_item[\"responses\"][\"200\"][\"content\"][\"application/json\"][\"schema\"][\"\"]\n                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^^^\nKeyError: ''\n", "exit_code": 1}}

{"status": "ok", "stdout": "Model schema properties: []\nTest failed: Computed field 'total' missing from OpenAPI schema when separate_input_output_schemas=False\n", "exit_code": 0}

{"status": "ok", "filepath": "fastapi/_compat/v2.py", "content": "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", "start_line": 170, "end_line": 200, "total_lines": 486, "is_truncated": false}

{"status": "ok", "filepath": "fastapi/_compat/v2.py", "content": "    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    validation_fields = [field for field in fields if field.mode == \"validation\"]\n    serialization_fields = [field for field in fields if field.mode == \"serialization\"]\n    flat_validation_models = get_flat_models_from_fields(\n        validation_fields, known_models=set()\n    )\n    flat_serialization_models = get_flat_models_from_fields(\n        serialization_fields, known_models=set()\n    )\n    flat_validation_model_fields = [\n        ModelField(\n            field_info=FieldInfo(annotation=model),\n            name=model.__name__,\n            mode=\"validation\",\n        )\n        for model in flat_validation_models\n    ]\n    flat_serialization_model_fields = [\n        ModelField(\n            field_info=FieldInfo(annotation=model),\n            name=model.__name__,\n            mode=\"serialization\",\n        )\n        for model in flat_serialization_models\n    ]\n    flat_model_fields = flat_validation_model_fields + flat_serialization_model_fields\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_de

{"status": "error", "error_type": "FileEditError", "error_message": "old_string matched 2 occurrences; provide more context or set allow_multiple"}

{"status": "ok", "filepath": "fastapi/_compat/v2.py", "occurrences": 1, "strategy": "exact", "diff": "--- a/fastapi/_compat/v2.py\n+++ b/fastapi/_compat/v2.py\n@@ -180,8 +180,8 @@\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+    override_mode: Union[Literal[\"serialization\"], None] = (\n+        None if separate_input_output_schemas else \"serialization\"\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", "is_truncated": false}

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

{"status": "ok", "stdout": "Test passed!\n", "exit_code": 0}

{"status": "ok", "filepath": "fastapi/_compat/v2.py", "content": "    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    validation_fields = [field for field in fields if field.mode == \"validation\"]\n    serialization_fields = [field for field in fields if field.mode == \"serialization\"]\n    flat_validation_models = get_flat_models_from_fields(\n        validation_fields, known_models=set()\n    )\n    flat_serialization_models = get_flat_models_from_fields(\n        serialization_fields, known_models=set()\n    )\n    flat_validation_model_fields = [\n        ModelField(\n            field_info=FieldInfo(annotation=model),\n            name=model.__name__,\n            mode=\"validation\",\n        )\n        for model in flat_validation_models\n    ]\n    flat_serialization_model_fields = [\n        ModelField(\n            field_info=FieldInfo(annotation=model),\n            name=model.__name__,\n            mode=\"serialization\",\n", "start_line": 200, "end_line": 230, "total_lines": 486, "is_truncated": false}

{"status": "ok", "filepath": "fastapi/_compat/v2.py", "occurrences": 1, "strategy": "exact", "diff": "--- a/fastapi/_compat/v2.py\n+++ b/fastapi/_compat/v2.py\n@@ -204,8 +204,8 @@\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+    override_mode: Union[Literal[\"serialization\"], None] = (\n+        None if separate_input_output_schemas else \"serialization\"\n     )\n     validation_fields = [field for field in fields if field.mode == \"validation\"]\n     serialization_fields = [field for field in fields if field.mode == \"serialization\"]\n", "is_truncated": false}

{"status": "ok", "stdout": "Model schema properties: []\nTest failed: Computed field 'total' missing from OpenAPI schema when separate_input_output_schemas=False\nTest passed!\n", "exit_code": 0}

{"status": "ok", "stdout": "Model schema properties: []\nTest failed: Computed field 'total' missing from OpenAPI schema when separate_input_output_schemas=False\n", "exit_code": 0}

{"status": "ok", "filepath": "fastapi/_compat/v2.py", "content": "            field_info=FieldInfo(annotation=model),\n            name=model.__name__,\n            mode=\"validation\",\n        )\n        for model in flat_validation_models\n    ]\n    flat_serialization_model_fields = [\n        ModelField(\n            field_info=FieldInfo(annotation=model),\n            name=model.__name__,\n            mode=\"serialization\",\n        )\n        for model in flat_serialization_models\n    ]\n    flat_model_fields = flat_validation_model_fields + flat_serialization_model_fields\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", "start_line": 220, "end_line": 260, "total_lines": 486, "is_truncated": false}

{"status": "ok", "stdout": "Model schema properties: []\nTest failed: Computed field 'total' missing from OpenAPI schema when separate_input_output_schemas=False\n", "exit_code": 0}

{"status": "ok", "filepath": "fastapi/_compat/v2.py", "content": "    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[\"serialization\"], None] = (\n        None if separate_input_output_schemas else \"serialization\"\n    )\n    validation_fields = [field for field in fields if field.mode == \"validation\"]\n    serialization_fields = [field for field in fields if field.mode == \"serialization\"]\n    flat_validation_models = get_flat_models_from_fields(\n        validation_fields, known_models=set()\n    )\n    flat_serialization_models = get_flat_models_from_fields(\n        serialization_fields, known_models=set()\n    )\n    flat_validation_model_fields = [\n        ModelField(\n            field_info=FieldInfo(annotation=model),\n            name=model.__name__,\n            mode=\"validation\",\n        )\n        for model in flat_validation_models\n    ]\n    flat_serialization_model_fields = [\n        ModelField(\n            field_info=FieldInfo(annotation=model),\n            name=model.__name__,\n            mode=\"serialization\",\n        )\n        for model in flat_serialization_models\n    ]\n    flat_model_fields = flat_validation_model_fields + flat_serialization_model_fields\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 \"descri

{"status": "ok", "stdout": "Model schema properties: []\nTest failed: Computed field 'total' missing from OpenAPI schema when separate_input_output_schemas=False\n", "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", "exit_code": 0}

{"status": "ok", "stdout": "Model schema properties: []\nTest failed: Computed field 'total' missing from OpenAPI schema when separate_input_output_schemas=False\n", "exit_code": 0}

{"status": "ok", "stdout": "Model schema properties: []\nTest failed: Computed field 'total' missing from OpenAPI schema when separate_input_output_schemas=True\n", "exit_code": 0}

{"status": "ok", "stdout": "Model schema properties: []\nTest failed: Computed field 'total' missing from OpenAPI schema\n", "exit_code": 0}

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

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

{"status": "ok", "filepath": "fastapi/openapi/utils.py", "content": "                # Make sure required definitions of the same parameter take precedence\n                # over non-required definitions\n                all_parameters.update(required_parameters)\n                operation[\"parameters\"] = list(all_parameters.values())\n            if method in METHODS_WITH_BODY:\n                request_body_oai = get_openapi_operation_request_body(\n                    body_field=route.body_field,\n                    model_name_map=model_name_map,\n                    field_mapping=field_mapping,\n                    separate_input_output_schemas=separate_input_output_schemas,\n                )\n                if request_body_oai:\n                    operation[\"requestBody\"] = request_body_oai\n            if route.callbacks:\n                callbacks = {}\n                for callback in route.callbacks:\n                    if isinstance(callback, routing.APIRoute):\n                        (\n                            cb_path,\n                            cb_security_schemes,\n                            cb_definitions,\n                        ) = get_openapi_path(\n                            route=callback,\n                            operation_ids=operation_ids,\n                            model_name_map=model_name_map,\n                            field_mapping=field_mapping,\n                            separate_input_output_schemas=separate_input_output_schemas,\n                        )\n                        callbacks[callback.name] = {callback.path: cb_path}\n                operation[\"callbacks\"] = callbacks\n            if route.status_code is not None:\n                status_code = str(route.status_code)\n            else:\n                # It would probably make more sense for all response classes to have an\n                # explicit default status_code, and to extract it from them, instead of\n                # doing this in

{"status": "ok", "patch_size": 1280, "files_changed": 1}