bee_python 0.0.3 → 0.0.4

data/tools/pylint2/pylint/checkers/variables.py

@@ -1,498 +0,0 @@
-# Copyright (c) 2003-2010 LOGILAB S.A. (Paris, FRANCE).
-# http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU General Public License as published by the Free Software
-# Foundation; either version 2 of the License, or (at your option) any later
-# version.
-#
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-"""variables checkers for Python code
-"""
-
-from copy import copy
-
-from logilab.common.compat import enumerate
-from logilab import astng
-from logilab.astng import are_exclusive, builtin_lookup
-
-from pylint.interfaces import IASTNGChecker
-from pylint.checkers import BaseChecker
-from pylint.checkers.utils import PYMETHODS, is_ancestor_name, is_builtin, \
-     is_defined_before, is_error, is_func_default, is_func_decorator, assign_parent
-
-
-def overridden_method(klass, name):
-    """get overridden method if any"""
-    try:
-        parent = klass.local_attr_ancestors(name).next()
-    except (StopIteration, KeyError):
-        return None
-    try:
-        meth_node = parent[name]
-    except KeyError:
-        # We have found an ancestor defining <name> but it's not in the local
-        # dictionary. This may happen with astng built from living objects.
-        return None
-    if isinstance(meth_node, astng.Function):
-        return meth_node
-    return None
-
-
-MSGS = {
-    'E0601': ('Using variable %r before assignment',
-              'Used when a local variable is accessed before it\'s \
-              assignment.'),
-    'E0602': ('Undefined variable %r',
-              'Used when an undefined variable is accessed.'),
-
-    'E0611': ('No name %r in module %r',
-              'Used when a name cannot be found in a module.'),
-
-    'W0601': ('Global variable %r undefined at the module level',
-              'Used when a variable is defined through the "global" statement \
-              but the variable is not defined in the module scope.'),
-    'W0602': ('Using global for %r but no assignment is done',
-              'Used when a variable is defined through the "global" statement \
-              but no assignment to this variable is done.'),
-    'W0603': ('Using the global statement', # W0121
-              'Used when you use the "global" statement to update a global \
-              variable. PyLint just try to discourage this \
-              usage. That doesn\'t mean you can not use it !'),
-    'W0604': ('Using the global statement at the module level', # W0103
-              'Used when you use the "global" statement at the module level \
-              since it has no effect'),
-    'W0611': ('Unused import %s',
-              'Used when an imported module or variable is not used.'),
-    'W0612': ('Unused variable %r',
-              'Used when a variable is defined but not used.'),
-    'W0613': ('Unused argument %r',
-              'Used when a function or method argument is not used.'),
-    'W0614': ('Unused import %s from wildcard import',
-              'Used when an imported module or variable is not used from a \
-              \'from X import *\' style import.'),
-
-    'W0621': ('Redefining name %r from outer scope (line %s)',
-              'Used when a variable\'s name hide a name defined in the outer \
-              scope.'),
-    'W0622': ('Redefining built-in %r',
-              'Used when a variable or function override a built-in.'),
-
-    'W0631': ('Using possibly undefined loop variable %r',
-              'Used when an loop variable (i.e. defined by a for loop or \
-              a list comprehension or a generator expression) is used outside \
-              the loop.'),
-    }
-
-class VariablesChecker(BaseChecker):
-    """checks for
-    * unused variables / imports
-    * undefined variables
-    * redefinition of variable from builtins or from an outer scope
-    * use of variable before assignment
-    """
-
-    __implements__ = IASTNGChecker
-
-    name = 'variables'
-    msgs = MSGS
-    priority = -1
-    options = (
-               ("init-import",
-                {'default': 0, 'type' : 'yn', 'metavar' : '<y_or_n>',
-                 'help' : 'Tells whether we should check for unused import in \
-__init__ files.'}),
-               ("dummy-variables-rgx",
-                {'default': ('_|dummy'),
-                 'type' :'regexp', 'metavar' : '<regexp>',
-                 'help' : 'A regular expression matching names used \
-                 for dummy variables (i.e. not used).'}),
-               ("additional-builtins",
-                {'default': (), 'type' : 'csv',
-                 'metavar' : '<comma separated list>',
-                 'help' : 'List of additional names supposed to be defined in \
-builtins. Remember that you should avoid to define new builtins when possible.'
-                 }),
-               )
-    def __init__(self, linter=None):
-        BaseChecker.__init__(self, linter)
-        self._to_consume = None
-        self._checking_mod_attr = None
-        self._vars = None
-
-    def visit_module(self, node):
-        """visit module : update consumption analysis variable
-        checks globals doesn't overrides builtins
-        """
-        self._to_consume = [(copy(node.locals), {}, 'module')]
-        self._vars = []
-        for name, stmts in node.locals.items():
-            if is_builtin(name):
-                # do not print Redefining builtin for additional builtins
-                self.add_message('W0622', args=name, node=stmts[0])
-
-    def leave_module(self, node):
-        """leave module: check globals
-        """
-        assert len(self._to_consume) == 1
-        not_consumed = self._to_consume.pop()[0]
-        # don't check unused imports in __init__ files
-        if not self.config.init_import and node.package:
-            return
-        for name, stmts in not_consumed.items():
-            stmt = stmts[0]
-            if isinstance(stmt, astng.Import):
-                self.add_message('W0611', args=name, node=stmt)
-            elif isinstance(stmt, astng.From) and stmt.modname != '__future__':
-                if stmt.names[0][0] == '*':
-                    self.add_message('W0614', args=name, node=stmt)
-                else:
-                    self.add_message('W0611', args=name, node=stmt)
-        del self._to_consume
-        del self._vars
-
-    def visit_class(self, node):
-        """visit class: update consumption analysis variable
-        """
-        self._to_consume.append((copy(node.locals), {}, 'class'))
-
-    def leave_class(self, _):
-        """leave class: update consumption analysis variable
-        """
-        # do not check for not used locals here (no sense)
-        self._to_consume.pop()
-
-    def visit_lambda(self, node):
-        """visit lambda: update consumption analysis variable
-        """
-        self._to_consume.append((copy(node.locals), {}, 'lambda'))
-
-    def leave_lambda(self, _):
-        """leave lambda: update consumption analysis variable
-        """
-        # do not check for not used locals here
-        self._to_consume.pop()
-
-    def visit_genexpr(self, node):
-        """visit genexpr: update consumption analysis variable
-        """
-        self._to_consume.append((copy(node.locals), {}, 'genexpr'))
-
-    def leave_genexpr(self, _):
-        """leave genexpr: update consumption analysis variable
-        """
-        # do not check for not used locals here
-        self._to_consume.pop()
-
-    def visit_function(self, node):
-        """visit function: update consumption analysis variable and check locals
-        """
-        globs = node.root().globals
-        for name, stmt in node.items():
-            if globs.has_key(name) and not isinstance(stmt, astng.Global):
-                line = globs[name][0].lineno
-                self.add_message('W0621', args=(name, line), node=stmt)
-            elif is_builtin(name):
-                # do not print Redefining builtin for additional builtins
-                self.add_message('W0622', args=name, node=stmt)
-        self._to_consume.append((copy(node.locals), {}, 'function'))
-        self._vars.append({})
-
-    def leave_function(self, node):
-        """leave function: check function's locals are consumed"""
-        not_consumed = self._to_consume.pop()[0]
-        self._vars.pop(0)
-        # don't check arguments of function which are only raising an exception
-        if is_error(node):
-            return
-        # don't check arguments of abstract methods or within an interface
-        is_method = node.is_method()
-        klass = node.parent.frame()
-        if is_method and (klass.type == 'interface' or node.is_abstract()):
-            return
-        authorized_rgx = self.config.dummy_variables_rgx
-        overridden = marker = []
-        argnames = node.argnames()
-        for name, stmts in not_consumed.iteritems():
-            # ignore some special names specified by user configuration
-            if authorized_rgx.match(name):
-                continue
-            # ignore names imported by the global statement
-            # FIXME: should only ignore them if it's assigned latter
-            stmt = stmts[0]
-            if isinstance(stmt, astng.Global):
-                continue
-            # care about functions with unknown argument (builtins)
-            if name in argnames:
-                if is_method:
-                    # don't warn for the first argument of a (non static) method
-                    if node.type != 'staticmethod' and name == argnames[0]:
-                        continue
-                    # don't warn for argument of an overridden method
-                    if overridden is marker:
-                        overridden = overridden_method(klass, node.name)
-                    if overridden is not None and name in overridden.argnames():
-                        continue
-                    if node.name in PYMETHODS and node.name not in ('__init__', '__new__'):
-                        continue
-                # don't check callback arguments XXX should be configurable
-                if node.name.startswith('cb_') or node.name.endswith('_cb'):
-                    continue
-                self.add_message('W0613', args=name, node=stmt)
-            else:
-                self.add_message('W0612', args=name, node=stmt)
-
-    def visit_global(self, node):
-        """check names imported exists in the global scope"""
-        frame = node.frame()
-        if isinstance(frame, astng.Module):
-            self.add_message('W0604', node=node)
-            return
-        module = frame.root()
-        default_message = True
-        for name in node.names:
-            try:
-                assign_nodes = module.getattr(name)
-            except astng.NotFoundError:
-                # unassigned global, skip
-                assign_nodes = []
-            for anode in assign_nodes:
-                if anode.parent is None:
-                    # node returned for builtin attribute such as __file__,
-                    # __doc__, etc...
-                    continue
-                if anode.frame() is frame:
-                    # same scope level assignment
-                    break
-            else:
-                # global but no assignment
-                self.add_message('W0602', args=name, node=node)
-                default_message = False
-            if not assign_nodes:
-                continue
-            for anode in assign_nodes:
-                if anode.parent is None:
-                    self.add_message('W0622', args=name, node=node)
-                    break
-                if anode.frame() is module:
-                    # module level assignment
-                    break
-            else:
-                # global undefined at the module scope
-                self.add_message('W0601', args=name, node=node)
-                default_message = False
-        if default_message:
-            self.add_message('W0603', node=node)
-
-    def _loopvar_name(self, node, name):
-        # filter variables according to node's scope
-        # XXX used to filter parents but don't remember why, and removing this
-        # fixes a W0631 false positive reported by Paul Hachmann on 2008/12 on
-        # python-projects (added to func_use_for_or_listcomp_var test)
-        #astmts = [stmt for stmt in node.lookup(name)[1]
-        #          if hasattr(stmt, 'ass_type')] and
-        #          not stmt.statement().parent_of(node)]
-        astmts = [stmt for stmt in node.lookup(name)[1]
-                  if hasattr(stmt, 'ass_type')]
-        # filter variables according their respective scope
-        if not astmts or astmts[0].statement().parent_of(node):
-            _astmts = []
-        else:
-            _astmts = astmts[:1]
-        for i, stmt in enumerate(astmts[1:]):
-            if astmts[i].statement().parent_of(stmt):
-                continue
-            _astmts.append(stmt)
-        astmts = _astmts
-        if len(astmts) == 1:
-            ass = astmts[0].ass_type()
-            if isinstance(ass, (astng.For, astng.Comprehension, astng.GenExpr)) \
-                   and not ass.statement() is node.statement():
-                self.add_message('W0631', args=name, node=node)
-
-    def visit_assname(self, node):
-        if isinstance(node.ass_type(), astng.AugAssign):
-            self.visit_name(node)
-
-    def visit_delname(self, node):
-        self.visit_name(node)
-
-    def visit_name(self, node):
-        """check that a name is defined if the current scope and doesn't
-        redefine a built-in
-        """
-        stmt = node.statement()
-        if stmt.fromlineno is None:
-            # name node from a astng built from live code, skip
-            assert not stmt.root().file.endswith('.py')
-            return
-        name = node.name
-        frame = stmt.scope()
-        # if the name node is used as a function default argument's value or as
-        # a decorator, then start from the parent frame of the function instead
-        # of the function frame - and thus open an inner class scope
-        if (is_func_default(node) or is_func_decorator(node)
-            or is_ancestor_name(frame, node)):
-            start_index = len(self._to_consume) - 2
-        else:
-            start_index = len(self._to_consume) - 1
-        # iterates through parent scopes, from the inner to the outer
-        base_scope_type = self._to_consume[start_index][-1]
-        for i in range(start_index, -1, -1):
-            to_consume, consumed, scope_type = self._to_consume[i]
-            # if the current scope is a class scope but it's not the inner
-            # scope, ignore it. This prevents to access this scope instead of
-            # the globals one in function members when there are some common
-            # names. The only exception is when the starting scope is a
-            # genexpr and its direct outer scope is a class
-            if scope_type == 'class' and i != start_index and not (
-                base_scope_type == 'genexpr' and i == start_index-1):
-                # XXX find a way to handle class scope in a smoother way
-                continue
-            # the name has already been consumed, only check it's not a loop
-            # variable used outside the loop
-            if consumed.has_key(name):
-                self._loopvar_name(node, name)
-                break
-            # mark the name as consumed if it's defined in this scope
-            # (i.e. no KeyError is raised by "to_consume[name]")
-            try:
-                consumed[name] = to_consume[name]
-            except KeyError:
-                continue
-            else:
-                # checks for use before assignment
-                defnode = assign_parent(to_consume[name][0])
-                if defnode is not None:
-                    defstmt = defnode.statement()
-                    defframe = defstmt.frame()
-                    maybee0601 = True
-                    if not frame is defframe:
-                        maybee0601 = False
-                    elif defframe.parent is None:
-                        # we are at the module level, check the name is not
-                        # defined in builtins
-                        if name in defframe.scope_attrs or builtin_lookup(name)[1]:
-                            maybee0601 = False
-                    else:
-                        # we are in a local scope, check the name is not
-                        # defined in global or builtin scope
-                        if defframe.root().lookup(name)[1]:
-                            maybee0601 = False
-                    if (maybee0601
-                        and stmt.fromlineno <= defstmt.fromlineno
-                        and not is_defined_before(node)
-                        and not are_exclusive(stmt, defstmt, ('NameError', 'Exception', 'BaseException'))):
-                        if defstmt is stmt and isinstance(node, (astng.DelName,
-                                                                 astng.AssName)):
-                            self.add_message('E0602', args=name, node=node)
-                        elif self._to_consume[-1][-1] != 'lambda':
-                            # E0601 may *not* occurs in lambda scope
-                            self.add_message('E0601', args=name, node=node)
-                if not isinstance(node, astng.AssName): # Aug AssName
-                    del to_consume[name]
-                else:
-                    del consumed[name]
-                # check it's not a loop variable used outside the loop
-                self._loopvar_name(node, name)
-                break
-        else:
-            # we have not found the name, if it isn't a builtin, that's an
-            # undefined name !
-            if not (name in astng.Module.scope_attrs or is_builtin(name)
-                    or name in self.config.additional_builtins):
-                self.add_message('E0602', args=name, node=node)
-
-    def visit_import(self, node):
-        """check modules attribute accesses"""
-        for name, _ in node.names:
-            parts = name.split('.')
-            try:
-                module = node.infer_name_module(parts[0]).next()
-            except astng.ResolveError:
-                continue
-            self._check_module_attrs(node, module, parts[1:])
-
-    def visit_from(self, node):
-        """check modules attribute accesses"""
-        name_parts = node.modname.split('.')
-        try:
-            module = node.root().import_module(name_parts[0])
-        except KeyboardInterrupt:
-            raise
-        except:
-            return
-        module = self._check_module_attrs(node, module, name_parts[1:])
-        if not module:
-            return
-        for name, _ in node.names:
-            if name == '*':
-                continue
-            self._check_module_attrs(node, module, name.split('.'))
-
-##     def leave_getattr(self, node):
-##         """check modules attribute accesses
-
-##         this function is a "leave_" because when parsing 'a.b.c'
-##         we want to check the innermost expression first.
-##         """
-##         if isinstance(node.expr, astng.Name):
-##             try:
-##                 module = node.expr.infer().next()
-##             except astng.InferenceError:
-##                 return
-##             if not isinstance(module, astng.Module):
-##                 # Not a module, don't check
-##                 return
-##         elif self._checking_mod_attr is not None:
-##             module = self._checking_mod_attr
-##         else:
-##             return
-##         self._checking_mod_attr = self._check_module_attrs(node, module,
-##                                                            [node.attrname])
-
-##     def leave_default(self, node):
-##         """by default, reset the _checking_mod_attr attribute"""
-##         self._checking_mod_attr = None
-
-    def _check_module_attrs(self, node, module, module_names):
-        """check that module_names (list of string) are accessible through the
-        given module
-        if the latest access name corresponds to a module, return it
-        """
-        assert isinstance(module, astng.Module), module
-        while module_names:
-            name = module_names.pop(0)
-            if name == '__dict__':
-                module = None
-                break
-            try:
-                module = module.getattr(name)[0].infer().next()
-            except astng.NotFoundError:
-                self.add_message('E0611', args=(name, module.name), node=node)
-                return None
-            except astng.InferenceError:
-                return None
-        if module_names:
-            # FIXME: other message if name is not the latest part of
-            # module_names ?
-            modname = module and module.name or '__dict__'
-            self.add_message('E0611', node=node,
-                             args=('.'.join(module_names), modname))
-            return None
-        if isinstance(module, astng.Module):
-            return module
-        return None
-
-
-
-
-def register(linter):
-    """required method to auto register this checker"""
-    linter.register_checker(VariablesChecker(linter))

