bee_python 0.0.3 → 0.0.4

data/tools/pychecker/function.py

@@ -1,159 +0,0 @@
-#!/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

@@ -1,175 +0,0 @@
-#!/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

@@ -1,275 +0,0 @@
-"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

@@ -1,19 +0,0 @@
-"""
-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