queue.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:
# Rafael Fontenelle <rffontenelle@gmail.com>, 2026
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.15\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-09-29 18:58+0000\n"
"PO-Revision-Date: 2025-09-16 00:01+0000\n"
"Last-Translator: Rafael Fontenelle <rffontenelle@gmail.com>, 2026\n"
"Language-Team: Japanese (https://app.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/queue.rst:2
msgid ":mod:`!queue` --- A synchronized queue class"
msgstr ":mod:`!queue` --- 同期キュークラス"

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

#: ../../library/queue.rst:11
msgid ""
"The :mod:`!queue` module implements multi-producer, multi-consumer queues. "
"It is especially useful in threaded programming when information must be "
"exchanged safely between multiple threads.  The :class:`Queue` class in this "
"module implements all the required locking semantics."
msgstr ""

#: ../../library/queue.rst:16
msgid ""
"The module implements three types of queue, which differ only in the order "
"in which the entries are retrieved.  In a :abbr:`FIFO (first-in, first-out)` "
"queue, the first tasks added are the first retrieved.  In a :abbr:`LIFO "
"(last-in, first-out)` queue, the most recently added entry is the first "
"retrieved (operating like a stack).  With a priority queue, the entries are "
"kept sorted (using the :mod:`heapq` module) and the lowest valued entry is "
"retrieved first."
msgstr ""
"このモジュールでは3種類のキューが実装されています。それらはキューから取り出さ"
"れるエントリの順番だけが違います。 :abbr:`FIFO (first-in, first-out, 先入れ先"
"出し)` キューでは、最初に追加されたエントリが最初に取り出されます。  :abbr:"
"`LIFO (last-in, first-out, 後入れ先出し)` キューでは、最後に追加されたエント"
"リが最初に取り出されます(スタックのように振る舞います)。 優先順位付きキュー"
"(priority queue)では、エントリは(:mod:`heapq` モジュールを利用して)ソートさ"
"れ、 最も低い値のエントリが最初に取り出されます。"

#: ../../library/queue.rst:24
msgid ""
"Internally, those three types of queues use locks to temporarily block "
"competing threads; however, they are not designed to handle reentrancy "
"within a thread."
msgstr ""
"内部的には、これらの3種類のキューは競争スレッドを一時的にブロックするために"
"ロックを使っています; しかし、スレッド内での再入を扱うようには設計されていま"
"せん。"

#: ../../library/queue.rst:28
msgid ""
"In addition, the module implements a \"simple\" :abbr:`FIFO (first-in, first-"
"out)` queue type, :class:`SimpleQueue`, whose specific implementation "
"provides additional guarantees in exchange for the smaller functionality."
msgstr ""

#: ../../library/queue.rst:33
msgid "The :mod:`!queue` module defines the following classes and exceptions:"
msgstr ""

#: ../../library/queue.rst:37
msgid ""
"Constructor for a :abbr:`FIFO (first-in, first-out)` queue.  *maxsize* is an "
"integer that sets the upperbound limit on the number of items that can be "
"placed in the queue.  Insertion will block once this size has been reached, "
"until queue items are consumed.  If *maxsize* is less than or equal to zero, "
"the queue size is infinite."
msgstr ""
":abbr:`FIFO (first-in, first-out, 先入れ先出し)` キューのコンストラクタで"
"す。\n"
"*maxsize* はキューに入れられる要素数の上限を設定する整数です。\n"
"いったんこの大きさに達したら、挿入処理はキューの要素が消費されるまでブロック"
"されます。\n"
"*maxsize* が0以下の場合は、キューの大きさは無限です。"

#: ../../library/queue.rst:45
msgid ""
"Constructor for a :abbr:`LIFO (last-in, first-out)` queue.  *maxsize* is an "
"integer that sets the upperbound limit on the number of items that can be "
"placed in the queue.  Insertion will block once this size has been reached, "
"until queue items are consumed.  If *maxsize* is less than or equal to zero, "
"the queue size is infinite."
msgstr ""
":abbr:`LIFO (last-in, first-out, 後入れ先出し)` キューのコンストラクタで"
"す。\n"
"*maxsize* はキューに入れられる要素数の上限を設定する整数です。\n"
"いったんこの大きさに達したら、挿入処理はキューの要素が消費されるまでブロック"
"されます。\n"
"*maxsize* が0以下の場合は、キューの大きさは無限です。"

