asyncore.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 1990-2021, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
# 秘湯 <xwhhsprings@gmail.com>, 2016
msgid ""
msgstr ""
"Project-Id-Version: Python 2.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2021-01-01 01:01+0900\n"
"PO-Revision-Date: 2019-09-01 05:18+0000\n"
"Last-Translator: tomo\n"
"Language-Team: Japanese (http://www.transifex.com/python-doc/python-27/"
"language/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/asyncore.rst:2
msgid ":mod:`asyncore` --- Asynchronous socket handler"
msgstr ":mod:`asyncore` --- 非同期ソケットハンドラ"

#: ../../library/asyncore.rst:12
msgid "**Source code:** :source:`Lib/asyncore.py`"
msgstr "**ソースコード:** :source:`Lib/asyncore.py`"

#: ../../library/asyncore.rst:16
msgid ""
"This module provides the basic infrastructure for writing asynchronous  "
"socket service clients and servers."
msgstr ""
"このモジュールは、非同期ソケットサービスのクライアント・サーバを開発するため"
"の基盤として使われます。"

#: ../../library/asyncore.rst:19
msgid ""
"There are only two ways to have a program on a single processor do  \"more "
"than one thing at a time.\" Multi-threaded programming is the  simplest and "
"most popular way to do it, but there is another very different technique, "
"that lets you have nearly all the advantages of  multi-threading, without "
"actually using multiple threads.  It's really  only practical if your "
"program is largely I/O bound.  If your program is processor bound, then pre-"
"emptive scheduled threads are probably what you really need.  Network "
"servers are rarely processor bound, however."
msgstr ""
"CPUが一つしかない場合、プログラムが\"二つのことを同時に\"実行する方法は二つし"
"かありません。もっとも簡単で一般的なのはマルチスレッドを利用する方法ですが、"
"これとはまったく異なるテクニックで、一つのスレッドだけでマルチスレッドと同じ"
"ような効果を得られるテクニックがあります。このテクニックはI/O処理が中心である"
"場合にのみ有効で、CPU負荷の高いプログラムでは効果が無く、この場合にはプリエン"
"プティブなスケジューリングが可能なスレッドが有効でしょう。しかし、多くの場"
"合、ネットワークサーバではCPU負荷よりはIO負荷が問題となります。"

#: ../../library/asyncore.rst:28
msgid ""
"If your operating system supports the :c:func:`select` system call in its I/"
"O library (and nearly all do), then you can use it to juggle multiple "
"communication channels at once; doing other work while your I/O is taking "
"place in the \"background.\"  Although this strategy can seem strange and "
"complex, especially at first, it is in many ways easier to understand and "
"control than multi-threaded programming.  The :mod:`asyncore` module solves "
"many of the difficult problems for you, making the task of building "
"sophisticated high-performance network servers and clients a snap.  For "
"\"conversational\" applications and protocols the companion :mod:`asynchat` "
"module is invaluable."
msgstr ""
"もしOSのI/Oライブラリがシステムコール :c:func:`select` をサポートしている場合"
"（ほとんどの場合はサポートされている）、I/O処理は\"バックグラウンド\"で実行"
"し、その間に他の処理を実行すれば、複数の通信チャネルを同時にこなすことができ"
"ます。一見、この戦略は奇妙で複雑に思えるかもしれませんが、いろいろな面でマル"
"チスレッドよりも理解しやすく、制御も容易です。 :mod:`asyncore` は多くの複雑な"
"問題を解決済みなので、洗練され、パフォーマンスにも優れたネットワークサーバと"
"クライアントを簡単に開発することができます。とくに、 :mod:`asynchat` のよう"
"な、対話型のアプリケーションやプロトコルには非常に有効でしょう。"

#: ../../library/asyncore.rst:39
msgid ""
"The basic idea behind both modules is to create one or more network "
"*channels*, instances of class :class:`asyncore.dispatcher` and :class:"
"`asynchat.async_chat`.  Creating the channels adds them to a global map, "
"used by the :func:`loop` function if you do not provide it with your own "
"*map*."
msgstr ""
"基本的には、この二つのモジュールを使う場合は一つ以上のネットワーク *チャネル"
"* を :class:`asyncore.dispatcher` クラス、または :class:`asynchat."
"async_chat` のインスタンスとして作成します。作成されたチャネルはグローバル"
"マップに登録され、 :func:`loop` 関数で参照されます。 :func:`loop` には、専用"
"の *マップ* を渡す事も可能です。"

