Extensão
********

A direção principal para a extensão "asyncio" é escrever classes
personalizadas de *event loop*. Asyncio tem auxiliares que podem ser
usados para simplificar esta tarefa.

Nota:

  Terceiros devem reutilizar o código assíncrono existente com
  cuidado, uma versão nova do Python pode quebrar a compatibilidade
  com versões anteriores da parte *interna* da API.


Escrevendo um loop de evento personalizado
==========================================

"asyncio.AbstractEventLoop" declara muitos métodos. Implementar todos
eles do zero é um trabalho tedioso.

Um laço de repetição pode receber, através de herança, vários métodos
de implementação da classe "asyncio.BaseEventLoop".

Por sua vez, o sucessor deve implementar um conjunto de métodos
*privados* declarados, porém não implementados, em
"asyncio.BaseEventLoop".

Por exemplo, "loop.create_connection()``verifica os argumentos,
resolve alguns endereços DNS, e chama a função
``loop._make_socket_transport()" que deve ser implementada por ser uma
classe herdada. O
método``_make_socket_transport()`` não está documentado e é
considerado parte de uma API *interna*.


Construtores privados Future e Task
===================================

As classes "asyncio.Future" e "asyncio.Task" nunca deverão ser criadas
diretamente, por favor, substitua pelas factories correspondentes:
"loop.create_future()" e "loop.create_task()" ou
"asyncio.create_task()".

Porém *event-loops* de terceiros podem *reusar* as implementações
nativas de Future e Task em detrimento de obter um código complexo e
mais otimizado.

Com este propósito, os seguintes construtores *privados* serão
listados a seguir:

Future.__init__(*, loop=None)

   Criar uma uma instância Future nativa.

   *loop* é uma instância opcional do event-loop.

Task.__init__(coro, *, loop=None, name=None, context=None)

   Create a built-in task instance.

   *loop* is an optional event loop instance. The rest of arguments
   are described in "loop.create_task()" description.

   Alterado na versão 3.11: *context* argument is added.


Task lifetime support
=====================

A third party task implementation should call the following functions
to keep a task visible by "asyncio.all_tasks()" and
"asyncio.current_task()":

asyncio._register_task(task)

   Register a new *task* as managed by *asyncio*.

   Call the function from a task constructor.

asyncio._unregister_task(task)

   Unregister a *task* from *asyncio* internal structures.

   The function should be called when a task is about to finish.

asyncio._enter_task(loop, task)

   Switch the current task to the *task* argument.

   Call the function just before executing a portion of embedded
   *coroutine* ("coroutine.send()" or "coroutine.throw()").

asyncio._leave_task(loop, task)

   Switch the current task back from *task* to "None".

   Call the function just after "coroutine.send()" or
   "coroutine.throw()" execution.
