asyncio-stream.po

# 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.
#
# Translators:
# Rafael Fontenelle <rffontenelle@gmail.com>, 2024
# Freesand Leo <yuqinju@163.com>, 2024
#
#,fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.12\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-10-11 14:48+0000\n"
"PO-Revision-Date: 2024-05-11 00:33+0000\n"
"Last-Translator: Freesand Leo <yuqinju@163.com>, 2024\n"
"Language-Team: Chinese (China) (https://app.transifex.com/python-doc/teams/5390/zh_CN/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: zh_CN\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#:../../library/asyncio-stream.rst:7
msgid"Streams"
msgstr"流"

#:../../library/asyncio-stream.rst:9
msgid"**Source code:** :source:`Lib/asyncio/streams.py`"
msgstr"**源码:** :source:`Lib/asyncio/streams.py`"

#:../../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"流是用于处理网络连接的支持 async/await 的高层级原语。 流允许发送和接收数据，而不需要使用回调或低级协议和传输。"

#:../../library/asyncio-stream.rst:19
msgid""
"Here is an example of a TCP echo client written using asyncio streams::"
msgstr"下面是一个使用 asyncio streams 编写的 TCP echo 客户端示例::"

#:../../library/asyncio-stream.rst:22../../library/asyncio-stream.rst:404
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""
"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!'))"

#:../../library/asyncio-stream.rst:42
msgid"See also the `Examples`_ section below."
msgstr"参见下面的 `Examples`_ 部分。"

#:../../library/asyncio-stream.rst:46
msgid"Stream Functions"
msgstr"Stream 函数"

#:../../library/asyncio-stream.rst:47
msgid""
"The following top-level asyncio functions can be used to create and work "
"with streams:"
msgstr"下面的高级 asyncio 函数可以用来创建和处理流:"

#:../../library/asyncio-stream.rst:58
msgid""
"Establish a network connection and return a pair of ``(reader, writer)`` "
"objects."
msgstr"建立网络连接并返回一对 ``(reader, writer)`` 对象。"

#:../../library/asyncio-stream.rst:61
msgid""
"The returned *reader* and *writer* objects are instances of "
":class:`StreamReader` and :class:`StreamWriter` classes."
msgstr""
"返回的 *reader* 和 *writer* 对象是 :class:`StreamReader` 和 :class:`StreamWriter` "
"类的实例。"

#:../../library/asyncio-stream.rst:64../../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* 确定返回的 :class:`StreamReader` 实例使用的缓冲区大小限制。默认情况下，*limit* 设置为 64 KiB 。"

#:../../library/asyncio-stream.rst:68
msgid""
"The rest of the arguments are passed directly to "
":meth:`loop.create_connection`."
msgstr"其余的参数直接传递到 :meth:`loop.create_connection` 。"

#:../../library/asyncio-stream.rst:73../../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""
"*sock* 参数可将套接字的所有权转给所创建的 :class:`StreamWriter`。 要关闭该套接字，请调用其 "
":meth:`~asyncio.StreamWriter.close` 方法。"

#:../../library/asyncio-stream.rst:77
msgid"Added the *ssl_handshake_timeout* parameter."
msgstr"添加了 *ssl_handshake_timeout* 形参。"

#:../../library/asyncio-stream.rst:80
msgid"Added the *happy_eyeballs_delay* and *interleave* parameters."
msgstr"增加了 *happy_eyeballs_delay* 和 *interleave* 形参。"

#:../../library/asyncio-stream.rst:83../../library/asyncio-stream.rst:125
#:../../library/asyncio-stream.rst:157../../library/asyncio-stream.rst:187
msgid"Removed the *loop* parameter."
msgstr"移除了 *loop* 形参。"

#:../../library/asyncio-stream.rst:86../../library/asyncio-stream.rst:128
#:../../library/asyncio-stream.rst:160../../library/asyncio-stream.rst:190
#:../../library/asyncio-stream.rst:372
msgid"Added the *ssl_shutdown_timeout* parameter."
msgstr"添加了 *ssl_shutdown_timeout* 形参。"

#:../../library/asyncio-stream.rst:98
msgid"Start a socket server."
msgstr"启动套接字服务。"

