eric: comparison Plugins/CheckerPlugins/CodeStyleChecker/pycodestyle.py

-:bf2ec89b1975
+:1a4758379c45
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-# pycodestyle.py - Check Python source code formatting, according to PEP 8
+# pycodestyle.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>
 #
 # follows:
 #
 # - made messages translatable via Qt
 # - added code for eric6 integration
 #
-# Copyright (c) 2011 - 2019 Detlev Offenbach <detlev@die-offenbachs.de>
+# Copyright (c) 2011 - 2018 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 import inspect
 import keyword
 import os
 try:
 from functools import lru_cache
 except ImportError:
 def lru_cache(maxsize=128):  # noqa as it's a fake implementation.
-"""Does not really need a real a lru_cache, it's just optimization, so
+"""Does not really need a real a lru_cache, it's just
-let's just do nothing here. Python 3.2+ will just get better
+optimization, so let's just do nothing here. Python 3.2+ will
-performances, time to upgrade?
+just get better performances, time to upgrade?
 """
 return lambda function: function
 from fnmatch import fnmatch
 from optparse import OptionParser
 from configparser import RawConfigParser
 from io import TextIOWrapper
 except ImportError:
 from ConfigParser import RawConfigParser            # __IGNORE_WARNING__
-__version__ = '2.4.0-eric'
+__version__ = '2.5.0-eric'
 DEFAULT_EXCLUDE = '.svn,CVS,.bzr,.hg,.git,__pycache__,.tox'
 DEFAULT_IGNORE = 'E121,E123,E126,E226,E24,E704,W503,W504'
 try:
 if sys.platform == 'win32':
 # Top level class and function.
 'top_level': 2,
 # Methods and nested class and function.
 'method': 1,
 }
+MAX_DOC_LENGTH = 72
 REPORT_FORMAT = {
 'default': '%(path)s:%(row)d:%(col)d: %(code)s %(text)s',
 'pylint': '%(path)s:%(row)d: [%(code)s] %(text)s',
 }
 SINGLETONS = frozenset(['False', 'None', 'True'])
 KEYWORDS = frozenset(keyword.kwlist + ['print', 'async']) - SINGLETONS
 UNARY_OPERATORS = frozenset(['>>', '**', '*', '+', '-'])
 ARITHMETIC_OP = frozenset(['**', '*', '/', '//', '+', '-'])
 WS_OPTIONAL_OPERATORS = ARITHMETIC_OP.union(['^', '&', '|', '<<', '>>', '%'])
+# Warn for -> function annotation operator in py3.5+ (issue 803)
+FUNCTION_RETURN_ANNOTATION_OP = ['->'] if sys.version_info >= (3, 5) else []
 WS_NEEDED_OPERATORS = frozenset([
 '**=', '*=', '/=', '//=', '+=', '-=', '!=', '<>', '<', '>',
-'%=', '^=', '&=', '|=', '==', '<=', '>=', '<<=', '>>=', '='])
+'%=', '^=', '&=', '|=', '==', '<=', '>=', '<<=', '>>=', '='] +
+FUNCTION_RETURN_ANNOTATION_OP)
 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])
 'while',
 )))
 )
 DUNDER_REGEX = re.compile(r'^__([^\s]+)__ = ')
-# 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'
 _checks = {'physical_line': {}, 'logical_line': {}, 'tree': {}}
 def _get_parameters(function):
 if sys.version_info >= (3, 3):
 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]:
 if _get_parameters(check.__init__)[:2] == ['self', 'tree']:
 _add_check(check, 'tree', codes, None)
 return check
-##############################################################################
+########################################################################
 # Plugins (check functions) for physical lines
-##############################################################################
+########################################################################
 @register_check
 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
+second-most popular way is with tabs only.  Code indented with a
-of tabs and spaces should be converted to using spaces exclusively.  When
+mixture of tabs and spaces should be converted to using spaces
-invoking the Python command line interpreter with the -t option, it issues
+exclusively.  When invoking the Python command line interpreter with
-warnings about code that illegally mixes tabs and spaces.  When using -tt
+the -t option, it issues warnings about code that illegally mixes
-these warnings become errors.  These options are highly recommended!
+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
+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"
 @register_check
 def tabs_obsolete(physical_line):
-r"""For new projects, spaces-only are strongly recommended over tabs.
+r"""On 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)
 @register_check
 def trailing_whitespace(physical_line):
 r"""Trailing whitespace is superfluous.
