Tools/scripts/pdeps.py

   1 #! /usr/bin/env python
   2
   3 # pdeps
   4 #
   5 # Find dependencies between a bunch of Python modules.
   6 #
   7 # Usage:
   8 #       pdeps file1.py file2.py ...
   9 #
  10 # Output:
  11 # Four tables separated by lines like '--- Closure ---':
  12 # 1) Direct dependencies, listing which module imports which other modules
  13 # 2) The inverse of (1)
  14 # 3) Indirect dependencies, or the closure of the above
  15 # 4) The inverse of (3)
  16 #
  17 # To do:
  18 # - command line options to select output type
  19 # - option to automatically scan the Python library for referenced modules
  20 # - option to limit output to particular modules
  21
  22
  23 import sys
  24 import re
  25 import os
  26
  27
  28 # Main program
  29 #
  30 def main():
  31     args = sys.argv[1:]
  32     if not args:
  33         print 'usage: pdeps file.py file.py ...'
  34         return 2
  35     #
  36     table = {}
  37     for arg in args:
  38         process(arg, table)
  39     #
  40     print '--- Uses ---'
  41     printresults(table)
  42     #
  43     print '--- Used By ---'
  44     inv = inverse(table)
  45     printresults(inv)
  46     #
  47     print '--- Closure of Uses ---'
  48     reach = closure(table)
  49     printresults(reach)
  50     #
  51     print '--- Closure of Used By ---'
  52     invreach = inverse(reach)
  53     printresults(invreach)
  54     #
  55     return 0
  56
  57
  58 # Compiled regular expressions to search for import statements
  59 #
  60 m_import = re.compile('^[ \t]*from[ \t]+([^ \t]+)[ \t]+')
  61 m_from = re.compile('^[ \t]*import[ \t]+([^#]+)')
  62
  63
  64 # Collect data from one file
  65 #
  66 def process(filename, table):
  67     fp = open(filename, 'r')
  68     mod = os.path.basename(filename)
  69     if mod[-3:] == '.py':
  70         mod = mod[:-3]
  71     table[mod] = list = []
  72     while 1:
  73         line = fp.readline()
  74         if not line: break
  75         while line[-1:] == '\\':
  76             nextline = fp.readline()
  77             if not nextline: break
  78             line = line[:-1] + nextline
  79         if m_import.match(line) >= 0:
  80             (a, b), (a1, b1) = m_import.regs[:2]
  81         elif m_from.match(line) >= 0:
  82             (a, b), (a1, b1) = m_from.regs[:2]
  83         else: continue
  84         words = line[a1:b1].split(',')
  85         # print '#', line, words
  86         for word in words:
  87             word = word.strip()
  88             if word not in list:
  89                 list.append(word)
  90
  91
  92 # Compute closure (this is in fact totally general)
  93 #
  94 def closure(table):
  95     modules = table.keys()
  96     #
  97     # Initialize reach with a copy of table
  98     #
  99     reach = {}
 100     for mod in modules:
 101         reach[mod] = table[mod][:]
 102     #
 103     # Iterate until no more change
 104     #
 105     change = 1
 106     while change:
 107         change = 0
 108         for mod in modules:
 109             for mo in reach[mod]:
 110                 if mo in modules:
 111                     for m in reach[mo]:
 112                         if m not in reach[mod]:
 113                             reach[mod].append(m)
 114                             change = 1
 115     #
 116     return reach
 117
 118
 119 # Invert a table (this is again totally general).
 120 # All keys of the original table are made keys of the inverse,
 121 # so there may be empty lists in the inverse.
 122 #
 123 def inverse(table):
 124     inv = {}
 125     for key in table.keys():
 126         if not inv.has_key(key):
 127             inv[key] = []
 128         for item in table[key]:
 129             store(inv, item, key)
 130     return inv
 131
 132
 133 # Store "item" in "dict" under "key".
 134 # The dictionary maps keys to lists of items.
 135 # If there is no list for the key yet, it is created.
 136 #
 137 def store(dict, key, item):
 138     if dict.has_key(key):
 139         dict[key].append(item)
 140     else:
 141         dict[key] = [item]
 142
 143
 144 # Tabulate results neatly
 145 #
 146 def printresults(table):
 147     modules = table.keys()
 148     maxlen = 0
 149     for mod in modules: maxlen = max(maxlen, len(mod))
 150     modules.sort()
 151     for mod in modules:
 152         list = table[mod]
 153         list.sort()
 154         print mod.ljust(maxlen), ':',
 155         if mod in list:
 156             print '(*)',
 157         for ref in list:
 158             print ref,
 159         print
 160
 161
 162 # Call main and honor exit status
 163 if __name__ == '__main__':
 164     try:
 165         sys.exit(main())
 166     except KeyboardInterrupt:
 167         sys.exit(1)