#: ../../library/queue.rst:54
msgid ""
"Constructor for a priority queue.  *maxsize* is an integer that sets the "
"upperbound limit on the number of items that can be placed in the queue.  "
"Insertion will block once this size has been reached, until queue items are "
"consumed.  If *maxsize* is less than or equal to zero, the queue size is "
"infinite."
msgstr ""
"優先順位付きキューのコンストラクタです。*maxsize* はキューに置くことのできる"
"要素数の上限を設定する整数です。いったんこの大きさに達したら、挿入はキューの"
"要素が消費されるまでブロックされます。もし *maxsize* が0以下であるならば、"
"キューの大きさは無限です。"

#: ../../library/queue.rst:59
msgid ""
"The lowest valued entries are retrieved first (the lowest valued entry is "
"the one that would be returned by ``min(entries)``).  A typical pattern for "
"entries is a tuple in the form: ``(priority_number, data)``."
msgstr ""
"最小の値を持つ要素が最初に検索されます (最小の値を持つ値は、``min(entries)`` "
"によって返されるものです)。典型的な要素のパターンは、``(priority_number, "
"data)`` 形式のタプルです。"

#: ../../library/queue.rst:63
msgid ""
"If the *data* elements are not comparable, the data can be wrapped in a "
"class that ignores the data item and only compares the priority number::"
msgstr ""

#: ../../library/queue.rst:66
msgid ""
"from dataclasses import dataclass, field\n"
"from typing import Any\n"
"\n"
"@dataclass(order=True)\n"
"class PrioritizedItem:\n"
"    priority: int\n"
"    item: Any=field(compare=False)"
msgstr ""

#: ../../library/queue.rst:76
msgid ""
"Constructor for an unbounded :abbr:`FIFO (first-in, first-out)` queue. "
"Simple queues lack advanced functionality such as task tracking."
msgstr ""

#: ../../library/queue.rst:79
msgid ""
"Simple queues are :ref:`generic <generics>` over the type of their items."
msgstr ""

#: ../../library/queue.rst:86
msgid ""
"Exception raised when non-blocking :meth:`~Queue.get` (or :meth:`~Queue."
"get_nowait`) is called on a :class:`Queue` object which is empty."
msgstr ""
"空の :class:`Queue` オブジェクトで、非ブロックメソッド :meth:`~Queue.get` (ま"
"たは :meth:`~Queue.get_nowait`) が呼ばれたとき、送出される例外です。"

#: ../../library/queue.rst:93
msgid ""
"Exception raised when non-blocking :meth:`~Queue.put` (or :meth:`~Queue."
"put_nowait`) is called on a :class:`Queue` object which is full."
msgstr ""
"満杯の :class:`Queue` オブジェクトで、非ブロックメソッド :meth:`~Queue.put` "
"(または :meth:`~Queue.put_nowait`) が呼ばれたとき、送出される例外です。"

#: ../../library/queue.rst:100
msgid ""
"Exception raised when :meth:`~Queue.put` or :meth:`~Queue.get` is called on "
"a :class:`Queue` object which has been shut down."
msgstr ""

#: ../../library/queue.rst:109
msgid "Queue Objects"
msgstr "キューオブジェクト"

#: ../../library/queue.rst:111
msgid ""
"Queue objects (:class:`Queue`, :class:`LifoQueue`, or :class:"
"`PriorityQueue`) provide the public methods described below."
msgstr ""
"キューオブジェクト(:class:`Queue`, :class:`LifoQueue`, :class:"
"`PriorityQueue`)は、以下のpublicメソッドを提供しています。"

#: ../../library/queue.rst:117
msgid ""
"Return the approximate size of the queue.  Note, qsize() > 0 doesn't "
"guarantee that a subsequent get() will not block, nor will qsize() < maxsize "
"guarantee that put() will not block."
msgstr ""
"キューの近似サイズを返します。ここで、qsize() > 0 は後続の get() がブロックし"
"ないことを保証しないこと、また qsize() < maxsize が put() がブロックしないこ"
"とを保証しないことに注意してください。"

