# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001-2025, Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# Dmytro Kazanzhy, 2022

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.13\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2025-04-25 14:19+0000\n"

"PO-Revision-Date: 2021-06-28 00:55+0000\n"

"Last-Translator: Dmytro Kazanzhy, 2022\n"

"Language-Team: Ukrainian (https://app.transifex.com/python-doc/teams/5390/"

"uk/)\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Language: uk\n"

"Plural-Forms: nplurals=4; plural=(n % 1 == 0 && n % 10 == 1 && n % 100 != "

"11 ? 0 : n % 1 == 0 && n % 10 >= 2 && n % 10 <= 4 && (n % 100 < 12 || n % "

"100 > 14) ? 1 : n % 1 == 0 && (n % 10 ==0 || (n % 10 >=5 && n % 10 <=9) || "

"(n % 100 >=11 && n % 100 <=14 )) ? 2: 3);\n"

msgid "Queues"

msgstr "Черги"

msgid "**Source code:** :source:`Lib/asyncio/queues.py`"

msgstr "**Вихідний код:** :source:`Lib/asyncio/queues.py`"

msgid ""

"asyncio queues are designed to be similar to classes of the :mod:`queue` "

"module. Although asyncio queues are not thread-safe, they are designed to "

"be used specifically in async/await code."

msgstr ""

"асинхронні черги розроблені таким чином, щоб бути подібними до класів "

"модуля :mod:`queue`. Хоча асинхронні черги не є потокобезпечними, вони "

"розроблені спеціально для використання в асинхронному коді/коді очікування."

msgid ""

"Note that methods of asyncio queues don't have a *timeout* parameter; use :"

"func:`asyncio.wait_for` function to do queue operations with a timeout."

msgstr ""

"Зауважте, що методи асинхронних черг не мають параметра *timeout*; "

"використовуйте функцію :func:`asyncio.wait_for`, щоб виконувати операції в "

"черзі з тайм-аутом."

msgid "See also the `Examples`_ section below."

msgstr "Дивіться також розділ `Examples`_ нижче."

msgid "Queue"

msgstr "Чергу"

msgid "A first in, first out (FIFO) queue."

msgstr "Черга першим прийшов, першим вийшов (FIFO)."

msgid ""

"If *maxsize* is less than or equal to zero, the queue size is infinite. If "

"it is an integer greater than ``0``, then ``await put()`` blocks when the "

"queue reaches *maxsize* until an item is removed by :meth:`get`."

msgstr ""

"Якщо *maxsize* менше або дорівнює нулю, розмір черги є нескінченним. Якщо це "

"ціле число, більше за ``0``, тоді ``await put()`` блокує, коли черга досягає "

"*maxsize*, доки елемент не буде видалено :meth:`get`."

msgid ""

"Unlike the standard library threading :mod:`queue`, the size of the queue is "

"always known and can be returned by calling the :meth:`qsize` method."

msgstr ""

"На відміну від стандартної потокової обробки бібліотеки :mod:`queue`, розмір "

"черги завжди відомий і може бути повернутий викликом методу :meth:`qsize`."

msgid "Removed the *loop* parameter."

msgstr "Видалено параметр *loop*."

msgid "This class is :ref:`not thread safe <asyncio-multithreading>`."

msgstr "Цей клас :ref:`не потоково безпечний <asyncio-multithreading>`."

msgid "Number of items allowed in the queue."

msgstr "Кількість елементів, дозволених у черзі."

msgid "Return ``True`` if the queue is empty, ``False`` otherwise."

msgstr "Повертає ``True``, якщо черга порожня, ``False`` інакше."

msgid "Return ``True`` if there are :attr:`maxsize` items in the queue."

msgstr "Повертає ``True``, якщо в черзі є елементи :attr:`maxsize`."

msgid ""

"If the queue was initialized with ``maxsize=0`` (the default), then :meth:"

"`full` never returns ``True``."

msgstr ""

msgid ""

"Remove and return an item from the queue. If queue is empty, wait until an "

"item is available."

msgstr ""

"Видалити та повернути елемент із черги. Якщо черга порожня, зачекайте, поки "

"елемент стане доступним."

msgid ""

"Raises :exc:`QueueShutDown` if the queue has been shut down and is empty, or "

"if the queue has been shut down immediately."

msgstr ""

msgid ""

"Return an item if one is immediately available, else raise :exc:`QueueEmpty`."

msgstr ""

"Повернути елемент, якщо він одразу доступний, інакше підняти :exc:"

"`QueueEmpty`."

msgid "Block until all items in the queue have been received and processed."

msgstr "Блокуйте, доки всі елементи в черзі не будуть отримані та оброблені."

msgid ""

"The count of unfinished tasks goes up whenever an item is added to the "

"queue. The count goes down whenever a consumer coroutine 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` розблоковується."

msgid ""

"Put an item into the queue. If the queue is full, wait until a free slot is "

"available before adding the item."

msgstr ""

"Помістіть товар у чергу. Якщо черга заповнена, зачекайте, поки з’явиться "

"вільне місце, перш ніж додавати елемент."

msgid "Raises :exc:`QueueShutDown` if the queue has been shut down."

msgstr ""

msgid "Put an item into the queue without blocking."

msgstr "Поставте елемент у чергу без блокування."

msgid "If no free slot is immediately available, raise :exc:`QueueFull`."

msgstr "Якщо вільного місця немає, підніміть :exc:`QueueFull`."

