class ItemGroup(BaseModel):
    items: list[tuple[str, str]]


class Coordinate(BaseModel):
    x: float
    y: float


@app.post("/model-with-tuple/")
def post_model_with_tuple(item_group: ItemGroup):
    return item_group


@app.post("/tuple-of-models/")
def post_tuple_of_models(square: tuple[Coordinate, Coordinate]):
    return square


@app.post("/tuple-form/")

def _remap_definitions_and_field_mappings(
    *,
    model_name_map: ModelNameMap,
    definitions: dict[str, Any],
    field_mapping: dict[
        tuple[ModelField, Literal["validation", "serialization"]], JsonSchemaValue
    ],
) -> tuple[
    dict[tuple[ModelField, Literal["validation", "serialization"]], JsonSchemaValue],
    dict[str, Any],
]:
    old_name_to_new_name_map = {}

UnionType = getattr(types, "UnionType", Union)
ModelNameMap = dict[Union[type[BaseModel], type[Enum]], str]
IncEx = Union[set[int], set[str], dict[int, Any], dict[str, Any]]

@needs_py310
def test_typing():
    types = {
        list[int]: [1, 2, 3],
        dict[str, list[int]]: {"a": [1, 2, 3], "b": [4, 5, 6]},
        set[int]: [1, 2, 3],  # `set` is converted to `list`
        tuple[int, ...]: [1, 2, 3],  # `tuple` is converted to `list`
    }
    for test_type, expect in types.items():
        app = FastAPI()

        @app.post("/", response_model=test_type)
        def post_endpoint(input: test_type):

E, ainda assim, o editor sabe que é um `str` e fornece suporte para isso.

#### Tuple e Set { #tuple-and-set }

Você faria o mesmo para declarar `tuple`s e `set`s:

{* ../../docs_src/python_types/tutorial007_py39.py hl[1] *}

Isso significa que:

* A variável `items_t` é uma `tuple` com 3 itens, um `int`, outro `int` e uma `str`.

Y aún así, el editor sabe que es un `str` y proporciona soporte para eso.

#### Tuple y Set { #tuple-and-set }

Harías lo mismo para declarar `tuple`s y `set`s:

{* ../../docs_src/python_types/tutorial007_py39.py hl[1] *}

Esto significa:

* La variable `items_t` es un `tuple` con 3 ítems, un `int`, otro `int`, y un `str`.

def client() -> Iterator[TestClient]:
    with TestClient(app) as client:
        yield client


def _bench_get(benchmark, client: TestClient, path: str) -> tuple[int, bytes]:
    warmup = client.get(path)
    assert warmup.status_code == 200

    def do_request() -> tuple[int, bytes]:
        response = client.get(path)
        return response.status_code, response.content

    return benchmark(do_request)

And still, the editor knows it is a `str`, and provides support for that.

#### Tuple and Set { #tuple-and-set }

You would do the same to declare `tuple`s and `set`s:

{* ../../docs_src/python_types/tutorial007_py39.py hl[1] *}

This means:

* The variable `items_t` is a `tuple` with 3 items, an `int`, another `int`, and a `str`.

from typing import Optional


def get_authorization_scheme_param(
    authorization_header_value: Optional[str],
) -> tuple[str, str]:
    if not authorization_header_value:
        return "", ""
    scheme, _, param = authorization_header_value.partition(" ")

И всё же редактор кода знает, что это `str`, и даёт соответствующую поддержку.

#### Tuple и Set { #tuple-and-set }

Аналогично вы бы объявили `tuple` и `set`:

{* ../../docs_src/python_types/tutorial007_py39.py hl[1] *}

Это означает:

* Переменная `items_t` — это `tuple` из 3 элементов: `int`, ещё один `int` и `str`.
* Переменная `items_s` — это `set`, и каждый элемент имеет тип `bytes`.