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 regex
  25 import os
  26 import string
  27
  28
  29 # Main program
  30 #
  31 def main():
  32     args = sys.argv[1:]
  33     if not args:
  34         print 'usage: pdeps file.py file.py ...'
  35         return 2
  36     #
  37     table = {}
  38     for arg in args:
  39         process(arg, table)
  40     #
  41     print '--- Uses ---'
  42     printresults(table)
  43     #
  44     print '--- Used By ---'
  45     inv = inverse(table)
  46     printresults(inv)
  47     #
  48     print '--- Closure of Uses ---'
  49     reach = closure(table)
  50     printresults(reach)
  51     #
  52     print '--- Closure of Used By ---'
  53     invreach = inverse(reach)
  54     printresults(invreach)
  55     #
  56     return 0
  57
  58
  59 # Compiled regular expressions to search for import statements
  60 #
  61 m_import = regex.compile('^[ \t]*from[ \t]+\([^ \t]+\)[ \t]+')
  62 m_from = regex.compile('^[ \t]*import[ \t]+\([^#]+\)')
  63
  64
  65 # Collect data from one file
  66 #
  67 def process(filename, table):
  68     fp = open(filename, 'r')
  69     mod = os.path.basename(filename)
  70     if mod[-3:] == '.py':
  71         mod = mod[:-3]
  72     table[mod] = list = []
  73     while 1:
  74         line = fp.readline()
  75         if not line: break
  76         while line[-1:] == '\\':
  77             nextline = fp.readline()
  78             if not nextline: break
  79             line = line[:-1] + nextline
  80         if m_import.match(line) >= 0:
  81             (a, b), (a1, b1) = m_import.regs[:2]
  82         elif m_from.match(line) >= 0:
  83             (a, b), (a1, b1) = m_from.regs[:2]
  84         else: continue
  85         words = string.splitfields(line[a1:b1], ',')
  86         # print '#', line, words
  87         for word in words:
  88             word = string.strip(word)
  89             if word not in list:
  90                 list.append(word)
  91
  92
  93 # Compute closure (this is in fact totally general)
  94 #
  95 def closure(table):
  96     modules = table.keys()
  97     #
  98     # Initialize reach with a copy of table
  99     #
 100     reach = {}
 101     for mod in modules:
 102         reach[mod] = table[mod][:]
 103     #
 104     # Iterate until no more change
 105     #
 106     change = 1
 107     while change:
 108         change = 0
 109         for mod in modules:
 110             for mo in reach[mod]:
 111                 if mo in modules:
 112                     for m in reach[mo]:
 113                         if m not in reach[mod]:
 114                             reach[mod].append(m)
 115                             change = 1
 116     #
 117     return reach
 118
 119
 120 # Invert a table (this is again totally general).
 121 # All keys of the original table are made keys of the inverse,
 122 # so there may be empty lists in the inverse.
 123 #
 124 def inverse(table):
 125     inv = {}
 126     for key in table.keys():
 127         if not inv.has_key(key):
 128             inv[key] = []
 129         for item in table[key]:
 130             store(inv, item, key)
 131     return inv
 132
 133
 134 # Store "item" in "dict" under "key".
 135 # The dictionary maps keys to lists of items.
 136 # If there is no list for the key yet, it is created.
 137 #
 138 def store(dict, key, item):
 139     if dict.has_key(key):
 140         dict[key].append(item)
 141     else:
 142         dict[key] = [item]
 143
 144
 145 # Tabulate results neatly
 146 #
 147 def printresults(table):
 148     modules = table.keys()
 149     maxlen = 0
 150     for mod in modules: maxlen = max(maxlen, len(mod))
 151     modules.sort()
 152     for mod in modules:
 153         list = table[mod]
 154         list.sort()
 155         print string.ljust(mod, maxlen), ':',
 156         if mod in list:
 157             print '(*)',
 158         for ref in list:
 159             print ref,
 160         print
 161
 162
 163 # Call main and honor exit status
 164 try:
 165     sys.exit(main())
 166 except KeyboardInterrupt:
 167     sys.exit(1)