#:../../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""
"当一个新的客户端连接被建立时，回调函数 *client_connected_cb* 会被调用。该函数会接收到一对参数 ``(reader, "
"writer)`` ，reader是类 :class:`StreamReader` 的实例，而writer是类 "
":class:`StreamWriter` 的实例。"

#:../../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* 即可以是普通的可调用对象也可以是一个 :ref:`协程函数 <coroutine>`; "
"如果它是一个协程函数，它将自动作为 :class:`Task` 被调度。"

#:../../library/asyncio-stream.rst:113
msgid""
"The rest of the arguments are passed directly to :meth:`loop.create_server`."
msgstr"余下的参数将会直接传递给 :meth:`loop.create_server`."

#:../../library/asyncio-stream.rst:118../../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""
"*sock* 参数可将套接字的所有权转给所创建的服务器。 要关闭该套接字，请调用服务器的 :meth:`~asyncio.Server.close` "
"方法。"

#:../../library/asyncio-stream.rst:122
msgid"Added the *ssl_handshake_timeout* and *start_serving* parameters."
msgstr"增加了 *ssl_handshake_timeout* 和 *start_serving* 形参。"

#:../../library/asyncio-stream.rst:133
msgid"Unix Sockets"
msgstr"Unix 套接字"

#:../../library/asyncio-stream.rst:138
msgid""
"Establish a Unix socket connection and return a pair of ``(reader, "
"writer)``."
msgstr"建立一个 Unix 套接字连接并返回 ``(reader, writer)`` 这对返回值。"

#:../../library/asyncio-stream.rst:141
msgid"Similar to :func:`open_connection` but operates on Unix sockets."
msgstr"与 :func:`open_connection` 相似，但是是在 Unix 套接字上的操作。"

#:../../library/asyncio-stream.rst:143
msgid"See also the documentation of :meth:`loop.create_unix_connection`."
msgstr"请看文档 :meth:`loop.create_unix_connection`."

#:../../library/asyncio-stream.rst:151../../library/asyncio-stream.rst:181
msgid"Availability"
msgstr"Availability"

#:../../library/asyncio-stream.rst:153
msgid""
"Added the *ssl_handshake_timeout* parameter. The *path* parameter can now be"
" a :term:`path-like object`"
msgstr""
"增加了 *ssl_handshake_timeout* 形参。 现在 *path* 形参可以是一个 :term:`path-like object`"

#:../../library/asyncio-stream.rst:169
msgid"Start a Unix socket server."
msgstr"启动一个 Unix 套接字服务。"

#:../../library/asyncio-stream.rst:171
msgid"Similar to :func:`start_server` but works with Unix sockets."
msgstr"与 :func:`start_server` 相似，但是是在 Unix 套接字上的操作。"

#:../../library/asyncio-stream.rst:173
msgid"See also the documentation of :meth:`loop.create_unix_server`."
msgstr"请看文档 :meth:`loop.create_unix_server`."

#:../../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""
"增加了 *ssl_handshake_timeout* 和 *start_serving* 形参。 现在 *path* 形参可以是一个 "
":term:`path-like object`。"

#:../../library/asyncio-stream.rst:195
msgid"StreamReader"
msgstr"StreamReader"

#:../../library/asyncio-stream.rst:199
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""
"代表一个提供从 IO 流读取数据的 API 的读取器。 作为一个 :term:`asynchronous iterable`，该对象支持 "
":keyword:`async for` 语句。"

#:../../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""
"不推荐直接实例化 *StreamReader* 对象，建议使用 :func:`open_connection` 和 "
":func:`start_server` 来获取 *StreamReader* 实例。"

#:../../library/asyncio-stream.rst:209
msgid"Acknowledge the EOF."
msgstr"识别 EOF。"

#:../../library/asyncio-stream.rst:213
msgid"Read up to *n* bytes from the stream."
msgstr"从流读取至多 *n* 个字节。"

#:../../library/asyncio-stream.rst:215
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""
"如果未提供 *n* 或是设为 ``-1``，则一直读取到 EOF，然后返回所读取的全部 :class:`bytes`。 如果收到 EOF "
"并且内部缓冲区为空，则返回一个空 ``bytes`` 对象。object."