-The warning returned varies on whether the line itself is blank, for easier
+The warning returned varies on whether the line itself is blank,
-filtering for those who want to indent their blank lines.
+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
 """
 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:
+if physical_line and 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"
+return len(lines[-1]), "W292 no newline at end of file"
 @register_check
 def maximum_line_length(physical_line, max_line_length, multiline,
 line_number, noqa):
 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
+lines; plus, limiting windows to 80 characters makes it possible to
-several windows side-by-side.  The default wrapping on such devices looks
+have several windows side-by-side.  The default wrapping on such
-ugly.  Therefore, please limit all lines to a maximum of 79 characters.
+devices looks ugly.  Therefore, please limit all lines to a maximum
-For flowing long blocks of text (docstrings or comments), limiting the
+of 79 characters. For flowing long blocks of text (docstrings or
-length to 72 characters is recommended.
+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:
 # Special case: ignore long shebang lines.
 if line_number == 1 and line.startswith('#!'):
 return
-# Special case for long URLs in multi-line docstrings or comments,
+# Special case for long URLs in multi-line docstrings or
-# but still report the error when the 72 first chars are whitespaces.
+# 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
 return (max_line_length, "E501 line too long "
 "(%d > %d characters)" % (length, max_line_length),
 length, max_line_length)
-##############################################################################
+########################################################################
 # Plugins (check functions) for logical lines
-##############################################################################
+########################################################################
 @register_check
 def blank_lines(logical_line, blank_lines, indent_level, line_number,
 blank_before, previous_logical,
 previous_unindented_logical_line, previous_indent_level,
 lines):
-r"""Separate top-level function and class definitions with two blank lines.
+r"""Separate top-level function and class definitions with two blank
+lines.
-Method definitions inside a class are separated by a single blank line.
+Method definitions inside a class are separated by a single blank
-Extra blank lines may be used (sparingly) to separate groups of related
+line.
-functions.  Blank lines may be omitted between a bunch of related
-one-liners (e.g. a set of dummy implementations).
+Extra blank lines may be used (sparingly) to separate groups of
+related functions.  Blank lines may be omitted between a bunch of
-Use blank lines in functions, sparingly, to indicate logical sections.
+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\nasync def b():\n    pass
 Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
 Okay: default = 1\nfoo = 1
 "scope, expected %d", blank_lines, method_lines)
 else:
 yield (0, "E303 too many blank lines (%d), expected %d",
 blank_lines, top_level_lines)
 elif STARTSWITH_TOP_LEVEL_REGEX.match(logical_line):
+# If this is a one-liner (i.e. the next line is not more
+# indented), and the previous line is also not deeper
+# (it would be better to check if the previous line is part
+# of another def/class at the same level), don't require blank
+# lines around this.
+prev_line = lines[line_number - 2] if line_number >= 2 else ''
+next_line = lines[line_number] if line_number < len(lines) else ''
+if (expand_indent(prev_line) <= indent_level and
+expand_indent(next_line) <= indent_level):
+return
 if indent_level:
 if not (blank_before == method_lines or
 previous_indent_level < indent_level or
 DOCSTRING_REGEX.match(previous_logical)
 ):
 ancestor_level = indent_level
 nested = False
-# Search backwards for a def ancestor or tree root (top level).
+# Search backwards for a def ancestor or tree root
+# (top level).
 for line in lines[line_number - top_level_lines::-1]:
 if line.strip() and expand_indent(line) < ancestor_level:
 ancestor_level = expand_indent(line)
 nested = line.lstrip().startswith('def ')
 if nested or ancestor_level == 0:
 yield match.start(2), "E271 multiple spaces after keyword"
 @register_check
 def missing_whitespace_after_import_keyword(logical_line):
-r"""Multiple imports in form from x import (a, b, c) should have space
+r"""Multiple imports in form from x import (a, b, c) should have
-between import statement and parenthesised name list.
+space between import statement and parenthesised name list.
 Okay: from foo import (bar, baz)
 E275: from foo import(bar, baz)
 E275: from importable.module import(bar, baz)
 """
 @register_check
 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
