queue.po

# Copyright (C) 2001-2020, Python Software Foundation
# This file is distributed under the same license as the Python package.
# Maintained by the python-doc-es workteam.
# docs-es@python.org /
# https://mail.python.org/mailman3/lists/docs-es.python.org/
# Check https://github.com/python/python-docs-es/blob/3.8/TRANSLATORS to
# get the list of volunteers
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2022-10-25 19:47+0200\n"
"PO-Revision-Date: 2022-11-17 12:05-0300\n"
"Last-Translator: \n"
"Language-Team: python-doc-es\n"
"Language: es\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"Generated-By: Babel 2.10.3\n"
"X-Generator: Poedit 3.0.1\n"

#: ../Doc/library/queue.rst:2
msgid ":mod:`queue` --- A synchronized queue class"
msgstr ":mod:`queue` --- clase de cola sincronizada"

#: ../Doc/library/queue.rst:7
msgid "**Source code:** :source:`Lib/queue.py`"
msgstr "**Código fuente:** :source:`Lib/queue.py`"

#: ../Doc/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 ""
"El módulo :mod:`queue` implementa colas multi-productor y multi-consumidor. "
"Es especialmente útil en la programación en hilo cuando la información debe "
"intercambiarse de forma segura entre varios subprocesos.  La clase :class:"
"`Queue` de este módulo implementa toda la semántica de bloqueo necesaria."

#: ../Doc/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 ""
"El módulo implementa tres tipos de cola, que difieren sólo en el orden en "
"que se recuperan las entradas.  En una cola :abbr:`FIFO (first-in, first-"
"out)`, las primeras tareas añadidas son las primeras recuperadas. En una "
"cola :abbr:`LIFO (last-in, first-out)`, la última entrada añadida es la "
"primera recuperada (operando como una pila).  En una cola de prioridad, las "
"entradas se mantienen ordenadas (usando el módulo :mod:`heapq`) y la entrada "
"de menor valor se recupera primero."

#: ../Doc/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 ""
"Internamente, estos tres tipos de colas utilizan bloqueos para bloquear "
"temporalmente los hilos que compiten entre sí; sin embargo, no están "
"diseñadas para manejar la reposición dentro de un hilo."

#: ../Doc/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 ""
"Además, el módulo implementa un tipo de cola \"simple\" :abbr:`FIFO (first-"
"in, first-out)`, :class:`SimpleQueue`, cuya implementación específica "
"proporciona garantías adicionales a cambio de una funcionalidad menor."

#: ../Doc/library/queue.rst:33
msgid "The :mod:`queue` module defines the following classes and exceptions:"
msgstr "El módulo :mod:`queue` define las siguientes clases y excepciones:"

#: ../Doc/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 ""
"Constructor para una cola :abbr:`FIFO (first-in, first-out)`.  *maxsize* es "
"un número entero que establece el límite superior del número de elementos "
"que pueden ser colocados en la cola.  La inserción se bloqueará una vez que "
"se haya alcanzado este tamaño, hasta que se consuman los elementos de la "
"cola.  Si *maxsize* es menor o igual a cero, el tamaño de la cola es "
"infinito."

#: ../Doc/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 ""
"Constructor para una cola :abbr:`LIFO (último en entrar, primero en "
"salir)`.  *maxsize* es un número entero que establece el límite superior del "
"número de elementos que pueden ser colocados en la cola.  La inserción se "
"bloqueará una vez que se haya alcanzado este tamaño, hasta que se consuman "
"los elementos de la cola.  Si *maxsize* es menor o igual a cero, el tamaño "
"de la cola es infinito."

#: ../Doc/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 ""
"Constructor para una cola de prioridad.  *maxsize* es un número entero que "
"establece el límite superior del número de elementos que pueden ser "
"colocados en la cola.  La inserción se bloqueará una vez que se haya "
"alcanzado este tamaño, hasta que se consuman los elementos de la cola.  Si "
"*maxsize* es menor o igual a cero, el tamaño de la cola es infinito."

#: ../Doc/library/queue.rst:59
msgid ""
"The lowest valued entries are retrieved first (the lowest valued entry is "
"the one returned by ``sorted(list(entries))[0]``).  A typical pattern for "
"entries is a tuple in the form: ``(priority_number, data)``."
msgstr ""
"Las entradas de menor valor se recuperan primero (la entrada de menor valor "
"es la retornada por ``sorted(list(entries))[0]``).  Un patrón típico para "
"las entradas es una tupla en la forma: ``(número_de_prioridad, datos)``."

#: ../Doc/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 ""
"Si los elementos de *datos* no son comparables, los datos pueden envolverse "
"en una clase que ignore el elemento de datos y sólo compare el número de "
"prioridad::"

#: ../Doc/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 ""
"Constructor de una cola sin límites :abbr:`FIFO (first-in, first-out)`. Las "
"colas simples carecen de funcionalidad avanzada como el seguimiento de "
"tareas."

