eric: Plugins/CheckerPlugins/Pep8/pep8.py@62171fa4a6a4 (annotated)

 # -*- coding: utf-8 -*-
 #
 # pep8.py - Check Python source code formatting, according to PEP 8
 # Copyright (C) 2006-2009 Johann C. Rocholl <johann@rocholl.net>
 # Copyright (C) 2009-2013 Florent Xicluna <florent.xicluna@gmail.com>
 #
 # Permission is hereby granted, free of charge, to any person
 # obtaining a copy of this software and associated documentation files
 # (the "Software"), to deal in the Software without restriction,
 # including without limitation the rights to use, copy, modify, merge,
 # publish, distribute, sublicense, and/or sell copies of the Software,
 # and to permit persons to whom the Software is furnished to do so,
 # subject to the following conditions:
 #
 # The above copyright notice and this permission notice shall be
 # included in all copies or substantial portions of the Software.
 #
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 # BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 # ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 """
 Check Python source code formatting, according to PEP 8:
 http://www.python.org/dev/peps/pep-0008/
 For usage and a list of options, try this:
 $ python pep8.py -h
 This program and its regression test suite live here:
 http://github.com/jcrocholl/pep8
 Groups of errors and warnings:
 E errors
 W warnings
 indentation
 whitespace
 blank lines
 imports
 line length
 deprecation
 statements
 syntax error
 """
 #
 # This is a modified version to make the original pep8.py better suitable
 # for being called from within the eric5 IDE. The modifications are as
 # follows:
 #
 # - made messages translatable via Qt
 #
 # Copyright (c) 2011 - 2013 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 __version__ = '1.4.6'
 import os
 import sys
 import re
 import time
 import inspect
 import keyword
 import tokenize
 from optparse import OptionParser
 from fnmatch import fnmatch
 try:
     from configparser import RawConfigParser
     from io import TextIOWrapper
 except ImportError:
     from ConfigParser import RawConfigParser            # __IGNORE_WARNING__
 from PyQt4.QtCore import QCoreApplication, QT_TRANSLATE_NOOP
 DEFAULT_EXCLUDE = '.svn,CVS,.bzr,.hg,.git,__pycache__'
 DEFAULT_IGNORE = 'E123,E226,E24'
 if sys.platform == 'win32':
     DEFAULT_CONFIG = os.path.expanduser(r'~\.pep8')
 else:
     DEFAULT_CONFIG = os.path.join(os.getenv('XDG_CONFIG_HOME') or
                                   os.path.expanduser('~/.config'), 'pep8')
 PROJECT_CONFIG = ('setup.cfg', 'tox.ini', '.pep8')
 TESTSUITE_PATH = os.path.join(os.path.dirname(__file__), 'testsuite')
 MAX_LINE_LENGTH = 79
 REPORT_FORMAT = {
     'default': '%(path)s:%(row)d:%(col)d: %(code)s %(text)s',
     'pylint': '%(path)s:%(row)d: [%(code)s] %(text)s',
 }
 PyCF_ONLY_AST = 1024
 SINGLETONS = frozenset(['False', 'None', 'True'])
 KEYWORDS = frozenset(keyword.kwlist + ['print']) - SINGLETONS
 UNARY_OPERATORS = frozenset(['>>', '**', '*', '+', '-'])
 ARITHMETIC_OP = frozenset(['**', '*', '/', '//', '+', '-'])
 WS_OPTIONAL_OPERATORS = ARITHMETIC_OP.union(['^', '&', '|', '<<', '>>', '%'])
 WS_NEEDED_OPERATORS = frozenset([
     '**=', '*=', '/=', '//=', '+=', '-=', '!=', '<>', '<', '>',
     '%=', '^=', '&=', '|=', '==', '<=', '>=', '<<=', '>>=', '='])
 WHITESPACE = frozenset(' \t')
 SKIP_TOKENS = frozenset([tokenize.COMMENT, tokenize.NL, tokenize.NEWLINE,
                          tokenize.INDENT, tokenize.DEDENT])
 BENCHMARK_KEYS = ['directories', 'files', 'logical lines', 'physical lines']
 INDENT_REGEX = re.compile(r'([ \t]*)')
 RAISE_COMMA_REGEX = re.compile(r'raise\s+\w+\s*,')
 RERAISE_COMMA_REGEX = re.compile(r'raise\s+\w+\s*,\s*\w+\s*,\s*\w+')
 ERRORCODE_REGEX = re.compile(r'\b[A-Z]\d{3}\b')
 DOCSTRING_REGEX = re.compile(r'u?r?["\']')
 EXTRANEOUS_WHITESPACE_REGEX = re.compile(r'[[({] | []}),;:]')
 WHITESPACE_AFTER_COMMA_REGEX = re.compile(r'[,;:]\s*(?:  |\t)')
 COMPARE_SINGLETON_REGEX = re.compile(r'([=!]=)\s*(None|False|True)')
 COMPARE_TYPE_REGEX = re.compile(r'(?:[=!]=|is(?:\s+not)?)\s*type(?:s.\w+Type'
                                 r'|\s*\(\s*([^)]*[^ )])\s*\))')
 KEYWORD_REGEX = re.compile(r'(\s*)\b(?:%s)\b(\s*)' % r'|'.join(KEYWORDS))
 OPERATOR_REGEX = re.compile(r'(?:[^,\s])(\s*)(?:[-+*/|!<=>%&^]+)(\s*)')
 LAMBDA_REGEX = re.compile(r'\blambda\b')
 HUNK_REGEX = re.compile(r'^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@.*$')
 # Work around Python < 2.6 behaviour, which does not generate NL after
 # a comment which is on a line by itself.
 COMMENT_WITH_NL = tokenize.generate_tokens(['#\n'].pop).send(None)[1] == '#\n'
 ##############################################################################
 # Helper functions for translated and formatted messages
 ##############################################################################
 pep8_messages = {
     "E101": QT_TRANSLATE_NOOP("pep8",
         "indentation contains mixed spaces and tabs"),
     "E111": QT_TRANSLATE_NOOP("pep8",
         "indentation is not a multiple of four"),
     "E112": QT_TRANSLATE_NOOP("pep8",
         "expected an indented block"),
     "E113": QT_TRANSLATE_NOOP("pep8",
         "unexpected indentation"),
     "E121": QT_TRANSLATE_NOOP("pep8",
         "continuation line indentation is not a multiple of four"),
     "E122": QT_TRANSLATE_NOOP("pep8",
         "continuation line missing indentation or outdented"),
     "E123": QT_TRANSLATE_NOOP("pep8",
         "closing bracket does not match indentation of opening bracket's line"),
     "E124": QT_TRANSLATE_NOOP("pep8",
         "closing bracket does not match visual indentation"),
     "E125": QT_TRANSLATE_NOOP("pep8",
         "continuation line does not distinguish itself from next logical line"),
     "E126": QT_TRANSLATE_NOOP("pep8",
         "continuation line over-indented for hanging indent"),
     "E127": QT_TRANSLATE_NOOP("pep8",
         "continuation line over-indented for visual indent"),
     "E128": QT_TRANSLATE_NOOP("pep8",
         "continuation line under-indented for visual indent"),
     "E133": QT_TRANSLATE_NOOP("pep8",
         "closing bracket is missing indentation"),
     "W191": QT_TRANSLATE_NOOP("pep8",
         "indentation contains tabs"),
     "E201": QT_TRANSLATE_NOOP("pep8",
         "whitespace after '{0}'"),
     "E202": QT_TRANSLATE_NOOP("pep8",
         "whitespace before '{0}'"),
     "E203": QT_TRANSLATE_NOOP("pep8",
         "whitespace before '{0}'"),
     "E211": QT_TRANSLATE_NOOP("pep8",
         "whitespace before '{0}'"),
     "E221": QT_TRANSLATE_NOOP("pep8",
         "multiple spaces before operator"),
     "E222": QT_TRANSLATE_NOOP("pep8",
         "multiple spaces after operator"),
     "E223": QT_TRANSLATE_NOOP("pep8",
         "tab before operator"),
     "E224": QT_TRANSLATE_NOOP("pep8",
         "tab after operator"),
     "E225": QT_TRANSLATE_NOOP("pep8",
         "missing whitespace around operator"),
     "E226": QT_TRANSLATE_NOOP("pep8",
         "missing whitespace around arithmetic operator"),
     "E227": QT_TRANSLATE_NOOP("pep8",
         "missing whitespace around bitwise or shift operator"),
     "E228": QT_TRANSLATE_NOOP("pep8",
         "missing whitespace around modulo operator"),
     "E231": QT_TRANSLATE_NOOP("pep8",
         "missing whitespace after '{0}'"),
     "E241": QT_TRANSLATE_NOOP("pep8",
         "multiple spaces after '{0}'"),
     "E242": QT_TRANSLATE_NOOP("pep8",
         "tab after '{0}'"),
     "E251": QT_TRANSLATE_NOOP("pep8",
         "unexpected spaces around keyword / parameter equals"),
     "E261": QT_TRANSLATE_NOOP("pep8",
         "at least two spaces before inline comment"),
     "E262": QT_TRANSLATE_NOOP("pep8",
         "inline comment should start with '# '"),
     "E271": QT_TRANSLATE_NOOP("pep8",
         "multiple spaces after keyword"),
     "E272": QT_TRANSLATE_NOOP("pep8",
         "multiple spaces before keyword"),
     "E273": QT_TRANSLATE_NOOP("pep8",
         "tab after keyword"),
     "E274": QT_TRANSLATE_NOOP("pep8",
         "tab before keyword"),
     "W291": QT_TRANSLATE_NOOP("pep8",
         "trailing whitespace"),
     "W292": QT_TRANSLATE_NOOP("pep8",
         "no newline at end of file"),
     "W293": QT_TRANSLATE_NOOP("pep8",
         "blank line contains whitespace"),
     "E301": QT_TRANSLATE_NOOP("pep8",
         "expected 1 blank line, found 0"),
     "E302": QT_TRANSLATE_NOOP("pep8",
         "expected 2 blank lines, found {0}"),
     "E303": QT_TRANSLATE_NOOP("pep8",
         "too many blank lines ({0})"),
     "E304": QT_TRANSLATE_NOOP("pep8",
         "blank lines found after function decorator"),
     "W391": QT_TRANSLATE_NOOP("pep8",
         "blank line at end of file"),
     "E401": QT_TRANSLATE_NOOP("pep8",
         "multiple imports on one line"),
     "E501": QT_TRANSLATE_NOOP("pep8",
         "line too long ({0} > {1} characters)"),
     "E502": QT_TRANSLATE_NOOP("pep8",
         "the backslash is redundant between brackets"),
     "W601": QT_TRANSLATE_NOOP("pep8",
         ".has_key() is deprecated, use 'in'"),
     "W602": QT_TRANSLATE_NOOP("pep8",
         "deprecated form of raising exception"),
     "W603": QT_TRANSLATE_NOOP("pep8",
         "'<>' is deprecated, use '!='"),
     "W604": QT_TRANSLATE_NOOP("pep8",
         "backticks are deprecated, use 'repr()'"),
     "E701": QT_TRANSLATE_NOOP("pep8",
         "multiple statements on one line (colon)"),
     "E702": QT_TRANSLATE_NOOP("pep8",
         "multiple statements on one line (semicolon)"),
     "E703": QT_TRANSLATE_NOOP("pep8",
         "statement ends with a semicolon"),
     "E711": QT_TRANSLATE_NOOP("pep8",
         "comparison to {0} should be {1}"),
     "E712": QT_TRANSLATE_NOOP("pep8",
         "comparison to {0} should be {1}"),
     "E721": QT_TRANSLATE_NOOP("pep8",
         "do not compare types, use 'isinstance()'"),
     "E901": QT_TRANSLATE_NOOP("pep8",
         "{0}: {1}"),
 }
 pep8_messages_sample_args = {
     "E201": ["([{"],
     "E202": ["}])"],
     "E203": [",;:"],
     "E211": ["(["],
     "E231": [",;:"],
     "E241": [",;:"],
     "E242": [",;:"],
     "E302": [1],
     "E303": [3],
     "E501": [85, 79],
     "E711": ["None", "'if cond is None:'"],
     "E712": ["True", "'if cond is True:' or 'if cond:'"],
     "E901": ["SyntaxError", "Invalid Syntax"],
 }
 def getMessage(code, *args):
     """
     Function to get a translated and formatted message for a given code.
     @param code message code (string)
     @param args arguments for a formatted message (list)
     @return translated and formatted message (string)
     """
     if code in pep8_messages:
         return code + " " + QCoreApplication.translate("pep8",
             pep8_messages[code]).format(*args)
     else:
         return code + " " + QCoreApplication.translate("pep8",
             "no message for this code defined")
 ##############################################################################
 # Plugins (check functions) for physical lines
 ##############################################################################
 def tabs_or_spaces(physical_line, indent_char):
     r"""
     Never mix tabs and spaces.
     The most popular way of indenting Python is with spaces only.  The
     second-most popular way is with tabs only.  Code indented with a mixture
     of tabs and spaces should be converted to using spaces exclusively.  When
     invoking the Python command line interpreter with the -t option, it issues
     warnings about code that illegally mixes tabs and spaces.  When using -tt
     these warnings become errors.  These options are highly recommended!
     Okay: if a == 0:\n        a = 1\n        b = 1
     E101: if a == 0:\n        a = 1\n\tb = 1
     """
     indent = INDENT_REGEX.match(physical_line).group(1)
     for offset, char in enumerate(indent):
         if char != indent_char:
             return offset, "E101"
 def tabs_obsolete(physical_line):
     r"""
     For new projects, spaces-only are strongly recommended over tabs.  Most
     editors have features that make this easy to do.
     Okay: if True:\n    return
     W191: if True:\n\treturn
     """
     indent = INDENT_REGEX.match(physical_line).group(1)
     if '\t' in indent:
         return indent.index('\t'), "W191"
 def trailing_whitespace(physical_line):
     r"""
     JCR: Trailing whitespace is superfluous.
     FBM: Except when it occurs as part of a blank line (i.e. the line is
          nothing but whitespace). According to Python docs[1] a line with only
          whitespace is considered a blank line, and is to be ignored. However,
          matching a blank line to its indentation level avoids mistakenly
          terminating a multi-line statement (e.g. class declaration) when
          pasting code into the standard Python interpreter.
          [1] http://docs.python.org/reference/lexical_analysis.html#blank-lines
     The warning returned varies on whether the line itself is blank, for easier
     filtering for those who want to indent their blank lines.
     Okay: spam(1)\n#
     W291: spam(1) \n#
     W293: class Foo(object):\n    \n    bang = 12
     """
     physical_line = physical_line.rstrip('\n')    # chr(10), newline
     physical_line = physical_line.rstrip('\r')    # chr(13), carriage return
     physical_line = physical_line.rstrip('\x0c')  # chr(12), form feed, ^L
     stripped = physical_line.rstrip(' \t\v')
     if physical_line != stripped:
         if stripped:
             return len(stripped), "W291"
         else:
             return 0, "W293"
 def trailing_blank_lines(physical_line, lines, line_number):
     r"""
     JCR: Trailing blank lines are superfluous.
     Okay: spam(1)
     W391: spam(1)\n
     """
     if not physical_line.rstrip() and line_number == len(lines):
         return 0, "W391"
 def missing_newline(physical_line):
     """
     JCR: The last line should have a newline.
     Reports warning W292.
     """
     if physical_line.rstrip() == physical_line:
         return len(physical_line), "W292"
 def maximum_line_length(physical_line, max_line_length):
     """
     Limit all lines to a maximum of 79 characters.
     There are still many devices around that are limited to 80 character
     lines; plus, limiting windows to 80 characters makes it possible to have
     several windows side-by-side.  The default wrapping on such devices looks
     ugly.  Therefore, please limit all lines to a maximum of 79 characters.
     For flowing long blocks of text (docstrings or comments), limiting the
     length to 72 characters is recommended.
     Reports error E501.
     """
     line = physical_line.rstrip()
     length = len(line)
     if length > max_line_length and not noqa(line):
         if hasattr(line, 'decode'):   # Python 2
             # The line could contain multi-byte characters
             try:
                 length = len(line.decode('utf-8'))
             except UnicodeError:
                 pass
         if length > max_line_length:
             return max_line_length, "E501", length, max_line_length
 ##############################################################################
 # Plugins (check functions) for logical lines
 ##############################################################################
 def blank_lines(logical_line, blank_lines, indent_level, line_number,
                 previous_logical, previous_indent_level):
     r"""
     Separate top-level function and class definitions with two blank lines.
     Method definitions inside a class are separated by a single blank line.
     Extra blank lines may be used (sparingly) to separate groups of related
     functions.  Blank lines may be omitted between a bunch of related
     one-liners (e.g. a set of dummy implementations).
     Use blank lines in functions, sparingly, to indicate logical sections.
     Okay: def a():\n    pass\n\n\ndef b():\n    pass
     Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
     E301: class Foo:\n    b = 0\n    def bar():\n        pass
     E302: def a():\n    pass\n\ndef b(n):\n    pass
     E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass
     E303: def a():\n\n\n\n    pass
     E304: @decorator\n\ndef a():\n    pass
     """
     if line_number < 3 and not previous_logical:
         return  # Don't expect blank lines before the first line
     if previous_logical.startswith('@'):
         if blank_lines:
             yield 0, "E304"
     elif blank_lines > 2 or (indent_level and blank_lines == 2):
         yield 0, "E303", blank_lines
     elif logical_line.startswith(('def ', 'class ', '@')):
         if indent_level:
             if not (blank_lines or previous_indent_level < indent_level or
                     DOCSTRING_REGEX.match(previous_logical)):
                 yield 0, "E301"
         elif blank_lines != 2:
             yield 0, "E302", blank_lines
 def extraneous_whitespace(logical_line):
     """
     Avoid extraneous whitespace in the following situations:
     - Immediately inside parentheses, brackets or braces.
     - Immediately before a comma, semicolon, or colon.
     Okay: spam(ham[1], {eggs: 2})
     E201: spam( ham[1], {eggs: 2})
     E201: spam(ham[ 1], {eggs: 2})
     E201: spam(ham[1], { eggs: 2})
     E202: spam(ham[1], {eggs: 2} )
     E202: spam(ham[1 ], {eggs: 2})
     E202: spam(ham[1], {eggs: 2 })
     E203: if x == 4: print x, y; x, y = y , x
     E203: if x == 4: print x, y ; x, y = y, x
     E203: if x == 4 : print x, y; x, y = y, x
     """
     line = logical_line
     for match in EXTRANEOUS_WHITESPACE_REGEX.finditer(line):
         text = match.group()
         char = text.strip()
         found = match.start()
         if text == char + ' ':
             # assert char in '([{'
             yield found + 1, "E201", char
         elif line[found - 1] != ',':
             code = ('E202' if char in '}])' else 'E203')  # if char in ',;:'
             yield found, code, char
 def whitespace_around_keywords(logical_line):
     r"""
     Avoid extraneous whitespace around keywords.
     Okay: True and False
     E271: True and  False
     E272: True  and False
     E273: True and\tFalse
     E274: True\tand False
     """
     for match in KEYWORD_REGEX.finditer(logical_line):
         before, after = match.groups()
         if '\t' in before:
             yield match.start(1), "E274"
         elif len(before) > 1:
             yield match.start(1), "E272"
         if '\t' in after:
             yield match.start(2), "E273"
         elif len(after) > 1:
             yield match.start(2), "E271"
 def missing_whitespace(logical_line):
     """
     JCR: Each comma, semicolon or colon should be followed by whitespace.
     Okay: [a, b]
     Okay: (3,)
     Okay: a[1:4]
     Okay: a[:4]
     Okay: a[1:]
     Okay: a[1:4:2]
     E231: ['a','b']
     E231: foo(bar,baz)
     E231: [{'a':'b'}]
     """
     line = logical_line
     for index in range(len(line) - 1):
         char = line[index]
         if char in ',;:' and line[index + 1] not in WHITESPACE:
             before = line[:index]
             if char == ':' and before.count('[') > before.count(']') and \
                     before.rfind('{') < before.rfind('['):
                 continue  # Slice syntax, no space required
             if char == ',' and line[index + 1] == ')':
                 continue  # Allow tuple with only one element: (3,)
             yield index, "E231", char
 def indentation(logical_line, previous_logical, indent_char,
                 indent_level, previous_indent_level):
     r"""
     Use 4 spaces per indentation level.
     For really old code that you don't want to mess up, you can continue to
     use 8-space tabs.
     Okay: a = 1
     Okay: if a == 0:\n    a = 1
     E111:   a = 1
     Okay: for item in items:\n    pass
     E112: for item in items:\npass
     Okay: a = 1\nb = 2
     E113: a = 1\n    b = 2
     """
     if indent_char == ' ' and indent_level % 4:
         yield 0, "E111"
     indent_expect = previous_logical.endswith(':')
     if indent_expect and indent_level <= previous_indent_level:
         yield 0, "E112"
     if indent_level > previous_indent_level and not indent_expect:
         yield 0, "E113"
 def continued_indentation(logical_line, tokens, indent_level, hang_closing,
                           noqa, verbose):
     r"""
     Continuation lines should align wrapped elements either vertically using
     Python's implicit line joining inside parentheses, brackets and braces, or
     using a hanging indent.
     When using a hanging indent the following considerations should be applied:
     - there should be no arguments on the first line, and
     - further indentation should be used to clearly distinguish itself as a
       continuation line.
     Okay: a = (\n)
     E123: a = (\n    )
     Okay: a = (\n    42)
     E121: a = (\n   42)
     E122: a = (\n42)
     E123: a = (\n    42\n    )
     E124: a = (24,\n     42\n)
     E125: if (a or\n    b):\n    pass
     E126: a = (\n        42)
     E127: a = (24,\n      42)
     E128: a = (24,\n    42)
     """
     first_row = tokens[0][2][0]
     nrows = 1 + tokens[-1][2][0] - first_row
     if noqa or nrows == 1:
         return
     # indent_next tells us whether the next block is indented; assuming
     # that it is indented by 4 spaces, then we should not allow 4-space
     # indents on the final continuation line; in turn, some other
     # indents are allowed to have an extra 4 spaces.
     indent_next = logical_line.endswith(':')
     row = depth = 0
     # remember how many brackets were opened on each line
     parens = [0] * nrows
     # relative indents of physical lines
     rel_indent = [0] * nrows
     # visual indents
     indent_chances = {}
     last_indent = tokens[0][2]
     indent = [last_indent[1]]
     if verbose >= 3:
         print(">>> " + tokens[0][4].rstrip())
     for token_type, text, start, end, line in tokens:
         last_token_multiline = (start[0] != end[0])
         newline = row < start[0] - first_row
         if newline:
             row = start[0] - first_row
             newline = (not last_token_multiline and
                        token_type not in (tokenize.NL, tokenize.NEWLINE))
         if newline:
             # this is the beginning of a continuation line.
             last_indent = start
             if verbose >= 3:
                 print("... " + line.rstrip())
             # record the initial indent.
             rel_indent[row] = expand_indent(line) - indent_level
             if depth:
                 # a bracket expression in a continuation line.
                 # find the line that it was opened on
                 for open_row in range(row - 1, -1, -1):
                     if parens[open_row]:
                         break
             else:
                 # an unbracketed continuation line (ie, backslash)
                 open_row = 0
             hang = rel_indent[row] - rel_indent[open_row]
             close_bracket = (token_type == tokenize.OP and text in ']})')
             visual_indent = (not close_bracket and hang > 0 and
                              indent_chances.get(start[1]))
             if close_bracket and indent[depth]:
                 # closing bracket for visual indent
                 if start[1] != indent[depth]:
                     yield start, "E124"
             elif close_bracket and not hang:
                 # closing bracket matches indentation of opening bracket's line
                 if hang_closing:
                     yield start, "E133"
             elif visual_indent is True:
                 # visual indent is verified
                 if not indent[depth]:
                     indent[depth] = start[1]
             elif visual_indent in (text, str):
                 # ignore token lined up with matching one from a previous line
                 pass
             elif indent[depth] and start[1] < indent[depth]:
                 # visual indent is broken
                 yield start, "E128"
             elif hang == 4 or (indent_next and rel_indent[row] == 8):
                 # hanging indent is verified
                 if close_bracket and not hang_closing:
                     yield (start, "E123")
             else:
                 # indent is broken
                 if hang <= 0:
                     error = "E122"
                 elif indent[depth]:
                     error = "E127"
                 elif hang % 4:
                     error = "E121"
                 else:
                     error = "E126"
                 yield start, error
         # look for visual indenting
         if (parens[row] and token_type not in (tokenize.NL, tokenize.COMMENT)
                 and not indent[depth]):
             indent[depth] = start[1]
             indent_chances[start[1]] = True
             if verbose >= 4:
                 print("bracket depth %s indent to %s" % (depth, start[1]))
         # deal with implicit string concatenation
         elif (token_type in (tokenize.STRING, tokenize.COMMENT) or
               text in ('u', 'ur', 'b', 'br')):
             indent_chances[start[1]] = str
         # special case for the "if" statement because len("if (") == 4
         elif not indent_chances and not row and not depth and text == 'if':
             indent_chances[end[1] + 1] = True
         # keep track of bracket depth
         if token_type == tokenize.OP:
             if text in '([{':
                 depth += 1
                 indent.append(0)
                 parens[row] += 1
                 if verbose >= 4:
                     print("bracket depth %s seen, col %s, visual min = %s" %
                           (depth, start[1], indent[depth]))
             elif text in ')]}' and depth > 0:
                 # parent indents should not be more than this one
                 prev_indent = indent.pop() or last_indent[1]
                 for d in range(depth):
                     if indent[d] > prev_indent:
                         indent[d] = 0
                 for ind in list(indent_chances):
                     if ind >= prev_indent:
                         del indent_chances[ind]
                 depth -= 1
                 if depth:
                     indent_chances[indent[depth]] = True
                 for idx in range(row, -1, -1):
                     if parens[idx]:
                         parens[idx] -= 1
                         rel_indent[row] = rel_indent[idx]
                         break
             assert len(indent) == depth + 1
             if start[1] not in indent_chances:
                 # allow to line up tokens
                 indent_chances[start[1]] = text
     if indent_next and expand_indent(line) == indent_level + 4:
         yield last_indent, "E125"
 def whitespace_before_parameters(logical_line, tokens):
     """
     Avoid extraneous whitespace in the following situations:
     - Immediately before the open parenthesis that starts the argument
       list of a function call.
     - Immediately before the open parenthesis that starts an indexing or
       slicing.
     Okay: spam(1)
     E211: spam (1)
     Okay: dict['key'] = list[index]
     E211: dict ['key'] = list[index]
     E211: dict['key'] = list [index]
     """
     prev_type, prev_text, __, prev_end, __ = tokens[0]
     for index in range(1, len(tokens)):
         token_type, text, start, end, __ = tokens[index]
         if (token_type == tokenize.OP and
             text in '([' and
             start != prev_end and
             (prev_type == tokenize.NAME or prev_text in '}])') and
             # Syntax "class A (B):" is allowed, but avoid it
             (index < 2 or tokens[index - 2][1] != 'class') and
                 # Allow "return (a.foo for a in range(5))"
                 not keyword.iskeyword(prev_text)):
             yield prev_end, "E211", text
         prev_type = token_type
         prev_text = text
         prev_end = end
 def whitespace_around_operator(logical_line):
     """
     Avoid extraneous whitespace in the following situations:
     - More than one space around an assignment (or other) operator to
       align it with another.
     Okay: a = 12 + 3
     E221: a = 4  + 5
     E222: a = 4 +  5
     E223: a = 4\t+ 5
     E224: a = 4 +\t5
     """
     for match in OPERATOR_REGEX.finditer(logical_line):
         before, after = match.groups()
         if '\t' in before:
             yield match.start(1), "E223"
         elif len(before) > 1:
             yield match.start(1), "E221"
         if '\t' in after:
             yield match.start(2), "E224"
         elif len(after) > 1:
             yield match.start(2), "E222"
 def missing_whitespace_around_operator(logical_line, tokens):
     r"""
     - Always surround these binary operators with a single space on
       either side: assignment (=), augmented assignment (+=, -= etc.),
       comparisons (==, <, >, !=, <>, <=, >=, in, not in, is, is not),
       Booleans (and, or, not).
     - Use spaces around arithmetic operators.
     Okay: i = i + 1
     Okay: submitted += 1
     Okay: x = x * 2 - 1
     Okay: hypot2 = x * x + y * y
     Okay: c = (a + b) * (a - b)
     Okay: foo(bar, key='word', *args, **kwargs)
     Okay: alpha[:-i]
     E225: i=i+1
     E225: submitted +=1
     E225: x = x /2 - 1
     E225: z = x **y
     E226: c = (a+b) * (a-b)
     E226: hypot2 = x*x + y*y
     E227: c = a|b
     E228: msg = fmt%(errno, errmsg)
     """
     parens = 0
     need_space = False
     prev_type = tokenize.OP
     prev_text = prev_end = None
     for token_type, text, start, end, line in tokens:
         if token_type in (tokenize.NL, tokenize.NEWLINE, tokenize.ERRORTOKEN):
             # ERRORTOKEN is triggered by backticks in Python 3
             continue
         if text in ('(', 'lambda'):
             parens += 1
         elif text == ')':
             parens -= 1
         if need_space:
             if start != prev_end:
                 # Found a (probably) needed space
                 if need_space is not True and not need_space[1]:
                     yield need_space[0], "E225"
                 need_space = False
             elif text == '>' and prev_text in ('<', '-'):
                 # Tolerate the "<>" operator, even if running Python 3
                 # Deal with Python 3's annotated return value "->"
                 pass
             else:
                 if need_space is True or need_space[1]:
                     # A needed trailing space was not found
                     yield prev_end, "E225"
                 else:
                     code = 'E226'
                     if prev_text == '%':
                         code = 'E228'
                     elif prev_text not in ARITHMETIC_OP:
                         code = 'E227'
                     yield need_space[0], code
                 need_space = False
         elif token_type == tokenize.OP and prev_end is not None:
             if text == '=' and parens:
                 # Allow keyword args or defaults: foo(bar=None).
                 pass
             elif text in WS_NEEDED_OPERATORS:
                 need_space = True
             elif text in UNARY_OPERATORS:
                 # Check if the operator is being used as a binary operator
                 # Allow unary operators: -123, -x, +1.
                 # Allow argument unpacking: foo(*args, **kwargs).
                 if prev_type == tokenize.OP:
                     binary_usage = (prev_text in '}])')
                 elif prev_type == tokenize.NAME:
                     binary_usage = (prev_text not in KEYWORDS)
                 else:
                     binary_usage = (prev_type not in SKIP_TOKENS)
                 if binary_usage:
                     need_space = None
             elif text in WS_OPTIONAL_OPERATORS:
                 need_space = None
             if need_space is None:
                 # Surrounding space is optional, but ensure that
                 # trailing space matches opening space
                 need_space = (prev_end, start != prev_end)
             elif need_space and start == prev_end:
                 # A needed opening space was not found
                 yield prev_end, "E225"
                 need_space = False
         prev_type = token_type
         prev_text = text
         prev_end = end
 def whitespace_around_comma(logical_line):
     """
     Avoid extraneous whitespace in the following situations:
     - More than one space around an assignment (or other) operator to
       align it with another.
     JCR: This should also be applied around comma etc.
     Note: these checks are disabled by default
     Okay: a = (1, 2)
     E241: a = (1,  2)
     E242: a = (1,\t2)
     """
     line = logical_line
     for m in WHITESPACE_AFTER_COMMA_REGEX.finditer(line):
         found = m.start() + 1
         if '\t' in m.group():
             yield found, "E242", m.group()[0]
         else:
             yield found, "E241", m.group()[0]
 def whitespace_around_named_parameter_equals(logical_line, tokens):
     """
     Don't use spaces around the '=' sign when used to indicate a
     keyword argument or a default parameter value.
     Okay: def complex(real, imag=0.0):
     Okay: return magic(r=real, i=imag)
     Okay: boolean(a == b)
     Okay: boolean(a != b)
     Okay: boolean(a <= b)
     Okay: boolean(a >= b)
     E251: def complex(real, imag = 0.0):
     E251: return magic(r = real, i = imag)
     """
     parens = 0
     no_space = False
     prev_end = None
     message = "E251"
     for token_type, text, start, end, line in tokens:
         if no_space:
             no_space = False
             if start != prev_end:
                 yield prev_end, message
         elif token_type == tokenize.OP:
             if text == '(':
                 parens += 1
             elif text == ')':
                 parens -= 1
             elif parens and text == '=':
                 no_space = True
                 if start != prev_end:
                     yield prev_end, message
         prev_end = end
 def whitespace_before_inline_comment(logical_line, tokens):
     """
     Separate inline comments by at least two spaces.
     An inline comment is a comment on the same line as a statement.  Inline
     comments should be separated by at least two spaces from the statement.
     They should start with a # and a single space.
     Okay: x = x + 1  # Increment x
     Okay: x = x + 1    # Increment x
     E261: x = x + 1 # Increment x
     E262: x = x + 1  #Increment x
     E262: x = x + 1  #  Increment x
     """
     prev_end = (0, 0)
     for token_type, text, start, end, line in tokens:
         if token_type == tokenize.COMMENT:
             if not line[:start[1]].strip():
                 continue
             if prev_end[0] == start[0] and start[1] < prev_end[1] + 2:
                 yield prev_end, "E261"
             symbol, sp, comment = text.partition(' ')
             if symbol not in ('#', '#:') or comment[:1].isspace():
                 yield start, "E262"
         elif token_type != tokenize.NL:
             prev_end = end
 def imports_on_separate_lines(logical_line):
     r"""
     Imports should usually be on separate lines.
     Okay: import os\nimport sys
     E401: import sys, os
     Okay: from subprocess import Popen, PIPE
     Okay: from myclas import MyClass
     Okay: from foo.bar.yourclass import YourClass
     Okay: import myclass
     Okay: import foo.bar.yourclass
     """
     line = logical_line
     if line.startswith('import '):
         found = line.find(',')
         if -1 < found and ';' not in line[:found]:
             yield found, "E401"
 def compound_statements(logical_line):
     r"""
     Compound statements (multiple statements on the same line) are
     generally discouraged.
     While sometimes it's okay to put an if/for/while with a small body
     on the same line, never do this for multi-clause statements. Also
     avoid folding such long lines!
     Okay: if foo == 'blah':\n    do_blah_thing()
     Okay: do_one()
     Okay: do_two()
     Okay: do_three()
     E701: if foo == 'blah': do_blah_thing()
     E701: for x in lst: total += x
     E701: while t < 10: t = delay()
     E701: if foo == 'blah': do_blah_thing()
     E701: else: do_non_blah_thing()
     E701: try: something()
     E701: finally: cleanup()
     E701: if foo == 'blah': one(); two(); three()
     E702: do_one(); do_two(); do_three()
     E703: do_four();  # useless semicolon
     """
     line = logical_line
     last_char = len(line) - 1
     found = line.find(':')
     while -1 < found < last_char:
         before = line[:found]
         if (before.count('{') <= before.count('}') and  # {'a': 1} (dict)
             before.count('[') <= before.count(']') and  # [1:2] (slice)
             before.count('(') <= before.count(')') and  # (Python 3 annotation)
                 not LAMBDA_REGEX.search(before)):       # lambda x: x
             yield found, "E701"
         found = line.find(':', found + 1)
     found = line.find(';')
     while -1 < found:
         if found < last_char:
             yield found, "E702"
         else:
             yield found, "E703"
         found = line.find(';', found + 1)
 def explicit_line_join(logical_line, tokens):
     r"""
     Avoid explicit line join between brackets.
     The preferred way of wrapping long lines is by using Python's implied line
     continuation inside parentheses, brackets and braces.  Long lines can be
     broken over multiple lines by wrapping expressions in parentheses.  These
     should be used in preference to using a backslash for line continuation.
     E502: aaa = [123, \\n       123]
     E502: aaa = ("bbb " \\n       "ccc")
     Okay: aaa = [123,\n       123]
     Okay: aaa = ("bbb "\n       "ccc")
     Okay: aaa = "bbb " \\n    "ccc"
     """
     prev_start = prev_end = parens = 0
     backslash = None
     for token_type, text, start, end, line in tokens:
         if start[0] != prev_start and parens and backslash:
             yield backslash, "E502"
         if end[0] != prev_end:
             if line.rstrip('\r\n').endswith('\\'):
                 backslash = (end[0], len(line.splitlines()[-1]) - 1)
             else:
                 backslash = None
             prev_start = prev_end = end[0]
         else:
             prev_start = start[0]
         if token_type == tokenize.OP:
             if text in '([{':
                 parens += 1
             elif text in ')]}':
                 parens -= 1
 def comparison_to_singleton(logical_line, noqa):
     """
     Comparisons to singletons like None should always be done
     with "is" or "is not", never the equality operators.
     Okay: if arg is not None:
     E711: if arg != None:
     E712: if arg == True:
     Also, beware of writing if x when you really mean if x is not None --
     e.g. when testing whether a variable or argument that defaults to None was
     set to some other value.  The other value might have a type (such as a
     container) that could be false in a boolean context!
     """
     match = not noqa and COMPARE_SINGLETON_REGEX.search(logical_line)
     if match:
         same = (match.group(1) == '==')
         singleton = match.group(2)
         msg = "'if cond is %s:'" % (('' if same else 'not ') + singleton)
         if singleton in ('None',):
             code = 'E711'
         else:
             code = 'E712'
             nonzero = ((singleton == 'True' and same) or
                        (singleton == 'False' and not same))
             msg += " or 'if %scond:'" % ('' if nonzero else 'not ')
         yield match.start(1), code, singleton, msg
 def comparison_type(logical_line):
     """
     Object type comparisons should always use isinstance() instead of
     comparing types directly.
     Okay: if isinstance(obj, int):
     E721: if type(obj) is type(1):
     When checking if an object is a string, keep in mind that it might be a
 a1448560d7dc
Started upgrading the pep8 checker to the latest release.

Detlev Offenbach <detlev@die-offenbachs.de>
parents: 
2861
diff
c

Mercurial Repositories > eric / annotate

Plugins/CheckerPlugins/Pep8/pep8.py@62171fa4a6a4 (annotated)

Plugins/CheckerPlugins/Pep8/pep8.py