asyncio-sync.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-08-25 08:59+0900\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: Nakamura Masahito <randomstep@gmail.com>, 2018\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-sync.rst:5
msgid "Synchronization primitives"
msgstr "同期プリミティブ"

#: ../../library/asyncio-sync.rst:7
msgid "**Source code:** :source:`Lib/asyncio/locks.py`"
msgstr "**ソースコード:** :source:`Lib/asyncio/locks.py`"

#: ../../library/asyncio-sync.rst:9
msgid "Locks:"
msgstr "ロック:"

#: ../../library/asyncio-sync.rst:11
msgid ":class:`Lock`"
msgstr ":class:`Lock`"

#: ../../library/asyncio-sync.rst:12
msgid ":class:`Event`"
msgstr ":class:`Event`"

#: ../../library/asyncio-sync.rst:13
msgid ":class:`Condition`"
msgstr ":class:`Condition`"

#: ../../library/asyncio-sync.rst:15
msgid "Semaphores:"
msgstr "セマフォ:"

#: ../../library/asyncio-sync.rst:17
msgid ":class:`Semaphore`"
msgstr ":class:`Semaphore`"

#: ../../library/asyncio-sync.rst:18
msgid ":class:`BoundedSemaphore`"
msgstr ":class:`BoundedSemaphore`"

#: ../../library/asyncio-sync.rst:20
msgid ""
"asyncio lock API was designed to be close to classes of the :mod:`threading`"
" module (:class:`~threading.Lock`, :class:`~threading.Event`, "
":class:`~threading.Condition`, :class:`~threading.Semaphore`, "
":class:`~threading.BoundedSemaphore`), but it has no *timeout* parameter. "
"The :func:`asyncio.wait_for` function can be used to cancel a task after a "
"timeout."
msgstr ""
"asyncio lock API は :mod:`threading` モジュールのクラス (:class:`~threading.Lock`, :class:`~threading.Event`, :class:`~threading.Condition`, :class:`~threading.Semaphore`, :class:`~threading.BoundedSemaphore`) に近くなるよう設計されましたが、 *timeout* 引数はありません。\n"
":func:`asyncio.wait_for` 関数を用いてタイムアオウト後にタスクをキャンセルすることが出来ます。"

#: ../../library/asyncio-sync.rst:28
msgid "Lock"
msgstr "Lock"

#: ../../library/asyncio-sync.rst:32
msgid "Primitive lock objects."
msgstr "プリミティブなロックオブジェクトです。"

#: ../../library/asyncio-sync.rst:34
msgid ""
"A primitive lock is a synchronization primitive that is not owned by a "
"particular coroutine when locked.  A primitive lock is in one of two states,"
" 'locked' or 'unlocked'."
msgstr ""
"プリミティブロックは、ロックされたときに特定のコルーチンに所有されない同期プリミティブです。プリミティブロックは 'ロック状態' か 'アンロック状態'"
" のどちらかの状態になります。"

#: ../../library/asyncio-sync.rst:38
msgid ""
"The lock is created in the unlocked state. It has two basic methods, "
":meth:`acquire` and :meth:`release`. When the state is unlocked, acquire() "
"changes the state to locked and returns immediately.  When the state is "
"locked, acquire() blocks until a call to release() in another coroutine "
"changes it to unlocked, then the acquire() call resets it to locked and "
"returns.  The release() method should only be called in the locked state; it"
" changes the state to unlocked and returns immediately.  If an attempt is "
"made to release an unlocked lock, a :exc:`RuntimeError` will be raised."
msgstr ""

#: ../../library/asyncio-sync.rst:48
msgid ""
"When more than one coroutine is blocked in acquire() waiting for the state "
"to turn to unlocked, only one coroutine proceeds when a release() call "
"resets the state to unlocked; first coroutine which is blocked in acquire() "
"is being processed."
msgstr ""
"1 個以上のコルーチンが acquire() でブロックされ、アンロック状態への変更を待っている場合、release() "
"が呼び出されアンロック状態にリセットされたとき 1 個のコルーチンのみが開始されます; 最初に acquire() "
"でプロックされたコルーチンが開始されます。"