#: ../Doc/library/queue.rst:84
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 ""
"Excepción lanzada cuando el objeto :meth:`~Queue.get` (o :meth:`~Queue."
"get_nowait`) que no se bloquea es llamado en un objeto :class:`Queue` que "
"está vacío."

#: ../Doc/library/queue.rst:91
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 ""
"Excepción lanzada cuando el objeto :meth:`~Queue.put` (o :meth:`~Queue."
"put_nowait`) que no se bloquea es llamado en un objeto :class:`Queue` que "
"está lleno."

#: ../Doc/library/queue.rst:99
msgid "Queue Objects"
msgstr "Objetos de la cola"

#: ../Doc/library/queue.rst:101
msgid ""
"Queue objects (:class:`Queue`, :class:`LifoQueue`, or :class:"
"`PriorityQueue`) provide the public methods described below."
msgstr ""
"Los objetos de la cola (:class:`Queue`, :class:`LifoQueue`, o :class:"
"`PriorityQueue`) proporcionan los métodos públicos descritos a continuación."

#: ../Doc/library/queue.rst:107
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 ""
"Retorna el tamaño aproximado de la cola.  Nota, qsize() > 0 no garantiza que "
"un get() posterior no se bloquee, ni *qsize() < maxsize* garantiza que put() "
"no se bloquee."

#: ../Doc/library/queue.rst:114
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 ""
"Retorna ``True`` si la cola está vacía, ``False`` si no.  Si empty() retorna "
"``True`` no garantiza que una llamada posterior a put() no se bloquee.  Del "
"mismo modo, si empty() retorna ``False`` no garantiza que una llamada "
"posterior a get() no se bloquee."

#: ../Doc/library/queue.rst:122
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 ""
"Retorna ``True`` si la cola está llena, ``False`` si no.  Si full() retorna "
"``True`` no garantiza que una llamada posterior a get() no se bloquee.  Del "
"mismo modo, si full() retorna ``False`` no garantiza que una llamada "
"posterior a put() no se bloquee."

#: ../Doc/library/queue.rst:130
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 ""
"Pone el *item* en la cola. Si el argumento opcional *block* es verdadero y "
"*timeout* es ``None`` (el predeterminado), bloquea si es necesario hasta que "
"un espacio libre esté disponible. Si *timeout* es un número positivo, "
"bloquea como máximo *timeout* segundos y aumenta la excepción :exc:`Full` si "
"no había ningún espacio libre disponible en ese tiempo. De lo contrario "
"(*block* es falso), pone un elemento en la cola si un espacio libre está "
"disponible inmediatamente, o bien lanza la excepción :exc:`Full` (*timeout* "
"es ignorado en ese caso)."

#: ../Doc/library/queue.rst:141
msgid "Equivalent to ``put(item, block=False)``."
msgstr "Equivalente a ``put(item, block=False)``."

#: ../Doc/library/queue.rst:146
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 ""
"Retira y retorna un elemento de la cola. Si el argumento opcional *block* es "
"verdadero y *timeout* es ``None`` (el predeterminado), bloquea si es "
"necesario hasta que un elemento esté disponible. Si *timeout* es un número "
"positivo, bloquea como máximo *timeout* segundos y aumenta la excepción :exc:"
"`Empty` si no había ningún elemento disponible en ese tiempo. De lo "
"contrario (*block* es falso), retorna un elemento si uno está disponible "
"inmediatamente, o bien lanza la excepción :exc:`Empty` (*timeout* es "
"ignorado en ese caso)."

#: ../Doc/library/queue.rst:153
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 ""
"Antes de la 3.0 en los sistemas POSIX, y para todas las versiones en "
"Windows, si *block* es verdadero y *timeout* es ``None``, esta operación "
"entra en una espera ininterrumpida en una cerradura subyacente. Esto "
"significa que no puede haber excepciones, y en particular una SIGINT no "
"disparará una :exc:`KeyboardInterrupt`."

#: ../Doc/library/queue.rst:161 ../Doc/library/queue.rst:268
msgid "Equivalent to ``get(False)``."
msgstr "Equivalente a ``get(False)``."

#: ../Doc/library/queue.rst:163
msgid ""
"Two methods are offered to support tracking whether enqueued tasks have been "
"fully processed by daemon consumer threads."
msgstr ""
"Se ofrecen dos métodos para apoyar el seguimiento si las tareas en cola han "
"sido completamente procesadas por hilos *daemon* de consumo."

#: ../Doc/library/queue.rst:169
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 ""
"Indica que una tarea anteriormente en cola está completa.  Utilizado por los "
"hilos de la cola de consumo.  Por cada :meth:`get` usado para recuperar una "
"tarea, una llamada posterior a :meth:`task_done` le dice a la cola que el "
"procesamiento de la tarea está completo."

