code: def topological_sort(graph_unsorted):
      """Repeatedly go through all of the nodes in the graph, moving each of the nodes that has all its edges
      resolved, onto a sequence that forms our sorted graph.
  
      A node has all of its edges resolved and can be moved once all the nodes its edges point to, have been moved from
      the unsorted graph onto the sorted one.
      """
  
      # This is the list we'll return, that stores each node/edges pair
      # in topological order.
      graph_sorted = []
  
      # Convert the unsorted graph into a hash table. This gives us
      # constant-time lookup for checking if edges are unresolved, and
      # for removing nodes from the unsorted graph.
      graph_unsorted = dict(graph_unsorted)
  
      # Run until the unsorted graph is empty.
      while graph_unsorted:
          # Go through each of the node/edges pairs in the unsorted
          # graph. If a set of edges does not contain any nodes that
          # haven't been resolved, that is, that are still in the
          # unsorted graph, remove the pair from the unsorted graph,
          # and append it to the sorted graph. Note here that by using
          # using the items() method for iterating, a copy of the
          # unsorted graph is used, allowing us to modify the unsorted
          # graph as we move through it. We also keep a flag for
          # checking that that graph is acyclic, which is true if any
          # nodes are resolved during each pass through the graph. If
          # not, we need to bail out as the graph therefore can't be
          # sorted.
          acyclic = False
          for node, edges in list(graph_unsorted.items()):
              if edges is None:
                  edges = []
              for edge in edges:
                  if edge in graph_unsorted:
                      break
              else:
                  acyclic = True
                  del graph_unsorted[node]
                  graph_sorted.append((node, edges))
  
          if not acyclic:
              # Uh oh, we've passed through all the unsorted nodes and
              # weren't able to resolve any of them, which means there
              # are nodes with cyclic edges that will never be resolved,
              # so we bail out with an error.
              raise RuntimeError("A cyclic dependency occurred")
  
      return graph_sorted
  
label_desc: Use image node_id 1 for calling a global function with example usage: topological_sort(graph_unsorted) and returns: graph_sorted