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

-:ed79209469ad
+:e21b51a3d990
 import sys
 import time
 import tokenize
 import warnings
-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 let's just do nothing here. Python 3.2+ will
-just get better performances, time to upgrade?
-"""
-return lambda function: function
 from fnmatch import fnmatch
+from functools import lru_cache
 from optparse import OptionParser
 try:
 from configparser import RawConfigParser
 from io import TextIOWrapper
 sys.version_info < (3, 10) and
 callable(getattr(tokenize, '_compile', None))
 ):  # pragma: no cover (<py310)
 tokenize._compile = lru_cache()(tokenize._compile)  # type: ignore
-__version__ = '2.8.0-eric'
+__version__ = '2.9.1-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':
 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 []
 ASSIGNMENT_EXPRESSION_OP = [':='] if sys.version_info >= (3, 8) else []
 WS_NEEDED_OPERATORS = frozenset([
 '**=', '*=', '/=', '//=', '+=', '-=', '!=', '<>', '<', '>',
 '%=', '^=', '&=', '|=', '==', '<=', '>=', '<<=', '>>=', '=',
-'and', 'in', 'is', 'or'] +
+'and', 'in', 'is', 'or', '->'] +
-FUNCTION_RETURN_ANNOTATION_OP +
 ASSIGNMENT_EXPRESSION_OP)
-WHITESPACE = frozenset(' \t')
+WHITESPACE = frozenset(' \t\xa0')
 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']
 COMPARE_NEGATIVE_REGEX = re.compile(r'\b(?<!is\s)(not)\s+[^][)(}{ ]+\s+'
 r'(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*)')
+OPERATOR_REGEX = re.compile(r'(?:[^,\s])(\s*)(?:[-+*/|!<=>%&^]+|:=)(\s*)')
 LAMBDA_REGEX = re.compile(r'\blambda\b')
 HUNK_REGEX = re.compile(r'^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@.*$')
 STARTSWITH_DEF_REGEX = re.compile(r'^(async\s+def|def)\b')
 STARTSWITH_TOP_LEVEL_REGEX = re.compile(r'^(async\s+def\s+|def\s+|class\s+|@)')
 STARTSWITH_INDENT_STATEMENT_REGEX = re.compile(
-r'^\s*({0})\b'.format('|'.join(s.replace(' ', r'\s+') for s in (
+r'^\s*({})\b'.format('|'.join(s.replace(' ', r'\s+') for s in (
 'def', 'async def',
 'for', 'async for',
 'if', 'elif', 'else',
 'try', 'except', 'finally',
 'with', 'async with',
 _checks = {'physical_line': {}, 'logical_line': {}, 'tree': {}}
 def _get_parameters(function):
-if sys.version_info >= (3, 3):
+return [parameter.name
-return [parameter.name
+for parameter
-for parameter
+in inspect.signature(function).parameters.values()
-in inspect.signature(function).parameters.values()
+if parameter.kind == parameter.POSITIONAL_OR_KEYWORD]
-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):
 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),
 length, max_line_length)
 ancestor_level = expand_indent(line)
 nested = STARTSWITH_DEF_REGEX.match(line.lstrip())
 if nested or ancestor_level == 0:
 break
 if nested:
-yield (0, "E306 expected %s blank lines before a "
+yield (0, "E306 expected {} blank lines before a "
-"nested definition, found %d", method_lines,
+"nested definition, found {}", method_lines,
 blank_before)
 else:
-yield (0, "E301 expected %s blank lines, found %d",
+yield (0, "E301 expected {} blank lines, found %d",
 method_lines, blank_before)
 elif blank_before != top_level_lines:
-yield (0, "E302 expected %s blank lines, found %d",
+yield (0, "E302 expected {} blank lines, found {}",
 top_level_lines, blank_before)
 elif (logical_line and
 not indent_level and
 blank_before != top_level_lines and
 previous_unindented_logical_line.startswith(('def ', 'class '))
 ):
-yield (0, "E305 expected %s blank lines after " \
+yield (0, "E305 expected {} blank lines after " \
-"class or function definition, found %d",
+"class or function definition, found {}",
 top_level_lines, blank_before)
 @register_check
 def extraneous_whitespace(logical_line):
 if text[-1].isspace():
 # 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), char
+yield found, f"{code} whitespace before '{char}'", char
 @register_check
 def whitespace_around_keywords(logical_line):
 r"""Avoid extraneous whitespace around keywords.
 elif len(after) > 1:
 yield match.start(2), "E271 multiple spaces after keyword"
 @register_check
