asyncio-protocol.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2018, 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.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2018-06-30 05:56+0900\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: Shun Sakurai, 2017\n"
"Language-Team: Japanese (https://www.transifex.com/python-doc/teams/5390/ja/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: ja\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../library/asyncio-protocol.rst:5
msgid "Transports and protocols (callback based API)"
msgstr ""

#: ../../library/asyncio-protocol.rst:7
msgid "**Source code:** :source:`Lib/asyncio/transports.py`"
msgstr ""

#: ../../library/asyncio-protocol.rst:9
msgid "**Source code:** :source:`Lib/asyncio/protocols.py`"
msgstr ""

#: ../../library/asyncio-protocol.rst:14
msgid "Transports"
msgstr "トランスポート"

#: ../../library/asyncio-protocol.rst:16
msgid ""
"Transports are classes provided by :mod:`asyncio` in order to abstract "
"various kinds of communication channels.  You generally won't instantiate a "
"transport yourself; instead, you will call an :class:`AbstractEventLoop` "
"method which will create the transport and try to initiate the underlying "
"communication channel, calling you back when it succeeds."
msgstr ""
"トランスポートは、:mod:`asyncio` "
"が提供する、さまざまな種類の通信チャンネルを抽象化するクラス群です。通常あなた自身が直接トランスポートのインスタンスを作成することはなく、:class:`AbstractEventLoop`"
" のメソッドを呼び出すことでトランスポートとその下層の通信チャンネルのインスタンスが作成され、成功時にコールバックが返ります。"

#: ../../library/asyncio-protocol.rst:22
msgid ""
"Once the communication channel is established, a transport is always paired "
"with a :ref:`protocol <asyncio-protocol>` instance.  The protocol can then "
"call the transport's methods for various purposes."
msgstr ""
"いったん通信チャンネルが確立されると、トランスポートは常に :ref:`プロトコル <asyncio-protocol>` "
"インスタンスとのペアを成します。プロトコルはその後さまざまな用途のためトランスポートのメソッドを呼び出します。"

#: ../../library/asyncio-protocol.rst:26
msgid ""
":mod:`asyncio` currently implements transports for TCP, UDP, SSL, and "
"subprocess pipes.  The methods available on a transport depend on the "
"transport's kind."
msgstr ""
":mod:`asyncio` は現在 TCP、UDP、SSL "
"およびサブプロセスパイプのトランスポートを実装しています。利用可能なトランスポートのメソッドはトランスポートの種類に依存します。"

#: ../../library/asyncio-protocol.rst:30
msgid ""
"The transport classes are :ref:`not thread safe <asyncio-multithreading>`."
msgstr "トランスポートクラスは :ref:`スレッド安全ではありません <asyncio-multithreading>`。"

#: ../../library/asyncio-protocol.rst:32
msgid "The socket option ``TCP_NODELAY`` is now set by default."
msgstr "デフォルトでソケットオプションの ``TCP_NODELAY`` が設定されるようになりました。"

#: ../../library/asyncio-protocol.rst:37
msgid "BaseTransport"
msgstr "BaseTransport"

#: ../../library/asyncio-protocol.rst:41
msgid "Base class for transports."
msgstr "トランスポートの基底クラスです。"

#: ../../library/asyncio-protocol.rst:45
msgid ""
"Close the transport.  If the transport has a buffer for outgoing data, "
"buffered data will be flushed asynchronously.  No more data will be "
"received.  After all buffered data is flushed, the protocol's "
":meth:`connection_lost` method will be called with :const:`None` as its "
"argument."
msgstr ""
"トランスポートをクローズします。トランスポートが発信データのバッファーを持っていた場合、バッファーされたデータは非同期にフラッシュされます。それ以降データは受信されません。バッファーされていたデータがすべてフラッシュされた後、そのプロトコルの"
" :meth:`connection_lost` メソッドが引数 :const:`None` で呼び出されます。"

#: ../../library/asyncio-protocol.rst:53
msgid "Return ``True`` if the transport is closing or is closed."
msgstr "トランスポートを閉じている最中か閉じていた場合 ``True`` を返します。"

#: ../../library/asyncio-protocol.rst:59
msgid ""
"Return optional transport information.  *name* is a string representing the "
"piece of transport-specific information to get, *default* is the value to "
"return if the information doesn't exist."
msgstr ""
"オプションのトランスポート情報を返します。*name* は取得したトランスポート固有の情報を表す文字列で、*default* "
"は情報が存在しなかったときに返す値になります。"

#: ../../library/asyncio-protocol.rst:63
msgid ""
"This method allows transport implementations to easily expose channel-"
"specific information."
msgstr "このメソッドはトランスポートの実装に容易にチャンネル固有の情報を渡すことができます。"

#: ../../library/asyncio-protocol.rst:66
msgid "socket:"
msgstr "ソケット:"

#: ../../library/asyncio-protocol.rst:68
msgid ""
"``'peername'``: the remote address to which the socket is connected, result "
"of :meth:`socket.socket.getpeername` (``None`` on error)"
msgstr ""
"``'peername'``: ソケットが接続されているリモートアドレスで、:meth:`socket.socket.getpeername` "
"の結果になります (エラーのときは ``None``)"

#: ../../library/asyncio-protocol.rst:70
msgid "``'socket'``: :class:`socket.socket` instance"
msgstr "``'socket'``: :class:`socket.socket` のインスタンスになります"

#: ../../library/asyncio-protocol.rst:71
msgid ""
"``'sockname'``: the socket's own address, result of "
":meth:`socket.socket.getsockname`"
msgstr ""
"``'sockname'``: ソケット自身のアドレスで、:meth:`socket.socket.getsockname` の結果になります"

