# Copyright (C) 2001-2020, Python Software Foundation

# This file is distributed under the same license as the Python package.

# Maintained by the python-doc-es workteam.

# docs-es@python.org /

# https://mail.python.org/mailman3/lists/docs-es.python.org/

# Check https://github.com/python/python-docs-es/blob/3.8/TRANSLATORS to

# get the list of volunteers

#

msgid ""

msgstr ""

"Project-Id-Version: Python 3.8\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2024-11-21 16:38-0300\n"

"PO-Revision-Date: 2023-02-10 14:01+0100\n"

"Last-Translator: Gustavo Huarcaya <diavolo@gahd.net>\n"

"Language: es\n"

"Language-Team: python-doc-es\n"

"Plural-Forms: nplurals=2; plural=(n != 1);\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=utf-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Generated-By: Babel 2.16.0\n"

#: ../Doc/library/asyncio-stream.rst:7

msgid "Streams"

msgstr "Streams"

#: ../Doc/library/asyncio-stream.rst:9

msgid "**Source code:** :source:`Lib/asyncio/streams.py`"

msgstr "**Código fuente:** :source:`Lib/asyncio/streams.py`"

#: ../Doc/library/asyncio-stream.rst:13

msgid ""

"Streams are high-level async/await-ready primitives to work with network "

"connections. Streams allow sending and receiving data without using "

"callbacks or low-level protocols and transports."

msgstr ""

"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."

#: ../Doc/library/asyncio-stream.rst:19

msgid "Here is an example of a TCP echo client written using asyncio streams::"

msgstr ""

"Aquí hay un ejemplo de un cliente eco TCP escrito utilizando *streams* "

"asyncio::"

#: ../Doc/library/asyncio-stream.rst:22 ../Doc/library/asyncio-stream.rst:415

msgid ""

"import asyncio\n"

"\n"

"async def tcp_echo_client(message):\n"

" reader, writer = await asyncio.open_connection(\n"

" '127.0.0.1', 8888)\n"

"\n"

" print(f'Send: {message!r}')\n"

" writer.write(message.encode())\n"

" await writer.drain()\n"

"\n"

" data = await reader.read(100)\n"

" print(f'Received: {data.decode()!r}')\n"

"\n"

" print('Close the connection')\n"

" writer.close()\n"

" await writer.wait_closed()\n"

"\n"

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

msgstr ""

#: ../Doc/library/asyncio-stream.rst:42

msgid "See also the `Examples`_ section below."

msgstr "Consulte también la sección de `Examples`_ a continuación."

#: ../Doc/library/asyncio-stream.rst:46

msgid "Stream Functions"

msgstr "Funciones *stream*"

#: ../Doc/library/asyncio-stream.rst:47

msgid ""

"The following top-level asyncio functions can be used to create and work "

"with streams:"

msgstr ""

"Las siguientes funciones asyncio de nivel superior se pueden utilizar para "

"crear y trabajar con *streams*:"

#: ../Doc/library/asyncio-stream.rst:58

msgid ""

"Establish a network connection and return a pair of ``(reader, writer)`` "

"objects."

msgstr ""

"Establece una conexión de red y retorna un par de objetos ``(reader, "

"writer)``."

#: ../Doc/library/asyncio-stream.rst:61

msgid ""

"The returned *reader* and *writer* objects are instances of :class:"

"`StreamReader` and :class:`StreamWriter` classes."

msgstr ""

"Los objetos *reader* y *writer* retornados son instancias de las clases :"

"class:`StreamReader` y :class:`StreamWriter`."

#: ../Doc/library/asyncio-stream.rst:64 ../Doc/library/asyncio-stream.rst:109

msgid ""

"*limit* determines the buffer size limit used by the returned :class:"

"`StreamReader` instance. By default the *limit* is set to 64 KiB."

msgstr ""

"*limit* determina el límite de tamaño del búfer utilizado por la instancia "

"de :class:`StreamReader` retornada. De forma predeterminada, *limit* está "

"establecido en 64 KiB."

#: ../Doc/library/asyncio-stream.rst:68

msgid ""

"The rest of the arguments are passed directly to :meth:`loop."