-def missing_whitespace_after_import_keyword(logical_line):
+def missing_whitespace_after_keyword(logical_line, tokens):
-r"""Multiple imports in form from x import (a, b, c) should have
+r"""Keywords should be followed by whitespace.
-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)
-"""
+E275: if(foo): bar
-line = logical_line
+"""
-indicator = ' import('
+for tok0, tok1 in zip(tokens, tokens[1:]):
-if line.startswith('from '):
+# This must exclude the True/False/None singletons, which can
-found = line.find(indicator)
+# appear e.g. as "if x is None:", and async/await, which were
-if -1 < found:
+# valid identifier names in old Python versions.
-pos = found + len(indicator) - 1
+if (tok0.end == tok1.start and
-yield pos, "E275 missing whitespace after keyword"
+keyword.iskeyword(tok0.string) and
+tok0.string not in SINGLETONS and
+tok0.string not in ('async', 'await') and
+not (tok0.string == 'except' and tok1.string == '*') and
+not (tok0.string == 'yield' and tok1.string == ')') and
+tok1.string not in ':\n'):
+yield tok0.end, "E275 missing whitespace after keyword"
 @register_check
 def missing_whitespace(logical_line):
 r"""Each comma, semicolon or colon should be followed by whitespace.
 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]))
+print(f"bracket depth {depth} indent to {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
 # visual indent after assert/raise/with
 prev_end = end
 @register_check
 def whitespace_before_comment(logical_line, tokens):
-r"""Separate inline comments by at least two spaces.
+"""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
+Each line of a block comment starts with a # and one or multiple
-(unless it is indented text inside the comment).
+spaces as there can be indented text inside the comment.
 Okay: x = x + 1  # Increment x
 Okay: x = x + 1    # Increment x
-Okay: # Block comment
+Okay: # Block comments:
+Okay: #  - Block comment list
+Okay: # \xa0- Block comment list
 E261: x = x + 1 # Increment x
 E262: x = x + 1  #Increment x
 E262: x = x + 1  #  Increment x
+E262: x = x + 1  # \xa0Increment x
 E265: #Block comment
 E266: ### Block comment
 """
 prev_end = (0, 0)
 for token_type, text, start, end, line in tokens:
 not (sys.version_info >= (3, 8) and
 line[found + 1] == '=')):  # assignment expression
 lambda_kw = LAMBDA_REGEX.search(line, 0, found)
 if lambda_kw:
 before = line[:lambda_kw.start()].rstrip()
-if before[-1:] == '=' and isidentifier(before[:-1].strip()):
+if before[-1:] == '=' and before[:-1].strip().isidentifier():
 yield 0, ("E731 do not assign a lambda expression, use a "
 "def")
 break
 if STARTSWITH_DEF_REGEX.match(line):
 yield 0, "E704 multiple statements on one line (def)"
 parens += 1
 elif text in ')]}':
 parens -= 1
+# 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.
 _SYMBOLIC_OPS = frozenset("()[]{},:.;@=%~") | frozenset(("...",))
 def _is_binary_operator(token_type, text):
-is_op_token = token_type == tokenize.OP
+return (
-is_conjunction = text in ['and', 'or']
+token_type == tokenize.OP or
-# NOTE(sigmavirus24): Previously the not_a_symbol check was executed
+text in {'and', 'or'}
-# conditionally. Since it is now *always* executed, text may be
+) and (
-# None. In that case we get a TypeError for `text not in str`.
+text not in _SYMBOLIC_OPS
-not_a_symbol = text and text not in _SYMBOLIC_OPS
+)
-# 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)
 def _break_around_binary_operators(tokens):
 """Private function to reduce duplication.
 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:
+if inst and inst.isidentifier() and inst not in SINGLETONS:
 return  # Allow comparison for types which are not obvious
 yield match.start(), "E721 do not compare types, use 'isinstance()'"
 @register_check
 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:
 ########################################################################
 # Helper functions
 ########################################################################
-if sys.version_info < (3,):
+def readlines(filename):
-# Python 2: implicit encoding.
+"""Read the source code."""
-def readlines(filename):
+try:
-"""Read the source code."""
+with tokenize.open(filename) as f:
-with open(filename, 'rU') as f:
 return f.readlines()
-isidentifier = re.compile(r'[a-zA-Z_]\w*$').match
+except (LookupError, SyntaxError, UnicodeError):
-stdin_get_value = sys.stdin.read
+# Fall back if file encoding is improperly declared
-else:
+with open(filename, encoding='latin-1') as f:
-# Python 3
+return f.readlines()
-def readlines(filename):
-"""Read the source code."""
+def stdin_get_value():
-try:
+"""Read the value from stdin."""
-with tokenize.open(filename) as f:
+return TextIOWrapper(sys.stdin.buffer, errors='ignore').read()
-return 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():
-"""Read the value from stdin."""
-return TextIOWrapper(sys.stdin.buffer, errors='ignore').read()
 noqa = lru_cache(512)(re.compile(r'# no(?:qa|pep8)\b', re.I).search)
 def expand_indent(line):
 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()]
+(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 instead of a/b/c/d as prefixes for patches
 ########################################################################
 # Framework to run all checks
 ########################################################################
-class Checker(object):
+class Checker:
 """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:
 elif lines is None:
 try:
 self.lines = readlines(filename)
 except OSError:
 (exc_type, exc) = sys.exc_info()[:2]
