bee_python 0.0.1

data/tools/pychecker/function.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python
+
+# Copyright (c) 2001-2002, MetaSlash Inc.  All rights reserved.
+
+"""
+Object to hold information about functions.
+Also contain a pseudo Python function object
+"""
+
+import string
+
+_ARGS_ARGS_FLAG = 4
+_KW_ARGS_FLAG = 8
+_CO_FLAGS_MASK = _ARGS_ARGS_FLAG + _KW_ARGS_FLAG
+
+class _ReturnValues:
+    def __init__(self):
+        self.returnValues = None
+
+    def returnsNoValue(self):
+        returnValues = self.returnValues
+        # if unset, we don't know
+        if returnValues is None:
+            return 0
+        # it's an empty list, that means no values
+        if not returnValues:
+            return 1
+        # make sure each value is not None
+        for rv in returnValues:
+            if not rv[1].isNone():
+                return 0
+        return returnValues[-1][1].isImplicitNone()
+
+class FakeCode :
+    "This is a holder class for code objects (so we can modify them)"
+    def __init__(self, code, varnames = None) :
+        for attr in dir(code):
+            try:
+                setattr(self, attr, getattr(code, attr))
+            except:
+                pass
+        if varnames is not None:
+            self.co_varnames = varnames
+
+class FakeFunction(_ReturnValues):
+    "This is a holder class for turning code at module level into a function"
+
+    def __init__(self, name, code, func_globals = {}, varnames = None) :
+        _ReturnValues.__init__(self)
+        self.func_name = self.__name__ = name
+        self.func_doc  = self.__doc__  = "ignore"
+
+        self.func_code = FakeCode(code, varnames)
+        self.func_defaults = None
+        self.func_globals = func_globals
+
+    def __str__(self):
+        return self.func_name
+
+    def __repr__(self):
+        return '%s from %r' % (self.func_name, self.func_code.co_filename)
+
+class Function(_ReturnValues):
+    "Class to hold all information about a function"
+
+    def __init__(self, function, isMethod=0):
+        _ReturnValues.__init__(self)
+        self.function = function
+        self.isMethod = isMethod
+        self.minArgs = self.maxArgs = function.func_code.co_argcount
+        if function.func_defaults is not None :
+            self.minArgs = self.minArgs - len(function.func_defaults)
+        # if function uses *args, there is no max # args
+        try:
+            if function.func_code.co_flags & _ARGS_ARGS_FLAG != 0 :
+                self.maxArgs = None
+            self.supportsKW = function.func_code.co_flags & _KW_ARGS_FLAG
+        except AttributeError:
+            # this happens w/Zope
+            self.supportsKW = 0
+
+    def __str__(self):
+        return self.function.func_name
+
+    def __repr__(self):
+        return '%s from %r:%d' % (self.function.func_name,
+                                  self.function.func_code.co_filename,
+                                  self.function.func_code.co_firstlineno)
+
+    def arguments(self) :
+        numArgs = self.function.func_code.co_argcount
+        if self.maxArgs is None :
+            numArgs = numArgs + 1
+        if self.supportsKW :
+            numArgs = numArgs + 1
+        return self.function.func_code.co_varnames[:numArgs]
+        
+    def isParam(self, name) :
+        return name in self.arguments()
+
+    def isStaticMethod(self):
+        return self.isMethod and isinstance(self.function, type(create_fake))
+
+    def isClassMethod(self):
+        try:
+            return self.isMethod and self.function.im_self is not None
+        except AttributeError:
+            return 0
+
+    def defaultValue(self, name) :
+        func_code = self.function.func_code
+        arg_names = list(func_code.co_varnames[:func_code.co_argcount])
+        i = arg_names.index(name)
+        if i < self.minArgs :
+            raise ValueError
+        return self.function.func_defaults[i - self.minArgs]
+
+    def varArgName(self) :
+        if self.maxArgs is not None :
+            return None
+        func_code = self.function.func_code
+        return func_code.co_varnames[func_code.co_argcount]
+
+def create_fake(name, code, func_globals = {}, varnames = None) :
+    return Function(FakeFunction(name, code, func_globals, varnames))
+
+def create_from_file(file, filename, module) :
+    if file is None:
+        return create_fake(filename, compile('', filename, 'exec'))
+
+    # Make sure the file is at the beginning
+    #   if python compiled the file, it will be at the end
+    file.seek(0)
+
+    # Read in the source file, see py_compile.compile() for games w/src str
+    codestr = file.read()
+    codestr = string.replace(codestr, "\r\n", "\n")
+    codestr = string.replace(codestr, "\r", "\n")
+    if codestr and codestr[-1] != '\n' :
+        codestr = codestr + '\n'
+    code = compile(codestr, filename, 'exec')
+    return Function(FakeFunction('__main__', code, module.__dict__))
+
+def _co_flags_equal(o1, o2) :
+    return (o1.co_flags & _CO_FLAGS_MASK) == (o2.co_flags & _CO_FLAGS_MASK)
+    
+def same_signature(func, object) :
+    '''Return a boolean value if the <func> has the same signature as
+       a function with the same name in <object> (ie, an overriden method)'''
+
+    try :
+        baseMethod = getattr(object, func.func_name)
+        base_func_code = baseMethod.im_func.func_code
+    except AttributeError :
+        return 1
+
+    return _co_flags_equal(base_func_code, func.func_code) and \
+           base_func_code.co_argcount == func.func_code.co_argcount
+

