asyncio-stream.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# python-doc bot, 2025
# Takanori Suzuki <takanori@takanory.net>, 2026
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.15\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-10-01 19:07+0000\n"
"PO-Revision-Date: 2025-09-16 00:00+0000\n"
"Last-Translator: Takanori Suzuki <takanori@takanory.net>, 2026\n"
"Language-Team: Japanese (https://app.transifex.com/python-doc/teams/5390/"
"ja/)\n"
"Language: ja\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"

#: ../../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 ストリームを使って書いた TCP エコークライアントの例です::"

#: ../../library/asyncio-stream.rst:22 ../../library/asyncio-stream.rst:455
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 ""
"以下の asyncio のトップレベル関数はストリームの作成や操作を行うことができま"
"す:"

#: ../../library/asyncio-stream.rst:59
msgid ""
"Establish a network connection and return a pair of ``(reader, writer)`` "
"objects."
msgstr ""
"ネットワークコネクションを確立し、 ``(reader, writer)`` のオブジェクトのペア"
"を返します。"

#: ../../library/asyncio-stream.rst:62
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:65 ../../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 ""
"*limit* は戻り値の :class:`StreamReader` インスタンスが利用するバッファのサイ"
"ズの上限値を設定します。デフォルトでは *limit* は 64 KiB に設定されます。"

#: ../../library/asyncio-stream.rst:69
msgid ""
"The rest of the arguments are passed directly to :meth:`loop."
"create_connection`."
msgstr "残りの引数は直接 :meth:`loop.create_connection` に渡されます。"

#: ../../library/asyncio-stream.rst:74 ../../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 "*ssl_handshake_timeout* 引数が追加されました。"

#: ../../library/asyncio-stream.rst:81
msgid "Added the *happy_eyeballs_delay* and *interleave* parameters."
msgstr "*happy_eyeballs_delay* と *interleave* が追加されました。"

#: ../../library/asyncio-stream.rst:84 ../../library/asyncio-stream.rst:128
#: ../../library/asyncio-stream.rst:164 ../../library/asyncio-stream.rst:199
msgid "Removed the *loop* parameter."
msgstr "*loop* パラメータが削除されました。"

#: ../../library/asyncio-stream.rst:87 ../../library/asyncio-stream.rst:131
#: ../../library/asyncio-stream.rst:167 ../../library/asyncio-stream.rst:202
#: ../../library/asyncio-stream.rst:418
msgid "Added the *ssl_shutdown_timeout* parameter."
msgstr "*ssl_shutdown_timeout* パラメータが追加されました。"

#: ../../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 ""
"*client_connected_cb* コールバックは新しいクライアントコネクションが確立され"
"るたびに呼び出されます。このコールバックは :class:`StreamReader` と :class:"
"`StreamWriter` クラスのインスタンスのペア ``(reader, writer)`` を2つの引数と"
"して受け取ります。"

#: ../../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 ""
"*client_connected_cb* には単純な呼び出し可能オブジェクトか、または :ref:`コ"
"ルーチン関数 <coroutine>` を指定します; コルーチン関数が指定された場合、コー"
"ルバックの呼び出しは自動的に :class:`Task` としてスケジュールされます。"

#: ../../library/asyncio-stream.rst:116
msgid ""
"The rest of the arguments are passed directly to :meth:`loop.create_server`."
msgstr "残りの引数は直接 :meth:`loop.create_server` に渡されます。"

#: ../../library/asyncio-stream.rst:121 ../../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 ""
"*ssl_handshake_timeout* と *start_serving* パラメータが追加されました。"

#: ../../library/asyncio-stream.rst:134
msgid "Added the *keep_alive* parameter."
msgstr ""

#: ../../library/asyncio-stream.rst:139
msgid "Unix Sockets"
msgstr "Unix ソケット"

#: ../../library/asyncio-stream.rst:145
msgid ""
"Establish a Unix socket connection and return a pair of ``(reader, writer)``."
msgstr ""
"Unix ソケットコネクションを確立し、 ``(reader, writer)`` のオブジェクトのペア"
"を返します。"

#: ../../library/asyncio-stream.rst:148
msgid "Similar to :func:`open_connection` but operates on Unix sockets."
msgstr ""
"この関数は :func:`open_connection` と似ていますが Unix ソケットに対して動作し"
"ます。"

#: ../../library/asyncio-stream.rst:150
msgid "See also the documentation of :meth:`loop.create_unix_connection`."
msgstr ":meth:`loop.create_unix_connection` のドキュメントも参照してください。"

#: ../../library/asyncio-stream.rst:158 ../../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 "Unix のソケットサーバーを起動します。"

#: ../../library/asyncio-stream.rst:179
msgid "Similar to :func:`start_server` but works with Unix sockets."
msgstr ":func:`start_server` と似ていますが Unix ソケットに対して動作します。"

#: ../../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 ":meth:`loop.create_unix_server` のドキュメントも参照してください。"

#: ../../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 "StreamReader"

