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

-:0a62a4bf749c
+:8312e0e76795
 # 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
+tokenize._compile = lru_cache(tokenize._compile)  # type: ignore
-__version__ = '2.10.0-eric'
+__version__ = '2.11.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':
+if sys.platform == 'win32':  # pragma: win32 cover
 USER_CONFIG = os.path.expanduser(r'~\.pycodestyle')
-else:
+else:  # pragma: win32 no cover
 USER_CONFIG = os.path.join(
 os.getenv('XDG_CONFIG_HOME') or os.path.expanduser('~/.config'),
 'pycodestyle'
 )
 except ImportError:
 USER_CONFIG = None
 PROJECT_CONFIG = ('setup.cfg', 'tox.ini')
-TESTSUITE_PATH = os.path.join(os.path.dirname(__file__), 'testsuite')
 MAX_LINE_LENGTH = 79
 # Number of blank lines between various code parts.
 BLANK_LINES_CONFIG = {
 # Top level class and function.
 'top_level': 2,
 SINGLETONS = frozenset(['False', 'None', 'True'])
 KEYWORDS = frozenset(keyword.kwlist + ['print', 'async']) - SINGLETONS
 UNARY_OPERATORS = frozenset(['>>', '**', '*', '+', '-'])
 ARITHMETIC_OP = frozenset(['**', '*', '/', '//', '+', '-', '@'])
 WS_OPTIONAL_OPERATORS = ARITHMETIC_OP.union(['^', '&', '|', '<<', '>>', '%'])
-ASSIGNMENT_EXPRESSION_OP = [':='] if sys.version_info >= (3, 8) else []
 WS_NEEDED_OPERATORS = frozenset([
-'**=', '*=', '/=', '//=', '+=', '-=', '!=', '<>', '<', '>',
+'**=', '*=', '/=', '//=', '+=', '-=', '!=', '<', '>',
 '%=', '^=', '&=', '|=', '==', '<=', '>=', '<<=', '>>=', '=',
-'and', 'in', 'is', 'or', '->'] +
+'and', 'in', 'is', 'or', '->', ':='])
-ASSIGNMENT_EXPRESSION_OP)
 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']
 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'[\[({][ \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')
-COMPARE_TYPE_REGEX = re.compile(r'(?:[=!]=|is(?:\s+not)?)\s+type(?:s.\w+Type'
+COMPARE_TYPE_REGEX = re.compile(
-r'|\s*\(\s*([^)]*[^ )])\s*\))')
+r'[=!]=\s+type(?:\s*\(\s*([^)]*[^ )])\s*\))'
+r'|\btype(?:\s*\(\s*([^)]*[^ )])\s*\))\s+[=!]='
+)
 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')
 )))
 )
 DUNDER_REGEX = re.compile(r"^__([^\s]+)__(?::\s*[a-zA-Z.0-9_\[\]\"]+)? = ")
 BLANK_EXCEPT_REGEX = re.compile(r"except\s*:")
