fastapi_14430

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

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

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

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

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

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

{
 "command": "python3 - <<'PY'\nimport typing\nimport types\nfrom typing_extensions import get_origin, get_args\n\n# Mocking UnionType for Python < 3.10 if necessary, \n# but we are likely on 3.10+ given the issue description.\nUnionType = getattr(types, \"UnionType\", typing.Union)\n\ndef field_annotation_is_sequence(annotation):\n    origin = get_origin(annotation)\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    \n    # Simplified version of _annotation_is_sequence for testing\n    # In reality, it uses lenient_issubclass and sequence_types\n    if annotation in (list, typing.List, tuple, typing.Tuple, set, typing.Set):\n        return True\n    if origin in (list, typing.List, tuple, typing.Tuple, set, typing.Set):\n        return True\n    return False\n\n# Test cases\n# 1. Standard Union\nprint(f\"Union[list[int], int]: {field_annotation_is_sequence(typing.Union[typing.List[int], int])}\") # Expected True\n\n# 2. Python 3.10 Union syntax (int | list[int])\ntry:\n    # This syntax is only valid in Python 3.10+\n    print(f\"int | list[int]: {field_annotation_is_sequence(int | list[int])}\") # Expected True\nexcept TypeError:\n    print(\"Python version < 3.10, skipping | syntax\")\n\n# 3. Optional sequence (list[int] | None)\ntry:\n    print(f\"list[int] | None: {field_annotation_is_sequence(list[int] | None)}\") # Expected True\nexcept TypeError:\n    print(\"Python version < 3.10, skipping | syntax\")\n\n# 4. Optional non-sequence (int | None)\ntry:\n    print(f\"int | None: {field_annotation_is_sequence(int | None)}\") # Expected False\nexcept TypeError:\n    print(\"Python version < 3.10, skipping | syntax\")\nPY\n"
}

{
 "command": "python3 - <<'PY'\nimport typing\nimport types\nfrom typing_extensions import get_origin, get_args\n\nUnionType = getattr(types, \"UnionType\", typing.Union)\n\ndef field_annotation_is_scalar(annotation):\n    # Simplified version of field_annotation_is_scalar\n    # It returns True if it's NOT complex.\n    # For this test, let's just define what's complex.\n    # Complex: BaseModel, Mapping, UploadFile, Sequence, dataclass\n    # We'll just mock it.\n    if annotation in (list, typing.List, tuple, typing.Tuple, set, typing.Set):\n        return False\n    return True\n\ndef field_annotation_is_scalar_sequence(annotation):\n    origin = get_origin(annotation)\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    # Simplified check for sequence and all scalar\n    if origin in (list, typing.List, tuple, typing.Tuple, set, typing.Set):\n        return all(field_annotation_is_scalar(sub) for sub in get_args(annotation))\n    return False\n\n# Test cases\n# 1. Scalar sequence in Union\n# list[int] | int  -> True (at least one scalar sequence, others are scalar)\ntry:\n    print(f\"list[int] | int: {field_annotation_is_scalar_sequence(list[int] | int)}\") \nexcept TypeError:\n    print(\"Python < 3.10\")\n\n# 2. Scalar sequence and non-scalar in Union\n# list[int] | list[list[int]] -> False (one is scalar sequence, one is not scalar)\ntry:\n    print(f\"list[int] | list[list[int]]: {field_annotation_is_scalar_sequence(list[int] | list[list[int]])}\")\nexcept TypeError:\n    print(\"Python < 3.10\")\n\n# 3. Optional scalar sequence\n# list[int] | None -> True (list[int] is scalar sequence, None is scalar)\ntry:\n    print(f\"list[int] | None: {field_annotation_is_scalar_sequence(list[int] | None)}\")\nexcept TypeError:\n    print(\"Python < 3.10\")\n\n# 4. Optional non-scalar sequence\n# list[list[int]] | None -> False (list[list[int]] is not scalar)\ntry:\n    print(f\"list[list[int]] | None: {field_annotation_is_scalar_sequence(list[list[int]] | None)}\")\nexcept TypeError:\n    print(\"Python < 3.10\")\nPY\n"
}