#: ../../library/asyncio-protocol.rst:74
msgid "SSL socket:"
msgstr "SSL ソケット:"

#: ../../library/asyncio-protocol.rst:76
msgid ""
"``'compression'``: the compression algorithm being used as a string, or "
"``None`` if the connection isn't compressed; result of "
":meth:`ssl.SSLSocket.compression`"
msgstr ""
"``'compression'``: 圧縮アルゴリズムで、:meth:`ssl.SSLSocket.compression` "
"の結果になります。圧縮されていないときは ``None`` になります"

#: ../../library/asyncio-protocol.rst:79
msgid ""
"``'cipher'``: a three-value tuple containing the name of the cipher being "
"used, the version of the SSL protocol that defines its use, and the number "
"of secret bits being used; result of :meth:`ssl.SSLSocket.cipher`"
msgstr ""
"``'cipher'``: 3 個の値 (使用されている暗号アルゴリズムの名称、使用が定義されている SSL "
"プロトコルのバージョン、および使用されている秘密鍵のビット数) からなるタプルで、:meth:`ssl.SSLSocket.cipher` "
"の結果になります"

#: ../../library/asyncio-protocol.rst:83
msgid ""
"``'peercert'``: peer certificate; result of "
":meth:`ssl.SSLSocket.getpeercert`"
msgstr "``'peercert'``: ピアの証明書で、:meth:`ssl.SSLSocket.getpeercert` の結果になります"

#: ../../library/asyncio-protocol.rst:85
msgid "``'sslcontext'``: :class:`ssl.SSLContext` instance"
msgstr "``'sslcontext'``: :class:`ssl.SSLContext` のインスタンスになります"

#: ../../library/asyncio-protocol.rst:86
msgid ""
"``'ssl_object'``: :class:`ssl.SSLObject` or :class:`ssl.SSLSocket` instance"
msgstr ""
"``'ssl_object'``: :class:`ssl.SSLObject` または :class:`ssl.SSLSocket` インスタンス"

#: ../../library/asyncio-protocol.rst:89
msgid "pipe:"
msgstr "パイプ:"

#: ../../library/asyncio-protocol.rst:91
msgid "``'pipe'``: pipe object"
msgstr "``'pipe'``: パイプオブジェクトです"

#: ../../library/asyncio-protocol.rst:93
msgid "subprocess:"
msgstr "サブプロセス:"

#: ../../library/asyncio-protocol.rst:95
msgid "``'subprocess'``: :class:`subprocess.Popen` instance"
msgstr "``'subprocess'``: :class:`subprocess.Popen` のインスタンスになります"

#: ../../library/asyncio-protocol.rst:99
msgid ""
"Set a new protocol.  Switching protocol should only be done when both "
"protocols are documented to support the switch."
msgstr "新しいプロトコルを設定します。プロトコルの切り替えは、両方のプロトコルのドキュメントで切り替えがサポートされている場合にのみ行うべきです。"

#: ../../library/asyncio-protocol.rst:106
msgid "Return the current protocol."
msgstr "現在のプロトコルを返します。"

#: ../../library/asyncio-protocol.rst:110
msgid "``'ssl_object'`` info was added to SSL sockets."
msgstr "``'ssl_object'`` 情報が SSL ソケットに追加されました。"

#: ../../library/asyncio-protocol.rst:115
msgid "ReadTransport"
msgstr "ReadTransport"

#: ../../library/asyncio-protocol.rst:119
msgid "Interface for read-only transports."
msgstr "読み出し専用トランスポートのインターフェースです。"

#: ../../library/asyncio-protocol.rst:123
msgid "Return ``True`` if the transport is receiving new data."
msgstr ""

#: ../../library/asyncio-protocol.rst:129
msgid ""
"Pause the receiving end of the transport.  No data will be passed to the "
"protocol's :meth:`data_received` method until :meth:`resume_reading` is "
"called."
msgstr ""
"トランスポートの受信側を一時停止します。:meth:`resume_reading` が呼び出されるまでそのプロトコルの "
":meth:`data_received` メソッドにデータは渡されません。"

#: ../../library/asyncio-protocol.rst:133
msgid ""
"The method is idempotent, i.e. it can be called when the transport is "
"already paused or closed."
msgstr ""

#: ../../library/asyncio-protocol.rst:139
msgid ""
"Resume the receiving end.  The protocol's :meth:`data_received` method will "
"be called once again if some data is available for reading."
msgstr ""
"受信を再開します。読み込み可能データが存在した場合そのプロトコルの :meth:`data_received` メソッドが一度呼び出されます。"

#: ../../library/asyncio-protocol.rst:142
msgid ""
"The method is idempotent, i.e. it can be called when the transport is "
"already reading."
msgstr ""

#: ../../library/asyncio-protocol.rst:148
msgid "WriteTransport"
msgstr "WriteTransport"

#: ../../library/asyncio-protocol.rst:152
msgid "Interface for write-only transports."
msgstr "書き込み専用トランスポートのインターフェースです。"

#: ../../library/asyncio-protocol.rst:156
#: ../../library/asyncio-protocol.rst:244
msgid ""
"Close the transport immediately, without waiting for pending operations to "
"complete.  Buffered data will be lost.  No more data will be received. The "
"protocol's :meth:`connection_lost` method will eventually be called with "
":const:`None` as its argument."
msgstr ""
"トランスポートを即座にクローズします。未完了の処理があってもそれを待ちません。バッファーされているデータは失われます。それ以降データは受信されません。最終的にそのプロトコルの"
" :meth:`connection_lost` メソッドが引数 :const:`None` で呼び出されます。"

#: ../../library/asyncio-protocol.rst:163
msgid ""
"Return :const:`True` if the transport supports :meth:`write_eof`, "
":const:`False` if not."
msgstr ""
"トランスポートが :meth:`write_eof` をサポートしている場合 :const:`True` を、サポートしていない場合は "
":const:`False` を返します。"

