asyncio-stream.po

# Copyright (C) 2001-2024, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
# Adrian Liaw <adrianliaw2000@gmail.com>, 2018
# Matt Wang <mattwang44@gmail.com>, 2022-2024
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-11-25 00:14+0000\n"
"PO-Revision-Date: 2022-10-31 16:28+0800\n"
"Last-Translator: Matt Wang <mattwang44@gmail.com>\n"
"Language-Team: Chinese - TAIWAN (https://github.com/python/python-docs-zh-"
"tw)\n"
"Language: zh_TW\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"
"X-Generator: Poedit 3.1.1\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 (async/await-ready) 的高階原始物件 (high-level "
"primitive)，用於處理網路連線。串流不需要使用回呼 (callback) 或低階協定和傳輸 "
"(transport) 就能夠傳送和接收資料。"

#: ../../library/asyncio-stream.rst:19
msgid "Here is an example of a TCP echo client written using asyncio streams::"
msgstr "這是一個使用 asyncio 串流編寫的 TCP echo 客戶端範例： ::"

#: ../../library/asyncio-stream.rst:22 ../../library/asyncio-stream.rst:419
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 "串流函式"

#: ../../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:110
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` 實例所使用的緩衝區 (buffer) 大小限"
"制。*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:151
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: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:126
#: ../../library/asyncio-stream.rst:161 ../../library/asyncio-stream.rst:191
msgid "Removed the *loop* parameter."
msgstr "移除 *loop* 參數。"

#: ../../library/asyncio-stream.rst:86 ../../library/asyncio-stream.rst:129
#: ../../library/asyncio-stream.rst:164 ../../library/asyncio-stream.rst:194
#: ../../library/asyncio-stream.rst:387
msgid "Added the *ssl_shutdown_timeout* parameter."
msgstr "新增 *ssl_shutdown_timeout* 參數。"

#: ../../library/asyncio-stream.rst:99
msgid "Start a socket server."
msgstr "啟動 socket 伺服器。"

#: ../../library/asyncio-stream.rst:101
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)``，分別為 :class:`StreamReader` 和 :"
"class:`StreamWriter` 的實例。"

#: ../../library/asyncio-stream.rst:106
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* 既可以是普通的可呼叫物件 (callable)，也可以是一個\\ :"
"ref:`協程函式 <coroutine>`；如果它是一個協程函式，它將自動作為 :class:`Task` "
"來被排程。"

#: ../../library/asyncio-stream.rst:114
msgid ""
"The rest of the arguments are passed directly to :meth:`loop.create_server`."
msgstr "剩下的引數將會直接傳遞給 :meth:`loop.create_server`。"

#: ../../library/asyncio-stream.rst:119 ../../library/asyncio-stream.rst:181
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:123
msgid "Added the *ssl_handshake_timeout* and *start_serving* parameters."
msgstr "新增 *ssl_handshake_timeout* 與 *start_serving* 參數。"

#: ../../library/asyncio-stream.rst:132
msgid "Added the *keep_alive* parameter."
msgstr "新增 *keep_alive* 參數。"

#: ../../library/asyncio-stream.rst:137
msgid "Unix Sockets"
msgstr "Unix Sockets"

#: ../../library/asyncio-stream.rst:142
msgid ""
"Establish a Unix socket connection and return a pair of ``(reader, writer)``."
msgstr "建立一個 Unix socket 連線並回傳一對 ``(reader, writer)``。"

#: ../../library/asyncio-stream.rst:145
msgid "Similar to :func:`open_connection` but operates on Unix sockets."
msgstr "與 :func:`open_connection` 相似，但是是操作 Unix sockets。"

#: ../../library/asyncio-stream.rst:147
msgid "See also the documentation of :meth:`loop.create_unix_connection`."
msgstr "另請參閱 :meth:`loop.create_unix_connection` 文件。"

#: ../../library/asyncio-stream.rst:155 ../../library/asyncio-stream.rst:185
msgid "Availability"
msgstr ""

#: ../../library/asyncio-stream.rst:157
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:173
msgid "Start a Unix socket server."
msgstr "啟動一個 Unix socket 伺服器。"

#: ../../library/asyncio-stream.rst:175
msgid "Similar to :func:`start_server` but works with Unix sockets."
msgstr "與 :func:`start_server` 相似，但會是操作 Unix sockets。"

#: ../../library/asyncio-stream.rst:177
msgid "See also the documentation of :meth:`loop.create_unix_server`."
msgstr "另請參閱 :meth:`loop.create_unix_server` 文件。"

#: ../../library/asyncio-stream.rst:187
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:199
msgid "StreamReader"
msgstr "StreamReader"

#: ../../library/asyncio-stream.rst:203
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 ""
"表示一個有提供 API 來從 IO 串流中讀取資料的 reader 物件。作為一個 :term:"
"`asynchronous iterable`，此物件支援 :keyword:`async for` 陳述式。"

#: ../../library/asyncio-stream.rst:207
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` 會是較好的做法。"

