# SOME DESCRIPTIVE TITLE.

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

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

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2025-11-27 09:00+0200\n"

"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"

"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"

"Language-Team: LANGUAGE <LL@li.org>\n"

"Language: \n"

"MIME-Version: 1.0\n"

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

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

#: library/asyncio-stream.rst:7

msgid "Streams"

msgstr ""

#: library/asyncio-stream.rst:9

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

msgstr ""

#: 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 ""

#: library/asyncio-stream.rst:19

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

msgstr ""

#: library/asyncio-stream.rst:441

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

#: library/asyncio-stream.rst:42

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

msgstr ""

#: library/asyncio-stream.rst:46

msgid "Stream Functions"

msgstr ""

#: library/asyncio-stream.rst:47

msgid ""

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

"with streams:"

msgstr ""

#: library/asyncio-stream.rst:59

msgid ""

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

"objects."

msgstr ""

#: library/asyncio-stream.rst:62

msgid ""

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

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

msgstr ""

#: library/asyncio-stream.rst:112

msgid ""

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

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

msgstr ""

#: library/asyncio-stream.rst:69

msgid ""

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

"create_connection`."

msgstr ""

#: library/asyncio-stream.rst:154

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

#: library/asyncio-stream.rst:78

msgid "Added the *ssl_handshake_timeout* parameter."

msgstr ""

#: library/asyncio-stream.rst:81

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

msgstr ""

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

msgid "Removed the *loop* parameter."

msgstr ""

#: library/asyncio-stream.rst:131 library/asyncio-stream.rst:202

#: library/asyncio-stream.rst:408

msgid "Added the *ssl_shutdown_timeout* parameter."

msgstr ""

#: library/asyncio-stream.rst:101

msgid "Start a socket server."

msgstr ""

#: library/asyncio-stream.rst:103

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

#: library/asyncio-stream.rst:108

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

#: library/asyncio-stream.rst:116

msgid ""

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

msgstr ""

#: library/asyncio-stream.rst:189

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

#: library/asyncio-stream.rst:125

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

msgstr ""

#: library/asyncio-stream.rst:134

msgid "Added the *keep_alive* parameter."

msgstr ""

#: library/asyncio-stream.rst:139

msgid "Unix Sockets"

msgstr ""

#: library/asyncio-stream.rst:145

msgid ""

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

msgstr ""

#: library/asyncio-stream.rst:148

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

msgstr ""

#: library/asyncio-stream.rst:150

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

msgstr ""

#: library/asyncio-stream.rst:193

msgid "Availability"

msgstr ""

#: library/asyncio-stream.rst:160

msgid ""

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

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

msgstr ""

#: library/asyncio-stream.rst:177

msgid "Start a Unix socket server."

msgstr ""

#: library/asyncio-stream.rst:179

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

msgstr ""

#: library/asyncio-stream.rst:181

msgid ""

"If *cleanup_socket* is true then the Unix socket will automatically be "

"removed from the filesystem when the server is closed, unless the socket has "

"been replaced after the server has been created."

msgstr ""

#: library/asyncio-stream.rst:185

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

msgstr ""

#: library/asyncio-stream.rst:195

msgid ""

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

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

msgstr ""

#: library/asyncio-stream.rst:205

msgid "Added the *cleanup_socket* parameter."

msgstr ""

#: library/asyncio-stream.rst:210

msgid "StreamReader"

msgstr ""

#: library/asyncio-stream.rst:214

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

#: library/asyncio-stream.rst:218

msgid ""

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

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

msgstr ""

#: library/asyncio-stream.rst:224

msgid "Acknowledge the EOF."

msgstr ""

#: library/asyncio-stream.rst:229

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

msgstr ""

#: library/asyncio-stream.rst:231

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

#: library/asyncio-stream.rst:236

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

msgstr ""

#: library/asyncio-stream.rst:238

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

#: library/asyncio-stream.rst:246

msgid ""

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

msgstr ""

#: library/asyncio-stream.rst:249

msgid ""

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

"read data."

msgstr ""

#: library/asyncio-stream.rst:252

msgid ""

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

"``bytes`` object."

msgstr ""

#: library/asyncio-stream.rst:258

msgid "Read exactly *n* bytes."

msgstr ""

#: library/asyncio-stream.rst:260

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

#: library/asyncio-stream.rst:267

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

msgstr ""

#: library/asyncio-stream.rst:269

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

