fastapi_14430

{
 "command": "grep -rn \"Union\" fastapi/fastapi | grep \"Python 3.10\" || grep -rn \"Union\" fastapi/fastapi | head -20"
}

{
 "command": "ls -F"
}

{
 "command": "grep -rn \"Union\" fastapi/ | grep \"3.10\" | head -20"
}

{
 "command": "sed -n '800,860p' fastapi/dependencies/utils.py"
}

{
 "command": "grep -rn \"UnionType\" fastapi/"
}

{
 "command": "sed -n '10,210p' fastapi/_compat/shared.py"
}

{
 "command": "python3 - <<'PY'\nimport typing\nimport types\nfrom typing_extensions import get_origin, get_args\n\ndef check_field_annotation_is_sequence(annotation):\n    # Simulating the logic in fastapi/_compat/shared.py\n    # sequence_types = (Sequence, List, list, Tuple, tuple, Set, set, FrozenSet, frozenset, Deque, deque)\n    from typing import Sequence, List, Tuple, Set, FrozenSet\n    from collections import deque\n    sequence_types = (Sequence, List, list, Tuple, tuple, Set, set, FrozenSet, frozenset, deque)\n    \n    def lenient_issubclass(cls, class_or_tuple):\n        try:\n            return isinstance(cls, type) and issubclass(cls, class_or_tuple)\n        except TypeError:\n            return False\n\n    def _annotation_is_sequence(annotation):\n        if lenient_issubclass(annotation, (str, bytes)):\n            return False\n        return lenient_issubclass(annotation, sequence_types)\n\n    origin = get_origin(annotation)\n    # This is the part we are testing\n    UnionType = getattr(types, \"UnionType\", typing.Union)\n    if origin is typing.Union or origin is UnionType:\n        for arg in get_args(annotation):\n            # We need to call field_annotation_is_sequence recursively, \n            # but for this test we'll just use the inner logic.\n            # Let's refine the structure to match the real function.\n            pass\n    return False\n\n# The actual function from the codebase\ndef field_annotation_is_sequence_impl(annotation, sequence_types, lenient_issubclass, _annotation_is_sequence):\n    origin = get_origin(annotation)\n    UnionType = getattr(types, \"UnionType\", typing.Union)\n    if origin is typing.Union or origin is UnionType:\n        for arg in get_args(annotation):\n            # Recursive call\n            if field_annotation_is_sequence_impl(arg, sequence_types, lenient_issubclass, _annotation_is_sequence):\n                return True\n        return False\n    return _annotation_is_sequence(annotation) or _annotation_is_sequence(\n        get_origin(annotation)\n    )\n\ndef _annotation_is_sequence_impl(annotation, sequence_types, lenient_issubclass):\n    if lenient_issubclass(annotation, (str, bytes)):\n        return False\n    return lenient_issubclass(annotation, sequence_types)\n\ndef lenient_issubclass_impl(cls, class_or_tuple):\n    try:\n        return isinstance(cls, type) and issubclass(cls, class_or_tuple)\n    except TypeError:\n        return False\n\nsequence_types = (typing.Sequence, typing.List, list, typing.Tuple, tuple, typing.Set, set, typing.FrozenSet, frozenset, \n                  # Use a dummy for deque since it might not be imported\n                  type(None)) # Just a placeholder\n\n# Need real sequence types\nfrom collections import deque\nsequence_types = (typing.Sequence, typing.List, list, typing.Tuple, tuple, typing.Set, set, typing.FrozenSet, frozenset, deque)\n\ndef test():\n    # Python 3.10+ union syntax: list[int] | None\n    # This should be recognized as a sequence.\n    try:\n        annotation = list[int] | None\n    except TypeError:\n        # Fallback for Python < 3.10\n        annotation = typing.Union[typing.List[int], None]\n\n    result = field_annotation_is_sequence_impl(\n        annotation, \n        sequence_types, \n        lenient_issubclass_impl, \n        lambda a: _annotation_is_sequence_impl(a, sequence_types, lenient_issubclass_impl)\n    )\n    print(f\"Annotation: {annotation}, Is sequence: {result}\")\n\ntest()\nPY\n"
}