#:../../library/asyncio-stream.rst:220
msgid"If *n* is ``0``, return an empty ``bytes`` object immediately."
msgstr"如果 *n* 为 ``0``，则立即返回一个空 ``bytes`` 对象。"

#:../../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""
"如果 *n* 为正值，则一旦内部缓冲区有至少 1 个字节可用就返回至多 *n* 个可用的 ``bytes``。 如果在读取任何字节之前收到 "
"EOF，则返回一个空 ``bytes`` 对象。"

#:../../library/asyncio-stream.rst:229
msgid"Read one line, where \"line\" is a sequence of bytes ending with ``\\n``."
msgstr"读取一行，其中“行”指的是以 ``\\n`` 结尾的字节序列。"

#:../../library/asyncio-stream.rst:232
msgid""
"If EOF is received and ``\\n`` was not found, the method returns partially "
"read data."
msgstr"如果读到EOF而没有找到 ``\\n`` ，该方法返回部分读取的数据。"

#:../../library/asyncio-stream.rst:235
msgid""
"If EOF is received and the internal buffer is empty, return an empty "
"``bytes`` object."
msgstr"如果读到EOF，且内部缓冲区为空，则返回一个空的 ``bytes`` 对象。"

#:../../library/asyncio-stream.rst:240
msgid"Read exactly *n* bytes."
msgstr"精确读取 *n* 个 bytes，不会超过也不能少于。"

#:../../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""
"如果在读取完 *n* 个byte之前读取到EOF，则会引发 :exc:`IncompleteReadError` 异常。使用 "
":attr:`IncompleteReadError.partial` 属性来获取到达流结束之前读取的 bytes 字符串。"

#:../../library/asyncio-stream.rst:248
msgid"Read data from the stream until *separator* is found."
msgstr"从流中读取数据直至遇到 *separator*"

#:../../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"成功后，数据和指定的separator将从内部缓冲区中删除(或者说被消费掉)。返回的数据将包括在末尾的指定separator。"

#:../../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"如果读取的数据量超过了配置的流限制，将引发 :exc:`LimitOverrunError` 异常，数据将留在内部缓冲区中并可以再次读取。"

#:../../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""
"如果在找到完整的separator之前到达EOF，则会引发 :exc:`IncompleteReadError` 异常，并重置内部缓冲区。 "
":attr:`IncompleteReadError.partial` 属性可能包含指定separator的一部分。"

#:../../library/asyncio-stream.rst:267
msgid""
"Return ``True`` if the buffer is empty and :meth:`feed_eof` was called."
msgstr"如果缓冲区为空并且 :meth:`feed_eof` 被调用，则返回 ``True`` 。"

#:../../library/asyncio-stream.rst:272
msgid"StreamWriter"
msgstr"StreamWriter"

#:../../library/asyncio-stream.rst:276
msgid""
"Represents a writer object that provides APIs to write data to the IO "
"stream."
msgstr"这个类表示一个写入器对象，该对象提供api以便于写数据至IO流中。"

#:../../library/asyncio-stream.rst:279
msgid""
"It is not recommended to instantiate *StreamWriter* objects directly; use "
":func:`open_connection` and :func:`start_server` instead."
msgstr""
"不建议直接实例化 *StreamWriter*；而应改用 :func:`open_connection` 和 :func:`start_server`。"

#:../../library/asyncio-stream.rst:285
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"此方法会尝试立即将 *data* 写入到下层的套接字。 如果写入失败，数据会被排入内部写缓冲队列直到可以被发送。"

#:../../library/asyncio-stream.rst:289../../library/asyncio-stream.rst:301
msgid"The method should be used along with the ``drain()`` method::"
msgstr"此方法应当与 ``drain()`` 方法一起使用::"

#:../../library/asyncio-stream.rst:291
msgid""
"stream.write(data)\n"
"await stream.drain()"
msgstr""
"stream.write(data)\n"
"await stream.drain()"

#:../../library/asyncio-stream.rst:296
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:303
msgid""
"stream.writelines(lines)\n"
"await stream.drain()"
msgstr""
"stream.writelines(lines)\n"
"await stream.drain()"

#:../../library/asyncio-stream.rst:308
msgid"The method closes the stream and the underlying socket."
msgstr"此方法会关闭流以及下层的套接字。"