#: ../../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 ""
"*StreamReader* オブジェクトを直接インスタンス化することは推奨されません; 代わ"
"りに :func:`open_connection` や :func:`start_server` を使ってください。"

#: ../../library/asyncio-stream.rst:224
msgid "Acknowledge the EOF."
msgstr "EOF の肯定応答を行います。"

#: ../../library/asyncio-stream.rst:229
msgid "Read up to *n* bytes from the stream."
msgstr "ストリームから最大 *n* バイト読み込みます。"

#: ../../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 ""
"*n* が指定されないか ``-1`` が指定されていた場合 EOF になるまで読み込み、読み"
"込まれた全ての :class:`bytes` を返します。EOF を受信し、かつ内部バッファーが"
"空の場合、空の ``bytes`` オブジェクトを返します。"

#: ../../library/asyncio-stream.rst:236
msgid "If *n* is ``0``, return an empty ``bytes`` object immediately."
msgstr "*n* が ``0`` なら、ただちに空の ``bytes`` オブジェクトを返します。"

#: ../../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 ""
"*n* が正なら、内部バッファで最低でも 1 バイトが利用可能になり次第、利用可能な"
"最大 *n* ``bytes`` を返します。1 バイトも読み込まないうちに EOF を受信したな"
"ら、空の ``bytes`` オブジェクトを返します。"

#: ../../library/asyncio-stream.rst:246
msgid ""
"Read one line, where \"line\" is a sequence of bytes ending with ``\\n``."
msgstr ""
"1 行読み込みます。 \"行\" とは、``\\n`` で終了するバイト列のシーケンスです。"

#: ../../library/asyncio-stream.rst:249
msgid ""
"If EOF is received and ``\\n`` was not found, the method returns partially "
"read data."
msgstr ""
"EOF を受信し、かつ ``\\n`` が見つからない場合、このメソッドは部分的に読み込ん"
"だデータを返します。"

#: ../../library/asyncio-stream.rst:252
msgid ""
"If EOF is received and the internal buffer is empty, return an empty "
"``bytes`` object."
msgstr ""
"EOF を受信し、かつ内部バッファーが空の場合、空の ``bytes`` オブジェクトを返し"
"ます。"

#: ../../library/asyncio-stream.rst:258
msgid "Read exactly *n* bytes."
msgstr "厳密に *n* バイトのデータを読み出します。"

#: ../../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 ""
"*n* バイトを読み出す前に EOF に達した場合 :exc:`IncompleteReadError` を送出し"
"ます。部分的に読み出したデータを取得するには :attr:`IncompleteReadError."
"partial` 属性を使ってください。"

#: ../../library/asyncio-stream.rst:267
msgid "Read data from the stream until *separator* is found."
msgstr "*separator* が見つかるまでストリームからデータを読み出します。"

#: ../../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 ""
"読み出したデータの量が設定したストリームの上限を超えると :exc:"
"`LimitOverrunError` 例外が送出されます。このときデータは内部バッファーに残さ"
"れ、再度読み出すことができます。"

#: ../../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 ""
"完全な区切り文字が見つかる前に EOF に達すると :exc:`IncompleteReadError`  例"
"外が送出され、内部バッファーがリセットされます。このとき :attr:"
"`IncompleteReadError.partial` 属性は区切り文字の一部を含むかもしれません。"

#: ../../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 ""
"バッファーが空で :meth:`feed_eof` が呼ばれていた場合 ``True`` を返します。"

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

#: ../../library/asyncio-stream.rst:306
msgid ""
"Represents a writer object that provides APIs to write data to the IO stream."
msgstr ""
"IO ストリームにデータを書き込むための API を提供するライターオブジェクトを表"
"します。"

#: ../../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 ""
"*StreamWriter* オブジェクトを直接インスタンス化することは推奨されません; 代わ"
"りに :func:`open_connection` や :func:`start_server` を使ってください。"

#: ../../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 ""
"このメソッドは、背後にあるソケットにデータ *data* を即座に書き込みます。書き"
"込みに失敗した場合、データは送信可能になるまで内部の書き込みバッファーに格納"
"されて待機します。"

#: ../../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:322 ../../library/asyncio-stream.rst:335
msgid "The method should be used along with the ``drain()`` method::"
msgstr "このメソッドは ``drain()`` メソッドと組み合わせて使うべきです::"

#: ../../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 ""
"背後にあるトランスポートが :meth:`write_eof` メソッドをサポートしている場合 "
"``True`` を返し、そうでない場合は ``False`` を返します。"

#: ../../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 "背後にある asyncio トランスポートを返します。"

#: ../../library/asyncio-stream.rst:366
msgid ""
"Access optional transport information; see :meth:`BaseTransport."
"get_extra_info` for details."
msgstr ""
"オプションのトランスポート情報にアクセスします。詳細は :meth:`BaseTransport."
"get_extra_info` を参照してください。"

