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

-:96826d133cf0
+:d900e60c1eaf
 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.12.1-eric'
+__version__ = '2.13.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':  # pragma: win32 cover
 'pylint': '%(path)s:%(row)d: [%(code)s] %(text)s',
 }
 PyCF_ONLY_AST = 1024
 SINGLETONS = frozenset(['False', 'None', 'True'])
-KEYWORDS = frozenset(keyword.kwlist + ['print', 'async']) - SINGLETONS
+KEYWORDS = frozenset(keyword.kwlist + ['print']) - SINGLETONS
 UNARY_OPERATORS = frozenset(['>>', '**', '*', '+', '-'])
 ARITHMETIC_OP = frozenset(['**', '*', '/', '//', '+', '-', '@'])
 WS_OPTIONAL_OPERATORS = ARITHMETIC_OP.union(['^', '&', '|', '<<', '>>', '%'])
 WS_NEEDED_OPERATORS = frozenset([
 '**=', '*=', '/=', '//=', '+=', '-=', '!=', '<', '>',
 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+))? @@.*$')
 STARTSWITH_DEF_REGEX = re.compile(r'^(async\s+def|def)\b')
+STARTSWITH_GENERIC_REGEX = re.compile(r'^(async\s+def|def|class|type)\s+\w+\[')
 STARTSWITH_TOP_LEVEL_REGEX = re.compile(r'^(async\s+def\s+|def\s+|class\s+|@)')
 STARTSWITH_INDENT_STATEMENT_REGEX = re.compile(
 r'^\s*({})\b'.format('|'.join(s.replace(' ', r'\s+') for s in (
 'def', 'async def',
 'for', 'async for',
 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
+# Strip these trailing characters:
-physical_line = physical_line.rstrip('\r')    # chr(13), carriage return
+# - chr(10), newline
-physical_line = physical_line.rstrip('\x0c')  # chr(12), form feed, ^L
+# - chr(13), carriage return
+# - chr(12), form feed, ^L
+physical_line = physical_line.rstrip('\n\r\x0c')
 stripped = physical_line.rstrip(' \t\v')
 if physical_line != stripped:
 if stripped:
 return len(stripped), "W291 trailing whitespace"
 else:
 # 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) and
 (
-sys.version_info < (3, 9) or
 # 3.12+: type is a soft keyword but no braces after
 prev_text == 'type' or
 not keyword.issoftkeyword(prev_text)
 )
 ):
 # Check if the operator is used as a binary operator
 # Allow unary operators: -123, -x, +1.
 # Allow argument unpacking: foo(*args, **kwargs).
 if prev_type == tokenize.OP and prev_text in '}])' or (
 prev_type != tokenize.OP and
-prev_text not in KEYWORDS and (
+prev_text not in KEYWORDS and
-sys.version_info < (3, 9) or
+not keyword.issoftkeyword(prev_text)
-not keyword.issoftkeyword(prev_text)
-)
 ):
 need_space = None
 elif text in WS_OPTIONAL_OPERATORS:
 need_space = None
 E251: def complex(real, imag = 0.0):
 E251: return magic(r = real, i = imag)
 E252: def complex(real, image: float=0.0):
 """
-parens = 0
+paren_stack = []
 no_space = False
 require_space = False
 prev_end = None
 annotated_func_arg = False
 in_def = bool(STARTSWITH_DEF_REGEX.match(logical_line))
+in_generic = bool(STARTSWITH_GENERIC_REGEX.match(logical_line))
 message = "E251 unexpected spaces around keyword / parameter equals"
 missing_message = "E252 missing whitespace around parameter equals"
 for token_type, text, start, end, line in tokens:
 require_space = False
 if start == prev_end:
 yield (prev_end, missing_message)
 if token_type == tokenize.OP:
 if text in '([':
-parens += 1
+paren_stack.append(text)
-elif text in ')]':
+# PEP 696 defaults always use spaced-style `=`
-parens -= 1
+# type A[T = default] = ...
-elif in_def and text == ':' and parens == 1:
+# def f[T = default](): ...
+# class C[T = default](): ...
+if in_generic and paren_stack == ['[']:
+annotated_func_arg = True
+elif text in ')]' and paren_stack:
+paren_stack.pop()
+# def f(arg: tp = default): ...
+elif text == ':' and in_def and paren_stack == ['(']:
 annotated_func_arg = True
-elif parens == 1 and text == ',':
+elif len(paren_stack) == 1 and text == ',':
 annotated_func_arg = False
-elif parens and text == '=':
+elif paren_stack and text == '=':
-if annotated_func_arg and parens == 1:
+if annotated_func_arg and len(paren_stack) == 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)
-if not parens:
+if not paren_stack:
 annotated_func_arg = False
 prev_end = end
 self.indent_char = line[0]
 return line
 def run_check(self, check, argument_names):
 """Run a check plugin."""
-arguments = []
+arguments = [getattr(self, name) for name in argument_names]
-for name in argument_names:
-arguments.append(getattr(self, name))
 return check(*arguments)
 def init_checker_state(self, name, argument_names):
 """Prepare custom state for the specific checker plugin."""
 if 'checker_state' in argument_names:

Mercurial Repositories > eric / file comparison

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

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