Índice da API de alto nível
***************************

Esta página lista todas as APIs asyncio de alto nível habilitadas por
async/await.


Tarefas
=======

Utilitários para executar programas asyncio, criar Tasks, e esperar
por múltiplas coisas com tempos limites.

+----------------------------------------------------+----------------------------------------------------+
| "run()"                                            | Cria um loop de evento, roda uma corrotina, fecha  |
|                                                    | o loop.                                            |
+----------------------------------------------------+----------------------------------------------------+
| "create_task()"                                    | Inicia uma Task de asyncio.                        |
+----------------------------------------------------+----------------------------------------------------+
| "await" "sleep()"                                  | Dorme for um número de segundos.                   |
+----------------------------------------------------+----------------------------------------------------+
| "await" "gather()"                                 | Agenda e espera pelas coisas concorrentemente.     |
+----------------------------------------------------+----------------------------------------------------+
| "await" "wait_for()"                               | Executar com um tempo limite.                      |
+----------------------------------------------------+----------------------------------------------------+
| "await" "shield()"                                 | Proteger contra cancelamento.                      |
+----------------------------------------------------+----------------------------------------------------+
| "await" "wait()"                                   | Monitorar para  for conclusão.                     |
+----------------------------------------------------+----------------------------------------------------+
| "current_task()"                                   | Retorna para a Task atual.                         |
+----------------------------------------------------+----------------------------------------------------+
| "all_tasks()"                                      | Retorna todas as tasks para um loop de evento.     |
+----------------------------------------------------+----------------------------------------------------+
| "Task"                                             | Objeto Task.                                       |
+----------------------------------------------------+----------------------------------------------------+
| "run_coroutine_threadsafe()"                       | Agenda uma corrotina a partir de outra thread do   |
|                                                    | sistema operacional.                               |
+----------------------------------------------------+----------------------------------------------------+
| "for in" "as_completed()"                          | Monitora a conclusão com um loop "for".            |
+----------------------------------------------------+----------------------------------------------------+

-[ Exemplos ]-

* Usando asyncio.gather() para executar coisas em paralelo.

* Usando asyncio.wait_for() para forçar um tempo limite de execução.

* Cancelamento.

* Usando asyncio.sleep().

* Veja também a página principal de documentação sobre Tasks.


Filas
=====

Filas devem ser usadas para distribuir trabalho entre múltiplos
asyncio Tasks, implementar pools de conexão, e padrões pub/sub.

+----------------------------------------------------+----------------------------------------------------+
| "Queue"                                            | Uma fila FIFO - Primeiro que entra, é o primeiro   |
|                                                    | que sai.                                           |
+----------------------------------------------------+----------------------------------------------------+
| "PriorityQueue"                                    | Uma fila de prioridade.                            |
+----------------------------------------------------+----------------------------------------------------+
| "LifoQueue"                                        | Uma fila LIFO - Último que entra, é o primeiro que |
|                                                    | sai.                                               |
+----------------------------------------------------+----------------------------------------------------+

-[ Exemplos ]-

* Usando asyncio.Queue para distribuir cargas de trabalho entre
  diversas Tasks.

* Veja também a Página de documentação da classe Queue.


Subprocesso
===========

Utilitários para iniciar subprocessos e executar comandos no console.

+----------------------------------------------------+----------------------------------------------------+
| "await" "create_subprocess_exec()"                 | Cria um subprocesso.                               |
+----------------------------------------------------+----------------------------------------------------+
| "await" "create_subprocess_shell()"                | Executa um comando no console.                     |
+----------------------------------------------------+----------------------------------------------------+

-[ Exemplos ]-

* Executando um comando no console.

* Veja também a documentação de subprocessos de APIs.


Fluxos
======

APIs de alto nível para trabalhar com entrada e saída de rede.

+----------------------------------------------------+----------------------------------------------------+
| "await" "open_connection()"                        | Estabelece uma conexão TCP.                        |
+----------------------------------------------------+----------------------------------------------------+
| "await" "open_unix_connection()"                   | Estabelece uma conexão com soquete Unix.           |
+----------------------------------------------------+----------------------------------------------------+
| "await" "start_server()"                           | Inicia um servidor TCP.                            |
+----------------------------------------------------+----------------------------------------------------+
| "await" "start_unix_server()"                      | Inicia um servidor com soquete Unix.               |
+----------------------------------------------------+----------------------------------------------------+
| "StreamReader"                                     | Objeto async/await de alto nível para receber      |
|                                                    | dados de rede.                                     |
+----------------------------------------------------+----------------------------------------------------+
| "StreamWriter"                                     | Objeto async/await de alto nível para enviar dados |
|                                                    | pela rede.                                         |
+----------------------------------------------------+----------------------------------------------------+

-[ Exemplos ]-

* Exemplo de cliente TCP.

* Veja também a documentação de fluxos APIs.


Sincronização
=============

Primitivas de sincronização similares a threads, que podem ser usadas
em tarefas.

+----------------------------------------------------+----------------------------------------------------+
| "Lock"                                             | Um bloqueio mutex.                                 |
+----------------------------------------------------+----------------------------------------------------+
| "Event"                                            | Um objeto de evento.                               |
+----------------------------------------------------+----------------------------------------------------+
| "Condition"                                        | Um objeto de condição.                             |
+----------------------------------------------------+----------------------------------------------------+
| "Semaphore"                                        | Um semáforo.                                       |
+----------------------------------------------------+----------------------------------------------------+
| "BoundedSemaphore"                                 | Um semáforo limitado.                              |
+----------------------------------------------------+----------------------------------------------------+

-[ Exemplos ]-

* Usando asyncio.Event.

* Veja também a documentação das primitivas de sincronização de
  asyncio.


Exceções
========

+----------------------------------------------------+----------------------------------------------------+
| "asyncio.TimeoutError"                             | Levantado ao atingir o tempo limite de funções     |
|                                                    | como "wait_for()". Tenha em mente que              |
|                                                    | "asyncio.TimeoutError" **não é relacionado** com a |
|                                                    | exceção "TimeoutError" embutida.                   |
+----------------------------------------------------+----------------------------------------------------+
| "asyncio.CancelledError"                           | Levantado quanto a Task é cancelada. Veja também   |
|                                                    | "Task.cancel()".                                   |
+----------------------------------------------------+----------------------------------------------------+

-[ Exemplos ]-

* Manipulando CancelledError para executar código no cancelamento de
  uma requisição.

* Veja também a lista completa de exceções específicas de asyncio.