{
 "command": "python3 - <<'PY'\nimport typing\nimport types\nfrom typing_extensions import get_origin, get_args\n\nUnionType = getattr(types, \"UnionType\", typing.Union)\n\ndef field_annotation_is_scalar(annotation):\n    # Simplified version of field_annotation_is_scalar\n    # It returns True if it's NOT complex.\n    # Complex: BaseModel, Mapping, UploadFile, Sequence, dataclass\n    if annotation in (list, typing.List, tuple, typing.Tuple, set, typing.Set):\n        return False\n    # For the sake of this test, let's assume None is scalar\n    if annotation is type(None):\n        return True\n    return True\n\ndef field_annotation_is_scalar_sequence(annotation):\n    origin = get_origin(annotation)\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    # Simplified check for sequence and all scalar\n    if origin in (list, typing.List, tuple, typing.Tuple, set, typing.Set):\n        return all(field_annotation_is_scalar(sub) for sub in get_args(annotation))\n    return False\n\n# Test cases\n# 1. Scalar sequence in Union\n# list[int] | int  -> True (at least one scalar sequence, others are scalar)\ntry:\n    print(f\"list[int] | int: {field_annotation_is_scalar_sequence(list[int] | int)}\") \nexcept TypeError:\n    print(\"Python < 3.10\")\n\n# 2. Scalar sequence and non-scalar in Union\n# list[int] | list[list[int]] -> False (one is scalar sequence, one is not scalar)\ntry:\n    print(f\"list[int] | list[list[int]]: {field_annotation_is_scalar_sequence(list[int] | list[list[int]])}\")\nexcept TypeError:\n    print(\"Python < 3.10\")\n\n# 3. Optional scalar sequence\n# list[int] | None -> True (list[int] is scalar sequence, None is scalar)\ntry:\n    print(f\"list[int] | None: {field_annotation_is_scalar_sequence(list[int] | None)}\")\nexcept TypeError:\n    print(\"Python < 3.10\")\n\n# 4. Optional non-scalar sequence\n# list[list[int]] | None -> False (list[list[int]] is not scalar)\ntry:\n    print(f\"list[list[int]] | None: {field_annotation_is_scalar_sequence(list[list[int]] | None)}\")\nexcept TypeError:\n    print(\"Python < 3.10\")\nPY\n"
}

{
 "command": "python3 - <<'PY'\nimport typing\nimport types\nfrom typing_extensions import get_origin, get_args\n\nUnionType = getattr(types, \"UnionType\", typing.Union)\n\ndef field_annotation_is_scalar(annotation):\n    if annotation in (list, typing.List, tuple, typing.Tuple, set, typing.Set):\n        return False\n    if annotation is type(None):\n        return True\n    return True\n\ndef field_annotation_is_scalar_sequence(annotation):\n    origin = get_origin(annotation)\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                # This is where the issue is. \n                # If arg is not a scalar sequence AND not a scalar, it should return False.\n                # But what if arg is a scalar sequence? \n                # The 'if field_annotation_is_scalar_sequence(arg)' already handled it.\n                return False\n        return at_least_one_scalar_sequence\n    \n    if origin in (list, typing.List, tuple, typing.Tuple, set, typing.Set):\n        return all(field_annotation_is_scalar(sub) for sub in get_args(annotation))\n    return False\n\n# Test cases\n# 1. Scalar sequence in Union\n# list[int] | int  -> True\ntry:\n    print(f\"list[int] | int: {field_annotation_is_scalar_sequence(list[int] | int)}\") \nexcept TypeError:\n    print(\"Python < 3.10\")\n\n# 2. Scalar sequence and non-scalar in Union\n# list[int] | list[list[int]] -> False\ntry:\n    print(f\"list[int] | list[list[int]]: {field_annotation_is_scalar_sequence(list[int] | list[list[int]])}\")\nexcept TypeError:\n    print(\"Python < 3.10\")\n\n# 3. Optional scalar sequence\n# list[int] | None -> True\ntry:\n    print(f\"list[int] | None: {field_annotation_is_scalar_sequence(list[int] | None)}\")\nexcept TypeError:\n    print(\"Python < 3.10\")\n\n# 4. Optional non-scalar sequence\n# list[list[int]] | None -> False\ntry:\n    print(f\"list[list[int]] | None: {field_annotation_is_scalar_sequence(list[list[int]] | None)}\")\nexcept TypeError:\n    print(\"Python < 3.10\")\nPY\n"
}

