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

-:6285e8374d99
+:04e80d1aaebf
 # - added code for eric integration
 #
 # Copyright (c) 2011 - 2021 Detlev Offenbach <detlev@die-offenbachs.de>
 #
+import bisect
 import inspect
 import keyword
 import os
 import re
 import sys
 import time
 import tokenize
 import warnings
-import bisect
 try:
 from functools import lru_cache
 except ImportError:
 def lru_cache(maxsize=128):  # noqa as it's a fake implementation.
 from configparser import RawConfigParser
 from io import TextIOWrapper
 except ImportError:
 from ConfigParser import RawConfigParser            # __IGNORE_WARNING__
-__version__ = '2.7.0-eric'
+# this is a performance hack.  see https://bugs.python.org/issue43014
+if (
+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'
 DEFAULT_EXCLUDE = '.svn,CVS,.bzr,.hg,.git,__pycache__,.tox'
 DEFAULT_IGNORE = 'E121,E123,E126,E226,E24,E704,W503,W504'
 try:
 if sys.platform == 'win32':
 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'[\[({] | [\]}),;]| :(?!=)')
+EXTRANEOUS_WHITESPACE_REGEX = re.compile(r'[\[({][ \t]|[ \t][\]}),;:](?!=)')
 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(?<!is\s)(not)\s+[^][)(}{ ]+\s+'
 r'(in|is)\s')
 'with', 'async with',
 'class',
 'while',
 )))
 )
-DUNDER_REGEX = re.compile(r'^__([^\s]+)__ = ')
+DUNDER_REGEX = re.compile(r"^__([^\s]+)__(?::\s*[a-zA-Z.0-9_\[\]\"]+)? = ")
+BLANK_EXCEPT_REGEX = re.compile(r"except\s*:")
 _checks = {'physical_line': {}, 'logical_line': {}, 'tree': {}}
 def _get_parameters(function):
 line = logical_line
 for match in EXTRANEOUS_WHITESPACE_REGEX.finditer(line):
 text = match.group()
 char = text.strip()
 found = match.start()
-if text == char + ' ':
+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
 @register_check
 def indentation(logical_line, previous_logical, indent_char,
 indent_level, previous_indent_level,
-indent_size, indent_size_str):
+indent_size):
 r"""Use indent_size (PEP8 says 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.
 c = 0 if logical_line else 3
 tmpl = "E11%d %s" if logical_line else "E11%d %s (comment)"
 if indent_level % indent_size:
 yield 0, tmpl % (
 1 + c,
-"indentation is not a multiple of " + indent_size_str,
+"indentation is not a multiple of " + str(indent_size),
 )
 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 % (7, 'over-indented')
 @register_check
 def continued_indentation(logical_line, tokens, indent_level, hang_closing,
-indent_char, indent_size, indent_size_str, noqa,
+indent_char, indent_size, noqa, verbose):
-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.
 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
+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)):
+not keyword.iskeyword(prev_text) and
+# 'match' and 'case' are only soft keywords
+(
+sys.version_info < (3, 9) or
+not keyword.issoftkeyword(prev_text)
+)
+):
 yield prev_end, "E211 whitespace before '%s'", text
 prev_type = token_type
 prev_text = text
 prev_end = end
 elif (
 # def f(a, /, b):
 #           ^
 # def f(a, b, /):
 #              ^
-prev_text == '/' and text in {',', ')'} or
+# f = lambda a, /:
+#                ^
+prev_text == '/' and text in {',', ')', ':'} or
 # def f(a, b, /):
 #               ^
 prev_text == ')' and text == ':'
 ):
 # Tolerate the "/" operator in function definition
 need_space = True
 elif text in UNARY_OPERATORS:
 # 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
+if prev_type == tokenize.OP and prev_text in '}])' or (
-else prev_text not in KEYWORDS):
+prev_type != tokenize.OP and
+prev_text not in KEYWORDS and (
+sys.version_info < (3, 9) or
+not keyword.issoftkeyword(prev_text)
+)
+):
 need_space = None
 elif text in WS_OPTIONAL_OPERATORS:
 need_space = None
 if need_space is 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 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 noqa:
-if match:
+return
+for match in COMPARE_SINGLETON_REGEX.finditer(logical_line):
 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',):
 E722: except:
 """
 if noqa:
 return
-regex = re.compile(r"except\s*:")
+match = BLANK_EXCEPT_REGEX.match(logical_line)
-match = regex.match(logical_line)
 if match:
 yield match.start(), "E722 do not use bare 'except'"
 @register_check
 self.max_doc_length = options.max_doc_length
 self.indent_size = options.indent_size
 self.multiline = False  # in a multiline string?
 self.hang_closing = options.hang_closing
 self.indent_size = options.indent_size
-self.indent_size_str = ({2: 'two', 4: 'four', 8: 'eight'}
-.get(self.indent_size, str(self.indent_size)))
 self.verbose = options.verbose
 self.filename = filename
 # Dictionary where a checker can store its custom state.
 self._checker_states = {}
 if filename is None:

Mercurial Repositories > eric / file comparison

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

eric7/Plugins/CheckerPlugins/CodeStyleChecker/pycodestyle.py