(original) (raw)

https://hg.python.org/cpython/rev/9aedec2dbc01
changeset: 100818:9aedec2dbc01
user: Victor Stinner <victor.stinner@gmail.com>
date: Thu Mar 31 23:30:53 2016 +0200
summary:
Python 8: no pep8, no chocolate!

files:
Include/patchlevel.h | 6 +-
Lib/pep8.py | 2151 ++++++++++++++++++++++++++++++
Lib/site.py | 56 +
3 files changed, 2210 insertions(+), 3 deletions(-)


diff --git a/Include/patchlevel.h b/Include/patchlevel.h
\--- a/Include/patchlevel.h
+++ b/Include/patchlevel.h
@@ -16,14 +16,14 @@

/\* Version parsed out into numeric values \*/
/\*--start constants--\*/
\-#define PY\_MAJOR\_VERSION 3
\-#define PY\_MINOR\_VERSION 6
+#define PY\_MAJOR\_VERSION 8
+#define PY\_MINOR\_VERSION 0
#define PY\_MICRO\_VERSION 0
#define PY\_RELEASE\_LEVEL PY\_RELEASE\_LEVEL\_ALPHA
#define PY\_RELEASE\_SERIAL 0

/\* Version as a string \*/
\-#define PY\_VERSION "3.6.0a0"
+#define PY\_VERSION "8.0.0a0"
/\*--end constants--\*/