#: ../../library/asyncore.rst:45
msgid ""
"Once the initial channel(s) is(are) created, calling the :func:`loop` "
"function activates channel service, which continues until the last channel "
"(including any that have been added to the map during asynchronous service) "
"is closed."
msgstr ""
"チャネルを生成後、 :func:`loop` を呼び出すとチャネル処理が開始し、最後のチャ"
"ネル（非同期処理中にマップに追加されたチャネルを含む）が閉じるまで継続しま"
"す。"

#: ../../library/asyncore.rst:52
msgid ""
"Enter a polling loop that terminates after count passes or all open channels "
"have been closed.  All arguments are optional.  The *count* parameter "
"defaults to ``None``, resulting in the loop terminating only when all "
"channels have been closed.  The *timeout* argument sets the timeout "
"parameter for the appropriate :func:`~select.select` or :func:`~select.poll` "
"call, measured in seconds; the default is 30 seconds.  The *use_poll* "
"parameter, if true, indicates that :func:`~select.poll` should be used in "
"preference to :func:`~select.select` (the default is ``False``)."
msgstr ""
"ポーリングループを開始し、count 回が過ぎるか、全てのオープン済みチャネルがク"
"ローズされた場合のみ終了します。全ての引数はオプションです。引数 *count* のデ"
"フォルト値は ``None`` で、ループは全てのチャネルがクローズされた場合のみ終了"
"します。引数 *timeout* は :func:`~select.select` または :func:`~select.poll` "
"の引数 timeout として渡され、秒単位で指定します。デフォルト値は 30 秒です。引"
"数 *use_poll* が真の場合、 :func:`~select.select` ではなく :func:`~select."
"poll` が使われます (デフォルト値は ``False`` です)。"

#: ../../library/asyncore.rst:61
msgid ""
"The *map* parameter is a dictionary whose items are the channels to watch. "
"As channels are closed they are deleted from their map.  If *map* is "
"omitted, a global map is used. Channels (instances of :class:`asyncore."
"dispatcher`, :class:`asynchat.async_chat` and subclasses thereof) can freely "
"be mixed in the map."
msgstr ""
"引数 *map* には、監視するチャネルをアイテムとして格納した辞書を指定します。"
"チャネルがクローズされた時に *map* からそのチャネルが削除されます。 *map* が"
"省略された場合、グローバルなマップが使用されます。チャネル (:class:`asyncore."
"dispatcher`, :class:`asynchat.async_chat` とそのサブクラス) は自由に混ぜて "
"map に入れることができます。"

#: ../../library/asyncore.rst:70
msgid ""
"The :class:`dispatcher` class is a thin wrapper around a low-level socket "
"object. To make it more useful, it has a few methods for event-handling "
"which are called from the asynchronous loop.   Otherwise, it can be treated "
"as a normal non-blocking socket object."
msgstr ""
":class:`dispatcher` クラスは、低レベルソケットオブジェクトの薄いラッパーで"
"す。便宜上、非同期ループから呼び出されるイベント処理メソッドを追加しています"
"が、これ以外の点では、non-blockingなソケットと同様です。"

#: ../../library/asyncore.rst:75
msgid ""
"The firing of low-level events at certain times or in certain connection "
"states tells the asynchronous loop that certain higher-level events have "
"taken place.  For example, if we have asked for a socket to connect to "
"another host, we know that the connection has been made when the socket "
"becomes writable for the first time (at this point you know that you may "
"write to it with the expectation of success).  The implied higher-level "
"events are:"
msgstr ""
"非同期ループ内で低レベルイベントが発生した場合、発生のタイミングやコネクショ"
"ンの状態から特定の高レベルイベントへと置き換えることができます。例えばソケッ"
"トを他のホストに接続する場合、最初の書き込み可能イベントが発生すれば接続が完"
"了した事が分かります(この時点で、ソケットへの書き込みは成功すると考えられ"
"る)。このように判定できる高レベルイベントを以下に示します:"

#: ../../library/asyncore.rst:84
msgid "Event"
msgstr "Event"

#: ../../library/asyncore.rst:84
msgid "Description"
msgstr "説明"

#: ../../library/asyncore.rst:86
msgid "``handle_connect()``"
msgstr "``handle_connect()``"

#: ../../library/asyncore.rst:86
msgid "Implied by the first read or write event"
msgstr "最初にreadもしくはwriteイベントが発生した時"

