# Futures

Código fuente: Lib/asyncio/futures.py, Lib/asyncio/base_futures.py

Los objetos Future se utilizan para conectar código basado en retrollamadas de bajo nivel (low-level callback-based code) con código async/await de alto nivel.

## Funciones Future

asyncio.isfuture(obj)

  Retorna `True` si obj es uno de los siguientes:

  - una instancia de `asyncio.Future`,

  - una instancia de `asyncio.Task`,

  - un objeto tipo Future con un atributo `_asyncio_future_blocking`.

  Nuevo en la versión 3.5.

asyncio.ensure_future(obj, *, loop=None)

  Retorna:

  - el argumento obj inalterado, si obj es una `Future`, `Task`, o un objeto tipo Future (esto se puede verificar con `isfuture()`.)

  - un objeto `Task` envolviendo obj, si obj es una corrutina (esto se puede verificar con `iscoroutine()`); en este caso, la corrutina será programada por `ensure_future()`.

  - un objeto `Task` que aguardará a obj, si obj es aguardable (esto se puede verificar con `inspect.isawaitable()`.)

  Si obj no es ninguno de los superiores, se lanzará `TypeError`.

  Importante

  Ver también la función `create_task()`, que es la forma preferida de crear nuevas Tasks.

  Guarda una referencia al resultado de esta función, evita que una tarea desaparezca a mitad de su ejecución.

  Distinto en la versión 3.5.1: La función acepta cualquier objeto awaitable.

  Obsoleto desde la versión 3.10: Se emite una advertencia de desaprobación si obj no es un objeto tipo Future y no se especifica loop y no hay un bucle de eventos en ejecución.

asyncio.wrap_future(future, *, loop=None)

  Envuelve un objeto `concurrent.futures.Future` en un objeto `asyncio.Future`.

  Obsoleto desde la versión 3.10: Se emite una advertencia de desaprobación si future no es un objeto tipo Future y loop no se especifica y no hay un bucle de eventos en ejecución.

## Objeto Future

