bee_python 0.0.3 → 0.0.4

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

@@ -1,239 +0,0 @@
-# Copyright (c) 2009-2010 Arista Networks, Inc. - James Lingard
-# Copyright (c) 2004-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.
-
-
-"""Checker for string formatting operations.
-"""
-
-import string
-from logilab import astng
-from pylint.interfaces import IASTNGChecker
-from pylint.checkers import BaseChecker
-
-MSGS = {
-    'E9900': ("Unsupported format character %r (%#02x) at index %d",
-              "Used when a unsupported format character is used in a format\
-              string."),
-    'E9901': ("Format string ends in middle of conversion specifier",
-              "Used when a format string terminates before the end of a \
-              conversion specifier."),
-    'E9902': ("Mixing named and unnamed conversion specifiers in format string",
-              "Used when a format string contains both named (e.g. '%(foo)d') \
-              and unnamed (e.g. '%d') conversion specifiers.  This is also \
-              used when a named conversion specifier contains * for the \
-              minimum field width and/or precision."),
-    'E9903': ("Expected mapping for format string, not %s",
-              "Used when a format string that uses named conversion specifiers \
-              is used with an argument that is not a mapping."),
-    'W9900': ("Format string dictionary key should be a string, not %s",
-              "Used when a format string that uses named conversion specifiers \
-              is used with a dictionary whose keys are not all strings."),
-    'W9901': ("Unused key %r in format string dictionary",
-              "Used when a format string that uses named conversion specifiers \
-              is used with a dictionary that conWtains keys not required by the \
-              format string."),
-    'E9904': ("Missing key %r in format string dictionary",
-              "Used when a format string that uses named conversion specifiers \
-              is used with a dictionary that doesn't contain all the keys \
-              required by the format string."),
-    'E9905': ("Too many arguments for format string",
-              "Used when a format string that uses unnamed conversion \
-              specifiers is given too few arguments."),
-    'E9906': ("Not enough arguments for format string",
-              "Used when a format string that uses unnamed conversion \
-              specifiers is given too many arguments"),
-    }
-
-class IncompleteFormatStringException(Exception):
-    """A format string ended in the middle of a format specifier."""
-    pass
-
-class UnsupportedFormatCharacterException(Exception):
-    """A format character in a format string is not one of the supported
-    format characters."""
-    def __init__(self, index):
-        Exception.__init__(self, index)
-        self.index = index
-
-def parse_format_string(format_string):
-    """Parses a format string, returning a tuple of (keys, num_args), where keys
-    is the set of mapping keys in the format string, and num_args is the number
-    of arguments required by the format string.  Raises
-    IncompleteFormatStringException or UnsupportedFormatCharacterException if a
-    parse error occurs."""
-    keys = set()
-    num_args = 0
-    def next_char(i):
-        i += 1
-        if i == len(format_string):
-            raise IncompleteFormatStringException
-        return (i, format_string[i])
-    i = 0
-    while i < len(format_string):
-        c = format_string[i]
-        if c == '%':
-            i, c = next_char(i)
-            # Parse the mapping key (optional).
-            key = None
-            if c == '(':
-                depth = 1
-                i, c = next_char(i)
-                key_start = i
-                while depth != 0:
-                    if c == '(':
-                        depth += 1
-                    elif c == ')':
-                        depth -= 1
-                    i, c = next_char(i)
-                key_end = i - 1
-                key = format_string[key_start:key_end]
-
-            # Parse the conversion flags (optional).
-            while c in '#0- +':
-                i, c = next_char(i)
-            # Parse the minimum field width (optional).
-            if c == '*':
-                num_args += 1
-                i, c = next_char(i)
-            else:
-                while c in string.digits:
-                    i, c = next_char(i)
-            # Parse the precision (optional).
-            if c == '.':
-                i, c = next_char(i)
-                if c == '*':
-                    num_args += 1
-                    i, c = next_char(i)
-                else:
-                    while c in string.digits:
-                        i, c = next_char(i)
-            # Parse the length modifier (optional).
-            if c in 'hlL':
-                i, c = next_char(i)
-            # Parse the conversion type (mandatory).
-            if c not in 'diouxXeEfFgGcrs%':
-                raise UnsupportedFormatCharacterException(i)
-            if key:
-                keys.add(key)
-            elif c != '%':
-                num_args += 1
-        i += 1
-    return keys, num_args
-
-class StringFormatChecker(BaseChecker):
-    """Checks string formatting operations to ensure that the format string
-    is valid and the arguments match the format string.
-    """
-    __implements__ = (IASTNGChecker,)
-    name = 'string_format'
-    msgs = MSGS
-    def visit_binop(self, node):
-        if node.op != '%':
-            return
-        f = node.left
-        args = node.right
-        if isinstance(f, astng.Const) and isinstance(f.value, basestring):
-            format_string = f.value
-            try:
-                required_keys, required_num_args = \
-                    parse_format_string(format_string)
-            except UnsupportedFormatCharacterException, e:
-                c = format_string[e.index]
-                self.add_message('E9900', node=node, args=(c, ord(c), e.index))
-            except IncompleteFormatStringException:
-                self.add_message('E9901', node=node)
-            else:
-                if required_keys and required_num_args:
-                    # The format string uses both named and unnamed format
-                    # specifiers.
-                    self.add_message('E9902', node=node)
-                elif required_keys:
-                    # The format string uses only named format specifiers.
-                    # Check that the RHS of the % operator is a mapping object
-                    # that contains precisely the set of keys required by the
-                    # format string.
-                    if isinstance(args, astng.Dict):
-                        keys = set()
-                        unknown_keys = False
-                        for k, v in args.items:
-                            if isinstance(k, astng.Const):
-                                key = k.value
-                                if isinstance(key, basestring):
-                                    keys.add(key)
-                                else:
-                                    self.add_message('W9900',
-                                                     node=node,
-                                                     args=key)
-                            else:
-                                # One of the keys was something other than a
-                                # constant.  Since we can't tell what it is,
-                                # supress checks for missing keys in the
-                                # dictionary.
-                                unknown_keys = True
-                        if not unknown_keys:
-                            for key in required_keys:
-                                if key not in keys:
-                                    self.add_message('E9904',
-                                                     node=node,
-                                                     args=key)
-                        for key in keys:
-                            if key not in required_keys:
-                                self.add_message('W9901', node=node, args=key)
-                    elif (isinstance(args, astng.Const) or
-                          isinstance(args, astng.Tuple) or
-                          isinstance(args, astng.List) or
-                          isinstance(args, astng.ListComp) or
-                          isinstance(args, astng.GenExpr) or
-                          isinstance(args, astng.Backquote) or
-                          isinstance(args, astng.Lambda)):
-                        type_name = type(args).__name__
-                        self.add_message('E9903', node=node, args=type_name)
-                    else:
-                        # The RHS of the format specifier is a name or
-                        # expression.  It may be a mapping object, so
-                        # there's nothing we can check.
-                        pass
-                else:
-                    # The format string uses only unnamed format specifiers.
-                    # Check that the number of arguments passed to the RHS of
-                    # the % operator matches the number required by the format
-                    # string.
-                    if isinstance(args, astng.Tuple):
-                        num_args = len(args.elts)
-                    elif (isinstance(args, astng.Const) or
-                          isinstance(args, astng.Dict) or
-                          isinstance(args, astng.List) or
-                          isinstance(args, astng.ListComp) or
-                          isinstance(args, astng.GenExpr) or
-                          isinstance(args, astng.Backquote) or
-                          isinstance(args, astng.Lambda) or
-                          isinstance(args, astng.Function)):
-                        num_args = 1
-                    else:
-                        # The RHS of the format specifier is a name or
-                        # expression.  It could be a tuple of unknown size, so
-                        # there's nothing we can check.
-                        num_args = None
-                    if num_args is not None:
-                        if num_args > required_num_args:
-                            self.add_message('E9905', node=node)
-                        elif num_args < required_num_args:
-                            self.add_message('E9906', node=node)
-
-
-def register(linter):
-    """required method to auto register this checker """
-    linter.register_checker(StringFormatChecker(linter))

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