+if sys.version_info >= (3, 12):  # pragma: >=3.12 cover
+FSTRING_START = tokenize.FSTRING_START
+FSTRING_MIDDLE = tokenize.FSTRING_MIDDLE
+FSTRING_END = tokenize.FSTRING_END
+else:  # pragma: <3.12 cover
+FSTRING_START = FSTRING_MIDDLE = FSTRING_END = -1
 _checks = {'physical_line': {}, 'logical_line': {}, 'tree': {}}
 def _get_parameters(function):
 return [parameter.name
 the -t option, it issues warnings about code that illegally mixes
 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
-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"
 # appear e.g. as "if x is None:", and async/await, which were
 # valid identifier names in old Python versions.
 if (tok0.end == tok1.start and
 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.
-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']
-E231: foo(bar,baz)
-E231: [{'a':'b'}]
-"""
-line = logical_line
-for index in range(len(line) - 1):
-char = line[index]
-next_char = line[index + 1]
-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 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
 @register_check
 def indentation(logical_line, previous_logical, indent_char,
 indent_level, previous_indent_level,
 indent[depth] = start[1]
 indent_chances[start[1]] = True
 if verbose >= 4:
 print(f"bracket depth {depth} indent to {start[1]}")
 # deal with implicit string concatenation
-elif (token_type in (tokenize.STRING, tokenize.COMMENT) or
+elif token_type in (tokenize.STRING, tokenize.COMMENT, FSTRING_START):
-text in ('u', 'ur', 'b', 'br')):
 indent_chances[start[1]] = str
 # visual indent after assert/raise/with
 elif not row and not depth and text in ["assert", "raise", "with"]:
 indent_chances[end[1] + 1] = True
 # special case for the "if" statement because len("if (") == 4
 (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) and
-# 'match' and 'case' are only soft keywords
 (
 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)
 )
 ):
 yield prev_end, "E211 whitespace before '%s'", text
 prev_type = token_type
 elif len(after) > 1:
 yield match.start(2), "E222 multiple spaces after operator"
 @register_check
-def missing_whitespace_around_operator(logical_line, tokens):
+def missing_whitespace(logical_line, tokens):
-r"""Surround operators with a single space on either side.
+r"""Surround operators with the correct amount of whitespace.
 - Always surround these binary operators with a single space on
 either side: assignment (=), augmented assignment (+=, -= etc.),
 comparisons (==, <, >, !=, <=, >=, in, not in, is, is not),
 Booleans (and, or, not).
+- Each comma, semicolon or colon should be followed by whitespace.
 - If operators with different priorities are used, consider adding
 whitespace around the operators with the lowest priorities.
 Okay: i = i + 1
 Okay: x = x * 2 - 1
 Okay: hypot2 = x * x + y * y
 Okay: c = (a + b) * (a - b)
 Okay: foo(bar, key='word', *args, **kwargs)
 Okay: alpha[:-i]
+Okay: [a, b]
+Okay: (3,)
+Okay: a[3,] = 1
+Okay: a[1:4]
+Okay: a[:4]
+Okay: a[1:]
+Okay: a[1:4:2]
 E225: i=i+1
 E225: submitted +=1
 E225: x = x /2 - 1
 E225: z = x **y
 E225: z = 1and 1
 E226: c = (a+b) * (a-b)
 E226: hypot2 = x*x + y*y
 E227: c = a|b
 E228: msg = fmt%(errno, errmsg)
-"""
+E231: ['a','b']
-parens = 0
+E231: foo(bar,baz)
+E231: [{'a':'b'}]
+"""
 need_space = False
 prev_type = tokenize.OP
 prev_text = prev_end = None
 operator_types = (tokenize.OP, tokenize.NAME)
+brace_stack = []
 for token_type, text, start, end, line in tokens:
+if token_type == tokenize.OP and text in {'[', '(', '{'}:
+brace_stack.append(text)
+elif token_type == FSTRING_START:  # pragma: >=3.12 cover
+brace_stack.append('f')
+elif token_type == tokenize.NAME and text == 'lambda':
+brace_stack.append('l')
+elif brace_stack:
+if token_type == tokenize.OP and text in {']', ')', '}'}:
+brace_stack.pop()
+elif token_type == FSTRING_END:  # pragma: >=3.12 cover
+brace_stack.pop()
+elif (
+brace_stack[-1] == 'l' and
+token_type == tokenize.OP and
+text == ':'
+):
+brace_stack.pop()
 if token_type in SKIP_COMMENTS:
 continue
-if text in ('(', 'lambda'):
-parens += 1
+if token_type == tokenize.OP and text in {',', ';', ':'}:
-elif text == ')':
+next_char = line[end[1]:end[1] + 1]
-parens -= 1
+if next_char not in WHITESPACE and next_char not in '\r\n':
+# slice
+if text == ':' and brace_stack[-1:] == ['[']:
+pass
+# 3.12+ fstring format specifier
+elif text == ':' and brace_stack[-2:] == ['f', '{']:  # pragma: >=3.12 cover  # noqa: E501
+pass
+# tuple (and list for some reason?)
+elif text == ',' and next_char in ')]':
+pass
+else:
+yield start, f'E231 missing whitespace after {text!r}', text
 if need_space:
 if start != prev_end:
 # Found a (probably) needed space
 if need_space is not True and not need_space[1]:
 yield (need_space[0],
 "E225 missing whitespace around operator")
 need_space = False
-elif text == '>' and prev_text in ('<', '-'):
-# Tolerate the "<>" operator, even if running Python 3
-# Deal with Python 3's annotated return value "->"
-pass
 elif (
 # def f(a, /, b):
 #           ^
 # def f(a, b, /):
 #              ^
 code, optype = 'E227', 'bitwise or shift'
 yield (need_space[0], "%s missing whitespace "
 "around %s operator" % (code, optype))
 need_space = False
 elif token_type in operator_types and prev_end is not None:
-if text == '=' and parens:
+if (
-# Allow keyword args or defaults: foo(bar=None).
+text == '=' and (
+# allow lambda default args: lambda x=None: None
+brace_stack[-1:] == ['l'] or
+# allow keyword args or defaults: foo(bar=None).
+brace_stack[-1:] == ['('] or
+# allow python 3.8 fstring repr specifier
+brace_stack[-2:] == ['f', '{']
+)
+):
 pass
 elif text in WS_NEEDED_OPERATORS:
 need_space = True
 elif text in UNARY_OPERATORS:
 # Check if the operator is used as a binary operator
 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
-Okay:
-try:\n\timport x\nexcept ImportError:\n\tpass\nelse:\n\tpass\nimport y
-Okay:
-try:\n\timport x\nexcept ImportError:\n\tpass\nfinally:\n\tpass\nimport y
 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
 found = line.find(':')
 prev_found = 0
 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)
+if (
-counts['['] <= counts[']'] and   # [1:2] (slice)
+counts['{'] <= counts['}'] and  # {'a': 1} (dict)
-counts['('] <= counts[')']) and  # (annotation)
+counts['['] <= counts[']'] and  # [1:2] (slice)
-not (sys.version_info >= (3, 8) and
+counts['('] <= counts[')'] and  # (annotation)
-line[found + 1] == '=')):  # assignment expression
+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 before[:-1].strip().isidentifier():
 yield 0, ("E731 do not assign a lambda expression, use a "
 r"""Object type comparisons should always use isinstance().
 Do not compare types directly.
 Okay: if isinstance(obj, int):
-E721: if type(obj) is type(1):
+Okay: if type(obj) is int:
+E721: if type(obj) == type(1):
-When checking if an object is a string, keep in mind that it might
-be a unicode string too! In Python 2.3, str and unicode have a
-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)
 if match and not noqa:
 inst = match.group(1)
 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()'"
+yield (
+match.start(),
+"E721 do not compare types, for exact checks use `is` / `is not`, "
+"for instance checks use `isinstance()`",
+)
 @register_check
 def bare_except(logical_line, noqa):
 r"""When catching exceptions, mention specific exceptions when
 prev_text = text
 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.
-Okay: if "alph" in d:\n    print d["alph"]
-W601: assert d.has_key('alph')
-"""
-pos = logical_line.find('.has_key(')
-if pos > -1 and not noqa:
-yield pos, "W601 .has_key() is deprecated, use 'in'"
-@register_check
-def python_3000_raise_comma(logical_line):
-r"""When raising an exception, use "raise ValueError('message')".
-The older form is removed in Python 3.
-Okay: raise DummyError("Message")
-W602: raise DummyError, "Message"
-"""
-match = RAISE_COMMA_REGEX.match(logical_line)
-if match and not RERAISE_COMMA_REGEX.match(logical_line):
-yield match.end() - 1, "W602 deprecated form of raising exception"
-@register_check
-def python_3000_not_equal(logical_line):
-r"""New code should always use != instead of <>.
-The older syntax is removed in Python 3.
-Okay: if a != 'no':
-W603: if a <> 'no':
-"""
-pos = logical_line.find('<>')
-if pos > -1:
-yield pos, "W603 '<>' is deprecated, use '!='"
-@register_check
-def python_3000_backticks(logical_line):
-r"""Use repr() instead of backticks in Python 3.
-Okay: val = repr(1 + 2)
-W604: val = `1 + 2`
-"""
-pos = logical_line.find('`')
-if pos > -1:
-yield pos, "W604 backticks are deprecated, use 'repr()'"
-@register_check
 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$'
 'N',
 'u',
 'U',
 ]