#: ../../library/asyncio-sync.rst:53
msgid ":meth:`acquire` is a coroutine and should be called with ``await``."
msgstr ""

#: ../../library/asyncio-sync.rst:55
msgid ""
"Locks support the :ref:`context management protocol <async-with-locks>`."
msgstr ""

#: ../../library/asyncio-sync.rst:57 ../../library/asyncio-sync.rst:97
#: ../../library/asyncio-sync.rst:145 ../../library/asyncio-sync.rst:237
#: ../../library/asyncio-sync.rst:274
msgid "This class is :ref:`not thread safe <asyncio-multithreading>`."
msgstr "このクラスは :ref:`スレッド安全ではありません <asyncio-multithreading>`。"

#: ../../library/asyncio-sync.rst:61
msgid "Return ``True`` if the lock is acquired."
msgstr "ロック状態のとき ``True`` を返します。"

#: ../../library/asyncio-sync.rst:65
msgid "Acquire a lock."
msgstr "ロックを獲得します。"

#: ../../library/asyncio-sync.rst:67 ../../library/asyncio-sync.rst:151
msgid ""
"This method blocks until the lock is unlocked, then sets it to locked and "
"returns ``True``."
msgstr "このメソッドはロックが解除されるまでブロックし、ロック状態に変更して ``True`` を返します。"

#: ../../library/asyncio-sync.rst:70 ../../library/asyncio-sync.rst:123
#: ../../library/asyncio-sync.rst:154 ../../library/asyncio-sync.rst:206
#: ../../library/asyncio-sync.rst:215 ../../library/asyncio-sync.rst:248
msgid "This method is a :ref:`coroutine <coroutine>`."
msgstr "このメソッドは :ref:`コルーチン <coroutine>` です。"

#: ../../library/asyncio-sync.rst:74
msgid "Release a lock."
msgstr "ロックを解放します。"

#: ../../library/asyncio-sync.rst:76
msgid ""
"When the lock is locked, reset it to unlocked, and return.  If any other "
"coroutines are blocked waiting for the lock to become unlocked, allow "
"exactly one of them to proceed."
msgstr ""
"ロックがロック状態のとき、アンロック状態にリセットして返します。他のコルーチンがプロックされロック解除を待っている場合、そのうちのひとつだけ開始されます。"

#: ../../library/asyncio-sync.rst:80 ../../library/asyncio-sync.rst:190
msgid "When invoked on an unlocked lock, a :exc:`RuntimeError` is raised."
msgstr "アンロック状態のロックに対して呼び出された場合、:exc:`RuntimeError` が送出されます。"

#: ../../library/asyncio-sync.rst:82 ../../library/asyncio-sync.rst:192
msgid "There is no return value."
msgstr "戻り値はありません。"

#: ../../library/asyncio-sync.rst:86
msgid "Event"
msgstr "Event"

#: ../../library/asyncio-sync.rst:90
msgid ""
"An Event implementation, asynchronous equivalent to "
":class:`threading.Event`."
msgstr ":class:`threading.Event` と等価で非同期な Event 実装です。"

#: ../../library/asyncio-sync.rst:92
msgid ""
"Class implementing event objects. An event manages a flag that can be set to"
" true with the :meth:`set` method and reset to false with the :meth:`clear` "
"method.  The :meth:`wait` method blocks until the flag is true. The flag is "
"initially false."
msgstr ""
"イベントオブジェクトを実装するクラスです。イベントは :meth:`set` メソッドで真に設定され、:meth:`clear` "
"メソッドで偽にリセットされるフラグを管理します。:meth:`wait` メソッドはフラグが真になるまでブロックします。フラグの最初の値は偽です。"