+For really old code that you don't want to mess up, you can continue
-use 8-space tabs.
+to use 8-space tabs.
 Okay: a = 1
 Okay: if a == 0:\n    a = 1
 E111:   a = 1
 E114:   # a = 1
 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")
+expected_indent_level = previous_indent_level + 4
+if indent_expect and indent_level > expected_indent_level:
+yield 0, tmpl % (7, 'over-indented')
 @register_check
 def continued_indentation(logical_line, tokens, indent_level, hang_closing,
 indent_char, noqa, verbose):
 r"""Continuation lines indentation.
 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
+- further indentation should be used to clearly distinguish itself
-continuation line.
+as a continuation line.
 Okay: a = (\n)
 E123: a = (\n    )
 Okay: a = (\n    42)
 # 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
+# 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
 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
+# 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"
 # 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
+# Check if the operator is 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
 @register_check
 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, except when using a type
+keyword argument or a default parameter value, except when
-annotation.
+using a type annotation.
 Okay: def complex(real, imag=0.0):
 Okay: return magic(r=real, i=imag)
 Okay: boolean(a == b)
 Okay: boolean(a != b)
 parens += 1
 elif text in ')]':
 parens -= 1
 elif in_def and text == ':' and parens == 1:
 annotated_func_arg = True
-elif parens and text == ',' and parens == 1:
+elif parens == 1 and text == ',':
 annotated_func_arg = False
 elif parens and text == '=':
-if not annotated_func_arg:
+if annotated_func_arg and parens == 1:
+require_space = True
+if start == prev_end:
+yield (prev_end, missing_message)
+else:
 no_space = True
 if start != prev_end:
 yield (prev_end, message)
-else:
-require_space = True
-if start == prev_end:
-yield (prev_end, missing_message)
 if not parens:
 annotated_func_arg = False
 prev_end = end
 @register_check
 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
+An inline comment is a comment on the same line as a statement.
-comments should be separated by at least two spaces from the statement.
+Inline comments should be separated by at least two spaces from the
-They should start with a # and a single space.
+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
 @register_check
 def module_imports_on_top_of_file(
 logical_line, indent_level, checker_state, noqa):
 r"""Place imports at the top of the file.
-Always put imports at the top of the file, just after any module comments
+Always put imports at the top of the file, just after any module
-and docstrings, and before module globals and constants.
+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
 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
-"""
+"""  # noqa
 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
+if indent_level:  # Allow imports in conditional statement/function
 return
 if not logical_line:  # Allow empty lines or comments
 return
 if noqa:
 return
 if checker_state.get('seen_non_imports', False):
 yield 0, "E402 module level import not at top of file"
 elif re.match(DUNDER_REGEX, line):
 return
 elif any(line.startswith(kw) for kw in allowed_try_keywords):
-# Allow try, except, else, finally keywords intermixed with imports in
+# Allow try, except, else, finally keywords intermixed with
-# order to support conditional importing
+# imports in order to support conditional importing
 return
 elif is_string_literal(line):
-# The first literal is a docstring, allow it. Otherwise, report error.
+# 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
 @register_check
 def compound_statements(logical_line):
-r"""Compound statements (on the same line) are generally discouraged.
+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!
 """
 line = logical_line
 last_char = len(line) - 1
 found = line.find(':')
 prev_found = 0