msgid "Return the number of items in the queue."

msgstr "Повернути кількість елементів у черзі."

msgid ""

"Shut down the queue, making :meth:`~Queue.get` and :meth:`~Queue.put` raise :"

"exc:`QueueShutDown`."

msgstr ""

msgid ""

"By default, :meth:`~Queue.get` on a shut down queue will only raise once the "

"queue is empty. Set *immediate* to true to make :meth:`~Queue.get` raise "

"immediately instead."

msgstr ""

msgid ""

"All blocked callers of :meth:`~Queue.put` and :meth:`~Queue.get` will be "

"unblocked. If *immediate* is true, a task will be marked as done for each "

"remaining item in the queue, which may unblock callers of :meth:`~Queue."

"join`."

msgstr ""

msgid "Indicate that a formerly enqueued work item is complete."

msgstr ""

msgid ""

"Used by queue consumers. For each :meth:`~Queue.get` used to fetch a work "

"item, a subsequent call to :meth:`task_done` tells the queue that the "

"processing on the work item is complete."

msgstr ""

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:`~Queue.put` into the queue)."

msgstr ""

"Якщо :meth:`join` зараз блокує, воно відновиться, коли всі елементи буде "

"оброблено (це означає, що виклик :meth:`task_done` отримано для кожного "

"елемента, який був :meth:`~Queue.put` в черга)."

msgid ""

"``shutdown(immediate=True)`` calls :meth:`task_done` for each remaining item "

"in the queue."

msgstr ""

msgid ""

"Raises :exc:`ValueError` if called more times than there were items placed "

"in the queue."

msgstr ""

"Викликає :exc:`ValueError`, якщо викликається стільки разів, скільки було "

"елементів, розміщених у черзі."

msgid "Priority Queue"

msgstr "Пріоритетна черга"

msgid ""

"A variant of :class:`Queue`; retrieves entries in priority order (lowest "

"first)."

msgstr ""

"Варіант :class:`Queue`; отримує записи в порядку пріоритету (найнижчий "

"спочатку)."

msgid "Entries are typically tuples of the form ``(priority_number, data)``."

msgstr "Записи зазвичай є кортежами у формі ``(число_пріоритету, дані)``."

msgid "LIFO Queue"

msgstr "Черга LIFO"

msgid ""

"A variant of :class:`Queue` that retrieves most recently added entries first "

"(last in, first out)."

msgstr ""

"Варіант :class:`Queue`, який першими отримує нещодавно додані записи "

"(останнім увійшов, першим вийшов)."

msgid "Exceptions"

msgstr "Винятки"

msgid ""

"This exception is raised when the :meth:`~Queue.get_nowait` method is called "

"on an empty queue."

msgstr ""

"Цей виняток виникає, коли метод :meth:`~Queue.get_nowait` викликається в "

"порожній черзі."

msgid ""

"Exception raised when the :meth:`~Queue.put_nowait` method is called on a "

"queue that has reached its *maxsize*."

msgstr ""

"Виняток виникає, коли метод :meth:`~Queue.put_nowait` викликається в черзі, "

"яка досягла *максимального розміру*."

msgid ""

"Exception raised when :meth:`~Queue.put` or :meth:`~Queue.get` is called on "

"a queue which has been shut down."

msgstr ""

msgid "Examples"

msgstr "Приклади"

msgid ""

"Queues can be used to distribute workload between several concurrent tasks::"

msgstr ""

"Черги можна використовувати для розподілу робочого навантаження між кількома "

"одночасними завданнями:"

msgid ""

"import asyncio\n"

"import random\n"

"import time\n"

"\n"

"\n"

"async def worker(name, queue):\n"

" while True:\n"

" # Get a \"work item\" out of the queue.\n"

" sleep_for = await queue.get()\n"

"\n"

" # Sleep for the \"sleep_for\" seconds.\n"

" await asyncio.sleep(sleep_for)\n"

"\n"

" # Notify the queue that the \"work item\" has been processed.\n"

" queue.task_done()\n"

"\n"

" print(f'{name} has slept for {sleep_for:.2f} seconds')\n"

"\n"

"\n"

"async def main():\n"

" # Create a queue that we will use to store our \"workload\".\n"

" queue = asyncio.Queue()\n"

"\n"

" # Generate random timings and put them into the queue.\n"

" total_sleep_time = 0\n"

" for _ in range(20):\n"

" sleep_for = random.uniform(0.05, 1.0)\n"

" total_sleep_time += sleep_for\n"

" queue.put_nowait(sleep_for)\n"

"\n"

" # Create three worker tasks to process the queue concurrently.\n"

" tasks = []\n"

" for i in range(3):\n"

" task = asyncio.create_task(worker(f'worker-{i}', queue))\n"

" tasks.append(task)\n"

"\n"

" # Wait until the queue is fully processed.\n"

" started_at = time.monotonic()\n"

" await queue.join()\n"

" total_slept_for = time.monotonic() - started_at\n"

"\n"

" # Cancel our worker tasks.\n"

" for task in tasks:\n"

" task.cancel()\n"

" # Wait until all worker tasks are cancelled.\n"

" await asyncio.gather(*tasks, return_exceptions=True)\n"

"\n"

" print('====')\n"

" print(f'3 workers slept in parallel for {total_slept_for:.2f} seconds')\n"

" print(f'total expected sleep time: {total_sleep_time:.2f} seconds')\n"

"\n"

"\n"

"asyncio.run(main())"

msgstr ""