{
 "command": "python3 - <<'PY'\nimport typing\nimport types\nfrom typing_extensions import get_origin, get_args\n\n# Mocking the environment as in fastapi/_compat/shared.py\nfrom collections import deque\nfrom typing import Sequence, List, Tuple, Set, FrozenSet\n\nsequence_types = (Sequence, List, list, Tuple, tuple, Set, set, FrozenSet, frozenset, deque)\n\ndef lenient_issubclass(cls, class_or_tuple):\n    try:\n        return isinstance(cls, type) and issubclass(cls, class_or_tuple)\n    except TypeError:\n        return False\n\ndef _annotation_is_sequence(annotation):\n    if lenient_issubclass(annotation, (str, bytes)):\n        return False\n    return lenient_issubclass(annotation, sequence_types)\n\ndef field_annotation_is_sequence(annotation):\n    origin = get_origin(annotation)\n    UnionType = getattr(types, \"UnionType\", typing.Union)\n    if origin is typing.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\ndef test():\n    # Case 1: list[int] | None\n    ann1 = list[int] | None\n    print(f\"list[int] | None: {field_annotation_is_sequence(ann1)}\")\n    \n    # Case 2: list[int] | str\n    # This should be True because list[int] is a sequence.\n    ann2 = list[int] | str\n    print(f\"list[int] | str: {field_annotation_is_sequence(ann2)}\")\n\n    # Case 3: str | int\n    ann3 = str | int\n    print(f\"str | int: {field_annotation_is_sequence(ann3)}\")\n\ntest()\nPY\n"
}

{
 "command": "python3 - <<'PY'\nimport typing\nimport types\nfrom typing_extensions import get_origin, get_args\n\nfrom collections import deque\nfrom typing import Sequence, List, Tuple, Set, FrozenSet\n\nsequence_types = (Sequence, List, list, Tuple, tuple, Set, set, FrozenSet, frozenset, deque)\n\ndef lenient_issubclass(cls, class_or_tuple):\n    try:\n        return isinstance(cls, type) and issubclass(cls, class_or_tuple)\n    except TypeError:\n        return False\n\ndef _annotation_is_sequence(annotation):\n    if lenient_issubclass(annotation, (str, bytes)):\n        return False\n    return lenient_issubclass(annotation, sequence_types)\n\ndef field_annotation_is_scalar(annotation):\n    # Simulation of field_annotation_is_scalar\n    # field_annotation_is_complex is what it uses.\n    # In a real scenario, it would check if it's a sequence or BaseModel etc.\n    if _annotation_is_sequence(annotation) or _annotation_is_sequence(get_origin(annotation)):\n        return False\n    return True\n\ndef field_annotation_is_scalar_sequence(annotation):\n    origin = get_origin(annotation)\n    UnionType = getattr(types, \"UnionType\", typing.Union)\n    if origin is typing.Union or origin is UnionType:\n        at_least_one_scalar_sequence = False\n        for arg in get_args(annotation):\n            if field_annotation_is_scalar_sequence(arg):\n                at_least_one_scalar_sequence = True\n                continue\n            elif not field_annotation_is_scalar(arg):\n                return False\n        return at_least_one_scalar_sequence\n    \n    # return field_annotation_is_sequence(annotation) and all(field_annotation_is_scalar(sub) for sub in get_args(annotation))\n    # Simulating field_annotation_is_sequence logic\n    is_seq = _annotation_is_sequence(annotation) or _annotation_is_sequence(origin)\n    if is_seq:\n        return all(field_annotation_is_scalar(sub) for sub in get_args(annotation))\n    return False\n\ndef test():\n    # The problematic case: list[int] | None\n    # list[int] is a scalar sequence.\n    # None is a scalar.\n    # So list[int] | None should be a scalar sequence.\n    \n    ann1 = list[int] | None\n    print(f\"list[int] | None: {field_annotation_is_scalar_sequence(ann1)}\")\n    \n    # Case: list[int] | list[str]\n    # list[int] is a scalar sequence, list[str] is a scalar sequence.\n    # This should be a scalar sequence.\n    ann2 = list[int] | list[str]\n    print(f\"list[int] | list[str]: {field_annotation_is_scalar_sequence(ann2)}\")\n    \n    # Case: list[int] | dict[str, int]\n    # dict[str, int] is complex but not a scalar sequence.\n    # So this should return False.\n    ann3 = list[int] | dict[str, int]\n    print(f\"list[int] | dict[str, int]: {field_annotation_is_scalar_sequence(ann3)}\")\n\ntest()\nPY\n"
}