"create_connection`."

msgstr ""

"El resto de los argumentos se pasan directamente a :meth:`loop."

"create_connection`."

#: ../Doc/library/asyncio-stream.rst:73 ../Doc/library/asyncio-stream.rst:147

msgid ""

"The *sock* argument transfers ownership of the socket to the :class:"

"`StreamWriter` created. To close the socket, call its :meth:`~asyncio."

"StreamWriter.close` method."

msgstr ""

"El argumento *sock* transfiere la propiedad del socket al :class:"

"`StreamWriter` creado. Para cerrar el socket, llame a su método :meth:"

"`~asyncio.StreamWriter.close`."

#: ../Doc/library/asyncio-stream.rst:77

msgid "Added the *ssl_handshake_timeout* parameter."

msgstr "Se agregó el parámetro *ssl_handshake_timeout*."

#: ../Doc/library/asyncio-stream.rst:80

#, fuzzy

msgid "Added the *happy_eyeballs_delay* and *interleave* parameters."

msgstr "Se agregaron los parámetros *happy_eyeballs_delay* e *interleave*."

#: ../Doc/library/asyncio-stream.rst:83 ../Doc/library/asyncio-stream.rst:125

#: ../Doc/library/asyncio-stream.rst:157 ../Doc/library/asyncio-stream.rst:187

msgid "Removed the *loop* parameter."

msgstr "Se eliminó el parámetro *loop*."

#: ../Doc/library/asyncio-stream.rst:86 ../Doc/library/asyncio-stream.rst:128

#: ../Doc/library/asyncio-stream.rst:160 ../Doc/library/asyncio-stream.rst:190

#: ../Doc/library/asyncio-stream.rst:383

#, fuzzy

msgid "Added the *ssl_shutdown_timeout* parameter."

msgstr "Se agregó el parámetro *ssl_handshake_timeout*."

#: ../Doc/library/asyncio-stream.rst:98

msgid "Start a socket server."

msgstr "Inicia un servidor socket."

#: ../Doc/library/asyncio-stream.rst:100

msgid ""

"The *client_connected_cb* callback is called whenever a new client "

"connection is established. It receives a ``(reader, writer)`` pair as two "

"arguments, instances of the :class:`StreamReader` and :class:`StreamWriter` "

"classes."

msgstr ""

"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 :class:`StreamReader` y :class:"

"`StreamWriter`."

#: ../Doc/library/asyncio-stream.rst:105

msgid ""

"*client_connected_cb* can be a plain callable or a :ref:`coroutine function "

"<coroutine>`; if it is a coroutine function, it will be automatically "

"scheduled as a :class:`Task`."

msgstr ""

"*client_connected_cb* puede ser una función simple invocable o de :ref:"

"`corrutina <coroutine>`; si es una función de corrutina, se programará "

"automáticamente como un :class:`Task`."

#: ../Doc/library/asyncio-stream.rst:113

msgid ""

"The rest of the arguments are passed directly to :meth:`loop.create_server`."

msgstr ""

"El resto de los argumentos se pasan directamente a :meth:`loop."

"create_server`."

#: ../Doc/library/asyncio-stream.rst:118 ../Doc/library/asyncio-stream.rst:177

msgid ""

"The *sock* argument transfers ownership of the socket to the server created. "

"To close the socket, call the server's :meth:`~asyncio.Server.close` method."

msgstr ""

"El argumento *sock* transfiere la propiedad del socket al servidor creado. "

"Para cerrar el socket, llame al método :meth:`~asyncio.Server.close` del "

"servidor."

#: ../Doc/library/asyncio-stream.rst:122

msgid "Added the *ssl_handshake_timeout* and *start_serving* parameters."

msgstr "Se agregaron los parámetros *ssl_handshake_timeout* y *start_serving*."

#: ../Doc/library/asyncio-stream.rst:133

msgid "Unix Sockets"

msgstr "Sockets Unix"

#: ../Doc/library/asyncio-stream.rst:138

msgid ""

"Establish a Unix socket connection and return a pair of ``(reader, writer)``."

msgstr ""

"Establece una conexión de socket Unix y retorna un par de ``(reader, "