#: ../../library/asyncio-protocol.rst:168
msgid "Return the current size of the output buffer used by the transport."
msgstr "トランスポートで使用されている出力バッファーの現在のサイズを返します。"

#: ../../library/asyncio-protocol.rst:172
msgid ""
"Get the *high*- and *low*-water limits for write flow control. Return a "
"tuple ``(low, high)`` where *low* and *high* are positive number of bytes."
msgstr ""
"書き込みフロー制御の *最高* および *最低* 水位点 (*high*- and *low*-water limits) を取得します。``(low,"
" high)`` のタプルを返します。*low* および *high* は整数のバイト列になります。"

#: ../../library/asyncio-protocol.rst:176
msgid "Use :meth:`set_write_buffer_limits` to set the limits."
msgstr "水位点の設定は :meth:`set_write_buffer_limits` で行います。"

#: ../../library/asyncio-protocol.rst:182
msgid "Set the *high*- and *low*-water limits for write flow control."
msgstr "書き込みフロー制御の *最高* および *最低* 水位点 (*high*- and *low*-water limits) を設定します。"

#: ../../library/asyncio-protocol.rst:184
msgid ""
"These two values (measured in number of bytes) control when the protocol's "
":meth:`pause_writing` and :meth:`resume_writing` methods are called. If "
"specified, the low-water limit must be less than or equal to the high-water "
"limit.  Neither *high* nor *low* can be negative."
msgstr ""

#: ../../library/asyncio-protocol.rst:190
msgid ""
":meth:`pause_writing` is called when the buffer size becomes greater than or"
" equal to the *high* value. If writing has been paused, "
":meth:`resume_writing` is called when the buffer size becomes less than or "
"equal to the *low* value."
msgstr ""

#: ../../library/asyncio-protocol.rst:195
msgid ""
"The defaults are implementation-specific.  If only the high-water limit is "
"given, the low-water limit defaults to an implementation-specific value less"
" than or equal to the high-water limit.  Setting *high* to zero forces *low*"
" to zero as well, and causes :meth:`pause_writing` to be called whenever the"
" buffer becomes non-empty.  Setting *low* to zero causes "
":meth:`resume_writing` to be called only once the buffer is empty. Use of "
"zero for either limit is generally sub-optimal as it reduces opportunities "
"for doing I/O and computation concurrently."
msgstr ""
"デフォルト値は実装固有になります。最高水位点のみ与えられた場合、最低水位点は最高水位点以下の実装固有のデフォルト値になります。最高水位点にゼロが設定されると最低水位点も強制的にゼロになり、バッファが空でなくなるたびに"
" :meth:`pause_writing` が呼び出されるようになります。最低水位点にゼロが設定されるとバッファは空になるとすぐに "
":meth:`resume_writing` が呼び出されるようになります。どちらかにゼロを設定することは、並列の I/O "
"処理や計算の機会を減らすことになるため、一般に最善とは言えません。"

#: ../../library/asyncio-protocol.rst:206
msgid "Use :meth:`get_write_buffer_limits` to get the limits."
msgstr "水位点の取得には :meth:`get_write_buffer_limits` を使用します。"

#: ../../library/asyncio-protocol.rst:210
msgid "Write some *data* bytes to the transport."
msgstr "トランスポートにバイト列 *data* を書き込みます。"

#: ../../library/asyncio-protocol.rst:212
#: ../../library/asyncio-protocol.rst:239
msgid ""
"This method does not block; it buffers the data and arranges for it to be "
"sent out asynchronously."
msgstr "このメソッドはブロックしません; データをバッファーし、非同期に送信する準備を行います。"

#: ../../library/asyncio-protocol.rst:217
msgid ""
"Write a list (or any iterable) of data bytes to the transport. This is "
"functionally equivalent to calling :meth:`write` on each element yielded by "
"the iterable, but may be implemented more efficiently."
msgstr ""
"バイト列のデータのリスト (またはイテラブル) をトランスポートに書き込みます。この振る舞いはイテラブルを yield して各要素で "
":meth:`write` を呼び出すことと等価ですが、より効率的な実装となる場合があります。"

#: ../../library/asyncio-protocol.rst:223
msgid ""
"Close the write end of the transport after flushing buffered data. Data may "
"still be received."
msgstr "バッファーされたデータをフラッシュした後トランスポートの送信側をクローズします。データは受信されます。"

#: ../../library/asyncio-protocol.rst:226
msgid ""
"This method can raise :exc:`NotImplementedError` if the transport (e.g. SSL)"
" doesn't support half-closes."
msgstr ""
"このメソッドはトランスポート (例えば SSL) がハーフクローズをサポートしていない場合 :exc:`NotImplementedError` "
"を送出します。"

#: ../../library/asyncio-protocol.rst:231
msgid "DatagramTransport"
msgstr "DatagramTransport"

#: ../../library/asyncio-protocol.rst:235
msgid ""
"Send the *data* bytes to the remote peer given by *addr* (a transport-"
"dependent target address).  If *addr* is :const:`None`, the data is sent to "
"the target address given on transport creation."
msgstr ""
"リモートピア *addr* (トランスポート依存の対象アドレス) にバイト列 *data* を送信します。*addr* が :const:`None` "
"の場合、データはトランスポートの作成時に指定された送信先に送られます。"

#: ../../library/asyncio-protocol.rst:251
msgid "BaseSubprocessTransport"
msgstr "BaseSubprocessTransport"

#: ../../library/asyncio-protocol.rst:257
msgid "Return the subprocess process id as an integer."
msgstr "サブプロセスのプロセス ID (整数) を返します。"