#: ../../library/asyncore.rst:89
msgid "``handle_close()``"
msgstr "``handle_close()``"

#: ../../library/asyncore.rst:89
msgid "Implied by a read event with no data available"
msgstr "読み込み可能なデータなしでreadイベントが発生した時"

#: ../../library/asyncore.rst:92
msgid "``handle_accept()``"
msgstr "``handle_accepted()``"

#: ../../library/asyncore.rst:92
msgid "Implied by a read event on a listening socket"
msgstr "listen中のソケットでreadイベントが発生した時"

#: ../../library/asyncore.rst:96
msgid ""
"During asynchronous processing, each mapped channel's :meth:`readable` and :"
"meth:`writable` methods are used to determine whether the channel's socket "
"should be added to the list of channels :c:func:`select`\\ ed or :c:func:"
"`poll`\\ ed for read and write events."
msgstr ""
"非同期処理中、マップに登録されたチャネルの :meth:`readable` メソッドと :meth:"
"`writable` メソッドが呼び出され、 :c:func:`select` か :c:func:`poll` でread/"
"writeイベントを検出するリストに登録するか否かを判定します。"

#: ../../library/asyncore.rst:101
msgid ""
"Thus, the set of channel events is larger than the basic socket events.  The "
"full set of methods that can be overridden in your subclass follows:"
msgstr ""
"このようにして、チャネルでは低レベルなソケットイベントの種類より多くの種類の"
"イベントを検出する事ができます。以下にあげるイベントは、サブクラスでオーバラ"
"イドすることが可能です:"

#: ../../library/asyncore.rst:107
msgid ""
"Called when the asynchronous loop detects that a :meth:`read` call on the "
"channel's socket will succeed."
msgstr ""
"非同期ループで、チャネルのソケットの :meth:`read` メソッドの呼び出しが成功し"
"た時に呼び出されます。"

#: ../../library/asyncore.rst:113
msgid ""
"Called when the asynchronous loop detects that a writable socket can be "
"written.  Often this method will implement the necessary buffering for "
"performance.  For example::"
msgstr ""
"非同期ループで、書き込み可能ソケットが実際に書き込み可能になった時に呼び出さ"
"れる。このメソッドは、パフォーマンスの向上のためバッファリングを行う場合など"
"に利用できます。例::"

#: ../../library/asyncore.rst:124
msgid ""
"Called when there is out of band (OOB) data for a socket connection.  This "
"will almost never happen, as OOB is tenuously supported and rarely used."
msgstr ""
"out of band (OOB)データが検出された時に呼び出されます。OOBはあまりサポートさ"
"れておらず、また滅多に使われないので、:meth:`handle_expt` が呼び出されること"
"はほとんどありません。"

#: ../../library/asyncore.rst:130
msgid ""
"Called when the active opener's socket actually makes a connection.  Might "
"send a \"welcome\" banner, or initiate a protocol negotiation with the "
"remote endpoint, for example."
msgstr ""
"ソケットの接続が確立した時に呼び出されます。\"welcome\"バナーの送信、プロトコ"
"ルネゴシエーションの初期化などを行います。"

#: ../../library/asyncore.rst:137
msgid "Called when the socket is closed."
msgstr "ソケットが閉じた時に呼び出されます。"

#: ../../library/asyncore.rst:142
msgid ""
"Called when an exception is raised and not otherwise handled.  The default "
"version prints a condensed traceback."
msgstr ""
"捕捉されない例外が発生した時に呼び出されます。デフォルトでは、短縮したトレー"
"スバック情報が出力されます。"

#: ../../library/asyncore.rst:148
msgid ""
"Called on listening channels (passive openers) when a connection can be "
"established with a new remote endpoint that has issued a :meth:`connect` "
"call for the local endpoint."
msgstr ""
"listen 中のチャネル (受動的にオープンしたもの) がリモートホストからの :meth:"
"`connect` で接続され、接続が確立した時に呼び出されます。"

#: ../../library/asyncore.rst:155
msgid ""
"Called each time around the asynchronous loop to determine whether a "
"channel's socket should be added to the list on which read events can "
"occur.  The default method simply returns ``True``, indicating that by "
"default, all channels will be interested in read events."
msgstr ""
"非同期ループ中に呼び出され、readイベントの監視リストに加えるか否かを決定しま"
"す。デフォルトのメソッドでは ``True`` を返し、readイベントの発生を監視しま"
"す。"

