pyclbr.py 11.1 KB
Newer Older
1
"""Parse a Python file and retrieve classes and methods.
2 3 4 5 6

Parse enough of a Python file to recognize class and method
definitions and to find out the superclasses of a class.

The interface consists of a single function:
Tim Peters's avatar
Tim Peters committed
7
        readmodule(module, path)
8 9 10 11 12 13 14 15 16 17
module is the name of a Python module, path is an optional list of
directories where the module is to be searched.  If present, path is
prepended to the system search path sys.path.
The return value is a dictionary.  The keys of the dictionary are
the names of the classes defined in the module (including classes
that are defined via the from XXX import YYY construct).  The values
are class instances of the class Class defined here.

A class is described by the class Class in this module.  Instances
of this class have the following instance variables:
Tim Peters's avatar
Tim Peters committed
18 19 20 21 22
        name -- the name of the class
        super -- a list of super classes (Class instances)
        methods -- a dictionary of methods
        file -- the file in which the class was defined
        lineno -- the line in the file on which the class statement occurred
23 24 25 26 27 28 29 30 31
The dictionary of methods uses the method names as keys and the line
numbers on which the method was defined as values.
If the name of a super class is not recognized, the corresponding
entry in the list of super classes is not a class instance but a
string giving the name of the super class.  Since import statements
are recognized and imported modules are scanned as well, this
shouldn't happen often.

BUGS
32 33
- Continuation lines are not dealt with at all, except inside strings.
- Nested classes and functions can confuse it.
34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
- Code that doesn't pass tabnanny or python -t will confuse it, unless
  you set the module TABWIDTH vrbl (default 8) to the correct tab width
  for the file.

PACKAGE RELATED BUGS
- If you have a package and a module inside that or another package
  with the same name, module caching doesn't work properly since the
  key is the base name of the module/package.
- The only entry that is returned when you readmodule a package is a
  __path__ whose value is a list which confuses certain class browsers.
- When code does:
  from package import subpackage
  class MyClass(subpackage.SuperClass):
    ...
  It can't locate the parent.  It probably needs to have the same
  hairy logic that the import locator already does.  (This logic
  exists coded in Python in the freeze package.)
51
"""
52 53 54

import sys
import imp
55
import re
56 57
import string

58 59
__all__ = ["readmodule"]

60 61
TABWIDTH = 8

62
_getnext = re.compile(r"""
63 64
    (?P<String>
       \""" [^"\\]* (?:
Tim Peters's avatar
Tim Peters committed
65 66 67
                        (?: \\. | "(?!"") )
                        [^"\\]*
                    )*
68 69 70
       \"""

    |   ''' [^'\\]* (?:
Tim Peters's avatar
Tim Peters committed
71 72 73 74
                        (?: \\. | '(?!'') )
                        [^'\\]*
                    )*
        '''
75 76 77 78

    |   " [^"\\\n]* (?: \\. [^"\\\n]*)* "

    |   ' [^'\\\n]* (?: \\. [^'\\\n]*)* '
79 80 81
    )

|   (?P<Method>
Tim Peters's avatar
Tim Peters committed
82 83 84 85 86
        ^
        (?P<MethodIndent> [ \t]* )
        def [ \t]+
        (?P<MethodName> [a-zA-Z_] \w* )
        [ \t]* \(
87
    )
88

89
|   (?P<Class>
Tim Peters's avatar
Tim Peters committed
90 91 92 93 94 95 96
        ^
        (?P<ClassIndent> [ \t]* )
        class [ \t]+
        (?P<ClassName> [a-zA-Z_] \w* )
        [ \t]*
        (?P<ClassSupers> \( [^)\n]* \) )?
        [ \t]* :
97 98 99
    )

|   (?P<Import>
Tim Peters's avatar
Tim Peters committed
100 101
        ^ import [ \t]+
        (?P<ImportList> [^#;\n]+ )
102 103 104
    )

|   (?P<ImportFrom>
Tim Peters's avatar
Tim Peters committed
105 106 107 108 109 110 111 112 113 114
        ^ from [ \t]+
        (?P<ImportFromPath>
            [a-zA-Z_] \w*
            (?:
                [ \t]* \. [ \t]* [a-zA-Z_] \w*
            )*
        )
        [ \t]+
        import [ \t]+
        (?P<ImportFromList> [^#;\n]+ )
115 116 117 118
    )
""", re.VERBOSE | re.DOTALL | re.MULTILINE).search

