fastapi_14430

{
 "command": "grep -rn \"typing_inspection\" . || echo '<IMPORTANT> NO MATCH FOUND. DO NOT TRY SAME COMMAND.'"
}

{
 "command": "grep -rn \"Optional\" --include=\"*.py\" fastapi/ | head -20"
}

{
 "command": "grep -rn \"Union\" --include=\"*.py\" fastapi/ | head -20"
}

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

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

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

{
 "command": "grep -rn \"Optional\\[Sequence\" fastapi/ | head -20"
}

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

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

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

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

{
 "command": "cat > /tmp/repro.py <<'PY'\nimport typing\nfrom typing import Sequence, Optional, List, Union\nimport types\n\n# Python 3.10+ UnionType\ntry:\n    UnionType = types.UnionType\nexcept AttributeError:\n    UnionType = typing.Union\n\n# We need to simulate the logic in fastapi/_compat/shared.py\ndef get_origin(tp):\n    return typing.get_origin(tp)\n\ndef get_args(tp):\n    return typing.get_args(tp)\n\nsequence_types = (Sequence, List, list, typing.Tuple, tuple, typing.Set, set, typing.FrozenSet, frozenset, typing.Deque, typing.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    if origin is Union or (UnionType is not typing.Union and 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# Test cases\ntest_cases = [\n    (Optional[Sequence[int]], True),\n    (Union[Sequence[int], None], True),\n    (list[int] | None, True), # Python 3.10 syntax\n    (Sequence[int] | None, True), # Python 3.10 syntax\n    (int | None, False),\n]\n\nfor ann, expected in test_cases:\n    result = field_annotation_is_sequence(ann)\n    print(f\"Annotation: {ann}, Expected: {expected}, Result: {result}\")\nPY\nrun_command: cd /workspace && python3 /tmp/repro.py\n"
}

{
 "command": "python3 /tmp/repro.py"
}

{
 "command": "python3 - <<'PY'\nimport typing\nfrom typing import Sequence, Optional, List, Union\nimport types\n\n# Python 3.10+ UnionType\ntry:\n    UnionType = types.UnionType\nexcept AttributeError:\n    UnionType = typing.Union\n\n# We need to simulate the logic in fastapi/_compat/shared.py\ndef get_origin(tp):\n    return typing.get_origin(tp)\n\ndef get_args(tp):\n    return typing.get_args(tp)\n\nsequence_types = (Sequence, List, list, typing.Tuple, tuple, typing.Set, set, typing.FrozenSet, frozenset, typing.Deque, typing.deque)\nPY\n"
}

{
 "command": "python3 - <<'PY'\nimport typing\nfrom typing import Sequence, Optional, List, Union, Deque\nimport types\nfrom collections import deque\n\n# Python 3.10+ UnionType\ntry:\n    UnionType = types.UnionType\nexcept AttributeError:\n    UnionType = typing.Union\n\ndef get_origin(tp):\n    return typing.get_origin(tp)\n\ndef get_args(tp):\n    return typing.get_args(tp)\n\nsequence_types = (Sequence, List, list, typing.Tuple, tuple, typing.Set, set, typing.FrozenSet, frozenset, Deque, 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    if origin is Union or (UnionType is not typing.Union and 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\ntest_cases = [\n    (Optional[Sequence[int]], True),\n    (Union[Sequence[int], None], True),\n    (list[int] | None, True), # Python 3.10 syntax\n    (Sequence[int] | None, True), # Python 3.10 syntax\n    (int | None, False),\n]\n\nfor ann, expected in test_cases:\n    result = field_annotation_is_sequence(ann)\n    print(f\"Annotation: {ann}, Expected: {expected}, Result: {result}\")\nPY\n"
}

{
 "command": "grep -rn \"typing-inspection\" . || echo '<IMPORTANT> NO MATCH FOUND. DO NOT TRY SAME COMMAND.'"
}

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

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