#: ../../library/queue.rst:124
msgid ""
"Return ``True`` if the queue is empty, ``False`` otherwise.  If empty() "
"returns ``True`` it doesn't guarantee that a subsequent call to put() will "
"not block.  Similarly, if empty() returns ``False`` it doesn't guarantee "
"that a subsequent call to get() will not block."
msgstr ""
"キューが空の場合は ``True`` を返し、そうでなければ ``False`` を返します。"
"empty() が ``True`` を返しても、後続の put() の呼び出しがブロックしないことは"
"保証されません。同様に、empty() が ``False`` を返しても、後続の get() の呼び"
"出しがブロックしないことは保証されません。"

#: ../../library/queue.rst:132
msgid ""
"Return ``True`` if the queue is full, ``False`` otherwise.  If full() "
"returns ``True`` it doesn't guarantee that a subsequent call to get() will "
"not block.  Similarly, if full() returns ``False`` it doesn't guarantee that "
"a subsequent call to put() will not block."
msgstr ""
"キューが一杯の場合は ``True`` を返し、そうでなければ ``False`` を返します。"
"full() が ``True`` を返しても、後続の get() の呼び出しがブロックしないことは"
"保証されません。同様に、full() が ``False`` を返しても、後続の put() の呼び出"
"しがブロックしないことは保証されません。"

#: ../../library/queue.rst:140
msgid ""
"Put *item* into the queue.  If optional args *block* is true and *timeout* "
"is ``None`` (the default), block if necessary until a free slot is "
"available.  If *timeout* is a positive number, it blocks at most *timeout* "
"seconds and raises the :exc:`Full` exception if no free slot was available "
"within that time. Otherwise (*block* is false), put an item on the queue if "
"a free slot is immediately available, else raise the :exc:`Full` exception "
"(*timeout* is ignored in that case)."
msgstr ""
"*item* をキューに入れます。\n"
"もしオプション引数 *block* が真で *timeout* が ``None`` (デフォルト) の場合"
"は、必要であればフリースロットが利用可能になるまでブロックします。\n"
"*timeout* が正の数の場合は、最大で *timeout* 秒間ブロックし、その時間内に空き"
"スロットが利用可能にならなければ、例外 :exc:`Full` を送出します。\n"
"そうでない場合 (*block* が偽) は、空きスロットが直ちに利用できるならば、"
"キューにアイテムを置きます。\n"
"できないならば、例外 :exc:`Full` を送出します (この場合 *timeout* は無視され"
"ます)。"

#: ../../library/queue.rst:148
msgid "Raises :exc:`ShutDown` if the queue has been shut down."
msgstr ""

#: ../../library/queue.rst:153
msgid "Equivalent to ``put(item, block=False)``."
msgstr "``put(item, block=False)`` と等価です。"

#: ../../library/queue.rst:158 ../../library/queue.rst:316
msgid ""
"Remove and return an item from the queue.  If optional args *block* is true "
"and *timeout* is ``None`` (the default), block if necessary until an item is "
"available. If *timeout* is a positive number, it blocks at most *timeout* "
"seconds and raises the :exc:`Empty` exception if no item was available "
"within that time. Otherwise (*block* is false), return an item if one is "
"immediately available, else raise the :exc:`Empty` exception (*timeout* is "
"ignored in that case)."
msgstr ""
"キューからアイテムを取り除き、それを返します。\n"
"オプション引数 *block* が真で *timeout* が ``None`` (デフォルト) の場合は、必"
"要であればアイテムが取り出せるようになるまでブロックします。\n"
"もし *timeout* が正の数の場合は、最大で *timeout* 秒間ブロックし、その時間内"
"でアイテムが取り出せるようにならなければ、例外 :exc:`Empty` を送出します。\n"
"そうでない場合 (*block* が偽) は、直ちにアイテムが取り出せるならば、それを返"
"します。\n"
"できないならば、例外 :exc:`Empty` を送出します (この場合 *timeout* は無視され"
"ます)。"

#: ../../library/queue.rst:165
msgid ""
"Prior to 3.0 on POSIX systems, and for all versions on Windows, if *block* "
"is true and *timeout* is ``None``, this operation goes into an "
"uninterruptible wait on an underlying lock.  This means that no exceptions "
"can occur, and in particular a SIGINT will not trigger a :exc:"
"`KeyboardInterrupt`."
msgstr ""

#: ../../library/queue.rst:170
msgid ""
"Raises :exc:`ShutDown` if the queue has been shut down and is empty, or if "
"the queue has been shut down immediately."
msgstr ""