#: ../../library/asyncore.rst:163
msgid ""
"Called each time around the asynchronous loop to determine whether a "
"channel's socket should be added to the list on which write events can "
"occur.  The default method simply returns ``True``, indicating that by "
"default, all channels will be interested in write events."
msgstr ""
"非同期ループ中に呼び出され、writeイベントの監視リストに加えるか否かを決定しま"
"す。デフォルトのメソッドでは ``True`` を返し、writeイベントの発生を監視しま"
"す。"

#: ../../library/asyncore.rst:169
msgid ""
"In addition, each channel delegates or extends many of the socket methods. "
"Most of these are nearly identical to their socket partners."
msgstr ""
"さらに、チャネルにはソケットのメソッドとほぼ同じメソッドがあり、チャネルはソ"
"ケットのメソッドの多くを委譲・拡張しており、ソケットとほぼ同じメソッドを持っ"
"ています。"

#: ../../library/asyncore.rst:175
msgid ""
"This is identical to the creation of a normal socket, and will use the same "
"options for creation.  Refer to the :mod:`socket` documentation for "
"information on creating sockets."
msgstr ""
"引数も含め、通常のソケット生成と同じ。 :mod:`socket` モジュールを参照のこと。"

#: ../../library/asyncore.rst:182
msgid ""
"As with the normal socket object, *address* is a tuple with the first "
"element the host to connect to, and the second the port number."
msgstr ""
"通常のソケットオブジェクトと同様、*address* には一番目の値が接続先ホスト、\\ "
"2番目の値がポート番号であるタプルを指定します。"

#: ../../library/asyncore.rst:188
msgid "Send *data* to the remote end-point of the socket."
msgstr "リモート側の端点に *data* を送出します。"

#: ../../library/asyncore.rst:193
msgid ""
"Read at most *buffer_size* bytes from the socket's remote end-point.  An "
"empty string implies that the channel has been closed from the other end."
msgstr ""
"リモート側の端点より、最大 *buffer_size* バイトのデータを読み込みます。長さ0"
"の文字列が返ってきた場合、チャネルはリモートから切断された事を示します。"

#: ../../library/asyncore.rst:196
msgid ""
"Note that :meth:`recv` may raise :exc:`socket.error` with :data:`~errno."
"EAGAIN` or :data:`~errno.EWOULDBLOCK`, even though :func:`select.select` or :"
"func:`select.poll` has reported the socket ready for reading."
msgstr ""
":meth:`recv` が :data:`~errno.EAGAIN` または :data:`~errno.EWOULDBLOCK` によ"
"る :exc:`socket.error` を起こしうることに注意してください。 :func:`select."
"select` や :func:`select.poll` が、ソケットが読み込み出来る状態にあると報告し"
"たとしてもです。"

#: ../../library/asyncore.rst:204
msgid ""
"Listen for connections made to the socket.  The *backlog* argument specifies "
"the maximum number of queued connections and should be at least 1; the "
"maximum value is system-dependent (usually 5)."
msgstr ""
"ソケットへの接続を待つ。引数 *backlog* は、キューイングできるコネクションの最"
"大数を指定します(1以上)。最大数はシステムに依存でします（通常は5)。"

#: ../../library/asyncore.rst:211
msgid ""
"Bind the socket to *address*.  The socket must not already be bound.  (The "
"format of *address* depends on the address family --- refer to the :mod:"
"`socket` documentation for more information.)  To mark the socket as re-"
"usable (setting the :const:`SO_REUSEADDR` option), call the :class:"
"`dispatcher` object's :meth:`set_reuse_addr` method."
msgstr ""
"ソケットを *address* にバインドします。ソケットはバインド済みであってはなりま"
"せん。 (*address* の形式は、アドレスファミリに依存します。 :mod:`socket` モ"
"ジュールを参照のこと。) ソケットを再利用可能にする (:const:`SO_REUSEADDR` オ"
"プションを設定する) には、 :class:`dispatcher` オブジェクトの :meth:"
"`set_reuse_addr` メソッドを呼び出してください。"