#:../../library/asyncio-stream.rst:310
msgid""
"The method should be used, though not mandatory, along with the "
"``wait_closed()`` method::"
msgstr"此方法应当于 ``wait_closed()`` 方法一起使用，但这并非强制要求::"

#:../../library/asyncio-stream.rst:313
msgid""
"stream.close()\n"
"await stream.wait_closed()"
msgstr""
"stream.close()\n"
"await stream.wait_closed()"

#:../../library/asyncio-stream.rst:318
msgid""
"Return ``True`` if the underlying transport supports the :meth:`write_eof` "
"method, ``False`` otherwise."
msgstr"如果下层的传输支持 :meth:`write_eof` 方法则返回 ``True``，否则返回 ``False``。"

#:../../library/asyncio-stream.rst:323
msgid""
"Close the write end of the stream after the buffered write data is flushed."
msgstr"在已缓冲的写入数据被刷新后关闭流的写入端。"

#:../../library/asyncio-stream.rst:328
msgid"Return the underlying asyncio transport."
msgstr"返回下层的 asyncio 传输。"

#:../../library/asyncio-stream.rst:332
msgid""
"Access optional transport information; see "
":meth:`BaseTransport.get_extra_info` for details."
msgstr"访问可选的传输信息；详情参见 :meth:`BaseTransport.get_extra_info`。"

#:../../library/asyncio-stream.rst:337
msgid""
"Wait until it is appropriate to resume writing to the stream. Example::"
msgstr"等待直到可以适当地恢复写入到流。 示例::"

#:../../library/asyncio-stream.rst:340
msgid""
"writer.write(data)\n"
"await writer.drain()"
msgstr""
"writer.write(data)\n"
"await writer.drain()"

#:../../library/asyncio-stream.rst:343
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""
"这是一个与下层的 IO 写缓冲区进行交互的流程控制方法。 当缓冲区大小达到最高水位（最大上限）时，*drain()* "
"会阻塞直到缓冲区大小减少至最低水位以便恢复写入。 当没有要等待的数据时，:meth:`drain` 会立即返回。"

#:../../library/asyncio-stream.rst:353
msgid"Upgrade an existing stream-based connection to TLS."
msgstr"将现有基于流的连接升级到 TLS。"

#:../../library/asyncio-stream.rst:355
msgid"Parameters:"
msgstr"参数："

#:../../library/asyncio-stream.rst:357
msgid"*sslcontext*: a configured instance of :class:`~ssl.SSLContext`."
msgstr"*sslcontext* ：一个已经配置好的 :class:`~ssl.SSLContext` 实例。"

#:../../library/asyncio-stream.rst:359
msgid""
"*server_hostname*: sets or overrides the host name that the target server's "
"certificate will be matched against."
msgstr"*server_hostname* ：设置或者覆盖目标服务器证书中相对应的主机名。"

#:../../library/asyncio-stream.rst:362
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* 是在放弃连接之前要等待 TLS 握手完成的秒数。 如为 ``None`` (默认值) 则使用 "
"``60.0``。"

#:../../library/asyncio-stream.rst:366
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_shutdown_timeout* 是在放弃连接之前要等待 SSL 关闭完成的秒数。 如为 ``None`` (默认值) 则使用 "
"``30.0``。"

#:../../library/asyncio-stream.rst:378
msgid""
"Return ``True`` if the stream is closed or in the process of being closed."
msgstr"如果流已被关闭或正在被关闭则返回 ``True``。"

#:../../library/asyncio-stream.rst:385
msgid"Wait until the stream is closed."
msgstr"等待直到流被关闭。"

#:../../library/asyncio-stream.rst:387
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"应当在 :meth:`close` 之后调用以等待直到下层连接被关闭，确保所有数据在退出程序之前已刷新。"

#:../../library/asyncio-stream.rst:395
msgid"Examples"
msgstr"例子"

#:../../library/asyncio-stream.rst:400
msgid"TCP echo client using streams"
msgstr"使用流的 TCP 回显客户端"

#:../../library/asyncio-stream.rst:402
msgid"TCP echo client using the :func:`asyncio.open_connection` function::"
msgstr"使用 :func:`asyncio.open_connection` 函数的 TCP 回显客户端::"