data/tools/pychecker/msgs.py

@@ -0,0 +1,175 @@
+#!/usr/bin/env python
+
+# Copyright (c) 2001-2004, MetaSlash Inc.  All rights reserved.
+# Portions Copyright (c) 2005, Google, Inc.  All rights reserved.
+
+"""
+Warning Messages for PyChecker
+"""
+
+import UserString
+
+class WarningClass:
+  level = 0
+
+  def __init__(self, msg, level_offset=None):
+    self.msg = msg
+    if level_offset is not None:
+      self.level += level_offset
+
+  def __mod__(self, args):
+    result = UserString.UserString(self.msg % args)
+    result.level = self.level
+    return result
+
+  def __str__(self):
+    return self.msg
+
+class Internal(WarningClass):
+  level = 100
+
+class Error(WarningClass):
+  level = 90
+
+class Security(WarningClass):
+  level = 90
+
+class Warning(WarningClass):
+  level = 70
+
+class Unused(WarningClass):
+  level = 50
+
+class Deprecated(WarningClass):
+  level = 40
+
+class Style(WarningClass):
+  level = 10
+
+TOO_MANY_WARNINGS = WarningClass("%d errors suppressed, use -#/--limit to increase the number of errors displayed")
+CHECKER_BROKEN = Internal("INTERNAL ERROR -- STOPPED PROCESSING FUNCTION --\n\t%s")
+INVALID_CHECKER_ARGS = Internal("Invalid warning suppression arguments --\n\t%s")
+
+NO_MODULE_DOC = Style("No module doc string")
+NO_CLASS_DOC = Style("No doc string for class %s")
+NO_FUNC_DOC = Style("No doc string for function %s")
+
+VAR_NOT_USED = Unused("Variable (%s) not used")
+IMPORT_NOT_USED = Unused("Imported module (%s) not used")
+UNUSED_LOCAL = Unused("Local variable (%s) not used")
+UNUSED_PARAMETER = Unused("Parameter (%s) not used")
+UNUSED_MEMBERS = Unused("Members (%s) not used in class (%s)")
+NO_LOCAL_VAR = Unused("No local variable (%s)")
+VAR_USED_BEFORE_SET = Warning("Variable (%s) used before being set")
+
+REDEFINING_ATTR = Warning("Redefining attribute (%s) original line (%d)")
+
+MODULE_IMPORTED_AGAIN = Warning("Module (%s) re-imported")
+MODULE_MEMBER_IMPORTED_AGAIN = Warning("Module member (%s) re-imported")
+MODULE_MEMBER_ALSO_STAR_IMPORTED = Warning("Module member (%s) re-imported with *")
+MIX_IMPORT_AND_FROM_IMPORT = Warning("Using import and from ... import for (%s)")
+IMPORT_SELF = Warning("Module (%s) imports itself")
+
+NO_METHOD_ARGS = Error("No method arguments, should have %s as argument")
+SELF_NOT_FIRST_ARG = Error("%s is not first %smethod argument")
+SELF_IS_ARG = Error("self is argument in %s")
+RETURN_FROM_INIT = Error("Cannot return a value from __init__")
+NO_CTOR_ARGS = Error("Instantiating an object with arguments, but no constructor")
+
+GLOBAL_DEFINED_NOT_DECLARED = Warning("Global variable (%s) not defined in module scope")
+INVALID_GLOBAL = Error("No global (%s) found")
+INVALID_METHOD = Error("No method (%s) found")
+INVALID_CLASS_ATTR = Warning("No class attribute (%s) found")
+INVALID_SET_CLASS_ATTR = Warning("Setting class attribute (%s) not set in __init__")
+INVALID_MODULE_ATTR = Error("No module attribute (%s) found")
+
+LOCAL_SHADOWS_GLOBAL = Warning("Local variable (%s) shadows global defined on line %d")
+VARIABLE_SHADOWS_BUILTIN = Warning("(%s) shadows builtin")
+USING_METHOD_AS_ATTR = Warning("Using method (%s) as an attribute (not invoked)")
+OBJECT_HAS_NO_ATTR = Warning("Object (%s) has no attribute (%s)")
+METHOD_SIGNATURE_MISMATCH = Warning("Overridden method (%s) doesn't match signature in class (%s)")
+
+INVALID_ARG_COUNT1 = Error("Invalid arguments to (%s), got %d, expected %d")
+INVALID_ARG_COUNT2 = Error("Invalid arguments to (%s), got %d, expected at least %d")
+INVALID_ARG_COUNT3 = Error("Invalid arguments to (%s), got %d, expected between %d and %d")
+FUNC_DOESNT_SUPPORT_KW = Error("Function (%s) doesn't support **kwArgs")
+FUNC_DOESNT_SUPPORT_KW_ARG = Error("Function (%s) doesn't support **kwArgs for name (%s)")
+FUNC_USES_NAMED_ARGS = Warning("Function (%s) uses named arguments")
+
+BASE_CLASS_NOT_INIT = Warning("Base class (%s) __init__() not called")
+NO_INIT_IN_SUBCLASS = Warning("No __init__() in subclass (%s)")
+METHODS_NEED_OVERRIDE = Error("Methods (%s) in %s need to be overridden in a subclass")
+
+FUNC_TOO_LONG = Style("Function (%s) has too many lines (%d)")
+TOO_MANY_BRANCHES = Style("Function (%s) has too many branches (%d)")
+TOO_MANY_RETURNS = Style("Function (%s) has too many returns (%d)")
+TOO_MANY_ARGS = Style("Function (%s) has too many arguments (%d)")
+TOO_MANY_LOCALS = Style("Function (%s) has too many local variables (%d)")
+TOO_MANY_REFERENCES = Style('Law of Demeter violated, more than %d references for (%s)')
+
+IMPLICIT_AND_EXPLICIT_RETURNS = Warning("Function returns a value and also implicitly returns None")
+INCONSISTENT_RETURN_TYPE = Warning("Function return types are inconsistent")
+INCONSISTENT_TYPE = Warning("Variable (%s) already has types %s and set to %s")
+CODE_UNREACHABLE = Error("Code appears to be unreachable")
+CONSTANT_CONDITION = Warning("Using a conditional statement with a constant value (%s)")
+STRING_ITERATION = Warning("Iterating over a string (%s)")
+DONT_RETURN_NONE = Error("%s should not return None, raise an exception if not found")
+IS_LITERAL = Warning("Using is%s %s, may not always work")
+INVALID_FORMAT = Error("Invalid format string, problem starts near: '%s'")
+INVALID_FORMAT_COUNT = Error("Format string argument count (%d) doesn't match arguments (%d)")
+TOO_MANY_STARS_IN_FORMAT = Error("Too many *s in format flags")
+USING_STAR_IN_FORMAT_MAPPING = Error("Can't use * in formats when using a mapping (dictionary), near: '%s'")
+CANT_MIX_MAPPING_IN_FORMATS = Error("Can't mix tuple/mapping (dictionary) formats in same format string")
+
+INTEGER_DIVISION = Warning("Using integer division (%s / %s) may return integer or float")
+MODULO_1 = Warning("... % 1 may be constant")
+USING_TUPLE_ACCESS_TO_LIST = Error("Using a tuple instead of slice as list accessor for (%s)")
+BOOL_COMPARE = Warning("Comparisons with %s are not necessary and may not work as expected")
+SHOULDNT_ASSIGN_BUILTIN = Deprecated("Should not assign to %s, it is (or will be) a builtin")
+SHOULDNT_ASSIGN_NAME = Deprecated("Should not assign to %s, it is similar to builtin %s")
+SET_VAR_TO_ITSELF = Warning("Setting %s to itself has no effect")
+MODIFY_VAR_NOOP = Warning("%s %s %s has no effect")
+DIVIDE_VAR_BY_ITSELF = Warning("%s %s %s is always 1 or ZeroDivisionError")
+XOR_VAR_WITH_ITSELF = Warning("%s %s %s is always 0")
+
+STMT_WITH_NO_EFFECT = Error("Operator (%s) doesn't exist, statement has no effect")
+POSSIBLE_STMT_WITH_NO_EFFECT = Error("Statement appears to have no effect")
+UNARY_POSITIVE_HAS_NO_EFFECT = Error("Unary positive (+) usually has no effect")
+LIST_APPEND_ARGS = Error("[].append() only takes 1 argument in Python 1.6 and above for (%s)")
+
+LOCAL_DELETED = Error("(%s) cannot be used after being deleted on line %d")
+LOCAL_ALREADY_DELETED = Error("Local variable (%s) has already been deleted on line %d")
+VAR_DELETED_BEFORE_SET = Error("Variable (%s) deleted before being set")
+
+CATCH_BAD_EXCEPTION = Warning("Catching a non-Exception object (%s)")
+CATCH_STR_EXCEPTION = Deprecated("Catching string exceptions are deprecated (%s)")
+RAISE_BAD_EXCEPTION = Warning("Raising an exception on a non-Exception object (%s)")
+RAISE_STR_EXCEPTION = Deprecated("Raising string exceptions are deprecated (%s)")
+SET_EXCEPT_TO_BUILTIN = Error("Setting exception to builtin (%s), consider () around exceptions")
+USING_KEYWORD = Warning("Using identifier (%s) which will become a keyword in version %s")
+MODIFYING_DEFAULT_ARG = Warning("Modifying parameter (%s) with a default value may have unexpected consequences")
+USING_SELF_IN_REPR = Warning("Using `self` in __repr__ method")
+USING_NONE_RETURN_VALUE = Error("Using the return value from (%s) which is always None")
+WRONG_UNPACK_SIZE = Error("Unpacking %d values into %d variables")
+WRONG_UNPACK_FUNCTION = Error("Unpacking function (%s) which returns %d values into %d variables")
+UNPACK_NON_SEQUENCE = Error("Unpacking a non-sequence (%s) of type %s")
+
+NOT_SPECIAL_METHOD = Warning("%s is not a special method")
+USING_COERCE_IN_NEW_CLASS = Error("Using __coerce__ in new-style class (%s) will not work for binary operations")
+USING_NEW_STYLE_METHOD_IN_OLD_CLASS = Error("Using %s in old-style class (%s) does not work")
+USING_PROPERTIES_IN_CLASSIC_CLASS = Error("Using property (%s) in classic class %s may not work")
+USING_SLOTS_IN_CLASSIC_CLASS = Error("Using __slots__ in classic class %s has no effect, consider deriving from object")
+EMPTY_SLOTS = Warning("__slots__ are empty in %s")
+
+USES_EXEC = Security("Using the exec statement")
+USES_GLOBAL_EXEC = Security("Using the exec statement in global namespace")
+USES_INPUT = Security("Using input() is a security problem, consider using raw_input()")
+
+USING_DEPRECATED_MODULE = Deprecated("%s module is deprecated")
+USING_DEPRECATED_ATTR = Deprecated("%s is deprecated")
+USING_INSECURE_FUNC = Security("%s() is a security problem")
+USE_INSTEAD = ", consider using %s"
+
+USES_CONST_ATTR = Warning("Passing a constant string to %s, consider direct reference")
+
+BAD_STRING_FIND = Error("string.find() returns an integer, consider checking >= 0 or < 0 for not found")