"writer)``."

#: ../Doc/library/asyncio-stream.rst:141

msgid "Similar to :func:`open_connection` but operates on Unix sockets."

msgstr "Similar a :func:`open_connection` pero opera en sockets Unix."

#: ../Doc/library/asyncio-stream.rst:143

msgid "See also the documentation of :meth:`loop.create_unix_connection`."

msgstr ""

"Consulte también la documentación de :meth:`loop.create_unix_connection`."

#: ../Doc/library/asyncio-stream.rst:151 ../Doc/library/asyncio-stream.rst:181

msgid ":ref:`Availability <availability>`: Unix."

msgstr ":ref:`Disponibilidad <availability>`: Unix."

#: ../Doc/library/asyncio-stream.rst:153

msgid ""

"Added the *ssl_handshake_timeout* parameter. The *path* parameter can now be "

"a :term:`path-like object`"

msgstr ""

"Se agregó el parámetro *ssl_handshake_timeout*. El parámetro *path* ahora "

"puede ser un :term:`path-like object`"

#: ../Doc/library/asyncio-stream.rst:169

msgid "Start a Unix socket server."

msgstr "Inicia un servidor socket Unix."

#: ../Doc/library/asyncio-stream.rst:171

msgid "Similar to :func:`start_server` but works with Unix sockets."

msgstr "Similar a :func:`start_server` pero funciona con sockets Unix."

#: ../Doc/library/asyncio-stream.rst:173

msgid "See also the documentation of :meth:`loop.create_unix_server`."

msgstr "Consulte también la documentación de :meth:`loop.create_unix_server`."

#: ../Doc/library/asyncio-stream.rst:183

msgid ""

"Added the *ssl_handshake_timeout* and *start_serving* parameters. The *path* "

"parameter can now be a :term:`path-like object`."

msgstr ""

"Se agregaron los parámetros *ssl_handshake_timeout* y *start_serving*. El "

"parámetro *path* ahora puede ser un :term:`path-like object`."

#: ../Doc/library/asyncio-stream.rst:195

msgid "StreamReader"

msgstr "StreamReader"

#: ../Doc/library/asyncio-stream.rst:199

#, fuzzy

msgid ""

"Represents a reader object that provides APIs to read data from the IO "

"stream. As an :term:`asynchronous iterable`, the object supports the :"

"keyword:`async for` statement."

msgstr ""

"Representa un objeto lector que proporciona APIs para leer datos del flujo "

"de E/S."

#: ../Doc/library/asyncio-stream.rst:203

msgid ""

"It is not recommended to instantiate *StreamReader* objects directly; use :"

"func:`open_connection` and :func:`start_server` instead."

msgstr ""

"No se recomienda crear instancias de objetos *StreamReader* directamente; "

"utilice :func:`open_connection` y :func:`start_server` en su lugar."

#: ../Doc/library/asyncio-stream.rst:209

msgid "Acknowledge the EOF."

msgstr ""

#: ../Doc/library/asyncio-stream.rst:213

msgid "Read up to *n* bytes from the stream."

msgstr ""

#: ../Doc/library/asyncio-stream.rst:215

#, fuzzy

msgid ""

"If *n* is not provided or set to ``-1``, read until EOF, then return all "

"read :class:`bytes`. If EOF was received and the internal buffer is empty, "

"return an empty ``bytes`` object."

msgstr ""

"Si se recibió EOF (final del archivo) y el búfer interno está vacío, retorna "

"un objeto ``bytes`` vacío."

#: ../Doc/library/asyncio-stream.rst:220

msgid "If *n* is ``0``, return an empty ``bytes`` object immediately."

msgstr ""

#: ../Doc/library/asyncio-stream.rst:222

msgid ""

"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."

msgstr ""

#: ../Doc/library/asyncio-stream.rst:229

msgid ""

"Read one line, where \"line\" is a sequence of bytes ending with ``\\n``."

msgstr ""

"Lea una línea, donde \"línea\" es una secuencia de bytes que termina en "

"``\\n``."

#: ../Doc/library/asyncio-stream.rst:232

msgid ""

"If EOF is received and ``\\n`` was not found, the method returns partially "

