File indexing completed on 2024-04-14 05:35:11

 #!/usr/bin/python
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2017 Sandro Knauß <sknauss@kde.org>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 
 """Graph the dependencies of all pim packages.
 
 The dependencies are minimized, so that only direct dependencies are shown.
 The green dots are packages without depdencies inside the set.
 The lightblue dots are one end of the build chain.
 
 If you have something like this:
 
     a -> b -> c
     a -> c
 the second depdency is not shown.
 
 You can enable the full dependency if you replace sgraph -> graph in the last for loop.
 
 The tier graph shows you a tier based view to pim packages.
 One tier is defined as a maximum set of packages, that do not depend on each other and only
 depend on lower tiers. Only dependecies from one tier to the next one are shown. Ellipsed shape
 packages without arrows are indicating, that they could be built in a higher tier. Diamond shape
 indicate that nothing depends on this anymore.
 
 usage:
 git clone kde:kde-build-metadata
 <pathto>/pim-build-deps-graphs.py > pim-graphs.dot
 dot -T png -o kde-build-metadata-17.12-deps.png  pim-graphs.dot > kde-build-metadata-17.12-tier.png
 """
 
 from __future__ import print_function
 
 import re
 import copy
 
 __fresh_id = 0
 
 def main():
     def get_id():
         global __fresh_id
         __fresh_id += 1
         return ("NODE_%d" % __fresh_id)
 
     def emit_arc(node1, node2):
         print('  "%s" -> "%s" ;' % (node1, node2))
     def emit_node(node, dsc=None):
         if dsc is None:
               print('  "%s";' % (node))
         else:
               print('  "%s" [label="%s"];' % (node, dsc))
     def emit_nodecolor(node, color):
         print('  "%s" [fillcolor="%s", style="filled"] ;' % (node, color))
 
 
     line = re.compile(r"^([^#^:]+):\s*([^#]+)\s*(#.*)?$")
     graph = {}
     for i in open('kde-build-metadata/dependency-data-kf5-qt5').readlines():
          if not i.strip():
              continue
          m = line.match(i)
          if not m:
              continue
          pkg = m.group(1).strip()
          dep = m.group(2).strip()
          if not pkg.startswith("kde/pim/"):
              continue
          else:
              pkg = pkg[len("kde/pim/"):]
 
          if not pkg in graph:
              graph[pkg] = set()
 
          if not dep.startswith("kde/pim/"):
              continue
          else:
              dep = dep[len("kde/pim/"):]
 
          if not dep in graph:
              graph[dep] = set()
 
          graph[pkg].add(dep)
 
     sgraph = {}     # minimized graph
     fgraph = graph  # full dependency graph
 
     for i in range(10):
         changed = False
         ograph = fgraph
         for pkg in ograph:
             deps = copy.copy(ograph[pkg])
             for dep in ograph[pkg]:
                 deps |= ograph[dep]
             if deps != ograph[pkg]:
                 changed = True
             fgraph[pkg] = deps
 
         if not changed:
             break
 
     for pkg in fgraph:
         deps = copy.copy(graph[pkg])
         for dep in graph[pkg]:
             deps -= fgraph[dep]
         sgraph[pkg] = deps
 
     pkgs = set(graph.keys())     # packages to order into tiers
     tiers = []                   # each tier will be one entry
     deps = set()                 # All deps from lower tiers
 
     while pkgs:
         tD = set()
         if tiers:
             deps |= tiers[-1]
         tiers.append(set())
         for pkg in pkgs:
             if not (sgraph[pkg] - deps):
                 tiers[-1].add(pkg)
                 tD.add(pkg)
         pkgs -= tD
 
     ends = set()
 
     for pkg in graph:
         name = pkg
         sDeps = sgraph[pkg]
         if sDeps:
             for p in sgraph:
                 if p == pkg:
                     continue
                 if pkg in sgraph[p]:
                     break
             else:
                 ends.add(name)
 
     print("digraph pim {")
     for pkg in graph:
         name = pkg
         sDeps = sgraph[pkg]
         if sDeps == set():
             emit_nodecolor(name, 'darkgreen')
         else:
             for p in sgraph:
                 if p == pkg:
                     continue
                 if pkg in sgraph[p]:
                     break
             else:
                 emit_nodecolor(name, 'lightblue')
 
     for pkg in graph:
         name = pkg
         sDeps = sgraph[pkg]
         for dep in sDeps:
             emit_arc(dep, name)
     print("}")
 
     print("digraph pimTier {")
     print("    node [shape=diamond,fillcolor=lightblue,style=filled];")
     for pkg in ends:    # all end notes
         emit_node(pkg)
     print("    node [shape=ellipse,fillcolor=darkgreen];")
     for pkg in tiers[0]:    #   all dependency free packages - aka tier 0
         emit_node(pkg)
     print("    node [shape=ellipse,fillcolor=white];")
     for index, tier in enumerate(tiers):
         print("  subgraph cluster_{} {{".format(index))
         print("     style=filled;")
         print("     color=lightgrey;")
         print('     label = "Tier {}";'.format(index))
         for pkg in tier:
             emit_node(pkg)
         print("  }")
         if index > 0:
             subTier = tiers[index-1]
             for pkg in tier:
                 for dep in (sgraph[pkg] & subTier):
                     emit_arc(dep, pkg)
     print("}")
 
 
 
 if __name__ == '__main__':
     main()