#: ../../library/asyncio-stream.rst:213
msgid "Acknowledge the EOF."
msgstr ""

#: ../../library/asyncio-stream.rst:217
msgid "Read up to *n* bytes from the stream."
msgstr "從串流中讀取至多 *n* 個位元組的資料。"

#: ../../library/asyncio-stream.rst:219
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`` 物"
"件。"

#: ../../library/asyncio-stream.rst:224
msgid "If *n* is ``0``, return an empty ``bytes`` object immediately."
msgstr "如果 *n* 為 ``0``，則立即回傳一個空的 ``bytes`` 物件。"

#: ../../library/asyncio-stream.rst:226
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:233
msgid ""
"Read one line, where \"line\" is a sequence of bytes ending with ``\\n``."
msgstr "讀取一行，其中\"行\"指的是以 ``\\n`` 結尾的位元組序列。"

#: ../../library/asyncio-stream.rst:236
msgid ""
"If EOF is received and ``\\n`` was not found, the method returns partially "
"read data."
msgstr "如果讀取到 EOF 而沒有找到 ``\\n``，該方法會回傳部分的已讀取資料。"

#: ../../library/asyncio-stream.rst:239
msgid ""
"If EOF is received and the internal buffer is empty, return an empty "
"``bytes`` object."
msgstr "如果讀取到 EOF 且內部緩衝區是空的，則回傳一個空的 ``bytes`` 物件。"

#: ../../library/asyncio-stream.rst:244
msgid "Read exactly *n* bytes."
msgstr "讀取剛好 *n* 個位元組。"

#: ../../library/asyncio-stream.rst:246
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* 個位元組之前讀取到 EOF，則會引發 :exc:"
"`IncompleteReadError`。使用 :attr:`IncompleteReadError.partial` 屬性來獲取串"
"流結束前已讀取的部分資料。"

#: ../../library/asyncio-stream.rst:252
msgid "Read data from the stream until *separator* is found."
msgstr "從串流中持續讀取資料直到出現 *separator*。"

#: ../../library/asyncio-stream.rst:254
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（分隔符號）會從內部緩衝區中刪除（或者說是被消費掉 "
"(consumed)）。回傳的資料在末尾會有一個 separator。"

#: ../../library/asyncio-stream.rst:258
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:262
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 ""
"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:277
msgid "The *separator* parameter may now be a :class:`tuple` of separators."
msgstr "現在 *separator* 參數可以是一個分隔符號的 :class:`tuple`。"

#: ../../library/asyncio-stream.rst:282
msgid "Return ``True`` if the buffer is empty and :meth:`feed_eof` was called."
msgstr "如果緩衝區是空的且 :meth:`feed_eof` 曾被呼叫則回傳 ``True``。"

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

#: ../../library/asyncio-stream.rst:291
msgid ""
"Represents a writer object that provides APIs to write data to the IO stream."
msgstr "表示一個有提供 API 來將資料寫入 IO 串流的 writer 物件。"

#: ../../library/asyncio-stream.rst:294
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:300
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* 寫入到底層的 socket。如果失敗，資料會被放到內部寫入"
"緩衝中排隊等待 (queue)，直到它可被發送。"

#: ../../library/asyncio-stream.rst:304 ../../library/asyncio-stream.rst:316
msgid "The method should be used along with the ``drain()`` method::"
msgstr "此方法應當與 ``drain()`` 方法一起使用： ::"

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

#: ../../library/asyncio-stream.rst:311
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 ""
"此方法會立即嘗試將一個位元組 list（或任何可疊代物件 (iterable)）寫入到底層的 "
"socket。如果失敗，資料會被放到內部寫入緩衝中排隊等待，直到它可被發送。"

#: ../../library/asyncio-stream.rst:318
msgid ""
"stream.writelines(lines)\n"
"await stream.drain()"
msgstr ""
"stream.writelines(lines)\n"
"await stream.drain()"

#: ../../library/asyncio-stream.rst:323
msgid "The method closes the stream and the underlying socket."
msgstr "此方法會關閉串流以及底層的 socket。"

#: ../../library/asyncio-stream.rst:325
msgid ""
"The method should be used, though not mandatory, along with the "
"``wait_closed()`` method::"
msgstr "此方法應與 ``wait_closed()`` 方法一起使用，但並非強制： ::"

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

#: ../../library/asyncio-stream.rst:333
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:338
msgid ""
"Close the write end of the stream after the buffered write data is flushed."
msgstr "在已緩衝的寫入資料被清理 (flush) 後關閉串流的寫入端。"