"read data."

msgstr ""

"Si se recibe EOF (final del archivo) y no se encontró ``\\n``, el método "

"retorna datos leídos parcialmente."

#: ../Doc/library/asyncio-stream.rst:235

msgid ""

"If EOF is received and the internal buffer is empty, return an empty "

"``bytes`` object."

msgstr ""

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

"un objeto ``bytes`` vacío."

#: ../Doc/library/asyncio-stream.rst:240

msgid "Read exactly *n* bytes."

msgstr "Lee exactamente *n* bytes."

#: ../Doc/library/asyncio-stream.rst:242

msgid ""

"Raise an :exc:`IncompleteReadError` if EOF is reached before *n* can be "

"read. Use the :attr:`IncompleteReadError.partial` attribute to get the "

"partially read data."

msgstr ""

"Genera un :exc:`IncompleteReadError` si se alcanza EOF (final del archivo) "

"antes de que se pueda leer *n*. Utilice el atributo :attr:"

"`IncompleteReadError.partial` para obtener los datos leídos parcialmente."

#: ../Doc/library/asyncio-stream.rst:248

msgid "Read data from the stream until *separator* is found."

msgstr ""

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

#: ../Doc/library/asyncio-stream.rst:250

msgid ""

"On success, the data and separator will be removed from the internal buffer "

"(consumed). Returned data will include the separator at the end."

msgstr ""

"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."

#: ../Doc/library/asyncio-stream.rst:254

msgid ""

"If the amount of data read exceeds the configured stream limit, a :exc:"

"`LimitOverrunError` exception is raised, and the data is left in the "

"internal buffer and can be read again."

msgstr ""

"Si la cantidad de datos leídos excede el límite de flujo configurado, se "

"genera una excepción :exc:`LimitOverrunError` y los datos se dejan en el "

"búfer interno y se pueden leer nuevamente."

#: ../Doc/library/asyncio-stream.rst:258

msgid ""

"If EOF is reached before the complete separator is found, an :exc:"

"`IncompleteReadError` exception is raised, and the internal buffer is "

"reset. The :attr:`IncompleteReadError.partial` attribute may contain a "

"portion of the separator."

msgstr ""

"Si se alcanza EOF (final del archivo) antes de que se encuentre el separador "

"completo, se genera una excepción :exc:`IncompleteReadError` y se restablece "

"el búfer interno. El atributo :attr:`IncompleteReadError.partial` puede "

"contener una parte del separador."

#: ../Doc/library/asyncio-stream.rst:263

msgid ""

"The *separator* may also be a tuple of separators. In this case the return "

"value will be the shortest possible that has any separator as the suffix. "

"For the purposes of :exc:`LimitOverrunError`, the shortest possible "

"separator is considered to be the one that matched."

msgstr ""

#: ../Doc/library/asyncio-stream.rst:273

msgid "The *separator* parameter may now be a :class:`tuple` of separators."

msgstr ""

#: ../Doc/library/asyncio-stream.rst:278

msgid "Return ``True`` if the buffer is empty and :meth:`feed_eof` was called."

msgstr ""

"Retorna ``True`` si el buffer está vacío y :meth:`feed_eof` fue llamado."

#: ../Doc/library/asyncio-stream.rst:283

msgid "StreamWriter"

msgstr "StreamWriter"

#: ../Doc/library/asyncio-stream.rst:287

msgid ""

"Represents a writer object that provides APIs to write data to the IO stream."

msgstr ""

"Representa un objeto de escritura que proporciona APIs para escribir datos "

"en el flujo de E/S."

#: ../Doc/library/asyncio-stream.rst:290

msgid ""

"It is not recommended to instantiate *StreamWriter* objects directly; use :"

"func:`open_connection` and :func:`start_server` instead."

msgstr ""

"No se recomienda crear instancias de objetos *StreamWriter* directamente; "

"use :func:`open_connection` y :func:`start_server` en su lugar."

#: ../Doc/library/asyncio-stream.rst:296

msgid ""

"The method attempts to write the *data* to the underlying socket "

"immediately. If that fails, the data is queued in an internal write buffer "

"until it can be sent."