{
 "command": "python3 - <<'PY'\nimport typing\nfrom typing import Sequence, Optional, List, Union, Deque\nimport types\nfrom collections import deque\n\n# Python 3.10+ UnionType\ntry:\n    UnionType = types.UnionType\nexcept AttributeError:\n    UnionType = typing.Union\n\ndef get_origin(tp):\n    return typing.get_origin(tp)\n\ndef get_args(tp):\n    return typing.get_args(tp)\n\nsequence_types = (Sequence, List, list, typing.Tuple, tuple, typing.Set, set, typing.FrozenSet, frozenset, Deque, 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    if origin is Union or (UnionType is not typing.Union and 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# Let's test if it fails for something like list[int] | list[str]\n# The current implementation returns True if ANY arg is a sequence.\n# But what if it's Union[int, str] | None?\n# That should be False.\n\ntest_cases = [\n    (Optional[Sequence[int]], True),\n    (Union[Sequence[int], None], True),\n    (list[int] | None, True),\n    (Sequence[int] | None, True),\n    (int | None, False),\n    (Union[int, str] | None, False),\n    (list[int] | list[str], True),\n    (list[int] | int, True),\n]\n\nfor ann, expected in test_cases:\n    result = field_annotation_is_sequence(ann)\n    print(f\"Annotation: {ann}, Expected: {expected}, Result: {result}\")\nPY\n"
}

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

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

{
 "command": "python3 - <<'PY'\nimport typing\nfrom typing import Sequence, Optional, List, Union, Deque\nimport types\nfrom collections import deque\n\ntry:\n    UnionType = types.UnionType\nexcept AttributeError:\n    UnionType = typing.Union\n\ndef get_origin(tp):\n    return typing.get_origin(tp)\n\ndef get_args(tp):\n    return typing.get_args(tp)\n\nsequence_types = (Sequence, List, list, typing.Tuple, tuple, typing.Set, set, typing.FrozenSet, frozenset, Deque, 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 _annotation_is_complex(annotation):\n    return (\n        lenient_issubclass(annotation, (typing.Mapping, UploadFile)) # Simplified\n        or _annotation_is_sequence(annotation)\n    )\n\n# Mock UploadFile\nclass UploadFile: pass\n\ndef field_annotation_is_complex(annotation):\n    origin = get_origin(annotation)\n    if origin is Union or (UnionType is not typing.Union and origin is UnionType):\n        return any(field_annotation_is_complex(arg) for arg in get_args(annotation))\n    \n    if origin is typing.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    )\n\n# Testing Python 3.10 Union\n# If I have int | None, it should be complex if int is complex (False) or None is complex (False).\n# Wait, the issue says \"optional sequence handling with new union syntax from Python 3.10\".\n# It seems it's about field_annotation_is_sequence.\n\ndef field_annotation_is_sequence(annotation):\n    origin = get_origin(annotation)\n    if origin is Union or (UnionType is not typing.Union and 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\nprint(f\"Optional[Sequence[int]]: {field_annotation_is_sequence(Optional[Sequence[int]])}\")\nprint(f\"Sequence[int] | None: {field_annotation_is_sequence(Sequence[int] | None)}\")\nPY\n"
}

{
 "command": "python3 - <<'PY'\nimport typing\nfrom typing import Sequence, Optional, List, Union, Deque\nimport types\nfrom collections import deque\n\ntry:\n    UnionType = types.UnionType\nexcept AttributeError:\n    UnionType = typing.Union\n\ndef get_origin(tp):\n    return typing.get_origin(tp)\n\ndef get_args(tp):\n    return typing.get_args(tp)\n\nsequence_types = (Sequence, List, list, typing.Tuple, tuple, typing.Set, set, typing.FrozenSet, frozenset, Deque, 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    # THE CURRENT FASTAPI IMPLEMENTATION:\n    if origin is Union or origin is UnionType: # This UnionType is from fastapi.types.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# Let's see what fastapi.types.UnionType is.\nPY\n"
}

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

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

{
 "command": "sed -n '1,15p' fastapi/types.py"
}

{
 "command": "cat > /tmp/test_union_type.py <<'PY'\nimport typing\nimport types\nfrom fastapi.types import UnionType\nfrom typing import Union\n\nprint(f\"typing.Union: {Union}\")\nprint(f\"types.UnionType (if exists): {getattr(types, 'UnionType', 'N/A')}\")\nprint(f\"fastapi.types.UnionType: {UnionType}\")\nprint(f\"Are they same? {UnionType is getattr(types, 'UnionType', Union)}\")\nPY\nrun_command: cd /workspace && python3 /tmp/test_union_type.py\n"
}

{
 "command": "python3 /tmp/test_union_type.py"
}