#: ../../library/queue.rst:176 ../../library/queue.rst:326
msgid "Equivalent to ``get(False)``."
msgstr "``get(False)`` と等価です。"

#: ../../library/queue.rst:178
msgid ""
"Two methods are offered to support tracking whether enqueued tasks have been "
"fully processed by daemon consumer threads."
msgstr ""
"キューに入れられたタスクが全てコンシューマスレッドに処理されたかどうかを追跡"
"するために 2つのメソッドが提供されます。"

#: ../../library/queue.rst:184
msgid ""
"Indicate that a formerly enqueued task is complete.  Used by queue consumer "
"threads.  For each :meth:`get` used to fetch a task, a subsequent call to :"
"meth:`task_done` tells the queue that the processing on the task is complete."
msgstr ""
"過去にキューに入れられたタスクが完了した事を示します。キューのコンシューマス"
"レッドに利用されます。タスクの取り出しに使われた各 :meth:`get` の後に :meth:"
"`task_done` を呼び出すと、取り出したタスクに対する処理が完了した事をキューに"
"教えます。"

#: ../../library/queue.rst:188
msgid ""
"If a :meth:`join` is currently blocking, it will resume when all items have "
"been processed (meaning that a :meth:`task_done` call was received for every "
"item that had been :meth:`put` into the queue)."
msgstr ""
":meth:`join` がブロックされていた場合、全itemが処理された (キューに :meth:"
"`put` された全てのitemに対して :meth:`task_done` が呼び出されたことを意味しま"
"す) 時に復帰します。"

#: ../../library/queue.rst:192
msgid ""
"Raises a :exc:`ValueError` if called more times than there were items placed "
"in the queue."
msgstr ""
"キューにある要素より多く呼び出された場合 :exc:`ValueError` が発生します。"

#: ../../library/queue.rst:198
msgid "Blocks until all items in the queue have been gotten and processed."
msgstr ""
"キューにあるすべてのアイテムが取り出されて処理されるまでブロックします。"

#: ../../library/queue.rst:200
msgid ""
"The count of unfinished tasks goes up whenever an item is added to the "
"queue. The count goes down whenever a consumer thread calls :meth:"
"`task_done` to indicate that the item was retrieved and all work on it is "
"complete.  When the count of unfinished tasks drops to zero, :meth:`join` "
"unblocks."
msgstr ""
"未完了のタスクのカウント値はキューにアイテムが追加されるときは常に加算され、"
"コンシューマースレッドが :meth:`task_done` を呼び出してアイテムの回収とその全"
"処理の完了が示されるときは常に減算されます。未完了のタスクのカウント値がゼロ"
"になった場合、:meth:`join` のブロックが解除されます。"

#: ../../library/queue.rst:207
msgid "Waiting for task completion"
msgstr ""

#: ../../library/queue.rst:209
msgid "Example of how to wait for enqueued tasks to be completed::"
msgstr "キューに入れたタスクが完了するのを待つ例::"

#: ../../library/queue.rst:211
msgid ""
"import threading\n"
"import queue\n"
"\n"
"q = queue.Queue()\n"
"\n"
"def worker():\n"
"    while True:\n"
"        item = q.get()\n"
"        print(f'Working on {item}')\n"
"        print(f'Finished {item}')\n"
"        q.task_done()\n"
"\n"
"# Turn-on the worker thread.\n"
"threading.Thread(target=worker, daemon=True).start()\n"
"\n"
"# Send thirty task requests to the worker.\n"
"for item in range(30):\n"
"    q.put(item)\n"
"\n"
"# Block until all tasks are done.\n"
"q.join()\n"
"print('All work completed')"
msgstr ""

#: ../../library/queue.rst:236
msgid "Terminating queues"
msgstr ""

#: ../../library/queue.rst:238
msgid ""
"When no longer needed, :class:`Queue` objects can be wound down until empty "
"or terminated immediately with a hard shutdown."
msgstr ""

#: ../../library/queue.rst:243
msgid "Put a :class:`Queue` instance into a shutdown mode."
msgstr ""

#: ../../library/queue.rst:245
msgid ""
"The queue can no longer grow. Future calls to :meth:`~Queue.put` raise :exc:"
"`ShutDown`. Currently blocked callers of :meth:`~Queue.put` will be "
"unblocked and will raise :exc:`ShutDown` in the formerly blocked thread."
msgstr ""

