code: def collapseCycles(self):
          
          # This algorithm determines Strongly Connected Components.  Look it up.
          # It is adapted to suit our data structures.
          # Phase 0: prepare the graph
          imports = {}
          for u in self.modules:
              imports[u] = set()
              for v in self.modules[u].imports:
                  if v in self.modules: # skip external dependencies
                      imports[u].add(v)
          # Phase 1: order the vertices
          visited = {}
          for u in self.modules:
              visited[u] = False
          order = []
          def visit1(u):
              visited[u] = True
              for v in imports[u]:
                  if not visited[v]:
                      visit1(v)
              order.append(u)
          for u in self.modules:
              if not visited[u]:
                  visit1(u)
          order.reverse()
          # Phase 2: compute the inverse graph
          revimports = {}
          for u in self.modules:
              revimports[u] = set()
          for u in self.modules:
              for v in imports[u]:
                  revimports[v].add(u)
          # Phase 3: determine the strongly connected components
          components = {}
          component_of = {}
          for u in self.modules:
              visited[u] = False
          def visit2(u):
              visited[u] = True
              component.append(u)
              for v in revimports[u]:
                  if not visited[v]:
                      visit2(v)
          for u in order:
              if not visited[u]:
                  component = []
                  visit2(u)
                  component.sort()
                  node = ModuleCycle(component)
                  components[node.modname] = node
                  for modname in component:
                      component_of[modname] = node
          # Phase 4: construct the condensed graph
          for node in components.values():
              for modname in node.modnames:
                  for impname in imports[modname]:
                      other = component_of[impname].modname
                      if other != node.modname:
                          node.imports.add(other)
          graph = ModuleGraph()
          graph.modules = components
          return graph
docs: Create a graph with cycles collapsed.
  
          Collapse modules participating in a cycle to a single node.