{
 "command": "python3 - <<'PY'\nimport typing\nfrom typing import Sequence, Optional, List, Union, Deque\nimport types\nfrom collections import deque\n\n# Simulate fastapi.types.UnionType\nUnionType = getattr(types, \"UnionType\", Union)\n\ndef get_origin(tp):\n    return typing.get_origin(tp)\n\ndef get_args(tp):\n    return typing.get_args(tp)\n\nsequence_types = (Sequence, List, list, typing.Tuple, tuple, typing.Set, set, typing.FrozenSet, frozenset, Deque, 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    # This is the code in fastapi/_compat/shared.py\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# Now let's try a nested union.\n# In Python 3.10, x | y | z is just a UnionType.\n# But what if we have something like (list[int] | None) | int?\n# Or Union[Union[list[int], None], int]?\n\nnested_union = (list[int] | None) | int\nprint(f\"Nested Union: {nested_union}\")\nprint(f\"Origin: {get_origin(nested_union)}\")\nprint(f\"Args: {get_args(nested_union)}\")\nprint(f\"Is sequence: {field_annotation_is_sequence(nested_union)}\")\n\n# What if it's a Union of something that is a Union?\n# typing.Union automatically flattens.\n# types.UnionType also flattens.\n\n# Let's try:\n# List[int] | None\nprint(f\"List[int] | None: {field_annotation_is_sequence(List[int] | None)}\")\nPY\n"
}

{
 "command": "python3 - <<'PY'\nimport typing\nfrom typing import Sequence, Optional, List, Union, Deque\nimport types\nfrom collections import deque\n\nUnionType = getattr(types, \"UnionType\", Union)\n\ndef get_origin(tp):\n    return typing.get_origin(tp)\n\ndef get_args(tp):\n    return typing.get_args(tp)\n\nsequence_types = (Sequence, List, list, typing.Tuple, tuple, typing.Set, set, typing.FrozenSet, frozenset, Deque, 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    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# Let's try something that might fail.\n# The issue says \"is only taking one union type into account\".\n# Maybe they mean it only handles Union but not UnionType?\n# But my tests showed it handles both.\n\n# Wait, maybe it's about field_annotation_is_complex?\n\ndef field_annotation_is_complex(annotation):\n    origin = get_origin(annotation)\n    if origin is Union or origin is UnionType:\n        # CURRENT IMPLEMENTATION:\n        return any(field_annotation_is_complex(arg) for arg in get_args(annotation))\n    \n    # ... rest of the function ...\n    return False # simplified\n\nprint(f\"Union[int, str]: {field_annotation_is_complex(Union[int, str])}\")\nprint(f\"int | str: {field_annotation_is_complex(int | str)}\")\nPY\n"
}

{
 "command": "python3 - <<'PY'\nimport typing\nfrom typing import Sequence, Optional, List, Union, Deque\nimport types\nfrom collections import deque\n\nUnionType = getattr(types, \"UnionType\", Union)\n\ndef get_origin(tp):\n    return typing.get_origin(tp)\n\ndef get_args(tp):\n    return typing.get_args(tp)\n\nsequence_types = (Sequence, List, list, typing.Tuple, tuple, typing.Set, set, typing.FrozenSet, frozenset, Deque, 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    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 _annotation_is_sequence(annotation):\n        return True\n    \n    return False\n\nprint(f\"Optional[Sequence[int]]: {field_annotation_is_complex(Optional[Sequence[int]])}\")\nprint(f\"Sequence[int] | None: {field_annotation_is_complex(Sequence[int] | None)}\")\nPY\n"
}

{
 "command": "python3 - <<'PY'\nimport typing\nfrom typing import Sequence, Optional, List, Union, Deque\nimport types\nfrom collections import deque\n\nUnionType = getattr(types, \"UnionType\", Union)\n\ndef get_origin(tp):\n    return typing.get_origin(tp)\n\ndef get_args(tp):\n    return typing.get_args(tp)\n\nsequence_types = (Sequence, List, list, typing.Tuple, tuple, typing.Set, set, typing.FrozenSet, frozenset, Deque, 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    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 _annotation_is_sequence(annotation):\n        return True\n    \n    # Handle Sequence[int] case\n    if get_origin(annotation) in sequence_types:\n        return True\n    \n    return False\n\nprint(f\"Optional[Sequence[int]]: {field_annotation_is_complex(Optional[Sequence[int]])}\")\nprint(f\"Sequence[int] | None: {field_annotation_is_complex(Sequence[int] | None)}\")\nPY\n"
}