msgstr ""

"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."

#: ../Doc/library/asyncio-stream.rst:300 ../Doc/library/asyncio-stream.rst:312

msgid "The method should be used along with the ``drain()`` method::"

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

#: ../Doc/library/asyncio-stream.rst:302

msgid ""

"stream.write(data)\n"

"await stream.drain()"

msgstr ""

#: ../Doc/library/asyncio-stream.rst:307

msgid ""

"The method writes a list (or any iterable) of bytes to the underlying socket "

"immediately. If that fails, the data is queued in an internal write buffer "

"until it can be sent."

msgstr ""

"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."

#: ../Doc/library/asyncio-stream.rst:314

msgid ""

"stream.writelines(lines)\n"

"await stream.drain()"

msgstr ""

#: ../Doc/library/asyncio-stream.rst:319

msgid "The method closes the stream and the underlying socket."

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

#: ../Doc/library/asyncio-stream.rst:321

#, fuzzy

msgid ""

"The method should be used, though not mandatory, along with the "

"``wait_closed()`` method::"

msgstr "El método debe usarse junto con el método ``wait_closed()``::"

#: ../Doc/library/asyncio-stream.rst:324

msgid ""

"stream.close()\n"

"await stream.wait_closed()"

msgstr ""

#: ../Doc/library/asyncio-stream.rst:329

msgid ""

"Return ``True`` if the underlying transport supports the :meth:`write_eof` "

"method, ``False`` otherwise."

msgstr ""

"Retorna ``True`` si el transporte subyacente admite el método :meth:"

"`write_eof`, ``False`` en caso contrario."

#: ../Doc/library/asyncio-stream.rst:334

msgid ""

"Close the write end of the stream after the buffered write data is flushed."

msgstr ""

"Cierra la escritura de la secuencia después de que se vacíen los datos de "

"escritura almacenados en búfer."

#: ../Doc/library/asyncio-stream.rst:339

msgid "Return the underlying asyncio transport."

msgstr "Retorna el transporte asyncio subyacente."

#: ../Doc/library/asyncio-stream.rst:343

msgid ""

"Access optional transport information; see :meth:`BaseTransport."

"get_extra_info` for details."

msgstr ""

"Accede a información de transporte opcional; consulte :meth:`BaseTransport."

"get_extra_info` para obtener más detalles."

#: ../Doc/library/asyncio-stream.rst:348

msgid "Wait until it is appropriate to resume writing to the stream. Example::"

msgstr ""

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

"Ejemplo::"

#: ../Doc/library/asyncio-stream.rst:351

msgid ""

"writer.write(data)\n"

"await writer.drain()"

msgstr ""

#: ../Doc/library/asyncio-stream.rst:354

msgid ""

"This is a flow control method that interacts with the underlying IO write "

"buffer. When the size of the buffer reaches the high watermark, *drain()* "

"blocks until the size of the buffer is drained down to the low watermark and "

"writing can be resumed. When there is nothing to wait for, the :meth:"

"`drain` returns immediately."

msgstr ""

"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, :meth:`drain` regresa inmediatamente."

#: ../Doc/library/asyncio-stream.rst:364

msgid "Upgrade an existing stream-based connection to TLS."

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

#: ../Doc/library/asyncio-stream.rst:366

msgid "Parameters:"

msgstr "Parámetros:"

#: ../Doc/library/asyncio-stream.rst:368

msgid "*sslcontext*: a configured instance of :class:`~ssl.SSLContext`."

msgstr "*sslcontext*: una instancia configurada de :class:`~ssl.SSLContext`."

#: ../Doc/library/asyncio-stream.rst:370

msgid ""

"*server_hostname*: sets or overrides the host name that the target server's "

"certificate will be matched against."

msgstr ""

"*server_hostname*: establece o sustituye el nombre de host con el que se "

"comparará el certificado del servidor de destino."

#: ../Doc/library/asyncio-stream.rst:373

msgid ""

"*ssl_handshake_timeout* is the time in seconds to wait for the TLS handshake "

"to complete before aborting the connection. ``60.0`` seconds if ``None`` "

"(default)."

msgstr ""

"*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)."

