"queue" --- A synchronized queue class
**************************************

**Código fuente:** Lib/queue.py

======================================================================

El módulo "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 "Queue" de este módulo implementa toda la semántica de bloqueo
necesaria.

The module implements three types of queue, which differ only in the
order in which the entries are retrieved.  In a FIFO (first-in, first-
out) queue, the first tasks added are the first retrieved.  In a 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 "heapq" module) and the lowest
valued entry is retrieved first.

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.

Además, el módulo implementa un tipo de cola "simple" FIFO (first-in,
first-out), "SimpleQueue", cuya implementación específica proporciona
garantías adicionales a cambio de una funcionalidad menor.

El módulo "queue" define las siguientes clases y excepciones:

class queue.Queue(maxsize=0)

   Constructor para una cola 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.

class queue.LifoQueue(maxsize=0)

   Constructor para una cola 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.

class queue.PriorityQueue(maxsize=0)

   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.

   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)".

   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:

      from dataclasses import dataclass, field
      from typing import Any

      @dataclass(order=True)
      class PrioritizedItem:
          priority: int
          item: Any=field(compare=False)

class queue.SimpleQueue

   Constructor de una cola sin límites FIFO (first-in, first-out). Las
   colas simples carecen de funcionalidad avanzada como el seguimiento
   de tareas.

   Added in version 3.7.

exception queue.Empty

   Excepción lanzada cuando el objeto "get()" (o "get_nowait()") que
   no se bloquea es llamado en un objeto "Queue" que está vacío.

exception queue.Full

   Excepción lanzada cuando el objeto "put()" (o "put_nowait()") que
   no se bloquea es llamado en un objeto "Queue" que está lleno.


Objetos de la cola
==================

Los objetos de la cola ("Queue", "LifoQueue", o "PriorityQueue")
proporcionan los métodos públicos descritos a continuación.

Queue.qsize()

   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.

Queue.empty()

   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.

Queue.full()

   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.

Queue.put(item, block=True, timeout=None)

   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 "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 "Full" exception (*timeout* is ignored in that
   case).

Queue.put_nowait(item)

   Equivalente a "put(item, block=False)".

Queue.get(block=True, timeout=None)

   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 "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 "Empty" (*timeout* es ignorado en ese
   caso).

   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
   "KeyboardInterrupt".

Queue.get_nowait()

   Equivalente a "get(False)".

Se ofrecen dos métodos para apoyar el seguimiento si las tareas en
cola han sido completamente procesadas por hilos *daemon* de consumo.

Queue.task_done()

   Indica que una tarea anteriormente en cola está completa.
   Utilizado por los hilos de la cola de consumo.  Por cada "get()"
   usado para recuperar una tarea, una llamada posterior a
   "task_done()" le dice a la cola que el procesamiento de la tarea
   está completo.

   Si un "join()" se está bloqueando actualmente, se reanudará cuando
   todos los ítems hayan sido procesados (lo que significa que se
   recibió una llamada "task_done()" por cada ítem que había sido
   "put()" en la cola).

   Lanza un "ValueError" si se llama más veces de las que hay
   elementos colocados en la cola.

Queue.join()

   Bloquea hasta que todos los artículos de la cola se hayan obtenido
   y procesado.

   The count of unfinished tasks goes up whenever an item is added to
   the queue. The count goes down whenever a consumer thread calls
   "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, "join()" unblocks.

Ejemplo de cómo esperar a que se completen las tareas en cola:

   import threading
   import queue

   q = queue.Queue()

   def worker():
       while True:
           item = q.get()
           print(f'Working on {item}')
           print(f'Finished {item}')
           q.task_done()

   # Turn-on the worker thread.
   threading.Thread(target=worker, daemon=True).start()

   # Send thirty task requests to the worker.
   for item in range(30):
       q.put(item)

   # Block until all tasks are done.
   q.join()
   print('All work completed')


Objetos de cola simple
======================

Los objetos "SimpleQueue" proporcionan los métodos públicos descritos
a continuación.

SimpleQueue.qsize()

   Retorna el tamaño aproximado de la cola.  Nota, qsize() > 0 no
   garantiza que un get() posterior no se bloquee.

SimpleQueue.empty()

   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.

SimpleQueue.put(item, block=True, timeout=None)

   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 "Queue.put()".

   **Detalles de implementación de CPython:** 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
   "weakref".

SimpleQueue.put_nowait(item)

   Equivalente a "put(item, block=False)", siempre y cuando sea
   compatible con "Queue.put_nowait`()".

SimpleQueue.get(block=True, timeout=None)

   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 "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 "Empty" (*timeout* es ignorado en ese
   caso).

SimpleQueue.get_nowait()

   Equivalente a "get(False)".

Ver también:

  Clase "multiprocessing.Queue"
     Una clase de cola para su uso en un contexto de
     multiprocesamiento (en lugar de multihilo).

  "collections.deque" es una implementación alternativa de colas sin
  límites con operaciones atómicas rápidas "append()" y "popleft()"
  que no requieren bloqueo y también soportan indexación.