#: ../../library/asyncio-sync.rst:101
msgid ""
"Reset the internal flag to false. Subsequently, coroutines calling "
":meth:`wait` will block until :meth:`set` is called to set the internal flag"
" to true again."
msgstr ""
"内部フラグを偽にリセットします。その後 :meth:`wait` を呼んでいるコルーチンは :meth:`set` "
"が呼び出されて内部フラグが真に設定されるまでブロックします。"

#: ../../library/asyncio-sync.rst:107
msgid "Return ``True`` if and only if the internal flag is true."
msgstr "内部フラグが真のとき ``True`` を返します。"

#: ../../library/asyncio-sync.rst:111
msgid ""
"Set the internal flag to true. All coroutines waiting for it to become true "
"are awakened. Coroutine that call :meth:`wait` once the flag is true will "
"not block at all."
msgstr ""
"内部フラグを真に設定します。それを待っていたすべてのコルーチンが再開します。:meth:`wait` "
"を呼び出していたコルーチンへのブロックが解除されます。"

#: ../../library/asyncio-sync.rst:117
msgid "Block until the internal flag is true."
msgstr "内部フラグが真になるまでブロックします。"

#: ../../library/asyncio-sync.rst:119
msgid ""
"If the internal flag is true on entry, return ``True`` immediately. "
"Otherwise, block until another coroutine calls :meth:`set` to set the flag "
"to true, then return ``True``."
msgstr ""
"入力時に内部フラグが真のとき直ちに ``True`` を返します。偽のときはコルーチンが :meth:`set` "
"を呼び出してフラグが真になるまでブロックし、真になった時点で ``True`` を返します。"

#: ../../library/asyncio-sync.rst:127
msgid "Condition"
msgstr "Condition"

#: ../../library/asyncio-sync.rst:131
msgid ""
"A Condition implementation, asynchronous equivalent to "
":class:`threading.Condition`."
msgstr ":class:`threading.Condition` と等価で非同期な Condition 実装です。"

#: ../../library/asyncio-sync.rst:134
msgid ""
"This class implements condition variable objects. A condition variable "
"allows one or more coroutines to wait until they are notified by another "
"coroutine."
msgstr ""
"このクラスは条件変数オブジェクトを実装しています。条件変数は 1 個以上のコルーチンが他のコルーチンから通知を受けるまで待機できるようにします。"

#: ../../library/asyncio-sync.rst:138
msgid ""
"If the *lock* argument is given and not ``None``, it must be a :class:`Lock`"
" object, and it is used as the underlying lock.  Otherwise, a new "
":class:`Lock` object is created and used as the underlying lock."
msgstr ""
"引数 *lock* に非 ``None`` が与えられた場合、それは :class:`Lock` "
"オブジェクトでなければなりません。これは下層のロックとして使用されます。与えられない場合、新しく :class:`Lock` "
"オブジェクトが作成されます。"

#: ../../library/asyncio-sync.rst:142
msgid ""
"Conditions support the :ref:`context management protocol <async-with-"
"locks>`."
msgstr ""

#: ../../library/asyncio-sync.rst:149
msgid "Acquire the underlying lock."
msgstr "下層でのロックを獲得します。"

#: ../../library/asyncio-sync.rst:158
msgid ""
"By default, wake up one coroutine waiting on this condition, if any. If the "
"calling coroutine has not acquired the lock when this method is called, a "
":exc:`RuntimeError` is raised."
msgstr ""
"デフォルトでは、この条件を待機しているコルーチンがあればそれが再開されます。呼び出したコルーチンがこのロックを獲得していない状態でこのメソッドが呼び出されると"
" :exc:`RuntimeError` が送出されます。"

#: ../../library/asyncio-sync.rst:162
msgid ""
"This method wakes up at most *n* of the coroutines waiting for the condition"
" variable; it is a no-op if no coroutines are waiting."
msgstr ""
"このメソッドではこの条件変数を待機しているうち最大で *n* 個のコルーチンが再開されます; 待機しているコルーチンがなければ何もしません。"