#: ../Doc/library/asyncio-stream.rst:377

#, fuzzy

msgid ""

"*ssl_shutdown_timeout* is the time in seconds to wait for the SSL shutdown "

"to complete before aborting the connection. ``30.0`` seconds if ``None`` "

"(default)."

msgstr ""

"*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)."

#: ../Doc/library/asyncio-stream.rst:389

msgid ""

"Return ``True`` if the stream is closed or in the process of being closed."

msgstr ""

"Retorna ``True`` si la secuencia está cerrada o en proceso de cerrarse."

#: ../Doc/library/asyncio-stream.rst:396

msgid "Wait until the stream is closed."

msgstr "Espera hasta que se cierre la secuencia."

#: ../Doc/library/asyncio-stream.rst:398

#, fuzzy

msgid ""

"Should be called after :meth:`close` to wait until the underlying connection "

"is closed, ensuring that all data has been flushed before e.g. exiting the "

"program."

msgstr ""

"Debería llamarse después de :meth:`close` para esperar hasta que se cierre "

"la conexión subyacente."

#: ../Doc/library/asyncio-stream.rst:406

msgid "Examples"

msgstr "Ejemplos"

#: ../Doc/library/asyncio-stream.rst:411

msgid "TCP echo client using streams"

msgstr "Cliente eco TCP usando *streams*"

#: ../Doc/library/asyncio-stream.rst:413

msgid "TCP echo client using the :func:`asyncio.open_connection` function::"

msgstr "Cliente eco TCP usando la función :func:`asyncio.open_connection`::"

#: ../Doc/library/asyncio-stream.rst:437

msgid ""

"The :ref:`TCP echo client protocol "

"<asyncio_example_tcp_echo_client_protocol>` example uses the low-level :meth:"

"`loop.create_connection` method."

msgstr ""

"El ejemplo del :ref:`protocolo de cliente eco TCP "

"<asyncio_example_tcp_echo_client_protocol>` utiliza el método :meth:`loop."

"create_connection` de bajo nivel."

#: ../Doc/library/asyncio-stream.rst:444

msgid "TCP echo server using streams"

msgstr "Servidor eco TCP usando *streams*"

#: ../Doc/library/asyncio-stream.rst:446

msgid "TCP echo server using the :func:`asyncio.start_server` function::"

msgstr "Servidor eco TCP usando la función :func:`asyncio.start_server`::"

#: ../Doc/library/asyncio-stream.rst:448

msgid ""

"import asyncio\n"

"\n"

"async def handle_echo(reader, writer):\n"

" data = await reader.read(100)\n"

" message = data.decode()\n"

" addr = writer.get_extra_info('peername')\n"

"\n"

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

"\n"

" print(f\"Send: {message!r}\")\n"

" writer.write(data)\n"

" await writer.drain()\n"

"\n"

" print(\"Close the connection\")\n"

" writer.close()\n"

" await writer.wait_closed()\n"

"\n"

"async def main():\n"

" server = await asyncio.start_server(\n"

" handle_echo, '127.0.0.1', 8888)\n"

"\n"

" addrs = ', '.join(str(sock.getsockname()) for sock in server.sockets)\n"

" print(f'Serving on {addrs}')\n"

"\n"

" async with server:\n"

" await server.serve_forever()\n"

"\n"

"asyncio.run(main())"

msgstr ""

#: ../Doc/library/asyncio-stream.rst:480

msgid ""

"The :ref:`TCP echo server protocol "

"<asyncio_example_tcp_echo_server_protocol>` example uses the :meth:`loop."

"create_server` method."

msgstr ""

"El ejemplo del :ref:`protocolo de servidor eco TCP "

"<asyncio_example_tcp_echo_server_protocol>` utiliza el método :meth:`loop."

"create_server`."

#: ../Doc/library/asyncio-stream.rst:485

msgid "Get HTTP headers"

msgstr "Obtener encabezados HTTP"

#: ../Doc/library/asyncio-stream.rst:487

msgid ""

"Simple example querying HTTP headers of the URL passed on the command line::"

msgstr ""

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

"de comando::"

#: ../Doc/library/asyncio-stream.rst:489