-for token_type, text, start, end, line in tokens:
+prefixes = []
-if token_type == tokenize.STRING:
+for token_type, text, start, _, _ in tokens:
-start_line, start_col = start
+if token_type in {tokenize.STRING, FSTRING_START}:
-quote = text[-3:] if text[-3:] in ('"""', "'''") else text[-1]
 # Extract string modifiers (e.g. u or r)
-quote_pos = text.index(quote)
+prefixes.append(text[:text.index(text[-1])].lower())
-prefix = text[:quote_pos].lower()
-start = quote_pos + len(quote)
+if token_type in {tokenize.STRING, FSTRING_MIDDLE}:
-string = text[start:-len(quote)]
+if 'r' not in prefixes[-1]:
+start_line, start_col = start
-if 'r' not in prefix:
+pos = text.find('\\')
-pos = string.find('\\')
 while pos >= 0:
 pos += 1
-if string[pos] not in valid:
+if text[pos] not in valid:
-line = start_line + string.count('\n', 0, pos)
+line = start_line + text.count('\n', 0, pos)
 if line == start_line:
-col = start_col + len(prefix) + len(quote) + pos
+col = start_col + pos
 else:
-col = pos - string.rfind('\n', 0, pos) - 1
+col = pos - text.rfind('\n', 0, pos) - 1
 yield (
 (line, col - 1),
-"W605 invalid escape sequence '\\%s'",
+f"W605 invalid escape sequence '\\{text[pos]}'",
-string[pos],
+text[pos],
 )
