fastapi_14430

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

{"status": "ok", "stdout": "4:from typing import Any, Callable, Dict, List, Optional, Sequence, Union\n33:        default_factory: Union[Callable[[], Any], None] = _Unset,\n36:        alias_priority: Union[int, None] = _Unset,\n39:        validation_alias: Union[str, None] = None,\n40:        serialization_alias: Union[str, None] = None,\n56:        discriminator: Union[str, None] = None,\n57:        strict: Union[bool, None] = _Unset,\n58:        multiple_of: Union[float, None] = _Unset,\n59:        allow_inf_nan: Union[bool, None] = _Unset,\n60:        max_digits: Union[int, None] = _Unset,\n61:        decimal_places: Union[int, None] = _Unset,\n71:        deprecated: Union[deprecated, str, bool, None] = None,\n73:        json_schema_extra: Union[Dict[str, Any], None] = None,\n147:        default_factory: Union[Callable[[], Any], None] = _Unset,\n150:        alias_priority: Union[int, None] = _Unset,\n153:        validation_alias: Union[str, None] = None,\n154:        serialization_alias: Union[str, None] = None,\n170:        discriminator: Union[str, None] = None,\n171:        strict: Union[bool, None] = _Unset,\n172:        multiple_of: Union[float, None] = _Unset,\n", "exit_code": 0}

{"status": "ok", "stdout": "12:    Union,\n44:def is_body_allowed_for_status_code(status_code: Union[int, str, None]) -> bool:\n69:    \"field (e.g. Union[Response, dict, None]) you can disable generating the \"\n81:    required: Union[bool, UndefinedType] = Undefined,\n82:    model_config: Union[Type[BaseConfig], None] = None,\n246:    first_item: Union[DefaultPlaceholder, DefaultType],\n247:    *extra_items: Union[DefaultPlaceholder, DefaultType],\n248:) -> Union[DefaultPlaceholder, DefaultType]:\n", "exit_code": 0}