{
 "command": "python3 - <<'PY'\nimport typing\nimport types\nfrom typing_extensions import get_origin, get_args\nfrom collections import deque\nfrom typing import Sequence, List, Tuple, Set, FrozenSet\n\nsequence_types = (Sequence, List, list, Tuple, tuple, Set, set, FrozenSet, frozenset, deque)\n\ndef lenient_issubclass(cls, class_or_tuple):\n    try:\n        return isinstance(cls, type) and issubclass(cls, class_or_tuple)\n    except TypeError:\n        return False\n\ndef _annotation_is_sequence(annotation):\n    if lenient_issubclass(annotation, (str, bytes)):\n        return False\n    return lenient_issubclass(annotation, sequence_types)\n\ndef field_annotation_is_complex(annotation):\n    # Simulating the logic: a complex type is a sequence or a BaseModel etc.\n    # For this test, let's just say it's complex if it's a sequence or a dict.\n    origin = get_origin(annotation)\n    if origin is typing.Union or origin is getattr(types, \"UnionType\", typing.Union):\n        return any(field_annotation_is_complex(arg) for arg in get_args(annotation))\n    \n    if _annotation_is_sequence(annotation) or _annotation_is_sequence(origin):\n        return True\n    if origin is dict:\n        return True\n    return False\n\ndef field_annotation_is_scalar(annotation):\n    return not field_annotation_is_complex(annotation)\n\ndef field_annotation_is_scalar_sequence(annotation):\n    origin = get_origin(annotation)\n    UnionType = getattr(types, \"UnionType\", typing.Union)\n    if origin is typing.Union or origin is UnionType:\n        at_least_one_scalar_sequence = False\n        for arg in get_args(annotation):\n            if field_annotation_is_scalar_sequence(arg):\n                at_least_one_scalar_sequence = True\n                continue\n            elif not field_annotation_is_scalar(arg):\n                return False\n        return at_least_one_scalar_sequence\n    \n    # Simulating field_annotation_is_sequence(annotation)\n    is_seq = _annotation_is_sequence(annotation) or _annotation_is_sequence(origin)\n    if is_seq:\n        return all(field_annotation_is_scalar(sub) for sub in get_args(annotation))\n    return False\n\ndef test():\n    # list[int] is a scalar sequence.\n    # None is a scalar.\n    # list[int] | None should be True.\n    ann1 = list[int] | None\n    print(f\"list[int] | None: {field_annotation_is_scalar_sequence(ann1)}\")\n    \n    # list[int] | list[str]\n    # Both are scalar sequences.\n    # Should be True.\n    ann2 = list[int] | list[str]\n    print(f\"list[int] | list[str]: {field_annotation_is_scalar_sequence(ann2)}\")\n    \n    # list[int] | dict[str, int]\n    # list[int] is scalar sequence.\n    # dict[str, int] is complex but NOT a scalar.\n    # This should return False.\n    ann3 = list[int] | dict[str, int]\n    print(f\"list[int] | dict[str, int]: {field_annotation_is_scalar_sequence(ann3)}\")\n\ntest()\nPY\n"
}

{
 "command": "grep -rn \"typing-inspection\" ."
}

{
 "command": "ls -F fastapi/types.py"
}

{
 "command": "cat fastapi/types.py"
}

{
 "command": "python3 - <<'PY'\nimport typing\nimport types\nfrom typing_extensions import get_origin, get_args\nfrom collections import deque\nfrom typing import Sequence, List, Tuple, Set, FrozenSet\n\nsequence_types = (Sequence, List, list, Tuple, tuple, Set, set, FrozenSet, frozenset, deque)\n\ndef lenient_issubclass(cls, class_or_tuple):\n    try:\n        return isinstance(cls, type) and issubclass(cls, class_or_tuple)\n    except TypeError:\n        return False\n\ndef _annotation_is_sequence(annotation):\n    if lenient_issubclass(annotation, (str, bytes)):\n        return False\n    return lenient_issubclass(annotation, sequence_types)\n\ndef field_annotation_is_complex(annotation):\n    origin = get_origin(annotation)\n    UnionType = getattr(types, \"UnionType\", typing.Union)\n    if origin is typing.Union or origin is UnionType:\n        return any(field_annotation_is_complex(arg) for arg in get_args(annotation))\n    \n    if _annotation_is_sequence(annotation) or _annotation_is_sequence(origin):\n        return True\n    if origin is dict:\n        return True\n    return False\n\ndef field_annotation_is_scalar(annotation):\n    return not field_annotation_is_complex(annotation)\n\ndef field_annotation_is_scalar_sequence(annotation):\n    origin = get_origin(annotation)\n    UnionType = getattr(types, \"UnionType\", typing.Union)\n    if origin is typing.Union or origin is UnionType:\n        at_least_one_scalar_sequence = False\n        for arg in get_args(annotation):\n            if field_annotation_is_scalar_sequence(arg):\n                at_least_one_scalar_sequence = True\n                continue\n            elif not field_annotation_is_scalar(arg):\n                return False\n        return at_least_one_scalar_sequence\n    \n    is_seq = _annotation_is_sequence(annotation) or _annotation_is_sequence(origin)\n    if is_seq:\n        return all(field_annotation_is_scalar(sub) for sub in get_args(annotation))\n    return False\n\ndef test():\n    # list[int] | None\n    ann1 = list[int] | None\n    print(f\"list[int] | None: {field_annotation_is_scalar_sequence(ann1)}\")\n    \n    # list[int] | list[str]\n    ann2 = list[int] | list[str]\n    print(f\"list[int] | list[str]: {field_annotation_is_scalar_sequence(ann2)}\")\n    \n    # list[int] | dict[str, int]\n    ann3 = list[int] | dict[str, int]\n    print(f\"list[int] | dict[str, int]: {field_annotation_is_scalar_sequence(ann3)}\")\n\ntest()\nPY\n"
}

