fastapi_14430

{"status": "ok", "stdout": "", "stderr": "grep: fastapi/fastapi: No such file or directory\n", "exit_code": 0}

{"status": "ok", "stdout": "./tests/test_openapi_schema_type.py:1:from typing import List, Optional, Union\n./tests/test_openapi_schema_type.py:16:    type_value: Optional[Union[SchemaType, List[SchemaType]]],\n./tests/test_union_inherited_body.py:1:from typing import Optional, Union\n./tests/test_validate_response.py:1:from typing import List, Optional, Union\n./tests/test_union_body.py:1:from typing import Optional, Union\n./fastapi/params.py:4:from typing import Any, Callable, Dict, List, Optional, Sequence, Union\n./fastapi/security/oauth2.py:1:from typing import Any, Dict, List, Optional, Union, cast\n./fastapi/security/api_key.py:1:from typing import Optional, Union\n./fastapi/applications.py:293:            Optional[List[Dict[str, Union[str, Any]]]],\n./fastapi/applications.py:570:            Optional[Dict[str, Union[str, Any]]],\n./fastapi/applications.py:603:            Optional[Dict[str, Union[str, Any]]],\n./fastapi/applications.py:692:            Optional[Dict[Union[int, str], Dict[str, Any]]],\n./fastapi/applications.py:1148:        tags: Optional[List[Union[str, Enum]]] = None,\n./fastapi/applications.py:1153:        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,\n./fastapi/applications.py:1206:        tags: Optional[List[Union[str, Enum]]] = None,\n./fastapi/applications.py:1211:        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,\n./fastapi/applications.py:1346:            Optional[List[Union[str, Enum]]],\n./fastapi/applications.py:1388:            Optional[Dict[Union[int, str], Dict[str, Any]]],\n./fastapi/applications.py:1606:            Optional[List[Union[str, Enum]]],\n./fastapi/applications.py:1672:            Optional[Dict[Union[int, str], Dict[str, Any]]],\n", "stderr": "", "exit_code": 0}

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