#: ../../library/asyncio-protocol.rst:261
msgid ""
"Return the transport for the communication pipe corresponding to the integer"
" file descriptor *fd*:"
msgstr "整数のファイル記述子 *fd* に該当する通信パイプのトランスポートを返します:"

#: ../../library/asyncio-protocol.rst:264
msgid ""
"``0``: readable streaming transport of the standard input (*stdin*), or "
":const:`None` if the subprocess was not created with ``stdin=PIPE``"
msgstr ""
"``0``: 標準入力 (*stdin*) の読み込み可能ストリーミングトランスポート。サブプロセスが ``stdin=PIPE`` "
"で作成されていない場合は :const:`None`"

#: ../../library/asyncio-protocol.rst:266
msgid ""
"``1``: writable streaming transport of the standard output (*stdout*), or "
":const:`None` if the subprocess was not created with ``stdout=PIPE``"
msgstr ""
"``1``: 標準出力 (*stdout*) の書き込み可能ストリーミングトランスポート。サブプロセスが ``stdout=PIPE`` "
"で作成されていない場合は :const:`None`"

#: ../../library/asyncio-protocol.rst:268
msgid ""
"``2``: writable streaming transport of the standard error (*stderr*), or "
":const:`None` if the subprocess was not created with ``stderr=PIPE``"
msgstr ""
"``2``: 標準エラー出力 (*stderr*) の書き込み可能ストリーミングトランスポート。サブプロセスが ``stderr=PIPE`` "
"で作成されていない場合は :const:`None`"

#: ../../library/asyncio-protocol.rst:270
msgid "other *fd*: :const:`None`"
msgstr "その他の *fd*: :const:`None`"

#: ../../library/asyncio-protocol.rst:274
msgid ""
"Return the subprocess returncode as an integer or :const:`None` if it hasn't"
" returned, similarly to the :attr:`subprocess.Popen.returncode` attribute."
msgstr ""
"サブプロセスのリターンコード (整数) を返します。リターンコードを持たない場合 :const:`None` "
"を返します。:attr:`subprocess.Popen.returncode` 属性と同じです。"

#: ../../library/asyncio-protocol.rst:280
msgid "Kill the subprocess, as in :meth:`subprocess.Popen.kill`."
msgstr ":meth:`subprocess.Popen.kill` と同様に、サブプロセスを kill します。"

#: ../../library/asyncio-protocol.rst:282
msgid ""
"On POSIX systems, the function sends SIGKILL to the subprocess. On Windows, "
"this method is an alias for :meth:`terminate`."
msgstr ""
"POSIX システムでは、この関数はサブプロセスに SIGKILL を送信します。Windows では、このメソッドは "
":meth:`terminate` の別名です。"

#: ../../library/asyncio-protocol.rst:287
msgid ""
"Send the *signal* number to the subprocess, as in "
":meth:`subprocess.Popen.send_signal`."
msgstr ""
"サブプロセスにシグナル *signal* を送信します。:meth:`subprocess.Popen.send_signal` と同じです。"

#: ../../library/asyncio-protocol.rst:292
msgid ""
"Ask the subprocess to stop, as in :meth:`subprocess.Popen.terminate`. This "
"method is an alias for the :meth:`close` method."
msgstr ""
"サブプロセスに停止を要求します。:meth:`subprocess.Popen.terminate` と同じです。このメソッドは "
":meth:`close` メソッドの別名です。"

#: ../../library/asyncio-protocol.rst:295
msgid ""
"On POSIX systems, this method sends SIGTERM to the subprocess. On Windows, "
"the Windows API function TerminateProcess() is called to stop the "
"subprocess."
msgstr ""
"POSIX システムでは、このメソッドはサブプロセスに SIGTERM を送信します。Windows では、Windows API 関数 "
"TerminateProcess() が呼び出されます。"

#: ../../library/asyncio-protocol.rst:301
msgid ""
"Ask the subprocess to stop by calling the :meth:`terminate` method if the "
"subprocess hasn't returned yet, and close transports of all pipes (*stdin*, "
"*stdout* and *stderr*)."
msgstr ""
"サブプロセスがまだ返していない場合、:meth:`terminate` メソッドの呼び出しによってサブプロセスに停止を要求し、全パイプ "
"(*stdin*、*stdout* および *stderr*) のトランスポートをクローズします。"

#: ../../library/asyncio-protocol.rst:309
msgid "Protocols"
msgstr "プロトコル"

#: ../../library/asyncio-protocol.rst:311
msgid ""
":mod:`asyncio` provides base classes that you can subclass to implement your"
" network protocols.  Those classes are used in conjunction with "
":ref:`transports <asyncio-transport>` (see below): the protocol parses "
"incoming data and asks for the writing of outgoing data, while the transport"
" is responsible for the actual I/O and buffering."
msgstr ""
":mod:`asyncio` はネットワークプロトコルの実装をサブクラス化する基底クラスを提供します。これらクラスは :ref:`トランスポート "
"<asyncio-transport>` と連動して使用されます: "
"プロトコルは入力データの解析および出力データの書き込みのための問い合わせを行い、トランスポートは実際の I/O とバッファリングに責任を持ちます。"

#: ../../library/asyncio-protocol.rst:317
msgid ""
"When subclassing a protocol class, it is recommended you override certain "
"methods.  Those methods are callbacks: they will be called by the transport "
"on certain events (for example when some data is received); you shouldn't "
"call them yourself, unless you are implementing a transport."
msgstr ""
"プロトコルクラスをサブクラス化するとき、いくつかのメソッドをオーバーライドすることを推奨します。これらメソッドはコールバックです: "
"いくつかのイベントが発生したとき (例えばデータの受信など) に呼び出されます; "
"あなたがトランスポートを実装する場合を除き、これらを直接呼び出すべきではありません。"