_modules = {}                           # cache of modules we've seen
119 120 121

# each Python class is represented by an instance of this class
class Class:
Tim Peters's avatar
Tim Peters committed
122 123 124 125 126 127 128 129 130 131 132 133 134
    '''Class to represent a Python class.'''
    def __init__(self, module, name, super, file, lineno):
        self.module = module
        self.name = name
        if super is None:
            super = []
        self.super = super
        self.methods = {}
        self.file = file
        self.lineno = lineno

    def _addmethod(self, name, lineno):
        self.methods[name] = lineno
135

136
class Function(Class):
Tim Peters's avatar
Tim Peters committed
137 138 139 140 141
    '''Class to represent a top-level Python function'''
    def __init__(self, module, name, file, lineno):
        Class.__init__(self, module, name, None, file, lineno)
    def _addmethod(self, name, lineno):
        assert 0, "Function._addmethod() shouldn't be called"
142

143
def readmodule(module, path=[], inpackage=0):
Tim Peters's avatar
Tim Peters committed
144
    '''Backwards compatible interface.
145

Tim Peters's avatar
Tim Peters committed
146 147
    Like readmodule_ex() but strips Function objects from the
    resulting dictionary.'''
148

Tim Peters's avatar
Tim Peters committed
149 150 151 152 153 154
    dict = readmodule_ex(module, path, inpackage)
    res = {}
    for key, value in dict.items():
        if not isinstance(value, Function):
            res[key] = value
    return res
155 156

def readmodule_ex(module, path=[], inpackage=0):
Tim Peters's avatar
Tim Peters committed
157 158 159 160 161 162 163 164
    '''Read a module file and return a dictionary of classes.

    Search for MODULE in PATH and sys.path, read and parse the
    module and return a dictionary with one entry for each class
    found in the module.'''

    dict = {}

165
    i = module.rfind('.')
Tim Peters's avatar
Tim Peters committed
166 167
    if i >= 0:
        # Dotted module name
168 169
        package = module[:i].strip()
        submodule = module[i+1:].strip()
170 171
        parent = readmodule_ex(package, path, inpackage)
        child = readmodule_ex(submodule, parent['__path__'], 1)
Tim Peters's avatar
Tim Peters committed
172 173
        return child

174
    if module in _modules:
Tim Peters's avatar
Tim Peters committed
175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263
        # we've seen this module before...
        return _modules[module]
    if module in sys.builtin_module_names:
        # this is a built-in module
        _modules[module] = dict
        return dict

    # search the path for the module
    f = None
    if inpackage:
        try:
            f, file, (suff, mode, type) = \
                    imp.find_module(module, path)
        except ImportError:
            f = None
    if f is None:
        fullpath = list(path) + sys.path
        f, file, (suff, mode, type) = imp.find_module(module, fullpath)
    if type == imp.PKG_DIRECTORY:
        dict['__path__'] = [file]
        _modules[module] = dict
        path = [file] + path
        f, file, (suff, mode, type) = \
                        imp.find_module('__init__', [file])
    if type != imp.PY_SOURCE:
        # not Python source, can't do anything with this module
        f.close()
        _modules[module] = dict
        return dict

    _modules[module] = dict
    classstack = [] # stack of (class, indent) pairs
    src = f.read()
    f.close()

    # To avoid having to stop the regexp at each newline, instead
    # when we need a line number we simply string.count the number of
    # newlines in the string since the last time we did this; i.e.,
    #    lineno = lineno + \
    #             string.count(src, '\n', last_lineno_pos, here)
    #    last_lineno_pos = here
    countnl = string.count
    lineno, last_lineno_pos = 1, 0
    i = 0
    while 1:
        m = _getnext(src, i)
        if not m:
            break
        start, i = m.span()

        if m.start("Method") >= 0:
            # found a method definition or function
            thisindent = _indent(m.group("MethodIndent"))
            meth_name = m.group("MethodName")
            lineno = lineno + \
                     countnl(src, '\n',
                             last_lineno_pos, start)
            last_lineno_pos = start
            # close all classes indented at least as much
            while classstack and \
                  classstack[-1][1] >= thisindent:
                del classstack[-1]
            if classstack:
                # it's a class method
                cur_class = classstack[-1][0]
                cur_class._addmethod(meth_name, lineno)
            else:
                # it's a function
                f = Function(module, meth_name,
                             file, lineno)
                dict[meth_name] = f

        elif m.start("String") >= 0:
            pass

        elif m.start("Class") >= 0:
            # we found a class definition
            thisindent = _indent(m.group("ClassIndent"))
            # close all classes indented at least as much
            while classstack and \
                  classstack[-1][1] >= thisindent:
                del classstack[-1]
            lineno = lineno + \
                     countnl(src, '\n', last_lineno_pos, start)
            last_lineno_pos = start
            class_name = m.group("ClassName")
            inherit = m.group("ClassSupers")
            if inherit:
                # the class inherits from other classes
