Streams¶

Código fuente: Lib/asyncio/streams.py

Los streams son async/await primitivos de alto nivel para trabajar con conexiones de red. Los streams permiten enviar y recibir datos sin utilizar callbacks o protocolos y transportes de bajo nivel.

Aquí hay un ejemplo de un cliente eco TCP escrito utilizando streams asyncio:

import asyncio

async def tcp_echo_client(message):
    reader, writer = await asyncio.open_connection(
        '127.0.0.1', 8888)

    print(f'Send: {message!r}')
    writer.write(message.encode())
    await writer.drain()

    data = await reader.read(100)
    print(f'Received: {data.decode()!r}')

    print('Close the connection')
    writer.close()
    await writer.wait_closed()

asyncio.run(tcp_echo_client('Hello World!'))

Consulte también la sección de Examples a continuación.

Funciones stream

Las siguientes funciones asyncio de nivel superior se pueden utilizar para crear y trabajar con streams:

coroutine asyncio.open_connection(host=None, port=None, *, limit=None, ssl=None, family=0, proto=0, flags=0, sock=None, local_addr=None, server_hostname=None, ssl_handshake_timeout=None, ssl_shutdown_timeout=None, happy_eyeballs_delay=None, interleave=None)¶

Establece una conexión de red y retorna un par de objetos (reader, writer).

Los objetos reader y writer retornados son instancias de las clases StreamReader y StreamWriter.

limit determina el límite de tamaño del búfer utilizado por la instancia de StreamReader retornada. De forma predeterminada, limit está establecido en 64 KiB.

El resto de los argumentos se pasan directamente a loop.create_connection().

Nota

El argumento sock transfiere la propiedad del socket al StreamWriter creado. Para cerrar el socket, llame a su método close().

Distinto en la versión 3.7: Se agregó el parámetro ssl_handshake_timeout.

Distinto en la versión 3.8: Added the happy_eyeballs_delay and interleave parameters.

Distinto en la versión 3.10: Se eliminó el parámetro loop.

Distinto en la versión 3.11: Added the ssl_shutdown_timeout parameter.

coroutine asyncio.start_server(client_connected_cb, host=None, port=None, *, limit=None, family=socket.AF_UNSPEC, flags=socket.AI_PASSIVE, sock=None, backlog=100, ssl=None, reuse_address=None, reuse_port=None, ssl_handshake_timeout=None, ssl_shutdown_timeout=None, start_serving=True)¶

Inicia un servidor socket.

La retrollamada client_connected_cb se llama siempre que se establece una nueva conexión de cliente. Recibe un par (reader, writer) como dos argumentos, instancias de las clases StreamReader y StreamWriter.

client_connected_cb puede ser una función simple invocable o de corrutina; si es una función de corrutina, se programará automáticamente como un Task.

limit determina el límite de tamaño del búfer utilizado por la instancia de StreamReader retornada. De forma predeterminada, limit está establecido en 64 KiB.

El resto de los argumentos se pasan directamente a loop.create_server().

Nota

El argumento sock transfiere la propiedad del socket al servidor creado. Para cerrar el socket, llame al método close() del servidor.

Distinto en la versión 3.7: Se agregaron los parámetros ssl_handshake_timeout y start_serving.

Distinto en la versión 3.10: Se eliminó el parámetro loop.

Distinto en la versión 3.11: Added the ssl_shutdown_timeout parameter.

Sockets Unix

coroutine asyncio.open_unix_connection(path=None, *, limit=None, ssl=None, sock=None, server_hostname=None, ssl_handshake_timeout=None, ssl_shutdown_timeout=None)¶: Establece una conexión de socket Unix y retorna un par de (reader, writer).

Similar a open_connection() pero opera en sockets Unix.

Consulte también la documentación de loop.create_unix_connection().

Nota

El argumento sock transfiere la propiedad del socket al StreamWriter creado. Para cerrar el socket, llame a su método close().

Disponibilidad: Unix.

Distinto en la versión 3.7: Se agregó el parámetro ssl_handshake_timeout. El parámetro path ahora puede ser un path-like object

Distinto en la versión 3.10: Se eliminó el parámetro loop.

Distinto en la versión 3.11: Added the ssl_shutdown_timeout parameter.

coroutine asyncio.start_unix_server(client_connected_cb, path=None, *, limit=None, sock=None, backlog=100, ssl=None, ssl_handshake_timeout=None, ssl_shutdown_timeout=None, start_serving=True)¶

Inicia un servidor socket Unix.

Similar a start_server() pero funciona con sockets Unix.

Consulte también la documentación de loop.create_unix_server().

Nota

El argumento sock transfiere la propiedad del socket al servidor creado. Para cerrar el socket, llame al método close() del servidor.