#: ../../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 ""
"このメソッドは背後にある IO 書き込みバッファーとやりとりを行うフロー制御メ"
"ソッドです。バッファーのサイズが最高水位点に達した場合、*drain()* はバッファ"
"のサイズが最低水位点を下回るまで減量され、書き込み再開可能になるまで書き込み"
"をブロックします。待ち受けの必要がない場合、 :meth:`drain` は即座にリターンし"
"ます。"

#: ../../library/asyncio-stream.rst:387
msgid ""
"When the write buffer is below the high watermark, :meth:`drain` returns "
"immediately without yielding to the event loop.  As a result, code which "
"repeatedly calls ``write()`` followed by ``await drain()`` may prevent other "
"tasks from running.  To prevent blocking behavior, yield to the event loop "
"explicitly with ``await asyncio.sleep(0)`` (see :func:`asyncio.sleep`)."
msgstr ""

#: ../../library/asyncio-stream.rst:399
msgid "Upgrade an existing stream-based connection to TLS."
msgstr ""

#: ../../library/asyncio-stream.rst:401
msgid "Parameters:"
msgstr "引数:"

#: ../../library/asyncio-stream.rst:403
msgid "*sslcontext*: a configured instance of :class:`~ssl.SSLContext`."
msgstr "*sslcontext*: 構成済みの :class:`~ssl.SSLContext` インスタンスです。"

#: ../../library/asyncio-stream.rst:405
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:408
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:412
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:421
msgid ""
"Raises a ``ValueError`` if ``sslcontext.check_hostname`` is ``True`` and "
"``server_hostname`` is not supplied."
msgstr ""

#: ../../library/asyncio-stream.rst:428
msgid ""
"Return ``True`` if the stream is closed or in the process of being closed."
msgstr ""
"ストリームがクローズされたか、またはクローズ処理中の場合に ``True`` を返しま"
"す。"

#: ../../library/asyncio-stream.rst:436
msgid "Wait until the stream is closed."
msgstr "ストリームがクローズされるまで待機します。"

#: ../../library/asyncio-stream.rst:438
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:446
msgid "Examples"
msgstr "使用例"

#: ../../library/asyncio-stream.rst:451
msgid "TCP echo client using streams"
msgstr "ストリームを使った TCP Echo クライアント"

#: ../../library/asyncio-stream.rst:453
msgid "TCP echo client using the :func:`asyncio.open_connection` function::"
msgstr ""
":func:`asyncio.open_connection` 関数を使った TCP Echo クライアントです::"

#: ../../library/asyncio-stream.rst:477
msgid ""
"The :ref:`TCP echo client protocol "
"<asyncio_example_tcp_echo_client_protocol>` example uses the low-level :meth:"
"`loop.create_connection` method."
msgstr ""
":ref:`TCP エコークライアントプロトコル "
"<asyncio_example_tcp_echo_client_protocol>` の例は低水準の :meth:`loop."
"create_connection` メソッドを使っています。"

#: ../../library/asyncio-stream.rst:484
msgid "TCP echo server using streams"
msgstr "ストリームを使った TCP Echo サーバー"

#: ../../library/asyncio-stream.rst:486
msgid "TCP echo server using the :func:`asyncio.start_server` function::"
msgstr ":func:`asyncio.start_server` 関数を使った TCP Echo サーバーです::"

#: ../../library/asyncio-stream.rst:488
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:520
msgid ""
"The :ref:`TCP echo server protocol "
"<asyncio_example_tcp_echo_server_protocol>` example uses the :meth:`loop."
"create_server` method."
msgstr ""
":ref:`TCP エコーサーバープロトコル "
"<asyncio_example_tcp_echo_server_protocol>` の例は :meth:`loop."
"create_server` メソッドを使っています。"

#: ../../library/asyncio-stream.rst:525
msgid "Get HTTP headers"
msgstr "HTTP ヘッダーの取得"

#: ../../library/asyncio-stream.rst:527
msgid ""
"Simple example querying HTTP headers of the URL passed on the command line::"
msgstr ""
"コマンドラインから渡された URL の HTTP ヘッダーを問い合わせる簡単な例です::"

#: ../../library/asyncio-stream.rst:529
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:566
msgid "Usage::"
msgstr "使い方::"

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

#: ../../library/asyncio-stream.rst:570
msgid "or with HTTPS::"
msgstr "または HTTPS を使用::"

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

#: ../../library/asyncio-stream.rst:578
msgid "Register an open socket to wait for data using streams"
msgstr "ストリームを使ってデータを待つオープンソケットの登録"

#: ../../library/asyncio-stream.rst:580
msgid ""
"Coroutine waiting until a socket receives data using the :func:"
"`open_connection` function::"
msgstr ""
":func:`open_connection` 関数を使ってソケットがデータを受信するまで待つコルー"
"チンです::"

#: ../../library/asyncio-stream.rst:583
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:615
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:`プロトコルを使ってオープンしたソケットをデータ待ち受けのために登録する "
"<asyncio_example_create_connection>` 例では、低水準のプロトコルと :meth:"
"`loop.create_connection` メソッドを使っています。"

#: ../../library/asyncio-stream.rst:619
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` メソッドを使ってファイル記述子を監視"
"しています。"