#: ../../library/asyncio-protocol.rst:323
msgid ""
"All callbacks have default implementations, which are empty.  Therefore, you"
" only need to implement the callbacks for the events in which you are "
"interested."
msgstr "すべてのコールバックはデフォルトで空の実装を持ちます。したがって、あなたが興味を持ったイベント用のコールバックのみ実装が必要になります。"

#: ../../library/asyncio-protocol.rst:329
msgid "Protocol classes"
msgstr "プロトコルクラス群"

#: ../../library/asyncio-protocol.rst:333
msgid ""
"The base class for implementing streaming protocols (for use with e.g. TCP "
"and SSL transports)."
msgstr "(例えば TCP や SSL トランスポートとともに使用する) ストリーミングプロトコルを実装する基底クラスです。"

#: ../../library/asyncio-protocol.rst:338
msgid ""
"A base class for implementing streaming protocols with manual control of the"
" receive buffer."
msgstr ""

#: ../../library/asyncio-protocol.rst:341
msgid ""
"**Important:** this has been added to asyncio in Python 3.7 *on a "
"provisional basis*!  Treat it as an experimental API that might be changed "
"or removed in Python 3.8."
msgstr ""

#: ../../library/asyncio-protocol.rst:348
msgid ""
"The base class for implementing datagram protocols (for use with e.g. UDP "
"transports)."
msgstr "(例えば UDP トランスポートともに使用する) データグラムプロトコルを実装する基底クラスです。"

#: ../../library/asyncio-protocol.rst:353
msgid ""
"The base class for implementing protocols communicating with child processes"
" (through a set of unidirectional pipes)."
msgstr "子プロセスと (一方向パイプを使用して) 通信するプロトコルを実装する基底クラスです。"

#: ../../library/asyncio-protocol.rst:358
msgid "Connection callbacks"
msgstr "コネクションコールバック"

#: ../../library/asyncio-protocol.rst:360
#: ../../library/asyncio-protocol.rst:537
msgid ""
"These callbacks may be called on :class:`Protocol`, "
":class:`DatagramProtocol` and :class:`SubprocessProtocol` instances:"
msgstr ""
"これらコールバックは :class:`Protocol`、:class:`DatagramProtocol` および "
":class:`SubprocessProtocol` インスタンスから呼び出される場合があります:"

#: ../../library/asyncio-protocol.rst:365
msgid "Called when a connection is made."
msgstr "コネクションが作成されたときに呼び出されます。"

#: ../../library/asyncio-protocol.rst:367
msgid ""
"The *transport* argument is the transport representing the connection.  You "
"are responsible for storing it somewhere (e.g. as an attribute) if you need "
"to."
msgstr ""
"引数 *transport* はコネクションを表すトランスポートです。必要であれば、それをどこに格納するか (例えば属性へ) を決めるのはあなたです。"

#: ../../library/asyncio-protocol.rst:373
msgid "Called when the connection is lost or closed."
msgstr "コネクションが失われた、あるいはクローズされたときに呼び出されます。"

#: ../../library/asyncio-protocol.rst:375
msgid ""
"The argument is either an exception object or :const:`None`. The latter "
"means a regular EOF is received, or the connection was aborted or closed by "
"this side of the connection."
msgstr ""
"引数は例外オブジェクトまたは :const:`None` になります。:const:`None` のとき、通常の EOF "
"が受信されたか、あるいはコネクションがこちら側から中止またはクローズされたことを意味します。"

#: ../../library/asyncio-protocol.rst:379
msgid ""
":meth:`~BaseProtocol.connection_made` and "
":meth:`~BaseProtocol.connection_lost` are called exactly once per successful"
" connection.  All other callbacks will be called between those two methods, "
"which allows for easier resource management in your protocol implementation."
msgstr ""
":meth:`~BaseProtocol.connection_made` および "
":meth:`~BaseProtocol.connection_lost` は接続が成功するたびに厳密に 1 "
"回呼び出されます。その他のすべてのコールバックはこれら 2 つのメソッドの間に呼び出され、あなたのプロトコルの実装内のリソース管理を容易に行えます。"

#: ../../library/asyncio-protocol.rst:384
msgid ""
"The following callbacks may be called only on :class:`SubprocessProtocol` "
"instances:"
msgstr "以下のコールバックを呼び出すのは :class:`SubprocessProtocol` インスタンスのみかもしれません:"

#: ../../library/asyncio-protocol.rst:389
msgid ""
"Called when the child process writes data into its stdout or stderr pipe. "
"*fd* is the integer file descriptor of the pipe.  *data* is a non-empty "
"bytes object containing the data."
msgstr ""
"子プロセスが自身の標準出力や標準エラー出力のパイプにデータを書き込んだときに呼び出されます。*fd* はパイプのファイル記述子 (整数) "
"になります。*data* はデータを含む空ではないバイト列になります。"

#: ../../library/asyncio-protocol.rst:395
msgid ""
"Called when one of the pipes communicating with the child process is closed."
"  *fd* is the integer file descriptor that was closed."
msgstr "子プロセスと通信するパイプの一つがクローズされると呼び出されます。*fd* はクローズされたファイル記述子 (整数) になります。"

#: ../../library/asyncio-protocol.rst:400
msgid "Called when the child process has exited."
msgstr "子プロセスが終了したときに呼び出されます。"

#: ../../library/asyncio-protocol.rst:404
msgid "Streaming protocols"
msgstr "ストリーミングプロトコル"

#: ../../library/asyncio-protocol.rst:406
msgid "The following callbacks are called on :class:`Protocol` instances:"
msgstr "以下のコールバックは :class:`Protocol` インスタンス上で呼び出されます:"