data/tools/pychecker/options.py

@@ -0,0 +1,275 @@
+"Main module for running pychecker a Tkinter GUI for all the options"
+
+import sys
+import os
+import Tkinter, tkFileDialog
+
+from OptionTypes import *
+from string import capitalize, strip, rstrip, split
+
+import Config
+
+MAX_SUBBOX_ROWS = 8
+MAX_BOX_COLS = 3
+PAD = 10
+EDITOR = "xterm -e vi -n +%(line)d %(file)s"
+if sys.platform == 'win32':
+    EDITOR = "notepad %(file)s"
+
+def col_weight(grid):
+    "Set column weights so that sticky grid settings actually work"
+    unused, col = grid.grid_size()
+    for c in range(col):
+        grid.columnconfigure(c, weight=1)
+
+def spawn(cmd_list):
+    try:
+        if os.fork():
+            try:
+                os.execvp(cmd_list[0], cmd_list)
+            finally:
+                sys.exit()
+    except AttributeError:
+        os.execvp(cmd_list[0], cmd_list)
+
+def edit(file, line):
+    "Fire up an external editor to see the file at the given line"
+    unused = file, line
+    list = split(EDITOR)
+    cmd_list = []
+    for word in list:
+        cmd_list.append(word % locals())
+    spawn(cmd_list)
+
+def closeCB():
+    sys.exit(0)
+
+class Results:
+    "Display the warnings produced by checker"
+
+    def __init__(self, w):
+        self.top = Tkinter.Toplevel(w, name="results")
+        self.top.transient(w)
+        self.top.bind('<Return>', self.hide)
+        self.top.bind('<Escape>', self.hide)
+        self.text = Tkinter.Text(self.top, name="text")
+        self.text.grid()
+        self.text.bind('<Double-Button-1>', self.showFile)
+        close = Tkinter.Button(self.top,
+                            name="close",
+                            default=Tkinter.ACTIVE,
+                            command=self.hide)
+        close.grid()
+        self.text.update_idletasks()
+
+    def show(self, text):
+        self.text.delete("0.1", "end")
+        self.text.insert("0.1", text)
+        self.top.deiconify()
+        self.top.lift()
+
+    def hide(self, *unused):
+        self.top.withdraw()
+
+    def line(self):
+        return split(self.text.index(Tkinter.CURRENT), ".")[0]
+
+    def showFile(self, unused):
+        import re
+        line = self.line()
+        text = self.text.get(line + ".0", line + ".end")
+        text = rstrip(text)
+        result = re.search("(.*):([0-9]+):", text)
+        if result:
+            file, line = result.groups()
+            edit(file, int(line))
+            self.text.after(0, self.selectLine)
+
+    def selectLine(self):
+        line = self.line()
+        self.text.tag_remove(Tkinter.SEL, "1.0", Tkinter.END)
+        self.text.tag_add(Tkinter.SEL, line + ".0", line + ".end")
+
+class ConfigDialog:
+    "Dialog for editing options"
+    
+    def __init__(self, tk):
+        self._tk = tk
+        self._cfg, _, _ = Config.setupFromArgs(sys.argv)
+
+        self._help = None
+        self._optMap = {}
+        self._opts = []
+        self._file = Tkinter.StringVar()
+        self._results = None
+
+	if len(sys.argv) > 1:
+            self._file.set(sys.argv[1])
+
+        for name, group in Config._OPTIONS:
+          opts = []
+          for _, useValue, longArg, member, description in group:
+              value = None
+              if member:
+                  value = getattr(self._cfg, member)
+                  description = member + ": " + capitalize(description)
+                  description = strip(description)
+              tk.option_add('*' + longArg + ".help", description)
+              if useValue:
+                  if type(value) == type([]):
+                      field = List(longArg, value)
+                  elif type(value) == type(1):
+                      field = Number(longArg, int(value))
+                  elif type(value) == type(''):
+                      field = Text(longArg, value)
+                  else:
+                      field = Boolean(longArg, value)
+              else:
+                  field = Boolean(longArg, value)
+              self._optMap[longArg] = field
+              opts.append(field)
+          self._opts.append( (name, opts))
+
+    def _add_fields(self, w, opts):
+        count = 0
+        for opt in opts:
+            f = opt.field(w)
+            c, r = divmod(count, MAX_SUBBOX_ROWS)
+            f.grid(row=r, column=c, sticky=Tkinter.NSEW)
+            count = count + 1
+
+    def _add_group(self, w, name, opts):
+        colFrame = Tkinter.Frame(w)
+        
+        label = Tkinter.Label(colFrame, text=name + ":")
+        label.grid(row=0, column=0, sticky=Tkinter.NSEW)
+        
+        gframe = Tkinter.Frame(colFrame, relief=Tkinter.GROOVE, borderwidth=2)
+        gframe.grid(row=1, column=0, sticky=Tkinter.NSEW)
+        self._add_fields(gframe, opts)
+        
+        label = Tkinter.Label(colFrame)
+        label.grid(row=2, column=0, sticky=Tkinter.NSEW)
+        colFrame.rowconfigure(2, weight=1)
+        return colFrame
+
+    def main(self):
+        frame = Tkinter.Frame(self._tk, name="opts")
+        frame.grid()
+        self._tk.option_readfile('Options.ad')
+        self._fields = {}
+        row, col = 0, 0
+        rowFrame = Tkinter.Frame(frame)
+        rowFrame.grid(row=row)
+        row = row + 1
+        for name, opts in self._opts:
+            w = self._add_group(rowFrame, name, opts)
+            w.grid(row=row, column=col, sticky=Tkinter.NSEW, padx=PAD)
+            col = col + 1
+            if col >= MAX_BOX_COLS:
+                col_weight(rowFrame)
+                rowFrame=Tkinter.Frame(frame)
+                rowFrame.grid(row=row, sticky=Tkinter.NSEW)
+                col = 0
+                row = row + 1
+        col_weight(rowFrame)
+
+        self._help = Tkinter.Label(self._tk, name="helpBox")
+        self._help.grid(row=row)
+        self._help.config(takefocus=0)
+        buttons = Tkinter.Frame(self._tk, name="buttons")
+        ok = Tkinter.Button(buttons, name="ok", command=self.ok, default=Tkinter.ACTIVE)
+        ok.grid(row=row, column=0)
+        default = Tkinter.Button(buttons, name="default", command=self.default)
+        default.grid(row=row, column=1)
+        close = Tkinter.Button(buttons, name="close", command=closeCB)
+        close.grid(row=row, column=2)
+        buttons.grid()
+
+        f = Tkinter.Frame(self._tk, name="fileStuff")
+        Tkinter.Button(f, name="getfile", command=self.file).grid(row=0, column=1)
+        fileEntry = Tkinter.Entry(f, name="fname", textvariable=self._file)
+	fileEntry.grid(row=0, column=2)
+        Tkinter.Button(f, name="check", command=self.check).grid(row=0, column=3)
+        f.grid(sticky=Tkinter.EW)
+        
+        self._tk.bind_all('<FocusIn>', self.focus)
+        self._tk.bind_all('<Enter>', self.focus)
+        self._tk.bind_all('<ButtonPress>', self.click)
+        fileEntry.bind('<Return>', self.check)
+        self._tk.mainloop()
+
+    #
+    # Callbacks
+    #
+
+    def help(self, w):
+        if type(w) == type(''):         # occurs with file dialog...
+            return
+        if self._help == w:             # ignore help events on help...
+            return
+        help = w.option_get("help", "help")
+        self._help.configure(text=help)
+
+    def focus(self, ev):
+        self.help(ev.widget)
+
+    def click(self, ev):
+        self.help(ev.widget)
+
+    def ok(self):
+        opts = []
+        # Pull command-line args
+        for _, group in self._opts:
+            for opt in group:
+                arg = opt.arg()
+                if arg:
+                    opts.append(arg)
+
+        # Calculate config
+        self._cfg, _, _ = Config.setupFromArgs(opts)
+
+        # Set controls based on new config
+        for _, group in Config._OPTIONS:
+            for _, _, longArg, member, _ in group:
+                if member:
+                    self._optMap[longArg].set(getattr(self._cfg, member))
+
+    def default(self):
+        self._cfg, _, _ = Config.setupFromArgs(sys.argv)
+        for _, group in Config._OPTIONS:
+            for _, _, longArg, member, _ in group:
+                if member:
+                    self._optMap[longArg].set(getattr(self._cfg, member))
+                else:
+                    self._optMap[longArg].set(0)
+
+    def file(self):
+        self._file.set(tkFileDialog.askopenfilename())
+
+    def check(self, *unused):
+        import checker
+        import StringIO
+        
+        self.ok()                       # show effect of all settings
+
+        checker._allModules = {}
+        warnings = checker.getWarnings([self._file.get()], self._cfg)
+        capture = StringIO.StringIO()
+        
+        if not self._results:
+            self._results = Results(self._help)
+        checker._printWarnings(warnings, capture)
+
+        value = strip(capture.getvalue())
+        if not value:
+            value = "None"
+        self._results.show(value)
+
+
+if __name__=='__main__':
+    dirs = os.path.join(os.path.split(os.getcwd())[:-1])
+    sys.path.append(dirs[0])
+    tk = Tkinter.Tk()
+    tk.title('PyChecker')
+    ConfigDialog(tk).main()

data/tools/pychecker/pcmodules.py

@@ -0,0 +1,19 @@
+"""
+Track loaded PyCheckerModules together with the directory they were loaded from.
+This allows us to differentiate between loaded modules with the same name
+but from different paths, in a way that sys.modules doesn't do.
+"""
+
+__pcmodules = {}
+
+def getPCModule(moduleName, moduleDir=None):
+    global __pcmodules
+    return __pcmodules.get((moduleName, moduleDir), None)
+
+def getPCModules():
+    global __pcmodules
+    return __pcmodules.values()
+
+def addPCModule(pcmodule):
+    global __pcmodules
+    __pcmodules[(pcmodule.moduleName, pcmodule.moduleDir)] = pcmodule