Disponibilidad: Unix.

Distinto en la versión 3.7: Se agregaron los parámetros ssl_handshake_timeout y start_serving. El parámetro path ahora puede ser un path-like object.

Distinto en la versión 3.10: Se eliminó el parámetro loop.

Distinto en la versión 3.11: Added the ssl_shutdown_timeout parameter.

StreamReader¶

class asyncio.StreamReader¶

Represents a reader object that provides APIs to read data from the IO stream. As an asynchronous iterable, the object supports the async for statement.

No se recomienda crear instancias de objetos StreamReader directamente; utilice open_connection() y start_server() en su lugar.

feed_eof()¶: Acknowledge the EOF.

coroutine read(n=-1)¶

Read up to n bytes from the stream.

If n is not provided or set to -1, read until EOF, then return all read bytes. If EOF was received and the internal buffer is empty, return an empty bytes object.

If n is 0, return an empty bytes object immediately.

If n is positive, return at most n available bytes as soon as at least 1 byte is available in the internal buffer. If EOF is received before any byte is read, return an empty bytes object.

coroutine readline()¶

Lea una línea, donde «línea» es una secuencia de bytes que termina en \n.

Si se recibe EOF (final del archivo) y no se encontró \n, el método retorna datos leídos parcialmente.

Si se recibe EOF (final de archivo) y el búfer interno está vacío, retorna un objeto bytes vacío.

coroutine readexactly(n)¶

Lee exactamente n bytes.

Genera un IncompleteReadError si se alcanza EOF (final del archivo) antes de que se pueda leer n. Utilice el atributo IncompleteReadError.partial para obtener los datos leídos parcialmente.

coroutine readuntil(separator=b'\n')¶

Lee datos de la secuencia hasta que se encuentre el separador (separator).

En caso de éxito, los datos y el separador se eliminarán del búfer interno (consumido). Los datos retornados incluirán el separador al final.

Si la cantidad de datos leídos excede el límite de flujo configurado, se genera una excepción LimitOverrunError y los datos se dejan en el búfer interno y se pueden leer nuevamente.

Si se alcanza EOF (final del archivo) antes de que se encuentre el separador completo, se genera una excepción IncompleteReadError y se restablece el búfer interno. El atributo IncompleteReadError.partial puede contener una parte del separador.

Nuevo en la versión 3.5.2.

at_eof()¶: Retorna True si el buffer está vacío y feed_eof() fue llamado.

StreamWriter¶

class asyncio.StreamWriter¶

Representa un objeto de escritura que proporciona APIs para escribir datos en el flujo de E/S.

No se recomienda crear instancias de objetos StreamWriter directamente; use open_connection() y start_server() en su lugar.

write(data)¶

El método intenta escribir los datos (data) en el socket subyacente inmediatamente. Si eso falla, los datos se ponen en cola en un búfer de escritura interno hasta que se puedan enviar.

El método debe usarse junto con el método drain():

stream.write(data)
await stream.drain()

writelines(data)¶

El método escribe una lista (o cualquier iterable) de bytes en el socket subyacente inmediatamente. Si eso falla, los datos se ponen en cola en un búfer de escritura interno hasta que se puedan enviar.

El método debe usarse junto con el método drain():

stream.writelines(lines)
await stream.drain()

close()¶

El método cierra la secuencia y el socket subyacente.

The method should be used, though not mandatory, along with the wait_closed() method:

stream.close()
await stream.wait_closed()

can_write_eof()¶: Retorna True si el transporte subyacente admite el método write_eof(), False en caso contrario.

write_eof()¶: Cierra la escritura de la secuencia después de que se vacíen los datos de escritura almacenados en búfer.

transport¶: Retorna el transporte asyncio subyacente.

get_extra_info(name, default=None)¶: Accede a información de transporte opcional; consulte BaseTransport.get_extra_info() para obtener más detalles.

coroutine drain()¶

Espera hasta que sea apropiado reanudar la escritura en la transmisión. Ejemplo:

writer.write(data)
await writer.drain()

Este es un método de control de flujo que interactúa con el búfer de escritura de E/S subyacente. Cuando el tamaño del búfer alcanza la marca de agua alta, drain() bloquea hasta que el tamaño del búfer se agota hasta la marca de agua baja y se pueda reanudar la escritura. Cuando no hay nada que esperar, drain() regresa inmediatamente.

coroutine start_tls(sslcontext, *, server_hostname=None, ssl_handshake_timeout=None)¶

Actualiza una conexión existente basada en flujo a TLS.

Parámetros:

sslcontext: una instancia configurada de SSLContext.
server_hostname: establece o sustituye el nombre de host con el que se comparará el certificado del servidor de destino.
ssl_handshake_timeout es el tiempo en segundos que se espera a que se complete el protocolo TLS antes de abortar la conexión. 60.0 segundos si None (por defecto).

Nuevo en la versión 3.11.

is_closing()¶: Retorna True si la secuencia está cerrada o en proceso de cerrarse.

Nuevo en la versión 3.7.

coroutine wait_closed()¶

Espera hasta que se cierre la secuencia.

Should be called after close() to wait until the underlying connection is closed, ensuring that all data has been flushed before e.g. exiting the program.

Nuevo en la versión 3.7.

Ejemplos¶

Cliente eco TCP usando streams¶

Cliente eco TCP usando la función asyncio.open_connection():

import asyncio

async def tcp_echo_client(message):
    reader, writer = await asyncio.open_connection(
        '127.0.0.1', 8888)

    print(f'Send: {message!r}')
    writer.write(message.encode())
    await writer.drain()

    data = await reader.read(100)
    print(f'Received: {data.decode()!r}')

    print('Close the connection')
    writer.close()
    await writer.wait_closed()

asyncio.run(tcp_echo_client('Hello World!'))

Ver también

El ejemplo del protocolo de cliente eco TCP utiliza el método loop.create_connection() de bajo nivel.

Servidor eco TCP usando streams¶

Servidor eco TCP usando la función asyncio.start_server():

import asyncio

async def handle_echo(reader, writer):
    data = await reader.read(100)
    message = data.decode()
    addr = writer.get_extra_info('peername')

    print(f"Received {message!r} from {addr!r}")

    print(f"Send: {message!r}")
    writer.write(data)
    await writer.drain()

    print("Close the connection")
    writer.close()
    await writer.wait_closed()

async def main():
    server = await asyncio.start_server(
        handle_echo, '127.0.0.1', 8888)

    addrs = ', '.join(str(sock.getsockname()) for sock in server.sockets)
    print(f'Serving on {addrs}')

    async with server:
        await server.serve_forever()

asyncio.run(main())

Ver también

El ejemplo del protocolo de servidor eco TCP utiliza el método loop.create_server().

Obtener encabezados HTTP¶

Ejemplo simple de consulta de encabezados HTTP de la URL pasada en la línea de comando:

import asyncio
import urllib.parse
import sys

async def print_http_headers(url):
    url = urllib.parse.urlsplit(url)
    if url.scheme == 'https':
        reader, writer = await asyncio.open_connection(
            url.hostname, 443, ssl=True)
    else:
        reader, writer = await asyncio.open_connection(
            url.hostname, 80)

    query = (
        f"HEAD {url.path or '/'} HTTP/1.0\r\n"
        f"Host: {url.hostname}\r\n"
        f"\r\n"
    )

    writer.write(query.encode('latin-1'))
    while True:
        line = await reader.readline()
        if not line:
            break

        line = line.decode('latin1').rstrip()
        if line:
            print(f'HTTP header> {line}')

    # Ignore the body, close the socket
    writer.close()
    await writer.wait_closed()

url = sys.argv[1]
asyncio.run(print_http_headers(url))

Uso:

python example.py http://example.com/path/page.html

o con HTTPS:

python example.py https://example.com/path/page.html

Registrar un socket abierto para esperar datos usando streams¶

Corutina esperando hasta que un socket reciba datos usando la función open_connection() function:

import asyncio
import socket

async def wait_for_data():
    # Get a reference to the current event loop because
    # we want to access low-level APIs.
    loop = asyncio.get_running_loop()

    # Create a pair of connected sockets.
    rsock, wsock = socket.socketpair()

    # Register the open socket to wait for data.
    reader, writer = await asyncio.open_connection(sock=rsock)

    # Simulate the reception of data from the network
    loop.call_soon(wsock.send, 'abc'.encode())

    # Wait for data
    data = await reader.read(100)

    # Got data, we are done: close the socket
    print("Received:", data.decode())
    writer.close()
    await writer.wait_closed()

    # Close the second socket
    wsock.close()

asyncio.run(wait_for_data())

Ver también

El ejemplo de registro de un socket abierto para esperar datos usando un protocolo utiliza un protocolo de bajo nivel y el método loop.create_connection().

El ejemplo de observar un descriptor de archivo para leer eventos utiliza el método loop.add_reader() de bajo nivel para ver un descriptor de archivo.

Streams¶

StreamReader¶

StreamWriter¶

Ejemplos¶

Cliente eco TCP usando streams¶

Servidor eco TCP usando streams¶

Obtener encabezados HTTP¶

Registrar un socket abierto para esperar datos usando streams¶

Tabla de contenido

Tema anterior

Próximo tema

Esta página