-pos = string.find('\\', pos + 1)
+pos = text.find('\\', pos + 1)
+if token_type in {tokenize.STRING, FSTRING_END}:
-@register_check
+prefixes.pop()
-def python_3000_async_await_keywords(logical_line, tokens):
-"""'async' and 'await' are reserved keywords starting at Python 3.7.
-W606: async = 42
-W606: await = 42
-Okay: async def read(db):\n    data = await db.fetch('SELECT ...')
-"""
-# The Python tokenize library before Python 3.5 recognizes
-# async/await as a NAME token. Therefore, use a state machine to
-# 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 for async/await names.
-state = None
-else:
-error = True
-elif state[0] == 'await':
-if token_type == tokenize.NAME:
-# 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 "
-"Python 3.7",
-)
-state = None
-# Last token
-if state is not None:
-yield (
-state[1],
-"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):
 def expand_indent(line):
 r"""Return the amount of indentation.
 Tabs are expanded to the next multiple of 8.
->>> expand_indent('    ')
-4
->>> expand_indent('\t')
-8
->>> expand_indent('       \t')
-8
->>> expand_indent('        \t')
-16
 """
 line = line.rstrip('\n\r')
 if '\t' not in line:
 return len(line) - len(line.lstrip())
 result = 0
 break
 return result
 def mute_string(text):
-"""Replace contents with 'xxx' to prevent syntax matching.
+"""Replace contents with 'xxx' to prevent syntax matching."""
->>> mute_string('"abc"')
-'"xxx"'
->>> mute_string("'''abc'''")
-"'''xxx'''"
->>> mute_string("r'abc'")
-"r'xxx'"
-"""
 # String modifiers (e.g. u or r)
 start = text.index(text[-1]) + 1
 end = len(text) - 1
 # Triple quotes
 if text[-3:] in ('"""', "'''"):
 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.indent_size = options.indent_size
+self.fstring_start = 0
 self.multiline = False  # in a multiline string?
 self.hang_closing = options.hang_closing
 self.indent_size = options.indent_size
 self.verbose = options.verbose
 self.filename = filename
 if token_type == tokenize.COMMENT:
 comments.append(text)
 continue
 if token_type == tokenize.STRING:
 text = mute_string(text)
+elif token_type == FSTRING_MIDDLE:  # pragma: >=3.12 cover
+text = 'x' * len(text)
 if prev_row:
 (start_row, start_col) = start
 if prev_row != start_row:    # different row
 prev_text = self.lines[prev_row - 1][prev_col - 1]
 if prev_text == ',' or (prev_text not in '{[(' and
 def maybe_check_physical(self, token, prev_physical):
 """If appropriate for token, check current physical line(s)."""
 # Called after every token, but act only on end of line.
+if token.type == FSTRING_START:  # pragma: >=3.12 cover
+self.fstring_start = token.start[0]
 # a newline token ends a single physical line.
-if _is_eol_token(token):
+elif _is_eol_token(token):
 # if the file does not end with a newline, the NEWLINE
 # token is inserted by the parser, but it does not contain
 # the previous physical line in `token[4]`
-if token[4] == '':
+if token.line == '':
 self.check_physical(prev_physical)
 else:
-self.check_physical(token[4])
+self.check_physical(token.line)
-elif token[0] == tokenize.STRING and '\n' in token[1]:
+elif (
+token.type == tokenize.STRING and '\n' in token.string or
+token.type == FSTRING_END
+):
 # 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 string *except* for the last one: its newline is
 # outside of the multiline string, so we consider it a
 #   contains the magical "# noqa" comment, we disable all
 #   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]):
+if noqa(token.line):
 return
+if token.type == FSTRING_END:  # pragma: >=3.12 cover
+start = self.fstring_start
+else:
+start = token.start[0]
+end = token.end[0]
 self.multiline = True
-self.line_number = token[2][0]
+self.line_number = start
-_, src, (_, offset), _, _ = token
+for line_number in range(start, end):
-src = self.lines[self.line_number - 1][:offset] + src
+self.check_physical(self.lines[line_number - 1] + '\n')
-for line in src.split('\n')[:-1]:
-self.check_physical(line + '\n')
 self.line_number += 1
 self.multiline = False
 def check_all(self, expected=None, line_offset=0):
 """Run all checks on the input file."""
 if not options.reporter:
 options.reporter = BaseReport if options.quiet else StandardReport
 options.select = tuple(options.select or ())
-#        if not (options.select or options.ignore or
+#        if not (options.select or options.ignore) and DEFAULT_IGNORE:
-#                options.testsuite or options.doctest) and DEFAULT_IGNORE:
 #            # The default choice: ignore controversial checks
 #            options.ignore = tuple(DEFAULT_IGNORE.split(','))
 #        else:
-#            # Ignore all checks which are not explicitly selected or all if no
+#            # Ignore all checks which are not explicitly selected
 #            options.ignore = ('',) if options.select else tuple(options.ignore)
-# check is ignored or explicitly selected
 options.ignore = ('',) if options.select else tuple(options.ignore)
 options.benchmark_keys = BENCHMARK_KEYS[:]
 options.ignore_code = self.ignore_code
 options.physical_checks = self.get_checks('physical_line')
 options.logical_checks = self.get_checks('logical_line')
 help="set the error format [default|pylint|<custom>]")
 parser.add_option('--diff', action='store_true',
 help="report changes only within line number ranges in "
 "the unified diff received on STDIN")
 group = parser.add_option_group("Testing Options")
-if os.path.exists(TESTSUITE_PATH):
-group.add_option('--testsuite', metavar='dir',
-help="run regression tests from dir")
-group.add_option('--doctest', action='store_true',
-help="run doctest on myself")
 group.add_option('--benchmark', action='store_true',
 help="measure processing speed")
 return parser
 value = normalize_paths(value, local_dir)
 setattr(new_options, normalized_opt, value)
 # Third, overwrite with the command-line options
 (options, __) = parser.parse_args(arglist, values=new_options)
-options.doctest = options.testsuite = False
 return options
 def process_options(arglist=None, parse_argv=False, config_file=None,
 parser=None, verbose=None):
 # If explicitly specified verbosity, override any `-v` CLI flag
 if verbose is not None:
 options.verbose = verbose
-if options.ensure_value('testsuite', False):
+if parse_argv and not args:
-args.append(options.testsuite)
+if options.diff or any(os.path.exists(name)
-elif not options.ensure_value('doctest', False):
+for name in PROJECT_CONFIG):
-if parse_argv and not args:
+args = ['.']
-if options.diff or any(os.path.exists(name)
+else:
-for name in PROJECT_CONFIG):
+parser.error('input not specified')
-args = ['.']
+options = read_config(options, args, arglist, parser)
-else:
+options.reporter = parse_argv and options.quiet == 1 and FileReport
-parser.error('input not specified')
-options = read_config(options, args, arglist, parser)
-options.reporter = parse_argv and options.quiet == 1 and FileReport
 options.filename = _parse_multi_options(options.filename)
 options.exclude = normalize_paths(options.exclude)
 options.select = _parse_multi_options(options.select)
 options.ignore = _parse_multi_options(options.ignore)
 pass    # not supported on Windows
 style_guide = StyleGuide(parse_argv=True)
 options = style_guide.options
-if options.doctest or options.testsuite:
+report = style_guide.check_files()
-from testsuite.support import run_tests
-report = run_tests(style_guide)
-else:
-report = style_guide.check_files()
 if options.statistics:
 report.print_statistics()
 if options.benchmark:
 report.print_benchmark()
-if options.testsuite and not options.quiet:
-report.print_results()
 if report.total_errors:
 if options.count:
 sys.stderr.write(str(report.total_errors) + '\n')
 sys.exit(1)

Mercurial Repositories > eric / file comparison

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

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