@@ -1,364 +0,0 @@
-# Copyright (c) 2006-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.
-"""try to find more bugs in the code using astng inference capabilities
-"""
-
-from logilab.common.compat import set
-
-
-from logilab import astng
-from logilab.astng import InferenceError, NotFoundError, YES, Instance
-
-from pylint.interfaces import IASTNGChecker
-from pylint.checkers import BaseChecker
-from pylint.checkers.utils import safe_infer, is_super
-
-MSGS = {
-    'E1101': ('%s %r has no %r member',
-              'Used when a variable is accessed for an unexistent member.'),
-    'E1102': ('%s is not callable',
-              'Used when an object being called has been inferred to a non \
-              callable object'),
-    'E1103': ('%s %r has no %r member (but some types could not be inferred)',
-              'Used when a variable is accessed for an unexistent member, but \
-              astng was not able to interpret all possible types of this \
-              variable.'),
-    'E1111': ('Assigning to function call which doesn\'t return',
-              'Used when an assignment is done on a function call but the \
-              inferred function doesn\'t return anything.'),
-    'W1111': ('Assigning to function call which only returns None',
-              'Used when an assignment is done on a function call but the \
-              inferred function returns nothing but None.'),
-
-    'E1120': ('No value passed for parameter %s in function call',
-              'Used when a function call passes too few arguments.'),
-    'E1121': ('Too many positional arguments for function call',
-              'Used when a function call passes too many positional \
-              arguments.'),
-    'E1122': ('Duplicate keyword argument %r in function call',
-              'Used when a function call passes the same keyword argument \
-              multiple times.'),
-    'E1123': ('Passing unexpected keyword argument %r in function call',
-              'Used when a function call passes a keyword argument that \
-              doesn\'t correspond to one of the function\'s parameter names.'),
-    'E1124': ('Multiple values passed for parameter %r in function call',
-              'Used when a function call would result in assigning multiple \
-              values to a function parameter, one value from a positional \
-              argument and one from a keyword argument.'),
-    }
-
-class TypeChecker(BaseChecker):
-    """try to find bugs in the code using type inference
-    """
-
-    __implements__ = (IASTNGChecker,)
-
-    # configuration section name
-    name = 'typecheck'
-    # messages
-    msgs = MSGS
-    priority = -1
-    # configuration options
-    options = (('ignore-mixin-members',
-                {'default' : True, 'type' : 'yn', 'metavar': '<y_or_n>',
-                 'help' : 'Tells whether missing members accessed in mixin \
-class should be ignored. A mixin class is detected if its name ends with \
-"mixin" (case insensitive).'}
-                ),
-
-               ('ignored-classes',
-                {'default' : ('SQLObject',),
-                 'type' : 'csv',
-                 'metavar' : '<members names>',
-                 'help' : 'List of classes names for which member attributes \
-should not be checked (useful for classes with attributes dynamically set).'}
-                 ),
-
-               ('zope',
-                {'default' : False, 'type' : 'yn', 'metavar': '<y_or_n>',
-                 'help' : 'When zope mode is activated, add a predefined set \
-of Zope acquired attributes to generated-members.'}
-                ),
-               ('generated-members',
-                {'default' : (
-        'REQUEST', 'acl_users', 'aq_parent'),
-                 'type' : 'csv',
-                 'metavar' : '<members names>',
-                 'help' : 'List of members which are set dynamically and \
-missed by pylint inference system, and so shouldn\'t trigger E0201 when \
-accessed.'}
-                ),
-        )
-    def __init__(self, linter=None):
-        BaseChecker.__init__(self, linter)
-        self.generated_members = list(self.config.generated_members)
-        if self.config.zope:
-            self.generated_members.extend(('REQUEST', 'acl_users', 'aq_parent'))
-
-    def visit_assattr(self, node):
-        if isinstance(node.ass_type(), astng.AugAssign):
-            self.visit_getattr(node)
-
-    def visit_delattr(self, node):
-        self.visit_getattr(node)
-
-    def visit_getattr(self, node):
-        """check that the accessed attribute exists
-
-        to avoid to much false positives for now, we'll consider the code as
-        correct if a single of the inferred nodes has the accessed attribute.
-
-        function/method, super call and metaclasses are ignored
-        """
-        if node.attrname in self.generated_members:
-            # attribute is marked as generated, stop here
-            return
-        try:
-            infered = list(node.expr.infer())
-        except InferenceError:
-            return
-        # list of (node, nodename) which are missing the attribute
-        missingattr = set()
-        ignoremim = self.config.ignore_mixin_members
-        inference_failure = False
-        for owner in infered:
-            # skip yes object
-            if owner is YES:
-                inference_failure = True
-                continue
-            # skip None anyway
-            if isinstance(owner, astng.Const) and owner.value is None:
-                continue
-            # XXX "super" / metaclass call
-            if is_super(owner) or getattr(owner, 'type', None) == 'metaclass':
-                continue
-            name = getattr(owner, 'name', 'None')
-            if name in self.config.ignored_classes:
-                continue
-            if ignoremim and name[-5:].lower() == 'mixin':
-                continue
-            try:
-                if not [n for n in owner.getattr(node.attrname)
-                        if not isinstance(n.statement(), astng.AugAssign)]:
-                    missingattr.add((owner, name))
-                    continue
-            except AttributeError:
-                # XXX method / function
-                continue
-            except NotFoundError:
-                if isinstance(owner, Instance) and owner.has_dynamic_getattr():
-                    continue
-                # explicit skipping of optparse'Values class
-                if owner.name == 'Values' and \
-                       owner.root().name in ('optik', 'optparse'):
-                    continue
-                missingattr.add((owner, name))
-                continue
-            # stop on the first found
-            break
-        else:
-            # we have not found any node with the attributes, display the
-            # message for infered nodes
-            done = set()
-            for owner, name in missingattr:
-                if isinstance(owner, Instance):
-                    actual = owner._proxied
-                else:
-                    actual = owner
-                if actual in done:
-                    continue
-                done.add(actual)
-                if inference_failure:
-                    msgid = 'E1103'
-                else:
-                    msgid = 'E1101'
-                self.add_message(msgid, node=node,
-                                 args=(owner.display_type(), name,
-                                       node.attrname))
-
-
-    def visit_assign(self, node):
-        """check that if assigning to a function call, the function is
-        possibly returning something valuable
-        """
-        if not isinstance(node.value, astng.CallFunc):
-            return
-        function_node = safe_infer(node.value.func)
-        # skip class, generator and incomplete function definition
-        if not (isinstance(function_node, astng.Function) and
-                function_node.root().fully_defined()):
-            return
-        if function_node.is_generator() \
-               or function_node.is_abstract(pass_is_abstract=False):
-            return
-        returns = list(function_node.nodes_of_class(astng.Return,
-                                                    skip_klass=astng.Function))
-        if len(returns) == 0:
-            self.add_message('E1111', node=node)
-        else:
-            for rnode in returns:
-                if not (isinstance(rnode.value, astng.Const)
-                        and rnode.value.value is None):
-                    break
-            else:
-                self.add_message('W1111', node=node)
-
-    def visit_callfunc(self, node):
-        """check that called functions/methods are inferred to callable objects,
-        and that the arguments passed to the function match the parameters in
-        the inferred function's definition
-        """
-
-        # Build the set of keyword arguments, checking for duplicate keywords,
-        # and count the positional arguments.
-        keyword_args = set()
-        num_positional_args = 0
-        for arg in node.args:
-            if isinstance(arg, astng.Keyword):
-                keyword = arg.arg
-                if keyword in keyword_args:
-                    self.add_message('E1122', node=node, args=keyword)
-                keyword_args.add(keyword)
-            else:
-                num_positional_args += 1
-
-        called = safe_infer(node.func)
-        # only function, generator and object defining __call__ are allowed
-        if called is not None and not called.callable():
-            self.add_message('E1102', node=node, args=node.func.as_string())
-
-        # Note that BoundMethod is a subclass of UnboundMethod (huh?), so must
-        # come first in this 'if..else'.
-        if isinstance(called, astng.BoundMethod):
-            # Bound methods have an extra implicit 'self' argument.
-            num_positional_args += 1
-        elif isinstance(called, astng.UnboundMethod):
-            if called.decorators is not None:
-                for d in called.decorators.nodes:
-                    if isinstance(d, astng.Name) and (d.name == 'classmethod'):
-                        # Class methods have an extra implicit 'cls' argument.
-                        num_positional_args += 1
-                        break
-        elif (isinstance(called, astng.Function) or
-              isinstance(called, astng.Lambda)):
-            pass
-        else:
-            return
-
-        if called.args.args is None:
-            # Built-in functions have no argument information.
-            return
-
-        if len( called.argnames() ) != len( set( called.argnames() ) ):
-            # Duplicate parameter name (see E9801).  We can't really make sense
-            # of the function call in this case, so just return.
-            return
-
-        # Analyze the list of formal parameters.
-        num_mandatory_parameters = len(called.args.args) - len(called.args.defaults)
-        parameters = []
-        parameter_name_to_index = {}
-        for i, arg in enumerate(called.args.args):
-            if isinstance(arg, astng.Tuple):
-                name = None
-                # Don't store any parameter names within the tuple, since those
-                # are not assignable from keyword arguments.
-            else:
-                if isinstance(arg, astng.Keyword):
-                    name = arg.arg
-                else:
-                    assert isinstance(arg, astng.AssName)
-                    # This occurs with:
-                    #    def f( (a), (b) ): pass
-                    name = arg.name
-                parameter_name_to_index[name] = i
-            if i >= num_mandatory_parameters:
-                defval = called.args.defaults[i - num_mandatory_parameters]
-            else:
-                defval = None
-            parameters.append([(name, defval), False])
-
-        # Match the supplied arguments against the function parameters.
-
-        # 1. Match the positional arguments.
-        for i in range(num_positional_args):
-            if i < len(parameters):
-                parameters[i][1] = True
-            elif called.args.vararg is not None:
-                # The remaining positional arguments get assigned to the *args
-                # parameter.
-                break
-            else:
-                # Too many positional arguments.
-                self.add_message('E1121', node=node)
-                break
-
-        # 2. Match the keyword arguments.
-        for keyword in keyword_args:
-            if keyword in parameter_name_to_index:
-                i = parameter_name_to_index[keyword]
-                if parameters[i][1]:
-                    # Duplicate definition of function parameter.
-                    self.add_message('E1124', node=node, args=keyword)
-                else:
-                    parameters[i][1] = True
-            elif called.args.kwarg is not None:
-                # The keyword argument gets assigned to the **kwargs parameter.
-                pass
-            else:
-                # Unexpected keyword argument.
-                self.add_message('E1123', node=node, args=keyword)
-
-        # 3. Match the *args, if any.  Note that Python actually processes
-        #    *args _before_ any keyword arguments, but we wait until after
-        #    looking at the keyword arguments so as to make a more conservative
-        #    guess at how many values are in the *args sequence.
-        if node.starargs is not None:
-            for i in range(num_positional_args, len(parameters)):
-                [(name, defval), assigned] = parameters[i]
-                # Assume that *args provides just enough values for all
-                # non-default parameters after the last parameter assigned by
-                # the positional arguments but before the first parameter
-                # assigned by the keyword arguments.  This is the best we can
-                # get without generating any false positives.
-                if (defval is not None) or assigned:
-                    break
-                parameters[i][1] = True
-
-        # 4. Match the **kwargs, if any.
-        if node.kwargs is not None:
-            for i, [(name, defval), assigned] in enumerate(parameters):
-                # Assume that *kwargs provides values for all remaining
-                # unassigned named parameters.
-                if name is not None:
-                    parameters[i][1] = True
-                else:
-                    # **kwargs can't assign to tuples.
-                    pass
-
-        # Check that any parameters without a default have been assigned
-        # values.
-        for [(name, defval), assigned] in parameters:
-            if (defval is None) and not assigned:
-                if name is None:
-                    display = '<tuple>'
-                else:
-                    display_name = repr(name)
-                self.add_message('E1120', node=node, args=display_name)
-
-def register(linter):
-    """required method to auto register this checker """
-    linter.register_checker(TypeChecker(linter))