#: ../../library/asyncio-sync.rst:167
msgid ""
"An awakened coroutine does not actually return from its :meth:`wait` call "
"until it can reacquire the lock. Since :meth:`notify` does not release the "
"lock, its caller should."
msgstr ""
"そのロックを獲得できるまで、再開されたコルーチンは実際には自身の :meth:`wait` 呼び出しから復帰しません。:meth:`notify` "
"はロックの解除を行わないため、呼び出し元がそれを行わなければなりません。"

#: ../../library/asyncio-sync.rst:173
msgid "Return ``True`` if the underlying lock is acquired."
msgstr "下層のロックを獲得していれば ``True`` を返します。"

#: ../../library/asyncio-sync.rst:177
msgid ""
"Wake up all coroutines waiting on this condition. This method acts like "
":meth:`notify`, but wakes up all waiting coroutines instead of one. If the "
"calling coroutine has not acquired the lock when this method is called, a "
":exc:`RuntimeError` is raised."
msgstr ""
"この条件を待機しているすべてのコルーチンを再開します。このメソッドは :meth:`notify` のように振る舞いますが、1 "
"個ではなくすべてのコルーチンが再開されます。呼び出したコルーチンがロックを獲得していない状態でこのメソッドが呼び出されると "
":exc:`RuntimeError` が送出されます。"

#: ../../library/asyncio-sync.rst:184
msgid "Release the underlying lock."
msgstr "下層のロックを解除します。"

#: ../../library/asyncio-sync.rst:186
msgid ""
"When the lock is locked, reset it to unlocked, and return. If any other "
"coroutines are blocked waiting for the lock to become unlocked, allow "
"exactly one of them to proceed."
msgstr ""
"ロックがロック状態のとき、アンロック状態にリセットされます。他にこのロックの解除を待機していたコルーチンが存在していた場合、そのうちの一つが再開されます。"

#: ../../library/asyncio-sync.rst:196
msgid "Wait until notified."
msgstr "通知を受けるまで待機します。"

#: ../../library/asyncio-sync.rst:198
msgid ""
"If the calling coroutine has not acquired the lock when this method is "
"called, a :exc:`RuntimeError` is raised."
msgstr "呼び出したコルーチンがロックを獲得していない状態でこのメソッドが呼び出されると、:exc:`RuntimeError` が送出されます。"

#: ../../library/asyncio-sync.rst:201
msgid ""
"This method releases the underlying lock, and then blocks until it is "
"awakened by a :meth:`notify` or :meth:`notify_all` call for the same "
"condition variable in another coroutine.  Once awakened, it re-acquires the "
"lock and returns ``True``."
msgstr ""
"このメソッドは下層のロックを解除し、その後それが他のコルーチンで同じ条件変数の :meth:`notify` か :meth:`notify_all` "
"によって再開されるまでブロックします。再開されると、再びロックを獲得して ``True`` を返します。"

#: ../../library/asyncio-sync.rst:210
msgid "Wait until a predicate becomes true."
msgstr "*predicate* が真になるまで待機します。"

#: ../../library/asyncio-sync.rst:212
msgid ""
"The predicate should be a callable which result will be interpreted as a "
"boolean value. The final predicate value is the return value."
msgstr ""
"*predicate* は呼び出し可能オブジェクトで、結果がブール値で解析できなければなりません。最終的な *predicate* "
"の結果が戻り値となります。"

#: ../../library/asyncio-sync.rst:219
msgid "Semaphore"
msgstr "Semaphore"

#: ../../library/asyncio-sync.rst:223
msgid "A Semaphore implementation."
msgstr "Semaphore 実装です。"

#: ../../library/asyncio-sync.rst:225
msgid ""
"A semaphore manages an internal counter which is decremented by each "
":meth:`acquire` call and incremented by each :meth:`release` call. The "
"counter can never go below zero; when :meth:`acquire` finds that it is zero,"
" it blocks, waiting until some other coroutine calls :meth:`release`."
msgstr ""
"セマフォは :meth:`acquire` の呼び出しで減算し、:meth:`release` "
"で加算する内部カウンターを管理します。カウンターは負数になることはありません;  :meth:`acquire` "
"が呼び出されたときにセマフォがゼロであればブロックされ、他のコルーチンが :meth:`release` を呼び出すまで待機します。"