{
 "command": "python3 - <<'PY'\nimport typing\nfrom typing import Sequence, Optional, List, Union, Deque\nimport types\nfrom collections import deque\n\nUnionType = getattr(types, \"UnionType\", Union)\n\ndef get_origin(tp):\n    return typing.get_origin(tp)\n\ndef get_args(tp):\n    return typing.get_args(tp)\n\nsequence_types = (Sequence, List, list, typing.Tuple, tuple, typing.Set, set, typing.FrozenSet, frozenset, Deque, 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    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 _annotation_is_sequence(annotation):\n        return True\n    \n    if origin in sequence_types:\n        return True\n    \n    return False\n\n# Let's trace Optional[Sequence[int]]\n# Optional[Sequence[int]] is Union[Sequence[int], None]\n# origin is Union.\n# any(field_annotation_is_complex(arg) for arg in [Sequence[int], None])\n#   field_annotation_is_complex(Sequence[int]):\n#     origin is Sequence.\n#     _annotation_is_sequence(Sequence[int]) -> False (it's not a class, it's a GenericAlias)\n#     origin in sequence_types -> Sequence in sequence_types -> True.\n#   field_annotation_is_complex(None):\n#     origin is None.\n#     _annotation_is_sequence(None) -> False.\n#     origin in sequence_types -> False.\n# Result: True.\n\nprint(f\"Optional[Sequence[int]]: {field_annotation_is_complex(Optional[Sequence[int]])}\")\nprint(f\"Sequence[int] | None: {field_annotation_is_complex(Sequence[int] | None)}\")\nPY\n"
}

{
 "command": "python3 - <<'PY'\nimport typing\nfrom typing import Sequence, Optional, List, Union, Deque\nimport types\nfrom collections import deque\n\nUnionType = getattr(types, \"UnionType\", Union)\n\ndef get_origin(tp):\n    return typing.get_origin(tp)\n\ndef get_args(tp):\n    return typing.get_args(tp)\n\nprint(f\"Origin of Optional[Sequence[int]]: {get_origin(Optional[Sequence[int]])}\")\nprint(f\"Origin of Sequence[int]: {get_origin(Sequence[int])}\")\nPY\n"
}

{
 "command": "python3 - <<'PY'\nimport typing\nfrom typing import Sequence, Optional, List, Union, Deque\nimport types\nfrom collections import deque\n\nUnionType = getattr(types, \"UnionType\", Union)\n\ndef get_origin(tp):\n    return typing.get_origin(tp)\n\ndef get_args(tp):\n    return typing.get_args(tp)\n\nsequence_types = (Sequence, List, list, typing.Tuple, tuple, typing.Set, set, typing.FrozenSet, frozenset, Deque, 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    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 _annotation_is_sequence(annotation):\n        return True\n    \n    # We need to check if origin is a sequence type\n    # But origin for Sequence[int] is collections.abc.Sequence\n    # Let's see if that's in our sequence_types.\n    print(f\"Origin: {origin}, sequence_types: {sequence_types}\")\n    \n    # sequence_types contains typing.Sequence\n    # Is collections.abc.Sequence same as typing.Sequence?\n    # In Python 3.9+, yes.\n    \n    if origin in sequence_types:\n        return True\n    \n    return False\n\nprint(f\"Optional[Sequence[int]]: {field_annotation_is_complex(Optional[Sequence[int]])}\")\nPY\n"
}

{
 "command": "python3 - <<'PY'\nimport typing\nfrom typing import Sequence\nimport collections\n\nprint(f\"typing.Sequence: {Sequence}\")\nprint(f\"collections.abc.Sequence: {collections.abc.Sequence}\")\nprint(f\"Are they same? {Sequence is collections.abc.Sequence}\")\nPY\n"
}

{
 "command": "python3 - <<'PY'\nimport typing\nfrom typing import Sequence\nimport collections\n\nprint(f\"issubclass(collections.abc.Sequence, typing.Sequence): {issubclass(collections.abc.Sequence, Sequence)}\")\nprint(f\"issubclass(typing.Sequence, collections.abc.Sequence): {issubclass(Sequence, collections.abc.Sequence)}\")\nPY\n"
}