-self._io_error = '%s: %s' % (exc_type.__name__, exc)
+self._io_error = f'{exc_type.__name__}: {exc}'
 self.lines = []
 else:
 self.lines = lines
 if self.lines:
 ord0 = ord(self.lines[0][0])
 for token in self.generate_tokens():
 self.tokens.append(token)
 token_type, text = token[0:2]
 if self.verbose >= 3:
 if token[2][0] == token[3][0]:
-pos = '[%s:%s]' % (token[2][1] or '', token[3][1])
+pos = '[{}:{}]'.format(token[2][1] or '', token[3][1])
 else:
 pos = 'l.%s' % token[3][0]
 print('l.%s\t%s\t%s\t%r' %
 (token[2][0], pos, tokenize.tok_name[token[0]], text))
 if token_type == tokenize.OP:
 self.check_physical(self.lines[-1])
 self.check_logical()
 return self.report.get_file_results()
-class BaseReport(object):
+class BaseReport:
 """Collect the results of the checks."""
 print_filename = False
 def __init__(self, options):
 for line in self.get_statistics(prefix):
 print(line)
 def print_benchmark(self):
 """Print benchmark numbers."""
-print('%-7.2f %s' % (self.elapsed, 'seconds elapsed'))
+print('{:<7.2f} {}'.format(self.elapsed, 'seconds elapsed'))
 if self.elapsed:
 for key in self._benchmark_keys:
 print('%-7d %s per second (%d total)' %
 (self.counters[key] / self.elapsed, key,
 self.counters[key]))
 return super().init_file(
 filename, lines, expected, line_offset)
 def error(self, line_number, offset, text, check):
 """Report an error, according to options."""
-code = super().error(line_number, offset,
+code = super().error(line_number, offset, text, check)
-text, check)
 if code and (self.counters[code] == 1 or self._repeat):
 self._deferred_print.append(
 (line_number, offset, code, text[5:], check.__doc__))
 return code
 if line_number not in self._selected[self.filename]:
 return
 return super().error(line_number, offset, text, check)
-class StyleGuide(object):
+class StyleGuide:
 """Initialize a PEP-8 instance with few options."""
 def __init__(self, *args, **kwargs):
 # build options from the command line
 self.checker_class = kwargs.pop('checker_class', Checker)
 for subdir in sorted(dirs):
 if self.excluded(subdir, root):
 dirs.remove(subdir)
 for filename in sorted(files):
 # contain a pattern that matches?
-if ((filename_match(filename, filepatterns) and
+if (
-not self.excluded(filename, root))):
+filename_match(filename, filepatterns) and
+not self.excluded(filename, root)
+):
 runner(os.path.join(root, filename))
 def excluded(self, filename, parent=None):
 """Check if the file should be excluded.
 for opt in config.options(pycodestyle_section):
 if opt.replace('_', '-') not in parser.config_options:
 print("  unknown option '%s' ignored" % opt)
 continue
 if options.verbose > 1:
-print("  %s = %s" % (opt,
+print("  {} = {}".format(opt,
 config.get(pycodestyle_section, opt)))
 normalized_opt = opt.replace('-', '_')
 opt_type = option_list[normalized_opt]
 if opt_type in ('int', 'count'):
 value = config.getint(pycodestyle_section, opt)
 elif opt_type in ('store_true', 'store_false'):

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Plugins/CheckerPlugins/CodeStyleChecker/pycodestyle.py

src/eric7/Plugins/CheckerPlugins/CodeStyleChecker/pycodestyle.py