bee_python 0.0.3 → 0.0.4

data/tools/pychecker/README

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

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

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

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

data/tools/pychecker/Warning.py

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

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