#:../../library/asyncio-stream.rst:426
msgid""
"The :ref:`TCP echo client protocol "
"<asyncio_example_tcp_echo_client_protocol>` example uses the low-level "
":meth:`loop.create_connection` method."
msgstr""
"使用低层级 :meth:`loop.create_connection` 方法的 :ref:`TCP 回显客户端协议 "
"<asyncio_example_tcp_echo_client_protocol>` 示例。"

#:../../library/asyncio-stream.rst:433
msgid"TCP echo server using streams"
msgstr"使用流的 TCP 回显服务器"

#:../../library/asyncio-stream.rst:435
msgid"TCP echo server using the :func:`asyncio.start_server` function::"
msgstr"TCP 回显服务器使用 :func:`asyncio.start_server` 函数::"

#:../../library/asyncio-stream.rst:437
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""
"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())"

#:../../library/asyncio-stream.rst:469
msgid""
"The :ref:`TCP echo server protocol "
"<asyncio_example_tcp_echo_server_protocol>` example uses the "
":meth:`loop.create_server` method."
msgstr""
"使用 :meth:`loop.create_server` 方法的 :ref:`TCP 回显服务器协议 "
"<asyncio_example_tcp_echo_server_protocol>` 示例。"

#:../../library/asyncio-stream.rst:474
msgid"Get HTTP headers"
msgstr"获取 HTTP 标头"

#:../../library/asyncio-stream.rst:476
msgid""
"Simple example querying HTTP headers of the URL passed on the command line::"
msgstr"查询命令行传入 URL 的 HTTP 标头的简单示例::"

#:../../library/asyncio-stream.rst:478
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""
"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))"

#:../../library/asyncio-stream.rst:515
msgid"Usage::"
msgstr"用法："

#:../../library/asyncio-stream.rst:517
msgid"python example.py http://example.com/path/page.html"
msgstr"python example.py http://example.com/path/page.html"

#:../../library/asyncio-stream.rst:519
msgid"or with HTTPS::"
msgstr"或使用 HTTPS::"

#:../../library/asyncio-stream.rst:521
msgid"python example.py https://example.com/path/page.html"
msgstr"python example.py https://example.com/path/page.html"

#:../../library/asyncio-stream.rst:527
msgid"Register an open socket to wait for data using streams"
msgstr"注册一个打开的套接字以等待使用流的数据"

#:../../library/asyncio-stream.rst:529
msgid""
"Coroutine waiting until a socket receives data using the "
":func:`open_connection` function::"
msgstr"使用 :func:`open_connection` 函数实现等待直到套接字接收到数据的协程::"

#:../../library/asyncio-stream.rst:532
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""
"import asyncio\n"
"import socket\n"
"\n"
"async def wait_for_data():\n"
" # 获取一个指向当前事件循环的引用\n"
" # 因为我们想要访问低层级的 API。\n"
" loop = asyncio.get_running_loop()\n"
"\n"
" # 创建一对已接连的套接字。\n"
" rsock, wsock = socket.socketpair()\n"
"\n"
" # 注册打开的套接字以等待数据。\n"
" reader, writer = await asyncio.open_connection(sock=rsock)\n"
"\n"
" # 模拟从网络接收数据\n"
" loop.call_soon(wsock.send, 'abc'.encode())\n"
"\n"
" # 等待数据\n"
" data = await reader.read(100)\n"
"\n"
" # 获得数据，我们已完成：关闭套接字\n"
" print(\"Received:\", data.decode())\n"
" writer.close()\n"
" await writer.wait_closed()\n"
"\n"
" # 关闭第二个套接字\n"
" wsock.close()\n"
"\n"
"asyncio.run(wait_for_data())"

#:../../library/asyncio-stream.rst:564
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""
"使用低层级协议以及 :meth:`loop.create_connection` 方法的 :ref:`注册一个打开的套接字以等待使用协议的数据 "
"<asyncio_example_create_connection>` 示例。"

#:../../library/asyncio-stream.rst:568
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""
"使用低层级的 :meth:`loop.add_reader` 方法来监视文件描述符的 :ref:`监视文件描述符以读取事件 "
"<asyncio_example_watch_fd>` 示例。"