#: ../../library/asyncio-protocol.rst:410
msgid ""
"Called when some data is received.  *data* is a non-empty bytes object "
"containing the incoming data."
msgstr "データを受信したときに呼び出されます。*data* は受信したデータを含む空ではないバイト列オブジェクトになります。"

#: ../../library/asyncio-protocol.rst:414
msgid ""
"Whether the data is buffered, chunked or reassembled depends on the "
"transport.  In general, you shouldn't rely on specific semantics and instead"
" make your parsing generic and flexible enough.  However, data is always "
"received in the correct order."
msgstr ""
"トランスポートによって、データのバッファー、チャンクあるいは再構築のどれかが行われます。一般に、固有のセマンティックを信頼すべきではなく、代わりに全体的かつ十分に柔軟な解析を行うべきです。ただし、データは常に正しい順序で受信されます。"

#: ../../library/asyncio-protocol.rst:421
msgid ""
"Called when the other end signals it won't send any more data (for example "
"by calling :meth:`write_eof`, if the other end also uses asyncio)."
msgstr ""
"相手方が送信するデータがないことを伝えてきたとき (例えば相手方が asyncio を使用しており :meth:`write_eof` "
"を呼び出した場合) に呼び出されます。"

#: ../../library/asyncio-protocol.rst:425
msgid ""
"This method may return a false value (including ``None``), in which case the"
" transport will close itself.  Conversely, if this method returns a true "
"value, closing the transport is up to the protocol.  Since the default "
"implementation returns ``None``, it implicitly closes the connection."
msgstr ""
"このメソッドは偽値 (``None`` を含む) "
"を返すことがあり、その場合トランスポートは自身をクローズします。真値を返す場合、トランスポートはプロトコルによってクローズされます。デフォルトの実装では"
" ``None`` を返すため、コネクションは暗黙的にクローズされます。"

#: ../../library/asyncio-protocol.rst:431
msgid ""
"Some transports such as SSL don't support half-closed connections, in which "
"case returning true from this method will not prevent closing the "
"connection."
msgstr ""
"SSL "
"のような一部のトランスポートはハーフクローズ接続をサポートしていません。その場合このメソッドが真値を返すとコネクションのクローズを回避できません。"

#: ../../library/asyncio-protocol.rst:435
msgid ""
":meth:`data_received` can be called an arbitrary number of times during a "
"connection.  However, :meth:`eof_received` is called at most once and, if "
"called, :meth:`data_received` won't be called after it."
msgstr ""
"接続中、:meth:`data_received` は複数回呼び出されえます。:meth:`eof_received` が呼び出されるのは 1 回で、1"
" 度呼び出されると、その後 :meth:`data_received` が呼び出されることはありません。"

#: ../../library/asyncio-protocol.rst:439
#: ../../library/asyncio-protocol.rst:500
msgid "State machine:"
msgstr "ステートマシン:"

#: ../../library/asyncio-protocol.rst:450
msgid "Streaming protocols with manual receive buffer control"
msgstr ""

#: ../../library/asyncio-protocol.rst:452
msgid ""
"**Important:** :class:`BufferedProtocol` has been added to asyncio in Python"
" 3.7 *on a provisional basis*!  Consider it as an experimental API that "
"might be changed or removed in Python 3.8."
msgstr ""

#: ../../library/asyncio-protocol.rst:458
msgid ""
"Event methods, such as :meth:`AbstractEventLoop.create_server` and "
":meth:`AbstractEventLoop.create_connection`, accept factories that return "
"protocols that implement this interface."
msgstr ""

#: ../../library/asyncio-protocol.rst:462
msgid ""
"The idea of BufferedProtocol is that it allows to manually allocate and "
"control the receive buffer.  Event loops can then use the buffer provided by"
" the protocol to avoid unnecessary data copies.  This can result in "
"noticeable performance improvement for protocols that receive big amounts of"
" data.  Sophisticated protocols implementations can allocate the buffer only"
" once at creation time."
msgstr ""

#: ../../library/asyncio-protocol.rst:469
msgid ""
"The following callbacks are called on :class:`BufferedProtocol` instances:"
msgstr ""

#: ../../library/asyncio-protocol.rst:474
msgid "Called to allocate a new receive buffer."
msgstr ""

#: ../../library/asyncio-protocol.rst:476
msgid ""
"*sizehint* is a recommended minimal size for the returned buffer.  It is "
"acceptable to return smaller or bigger buffers than what *sizehint* "
"suggests.  When set to -1, the buffer size can be arbitrary. It is an error "
"to return a zero-sized buffer."
msgstr ""

#: ../../library/asyncio-protocol.rst:481
msgid ""
"Must return an object that implements the :ref:`buffer protocol "
"<bufferobjects>`."
msgstr ""

#: ../../library/asyncio-protocol.rst:486
msgid "Called when the buffer was updated with the received data."
msgstr ""

#: ../../library/asyncio-protocol.rst:488
msgid "*nbytes* is the total number of bytes that were written to the buffer."
msgstr ""

#: ../../library/asyncio-protocol.rst:492
msgid "See the documentation of the :meth:`Protocol.eof_received` method."
msgstr ""

#: ../../library/asyncio-protocol.rst:495
msgid ""
":meth:`get_buffer` can be called an arbitrary number of times during a "
"connection.  However, :meth:`eof_received` is called at most once and, if "
"called, :meth:`get_buffer` and :meth:`buffer_updated` won't be called after "
"it."
msgstr ""

#: ../../library/asyncio-protocol.rst:513
msgid "Datagram protocols"
msgstr "データグラムプロトコル"

#: ../../library/asyncio-protocol.rst:515
msgid ""
"The following callbacks are called on :class:`DatagramProtocol` instances."
msgstr "以下のコールバックは :class:`DatagramProtocol` インスタンス上で呼び出されます。"

