bee_python 0.0.1

data/tools/pychecker/README

@@ -0,0 +1,152 @@
+
+PyChecker is a tool for finding bugs in python source code.
+It finds problems that are typically caught by a compiler for less
+dynamic languages, like C and C++.  It is similar to lint.
+Because of the dynamic nature of python, some warnings
+may be incorrect; however, spurious warnings should be fairly infrequent.
+
+PyChecker works in a combination of ways.  First, it imports each
+module.  If there is an import error, the module cannot be processed.
+The import provides some basic information about the module.  The code
+for each function, class, and method is checked for possible problems.
+
+Types of problems that can be found include:
+
+  * No global found (e.g., using a module without importing it)
+  * Passing the wrong number of parameters to functions/methods/constructors
+  * Passing the wrong number of parameters to builtin functions & methods
+  * Using format strings that don't match arguments
+  * Using class methods and attributes that don't exist
+  * Changing signature when overriding a method
+  * Redefining a function/class/method in the same scope
+  * Using a variable before setting it
+  * self not the first parameter to a method
+  * Unused globals and locals (module or variable)
+  * Unused function/method arguments (can ignore self)
+  * No doc strings in modules, classes, functions, and methods
+
+Using PyChecker
+---------------
+To use PyChecker, pass the python source files you want to check
+on the command line:
+
+	pychecker file1.py file2.py ...
+
+Note:  On Windows, use pychecker.bat.  You may also need to add
+python/scripts to your PATH.
+
+pychecker and pychecker.bat will only exist if pychecker has been
+installed.  To install, do:  python setup.py install
+
+Note:  If you haven't installed pychecker, it can be run by doing:
+python pychecker/checker.py
+
+An alternate way to use PyChecker is to import it in your code.
+See 'Importing PyChecker' below for more details.
+
+If there are import dependencies in your source files, you should
+import those files first on the command line in order to get as many
+files checked as possible.
+
+PyChecker works with Python 2.0 through 2.3.
+Some features don't work on earlier versions of Python.
+I only regularly test with versions 2.2 and 2.3.
+
+You can use the test files as examples:
+
+	pychecker [options] test_input/*.py
+
+If you want to change the default behaviour, you can pass command line options
+or define a .pycheckrc file.  For an example, look at pycheckrc.
+
+To show the available options, do:
+
+	pychecker -h
+
+Some of the most common options are:
+
+      --only         only warn about files passed on the command line [off]
+  -#, --limit        the maximum number of warnings to be displayed [10]
+  -s, --shadowbuiltin check if a variable shadows a builtin [on]
+  -q, --stdlib       ignore warnings from files under standard library [off]
+  -T, --argsused     unused method/function arguments [on]
+
+There is a simple GUI which is not maintained much.  It is good
+for showing all the options and also allows you to run pychecker.
+To run options, you will need to start it manually:
+
+	python pychecker/options.py
+
+If you want to suppress warnings on a module/function/class/method,
+you can define a suppressions dictionary in .pycheckrc.
+Examples of keys are:  'module', 'module.function',
+		       'module.class', 'module.class.method', etc.
+
+You can also define suppressions in your code by doing:
+
+	__pychecker__ = 'no-namedargs maxreturns=0 unusednames=foo,bar'
+
+The format for __pychecker__ values and values in the suppressions dictionary
+are the same.  Dashes (--) are optional when preceding long option names.
+
+Importing PyChecker
+-------------------
+You can import PyChecker in your code's main module, by doing:
+
+        import pychecker.checker
+
+This will allow each module imported after PyChecker to be checked 
+(other than the main module).  NOTE:  Modules imported before PyChecker
+will not be checked.  Warnings will be displayed on stdout 
+(ie, PyChecker uses print).
+
+Since you can't pass command line parameters, you can do:
+
+        os.environ['PYCHECKER'] = 'command line options here'
+
+This is equivalent of setting PYCHECKER in the shell environment:
+
+        PYCHECKER='no-namedargs maxreturns=0' /path/to/your/program
+
+If you want to disable the warnings (and processing done by PyChecker), 
+prior to importing PyChecker, do:
+
+        os.environ['PYCHECKER_DISABLED'] = 1
+
+This is equivalent of setting PYCHECKER_DISABLED in the shell environment:
+
+        PYCHECKER_DISABLED=1 /path/to/your/program
+
+Internal Errors
+---------------
+If you find a bug in PyChecker, meaning you see something like:
+
+	pychecker myfile.py
+
+	myfile.py:13 INTERNAL ERROR -- STOPPED PROCESSING FUNCTION --
+        Traceback (most recent call last):
+          File "./pychecker/warn.py", line 364, in _checkFunction
+            stack, oparg, lastLineNum)
+          File "./pychecker/warn.py", line 195, in _handleFunctionCall
+            kwArgs.append(stack[i].data)
+        IndexError: list index out of range
+
+Please post a bug in the SourceForge Tracker
+(https://sourceforge.net/tracker/?atid=382217&group_id=24686&func=browse)
+or send mail indicating the version of PyChecker, *your source file*
+which broke PyChecker (myfile.py in the example above), and the traceback.
+It is very helpful to provide a simple test case to demonstrate the problem.
+It helps to have the entire file and all the dependencies if you cannot
+produce a simple test case.  But if you can't provide a test case nor
+the file(s), I may be able to figure out the problem with just the line
+which broke PyChecker (myfile.py:13 in the example above).
+
+Good Luck!  As always, feedback is greatly appreciated.
+
+Neal
+pychecker-list@lists.sourceforge.net
+
+PyChecker can be found on SourceForge at:
+	http://pychecker.sourceforge.net/
+	http://sourceforge.net/projects/pychecker
+

data/tools/pychecker/Stack.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python
+
+# Copyright (c) 2001-2002, MetaSlash Inc.  All rights reserved.
+
+"""
+Module to hold manipulation of elements on the stack.
+"""
+
+import types
+from pychecker import utils
+
+DATA_UNKNOWN = "-unknown-"
+LOCALS = 'locals'
+
+# These should really be defined by subclasses
+TYPE_UNKNOWN = "-unknown-"
+TYPE_FUNC_RETURN = "-return-value-"
+TYPE_ATTRIBUTE = "-attribute-"
+TYPE_COMPARISON = "-comparison-"
+TYPE_GLOBAL = "-global-"
+TYPE_EXCEPT = "-except-"
+
+class Item :
+    "Representation of data on the stack"
+
+    def __init__(self, data, dataType, const = 0, length = 0) :
+        self.data = data
+        self.type = dataType
+        self.const = const
+        self.length = length
+        self.is_really_string = 0
+
+    def __str__(self) :
+        if type(self.data) == types.TupleType :
+            value = '('
+            for item in self.data :
+                value = value + utils.safestr(item) + ', '
+            # strip off the ', ' for multiple items
+            if len(self.data) > 1 :
+                value = value[:-2]
+            return value + ')'
+        return utils.safestr(self.data)
+
+    def __repr__(self):
+        return 'Stack Item: (%r, %r, %d)' % (self.data, self.type, self.const)
+
+    def isNone(self) :
+        return (self.type != TYPE_UNKNOWN and self.data is None or
+                (self.data == 'None' and not self.const))
+
+    def isImplicitNone(self) :
+        return self.data is None and self.const
+
+    def isMethodCall(self, c, methodArgName):
+        return self.type == TYPE_ATTRIBUTE and c != None and \
+               len(self.data) == 2 and self.data[0] == methodArgName
+
+    def isLocals(self) :
+        return self.type == types.DictType and self.data == LOCALS
+
+    def setStringType(self, value = types.StringType):
+        self.is_really_string = value == types.StringType
+
+    def getType(self, typeMap) :
+        if self.type != types.StringType or self.is_really_string:
+            return self.type
+        if self.const :
+            return type(self.data)
+        if type(self.data) == types.StringType :
+            localTypes = typeMap.get(self.data, [])
+            if len(localTypes) == 1 :
+                return localTypes[0]
+        return TYPE_UNKNOWN
+
+    def getName(self) :
+        if self.type == TYPE_ATTRIBUTE and type(self.data) != types.StringType:
+            strValue = ""
+            # convert the tuple into a string ('self', 'data') -> self.data
+            for item in self.data :
+                strValue = '%s.%s' % (strValue, utils.safestr(item))
+            return strValue[1:]
+        return utils.safestr(self.data)
+
+    def addAttribute(self, attr) :
+        if type(self.data) == types.TupleType :
+            self.data = self.data + (attr,)
+        else :
+            self.data = (self.data, attr)
+        self.type = TYPE_ATTRIBUTE
+
+
+def makeDict(values = (), const = 1) :
+    values = tuple(values)
+    if not values:
+        values = ('<on-stack>',)
+    return Item(values, types.DictType, const, len(values))
+
+def makeTuple(values = (), const = 1) :
+    return Item(tuple(values), types.TupleType, const, len(values))
+
+def makeList(values = [], const = 1) :
+    return Item(values, types.ListType, const, len(values))
+
+def makeFuncReturnValue(stackValue, argCount) :
+    data = DATA_UNKNOWN
+    # vars() without params == locals()
+    if stackValue.type == TYPE_GLOBAL and \
+       (stackValue.data == LOCALS or
+        (argCount == 0 and stackValue.data == 'vars')) :
+        data = LOCALS
+    return Item(data, TYPE_FUNC_RETURN)
+
+def makeComparison(stackItems, comparison) :
+    return Item((stackItems[0], comparison, stackItems[1]), TYPE_COMPARISON)
+

data/tools/pychecker/TODO

@@ -0,0 +1,101 @@
+Goals for next minor release:
+-----------------------------
+* Add warning for duplicated elif conditions
+* Check for "if s.find(str):" s/b "if s.find(str) >= 0:" where s is a string
+* Add warning for: x % x is always 0
+* Add warning when using listcomp variable (x) outside of [... for x in ...]
+* Add warning for import overriding builtin (from os import *)
+* Add warning if defining a module name that's also in the stdlib
+* Add decorator so you can do:
+
+   @pychecker(maxlocals=42)
+   def myfunc():
+
+* Support function attributes in addition to __pychecker__
+* Add warning when iterating over a dict (keys, values, items) and mutating it
+* Add warning for __special_ or __special or _special__ etc.
+* Add warning about redefining a function/method with different signatures
+* Add warning when base class has similar name and same signature:
+
+  class Base:
+    def foobar():
+  class Sub(Base):
+    def foobaz(): # damn, I wanted to override foobar
+
+* If unknown name, suggest similar names
+
+* Check for return from finally (disables exception, default off?)
+* Add another boolean warning for:    if bool(xxx):
+* Need way to configure broken (and non-broken) versions of evil C extensions
+* Add estimated difficulty to research/fix error
+* Shouldn't warn about using return value for generators
+* Suppress argument (self) name warnings if func has no impl?
+* Add warning for a variable that is constant 
+    ie, initialized and used, but never changed
+
+* Add warning for catching AttributeError when there is no attr access
+	ZeroDivisionError w/no division?
+	KeyError UnboundLocalError IndexError IndentationError ImportError
+* Add warning for a import b & b import a (import loops)
+* Check that classes with __slots__ don't get/set any other attributes
+* Expectations of __methods__, constness (don't modify in __nonzero__)
+* Add warning if dict has duplicate keys when creating from literals
+* __new__ should use cls, not self???
+
+* If arg has default value of None, check that arg is assigned some value
+
+* check if returning self from __str__()
+* check for str1 in str2 == otherValue
+* Fix dependancy problem w/checkReturnValues & checkImplicitReturns
+* check for use of self.attr before setting self.attr in __init__ method
+* Handle sys.exit() as non-returnable condition
+* Warn about non-escaping backslashes???
+* vars() should use locals, like locals(), hmmm, it should already ...
+
+Goals for next major release (0.9):
+-----------------------------------
+* Improve handling when importing packages (ie, don't import modules)
+  - Make a base class to handle stack operations
+  - Override base class with classes to handle module scope, functions, etc.
+  - Process module and create Module/Class/Function objects w/o dir(), etc.
+  - Finish tests: 44
+* Add a config option to ignore certain cantankerous modules
+
+* Add warning for global statement inside a conditional
+* Fix spurious warnings for unreachable code checks
+* Fix most of the FIXMEs
+* Add check for import module (from within package p-should be import p.module)
+  - don't use relative imports, should always use absolute paths
+
+Longer Term goals:
+------------------
+* Add check for magic #s/consts
+	(need dict of consts, count, max count, consts to ignore)
+* Add check for unsupported operand type(s) for * + / etc
+* Store types of globals, class attributes, function & method return values
+* Output stats about pychecker's job, good, bad, otherwise...
+	annotate code for problem areas, well checked areas, etc.
+* Add original line warnings for those that refer to another place
+	(e.g., overridden method doesn't match signature)
+* Add capability to check features from a specified version of python
+	which is different from runtime interpreter
+* Security checks for known issues.  Adrian Likins @redhat recommends 
+  looking at http://www.securesw.com/rats/
+* Make check for 'self' a list instead of a string
+* Check function return values - partially complete
+* Add check that private functions are used in module/class
+* Add check for using object members outside of class
+* Add portability checks for win32/unix
+* Add check for except: pass
+* Spell check doc strings
+
+# need to read source code for these:
+* Add warning for unnecessary global stmts
+* Add check for implicit string concatentation
+* Add check for creating tuple when don't want a tuple, like: 1,
+            or not creating tuple when want one, like: (1)
+* Warn when using () with statements (assert, print, del, if, while)
+* Add check for <>, should use !=
+* Find lines that end w/semi-colons (;)
+* inconsistent camel-case
+

data/tools/pychecker/VERSION

@@ -0,0 +1 @@
+0.8.18

data/tools/pychecker/Warning.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python
+
+# Copyright (c) 2001, MetaSlash Inc.  All rights reserved.
+# Portions Copyright (c) 2005, Google, Inc. All rights reserved.
+
+"""
+Warning class to hold info about each warning.
+"""
+
+
+class Warning :
+    "Class which holds error information."
+
+    def __init__(self, file, line, err) :
+        if hasattr(file, "function") :
+            file = file.function.func_code.co_filename
+        elif hasattr(file, "co_filename") :
+            file = file.co_filename
+        elif hasattr(line, "co_filename") :
+            file = line.co_filename
+        if file[:2] == './' :
+            file = file[2:]
+        self.file = file
+
+        if hasattr(line, "co_firstlineno") :
+            line = line.co_firstlineno
+        if line == None :
+            line = 1
+        self.line = line
+        self.err = err
+        self.level = err.level
+
+    def __cmp__(self, warn) :
+        if warn == None :
+            return 1
+        if not self.file and not self.line:
+            return 1
+        if self.file != warn.file :
+            return cmp(self.file, warn.file)
+        if self.line != warn.line :
+            return cmp(self.line, warn.line)
+        return cmp(self.err, warn.err)
+
+    def format(self) :
+        if not self.file and not self.line:
+            return str(self.err)
+        return "%s:%d: %s" % (self.file, self.line, self.err)
+
+    def output(self, stream) :
+        stream.write(self.format() + "\n")

data/tools/pychecker/__init__.py

@@ -0,0 +1,17 @@
+"""
+Copyright (c) 2001, MetaSlash Inc.  All rights reserved.
+
+PyChecker is a tool for finding common bugs in python source code.
+It finds problems that are typically caught by a compiler for less
+dynamic languages, like C and C++.  It is also similar to lint.
+
+Contact Info:
+  http://pychecker.sourceforge.net/
+  pychecker-list@lists.sourceforge.net
+"""
+
+# A version # to check against in the main module (checker.py)
+# this will allow us to check if there are two versions of checker
+# in site-packages and local dir
+MAIN_MODULE_VERSION = 3
+