-counts = dict((char, 0) for char in '{}[]()')
+counts = {char: 0 for char in '{}[]()'}
 while -1 < found < last_char:
 update_counts(line[prev_found:found], counts)
 if ((counts['{'] <= counts['}'] and   # {'a': 1} (dict)
 counts['['] <= counts[']'] and   # [1:2] (slice)
 counts['('] <= counts[')'])):    # (annotation)
 @register_check
 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
+The preferred way of wrapping long lines is by using Python's
-continuation inside parentheses, brackets and braces.  Long lines can be
+implied line continuation inside parentheses, brackets and braces.
-broken over multiple lines by wrapping expressions in parentheses.  These
+Long lines can be broken over multiple lines by wrapping expressions
-should be used in preference to using a backslash for line continuation.
+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]
 def _is_binary_operator(token_type, text):
 is_op_token = token_type == tokenize.OP
 is_conjunction = text in ['and', 'or']
 # NOTE(sigmavirus24): Previously the not_a_symbol check was executed
-# conditionally. Since it is now *always* executed, text may be None.
+# conditionally. Since it is now *always* executed, text may be
-# In that case we get a TypeError for `text not in str`.
+# None. In that case we get a TypeError for `text not in str`.
 not_a_symbol = text and text not in "()[]{},:.;@=%~"
 # 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 ((is_op_token or is_conjunction) and not_a_symbol)
 The following should be W504 but unary_context is tricky with these
 Okay: var = (1 /\n       -2)
 Okay: var = (1 +\n       -1 +\n       -2)
 """
+prev_start = None
 for context in _break_around_binary_operators(tokens):
 (token_type, text, previous_token_type, previous_text,
 line_break, unary_context, start) = context
 if (_is_binary_operator(previous_token_type, previous_text) and
 line_break and
 not unary_context and
 not _is_binary_operator(token_type, text)):
-error_pos = (start[0] - 1, start[1])
+yield prev_start, "W504 line break after binary operator"
-yield error_pos, "W504 line break after binary operator"
+prev_start = start
 @register_check
 def comparison_to_singleton(logical_line, noqa):
 r"""Comparison to singletons should use "is" or "is not".
 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 --
+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
+-- e.g. when testing whether a variable or argument that defaults to
-set to some other value.  The other value might have a type (such as a
+None was set to some other value.  The other value might have a type
-container) that could be false in a boolean context!
+(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) == '==')
 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
+When checking if an object is a string, keep in mind that it might
-unicode string too! In Python 2.3, str and unicode have a common base
+be a unicode string too! In Python 2.3, str and unicode have a
-class, basestring, so you can do:
+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)
 yield match.start(), "E721 do not compare types, use 'isinstance()'"
 @register_check
 def bare_except(logical_line, noqa):
-r"""When catching exceptions, mention specific exceptions when possible.
+r"""When catching exceptions, mention specific exceptions when
+possible.
 Okay: except Exception:
 Okay: except BaseException:
 E722: except:
 """
 @register_check
 def ambiguous_identifier(logical_line, tokens):
 r"""Never use the characters 'l', 'O', or 'I' as variable names.
-In some fonts, these characters are indistinguishable from the numerals
+In some fonts, these characters are indistinguishable from the
-one and zero. When tempted to use 'l', use 'L' instead.
+numerals one and zero. When tempted to use 'l', use 'L' instead.
 Okay: L = 0
 Okay: o = 123
 Okay: i = 42
 E741: l = 0
 E741: O = 123
 E741: I = 42
-Variables can be bound in several other contexts, including class and
+Variables can be bound in several other contexts, including class
-function definitions, 'global' and 'nonlocal' statements, exception
+and function definitions, 'global' and 'nonlocal' statements,
-handlers, and 'with' statements.
+exception handlers, and 'with' statements.
 Okay: except AttributeError as o:
 Okay: with lock as L:
 E741: except AttributeError as O:
 E741: with lock as l:
 # identifiers on the lhs of an assignment operator
 if token_type == tokenize.OP and '=' in text:
 if prev_text in idents_to_avoid:
 ident = prev_text
 pos = prev_start