#: ../../library/asyncio-protocol.rst:519
msgid ""
"Called when a datagram is received.  *data* is a bytes object containing the"
" incoming data.  *addr* is the address of the peer sending the data; the "
"exact format depends on the transport."
msgstr ""
"データグラムを受信したときに呼び出されます。*data* は受信データを含むバイトオブジェクトです。*addr* はデータを送信するピアのアドレスです;"
" 正確な形式はトランスポートに依存します。"

#: ../../library/asyncio-protocol.rst:525
msgid ""
"Called when a previous send or receive operation raises an :class:`OSError`."
"  *exc* is the :class:`OSError` instance."
msgstr ""
"直前の送信あるいは受信が :class:`OSError` を送出したときに呼び出されます。*exc* は :class:`OSError` "
"のインスタンスになります。"

#: ../../library/asyncio-protocol.rst:528
msgid ""
"This method is called in rare conditions, when the transport (e.g. UDP) "
"detects that a datagram couldn't be delivered to its recipient. In many "
"conditions though, undeliverable datagrams will be silently dropped."
msgstr ""
"このメソッドが呼ばれるのは、トランスポート (UDP など) "
"がデータグラムを受信側に配信できなかったことが検出されたなどの、まれな場合においてのみです。ほとんどの場合、データグラムが配信できなければそのまま通知されることなく破棄されます。"

#: ../../library/asyncio-protocol.rst:535
msgid "Flow control callbacks"
msgstr "フロー制御コールバック"

#: ../../library/asyncio-protocol.rst:542
msgid "Called when the transport's buffer goes over the high-water mark."
msgstr "トランスポートのバッファーサイズが最高水位点 (High-Water Mark) を超えたときに呼び出されます。"

#: ../../library/asyncio-protocol.rst:546
msgid "Called when the transport's buffer drains below the low-water mark."
msgstr "トランスポートのバッファーサイズが最低水位点 (Low-Water Mark) に達したきに呼び出されます。"

#: ../../library/asyncio-protocol.rst:549
msgid ""
":meth:`pause_writing` and :meth:`resume_writing` calls are paired -- "
":meth:`pause_writing` is called once when the buffer goes strictly over the "
"high-water mark (even if subsequent writes increases the buffer size even "
"more), and eventually :meth:`resume_writing` is called once when the buffer "
"size reaches the low-water mark."
msgstr ""
":meth:`pause_writing` および :meth:`resume_writing` の呼び出しは対になります。-- "
":meth:`pause_writing` はバッファーが完全に最高水位点を超えたとき (後続の書き込みがさらにバッファーサイズを増やすとしても) 1 "
"度呼び出され、バッファーサイズが最終的に最低水位点に達したときに :meth:`resume_writing` が 1 度呼び出されます。"

#: ../../library/asyncio-protocol.rst:556
msgid ""
"If the buffer size equals the high-water mark, :meth:`pause_writing` is not "
"called -- it must go strictly over. Conversely, :meth:`resume_writing` is "
"called when the buffer size is equal or lower than the low-water mark.  "
"These end conditions are important to ensure that things go as expected when"
" either mark is zero."
msgstr ""
"バッファーサイズが最高水位点と等しくなった時点では :meth:`pause_writing` は呼び出されません -- "
"完全に超えなければなりません。対して、バッファーサイズが最低水位点と等しくなったときは :meth:`resume_writing` "
"は呼び出されます。これら端末条件は各点がゼロになったとき予定通りに動作するかどうか確認するために重要です。"

#: ../../library/asyncio-protocol.rst:564
msgid ""
"On BSD systems (OS X, FreeBSD, etc.) flow control is not supported for "
":class:`DatagramProtocol`, because send failures caused by writing too many "
"packets cannot be detected easily.  The socket always appears 'ready' and "
"excess packets are dropped; an :class:`OSError` with errno set to "
":const:`errno.ENOBUFS` may or may not be raised; if it is raised, it will be"
" reported to :meth:`DatagramProtocol.error_received` but otherwise ignored."
msgstr ""
"BSD システム (OS X、FreeBSD など) では、:class:`DatagramProtocol` "
"でのフロー制御は、大量のパケット送信による送信失敗を検知するのが容易ではないためサポートされていません。ソケットは常に '待機状態' "
"のように見え、超過分のパケットは破棄されます; エラー番号 :const:`errno.ENOBUFS` が設定された :class:`OSError`"
" が送出されるときもあればされないときもあります; 送出された場合、:meth:`DatagramProtocol.error_received` "
"に通知されますが、送出されないと無視されます。"

#: ../../library/asyncio-protocol.rst:574
msgid "Coroutines and protocols"
msgstr "コルーチンとプロトコル"

#: ../../library/asyncio-protocol.rst:576
msgid ""
"Coroutines can be scheduled in a protocol method using "
":func:`ensure_future`, but there is no guarantee made about the execution "
"order.  Protocols are not aware of coroutines created in protocol methods "
"and so will not wait for them."
msgstr ""
"コルーチンはプロトコルメソッドで :func:`ensure_future` "
"を使用してスケジュールされることがありますが、それは実行順を保証するものではありません。プロトコルはプロトコルメソッド内で作成されたコルーチンを検知しないため、それらを待機しません。"

#: ../../library/asyncio-protocol.rst:580
msgid ""
"To have a reliable execution order, use :ref:`stream objects <asyncio-"
"streams>` in a coroutine with ``await``. For example, the "
":meth:`StreamWriter.drain` coroutine can be used to wait until the write "
"buffer is flushed."
msgstr ""

#: ../../library/asyncio-protocol.rst:587
msgid "Protocol examples"
msgstr "プロトコルの例"