#: ../../library/asyncore.rst:220
msgid ""
"Accept a connection.  The socket must be bound to an address and listening "
"for connections.  The return value can be either ``None`` or a pair ``(conn, "
"address)`` where *conn* is a *new* socket object usable to send and receive "
"data on the connection, and *address* is the address bound to the socket on "
"the other end of the connection. When ``None`` is returned it means the "
"connection didn't take place, in which case the server should just ignore "
"this event and keep listening for further incoming connections."
msgstr ""
"接続を受け入れます。ソケットはアドレスにバインド済みであり、:meth:`listen` で"
"接続待ち状態でなければなりません。戻り値は ``None`` か ``(conn, address)`` の"
"ペアで、*conn* はデータの送受信を行う **新しい** ソケットオブジェクト、"
"*address* は接続先ソケットがバインドされているアドレスです。``None`` が返され"
"た場合、接続が起こらなかったことを意味します。その場合、サーバーはこのイベン"
"トを無視して後続の接続を待ち続けるべきです。"

#: ../../library/asyncore.rst:232
msgid ""
"Close the socket.  All future operations on the socket object will fail. The "
"remote end-point will receive no more data (after queued data is flushed).  "
"Sockets are automatically closed when they are garbage-collected."
msgstr ""
"ソケットをクローズします。以降の全ての操作は失敗します。リモート端点では、"
"キューに溜まったデータ以外、これ以降のデータ受信は行えません。ソケットはガ"
"ベージコレクト時に自動的にクローズされます。"

#: ../../library/asyncore.rst:239
msgid ""
"A :class:`dispatcher` subclass which adds simple buffered output capability, "
"useful for simple clients. For more sophisticated usage use :class:`asynchat."
"async_chat`."
msgstr ""
":class:`dispatcher` のサブクラスで、シンプルなバッファされた出力を持ちます。"
"シンプルなクライアントプログラムに適しています。もっと高レベルな場合には :"
"class:`asynchat.async_chat` を利用してください。"

#: ../../library/asyncore.rst:245
msgid ""
"A file_dispatcher takes a file descriptor or file object along with an "
"optional map argument and wraps it for use with the :c:func:`poll` or :c:"
"func:`loop` functions.  If provided a file object or anything with a :c:func:"
"`fileno` method, that method will be called and passed to the :class:"
"`file_wrapper` constructor.  Availability: UNIX."
msgstr ""
"file_dispatcher はファイルデスクリプタか :term:`ファイルオブジェクト <file "
"object>` とオプションとして map を引数にとって、 :c:func:`poll` か :c:func:"
"`loop` 関数で利用できるようにラップします。与えられたファイルオブジェクトなど"
"が :c:func:`fileno` メソッドを持っているとき、そのメソッドが呼び出されて戻り"
"値が :class:`file_wrapper` のコンストラクタに渡されます。利用できるプラット"
"フォーム: UNIX。"

#: ../../library/asyncore.rst:253
msgid ""
"A file_wrapper takes an integer file descriptor and calls :func:`os.dup` to "
"duplicate the handle so that the original handle may be closed independently "
"of the file_wrapper.  This class implements sufficient methods to emulate a "
"socket for use by the :class:`file_dispatcher` class.  Availability: UNIX."
msgstr ""
"file_wrapper は整数のファイルデスクリプタを受け取って :func:`os.dup` を呼び出"
"してハンドルを複製するので、元のハンドルは file_wrapper と独立して\\ close さ"
"れます。このクラスは :class:`file_dispatcher` クラスが使うために必要なソケッ"
"トをエミュレートするメソッドを実装しています。利用できるプラットフォーム: "
"UNIX。"

#: ../../library/asyncore.rst:262
msgid "asyncore Example basic HTTP client"
msgstr "asyncoreの例: 簡単なHTTPクライアント"

#: ../../library/asyncore.rst:264
msgid ""
"Here is a very basic HTTP client that uses the :class:`dispatcher` class to "
"implement its socket handling::"
msgstr ""
"基本的なサンプルとして、以下に非常に単純なHTTPクライアントを示します。この"
"HTTPクライアントは :class:`dispatcher` クラスでソケットを利用しています::"

#: ../../library/asyncore.rst:300
msgid "asyncore Example basic echo server"
msgstr "基本的な echo サーバーの例"

#: ../../library/asyncore.rst:302
msgid ""
"Here is a basic echo server that uses the :class:`dispatcher` class to "
"accept connections and dispatches the incoming connections to a handler::"
msgstr ""
"この例の基本的な echoサーバーは、 :class:`dispatcher` を利用して接続を受けつ"
"け、接続をハンドラーにディスパッチします::"