-# identifiers bound to a value with 'as', 'global', or 'nonlocal'
+# identifiers bound to values with 'as', 'global', or 'nonlocal'
 if prev_text in ('as', 'global', 'nonlocal'):
 if text in idents_to_avoid:
 ident = text
 pos = start
 if prev_text == 'class':
 prev_start = start
 @register_check
 def python_3000_has_key(logical_line, noqa):
-r"""The {}.has_key() method is removed in Python 3: use the 'in' operator.
+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:
 yield pos, "W604 backticks are deprecated, use 'repr()'"
 @register_check
-def python_3000_invalid_escape_sequence(logical_line, tokens):
+def python_3000_invalid_escape_sequence(logical_line, tokens, noqa):
 r"""Invalid escape sequences are deprecated in Python 3.6.
 Okay: regex = r'\.png$'
 W605: regex = '\.png$'
 """
+if noqa:
+return
 # https://docs.python.org/3/reference/lexical_analysis.html#string-and-bytes-literals
 valid = [
 '\n',
 '\\',
 '\'',
 'U',
 ]
 for token_type, text, start, end, line in tokens:
 if token_type == tokenize.STRING:
+start_line, start_col = start
 quote = text[-3:] if text[-3:] in ('"""', "'''") else text[-1]
 # Extract string modifiers (e.g. u or r)
 quote_pos = text.index(quote)
 prefix = text[:quote_pos].lower()
 start = quote_pos + len(quote)
 if 'r' not in prefix:
 pos = string.find('\\')
 while pos >= 0:
 pos += 1
 if string[pos] not in valid:
+line = start_line + string.count('\n', 0, pos)
+if line == start_line:
+col = start_col + len(prefix) + len(quote) + pos
+else:
+col = pos - string.rfind('\n', 0, pos) - 1
 yield (
-pos,
+(line, col - 1),
 "W605 invalid escape sequence '\\%s'",
 string[pos],
 )
 pos = string.find('\\', pos + 1)
 @register_check
 def python_3000_async_await_keywords(logical_line, tokens):
-"""'async' and 'await' are reserved keywords starting with Python 3.7
+"""'async' and 'await' are reserved keywords starting at Python 3.7.
 W606: async = 42
 W606: await = 42