{"status": "ok", "stdout": "fastapi/params.py:4:from typing import Any, Callable, Dict, List, Optional, Sequence, Union\nfastapi/security/oauth2.py:1:from typing import Any, Dict, List, Optional, Union, cast\nfastapi/security/api_key.py:1:from typing import Optional, Union\nfastapi/applications.py:293:            Optional[List[Dict[str, Union[str, Any]]]],\nfastapi/applications.py:570:            Optional[Dict[str, Union[str, Any]]],\nfastapi/applications.py:603:            Optional[Dict[str, Union[str, Any]]],\nfastapi/applications.py:692:            Optional[Dict[Union[int, str], Dict[str, Any]]],\nfastapi/applications.py:1148:        tags: Optional[List[Union[str, Enum]]] = None,\nfastapi/applications.py:1153:        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,\nfastapi/applications.py:1206:        tags: Optional[List[Union[str, Enum]]] = None,\nfastapi/applications.py:1211:        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,\nfastapi/applications.py:1346:            Optional[List[Union[str, Enum]]],\nfastapi/applications.py:1388:            Optional[Dict[Union[int, str], Dict[str, Any]]],\nfastapi/applications.py:1606:            Optional[List[Union[str, Enum]]],\nfastapi/applications.py:1672:            Optional[Dict[Union[int, str], Dict[str, Any]]],\nfastapi/applications.py:1979:            Optional[List[Union[str, Enum]]],\nfastapi/applications.py:2045:            Optional[Dict[Union[int, str], Dict[str, Any]]],\nfastapi/applications.py:2357:            Optional[List[Union[str, Enum]]],\nfastapi/applications.py:2423:            Optional[Dict[Union[int, str], Dict[str, Any]]],\nfastapi/applications.py:2735:            Optional[List[Union[str, Enum]]],\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/params.py:4:from typing import Any, Callable, Dict, List, Optional, Sequence, Union\nfastapi/params.py:33:        default_factory: Union[Callable[[], Any], None] = _Unset,\nfastapi/params.py:36:        alias_priority: Union[int, None] = _Unset,\nfastapi/params.py:39:        validation_alias: Union[str, None] = None,\nfastapi/params.py:40:        serialization_alias: Union[str, None] = None,\nfastapi/params.py:56:        discriminator: Union[str, None] = None,\nfastapi/params.py:57:        strict: Union[bool, None] = _Unset,\nfastapi/params.py:58:        multiple_of: Union[float, None] = _Unset,\nfastapi/params.py:59:        allow_inf_nan: Union[bool, None] = _Unset,\nfastapi/params.py:60:        max_digits: Union[int, None] = _Unset,\nfastapi/params.py:61:        decimal_places: Union[int, None] = _Unset,\nfastapi/params.py:71:        deprecated: Union[deprecated, str, bool, None] = None,\nfastapi/params.py:73:        json_schema_extra: Union[Dict[str, Any], None] = None,\nfastapi/params.py:147:        default_factory: Union[Callable[[], Any], None] = _Unset,\nfastapi/params.py:150:        alias_priority: Union[int, None] = _Unset,\nfastapi/params.py:153:        validation_alias: Union[str, None] = None,\nfastapi/params.py:154:        serialization_alias: Union[str, None] = None,\nfastapi/params.py:170:        discriminator: Union[str, None] = None,\nfastapi/params.py:171:        strict: Union[bool, None] = _Unset,\nfastapi/params.py:172:        multiple_of: Union[float, None] = _Unset,\nfastapi/params.py:173:        allow_inf_nan: Union[bool, None] = _Unset,\nfastapi/params.py:174:        max_digits: Union[int, None] = _Unset,\nfastapi/params.py:175:        decimal_places: Union[int, None] = _Unset,\nfastapi/params.py:185:        deprecated: Union[deprecated, str, bool, None] = None,\nfastapi/params.py:187:        json_schema_extra: Union[Dict[str, Any], None] = None,\nfastapi/params.py:233:        default_factory: Union[Callable

{"status": "ok", "stdout": "fastapi/params.py:4:from typing import Any, Callable, Dict, List, Optional, Sequence, Union\nfastapi/params.py:774:    scopes: Optional[Sequence[str]] = None\nfastapi/applications.py:342:            Optional[Sequence[Depends]],\nfastapi/applications.py:481:            Optional[Sequence[Middleware]],\nfastapi/applications.py:514:            Optional[Sequence[Callable[[], Any]]],\nfastapi/applications.py:526:            Optional[Sequence[Callable[[], Any]]],\nfastapi/applications.py:1149:        dependencies: Optional[Sequence[Depends]] = None,\nfastapi/applications.py:1207:        dependencies: Optional[Sequence[Depends]] = None,\nfastapi/applications.py:1266:        dependencies: Optional[Sequence[Depends]] = None,\nfastapi/applications.py:1295:            Optional[Sequence[Depends]],\nfastapi/applications.py:1360:            Optional[Sequence[Depends]],\nfastapi/applications.py:1619:            Optional[Sequence[Depends]],\nfastapi/applications.py:1992:            Optional[Sequence[Depends]],\nfastapi/applications.py:2370:            Optional[Sequence[Depends]],\nfastapi/applications.py:2748:            Optional[Sequence[Depends]],\nfastapi/applications.py:3121:            Optional[Sequence[Depends]],\nfastapi/applications.py:3494:            Optional[Sequence[Depends]],\nfastapi/applications.py:3867:            Optional[Sequence[Depends]],\nfastapi/applications.py:4245:            Optional[Sequence[Depends]],\nfastapi/dependencies/models.py:5:from typing import Any, Callable, List, Optional, Sequence, Union\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/params.py:4:from typing import Any, Callable, Dict, List, Optional, Sequence, Union\nfastapi/dependencies/models.py:5:from typing import Any, Callable, List, Optional, Sequence, Union\nfastapi/openapi/utils.py:4:from typing import Any, Dict, List, Optional, Sequence, Set, Tuple, Type, Union, cast\nfastapi/exceptions.py:1:from typing import Any, Dict, Optional, Sequence, Type, Union\nfastapi/param_functions.py:1:from typing import Any, Callable, Dict, List, Optional, Sequence, Union\nfastapi/_compat/may_v1.py:2:from typing import Any, Dict, List, Literal, Sequence, Tuple, Type, Union\nfastapi/_compat/may_v1.py:116:    *, errors: Sequence[Any], loc_prefix: Tuple[Union[str, int], ...]\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/params.py:8:from typing_extensions import Annotated, Literal, deprecated\nfastapi/security/open_id_connect_url.py:9:from typing_extensions import Annotated\nfastapi/security/oauth2.py:14:from typing_extensions import Annotated\nfastapi/security/api_key.py:9:from typing_extensions import Annotated\nfastapi/security/http.py:14:from typing_extensions import Annotated\nfastapi/applications.py:47:from typing_extensions import Annotated, deprecated\nfastapi/background.py:5:from typing_extensions import Annotated, ParamSpec\nfastapi/dependencies/models.py:10:from typing_extensions import Literal\nfastapi/dependencies/utils.py:78:from typing_extensions import Annotated, Literal, get_args, get_origin\nfastapi/encoders.py:27:from typing_extensions import Annotated\nfastapi/openapi/models.py:14:from typing_extensions import Annotated, Literal, TypedDict\nfastapi/openapi/models.py:15:from typing_extensions import deprecated as typing_deprecated\nfastapi/openapi/docs.py:7:from typing_extensions import Annotated\nfastapi/openapi/utils.py:37:from typing_extensions import Literal\nfastapi/utils.py:33:from typing_extensions import Literal\nfastapi/routing.py:79:from typing_extensions import Annotated, deprecated\nfastapi/temp_pydantic_v1_params.py:6:from typing_extensions import Annotated, deprecated\nfastapi/exceptions.py:7:from typing_extensions import Annotated\nfastapi/param_functions.py:7:from typing_extensions import Annotated, Literal, deprecated\nfastapi/_compat/v1.py:20:from typing_extensions import Literal\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/dependencies/utils.py:78:from typing_extensions import Annotated, Literal, get_args, get_origin\nfastapi/dependencies/utils.py:357:    if get_origin(use_annotation) is Annotated:\nfastapi/dependencies/utils.py:836:    origin = get_origin(field_type)\nfastapi/_compat/shared.py:24:from typing_extensions import Annotated, get_args, get_origin\nfastapi/_compat/shared.py:84:    origin = get_origin(annotation)\nfastapi/_compat/shared.py:91:        get_origin(annotation)\nfastapi/_compat/shared.py:110:    origin = get_origin(annotation)\nfastapi/_compat/shared.py:131:    origin = get_origin(annotation)\nfastapi/_compat/shared.py:150:    origin = get_origin(annotation)\nfastapi/_compat/shared.py:161:    origin = get_origin(annotation)\nfastapi/_compat/shared.py:170:    origin = get_origin(annotation)\nfastapi/_compat/shared.py:185:    origin = get_origin(annotation)\nfastapi/_compat/shared.py:202:    origin = get_origin(annotation)\nfastapi/_compat/v2.py:36:from typing_extensions import Annotated, Literal, get_args, get_origin\nfastapi/_compat/v2.py:383:    origin_type = get_origin(field.field_info.annotation) or field.field_info.annotation\nfastapi/_compat/v2.py:389:            origin_type = get_origin(union_arg) or union_arg\nfastapi/_compat/v2.py:459:    origin = get_origin(annotation)\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/_compat/shared.py:16:    Union,\nfastapi/_compat/shared.py:20:from fastapi.types import UnionType\nfastapi/_compat/shared.py:39:        types.UnionType,\nfastapi/_compat/shared.py:67:    cls: Any, class_or_tuple: Union[Type[Any], Tuple[Type[Any], ...], None]\nfastapi/_compat/shared.py:77:def _annotation_is_sequence(annotation: Union[Type[Any], None]) -> bool:\nfastapi/_compat/shared.py:83:def field_annotation_is_sequence(annotation: Union[Type[Any], None]) -> bool:\nfastapi/_compat/shared.py:85:    if origin is Union or origin is UnionType:\nfastapi/_compat/shared.py:99:def _annotation_is_complex(annotation: Union[Type[Any], None]) -> bool:\nfastapi/_compat/shared.py:109:def field_annotation_is_complex(annotation: Union[Type[Any], None]) -> bool:\nfastapi/_compat/shared.py:111:    if origin is Union or origin is UnionType:\nfastapi/_compat/shared.py:130:def field_annotation_is_scalar_sequence(annotation: Union[Type[Any], None]) -> bool:\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:\n", "stderr": "", "exit_code": 0}

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

{"status": "ok", "stdout": "import sys\nimport types\nimport typing\nfrom collections import deque\nfrom dataclasses import is_dataclass\nfrom typing import (\n    Any,\n    Deque,\n    FrozenSet,\n    List,\n    Mapping,\n    Sequence,\n    Set,\n    Tuple,\n    Type,\n    Union,\n)\n\nfrom fastapi._compat import may_v1\nfrom fastapi.types import UnionType\nfrom pydantic import BaseModel\nfrom pydantic.version import VERSION as PYDANTIC_VERSION\nfrom starlette.datastructures import UploadFile\nfrom typing_extensions import Annotated, get_args, get_origin\n\n# Copy from Pydantic v2, compatible with v1\nif sys.version_info < (3, 9):\n    # Pydantic no longer supports Python 3.8, this might be incorrect, but the code\n    # this is used for is also never reached in this codebase, as it's a copy of\n    # Pydantic's lenient_issubclass, just for compatibility with v1\n    # TODO: remove when dropping support for Python 3.8\n    WithArgsTypes: Tuple[Any, ...] = ()\nelif sys.version_info < (3, 10):\n    WithArgsTypes: tuple[Any, ...] = (typing._GenericAlias, types.GenericAlias)  # type: ignore[attr-defined]\nelse:\n    WithArgsTypes: tuple[Any, ...] = (\n        typing._GenericAlias,  # type: ignore[attr-defined]\n        types.GenericAlias,\n        types.UnionType,\n    )  # pyright: ignore[reportAttributeAccessIssue]\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "import types\nfrom enum import Enum\nfrom typing import Any, Callable, Dict, Optional, Set, Tuple, Type, TypeVar, Union\n\nfrom pydantic import BaseModel\n\nDecoratedCallable = TypeVar(\"DecoratedCallable\", bound=Callable[..., Any])\nUnionType = getattr(types, \"UnionType\", Union)\nModelNameMap = Dict[Union[Type[BaseModel], Type[Enum]], str]\nIncEx = Union[Set[int], Set[str], Dict[int, Any], Dict[str, Any]]\nDependencyCacheKey = Tuple[Optional[Callable[..., Any]], Tuple[str, ...], str]\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "Testing list[int] | None: True\nTesting list[int] | str: True\nTesting Optional[List[int]]: True\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "Testing None | list[int]: True\nTesting str | list[int]: True\nTesting Optional[List[int]]: True\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/_compat/shared.py:109:def field_annotation_is_complex(annotation: Union[Type[Any], None]) -> bool:\nfastapi/_compat/shared.py:112:        return any(field_annotation_is_complex(arg) for arg in get_args(annotation))\nfastapi/_compat/shared.py:115:        return field_annotation_is_complex(get_args(annotation)[0])\nfastapi/_compat/shared.py:127:    return annotation is Ellipsis or not field_annotation_is_complex(annotation)\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    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_core_schema__\")\n    )\n\n\ndef field_annotation_is_scalar(annotation: Any) -> bool:\n    # handle Ellipsis here to make tuple[int, ...] work nicely\n    return annotation is Ellipsis or not field_annotation_is_complex(annotation)\n\n\ndef field_annotation_is_scalar_sequence(annotation: Union[Type[Any], None]) -> bool:\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "Testing None | list[int]: True\nTesting str | list[int]: True\nTesting Optional[List[int]]: True\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/_compat/shared.py:130:def field_annotation_is_scalar_sequence(annotation: Union[Type[Any], None]) -> bool:\nfastapi/_compat/shared.py:135:            if field_annotation_is_scalar_sequence(arg):\nfastapi/_compat/v2.py:362:    return shared.field_annotation_is_scalar_sequence(field.field_info.annotation)\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "def field_annotation_is_scalar_sequence(annotation: Union[Type[Any], None]) -> bool:\n    origin = get_origin(annotation)\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    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\ndef is_bytes_or_nonable_bytes_annotation(annotation: Any) -> bool:\n    if lenient_issubclass(annotation, bytes):\n        return True\n    origin = get_origin(annotation)\n    if origin is Union or origin is UnionType:\n        for arg in get_args(annotation):\n            if lenient_issubclass(arg, bytes):\n                return True\n    return False\n\n\ndef is_uploadfile_or_nonable_uploadfile_annotation(annotation: Any) -> bool:\n    if lenient_issubclass(annotation, UploadFile):\n        return True\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "Testing None | list[int]: True\nTesting str | list[int]: True\nTesting Optional[List[int]]: True\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "Testing None | list[int]: True\nTesting str | list[int]: True\nTesting list[int] | str: True\nTesting Optional[List[int]]: True\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "Testing None | list[int]: True\nTesting str | list[int]: True\nTesting list[int] | str: True\nTesting list[int] | list[str]: True\nTesting list[int] | dict[str, int]: False\nTesting Optional[List[int]]: True\n", "stderr": "", "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/types.py:8:UnionType = getattr(types, \"UnionType\", Union)\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:\n", "stderr": "", "exit_code": 0}

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

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

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

{"status": "ok", "stdout": "fastapi/dependencies/utils.py:78:from typing_extensions import Annotated, Literal, get_args, get_origin\nfastapi/dependencies/utils.py:358:        annotated_args = get_args(annotation)\nfastapi/dependencies/utils.py:842:    union_args = get_args(field_type)\nfastapi/_compat/shared.py:24:from typing_extensions import Annotated, get_args, get_origin\nfastapi/_compat/shared.py:86:        for arg in get_args(annotation):\nfastapi/_compat/shared.py:112:        return any(field_annotation_is_complex(arg) for arg in get_args(annotation))\nfastapi/_compat/shared.py:115:        return field_annotation_is_complex(get_args(annotation)[0])\nfastapi/_compat/shared.py:134:        for arg in get_args(annotation):\nfastapi/_compat/shared.py:143:        for sub_annotation in get_args(annotation)\nfastapi/_compat/shared.py:152:        for arg in get_args(annotation):\nfastapi/_compat/shared.py:163:        for arg in get_args(annotation):\nfastapi/_compat/shared.py:173:        for arg in get_args(annotation):\nfastapi/_compat/shared.py:180:        for sub_annotation in get_args(annotation)\nfastapi/_compat/shared.py:188:        for arg in get_args(annotation):\nfastapi/_compat/shared.py:195:        for sub_annotation in get_args(annotation)\nfastapi/_compat/shared.py:204:        for arg in get_args(annotation):\nfastapi/_compat/shared.py:208:        for sub_annotation in get_args(annotation):\nfastapi/_compat/v2.py:36:from typing_extensions import Annotated, Literal, get_args, get_origin\nfastapi/_compat/v2.py:385:        union_args = get_args(field.field_info.annotation)\nfastapi/_compat/v2.py:461:        for arg in get_args(annotation):\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "\n\ndef serialize_sequence_value(*, field: ModelField, value: Any) -> Sequence[Any]:\n    origin_type = get_origin(field.field_info.annotation) or field.field_info.annotation\n    if origin_type is Union:  # Handle optional sequences\n        union_args = get_args(field.field_info.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    assert issubclass(origin_type, shared.sequence_types)  # type: ignore[arg-type]\n    return shared.sequence_annotation_to_type[origin_type](value)  # type: ignore[no-any-return]\n\n\ndef get_missing_field_error(loc: Tuple[str, ...]) -> Dict[str, Any]:\n    error = ValidationError.from_exception_data(\n        \"Field required\", [{\"type\": \"missing\", \"loc\": loc, \"input\": {}}]\n    ).errors(include_url=False)[0]\n    error[\"input\"] = None\n    return error  # type: ignore[return-value]\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "Annotation list[int] | None with value [1, 2, 3] -> Exception: \nAnnotation None | list[int] with value [1, 2, 3] -> Exception: \nAnnotation typing.Optional[typing.List[int]] with value [1, 2, 3] -> [1, 2, 3]\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "Annotation list[int] | None with value [1, 2, 3] -> Exception: \nAnnotation None | list[int] with value [1, 2, 3] -> Exception: \nAnnotation typing.Optional[typing.List[int]] with value [1, 2, 3] -> [1, 2, 3]\n", "stderr": "", "exit_code": 0}