{
 "command": "python3 - <<'PY'\nimport typing\nimport types\nfrom typing_extensions import get_origin, get_args\n\nUnionType = getattr(types, \"UnionType\", typing.Union)\n\ndef field_annotation_is_scalar(annotation):\n    if annotation in (list, typing.List, tuple, typing.Tuple, set, typing.Set):\n        return False\n    if annotation is type(None):\n        return True\n    return True\n\ndef field_annotation_is_scalar_sequence(annotation):\n    origin = get_origin(annotation)\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    if origin in (list, typing.List, tuple, typing.Tuple, set, typing.Set):\n        return all(field_annotation_is_scalar(sub) for sub in get_args(annotation))\n    return False\n\n# Test cases\n# list[list[int]] | None\n# arg1 = list[list[int]]\n# field_annotation_is_scalar_sequence(list[list[int]]) -> False\n# field_annotation_is_scalar(list[list[int]]) -> False\n# return False\n\n# Wait, why did my previous run return True?\n# Let's re-examine field_annotation_is_scalar(list[list[int]])\n# list[list[int]] is NOT in (list, typing.List, ...)\n# It's a GenericAlias.\n# So field_annotation_is_scalar(list[list[int]]) returns True!\n# That's the bug in my test mock.\n\ndef field_annotation_is_scalar_fixed(annotation):\n    origin = get_origin(annotation)\n    if origin in (list, typing.List, tuple, typing.Tuple, set, typing.Set):\n        return False\n    if annotation in (list, typing.List, tuple, typing.Tuple, set, typing.Set):\n        return False\n    if annotation is type(None):\n        return True\n    return True\n\ndef field_annotation_is_scalar_sequence_fixed(annotation):\n    origin = get_origin(annotation)\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_fixed(arg):\n                at_least_one_scalar_sequence = True\n                continue\n            elif not field_annotation_is_scalar_fixed(arg):\n                return False\n        return at_least_one_scalar_sequence\n    \n    if origin in (list, typing.List, tuple, typing.Tuple, set, typing.Set):\n        return all(field_annotation_is_scalar_fixed(sub) for sub in get_args(annotation))\n    return False\n\nprint(f\"list[int] | None: {field_annotation_is_scalar_sequence_fixed(list[int] | None)}\") # True\nprint(f\"list[list[int]] | None: {field_annotation_is_scalar_sequence_fixed(list[list[int]] | None)}\") # False\nPY\n"
}

{
 "command": "grep -rn \"field_annotation_is_scalar_sequence\" fastapi/_compat/shared.py"
}

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