-Okay: async def read_data(db):\n    data = await db.fetch('SELECT ...')
+Okay: async def read(db):\n    data = await db.fetch('SELECT ...')
 """
-# The Python tokenize library before Python 3.5 recognizes async/await as a
+# The Python tokenize library before Python 3.5 recognizes
-# NAME token. Therefore, use a state machine to look for the possible
+# async/await as a NAME token. Therefore, use a state machine to
-# async/await constructs as defined by the Python grammar:
+# look for the possible async/await constructs as defined by the
+# Python grammar:
 # https://docs.python.org/3/reference/grammar.html
 state = None
 for token_type, text, start, end, line in tokens:
 error = False
+if token_type == tokenize.NL:
+continue
 if state is None:
 if token_type == tokenize.NAME:
 if text == 'async':
 state = ('async_stmt', start)
 elif text == 'await':
 state = ('await', start)
+elif (token_type == tokenize.NAME and
+text in ('def', 'for')):
+state = ('define', start)
 elif state[0] == 'async_stmt':
 if token_type == tokenize.NAME and text in ('def', 'with', 'for'):
-# One of funcdef, with_stmt, or for_stmt. Return to looking
+# One of funcdef, with_stmt, or for_stmt. Return to
-# for async/await names.
+# looking for async/await names.
 state = None
 else:
 error = True
 elif state[0] == 'await':
-if token_type in (tokenize.NAME, tokenize.NUMBER, tokenize.STRING):
+if token_type == tokenize.NAME:
-# An await expression. Return to looking for async/await names.
+# An await expression. Return to looking for async/await
+# names.
+state = None
+elif token_type == tokenize.OP and text == '(':
 state = None
 else:
 error = True
+elif state[0] == 'define':
+if token_type == tokenize.NAME and text in ('async', 'await'):
+error = True
+else:
+state = None
 if error:
 yield (
 state[1],
 "W606 'async' and 'await' are reserved keywords starting with "
 "W606 'async' and 'await' are reserved keywords starting with "
 "Python 3.7",
 )
-##############################################################################
+########################################################################
+@register_check
+def maximum_doc_length(logical_line, max_doc_length, noqa, tokens):
+r"""Limit all doc lines to a maximum of 72 characters.
+For flowing long blocks of text (docstrings or comments), limiting
+the length to 72 characters is recommended.
+Reports warning W505
+"""
+if max_doc_length is None or noqa:
+return
+prev_token = None
+skip_lines = set()
+# Skip lines that
+for token_type, text, start, end, line in tokens:
+if token_type not in SKIP_COMMENTS.union([tokenize.STRING]):
+skip_lines.add(line)
+for token_type, text, start, end, line in tokens:
+# Skip lines that aren't pure strings
+if token_type == tokenize.STRING and skip_lines:
+continue
+if token_type in (tokenize.STRING, tokenize.COMMENT):
+# Only check comment-only lines
+if prev_token is None or prev_token in SKIP_TOKENS:
+lines = line.splitlines()
+for line_num, physical_line in enumerate(lines):
+if hasattr(physical_line, 'decode'):  # Python 2
+# The line could contain multi-byte characters
+try:
+physical_line = physical_line.decode('utf-8')
+except UnicodeError:
+pass
+if start[0] + line_num == 1 and line.startswith('#!'):
+return
+length = len(physical_line)
+chunks = physical_line.split()
+if token_type == tokenize.COMMENT:
+if (len(chunks) == 2 and
+length - len(chunks[-1]) < MAX_DOC_LENGTH):
+continue
+if len(chunks) == 1 and line_num + 1 < len(lines):
+if (len(chunks) == 1 and
+length - len(chunks[-1]) < MAX_DOC_LENGTH):
+continue
+if length > max_doc_length:
+doc_error = (start[0] + line_num, max_doc_length)
+yield (doc_error, "W505 doc line too long "
+"(%d > %d characters)",
+length, max_doc_length)
+prev_token = token_type
+########################################################################
 # Helper functions
-##############################################################################
+########################################################################
 if sys.version_info < (3,):
 # Python 2: implicit encoding.
 def readlines(filename):
 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]
-# Git diff will use (i)ndex, (w)ork tree, (c)ommit and (o)bject
+# Git diff will use (i)ndex, (w)ork tree, (c)ommit and
-# instead of a/b/c/d as prefixes for patches
+# (o)bject instead of a/b/c/d as prefixes for patches
 if path[:2] in ('b/', 'w/', 'i/'):
 path = path[2:]
 rv[path] = set()
-return dict([(os.path.join(parent, path), rows)
+return {
-for (path, rows) in rv.items()
+os.path.join(parent, filepath): rows
-if rows and filename_match(path, patterns)])
+for (filepath, rows) in rv.items()
+if rows and filename_match(filepath, patterns)
+}
 def normalize_paths(value, parent=os.curdir):
 """Parse a comma-separated list of paths.
 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
-##############################################################################
+########################################################################
 class Checker(object):
 """Load a Python source file, tokenize it, check coding style."""
 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.max_doc_length = options.max_doc_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.
 lineno = args[0]
 if not self.lines or not noqa(self.lines[lineno - 1]):
 self.report_error_args(lineno, *args[1:])
 def generate_tokens(self):
-"""Tokenize the file, run physical line checks and yield tokens."""
+"""Tokenize file, run physical line checks and yield tokens."""
 if self._io_error:
 self.report_error_args(1, 0, 'E902', self._io_error, readlines)
 tokengen = tokenize.generate_tokens(self.readline)
 try:
 for token in tokengen:
 yield token
 except (SyntaxError, tokenize.TokenError):
 self.report_invalid_syntax()
 def maybe_check_physical(self, token):