data/tools/pylint2/pylint/config.py

@@ -1,149 +0,0 @@
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU General Public License as published by the Free Software
-# Foundation; either version 2 of the License, or (at your option) any later
-# version.
-#
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-""" Copyright (c) 2003-2006 LOGILAB S.A. (Paris, FRANCE).
- http://www.logilab.fr/ -- mailto:contact@logilab.fr
-
-  utilities for PyLint configuration :
-   _ pylintrc
-   _ pylint.d (PYLINT_HOME)
-"""
-
-import pickle
-import os
-import sys
-from os.path import exists, isfile, join, expanduser, abspath, dirname
-
-# pylint home is used to save old runs results ################################
-
-USER_HOME = expanduser('~')
-if os.environ.has_key('PYLINTHOME'):
-    PYLINT_HOME = os.environ['PYLINTHOME']
-    if USER_HOME == '~':
-        USER_HOME = dirname(PYLINT_HOME)
-elif USER_HOME == '~':
-    PYLINT_HOME = ".pylint.d"
-else:
-    PYLINT_HOME = join(USER_HOME, '.pylint.d')
-        
-if not exists(PYLINT_HOME):
-    try:
-        os.mkdir(PYLINT_HOME)
-    except OSError:
-        print >> sys.stderr, 'Unable to create directory %s' % PYLINT_HOME
-
-def get_pdata_path(base_name, recurs):
-    """return the path of the file which should contain old search data for the
-    given base_name with the given options values
-    """
-    base_name = base_name.replace(os.sep, '_')
-    return join(PYLINT_HOME, "%s%s%s"%(base_name, recurs, '.stats'))
-    
-def load_results(base):
-    """try to unpickle and return data from file if it exists and is not
-    corrupted
-    
-    return an empty dictionary if it doesn't exists
-    """
-    data_file = get_pdata_path(base, 1)        
-    try:
-        return pickle.load(open(data_file))
-    except:
-        return {}
-
-def save_results(results, base):
-    """pickle results"""
-    data_file = get_pdata_path(base, 1)
-    try:
-        pickle.dump(results, open(data_file, 'w'))
-    except (IOError, OSError), ex:
-        print >> sys.stderr, 'Unable to create file %s: %s' % (data_file, ex)
-    
-# location of the configuration file ##########################################
-
-
-def find_pylintrc():
-    """search the pylint rc file and return its path if it find it, else None
-    """
-    # is there a pylint rc file in the current directory ?
-    if exists('pylintrc'):
-        return abspath('pylintrc')
-    if isfile('__init__.py'):
-        curdir = abspath(os.getcwd())
-        while isfile(join(curdir, '__init__.py')):
-            curdir = abspath(join(curdir, '..'))
-            if isfile(join(curdir, 'pylintrc')):
-                return join(curdir, 'pylintrc')
-    if os.environ.has_key('PYLINTRC') and exists(os.environ['PYLINTRC']):
-        pylintrc = os.environ['PYLINTRC']
-    else:
-        user_home = expanduser('~')
-        if user_home == '~' or user_home == '/root':
-            pylintrc = ".pylintrc"
-        else:
-            pylintrc = join(user_home, '.pylintrc')
-    if not isfile(pylintrc):
-        if isfile('/etc/pylintrc'):
-            pylintrc = '/etc/pylintrc'
-        else:
-            pylintrc = None
-    return pylintrc
-
-PYLINTRC = find_pylintrc()
-
-ENV_HELP = '''
-The following environment variables are used :                                 
-    * PYLINTHOME                                                               
-    path to the directory where data of persistent run will be stored. If not
-found, it defaults to ~/.pylint.d/ or .pylint.d (in the current working
-directory) . The current PYLINTHOME is %(PYLINT_HOME)s.        
-    * PYLINTRC                                                                 
-    path to the configuration file. If not found, it will use the first        
-existent file in ~/.pylintrc, /etc/pylintrc. The current PYLINTRC is
-%(PYLINTRC)s.                                                                 
-''' % globals()
-
-# evaluation messages #########################################################
-
-def get_note_message(note):
-    """return a message according to note
-    note is a float < 10  (10 is the highest note)
-    """
-    assert note <= 10, "Note is %.2f. Either you cheated, or pylint's \
-broken!" % note
-    if note < 0:
-        msg = 'You have to do something quick !'
-    elif note < 1:
-        msg = 'Hey! This is really dreadful. Or maybe pylint is buggy?'
-    elif note < 2:
-        msg = "Come on! You can't be proud of this code"
-    elif note < 3:
-        msg = 'Hum... Needs work.'
-    elif note < 4:
-        msg = 'Wouldn\'t you be a bit lazy?'
-    elif note < 5:
-        msg = 'A little more work would make it acceptable.'
-    elif note < 6:
-        msg = 'Just the bare minimum. Give it a bit more polish. '
-    elif note < 7:
-        msg = 'This is okay-ish, but I\'m sure you can do better.'
-    elif note < 8:
-        msg = 'If you commit now, people should not be making nasty \
-comments about you on c.l.py'
-    elif note < 9:
-        msg = 'That\'s pretty good. Good work mate.'
-    elif note < 10:
-        msg = 'So close to being perfect...'
-    else:
-        msg = 'Wow ! Now this deserves our uttermost respect.\nPlease send \
-your code to python-projects@logilab.org'
-    return msg