#: ../Doc/library/queue.rst:173
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 ""
"Si un :meth:`join` se está bloqueando actualmente, se reanudará cuando todos "
"los ítems hayan sido procesados (lo que significa que se recibió una "
"llamada :meth:`task_done` por cada ítem que había sido :meth:`put` en la "
"cola)."

#: ../Doc/library/queue.rst:177
msgid ""
"Raises a :exc:`ValueError` if called more times than there were items placed "
"in the queue."
msgstr ""
"Lanza un :exc:`ValueError` si se llama más veces de las que hay elementos "
"colocados en la cola."

#: ../Doc/library/queue.rst:183
msgid "Blocks until all items in the queue have been gotten and processed."
msgstr ""
"Bloquea hasta que todos los artículos de la cola se hayan obtenido y "
"procesado."

#: ../Doc/library/queue.rst:185
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 ""
"El conteo de tareas sin terminar sube cada vez que se añade un elemento a la "
"cola. El conteo baja cuando un hilo de consumidor llama :meth:`task_done` "
"para indicar que el elemento fue recuperado y todo el trabajo en él está "
"completo. Cuando el conteo de tareas sin terminar cae a cero, :meth:`join` "
"se desbloquea."

#: ../Doc/library/queue.rst:191
msgid "Example of how to wait for enqueued tasks to be completed::"
msgstr "Ejemplo de cómo esperar a que se completen las tareas en cola::"

#: ../Doc/library/queue.rst:218
msgid "SimpleQueue Objects"
msgstr "Objetos de cola simple"

#: ../Doc/library/queue.rst:220
msgid ""
":class:`SimpleQueue` objects provide the public methods described below."
msgstr ""
"Los objetos :class:`SimpleQueue` proporcionan los métodos públicos descritos "
"a continuación."

#: ../Doc/library/queue.rst:224
msgid ""
"Return the approximate size of the queue.  Note, qsize() > 0 doesn't "
"guarantee that a subsequent get() will not block."
msgstr ""
"Retorna el tamaño aproximado de la cola.  Nota, qsize() > 0 no garantiza que "
"un get() posterior no se bloquee."

#: ../Doc/library/queue.rst:230
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 ""
"Retorna ``True`` si la cola está vacía, ``False`` si no. Si empty() retorna "
"``False`` no garantiza que una llamada posterior a get() no se bloquee."

#: ../Doc/library/queue.rst:237
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 ""
"Pone el elemento en la cola.  El método nunca se bloquea y siempre tiene "
"éxito (excepto por posibles errores de bajo nivel como la falta de "
"asignación de memoria). Los argumentos opcionales *block* y *timeout* son "
"ignorados y sólo se proporcionan por compatibilidad con :meth:`Queue.put`."

#: ../Doc/library/queue.rst:243
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 ""
"Este método tiene una implementación en C la cual ha sido usada "
"anteriormente. Los llamados ``put()`` o ``get()`` pueden ser interrumpidos "
"por otro llamado ``put()`` en el mismo hilo sin bloquear o corromper el "
"estado interno dentro de la fila. Esto lo hace apropiado para su uso en "
"destructores como los métodos ``__del__`` o las retrollamadas :mod:`weakref`."

#: ../Doc/library/queue.rst:252
msgid ""
"Equivalent to ``put(item, block=False)``, provided for compatibility with :"
"meth:`Queue.put_nowait`."
msgstr ""
"Equivalente a ``put(item, block=False)``, siempre y cuando sea compatible "
"con :meth:`Queue.put_nowait``."

#: ../Doc/library/queue.rst:258
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 ""
"Retira y retorna un elemento de la cola.  Si los argumentos opcionales "
"*block* son true y *timeout* es ``None`` (el predeterminado), bloquea si es "
"necesario hasta que un elemento esté disponible. Si *timeout* es un número "
"positivo, bloquea como máximo *timeout* segundos y lanza la excepción :exc:"
"`Empty` si no había ningún elemento disponible en ese tiempo. De lo "
"contrario (*block* es falso), retorna un elemento si uno está disponible "
"inmediatamente, o bien lanza la excepción :exc:`Empty` (*timeout* es "
"ignorado en ese caso)."

#: ../Doc/library/queue.rst:275
msgid "Class :class:`multiprocessing.Queue`"
msgstr "Clase :class:`multiprocessing.Queue`"

#: ../Doc/library/queue.rst:274
msgid ""
"A queue class for use in a multi-processing (rather than multi-threading) "
"context."
msgstr ""
"Una clase de cola para su uso en un contexto de multiprocesamiento (en lugar "
"de multihilo)."

#: ../Doc/library/queue.rst:277
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 ""
":class:`collections.deque` es una implementación alternativa de colas sin "
"límites con operaciones atómicas rápidas :meth:`~collections.deque.append` "
"y :meth:`~collections.deque.popleft` que no requieren bloqueo y también "
"soportan indexación."