-"""If appropriate (based on token), check current physical line(s)."""
+"""If appropriate for token, check current physical line(s)."""
 # Called after every token, but act only on end of line.
 if _is_eol_token(token):
 # Obviously, a newline token ends a single physical line.
 self.check_physical(token[4])
 elif token[0] == tokenize.STRING and '\n' in token[1]:
 # Less obviously, a string that contains newlines is a
 # multiline string, either triple-quoted or with internal
-# newlines backslash-escaped. Check every physical line in the
+# newlines backslash-escaped. Check every physical line in
-# string *except* for the last one: its newline is outside of
+# the string *except* for the last one: its newline is
-# the multiline string, so we consider it a regular physical
+# outside of the multiline string, so we consider it a
-# line, and will check it like any other physical line.
+# regular physical line, and will check it like any other
+# physical line.
 #
 # Subtleties:
-# - we don't *completely* ignore the last line; if it contains
+# - we don't *completely* ignore the last line; if it
-#   the magical "# noqa" comment, we disable all physical
+#   contains the magical "# noqa" comment, we disable all
-#   checks for the entire multiline string
+#   physical checks for the entire multiline string
 # - have to wind self.line_number back because initially it
 #   points to the last line of the string, and we want
 #   check_physical() to give accurate feedback
 if noqa(token[4]):
 return
 # The physical line contains only this token.
 self.blank_lines += 1
 del self.tokens[0]
 else:
 self.check_logical()
-elif COMMENT_WITH_NL and token_type == tokenize.COMMENT:
-if len(self.tokens) == 1:
-# The comment also ends a physical line
-token = list(token)
-token[1] = text.rstrip('\r\n')
-token[3] = (token[2][0], token[2][1] + len(token[1]))
-self.tokens = [tuple(token)]
-self.check_logical()
 if self.tokens:
 self.check_physical(self.lines[-1])
 self.check_logical()
 return self.report.get_file_results()
 """Return the count of errors and warnings for this file."""
 return self.file_errors
 def get_count(self, prefix=''):
 """Return the total count of errors and warnings."""
-return sum([self.counters[key]
+return sum(self.counters[key]
-for key in self.messages if key.startswith(prefix)])
+for key in self.messages if key.startswith(prefix))
 def get_statistics(self, prefix=''):
 """Get statistics for message codes that start with the prefix.
 prefix='' matches all errors and warnings
 (self.counters[key] / self.elapsed, key,
 self.counters[key]))
 class FileReport(BaseReport):
-"""Collect the results of the checks and print only the filenames."""
+"""Collect the results of the checks and print the filenames."""
 print_filename = True
 class StandardReport(BaseReport):
 self._deferred_print.append(
 (line_number, offset, code, args, check.__doc__))
 return code
 def get_file_results(self):
-"""Print the result and return the overall count for this file."""
+"""Print results and return the overall count for this file."""
 self._deferred_print.sort()
 for line_number, offset, code, text, doc in self._deferred_print:
 print(self._fmt % {
 'path': self.filename,
 'row': self.line_offset + line_number, 'col': offset + 1,
 print(re.sub(r'\S', ' ', line[:offset]) + '^')
 if self._show_pep8 and doc:
 print('    ' + doc.strip())
 # stdout is block buffered when not stdout.isatty().
-# line can be broken where buffer boundary since other processes
+# line can be broken where buffer boundary since other
-# write to same file.
+# processes write to same file.
 # flush() after print() to avoid buffer boundary.
 # Typical buffer size is 8192. line written safely when
 # len(line) < 8192.
 sys.stdout.flush()
 return self.file_errors
 runner(os.path.join(root, filename))
 def excluded(self, filename, parent=None):
 """Check if the file should be excluded.
-Check if 'options.exclude' contains a pattern that matches filename.
+Check if 'options.exclude' contains a pattern matching filename.
 """
 if not self.options.exclude:
 return False
 basename = os.path.basename(filename)
 if filename_match(basename, self.options.exclude):
 not code.startswith(self.options.select))
 def get_checks(self, argument_name):
 """Get all the checks for this category.