msgid ""

"import asyncio\n"

"import urllib.parse\n"

"import sys\n"

"\n"

"async def print_http_headers(url):\n"

" url = urllib.parse.urlsplit(url)\n"

" if url.scheme == 'https':\n"

" reader, writer = await asyncio.open_connection(\n"

" url.hostname, 443, ssl=True)\n"

" else:\n"

" reader, writer = await asyncio.open_connection(\n"

" url.hostname, 80)\n"

"\n"

" query = (\n"

" f\"HEAD {url.path or '/'} HTTP/1.0\\r\\n\"\n"

" f\"Host: {url.hostname}\\r\\n\"\n"

" f\"\\r\\n\"\n"

" )\n"

"\n"

" writer.write(query.encode('latin-1'))\n"

" while True:\n"

" line = await reader.readline()\n"

" if not line:\n"

" break\n"

"\n"

" line = line.decode('latin1').rstrip()\n"

" if line:\n"

" print(f'HTTP header> {line}')\n"

"\n"

" # Ignore the body, close the socket\n"

" writer.close()\n"

" await writer.wait_closed()\n"

"\n"

"url = sys.argv[1]\n"

"asyncio.run(print_http_headers(url))"

msgstr ""

#: ../Doc/library/asyncio-stream.rst:526

msgid "Usage::"

msgstr "Uso::"

#: ../Doc/library/asyncio-stream.rst:528

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

msgstr ""

#: ../Doc/library/asyncio-stream.rst:530

msgid "or with HTTPS::"

msgstr "o con HTTPS::"

#: ../Doc/library/asyncio-stream.rst:532

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

msgstr ""

#: ../Doc/library/asyncio-stream.rst:538

msgid "Register an open socket to wait for data using streams"

msgstr "Registrar un socket abierto para esperar datos usando *streams*"

#: ../Doc/library/asyncio-stream.rst:540

msgid ""

"Coroutine waiting until a socket receives data using the :func:"

"`open_connection` function::"

msgstr ""

"Corutina esperando hasta que un socket reciba datos usando la función :func:"

"`open_connection` function::"

#: ../Doc/library/asyncio-stream.rst:543

msgid ""

"import asyncio\n"

"import socket\n"

"\n"

"async def wait_for_data():\n"

" # Get a reference to the current event loop because\n"

" # we want to access low-level APIs.\n"

" loop = asyncio.get_running_loop()\n"

"\n"

" # Create a pair of connected sockets.\n"

" rsock, wsock = socket.socketpair()\n"

"\n"

" # Register the open socket to wait for data.\n"

" reader, writer = await asyncio.open_connection(sock=rsock)\n"

"\n"

" # Simulate the reception of data from the network\n"

" loop.call_soon(wsock.send, 'abc'.encode())\n"

"\n"

" # Wait for data\n"

" data = await reader.read(100)\n"

"\n"

" # Got data, we are done: close the socket\n"

" print(\"Received:\", data.decode())\n"

" writer.close()\n"

" await writer.wait_closed()\n"

"\n"

" # Close the second socket\n"

" wsock.close()\n"

"\n"

"asyncio.run(wait_for_data())"

msgstr ""

#: ../Doc/library/asyncio-stream.rst:575

msgid ""

"The :ref:`register an open socket to wait for data using a protocol "

"<asyncio_example_create_connection>` example uses a low-level protocol and "

"the :meth:`loop.create_connection` method."

msgstr ""

"El ejemplo de :ref:`registro de un socket abierto para esperar datos usando "

"un protocolo <asyncio_example_create_connection>` utiliza un protocolo de "

"bajo nivel y el método :meth:`loop.create_connection`."

#: ../Doc/library/asyncio-stream.rst:579

msgid ""

"The :ref:`watch a file descriptor for read events "

"<asyncio_example_watch_fd>` example uses the low-level :meth:`loop."

"add_reader` method to watch a file descriptor."

msgstr ""

"El ejemplo de :ref:`observar un descriptor de archivo para leer eventos "

"<asyncio_example_watch_fd>` utiliza el método :meth:`loop.add_reader` de "

"bajo nivel para ver un descriptor de archivo."