"graphlib" ---Funcionalidad para operar con estructuras de tipo-grafo
*********************************************************************

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

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

class graphlib.TopologicalSorter(graph=None)

   Provides functionality to topologically sort a graph of *hashable*
   nodes.

   Un ordenamiento topológico es un ordenamiento lineal de los
   vértices en un grafo de modo que para cada arista dirigida u -> v
   desde el vértice u al vértice v, el vértice u viene antes del
   vértice v en el ordenamiento. Por ejemplo, los vértices del grafo
   pueden representar tareas a realizar y las aristas pueden
   representar restricciones de que una tarea debe realizarse antes
   que otra; en este ejemplo, un ordenamiento topológico es solo una
   secuencia válida para las tareas. Es posible un ordenamiento
   topológico completo si y solo si el grafo no tiene ciclos
   dirigidos, es decir, si es un grafo acíclico dirigido.

   Si se proporciona el argumento opcional *graph*, este debe ser un
   diccionario que represente un grafo acíclico dirigido donde las
   claves son nodos y los valores son iterables de todos los
   predecesores de ese nodo en el grafo (los nodos que tienen las
   aristas que apuntan al valor clave). Se pueden agregar nodos
   adicionales al grafo utilizando el "add()" method.

   En el caso general, los pasos necesarios para realizar el
   ordenamiento de un grafo son los siguientes:

      * Cree una instancia "TopologicalSorter" con un grafo inicial
        opcional.

      * Agregue nodos adicionales al grafo.

      * Llame a "prepare()" en el grafo.

      * Mientras "is_active()" is "True", itere sobre los nodos
        retornados por "get_ready()" y procéselos . Llame a "done()"
        en cada nodo a medida que finaliza el procesamiento.

   En caso de que sólo se requiera una ordenación inmediata de los
   nodos del grafo y no haya paralelismo, se puede utilizar
   directamente el método de conveniencia
   "TopologicalSorter.static_order()"

      >>> graph = {"D": {"B", "C"}, "C": {"A"}, "B": {"A"}}
      >>> ts = TopologicalSorter(graph)
      >>> tuple(ts.static_order())
      ('A', 'C', 'B', 'D')

   La clase está diseñada para soportar fácilmente el procesamiento en
   paralelo de los nodos a medida que estén listos. Para la instancia:

      topological_sorter = TopologicalSorter()

      # Add nodes to 'topological_sorter'...

      topological_sorter.prepare()
      while topological_sorter.is_active():
          for node in topological_sorter.get_ready():
              # Worker threads or processes take nodes to work on off the
              # 'task_queue' queue.
              task_queue.put(node)

          # When the work for a node is done, workers put the node in
          # 'finalized_tasks_queue' so we can get more nodes to work on.
          # The definition of 'is_active()' guarantees that, at this point, at
          # least one node has been placed on 'task_queue' that hasn't yet
          # been passed to 'done()', so this blocking 'get()' must (eventually)
          # succeed.  After calling 'done()', we loop back to call 'get_ready()'
          # again, so put newly freed nodes on 'task_queue' as soon as
          # logically possible.
          node = finalized_tasks_queue.get()
          topological_sorter.done(node)

   add(node, *predecessors)

      Add a new node and its predecessors to the graph. Both the
      *node* and all elements in *predecessors* must be *hashable*.

      Si se llama varias veces con el mismo argumento del nodo, el
      conjunto de dependencias será la unión de todas las dependencias
      pasadas.

      Es posible añadir un nodo sin dependencias (no se proporciona
      *predecessors*) o proporcionar una dependencia dos veces. Si un
      nodo que no se ha proporcionado antes se incluye entre los
      *predecessors*, se añadirá automáticamente al grafo sin
      predecesores propios.

      Provoca "ValueError" si se llama después de "prepare()".

   prepare()

      Marca el grafo como terminado y comprueba si existen ciclos en
      el grafo. Si se detecta algún ciclo, se lanzará "CycleError",
      pero se puede seguir utilizando "get_ready()" para obtener
      tantos nodos como sea posible hasta que los ciclos bloqueen más
      el progreso. Después de una llamada a esta función, el grafo no
      puede ser modificado, y por lo tanto no se pueden añadir más
      nodos utilizando "add()".

   is_active()

      Retorna "True" si se puede avanzar más y "False" en caso
      contrario. Se puede avanzar si los ciclos no bloquean la
      resolución y, o bien todavía existen nodos listos que aún no han
      sido retornados por "TopologicalSorter.get_ready()" o el número
      de nodos marcados con "TopologicalSorter.done()" es menor que el
      número que han sido retornados por
      "TopologicalSorter.get_ready()".

      El método "__bool__()" de esta clase defiere a esta función, por
      lo que en lugar de:

         if ts.is_active():
             ...

      es posible hacer simplemente:

         if ts:
             ...

      Lanzar "ValueError" si se llama sin llamar previamente a
      "prepare()".

   done(*nodes)

      Marca un conjunto de nodos retornados por
      "TopologicalSorter.get_ready()" como procesados, desbloqueando
      cualquier sucesor de cada nodo en *nodes* para ser retornado en
      el futuro por una llamada a "TopologicalSorter.get_ready()".

      Lanza "ValueError" si algún nodo de *nodes* ya ha sido marcado
      como procesado por una llamada anterior a este método o si un
      nodo no fue añadido al grafo usando "TopologicalSorter.add()",
      si se llama sin llamar a "prepare()" o si el nodo aún no ha sido
      retornado por "get_ready()".

   get_ready()

      Retorna una "tupla" con todos los nodos que están listos.
      Inicialmente retorna todos los nodos sin predecesores, y una vez
      que éstos se marcan como procesados llamando a
      "TopologicalSorter.done()", las llamadas posteriores devolverán
      todos los nuevos nodos que tengan todos sus predecesores ya
      procesados. Una vez que no se puede avanzar más, se retornan
      tuplas vacías.

      Lanzar "ValueError" si se llama sin llamar previamente a
      "prepare()".

   static_order()

      Retorna un iterable de nodos en un ordenamiento topológico. El
      uso de este método no requiere llamar a
      "TopologicalSorter.prepare()" o "TopologicalSorter.done()". Este
      método es equivalente a:

         def static_order(self):
             self.prepare()
             while self.is_active():
                 node_group = self.get_ready()
                 yield from node_group
                 self.done(*node_group)

      El orden concreto que se retorna puede depender del orden
      específico en que se insertaron los elementos en el grafo. Por
      ejemplo:

         >>> ts = TopologicalSorter()
         >>> ts.add(3, 2, 1)
         >>> ts.add(1, 0)
         >>> print([*ts.static_order()])
         [2, 0, 1, 3]

         >>> ts2 = TopologicalSorter()
         >>> ts2.add(1, 0)
         >>> ts2.add(3, 2, 1)
         >>> print([*ts2.static_order()])
         [0, 2, 1, 3]

      Esto se debe a que "0" y "2" están en el mismo nivel en el
      gráfico (habrían sido retornados en la misma llamada a
      "get_ready()") y el orden entre ellos está determinado por el
      orden de inserción.

      Si se detecta algún ciclo, se lanzará "CycleError".

   Nuevo en la versión 3.9.


Excepciones
===========

El módulo "graphlib" define las siguientes clases de excepción:

exception graphlib.CycleError

   Subclase de "ValueError" planteada por
   "TopologicalSorter.prepare()" si existen ciclos en el grafo de
   trabajo. Si existen múltiples ciclos, sólo se informará de una
   elección indefinida entre ellos y se incluirá en la excepción.

   Se puede acceder al ciclo detectado a través del segundo elemento
   del atributo "args" de la instancia de la excepción y consiste en
   una lista de nodos, tal que cada nodo este, en el grafo, un
   predecesor inmediato del siguiente nodo en la lista. En la lista
   reportada, el primer y el último nodo serán el mismo, para dejar
   claro que es cíclico.