#: ../../library/asyncio-protocol.rst:592
msgid "TCP echo client protocol"
msgstr "TCP Echo クライアントプロトコル"

#: ../../library/asyncio-protocol.rst:594
msgid ""
"TCP echo client  using the :meth:`AbstractEventLoop.create_connection` "
"method, send data and wait until the connection is closed::"
msgstr ""
":meth:`AbstractEventLoop.create_connection` メソッドを使用した TCP Echo "
"クライアントで、データを送信しコネクションがクローズされるまで待機します。"

#: ../../library/asyncio-protocol.rst:624
msgid ""
"The event loop is running twice. The "
":meth:`~AbstractEventLoop.run_until_complete` method is preferred in this "
"short example to raise an exception if the server is not listening, instead "
"of having to write a short coroutine to handle the exception and stop the "
"running loop. At :meth:`~AbstractEventLoop.run_until_complete` exit, the "
"loop is no longer running, so there is no need to stop the loop in case of "
"an error."
msgstr ""
"この例ではイベントループを 2 個実行しています。:meth:`~AbstractEventLoop.run_until_complete` "
"メソッドはサーバが待ち受け状態にないときに例外を送出するためのもので、通常作成しなければならない例外の送出やループの停止などを行うための短いコルーチンの代用になります。:meth:`~AbstractEventLoop.run_until_complete`"
" の終了時、ループの実行は終了しているので、エラー発生時にループを停止する必要はありません。"

#: ../../library/asyncio-protocol.rst:633
msgid ""
"The :ref:`TCP echo client using streams <asyncio-tcp-echo-client-streams>` "
"example uses the :func:`asyncio.open_connection` function."
msgstr ""
":ref:`ストリームを使った TCP Echo クライアント <asyncio-tcp-echo-client-streams>` の例では "
":func:`asyncio.open_connection` 関数を使用しています。"

#: ../../library/asyncio-protocol.rst:640
msgid "TCP echo server protocol"
msgstr "TCP Echo サーバープロトコル"

#: ../../library/asyncio-protocol.rst:642
msgid ""
"TCP echo server using the :meth:`AbstractEventLoop.create_server` method, "
"send back received data and close the connection::"
msgstr ""
":meth:`AbstractEventLoop.create_server` メソッドを使用した TCP Echo "
"サーバーで、受信したデータを返信しコネクションをクローズします。"

#: ../../library/asyncio-protocol.rst:680
msgid ""
":meth:`Transport.close` can be called immediately after "
":meth:`WriteTransport.write` even if data are not sent yet on the socket: "
"both methods are asynchronous. ``await`` is not needed because these "
"transport methods are not coroutines."
msgstr ""

#: ../../library/asyncio-protocol.rst:687
msgid ""
"The :ref:`TCP echo server using streams <asyncio-tcp-echo-server-streams>` "
"example uses the :func:`asyncio.start_server` function."
msgstr ""
":ref:`ストリームを使った TCP Echo サーバー <asyncio-tcp-echo-server-streams>` の例では "
":func:`asyncio.start_server` 関数を使用しています。"

#: ../../library/asyncio-protocol.rst:694
msgid "UDP echo client protocol"
msgstr "UDP Echo クライアントプロトコル"

#: ../../library/asyncio-protocol.rst:696
msgid ""
"UDP echo client using the :meth:`AbstractEventLoop.create_datagram_endpoint`"
" method, send data and close the transport when we received the answer::"
msgstr ""
":meth:`AbstractEventLoop.create_datagram_endpoint` メソッドを使用する UDP Echo "
"クライアントで、データを送信し応答を受信するとトランスポートをクローズします。"

#: ../../library/asyncio-protocol.rst:740
msgid "UDP echo server protocol"
msgstr "UDP Echo サーバープロトコル"

#: ../../library/asyncio-protocol.rst:742
msgid ""
"UDP echo server using the :meth:`AbstractEventLoop.create_datagram_endpoint`"
" method, send back received data::"
msgstr ""
":meth:`AbstractEventLoop.create_datagram_endpoint` メソッドを使用しする UDP Echo "
"サーバーで、受信したデータを返送します。"

#: ../../library/asyncio-protocol.rst:776
msgid "Register an open socket to wait for data using a protocol"
msgstr "プロトコルを使ってデータを待つオープンソケットの登録"

#: ../../library/asyncio-protocol.rst:778
msgid ""
"Wait until a socket receives data using the "
":meth:`AbstractEventLoop.create_connection` method with a protocol, and then"
" close the event loop ::"
msgstr ""
"プロトコルと :meth:`AbstractEventLoop.create_connection` "
"メソッドを使用してソケットがデータを受信するまで待機し、受信後イベントループをクローズします。"

#: ../../library/asyncio-protocol.rst:822
msgid ""
"The :ref:`watch a file descriptor for read events <asyncio-watch-read-"
"event>` example uses the low-level :meth:`AbstractEventLoop.add_reader` "
"method to register the file descriptor of a socket."
msgstr ""
":ref:`読み込みイベント用のファイル記述子の監視 <asyncio-watch-read-event>` "
"の例では、ソケットのファイル記述子を登録するのに低水準の :meth:`AbstractEventLoop.add_reader` "
"メソッドを使用しています。"

#: ../../library/asyncio-protocol.rst:827
msgid ""
"The :ref:`register an open socket to wait for data using streams <asyncio-"
"register-socket-streams>` example uses high-level streams created by the "
":func:`open_connection` function in a coroutine."
msgstr ""
":ref:`ストリームを使ってデータを待つオープンソケットの登録 <asyncio-register-socket-streams>` "
"の例ではコルーチンの :func:`open_connection` 関数によって作成された高水準ストリームを使用しています。"