{
 "command": "grep -rn \"typing-inspection\" ."
}

{
 "command": "python3 - <<'PY'\nimport typing\nimport types\nfrom typing_extensions import get_origin, get_args\n\ndef test_union_types():\n    # Testing how get_origin and get_args handle Python 3.10 union syntax\n    try:\n        ann = list[int] | None\n    except TypeError:\n        ann = typing.Union[typing.List[int], None]\n        \n    print(f\"Annotation: {ann}\")\n    print(f\"Origin: {get_origin(ann)}\")\n    print(f\"Args: {get_args(ann)}\")\n    \n    UnionType = getattr(types, \"UnionType\", typing.Union)\n    print(f\"UnionType: {UnionType}\")\n    print(f\"Origin is Union: {get_origin(ann) is typing.Union}\")\n    print(f\"Origin is UnionType: {get_origin(ann) is UnionType}\")\n\ntest_union_types()\nPY\n"
}

{
 "command": "python3 - <<'PY'\nfrom pathlib import Path\np = Path(\"fastapi/_compat/shared.py\")\ns = p.read_text()\n# The issue report mentions that the current implementation is only taking one union type into account.\n# Looking at field_annotation_is_scalar_sequence:\n# if origin is Union or origin is UnionType:\n#     at_least_one_scalar_sequence = False\n#     for arg in get_args(annotation):\n#         if field_annotation_is_scalar_sequence(arg):\n#             at_least_one_scalar_sequence = True\n#             continue\n#         elif not field_annotation_is_scalar(arg):\n#             return False\n#     return at_least_one_scalar_sequence\n\n# Wait, I don't see an obvious bug in the logic I just reviewed.\n# Let's re-read the PR mentioned: https://github.com/fastapi/fastapi/pull/14297\n# Since I cannot access external links, I have to rely on the description.\n# \"is only taking one union type into account\"\n\n# Maybe there is another function that handles unions?\n# let's search for \"Union or origin is UnionType\" in shared.py\nPY\n"
}

{
 "command": "grep -n \"Union or origin is UnionType\" fastapi/_compat/shared.py"
}

{
 "command": "grep -rn \"typing-inspection\" ."
}

{
 "command": "python3 - <<'PY'\nimport typing\nimport types\nfrom typing_extensions import get_origin, get_args\n\ndef test_complex_union():\n    # If we have a nested union like Union[Union[int, str], float]\n    # Python 3.10+ usually flattens these.\n    ann = (int | str) | float\n    print(f\"Annotation: {ann}\")\n    print(f\"Origin: {get_origin(ann)}\")\n    print(f\"Args: {get_args(ann)}\")\n\ntest_complex_union()\nPY\n"
}

{
 "command": "python3 - <<'PY'\nfrom pathlib import Path\np = Path(\"fastapi/_compat/shared.py\")\ns = p.read_text()\n\n# I'll check for any other place where Unions are handled.\n# Maybe there's something with Optional?\n# In Python 3.10+, Optional[T] is Union[T, None].\n\n# Let's look at the code again.\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\n# This looks correct for checking if ANY of the union types is a sequence.\n\n# Let's search for \"get_origin(annotation) is Union\"\n# maybe it's missing \"or origin is UnionType\" somewhere?\nPY\n"
}