#: ../../library/asyncio-sync.rst:230
msgid ""
"The optional argument gives the initial value for the internal counter; it "
"defaults to ``1``. If the value given is less than ``0``, :exc:`ValueError` "
"is raised."
msgstr ""
"任意の引数 *value* で内部カウンターの初期値を指定できます; デフォルトは ``1`` です。value に ``0`` "
"未満の値が指定されると、:exc:`ValueError` が送出されます。"

#: ../../library/asyncio-sync.rst:234
msgid ""
"Semaphores support the :ref:`context management protocol <async-with-"
"locks>`."
msgstr ""

#: ../../library/asyncio-sync.rst:241
msgid "Acquire a semaphore."
msgstr "セマフォを獲得します。"

#: ../../library/asyncio-sync.rst:243
msgid ""
"If the internal counter is larger than zero on entry, decrement it by one "
"and return ``True`` immediately.  If it is zero on entry, block, waiting "
"until some other coroutine has called :meth:`release` to make it larger than"
" ``0``, and then return ``True``."
msgstr ""
"入力時内部カウンターがゼロより大きかった場合、1 減算され、直ちに ``True`` を返します。ゼロだった場合、ブロックされ、他のコルーチンが "
":meth:`release` を呼び出してカウンター値が ``0`` より大きくなるまで待機し、獲得できると ``True`` を返します。"

#: ../../library/asyncio-sync.rst:252
msgid "Returns ``True`` if semaphore can not be acquired immediately."
msgstr "セマフォを直ちに獲得できない場合 ``True`` を返します。"

#: ../../library/asyncio-sync.rst:256
msgid ""
"Release a semaphore, incrementing the internal counter by one. When it was "
"zero on entry and another coroutine is waiting for it to become larger than "
"zero again, wake up that coroutine."
msgstr ""
"セマフォを解放し、内部カウンターを 1 加算します。カウンター値がゼロで他のコルーチンが待機状態にあった場合、加算後そのコルーチンが再開されます。"

#: ../../library/asyncio-sync.rst:262
msgid "BoundedSemaphore"
msgstr "BoundedSemaphore"

#: ../../library/asyncio-sync.rst:266
msgid "A bounded semaphore implementation. Inherit from :class:`Semaphore`."
msgstr ":class:`Semaphore` を継承した有限セマフォの実装です。"

#: ../../library/asyncio-sync.rst:268
msgid ""
"This raises :exc:`ValueError` in :meth:`~Semaphore.release` if it would "
"increase the value above the initial value."
msgstr ""
":meth:`~Semaphore.release` 内でカウンター値が加算されて引数 *value* を超えると :exc:`ValueError` "
"を送出します。"

#: ../../library/asyncio-sync.rst:271
msgid ""
"Bounded semaphores support the :ref:`context management protocol <async-"
"with-locks>`."
msgstr ""

#: ../../library/asyncio-sync.rst:280
msgid ""
"Using locks, conditions and semaphores in the :keyword:`async with` "
"statement"
msgstr ""

#: ../../library/asyncio-sync.rst:282
msgid ""
":class:`Lock`, :class:`Condition`, :class:`Semaphore`, and "
":class:`BoundedSemaphore` objects can be used in :keyword:`async with` "
"statements."
msgstr ""

#: ../../library/asyncio-sync.rst:286
msgid ""
"The :meth:`acquire` method will be called when the block is entered, and "
":meth:`release` will be called when the block is exited.  Hence, the "
"following snippet::"
msgstr ""

#: ../../library/asyncio-sync.rst:293
msgid "is equivalent to::"
msgstr "は、以下と同じです ::"

#: ../../library/asyncio-sync.rst:303
msgid ""
"Lock acquiring using ``await lock`` or ``yield from lock`` and "
":keyword:`with` statement (``with await lock``, ``with (yield from lock)``) "
"are deprecated."
msgstr ""