fastapi_13207

{"status": "ok", "stdout": "./tests/test_openapi_separate_input_output_schemas.py:27:def get_app_client(separate_input_output_schemas: bool = True) -> TestClient:\n./tests/test_openapi_separate_input_output_schemas.py:28:    app = FastAPI(separate_input_output_schemas=separate_input_output_schemas)\n./tests/test_openapi_separate_input_output_schemas.py:55:    client_no = get_app_client(separate_input_output_schemas=False)\n./tests/test_openapi_separate_input_output_schemas.py:68:    client_no = get_app_client(separate_input_output_schemas=False)\n./tests/test_openapi_separate_input_output_schemas.py:89:    client_no = get_app_client(separate_input_output_schemas=False)\n./tests/test_openapi_separate_input_output_schemas.py:116:    client_no = get_app_client(separate_input_output_schemas=False)\n./tests/test_openapi_separate_input_output_schemas.py:360:    client = get_app_client(separate_input_output_schemas=False)\n./docs/ru/docs/how-to/separate-openapi-schemas.md:86:\u0412 \u0442\u0430\u043a\u043e\u043c \u0441\u043b\u0443\u0447\u0430\u0435 \u0432\u044b \u043c\u043e\u0436\u0435\u0442\u0435 \u043e\u0442\u043a\u043b\u044e\u0447\u0438\u0442\u044c \u044d\u0442\u0443 \u0444\u0443\u043d\u043a\u0446\u0438\u043e\u043d\u0430\u043b\u044c\u043d\u043e\u0441\u0442\u044c \u0432 FastAPI \u0441 \u043f\u043e\u043c\u043e\u0449\u044c\u044e \u043f\u0430\u0440\u0430\u043c\u0435\u0442\u0440\u0430 `separate_input_output_schemas=False`.\n./docs/ru/docs/how-to/separate-openapi-schemas.md:90:\u041f\u043e\u0434\u0434\u0435\u0440\u0436\u043a\u0430 `separate_input_output_schemas` \u043f\u043e\u044f\u0432\u0438\u043b\u0430\u0441\u044c \u0432 FastAPI `0.102.0`. \ud83e\udd13\n./docs/pt/docs/how-to/separate-openapi-schemas.md:86:Nesse caso, voc\u00ea pode desativar esse recurso no **FastAPI**, com o par\u00e2metro `separate_input_output_schemas=False`.\n./docs/pt/docs/how-to/separate-openapi-schemas.md:90:O suporte para `separate_input_output_schemas` foi adicionado no FastAPI `0.102.0`. \ud83e\ud

{"status": "error", "error_type": "CommandError", "error_message": "cat: /tests/test_openapi_separate_input_output_schemas.py: No such file or directory\n", "details": {"stdout": "", "stderr": "cat: /tests/test_openapi_separate_input_output_schemas.py: No such file or directory\n", "exit_code": 1}}

{"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": "Schema True Components:\ndict_keys(['Item'])\n\nSchema False Components:\ndict_keys(['Item'])\n\nFound name_upper (True): True\nFound name_upper (False): False\n\nIssue reproduced: Computed field missing when separate_input_output_schemas=False\n", "stderr": "", "exit_code": 0}

{"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": "error", "error_type": "CommandError", "error_message": "", "details": {"stdout": "", "stderr": "", "exit_code": 1}}

{"status": "ok", "stdout": "fastapi/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", "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        \"type\": {\"title\": \"Error Type\", \"type\": \"string\"},\n    },\n    \"required\": [\"loc\", \"msg\", \"type\"],\n}\n\nvalidation_error_response_definition = {\n    \"title\": \"HTTPValidationError\",\n    \"type\": \"object\",\n    \"properties\": {\n        \"detail\": {\n            \"title\": \"Detail\",\n            \"type\": \"array\",\n            \"

{"status": "ok", "stdout": "__init__.py\nmain.py\nmay_v1.py\nmodel_field.py\nshared.py\nv1.py\nv2.py\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/_compat/v1.py:236:def get_schema_from_model_field(\nfastapi/_compat/__init__.py:23:from .main import get_schema_from_model_field as 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(\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "def _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 \"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_va

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

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

{"status": "ok", "stdout": "fastapi/_compat/v1.py:149:class GenerateJsonSchema:\nfastapi/_compat/v2.py:31:from pydantic.json_schema import GenerateJsonSchema as GenerateJsonSchema\nfastapi/_compat/v2.py:186:    # This expects that GenerateJsonSchema was already used to generate the definitions\nfastapi/_compat/v2.py:206:    schema_generator = GenerateJsonSchema(ref_template=REF_TEMPLATE)\n", "stderr": "", "exit_code": 0}

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

{"status": "ok", "stdout": "<class 'pydantic.json_schema.GenerateJsonSchema'>\n", "stderr": "", "exit_code": 0}

{"status": "error", "error_type": "CommandError", "error_message": "  File \"<string>\", line 1\n    from pydantic import BaseModel; from pydantic.json_schema import GenerateJsonSchema; class Item(BaseModel): name: str; item = Item(name='foo'); print(GenerateJsonSchema().generate_definitions([(Item, 'validation', Item.model_json_schema().get('properties')))])\n                                                                                                                                                                                                                                                                     ^\nSyntaxError: closing parenthesis ')' does not match opening parenthesis '['\n", "details": {"stdout": "", "stderr": "  File \"<string>\", line 1\n    from pydantic import BaseModel; from pydantic.json_schema import GenerateJsonSchema; class Item(BaseModel): name: str; item = Item(name='foo'); print(GenerateJsonSchema().generate_definitions([(Item, 'validation', Item.model_json_schema().get('properties')))])\n                                                                                                                                                                                                                                                                     ^\nSyntaxError: closing parenthesis ')' does not match opening parenthesis '['\n", "exit_code": 1}}

{"status": "error", "error_type": "CommandError", "error_message": "  File \"<string>\", line 1\n    from pydantic import BaseModel; from pydantic.json_schema import GenerateJsonSchema; class Item(BaseModel): name: str; print(GenerateJsonSchema().generate_definitions([(Item, 'validation', Item.model_json_schema().get('properties')))])\n                                                                                                                                                                                                                                            ^\nSyntaxError: closing parenthesis ')' does not match opening parenthesis '['\n", "details": {"stdout": "", "stderr": "  File \"<string>\", line 1\n    from pydantic import BaseModel; from pydantic.json_schema import GenerateJsonSchema; class Item(BaseModel): name: str; print(GenerateJsonSchema().generate_definitions([(Item, 'validation', Item.model_json_schema().get('properties')))])\n                                                                                                                                                                                                                                            ^\nSyntaxError: closing parenthesis ')' does not match opening parenthesis '['\n", "exit_code": 1}}

{"status": "error", "error_type": "CommandError", "error_message": "  File \"<string>\", line 1\n    from pydantic import BaseModel; from pydantic.json_schema import GenerateJsonSchema; class Item(BaseModel): name: str; print(GenerateJsonSchema().generate_definitions([(Item, 'validation', {})]))\n                                                                                         ^^^^^\nSyntaxError: invalid syntax\n", "details": {"stdout": "", "stderr": "  File \"<string>\", line 1\n    from pydantic import BaseModel; from pydantic.json_schema import GenerateJsonSchema; class Item(BaseModel): name: str; print(GenerateJsonSchema().generate_definitions([(Item, 'validation', {})]))\n                                                                                         ^^^^^\nSyntaxError: invalid syntax\n", "exit_code": 1}}

{"status": "error", "error_type": "CommandError", "error_message": "  File \"<string>\", line 1\n    from pydantic import BaseModel; from pydantic.json_schema import GenerateJsonSchema; class Item(BaseModel): name: str; print(GenerateJsonSchema().generate_definitions([(Item, 'validation', Item.__pydantic_core_schema__)])\n                                                                                         ^^^^^\nSyntaxError: invalid syntax\n", "details": {"stdout": "", "stderr": "  File \"<string>\", line 1\n    from pydantic import BaseModel; from pydantic.json_schema import GenerateJsonSchema; class Item(BaseModel): name: str; print(GenerateJsonSchema().generate_definitions([(Item, 'validation', Item.__pydantic_core_schema__)])\n                                                                                         ^^^^^\nSyntaxError: invalid syntax\n", "exit_code": 1}}

{"status": "error", "error_type": "CommandError", "error_message": "  File \"<string>\", line 1\n    from pydantic import BaseModel; from pydantic.json_schema import GenerateJsonSchema; class Item(BaseModel): name: str; print(GenerateJsonSchema().generate_definitions([(Item, 'validation', Item.__pydantic_core_schema__)]))\n                                                                                         ^^^^^\nSyntaxError: invalid syntax\n", "details": {"stdout": "", "stderr": "  File \"<string>\", line 1\n    from pydantic import BaseModel; from pydantic.json_schema import GenerateJsonSchema; class Item(BaseModel): name: str; print(GenerateJsonSchema().generate_definitions([(Item, 'validation', Item.__pydantic_core_schema__)]))\n                                                                                         ^^^^^\nSyntaxError: invalid syntax\n", "exit_code": 1}}