#: library/asyncio-stream.rst:273

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

#: library/asyncio-stream.rst:277

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

#: library/asyncio-stream.rst:282

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

#: library/asyncio-stream.rst:292

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

msgstr ""

#: library/asyncio-stream.rst:297

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

msgstr ""

#: library/asyncio-stream.rst:302

msgid "StreamWriter"

msgstr ""

#: library/asyncio-stream.rst:306

msgid ""

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

msgstr ""

#: library/asyncio-stream.rst:309

msgid ""

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

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

msgstr ""

#: library/asyncio-stream.rst:315

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

#: library/asyncio-stream.rst:319

msgid ""

"The *data* buffer should be a bytes, bytearray, or C-contiguous one-"

"dimensional memoryview object."

msgstr ""

#: library/asyncio-stream.rst:335

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

msgstr ""

#: library/asyncio-stream.rst:324

msgid ""

"stream.write(data)\n"

"await stream.drain()"

msgstr ""

#: library/asyncio-stream.rst:330

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

#: library/asyncio-stream.rst:337

msgid ""

"stream.writelines(lines)\n"

"await stream.drain()"

msgstr ""

#: library/asyncio-stream.rst:342

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

msgstr ""

#: library/asyncio-stream.rst:344

msgid ""

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

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

msgstr ""

#: library/asyncio-stream.rst:347

msgid ""

"stream.close()\n"

"await stream.wait_closed()"

msgstr ""

#: library/asyncio-stream.rst:352

msgid ""

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

"method, ``False`` otherwise."

msgstr ""

#: library/asyncio-stream.rst:357

msgid ""

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

msgstr ""

#: library/asyncio-stream.rst:362

msgid "Return the underlying asyncio transport."

msgstr ""

#: library/asyncio-stream.rst:366

msgid ""

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

"get_extra_info` for details."

msgstr ""

#: library/asyncio-stream.rst:372

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

msgstr ""

#: library/asyncio-stream.rst:375

msgid ""

"writer.write(data)\n"

"await writer.drain()"

msgstr ""

#: library/asyncio-stream.rst:378

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

#: library/asyncio-stream.rst:389

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

msgstr ""

#: library/asyncio-stream.rst:391

msgid "Parameters:"

msgstr ""

#: library/asyncio-stream.rst:393

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

msgstr ""

#: library/asyncio-stream.rst:395

msgid ""

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

"certificate will be matched against."

msgstr ""

#: library/asyncio-stream.rst:398

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

#: library/asyncio-stream.rst:402

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

#: library/asyncio-stream.rst:414

msgid ""

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

msgstr ""

#: library/asyncio-stream.rst:422

msgid "Wait until the stream is closed."

msgstr ""

#: library/asyncio-stream.rst:424

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

#: library/asyncio-stream.rst:432

msgid "Examples"

msgstr ""

#: library/asyncio-stream.rst:437

msgid "TCP echo client using streams"

msgstr ""

#: library/asyncio-stream.rst:439

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

msgstr ""

#: library/asyncio-stream.rst:463

msgid ""

"The :ref:`TCP echo client protocol "

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

"`loop.create_connection` method."

msgstr ""

#: library/asyncio-stream.rst:470

msgid "TCP echo server using streams"

msgstr ""

#: library/asyncio-stream.rst:472

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

msgstr ""

#: library/asyncio-stream.rst:474

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

#: library/asyncio-stream.rst:506

msgid ""

"The :ref:`TCP echo server protocol "

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

"create_server` method."

msgstr ""

#: library/asyncio-stream.rst:511

msgid "Get HTTP headers"

msgstr ""

#: library/asyncio-stream.rst:513

msgid ""

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

msgstr ""

#: library/asyncio-stream.rst:515

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

#: library/asyncio-stream.rst:552

msgid "Usage::"

msgstr ""

#: library/asyncio-stream.rst:554

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

msgstr ""

#: library/asyncio-stream.rst:556

msgid "or with HTTPS::"

msgstr ""

#: library/asyncio-stream.rst:558

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

msgstr ""

#: library/asyncio-stream.rst:564

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

msgstr ""

#: library/asyncio-stream.rst:566

msgid ""

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

"`open_connection` function::"

msgstr ""

#: library/asyncio-stream.rst:569

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

#: library/asyncio-stream.rst:601

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

#: library/asyncio-stream.rst:605

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