Dann können wir einen `AsyncClient` mit der App erstellen und mit `await` asynchrone Requests an ihn senden.

{* ../../docs_src/async_tests/test_main.py hl[9:12] *}

Das ist das Äquivalent zu:

```Python
response = client.get('/')
```

... welches wir verwendet haben, um unsere Requests mit dem `TestClient` zu machen.

/// tip | "Tipp"

Beachten Sie, dass wir async/await mit dem neuen `AsyncClient` verwenden – der Request ist asynchron.

///

Then we can create an `AsyncClient` with the app, and send async requests to it, using `await`.

{* ../../docs_src/async_tests/test_main.py hl[9:12] *}

This is the equivalent to:

```Python
response = client.get('/')
```

...that we used to make our requests with the `TestClient`.

/// tip

Note that we're using async/await with the new `AsyncClient` - the request is asynchronous.

///

/// warning

* `read(size)`: Lê `size` (`int`) bytes/caracteres do arquivo.
* `seek(offset)`: Vai para o byte na posição `offset` (`int`) no arquivo.
    * Por exemplo, `await myfile.seek(0)` irá para o início do arquivo.
    * Isso é especialmente útil se você executar `await myfile.read()` uma vez e precisar ler o conteúdo novamente.
* `close()`: Fecha o arquivo.

Como todos esses métodos são métodos `assíncronos`, você precisa "aguardar" por eles.

        elif is_gen_callable(call) or is_async_gen_callable(call):
            solved = await solve_generator(
                call=call, stack=async_exit_stack, sub_values=solved_result.values
            )
        elif is_coroutine_callable(call):
            solved = await call(**solved_result.values)
        else:
            solved = await run_in_threadpool(call, **solved_result.values)
        if sub_dependant.name is not None:

        with:
          github-token: ${{secrets.GITHUB_TOKEN}}
          script: |
            const script = require('./.github/workflows/create_issue.js')

            });
        }

        // start all threads at once
        try {
            startLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // wait for all thread to end
        try {
            endLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

///

## Aguardar por mensagens e enviar mensagens

Em sua rota WebSocket você pode esperar (`await`) por mensagens e enviar mensagens.

{*../../docs_src/websockets/tutorial001.py hl[48:52]*}

Você pode receber e enviar dados binários, de texto e JSON.

## Tente você mesmo

                  startLatch.countDown();
                  startLatch.await();
                  callable.call();
                  doneLatch.countDown();
                  return null;
                }
              });
    }
    doneLatch.await();
  }

```Python
with open("file.txt") as file:
    file.read()
```

In recent versions of Python, there's also an **async context manager**. You would use it with `async with`:

```Python
async with lifespan(app):
    await do_stuff()
```

    Como sempre, no FastAPI você pode combinar `def` e `async def` conforme necessário.

    Se você precisar de uma atualização sobre quando usar qual, confira a seção _"Com pressa?"_ na documentação sobre [`async` e `await`](../async.md#in-a-hurry){.internal-link target=_blank}.

9. Esta *função de operação de rota* não está retornando dataclasses (embora pudesse), mas uma lista de dicionários com dados internos.