#: ../../library/queue.rst:250
msgid ""
"If *immediate* is false (the default), the queue can be wound down normally "
"with :meth:`~Queue.get` calls to extract tasks that have already been loaded."
msgstr ""

#: ../../library/queue.rst:254
msgid ""
"And if :meth:`~Queue.task_done` is called for each remaining task, a "
"pending :meth:`~Queue.join` will be unblocked normally."
msgstr ""

#: ../../library/queue.rst:257
msgid ""
"Once the queue is empty, future calls to :meth:`~Queue.get` will raise :exc:"
"`ShutDown`."
msgstr ""

#: ../../library/queue.rst:260
msgid ""
"If *immediate* is true, the queue is terminated immediately. The queue is "
"drained to be completely empty and the count of unfinished tasks is reduced "
"by the number of tasks drained. If unfinished tasks is zero, callers of :"
"meth:`~Queue.join` are unblocked.  Also, blocked callers of :meth:`~Queue."
"get` are unblocked and will raise :exc:`ShutDown` because the queue is empty."
msgstr ""

#: ../../library/queue.rst:268
msgid ""
"Use caution when using :meth:`~Queue.join` with *immediate* set to true. "
"This unblocks the join even when no work has been done on the tasks, "
"violating the usual invariant for joining a queue."
msgstr ""

#: ../../library/queue.rst:276
msgid "SimpleQueue Objects"
msgstr "SimpleQueue オブジェクト"

#: ../../library/queue.rst:278
msgid ""
":class:`SimpleQueue` objects provide the public methods described below."
msgstr ""
":class:`SimpleQueue` オブジェクトは以下のpublicメソッドを提供しています。"

#: ../../library/queue.rst:282
msgid ""
"Return the approximate size of the queue.  Note, qsize() > 0 doesn't "
"guarantee that a subsequent get() will not block."
msgstr ""
"キューの近似サイズを返します。ここで、qsize() > 0 であるからといって、後続の "
"get() の呼び出しがブロックしないことが保証されないことに注意してください。"

#: ../../library/queue.rst:288
msgid ""
"Return ``True`` if the queue is empty, ``False`` otherwise.  If empty() "
"returns ``False`` it doesn't guarantee that a subsequent call to get() will "
"not block."
msgstr ""
"キューが空の場合は ``True`` を返し、そうでなければ ``False`` を返します。 "
"empty() が ``False`` を返しても、後続の get() の呼び出しがブロックしないこと"
"は保証されません。"

#: ../../library/queue.rst:295
msgid ""
"Put *item* into the queue.  The method never blocks and always succeeds "
"(except for potential low-level errors such as failure to allocate memory). "
"The optional args *block* and *timeout* are ignored and only provided for "
"compatibility with :meth:`Queue.put`."
msgstr ""

#: ../../library/queue.rst:301
msgid ""
"This method has a C implementation which is reentrant.  That is, a ``put()`` "
"or ``get()`` call can be interrupted by another ``put()`` call in the same "
"thread without deadlocking or corrupting internal state inside the queue.  "
"This makes it appropriate for use in destructors such as ``__del__`` methods "
"or :mod:`weakref` callbacks."
msgstr ""

#: ../../library/queue.rst:310
msgid ""
"Equivalent to ``put(item, block=False)``, provided for compatibility with :"
"meth:`Queue.put_nowait`."
msgstr ""
"``put(item, block=False)`` と等価です。:meth:`Queue.put_nowait` との互換性の"
"ためのメソッドです。"

#: ../../library/queue.rst:331
msgid "Class :class:`multiprocessing.Queue`"
msgstr ":class:`multiprocessing.Queue` クラス"

#: ../../library/queue.rst:332
msgid ""
"A queue class for use in a multi-processing (rather than multi-threading) "
"context."
msgstr ""
"(マルチスレッドではなく) マルチプロセスの文脈で使用されるキュークラス。"

#: ../../library/queue.rst:335
msgid ""
":class:`collections.deque` is an alternative implementation of unbounded "
"queues with fast atomic :meth:`~collections.deque.append` and :meth:"
"`~collections.deque.popleft` operations that do not require locking and also "
"support indexing."
msgstr ""