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

-:3c56c81a70be
+:2b3802c3c6d2
 #
 # Copyright (c) 2011 - 2022 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 import bisect
+import configparser
 import inspect
+import io
 import keyword
 import os
 import re
 import sys
 import time
 from fnmatch import fnmatch
 from functools import lru_cache
 from optparse import OptionParser
-try:
-from configparser import RawConfigParser
-from io import TextIOWrapper
-except ImportError:
-from ConfigParser import RawConfigParser            # __IGNORE_WARNING__
 # 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.9.1-eric'
+__version__ = '2.10.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':
 def missing_whitespace(logical_line):
 r"""Each comma, semicolon or colon should be followed by whitespace.
 Okay: [a, b]
 Okay: (3,)
+Okay: a[3,] = 1
 Okay: a[1:4]
 Okay: a[:4]
 Okay: a[1:]
 Okay: a[1:4:2]
 E231: ['a','b']
 if char in ',;:' and next_char 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 next_char == ')':
+if char == ',' and next_char in ')]':
 continue  # Allow tuple with only one element: (3,)
 if char == ':' and next_char == '=' and sys.version_info >= (3, 8):
 continue  # Allow assignment expression
 yield index, "E231 missing whitespace after '%s'", char
 E741: l = 0
 E741: O = 123
 E741: I = 42
 Variables can be bound in several other contexts, including class
-and function definitions, 'global' and 'nonlocal' statements,
+and function definitions, lambda functions, 'global' and 'nonlocal'
-exception handlers, and 'with' and 'for' statements.
+statements, exception handlers, and 'with' and 'for' statements.
 In addition, we have a special handling for function parameters.
 Okay: except AttributeError as o:
 Okay: with lock as L:
 Okay: foo(l=12)
+Okay: foo(l=I)
 Okay: for a in foo(l=12):
+Okay: lambda arg: arg * l
+Okay: lambda a=l[I:5]: None
+Okay: lambda x=a.I: None
+Okay: if l >= 12:
 E741: except AttributeError as O:
 E741: with lock as l:
 E741: global I
 E741: nonlocal l
 E741: def foo(l):
 E741: def foo(l=12):
 E741: l = foo(l=12)
 E741: for l in range(10):
+E741: [l for l in lines if l]
+E741: lambda l: None
+E741: lambda a=x[1:5], l: None
+E741: lambda **l:
+E741: def f(**l):
 E742: class I(object):
 E743: def l(x):
 """
-is_func_def = False  # Set to true if 'def' is found
+func_depth = None  # set to brace depth if 'def' or 'lambda' is found
-parameter_parentheses_level = 0
+seen_colon = False  # set to true if we're done with function parameters
+brace_depth = 0
 idents_to_avoid = ('l', 'O', 'I')
 prev_type, prev_text, prev_start, prev_end, __ = tokens[0]
-for token_type, text, start, end, line in tokens[1:]:
+for index in range(1, len(tokens)):
+token_type, text, start, end, line = tokens[index]
 ident = pos = None
 # find function definitions
-if prev_text == 'def':
+if prev_text in {'def', 'lambda'}:
-is_func_def = True
+func_depth = brace_depth
+seen_colon = False
+elif (
+func_depth is not None and
+text == ':' and
+brace_depth == func_depth
+):
+seen_colon = True
 # update parameter parentheses level
-if parameter_parentheses_level == 0 and \
+if text in '([{':
-prev_type == tokenize.NAME and \
+brace_depth += 1
-token_type == tokenize.OP and text == '(':
+elif text in ')]}':
-parameter_parentheses_level = 1
+brace_depth -= 1
-elif parameter_parentheses_level > 0 and \
-token_type == tokenize.OP:
-if text == '(':
-parameter_parentheses_level += 1
-elif text == ')':
-parameter_parentheses_level -= 1
 # identifiers on the lhs of an assignment operator
-if token_type == tokenize.OP and '=' in text and \
+if text == ':=' or (text == '=' and brace_depth == 0):
-parameter_parentheses_level == 0:
 if prev_text in idents_to_avoid:
 ident = prev_text
 pos = prev_start
 # identifiers bound to values with 'as', 'for',
 # 'global', or 'nonlocal'
 if prev_text in ('as', 'for', 'global', 'nonlocal'):
 if text in idents_to_avoid:
 ident = text
 pos = start
-# function parameter definitions
+# function / lambda parameter definitions
-if is_func_def:
+if (
-if text in idents_to_avoid:
+func_depth is not None and
-ident = text
+not seen_colon and
-pos = start
+index < len(tokens) - 1 and tokens[index + 1][1] in ':,=)' and
+prev_text in {'lambda', ',', '*', '**', '('} and
+text in idents_to_avoid
+):
+ident = text
+pos = start
 if prev_text == 'class':
 if text in idents_to_avoid:
 yield start, "E742 ambiguous class definition '%s'", text
 if prev_text == 'def':
 if text in idents_to_avoid:
 yield start, "E743 ambiguous function definition '%s'", text
 if ident:
 yield pos, "E741 ambiguous variable name '%s'", ident
-prev_type = token_type
 prev_text = text
 prev_start = start
 @register_check
 with open(filename, encoding='latin-1') as f:
 return f.readlines()
 def stdin_get_value():
 """Read the value from stdin."""
-return TextIOWrapper(sys.stdin.buffer, errors='ignore').read()
+return io.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):
 Otherwise, the user configuration (~/.config/pycodestyle) and any
 local configurations in the current directory or above will be
 merged together (in that order) using the read method of
 ConfigParser.
 """
-config = RawConfigParser()
+config = configparser.RawConfigParser()
 cli_conf = options.config
 local_dir = os.curdir

Mercurial Repositories > eric / file comparison

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

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