264
                inherit = inherit[1:-1].strip()
Tim Peters's avatar
Tim Peters committed
265
                names = []
266 267
                for n in inherit.split(','):
                    n = n.strip()
268
                    if n in dict:
Tim Peters's avatar
Tim Peters committed
269 270 271
                        # we know this super class
                        n = dict[n]
                    else:
272
                        c = n.split('.')
Tim Peters's avatar
Tim Peters committed
273 274 275 276 277 278 279 280
                        if len(c) > 1:
                            # super class
                            # is of the
                            # form module.class:
                            # look in
                            # module for class
                            m = c[-2]
                            c = c[-1]
281
                            if m in _modules:
Tim Peters's avatar
Tim Peters committed
282
                                d = _modules[m]
283
                                if c in d:
Tim Peters's avatar
Tim Peters committed
284 285 286 287 288 289 290 291 292 293 294
                                    n = d[c]
                    names.append(n)
                inherit = names
            # remember this class
            cur_class = Class(module, class_name, inherit,
                              file, lineno)
            dict[class_name] = cur_class
            classstack.append((cur_class, thisindent))

        elif m.start("Import") >= 0:
            # import module
295 296
            for n in m.group("ImportList").split(','):
                n = n.strip()
Tim Peters's avatar
Tim Peters committed
297 298
                try:
                    # recursively read the imported module
299
                    d = readmodule_ex(n, path, inpackage)
Tim Peters's avatar
Tim Peters committed
300 301 302 303 304 305 306
                except:
                    ##print 'module', n, 'not found'
                    pass

        elif m.start("ImportFrom") >= 0:
            # from module import stuff
            mod = m.group("ImportFromPath")
307
            names = m.group("ImportFromList").split(',')
Tim Peters's avatar
Tim Peters committed
308 309
            try:
                # recursively read the imported module
310
                d = readmodule_ex(mod, path, inpackage)
Tim Peters's avatar
Tim Peters committed
311 312 313 314 315 316 317
            except:
                ##print 'module', mod, 'not found'
                continue
            # add any classes that were defined in the
            # imported module to our name space if they
            # were mentioned in the list
            for n in names:
318
                n = n.strip()
319
                if n in d:
Tim Peters's avatar
Tim Peters committed
320 321 322 323 324 325 326
                    dict[n] = d[n]
                elif n == '*':
                    # only add a name if not
                    # already there (to mimic what
                    # Python does internally)
                    # also don't add names that
                    # start with _
327
                    for n in d:
Tim Peters's avatar
Tim Peters committed
328
                        if n[0] != '_' and \
329
                           not n in dict:
Tim Peters's avatar
Tim Peters committed
330 331 332 333 334
                            dict[n] = d[n]
        else:
            assert 0, "regexp _getnext found something unexpected"

    return dict
335 336

def _indent(ws, _expandtabs=string.expandtabs):
Tim Peters's avatar
Tim Peters committed
337
    return len(_expandtabs(ws, TABWIDTH))