{
 "command": "python3 - <<'PY'\nimport typing\nimport types\nfrom typing_extensions import get_origin, get_args\n\nUnionType = getattr(types, \"UnionType\", typing.Union)\n\ndef field_annotation_is_scalar(annotation):\n    # Mocking field_annotation_is_complex\n    def field_annotation_is_complex(ann):\n        origin = get_origin(ann)\n        if origin in (list, typing.List, tuple, typing.Tuple, set, typing.Set):\n            return True\n        if ann in (list, typing.List, tuple, typing.Tuple, set, typing.Set):\n            return True\n        return False\n    return not field_annotation_is_complex(annotation)\n\ndef field_annotation_is_sequence(annotation):\n    origin = get_origin(annotation)\n    if origin in (list, typing.List, tuple, typing.Tuple, set, typing.Set):\n        return True\n    if annotation in (list, typing.List, tuple, typing.Tuple, set, typing.Set):\n        return True\n    return False\n\ndef field_annotation_is_scalar_sequence(annotation):\n    origin = get_origin(annotation)\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    return field_annotation_is_sequence(annotation) and all(\n        field_annotation_is_scalar(sub_annotation)\n        for sub_annotation in get_args(annotation)\n    )\n\n# Test case: list[int] | None\n# arg1 = list[int]\n# field_annotation_is_scalar_sequence(list[int]) -> True\n# at_least_one_scalar_sequence = True\n# arg2 = NoneType\n# field_annotation_is_scalar_sequence(NoneType) -> False\n# field_annotation_is_scalar(NoneType) -> True\n# return True (Correct)\n\n# Test case: list[list[int]] | None\n# arg1 = list[list[int]]\n# field_annotation_is_scalar_sequence(list[list[int]]) -> False (because sub_annotation list[int] is not scalar)\n# field_annotation_is_scalar(list[list[int]]) -> False (because it's complex)\n# return False (Correct)\n\n# Wait, if the current implementation is correct, what is the issue?\n# \"Fix optional sequence handling with new union syntax from Python 3.10\"\n# \"is only taking one union type into account\"\n\n# Let's try a more complex union: list[int] | int | None\n# arg1 = list[int] -> scalar sequence -> True, at_least_one = True\n# arg2 = int -> not scalar sequence, but scalar -> True\n# arg3 = None -> not scalar sequence, but scalar -> True\n# return True (Correct)\n\n# What if it's list[int] | list[str]?\n# arg1 = list[int] -> True, at_least_one = True\n# arg2 = list[str] -> True, at_least_one = True\n# return True (Correct)\n\n# What if it's list[int] | list[list[int]]?\n# arg1 = list[int] -> True, at_least_one = True\n# arg2 = list[list[int]] -> not scalar sequence, NOT scalar -> return False (Correct)\n\n# I don't see the bug in the provided code. Let me re-read the issue.\n# \"is only taking one union type into account\"\n# Maybe it's about how UnionType is handled?\n# In fastapi/types.py: UnionType = getattr(types, \"UnionType\", Union)\n# In fastapi/_compat/shared.py: from fastapi.types import UnionType\n# Then: if origin is Union or origin is UnionType:\n# If Python < 3.10, UnionType is Union. So 'origin is Union or origin is Union' is just 'origin is Union'.\n# If Python >= 3.10, UnionType is types.UnionType. So 'origin is Union or origin is UnionType' covers both.\n\n# Wait, let me check the PR mentioned: https://github.com/fastapi/fastapi/pull/14297\n# I can't access the internet, but the issue description says it's \"only taking one union type into account\".\n# Maybe it's in another function?\n\n# Let's check field_annotation_is_sequence again.\ndef field_annotation_is_sequence_impl(annotation):\n    origin = get_origin(annotation)\n    if origin is typing.Union or orig

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

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

{
 "command": "python3 - <<'PY'\nimport typing\nimport types\nfrom typing_extensions import get_origin, get_args\n\nUnionType = getattr(types, \"UnionType\", typing.Union)\n\ndef is_bytes_or_nonable_bytes_annotation(annotation):\n    # Simplified\n    return annotation is bytes or annotation is type(None)\n\ndef is_bytes_sequence_annotation(annotation):\n    origin = get_origin(annotation)\n    if origin is typing.Union or origin is UnionType:\n        at_least_one = False\n        for arg in get_args(annotation):\n            if is_bytes_sequence_annotation(arg):\n                at_least_one = True\n                continue\n        return at_least_one\n    # Simplified field_annotation_is_sequence\n    if origin in (list, typing.List, tuple, typing.Tuple, set, typing.Set):\n        return all(is_bytes_or_nonable_bytes_annotation(sub) for sub in get_args(annotation))\n    return False\n\n# Test: list[bytes] | int\n# arg1 = list[bytes] -> is_bytes_sequence_annotation(list[bytes]) -> True\n# at_least_one = True\n# arg2 = int -> is_bytes_sequence_annotation(int) -> False\n# return True (Correct)\n\n# Test: list[bytes] | list[int]\n# arg1 = list[bytes] -> True, at_least_one = True\n# arg2 = list[int] -> is_bytes_sequence_annotation(list[int]) -> False\n# return True (Correct)\n\n# Wait, if it's list[bytes] | list[int], should it be True?\n# is_bytes_sequence_annotation means \"is this a sequence of bytes?\"\n# If it's a Union of a bytes-sequence and a non-bytes-sequence, is it a bytes-sequence?\n# Probably not. It should probably be False if any member is not a bytes-sequence or scalar.\n\n# Let's look at is_bytes_sequence_annotation again:\n# if origin is Union or origin is UnionType:\n#     at_least_one = False\n#     for arg in get_args(annotation):\n#         if is_bytes_sequence_annotation(arg):\n#             at_least_one = True\n#             continue\n#     return at_least_one\n\n# This implementation returns True if ANY member of the Union is a bytes-sequence.\n# It doesn't check if other members are scalars.\n# This is different from field_annotation_is_scalar_sequence.\n\n# Let's check is_uploadfile_sequence_annotation. It's the same.\nPY\n"
}

{
 "command": "python3 - <<'PY'\nimport typing\nimport types\nfrom typing_extensions import get_origin, get_args\n\nUnionType = getattr(types, \"UnionType\", typing.Union)\n\ndef is_bytes_or_nonable_bytes_annotation(annotation):\n    return annotation is bytes or annotation is type(None)\n\ndef is_bytes_sequence_annotation(annotation):\n    origin = get_origin(annotation)\n    if origin is typing.Union or origin is UnionType:\n        at_least_one = False\n        for arg in get_args(annotation):\n            if is_bytes_sequence_annotation(arg):\n                at_least_one = True\n                continue\n        return at_least_one\n    \n    # Mock field_annotation_is_sequence\n    if origin in (list, typing.List, tuple, typing.Tuple, set, typing.Set):\n        return all(is_bytes_or_nonable_bytes_annotation(sub) for sub in get_args(annotation))\n    return False\n\n# Test: list[bytes] | list[int]\n# arg1 = list[bytes] -> True, at_least_one = True\n# arg2 = list[int] -> False\n# return True\n\n# If this is supposed to be like field_annotation_is_scalar_sequence, it should be False.\n# But is it?\n\n# Let's re-read the issue: \"Fix optional sequence handling with new union syntax from Python 3.10\"\n# \"is only taking one union type into account\"\n\n# Maybe it's about the `typing-inspection` recommendation.\n# Pydantic's typing-inspection handles Unions better.\n\n# Let's look at the code again.\n# In 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# This looks correct for \"Optional sequence\".\n# If it's `list[int] | None`, then:\n# arg1 = list[int] -> field_annotation_is_scalar_sequence(list[int]) -> True, at_least_one = True\n# arg2 = None -> field_annotation_is_scalar_sequence(None) -> False, field_annotation_is_scalar(None) -> True\n# return True.\n\n# What if it's `list[int] | int`?\n# arg1 = list[int] -> True, at_least_one = True\n# arg2 = int -> False, field_annotation_is_scalar(int) -> True\n# return True.\n\n# What if it's `list[int] | list[list[int]]`?\n# arg1 = list[int] -> True, at_least_one = True\n# arg2 = list[list[int]] -> False, field_annotation_is_scalar(list[list[int]]) -> False\n# return False.\n\n# I'm struggling to find the bug. Let me search for other places where Union is handled.\nPY\n"
}

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

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

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