/\* Version as a single 4-byte hex number, e.g. 0x010502B2 == 1.5.2b2.
diff --git a/Lib/pep8.py b/Lib/pep8.py
new file mode 100644
\--- /dev/null
+++ b/Lib/pep8.py
@@ -0,0 +1,2151 @@
+#!/usr/bin/env python
+# pep8.py - Check Python source code formatting, according to PEP 8
+# Copyright (C) 2006-2009 Johann C. Rocholl <johann@rocholl.net>
+# Copyright (C) 2009-2014 Florent Xicluna <florent.xicluna@gmail.com>
+# Copyright (C) 2014-2016 Ian Lee <ianlee1521@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.
+
+r"""
+Check Python source code formatting, according to PEP 8.
+
+For usage and a list of options, try this:
+$ python pep8.py -h
+
+This program and its regression test suite live here:
+https://github.com/pycqa/pep8
+
+Groups of errors and warnings:
+E errors
+W warnings
+100 indentation
+200 whitespace
+300 blank lines
+400 imports
+500 line length
+600 deprecation
+700 statements
+900 syntax error
+"""
+from \_\_future\_\_ import with\_statement
+
+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
+
+\_\_version\_\_ = '1.7.0'
+
+DEFAULT\_EXCLUDE = '.svn,CVS,.bzr,.hg,.git,\_\_pycache\_\_,.tox'
+DEFAULT\_IGNORE = 'E121,E123,E126,E226,E24,E704'
+try:
\+ if sys.platform == 'win32':
\+ USER\_CONFIG = os.path.expanduser(r'\~\\.pep8')
\+ else:
\+ USER\_CONFIG = os.path.join(
\+ os.getenv('XDG\_CONFIG\_HOME') or os.path.expanduser('\~/.config'),
\+ 'pep8'
\+ )
+except ImportError:
\+ USER\_CONFIG = None
+
+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')
+NEWLINE = frozenset(\[tokenize.NL, tokenize.NEWLINE\])
+SKIP\_TOKENS = NEWLINE.union(\[tokenize.INDENT, tokenize.DEDENT\])
+# ERRORTOKEN is triggered by backticks in Python 3
+SKIP\_COMMENTS = SKIP\_TOKENS.union(\[tokenize.COMMENT, tokenize.ERRORTOKEN\])
+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\*$')
+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'(\\bNone|\\bFalse|\\bTrue)?\\s\*(\[=!\]=)'
\+ r'\\s\*(?(1)|(None|False|True))\\b')
+COMPARE\_NEGATIVE\_REGEX = re.compile(r'\\b(not)\\s+\[^\]\[)(}{ \]+\\s+(in|is)\\s')
+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'
+
+
+##############################################################################
+# 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 indentation contains mixed spaces and tabs"
+
+
+def tabs\_obsolete(physical\_line):
\+ r"""For new projects, spaces-only are strongly recommended over tabs.
+
\+ 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 indentation contains tabs"
+
+
+def trailing\_whitespace(physical\_line):
\+ r"""Trailing whitespace is superfluous.
+
\+ 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 trailing whitespace"
\+ else:
\+ return 0, "W293 blank line contains whitespace"
+
+
+def trailing\_blank\_lines(physical\_line, lines, line\_number, total\_lines):
\+ r"""Trailing blank lines are superfluous.
+
\+ Okay: spam(1)
\+ W391: spam(1)\\n
+
\+ However the last line should end with a new line (warning W292).
\+ """
\+ if line\_number == total\_lines:
\+ stripped\_last\_line = physical\_line.rstrip()
\+ if not stripped\_last\_line:
\+ return 0, "W391 blank line at end of file"
\+ if stripped\_last\_line == physical\_line:
\+ return len(physical\_line), "W292 no newline at end of file"
+
+
+def maximum\_line\_length(physical\_line, max\_line\_length, multiline):
\+ r"""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):
\+ # Special case for long URLs in multi-line docstrings or comments,
\+ # but still report the error when the 72 first chars are whitespaces.
\+ chunks = line.split()
\+ if ((len(chunks) == 1 and multiline) or
\+ (len(chunks) == 2 and chunks\[0\] == '#')) and \\
\+ len(line) - len(chunks\[-1\]) < max\_line\_length - 7:
\+ return
\+ 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 line too long "
\+ "(%d > %d characters)" % (length, max\_line\_length))
+
+
+##############################################################################
+# Plugins (check functions) for logical lines
+##############################################################################
+
+
+def blank\_lines(logical\_line, blank\_lines, indent\_level, line\_number,
\+ blank\_before, 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 blank lines found after function decorator"
\+ elif blank\_lines > 2 or (indent\_level and blank\_lines == 2):
\+ yield 0, "E303 too many blank lines (%d)" % blank\_lines
\+ elif logical\_line.startswith(('def ', 'class ', '@')):
\+ if indent\_level:
\+ if not (blank\_before or previous\_indent\_level < indent\_level or
\+ DOCSTRING\_REGEX.match(previous\_logical)):
\+ yield 0, "E301 expected 1 blank line, found 0"
\+ elif blank\_before != 2:
\+ yield 0, "E302 expected 2 blank lines, found %d" % blank\_before
+
+
+def extraneous\_whitespace(logical\_line):
\+ r"""Avoid extraneous whitespace.
+
\+ Avoid extraneous whitespace in these 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 whitespace after '%s'" % char
\+ elif line\[found - 1\] != ',':
\+ code = ('E202' if char in '}\])' else 'E203') # if char in ',;:'
\+ yield found, "%s whitespace before '%s'" % (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 tab before keyword"
\+ elif len(before) > 1:
\+ yield match.start(1), "E272 multiple spaces before keyword"
+
\+ if '\\t' in after:
\+ yield match.start(2), "E273 tab after keyword"
\+ elif len(after) > 1:
\+ yield match.start(2), "E271 multiple spaces after keyword"
+
+
+def missing\_whitespace(logical\_line):
\+ r"""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 missing whitespace after '%s'" % 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
\+ E114: # a = 1
+
\+ Okay: for item in items:\\n pass
\+ E112: for item in items:\\npass
\+ E115: for item in items:\\n# Hi\\n pass
+
\+ Okay: a = 1\\nb = 2
\+ E113: a = 1\\n b = 2
\+ E116: a = 1\\n # b = 2
\+ """
\+ c = 0 if logical\_line else 3
\+ tmpl = "E11%d %s" if logical\_line else "E11%d %s (comment)"
\+ if indent\_level % 4:
\+ yield 0, tmpl % (1 + c, "indentation is not a multiple of four")
\+ indent\_expect = previous\_logical.endswith(':')
\+ if indent\_expect and indent\_level <= previous\_indent\_level:
\+ yield 0, tmpl % (2 + c, "expected an indented block")
\+ elif not indent\_expect and indent\_level > previous\_indent\_level:
\+ yield 0, tmpl % (3 + c, "unexpected indentation")
+
+
+def continued\_indentation(logical\_line, tokens, indent\_level, hang\_closing,
\+ indent\_char, noqa, verbose):
\+ r"""Continuation lines indentation.
+
\+ 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 these 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 (\\n b):\\n pass
\+ E126: a = (\\n 42)
\+ E127: a = (24,\\n 42)
\+ E128: a = (24,\\n 42)
\+ E129: if (a or\\n b):\\n pass
\+ E131: a = (\\n 42\\n 24)
\+ """
\+ 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
\+ valid\_hangs = (4,) if indent\_char != '\\t' else (4, 8)
\+ # remember how many brackets were opened on each line
\+ parens = \[0\] \* nrows
\+ # relative indents of physical lines
\+ rel\_indent = \[0\] \* nrows
\+ # for each depth, collect a list of opening rows
\+ open\_rows = \[\[0\]\]
\+ # for each depth, memorize the hanging indentation
\+ hangs = \[None\]
\+ # visual indents
\+ indent\_chances = {}
\+ last\_indent = tokens\[0\]\[2\]
\+ visual\_indent = None
\+ last\_token\_multiline = False
\+ # for each depth, memorize the visual indent column
\+ indent = \[last\_indent\[1\]\]
\+ if verbose >= 3:
\+ print(">>> " + tokens\[0\]\[4\].rstrip())
+
\+ for token\_type, text, start, end, line in tokens:
+
\+ newline = row < start\[0\] - first\_row
\+ if newline:
\+ row = start\[0\] - first\_row
\+ newline = not last\_token\_multiline and token\_type not in 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
+
\+ # identify closing bracket
\+ close\_bracket = (token\_type == tokenize.OP and text in '\]})')
+
\+ # is the indent relative to an opening bracket line?
\+ for open\_row in reversed(open\_rows\[depth\]):
\+ hang = rel\_indent\[row\] - rel\_indent\[open\_row\]
\+ hanging\_indent = hang in valid\_hangs
\+ if hanging\_indent:
\+ break
\+ if hangs\[depth\]:
\+ hanging\_indent = (hang == hangs\[depth\])
\+ # is there any chance of visual indent?
\+ 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 closing bracket does not match "
\+ "visual indentation")
\+ elif close\_bracket and not hang:
\+ # closing bracket matches indentation of opening bracket's line
\+ if hang\_closing:
\+ yield start, "E133 closing bracket is missing indentation"
\+ elif indent\[depth\] and start\[1\] < indent\[depth\]:
\+ if visual\_indent is not True:
\+ # visual indent is broken
\+ yield (start, "E128 continuation line "
\+ "under-indented for visual indent")
\+ elif hanging\_indent or (indent\_next and rel\_indent\[row\] == 8):
\+ # hanging indent is verified
\+ if close\_bracket and not hang\_closing:
\+ yield (start, "E123 closing bracket does not match "
\+ "indentation of opening bracket's line")
\+ hangs\[depth\] = hang
\+ elif visual\_indent is True:
\+ # visual indent is verified
\+ indent\[depth\] = start\[1\]
\+ elif visual\_indent in (text, str):
\+ # ignore token lined up with matching one from a previous line
\+ pass
\+ else:
\+ # indent is broken
\+ if hang <= 0:
\+ error = "E122", "missing indentation or outdented"
\+ elif indent\[depth\]:
\+ error = "E127", "over-indented for visual indent"
\+ elif not close\_bracket and hangs\[depth\]:
\+ error = "E131", "unaligned for hanging indent"
\+ else:
\+ hangs\[depth\] = hang
\+ if hang > 4:
\+ error = "E126", "over-indented for hanging indent"
\+ else:
\+ error = "E121", "under-indented for hanging indent"
\+ yield start, "%s continuation line %s" % 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
\+ elif text == ':' and line\[end\[1\]:\].isspace():
\+ open\_rows\[depth\].append(row)
+
\+ # keep track of bracket depth
\+ if token\_type == tokenize.OP:
\+ if text in '(\[{':
\+ depth += 1
\+ indent.append(0)
\+ hangs.append(None)
\+ if len(open\_rows) == depth:
\+ open\_rows.append(\[\])
\+ open\_rows\[depth\].append(row)
\+ 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\]
\+ hangs.pop()
\+ 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\]
\+ del open\_rows\[depth + 1:\]
\+ depth -= 1
\+ if depth:
\+ indent\_chances\[indent\[depth\]\] = True
\+ for idx in range(row, -1, -1):
\+ if parens\[idx\]:
\+ parens\[idx\] -= 1
\+ break
\+ assert len(indent) == depth + 1
\+ if start\[1\] not in indent\_chances:
\+ # allow to line up tokens
\+ indent\_chances\[start\[1\]\] = text
+
\+ last\_token\_multiline = (start\[0\] != end\[0\])
\+ if last\_token\_multiline:
\+ rel\_indent\[end\[0\] - first\_row\] = rel\_indent\[row\]
+
\+ if indent\_next and expand\_indent(line) == indent\_level + 4:
\+ pos = (start\[0\], indent\[0\] + 4)
\+ if visual\_indent:
\+ code = "E129 visually indented line"
\+ else:
\+ code = "E125 continuation line"
\+ yield pos, "%s with same indent as next logical line" % code
+
+
+def whitespace\_before\_parameters(logical\_line, tokens):
\+ r"""Avoid extraneous whitespace.
+
\+ Avoid extraneous whitespace in the following situations:
\+ - before the open parenthesis that starts the argument list of a
\+ function call.
\+ - 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 whitespace before '%s'" % text
\+ prev\_type = token\_type
\+ prev\_text = text
\+ prev\_end = end
+
+
+def whitespace\_around\_operator(logical\_line):
\+ r"""Avoid extraneous whitespace around an operator.
+
\+ 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 tab before operator"
\+ elif len(before) > 1:
\+ yield match.start(1), "E221 multiple spaces before operator"
+
\+ if '\\t' in after:
\+ yield match.start(2), "E224 tab after operator"
\+ elif len(after) > 1:
\+ yield match.start(2), "E222 multiple spaces after operator"
+
+
+def missing\_whitespace\_around\_operator(logical\_line, tokens):
\+ r"""Surround operators with a single space on either side.
+
\+ - 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).
+
\+ - If operators with different priorities are used, consider adding
\+ whitespace around the operators with the lowest priorities.
+
\+ 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 SKIP\_COMMENTS:
\+ 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 missing whitespace around operator")
\+ 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 missing whitespace around operator"
\+ elif prev\_text != '\*\*':
\+ code, optype = 'E226', 'arithmetic'
\+ if prev\_text == '%':
\+ code, optype = 'E228', 'modulo'
\+ elif prev\_text not in ARITHMETIC\_OP:
\+ code, optype = 'E227', 'bitwise or shift'
\+ yield (need\_space\[0\], "%s missing whitespace "
\+ "around %s operator" % (code, optype))
\+ 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\_text in '}\])' if prev\_type == tokenize.OP
\+ else prev\_text not in KEYWORDS):
\+ 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 missing whitespace around operator"
\+ need\_space = False
\+ prev\_type = token\_type
\+ prev\_text = text
\+ prev\_end = end
+
+
+def whitespace\_around\_comma(logical\_line):
\+ r"""Avoid extraneous whitespace after a comma or a colon.
+
\+ 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 tab after '%s'" % m.group()\[0\]
\+ else:
\+ yield found, "E241 multiple spaces after '%s'" % m.group()\[0\]
+
+
+def whitespace\_around\_named\_parameter\_equals(logical\_line, tokens):
\+ r"""Don't use spaces around the '=' sign in function arguments.
+
\+ 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)
\+ Okay: def foo(arg: int = 42):
+
\+ E251: def complex(real, imag = 0.0):
\+ E251: return magic(r = real, i = imag)
\+ """
\+ parens = 0
\+ no\_space = False
\+ prev\_end = None
\+ annotated\_func\_arg = False
\+ in\_def = logical\_line.startswith('def')
\+ message = "E251 unexpected spaces around keyword / parameter equals"
\+ for token\_type, text, start, end, line in tokens:
\+ if token\_type == tokenize.NL:
\+ continue
\+ if no\_space:
\+ no\_space = False
\+ if start != prev\_end:
\+ yield (prev\_end, message)
\+ if token\_type == tokenize.OP:
\+ if text == '(':
\+ parens += 1
\+ elif text == ')':
\+ parens -= 1
\+ elif in\_def and text == ':' and parens == 1:
\+ annotated\_func\_arg = True
\+ elif parens and text == ',' and parens == 1:
\+ annotated\_func\_arg = False
\+ elif parens and text == '=' and not annotated\_func\_arg:
\+ no\_space = True
\+ if start != prev\_end:
\+ yield (prev\_end, message)
\+ if not parens:
\+ annotated\_func\_arg = False
+
\+ prev\_end = end
+
+
+def whitespace\_before\_comment(logical\_line, tokens):
\+ r"""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.
+
\+ Each line of a block comment starts with a # and a single space
\+ (unless it is indented text inside the comment).
+
\+ Okay: x = x + 1 # Increment x
\+ Okay: x = x + 1 # Increment x
\+ Okay: # Block comment
\+ E261: x = x + 1 # Increment x
\+ E262: x = x + 1 #Increment x
\+ E262: x = x + 1 # Increment x
\+ E265: #Block comment
\+ E266: ### Block comment
\+ """
\+ prev\_end = (0, 0)
\+ for token\_type, text, start, end, line in tokens:
\+ if token\_type == tokenize.COMMENT:
\+ inline\_comment = line\[:start\[1\]\].strip()
\+ if inline\_comment:
\+ if prev\_end\[0\] == start\[0\] and start\[1\] < prev\_end\[1\] + 2:
\+ yield (prev\_end,
\+ "E261 at least two spaces before inline comment")
\+ symbol, sp, comment = text.partition(' ')
\+ bad\_prefix = symbol not in '#:' and (symbol.lstrip('#')\[:1\] or '#')
\+ if inline\_comment:
\+ if bad\_prefix or comment\[:1\] in WHITESPACE:
\+ yield start, "E262 inline comment should start with '# '"
\+ elif bad\_prefix and (bad\_prefix != '!' or start\[0\] > 1):
\+ if bad\_prefix != '#':
\+ yield start, "E265 block comment should start with '# '"
\+ elif comment:
\+ yield start, "E266 too many leading '#' for block comment"
\+ 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 multiple imports on one line"
+
+
+def module\_imports\_on\_top\_of\_file(
\+ logical\_line, indent\_level, checker\_state, noqa):
\+ r"""Imports are always put at the top of the file, just after any module
\+ comments and docstrings, and before module globals and constants.
+
\+ Okay: import os
\+ Okay: # this is a comment\\nimport os
\+ Okay: '''this is a module docstring'''\\nimport os
\+ Okay: r'''this is a module docstring'''\\nimport os
\+ Okay: try:\\n import x\\nexcept:\\n pass\\nelse:\\n pass\\nimport y
\+ Okay: try:\\n import x\\nexcept:\\n pass\\nfinally:\\n pass\\nimport y
\+ E402: a=1\\nimport os
\+ E402: 'One string'\\n"Two string"\\nimport os
\+ E402: a=1\\nfrom sys import x
+
\+ Okay: if x:\\n import os
\+ """
\+ def is\_string\_literal(line):
\+ if line\[0\] in 'uUbB':
\+ line = line\[1:\]
\+ if line and line\[0\] in 'rR':
\+ line = line\[1:\]
\+ return line and (line\[0\] == '"' or line\[0\] == "'")
+
\+ allowed\_try\_keywords = ('try', 'except', 'else', 'finally')
+
\+ if indent\_level: # Allow imports in conditional statements or functions
\+ return
\+ if not logical\_line: # Allow empty lines or comments
\+ return
\+ if noqa:
\+ return
\+ line = logical\_line
\+ if line.startswith('import ') or line.startswith('from '):
\+ if checker\_state.get('seen\_non\_imports', False):
\+ yield 0, "E402 module level import not at top of file"
\+ elif any(line.startswith(kw) for kw in allowed\_try\_keywords):
\+ # Allow try, except, else, finally keywords intermixed with imports in
\+ # order to support conditional importing
\+ return
\+ elif is\_string\_literal(line):
\+ # The first literal is a docstring, allow it. Otherwise, report error.
\+ if checker\_state.get('seen\_docstring', False):
\+ checker\_state\['seen\_non\_imports'\] = True
\+ else:
\+ checker\_state\['seen\_docstring'\] = True
\+ else:
\+ checker\_state\['seen\_non\_imports'\] = True
+
+
+def compound\_statements(logical\_line):
\+ r"""Compound 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!
+
\+ Always use a def statement instead of an assignment statement that
\+ binds a lambda expression directly to a name.
+
\+ 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
\+ E704: def f(x): return 2\*x
\+ E731: f = lambda x: 2\*x
\+ """
\+ 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(')'))): # (annotation)
\+ lambda\_kw = LAMBDA\_REGEX.search(before)
\+ if lambda\_kw:
\+ before = line\[:lambda\_kw.start()\].rstrip()
\+ if before\[-1:\] == '=' and isidentifier(before\[:-1\].strip()):
\+ yield 0, ("E731 do not assign a lambda expression, use a "
\+ "def")
\+ break
\+ if before.startswith('def '):
\+ yield 0, "E704 multiple statements on one line (def)"
\+ else:
\+ yield found, "E701 multiple statements on one line (colon)"
\+ found = line.find(':', found + 1)
\+ found = line.find(';')
\+ while -1 < found:
\+ if found < last\_char:
\+ yield found, "E702 multiple statements on one line (semicolon)"
\+ else:
\+ yield found, "E703 statement ends with a semicolon"
\+ 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"
\+ Okay: aaa = 123 # \\\\
\+ """
\+ prev\_start = prev\_end = parens = 0
\+ comment = False
\+ backslash = None
\+ for token\_type, text, start, end, line in tokens:
\+ if token\_type == tokenize.COMMENT:
\+ comment = True
\+ if start\[0\] != prev\_start and parens and backslash and not comment:
\+ yield backslash, "E502 the backslash is redundant between brackets"
\+ 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 break\_around\_binary\_operator(logical\_line, tokens):
\+ r"""
\+ Avoid breaks before binary operators.
+
\+ The preferred place to break around a binary operator is after the
\+ operator, not before it.
+
\+ W503: (width == 0\\n + height == 0)
\+ W503: (width == 0\\n and height == 0)
+
\+ Okay: (width == 0 +\\n height == 0)
\+ Okay: foo(\\n -x)
\+ Okay: foo(x\\n \[\])
\+ Okay: x = '''\\n''' + ''
\+ Okay: foo(x,\\n -y)
\+ Okay: foo(x, # comment\\n -y)
\+ """
\+ def is\_binary\_operator(token\_type, text):
\+ # The % character is strictly speaking a binary operator, but the
\+ # common usage seems to be to put it next to the format parameters,
\+ # after a line break.
\+ return ((token\_type == tokenize.OP or text in \['and', 'or'\]) and
\+ text not in "()\[\]{},:.;@=%")
+
\+ line\_break = False
\+ unary\_context = True
\+ for token\_type, text, start, end, line in tokens:
\+ if token\_type == tokenize.COMMENT:
\+ continue
\+ if ('\\n' in text or '\\r' in text) and token\_type != tokenize.STRING:
\+ line\_break = True
\+ else:
\+ if (is\_binary\_operator(token\_type, text) and line\_break and
\+ not unary\_context):
\+ yield start, "W503 line break before binary operator"
\+ unary\_context = text in '(\[{,;'
\+ line\_break = False
+
+
+def comparison\_to\_singleton(logical\_line, noqa):
\+ r"""Comparison to singletons should use "is" or "is not".
+
\+ 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:
\+ E711: if None == arg:
\+ E712: if arg == True:
\+ E712: if False == arg:
+
\+ 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:
\+ singleton = match.group(1) or match.group(3)
\+ same = (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(2), ("%s comparison to %s should be %s" %
\+ (code, singleton, msg))
+
+
+def comparison\_negative(logical\_line):
\+ r"""Negative comparison should be done using "not in" and "is not".
+
\+ Okay: if x not in y:\\n pass
\+ Okay: assert (X in Y or X is Z)
\+ Okay: if not (X in Y):\\n pass
\+ Okay: zz = x is not y
\+ E713: Z = not X in Y
\+ E713: if not X.B in Y:\\n pass
\+ E714: if not X is Y:\\n pass
\+ E714: Z = not X.B is Y
\+ """
\+ match = COMPARE\_NEGATIVE\_REGEX.search(logical\_line)
\+ if match:
\+ pos = match.start(1)
\+ if match.group(2) == 'in':
\+ yield pos, "E713 test for membership should be 'not in'"
\+ else:
\+ yield pos, "E714 test for object identity should be 'is not'"
+
+
+def comparison\_type(logical\_line, noqa):
\+ r"""Object type comparisons should always use isinstance().
+
\+ Do not compare 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
\+ unicode string too! In Python 2.3, str and unicode have a common base
\+ class, basestring, so you can do:
+
\+ Okay: if isinstance(obj, basestring):
\+ Okay: if type(a1) is type(b1):
\+ """
\+ match = COMPARE\_TYPE\_REGEX.search(logical\_line)
\+ if match and not noqa:
\+ inst = match.group(1)
\+ if inst and isidentifier(inst) and inst not in SINGLETONS:
\+ return # Allow comparison for types which are not obvious
\+ yield match.start(), "E721 do not compare types, use 'isinstance()'"
+
+
+def python\_3000\_has\_key(logical\_line, noqa):
\+ r"""The {}.has\_key() method is removed in Python 3: use the 'in' operator.
+
\+ Okay: if "alph" in d:\\n print d\["alph"\]
\+ W601: assert d.has\_key('alph')
\+ """
\+ pos = logical\_line.find('.has\_key(')
\+ if pos > -1 and not noqa:
\+ yield pos, "W601 .has\_key() is deprecated, use 'in'"
+
+
+def python\_3000\_raise\_comma(logical\_line):
\+ r"""When raising an exception, use "raise ValueError('message')".
+
\+ The older form is removed in Python 3.
+
\+ Okay: raise DummyError("Message")
\+ W602: raise DummyError, "Message"
\+ """
\+ match = RAISE\_COMMA\_REGEX.match(logical\_line)
\+ if match and not RERAISE\_COMMA\_REGEX.match(logical\_line):
\+ yield match.end() - 1, "W602 deprecated form of raising exception"
+
+
+def python\_3000\_not\_equal(logical\_line):
\+ r"""New code should always use != instead of <>.
+
\+ The older syntax is removed in Python 3.
+
\+ Okay: if a != 'no':
\+ W603: if a <> 'no':
\+ """
\+ pos = logical\_line.find('<>')
\+ if pos > -1:
\+ yield pos, "W603 '<>' is deprecated, use '!='"
+
+
+def python\_3000\_backticks(logical\_line):
\+ r"""Backticks are removed in Python 3: use repr() instead.
+
\+ Okay: val = repr(1 + 2)
\+ W604: val = \`1 + 2\`
\+ """
\+ pos = logical\_line.find('\`')
\+ if pos > -1:
\+ yield pos, "W604 backticks are deprecated, use 'repr()'"
+
+
+##############################################################################
+# Helper functions
+##############################################################################
+
+
+if sys.version\_info < (3,):
\+ # Python 2: implicit encoding.
\+ def readlines(filename):
\+ """Read the source code."""
\+ with open(filename, 'rU') as f:
\+ return f.readlines()
\+ isidentifier = re.compile(r'\[a-zA-Z\_\]\\w\*$').match
\+ stdin\_get\_value = sys.stdin.read
+else:
\+ # Python 3
\+ def readlines(filename):
\+ """Read the source code."""
\+ try:
\+ with open(filename, 'rb') as f:
\+ (coding, lines) = tokenize.detect\_encoding(f.readline)
\+ f = TextIOWrapper(f, coding, line\_buffering=True)
\+ return \[l.decode(coding) for l in lines\] + f.readlines()
\+ except (LookupError, SyntaxError, UnicodeError):
\+ # Fall back if file encoding is improperly declared
\+ with open(filename, encoding='latin-1') as f:
\+ return f.readlines()
\+ isidentifier = str.isidentifier
+
\+ def stdin\_get\_value():
\+ return TextIOWrapper(sys.stdin.buffer, errors='ignore').read()
+noqa = re.compile(r'# no(?:qa|pep8)\\b', re.I).search
+
+
+def expand\_indent(line):
\+ r"""Return the amount of indentation.
+
\+ Tabs are expanded to the next multiple of 8.
+
\+ >>> expand\_indent(' ')
\+ 4
\+ >>> expand\_indent('\\t')
\+ 8
\+ >>> expand\_indent(' \\t')
\+ 8
\+ >>> expand\_indent(' \\t')
\+ 16
\+ """
\+ if '\\t' not in line:
\+ return len(line) - len(line.lstrip())
\+ result = 0
\+ for char in line:
\+ if char == '\\t':
\+ result = result // 8 \* 8 + 8
\+ elif char == ' ':
\+ result += 1
\+ else:
\+ break
\+ return result
+
+
+def mute\_string(text):
\+ """Replace contents with 'xxx' to prevent syntax matching.
+
\+ >>> mute\_string('"abc"')
\+ '"xxx"'
\+ >>> mute\_string("'''abc'''")
\+ "'''xxx'''"
\+ >>> mute\_string("r'abc'")
\+ "r'xxx'"
\+ """
\+ # String modifiers (e.g. u or r)
\+ start = text.index(text\[-1\]) + 1
\+ end = len(text) - 1
\+ # Triple quotes
\+ if text\[-3:\] in ('"""', "'''"):
\+ start += 2
\+ end -= 2
\+ return text\[:start\] + 'x' \* (end - start) + text\[end:\]
+
+
+def parse\_udiff(diff, patterns=None, parent='.'):
\+ """Return a dictionary of matching lines."""
\+ # For each file of the diff, the entry key is the filename,
\+ # and the value is a set of row numbers to consider.
\+ rv = {}
\+ path = nrows = None
\+ for line in diff.splitlines():
\+ if nrows:
\+ if line\[:1\] != '-':
\+ nrows -= 1
\+ continue
\+ if line\[:3\] == '@@ ':
\+ hunk\_match = HUNK\_REGEX.match(line)
\+ (row, nrows) = \[int(g or '1') for g in hunk\_match.groups()\]
\+ rv\[path\].update(range(row, row + nrows))
\+ elif line\[:3\] == '+++':
\+ path = line\[4:\].split('\\t', 1)\[0\]
\+ if path\[:2\] == 'b/':
\+ path = path\[2:\]
\+ rv\[path\] = set()
\+ return dict(\[(os.path.join(parent, path), rows)
\+ for (path, rows) in rv.items()
\+ if rows and filename\_match(path, patterns)\])
+
+
+def normalize\_paths(value, parent=os.curdir):
\+ """Parse a comma-separated list of paths.
+
\+ Return a list of absolute paths.
\+ """
\+ if not value:
\+ return \[\]
\+ if isinstance(value, list):
\+ return value
\+ paths = \[\]
\+ for path in value.split(','):
\+ path = path.strip()
\+ if '/' in path:
\+ path = os.path.abspath(os.path.join(parent, path))
\+ paths.append(path.rstrip('/'))
\+ return paths
+
+
+def filename\_match(filename, patterns, default=True):
\+ """Check if patterns contains a pattern that matches filename.
+
\+ If patterns is unspecified, this always returns True.
\+ """
\+ if not patterns:
\+ return default
\+ return any(fnmatch(filename, pattern) for pattern in patterns)
+
+
+def \_is\_eol\_token(token):
\+ return token\[0\] in NEWLINE or token\[4\]\[token\[3\]\[1\]:\].lstrip() == '\\\\\\n'
+if COMMENT\_WITH\_NL:
\+ def \_is\_eol\_token(token, \_eol\_token=\_is\_eol\_token):
\+ return \_eol\_token(token) or (token\[0\] == tokenize.COMMENT and
\+ token\[1\] == token\[4\])
+
+##############################################################################
+# Framework to run all checks
+##############################################################################
+
+
+\_checks = {'physical\_line': {}, 'logical\_line': {}, 'tree': {}}
+
+
+def \_get\_parameters(function):
\+ if sys.version\_info >= (3, 3):
\+ return \[parameter.name
\+ for parameter
\+ in inspect.signature(function).parameters.values()
\+ if parameter.kind == parameter.POSITIONAL\_OR\_KEYWORD\]
\+ else:
\+ return inspect.getargspec(function)\[0\]
+
+
+def register\_check(check, codes=None):
\+ """Register a new check object."""
\+ def \_add\_check(check, kind, codes, args):
\+ if check in \_checks\[kind\]:
\+ \_checks\[kind\]\[check\]\[0\].extend(codes or \[\])
\+ else:
\+ \_checks\[kind\]\[check\] = (codes or \[''\], args)
\+ if inspect.isfunction(check):
\+ args = \_get\_parameters(check)
\+ if args and args\[0\] in ('physical\_line', 'logical\_line'):
\+ if codes is None:
\+ codes = ERRORCODE\_REGEX.findall(check.\_\_doc\_\_ or '')
\+ \_add\_check(check, args\[0\], codes, args)
\+ elif inspect.isclass(check):
\+ if \_get\_parameters(check.\_\_init\_\_)\[:2\] == \['self', 'tree'\]:
\+ \_add\_check(check, 'tree', codes, None)
+
+
+def init\_checks\_registry():
\+ """Register all globally visible functions.
+
\+ The first argument name is either 'physical\_line' or 'logical\_line'.
\+ """
\+ mod = inspect.getmodule(register\_check)
\+ for (name, function) in inspect.getmembers(mod, inspect.isfunction):
\+ register\_check(function)
+init\_checks\_registry()
+
+
+class Checker(object):
\+ """Load a Python source file, tokenize it, check coding style."""
+
\+ def \_\_init\_\_(self, filename=None, lines=None,
\+ options=None, report=None, \*\*kwargs):
\+ if options is None:
\+ options = StyleGuide(kwargs).options
\+ else:
\+ assert not kwargs
\+ self.\_io\_error = None
\+ self.\_physical\_checks = options.physical\_checks
\+ self.\_logical\_checks = options.logical\_checks
\+ self.\_ast\_checks = options.ast\_checks
\+ self.max\_line\_length = options.max\_line\_length
\+ self.multiline = False # in a multiline string?
\+ self.hang\_closing = options.hang\_closing
\+ self.verbose = options.verbose
\+ self.filename = filename
\+ # Dictionary where a checker can store its custom state.
\+ self.\_checker\_states = {}
\+ if filename is None:
\+ self.filename = 'stdin'
\+ self.lines = lines or \[\]
\+ elif filename == '-':
\+ self.filename = 'stdin'
\+ self.lines = stdin\_get\_value().splitlines(True)
\+ elif lines is None:
\+ try:
\+ self.lines = readlines(filename)
\+ except IOError:
\+ (exc\_type, exc) = sys.exc\_info()\[:2\]
\+ self.\_io\_error = '%s: %s' % (exc\_type.\_\_name\_\_, exc)
\+ self.lines = \[\]
\+ else:
\+ self.lines = lines
\+ if self.lines:
\+ ord0 = ord(self.lines\[0\]\[0\])
\+ if ord0 in (0xef, 0xfeff): # Strip the UTF-8 BOM
\+ if ord0 == 0xfeff:
\+ self.lines\[0\] = self.lines\[0\]\[1:\]
\+ elif self.lines\[0\]\[:3\] == '\\xef\\xbb\\xbf':
\+ self.lines\[0\] = self.lines\[0\]\[3:\]
\+ self.report = report or options.report
\+ self.report\_error = self.report.error
+
\+ def report\_invalid\_syntax(self):
\+ """Check if the syntax is valid."""
\+ (exc\_type, exc) = sys.exc\_info()\[:2\]
\+ if len(exc.args) > 1:
\+ offset = exc.args\[1\]
\+ if len(offset) > 2:
\+ offset = offset\[1:3\]
\+ else:
\+ offset = (1, 0)
\+ self.report\_error(offset\[0\], offset\[1\] or 0,
\+ 'E901 %s: %s' % (exc\_type.\_\_name\_\_, exc.args\[0\]),
\+ self.report\_invalid\_syntax)
+
\+ def readline(self):
\+ """Get the next line from the input buffer."""
\+ if self.line\_number >= self.total\_lines:
\+ return ''
\+ line = self.lines\[self.line\_number\]
\+ self.line\_number += 1
\+ if self.indent\_char is None and line\[:1\] in WHITESPACE:
\+ self.indent\_char = line\[0\]
\+ return line
+
\+ def run\_check(self, check, argument\_names):
\+ """Run a check plugin."""
\+ arguments = \[\]
\+ for name in argument\_names:
\+ arguments.append(getattr(self, name))
\+ return check(\*arguments)
+
\+ def init\_checker\_state(self, name, argument\_names):
\+ """ Prepares a custom state for the specific checker plugin."""
\+ if 'checker\_state' in argument\_names:
\+ self.checker\_state = self.\_checker\_states.setdefault(name, {})
+
\+ def check\_physical(self, line):
\+ """Run all physical checks on a raw input line."""
\+ self.physical\_line = line
\+ for name, check, argument\_names in self.\_physical\_checks:
\+ self.init\_checker\_state(name, argument\_names)
\+ result = self.run\_check(check, argument\_names)
\+ if result is not None:
\+ (offset, text) = result
\+ self.report\_error(self.line\_number, offset, text, check)
\+ if text\[:4\] == 'E101':
\+ self.indent\_char = line\[0\]
+
\+ def build\_tokens\_line(self):
\+ """Build a logical line from tokens."""
\+ logical = \[\]
\+ comments = \[\]
\+ length = 0
\+ prev\_row = prev\_col = mapping = None
\+ for token\_type, text, start, end, line in self.tokens:
\+ if token\_type in SKIP\_TOKENS:
\+ continue
\+ if not mapping:
\+ mapping = \[(0, start)\]
\+ if token\_type == tokenize.COMMENT:
\+ comments.append(text)
\+ continue
\+ if token\_type == tokenize.STRING:
\+ text = mute\_string(text)
\+ if prev\_row:
\+ (start\_row, start\_col) = start
\+ if prev\_row != start\_row: # different row
\+ prev\_text = self.lines\[prev\_row - 1\]\[prev\_col - 1\]
\+ if prev\_text == ',' or (prev\_text not in '{\[(' and
\+ text not in '}\])'):
\+ text = ' ' + text
\+ elif prev\_col != start\_col: # different column
\+ text = line\[prev\_col:start\_col\] + text
\+ logical.append(text)
\+ length += len(text)
\+ mapping.append((length, end))
\+ (prev\_row, prev\_col) = end
\+ self.logical\_line = ''.join(logical)
\+ self.noqa = comments and noqa(''.join(comments))
\+ return mapping
+
\+ def check\_logical(self):
\+ """Build a line from tokens and run all logical checks on it."""
\+ self.report.increment\_logical\_line()
\+ mapping = self.build\_tokens\_line()
+
\+ if not mapping:
\+ return
+
\+ (start\_row, start\_col) = mapping\[0\]\[1\]
\+ start\_line = self.lines\[start\_row - 1\]
\+ self.indent\_level = expand\_indent(start\_line\[:start\_col\])
\+ if self.blank\_before < self.blank\_lines:
\+ self.blank\_before = self.blank\_lines
\+ if self.verbose >= 2:
\+ print(self.logical\_line\[:80\].rstrip())
\+ for name, check, argument\_names in self.\_logical\_checks:
\+ if self.verbose >= 4:
\+ print(' ' + name)
\+ self.init\_checker\_state(name, argument\_names)
\+ for offset, text in self.run\_check(check, argument\_names) or ():
\+ if not isinstance(offset, tuple):
\+ for token\_offset, pos in mapping:
\+ if offset <= token\_offset:
\+ break
\+ offset = (pos\[0\], pos\[1\] + offset - token\_offset)
\+ self.report\_error(offset\[0\], offset\[1\], text, check)
\+ if self.logical\_line:
\+ self.previous\_indent\_level = self.indent\_level
\+ self.previous\_logical = self.logical\_line
\+ self.blank\_lines = 0
\+ self.tokens = \[\]
+
\+ def check\_ast(self):
\+ """Build the file's AST and run all AST checks."""
\+ try:
\+ tree = compile(''.join(self.lines), '', 'exec', PyCF\_ONLY\_AST)
\+ except (ValueError, SyntaxError, TypeError):
\+ return self.report\_invalid\_syntax()
\+ for name, cls, \_\_ in self.\_a