class asyncio.Future(*, loop=None)

  Un Future representa un resultado eventual de una operación asíncrona. No es seguro en hilos (thread-safe).

  Future es un objeto awaitable. Las corrutinas pueden esperar a objetos Future hasta que obtengan un resultado o excepción, o hasta que se cancelen. Un Future puede esperarse varias veces y el resultado es el mismo.

  Normalmente, los Futures se utilizan para permitir que código basado en retrollamadas de bajo nivel (low-level callback-based code) (por ejemplo, en protocolos implementados utilizando asyncio transports) interactúe con código async/await de alto nivel.

  Es recomendable no exponer nunca objetos Future en APIs expuestas al usuario, y la forma recomendada de crear un objeto Future es llamando a `loop.create_future()`. De esta forma, implementaciones alternativas de bucles de eventos (event loop) pueden inyectar sus propias implementaciones optimizadas de un objeto Future.

  Distinto en la versión 3.7: Añadido soporte para el módulo `contextvars`.

  Obsoleto desde la versión 3.10: Se emite una advertencia de desaprobación si no se especifica loop y no hay un bucle de eventos en ejecución.

  result()

    Retorna el resultado del Future.

    Si el Future es done y tiene un resultado establecido por el método `set_result()`, el valor resultante es retornado.

    Si el Future es done y tiene una excepción establecida por el método `set_exception()`, este método lanzará esta excepción.

    Si un evento es cancelled, este método lanzará una excepción `CancelledError`.

    Si el resultado del Future todavía no está disponible, este método lanzará una excepción `InvalidStateError`.

  set_result(result)

    Marca el Future como done y establece su resultado.

    Lanza un error `InvalidStateError` si el Future ya está done.

  set_exception(exception)

    Marca el Future como done y establece una excepción.

    Lanza un error `InvalidStateError` si el Future ya está done.

  done()

    Retorna `True` si el Future está done.

    Un Future está done si estaba cancelled o si tiene un resultado o excepción establecidos mediante llamadas a `set_result()` o `set_exception()`.

  cancelled()

    Retorna `True` si el Future fue cancelled.

    El método suele utilizarse para comprobar que un Future no es cancelled antes de establecer un resultado o excepción al mismo:

        if not fut.cancelled():
            fut.set_result(42)

  add_done_callback(callback, *, context=None)

    Añade una retrollamada (callback) a ser ejecutada cuando el Future es done.

    La retrollamada (callback) es llamada con el objeto Future como su único argumento.

    Si el Future ya es done cuando se llama a este método, la retrollamada (callback) es programada con `loop.call_soon()`.

    Un argumento opcional de contexto, por palabra clave, permite especificar un `contextvars.Context` personalizado para ser ejecutado en la retrollamada (callback). El contexto actual se utiliza cuando no se provee un contexto (context).

    `functools.partial()` se puede utilizar para dar parámetros a la retrollamada (callback), por ejemplo:

        # Call 'print("Future:", fut)' when "fut" is done.
        fut.add_done_callback(
            functools.partial(print, "Future:"))

    Distinto en la versión 3.7: El parámetro de contexto (context) por palabra clave fue añadido. Ver PEP 567 para más detalles.

  remove_done_callback(callback)

    Elimina la retrollamada (callback) de la lista de retrollamadas.

    Retorna el número de retrollamadas (callbacks) eliminadas, que normalmente es 1, excepto si una retrollamada fue añadida más de una vez.

  cancel(msg=None)

    Cancela el Future y programa retrollamadas (callbacks).

    Si el Future ya está done o cancelled, retorna `False`. De lo contrario, cambia el estado del Future a cancelled, programa las retrollamadas, y retorna `True`.

    Distinto en la versión 3.9: Se agregó el parámetro msg.

  exception()

    Retorna la excepción definida en este Future.

    La excepción (o `None` si no se había establecido ninguna excepción) es retornada sólo si Future es done.

    Si un evento es cancelled, este método lanzará una excepción `CancelledError`.

    Si el Future todavía no es done, este método lanza una excepción `InvalidStateError`.

  get_loop()

    Retorna el bucle de eventos (event loop) al cual el objeto Future está asociado.

    Nuevo en la versión 3.7.

Este ejemplo crea un objeto Future, crea y programa una Task asíncrona para establecer el resultado para el Future, y espera hasta que el Future tenga un resultado:

    async def set_after(fut, delay, value):
        # Sleep for *delay* seconds.
        await asyncio.sleep(delay)

        # Set *value* as a result of *fut* Future.
        fut.set_result(value)

    async def main():
        # Get the current event loop.
        loop = asyncio.get_running_loop()

        # Create a new Future object.
        fut = loop.create_future()

        # Run "set_after()" coroutine in a parallel Task.
        # We are using the low-level "loop.create_task()" API here because
        # we already have a reference to the event loop at hand.
        # Otherwise we could have just used "asyncio.create_task()".
        loop.create_task(
            set_after(fut, 1, '... world'))

        print('hello ...')

        # Wait until *fut* has a result (1 second) and print it.
        print(await fut)

    asyncio.run(main())

Importante

El objeto Future fue diseñado para imitar a `concurrent.futures.Future`. Entre las principales diferencias están:

- al contrario que Futures de asyncio, las instancias de `concurrent.futures.Future` no son aguardables (await).

- `asyncio.Future.result()` y `asyncio.Future.exception()` no aceptan el argumento timeout.

- `asyncio.Future.result()` y `asyncio.Future.exception()` lanzan una excepción `InvalidStateError` cuando el Future no es done.

- Las retrollamadas (callbacks) registradas con `asyncio.Future.add_done_callback()` no son llamadas inmediatamente, sino que son programadas con `loop.call_soon()`.

- asyncio Future no es compatible con las funciones `concurrent.futures.wait()` ni `concurrent.futures.as_completed()`.

- `asyncio.Future.cancel()` accepts an optional `msg` argument, but `concurrent.futures.Future.cancel()` does not.