-Find all globally visible functions where the first argument name
+Find all globally visible functions where the first argument
-starts with argument_name and which contain selected tests.
+name starts with argument_name and which contain selected tests.
 """
 checks = []
 for check, attrs in _checks[argument_name].items():
 (codes, args) = attrs
 if any(not (code and self.ignore_code(code)) for code in codes):
 """Create the parser for the program."""
 parser = OptionParser(prog=prog, version=version,
 usage="%prog [options] input ...")
 parser.config_options = [
 'exclude', 'filename', 'select', 'ignore', 'max-line-length',
-'hang-closing', 'count', 'format', 'quiet', 'show-pep8',
+'max-doc-length', 'hang-closing', 'count', 'format', 'quiet',
-'show-source', 'statistics', 'verbose']
+'show-pep8', 'show-source', 'statistics', 'verbose']
 parser.add_option('-v', '--verbose', default=0, action='count',
 help="print status messages, or debug with -vv")
 parser.add_option('-q', '--quiet', default=0, action='count',
 help="report only file names, or nothing with -qq")
 parser.add_option('-r', '--repeat', default=True, action='store_true',
 "total is not null")
 parser.add_option('--max-line-length', type='int', metavar='n',
 default=MAX_LINE_LENGTH,
 help="set maximum allowed line length "
 "(default: %default)")
+parser.add_option('--max-doc-length', type='int', metavar='n',
+default=None,
+help="set maximum allowed doc line length and perform "
+"these checks (unchecked if not set)")
 parser.add_option('--hang-closing', action='store_true',
 help="hang closing bracket instead of matching "
 "indentation of opening bracket's line")
 parser.add_option('--format', metavar='format', default='default',
 help="set the error format [default|pylint|<custom>]")
 def read_config(options, args, arglist, parser):
 """Read and parse configurations.
-If a config file is specified on the command line with the "--config"
+If a config file is specified on the command line with the
-option, then only it is used for configuration.
+"--config" option, then only it is used for configuration.
-Otherwise, the user configuration (~/.config/pycodestyle) and any local
+Otherwise, the user configuration (~/.config/pycodestyle) and any
-configurations in the current directory or above will be merged together
+local configurations in the current directory or above will be
-(in that order) using the read method of ConfigParser.
+merged together (in that order) using the read method of
+ConfigParser.
 """
 config = RawConfigParser()
 cli_conf = options.config
 elif config.has_section('pep8'):
 pycodestyle_section = 'pep8'  # Deprecated
 warnings.warn('[pep8] section is deprecated. Use [pycodestyle].')
 if pycodestyle_section:
-option_list = dict([(o.dest, o.type or o.action)
+option_list = {o.dest: o.type or o.action for o in parser.option_list}
-for o in parser.option_list])
 # First, read the default values
 (new_options, __) = parser.parse_args([])
 # Second, parse the configuration
 return options
 def process_options(arglist=None, parse_argv=False, config_file=None,
 parser=None, verbose=None):
-"""Process options passed either via arglist or via command line args.
+"""Process options passed either via arglist or command line args.
-Passing in the ``config_file`` parameter allows other tools, such as flake8
+Passing in the ``config_file`` parameter allows other tools, such as
-to specify their own options to be processed in pycodestyle.
+flake8 to specify their own options to be processed in pycodestyle.
 """
 if not parser:
 parser = get_parser()
 if not parser.has_option('--config'):
 group = parser.add_option_group("Configuration", description=(
 # If parse_argv is True and arglist is None, arguments are
 # parsed from the command line (sys.argv)
 (options, args) = parser.parse_args(arglist)
 options.reporter = None
-# If explicity specified verbosity, override any `-v` CLI flag
+# If explicitly specified verbosity, override any `-v` CLI flag
 if verbose is not None:
 options.verbose = verbose
 if options.ensure_value('testsuite', False):
 args.append(options.testsuite)

Mercurial Repositories > eric / file comparison

comparison: Plugins/CheckerPlugins/CodeStyleChecker/pycodestyle.py

Plugins/CheckerPlugins/CodeStyleChecker/pycodestyle.py