#: ../../library/asyncio-stream.rst:343
msgid "Return the underlying asyncio transport."
msgstr "回傳底層的 asyncio 傳輸。"

#: ../../library/asyncio-stream.rst:347
msgid ""
"Access optional transport information; see :meth:`BaseTransport."
"get_extra_info` for details."
msgstr "存取可選的傳輸資訊；詳情請見 :meth:`BaseTransport.get_extra_info`。"

#: ../../library/asyncio-stream.rst:352
msgid "Wait until it is appropriate to resume writing to the stream. Example::"
msgstr "等待直到可以繼續寫入到串流。範例： ::"

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

#: ../../library/asyncio-stream.rst:358
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 寫入緩衝區互動的流程控制方法。當緩衝區大小達到最高標記位 "
"(high watermark) 時，*drain()* 會阻塞直到緩衝區大小減少至最低標記位 (low "
"watermark) 以便繼續寫入。當沒有要等待的資料時，:meth:`drain` 會立即回傳。"

#: ../../library/asyncio-stream.rst:368
msgid "Upgrade an existing stream-based connection to TLS."
msgstr "將現有的基於串流的連線升級到 TLS。"

#: ../../library/asyncio-stream.rst:370
msgid "Parameters:"
msgstr "參數："

#: ../../library/asyncio-stream.rst:372
msgid "*sslcontext*: a configured instance of :class:`~ssl.SSLContext`."
msgstr "*sslcontext*：一個 :class:`~ssl.SSLContext` 的已配置實例。"

#: ../../library/asyncio-stream.rst:374
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:377
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:381
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:393
msgid ""
"Return ``True`` if the stream is closed or in the process of being closed."
msgstr "如果串流已被關閉或正在被關閉則回傳 ``True``。"

#: ../../library/asyncio-stream.rst:400
msgid "Wait until the stream is closed."
msgstr "等待直到串流被關閉。"

#: ../../library/asyncio-stream.rst:402
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:410
msgid "Examples"
msgstr "範例"

#: ../../library/asyncio-stream.rst:415
msgid "TCP echo client using streams"
msgstr "使用串流的 TCP echo 客戶端"

#: ../../library/asyncio-stream.rst:417
msgid "TCP echo client using the :func:`asyncio.open_connection` function::"
msgstr "使用 :func:`asyncio.open_connection` 函式的 TCP echo 客戶端： ::"

#: ../../library/asyncio-stream.rst:441
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 echo 客戶端協定 "
"<asyncio_example_tcp_echo_client_protocol>`\\ 範例。"

#: ../../library/asyncio-stream.rst:448
msgid "TCP echo server using streams"
msgstr "使用串流的 TCP echo 伺服器"

#: ../../library/asyncio-stream.rst:450
msgid "TCP echo server using the :func:`asyncio.start_server` function::"
msgstr "TCP echo 伺服器使用 :func:`asyncio.start_server` 函式： ::"

#: ../../library/asyncio-stream.rst:452
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:484
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 echo 伺服器協定 "
"<asyncio_example_tcp_echo_server_protocol>` 範例。"

#: ../../library/asyncio-stream.rst:489
msgid "Get HTTP headers"
msgstr "獲取 HTTP 標頭"

#: ../../library/asyncio-stream.rst:491
msgid ""
"Simple example querying HTTP headers of the URL passed on the command line::"
msgstr "查詢自命令列傳入之 URL 所帶有 HTTP 標頭的簡單範例： ::"

#: ../../library/asyncio-stream.rst:493
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:530
msgid "Usage::"
msgstr "用法： ::"

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

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

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

#: ../../library/asyncio-stream.rst:542
msgid "Register an open socket to wait for data using streams"
msgstr "註冊一個使用串流來等待資料的開放 socket"

#: ../../library/asyncio-stream.rst:544
msgid ""
"Coroutine waiting until a socket receives data using the :func:"
"`open_connection` function::"
msgstr ""
"等待直到 socket 透過使用 :func:`open_connection` 函式接收到資料的協程： ::"

#: ../../library/asyncio-stream.rst:547
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:579
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 ""
"在\\ :ref:`註冊一個開啟的 socket 以等待有使用協定的資料 "
"<asyncio_example_create_connection>`\\ 範例中，有使用了低階協定以及 :meth:"
"`loop.create_connection` 方法。"

#: ../../library/asyncio-stream.rst:583
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 ""
"在\\ :ref:`監視檔案描述器以讀取事件 <asyncio_example_watch_fd>`\\ 範例中，有"
"使用低階的 :meth:`loop.add_reader` 方法來監視檔案描述器。"