{"status": "ok", "stdout": "./tests/test_union_inherited_body.py:20:def save_union_different_body(item: Union[ExtendedItem, Item]):\n./tests/test_union_body.py:20:def save_union_body(item: Union[OtherItem, Item]):\n./tests/test_response_model_as_return_annotation.py:235:def no_response_model_annotation_union_return_model1() -> Union[User, Item]:\n./tests/test_response_model_as_return_annotation.py:240:def no_response_model_annotation_union_return_model2() -> Union[User, Item]:\n./tests/test_union_forms.py:22:def post_union_form(data: Annotated[Union[UserForm, CompanyForm], Form()]):\n./docs/ko/docs/tutorial/extra-models.md:178:<a href=\"https://docs.pydantic.dev/latest/concepts/types/#unions\" class=\"external-link\" target=\"_blank\">`Union`</a>\uc744 \uc815\uc758\ud560\ub54c\ub294 \ub354 \uad6c\uccb4\uc801\uc778 \ud0c0\uc785\uc744 \uba3c\uc800 \ud3ec\ud568\ud558\uace0, \ub35c \uad6c\uccb4\uc801\uc778 \ud0c0\uc785\uc744 \uadf8 \ub4a4\uc5d0 \ub098\uc5f4\ud574\uc57c\ud569\ub2c8\ub2e4. \uc544\ub798 \uc608\uc81c\uc5d0\uc11c\ub294 `Union[PlaneItem, CarItem]` \ub97c \ubcf4\uba74, \ub354 \uad6c\uccb4\uc801\uc778 `PlaneItem`\uc774 `CarItem`\ubcf4\ub2e4 \uc55e\uc5d0 \uc704\uce58\ud569\ub2c8\ub2e4.\n./docs/es/docs/python-types.md:399:En Python 3.10, como alternativa a usar los gen\u00e9ricos `Union` y `Optional`, puedes usar la <abbr title='tambi\u00e9n llamado \"operador OR a nivel de bits\", pero ese significado no es relevante aqu\u00ed'>barra vertical (`|`)</abbr> para declarar uniones de tipos, eso es mucho mejor y m\u00e1s simple.\n./docs/es/docs/tutorial/extra-models.md:177:Al definir una <a href=\"https://docs.pydantic.dev/latest/concepts/types/#unions\" class=\"external-link\" target=\"_blank\">`Union`</a>, incluye el tipo m\u00e1s espec\u00edfico primero, seguido por el tipo menos espec\u00edfico. En el ejemplo a continuaci\u00f3n, el m\u00e1s espec\u00edfico `PlaneItem` viene antes de `CarItem` en `Union[PlaneItem, CarItem]`.\n./docs/de/docs/python-types.md:279:##

{"status": "ok", "stdout": "fastapi/dependencies/utils.py:838:    # Check if it's a Union type (covers both typing.Union and types.UnionType in Python 3.10+)\n", "exit_code": 0}

{"status": "ok", "filepath": "fastapi/dependencies/utils.py", "content": "                    params_to_process[key] = value\n            else:\n                params_to_process[key] = received_params.get(key)\n\n    if single_not_embedded_field:\n        field_info = first_field.field_info\n        assert isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param)), (\n            \"Params must be subclasses of Param\"\n        )\n        loc: Tuple[str, ...] = (field_info.in_.value,)\n        v_, errors_ = _validate_value_with_model_field(\n            field=first_field, value=params_to_process, values=values, loc=loc\n        )\n        return {first_field.name: v_}, errors_\n\n    for field in fields:\n        value = _get_multidict_value(field, received_params)\n        field_info = field.field_info\n        assert isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param)), (\n            \"Params must be subclasses of Param\"\n        )\n        loc = (field_info.in_.value, field.alias)\n        v_, errors_ = _validate_value_with_model_field(\n            field=field, value=value, values=values, loc=loc\n        )\n        if errors_:\n            errors.extend(errors_)\n        else:\n            values[field.name] = v_\n    return values, errors\n\n\ndef is_union_of_base_models(field_type: Any) -> bool:\n    \"\"\"Check if field type is a Union where all members are BaseModel subclasses.\"\"\"\n    from fastapi.types import UnionType\n\n    origin = get_origin(field_type)\n\n    # Check if it's a Union type (covers both typing.Union and types.UnionType in Python 3.10+)\n    if origin is not Union and origin is not UnionType:\n        return False\n\n    union_args = get_args(field_type)\n\n    for arg in union_args:\n        if not _is_model_class(arg):\n            return False\n\n    return True\n\n\ndef _should_embed_body_fields(fields: List[ModelField]) -> bool:\n    if not fields:\n        return False\n    # More than one dependenc

{"status": "ok", "stdout": "fastapi/dependencies/utils.py:832:def is_union_of_base_models(field_type: Any) -> bool:\nfastapi/dependencies/utils.py:869:        and not is_union_of_base_models(first_field.type_)\n", "exit_code": 0}

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

{"status": "ok", "stdout": "Union[ModelA, ModelB]: True\nOptional[ModelA]: False\nModelA | ModelB: True\nModelA | None: False\nModelA | ModelB | int: False\n", "exit_code": 0}

{"status": "ok", "filepath": "fastapi/dependencies/utils.py", "content": "\n\ndef is_union_of_base_models(field_type: Any) -> bool:\n    \"\"\"Check if field type is a Union where all members are BaseModel subclasses.\"\"\"\n    from fastapi.types import UnionType\n\n    origin = get_origin(field_type)\n\n    # Check if it's a Union type (covers both typing.Union and types.UnionType in Python 3.10+)\n    if origin is not Union and origin is not UnionType:\n        return False\n\n    union_args = get_args(field_type)\n\n    for arg in union_args:\n        if not _is_model_class(arg):\n            return False\n\n    return True\n\n\n", "start_line": 830, "end_line": 850, "total_lines": 1035, "is_truncated": false}

{"status": "ok", "stdout": "30:    _is_model_class,\n178:    if len(fields) == 1 and _is_model_class(first_field.type_):\n520:                    _is_model_class(field.type_)\n845:        if not _is_model_class(arg):\n868:        and not _is_model_class(first_field.type_)\n938:        and _is_model_class(first_field.type_)\n", "exit_code": 0}

{"status": "ok", "filepath": "fastapi/dependencies/utils.py", "content": "import dataclasses\nimport inspect\nfrom contextlib import AsyncExitStack, contextmanager\nfrom copy import copy, deepcopy\nfrom dataclasses import dataclass\nfrom typing import (\n    Any,\n    Callable,\n    Coroutine,\n    Dict,\n    ForwardRef,\n    List,\n    Mapping,\n    Optional,\n    Sequence,\n    Tuple,\n    Type,\n    Union,\n    cast,\n)\n\nimport anyio\nfrom fastapi import params\nfrom fastapi._compat import (\n    PYDANTIC_V2,\n    ModelField,\n    RequiredParam,\n    Undefined,\n    _is_error_wrapper,\n    _is_model_class,\n    copy_field_info,\n    create_body_model,\n    evaluate_forwardref,\n    field_annotation_is_scalar,\n    get_annotation_from_field_info,\n    get_cached_model_fields,\n    get_missing_field_error,\n    is_bytes_field,\n    is_bytes_sequence_field,\n    is_scalar_field,\n    is_scalar_sequence_field,\n    is_sequence_field,\n    is_uploadfile_or_nonable_uploadfile_annotation,\n    is_uploadfile_sequence_annotation,\n    lenient_issubclass,\n    may_v1,\n    sequence_types,\n    serialize_sequence_value,\n    value_is_sequence,\n)\n", "start_line": 1, "end_line": 50, "total_lines": 1035, "is_truncated": false}

{"status": "ok", "stdout": "Union[ModelA, ModelB]: True\nOptional[ModelA]: False\nModelA | ModelB: True\nModelA | None: False\n", "exit_code": 0}

{"status": "error", "error_type": "CommandError", "error_message": "Command failed with exit code 1", "details": {"stdout": "", "stderr": "", "exit_code": 1}}

{"status": "ok", "filepath": "fastapi/dependencies/utils.py", "content": "\n\ndef is_union_of_base_models(field_type: Any) -> bool:\n    \"\"\"Check if field type is a Union where all members are BaseModel subclasses.\"\"\"\n    from fastapi.types import UnionType\n\n    origin = get_origin(field_type)\n\n    # Check if it's a Union type (covers both typing.Union and types.UnionType in Python 3.10+)\n    if origin is not Union and origin is not UnionType:\n        return False\n\n    union_args = get_args(field_type)\n\n    for arg in union_args:\n        if not _is_model_class(arg):\n            return False\n\n    return True\n\n\ndef _should_embed_body_fields(fields: List[ModelField]) -> bool:\n    if not fields:\n        return False\n    # More than one dependency could have the same field, it would show up as multiple\n    # fields but it's the same one, so count them by name\n    body_param_names_set = {field.name for field in fields}\n    # A top level field has to be a single field, not multiple\n    if len(body_param_names_set) > 1:\n        return True\n    first_field = fields[0]\n", "start_line": 830, "end_line": 860, "total_lines": 1035, "is_truncated": false}

{"status": "ok", "stdout": "Optional[List[ModelA]]: False\nList[ModelA] | None: False\n", "exit_code": 0}

{"status": "ok", "stdout": "ModelA: True\nList[ModelA]: False\nUnion[ModelA, ModelB]: True\n", "exit_code": 0}

{"status": "ok", "stdout": "ModelA: True\nList[ModelA]: False\nOptional[ModelA]: False\n", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/dependencies/utils.py:834:    from fastapi.types import UnionType\nfastapi/dependencies/utils.py:838:    # Check if it's a Union type (covers both typing.Union and types.UnionType in Python 3.10+)\nfastapi/dependencies/utils.py:839:    if origin is not Union and origin is not UnionType:\nfastapi/_compat/shared.py:20:from fastapi.types import UnionType\nfastapi/_compat/shared.py:39:        types.UnionType,\nfastapi/_compat/shared.py:85:    if origin is Union or origin is UnionType:\nfastapi/_compat/shared.py:111:    if origin is Union or origin is UnionType:\nfastapi/_compat/shared.py:132:    if origin is Union or origin is UnionType:\nfastapi/_compat/shared.py:151:    if origin is Union or origin is UnionType:\nfastapi/_compat/shared.py:162:    if origin is Union or origin is UnionType:\nfastapi/_compat/shared.py:171:    if origin is Union or origin is UnionType:\nfastapi/_compat/shared.py:186:    if origin is Union or origin is UnionType:\nfastapi/_compat/shared.py:203:    if origin is Union or origin is UnionType:\nfastapi/types.py:8:UnionType = getattr(types, \"UnionType\", Union)\n", "exit_code": 0}

{"status": "ok", "filepath": "fastapi/_compat/shared.py", "content": "        return isinstance(cls, type) and issubclass(cls, class_or_tuple)  # type: ignore[arg-type]\n    except TypeError:  # pragma: no cover\n        if isinstance(cls, WithArgsTypes):\n            return False\n        raise  # pragma: no cover\n\n\ndef _annotation_is_sequence(annotation: Union[Type[Any], None]) -> bool:\n    if lenient_issubclass(annotation, (str, bytes)):\n        return False\n    return lenient_issubclass(annotation, sequence_types)  # type: ignore[arg-type]\n\n\ndef field_annotation_is_sequence(annotation: Union[Type[Any], None]) -> bool:\n    origin = get_origin(annotation)\n    if origin is Union or origin is UnionType:\n        for arg in get_args(annotation):\n            if field_annotation_is_sequence(arg):\n                return True\n        return False\n    return _annotation_is_sequence(annotation) or _annotation_is_sequence(\n        get_origin(annotation)\n    )\n\n\ndef value_is_sequence(value: Any) -> bool:\n    return isinstance(value, sequence_types) and not isinstance(value, (str, bytes))  # type: ignore[arg-type]\n\n\ndef _annotation_is_complex(annotation: Union[Type[Any], None]) -> bool:\n    return (\n        lenient_issubclass(\n            annotation, (BaseModel, may_v1.BaseModel, Mapping, UploadFile)\n        )\n        or _annotation_is_sequence(annotation)\n        or is_dataclass(annotation)\n    )\n\n\ndef field_annotation_is_complex(annotation: Union[Type[Any], None]) -> bool:\n    origin = get_origin(annotation)\n    if origin is Union or origin is UnionType:\n        return any(field_annotation_is_complex(arg) for arg in get_args(annotation))\n\n    if origin is Annotated:\n        return field_annotation_is_complex(get_args(annotation)[0])\n\n    return (\n        _annotation_is_complex(annotation)\n        or _annotation_is_complex(origin)\n        or hasattr(origin, \"__pydantic_core_schema__\")\n        or hasattr(origin, \"__get_pydantic

{"status": "ok", "stdout": "Union[ModelA, ModelB]: True\nOptional[ModelA]: False\nModelA | ModelB: True\nModelA | None: False\n", "exit_code": 0}

{"status": "error", "error_type": "FileEditError", "error_message": "old_string not found in file (tried exact, flexible and regex matching)"}

{"status": "ok", "filepath": "fastapi/dependencies/utils.py", "content": "        return False\n\n    union_args = get_args(field_type)\n\n    for arg in union_args:\n        if not _is_model_class(arg):\n            return False\n", "start_line": 840, "end_line": 846, "total_lines": 1035, "is_truncated": false}

{"status": "ok", "filepath": "fastapi/dependencies/utils.py", "occurrences": 1, "strategy": "exact", "diff": "--- a/fastapi/dependencies/utils.py\n+++ b/fastapi/dependencies/utils.py\n@@ -842,7 +842,7 @@\n     union_args = get_args(field_type)\n \n     for arg in union_args:\n-        if not _is_model_class(arg):\n+        if arg is not None and not _is_model_class(arg):\n             return False\n \n     return True\n", "is_truncated": false}

{"status": "ok", "stdout": "Union[ModelA, ModelB]: True\nOptional[ModelA]: False\nModelA | ModelB: True\nModelA | None: False\n", "exit_code": 0}

{"status": "ok", "stdout": "Union[ModelA, ModelB]: True\nOptional[ModelA]: False\nModelA | ModelB: True\nModelA | None: False\n", "exit_code": 0}

{"status": "ok", "stdout": "Type: typing.Optional[__main__.ModelA]\nArgs: (<class '__main__.ModelA'>, <class 'NoneType'>)\nunion_args: (<class '__main__.ModelA'>, <class 'NoneType'>)\narg: <class '__main__.ModelA'>, is None: False, _is_model_class: True\narg: <class 'NoneType'>, is None: False, _is_model_class: False\nResult: False\n", "exit_code": 0}

{"status": "ok", "filepath": "fastapi/dependencies/utils.py", "occurrences": 1, "strategy": "exact", "diff": "--- a/fastapi/dependencies/utils.py\n+++ b/fastapi/dependencies/utils.py\n@@ -842,7 +842,7 @@\n     union_args = get_args(field_type)\n \n     for arg in union_args:\n-        if arg is not None and not _is_model_class(arg):\n+        if arg is not type(None) and not _is_model_class(arg):\n             return False\n \n     return True\n", "is_truncated": false}

{"status": "ok", "stdout": "Union[ModelA, ModelB]: True\nOptional[ModelA]: True\nModelA | ModelB: True\nModelA | None: True\n", "exit_code": 0}

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