{
 "command": "grep -rn \"origin is Union\" fastapi/ | grep -v \"UnionType\""
}

{
 "command": "grep -rn \"origin is Union\" fastapi/ | head -20"
}

{
 "command": "grep -rn \"get_origin\" fastapi/ | grep -v \"UnionType\" | head -20"
}

{
 "command": "sed -n '380,400p' fastapi/_compat/v2.py"
}

{
 "command": "python3 - <<'PY'\nimport typing\nimport types\nfrom typing_extensions import get_origin, get_args\n\ndef test_serialize_sequence_value():\n    # Simulating the logic in fastapi/_compat/v2.py\n    def serialize_sequence_value(annotation, value):\n        origin_type = get_origin(annotation) or annotation\n        \n        # This is the part we suspect is broken:\n        # if origin_type is Union:\n        if origin_type is typing.Union:\n            union_args = get_args(annotation)\n            for union_arg in union_args:\n                if union_arg is type(None):\n                    continue\n                origin_type = get_origin(union_arg) or union_arg\n                break\n        \n        print(f\"Annotation: {annotation}, Final origin_type: {origin_type}\")\n        # return issubclass(origin_type, (list, tuple, set)) # simplified\n\n    # Case 1: typing.Union[list[int], None]\n    serialize_sequence_value(typing.Union[typing.List[int], None], [1, 2])\n    \n    # Case 2: list[int] | None (Python 3.10 syntax)\n    try:\n        serialize_sequence_value(list[int] | None, [1, 2])\n    except TypeError:\n        print(\"Python < 3.10\")\n\ntest_serialize_sequence_value()\nPY\n"
}

{
 "command": "python3 - <<'PY'\nfrom pathlib import Path\np = Path(\"fastapi/_compat/v2.py\")\ns = p.read_text()\nold = \"\"\"    if origin_type is Union:  # Handle optional sequences\"\"\"\nnew = \"\"\"    if origin_type is Union or origin_type is UnionType:  # Handle optional sequences\"\"\"\n# Need to make sure UnionType is imported.\n# Let's check imports in v2.py\nPY\n"
}

{
 "command": "sed -n '1,50p' fastapi/_compat/v2.py"
}

{
 "command": "python3 - <<'PY'\nfrom pathlib import Path\np = Path(\"fastapi/_compat/v2.py\")\ns = p.read_text()\n\n# Add UnionType import from fastapi.types\n# and update serialize_sequence_value\n\nif \"from fastapi.types import IncEx, ModelNameMap\" in s:\n    s = s.replace(\n        \"from fastapi.types import IncEx, ModelNameMap\",\n        \"from fastapi.types import IncEx, ModelNameMap, UnionType\"\n    )\n\n# I need to find the exact lines for the replace.\n# Using the previous sed output:\n# 386:    if origin_type is Union:  # Handle optional sequences\n# Let's use a safer replacement.\nold_line = \"    if origin_type is Union:  # Handle optional sequences\"\nnew_line = \"    if origin_type is Union or origin_type is UnionType:  # Handle optional sequences\"\n\nif old_line in s:\n    s = s.replace(old_line, new_line)\n\np.write_text(s)\nPY\n"
}

{
 "command": "python3 -m py_compile fastapi/_compat/v2.py"
}

{
 "command": "python3 - <<'PY'\nimport typing\nimport types\nfrom typing_extensions import get_origin, get_args\nfrom fastapi.types import UnionType\n\ndef test_serialize_sequence_value_fixed():\n    def serialize_sequence_value_impl(annotation):\n        origin_type = get_origin(annotation) or annotation\n        \n        # Fixed logic\n        if origin_type is typing.Union or origin_type is UnionType:\n            union_args = get_args(annotation)\n            for union_arg in union_args:\n                if union_arg is type(None):\n                    continue\n                origin_type = get_origin(union_arg) or union_arg\n                break\n        \n        return origin_type\n\n    # Case 1: typing.Union[list[int], None]\n    ann1 = typing.Union[typing.List[int], None]\n    print(f\"Union[List, None] -> {serialize_sequence_value_impl(ann1)}\")\n    \n    # Case 2: list[int] | None (Python 3.10 syntax)\n    try:\n        ann2 = list[int] | None\n        print(f\"list[int] | None -> {serialize_sequence_value_impl(ann2)}\")\n    except TypeError:\n        print(\"Python < 3.10\")\n\ntest_serialize_sequence_value_fixed()\nPY\n"
}

{
 "command": "submit_patch"
}

{}