pycodestyle 2.12.1__tar.gz → 2.14.0__tar.gz

{pycodestyle-2.12.1 → pycodestyle-2.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pycodestyle
-Version: 2.12.1
+Version: 2.14.0
 Summary: Python style guide checker
 Home-page: https://pycodestyle.pycqa.org/
 Author: Johann C. Rocholl
@@ -13,7 +13,6 @@ Keywords: pycodestyle,pep8,PEP 8,PEP-8,PEP8
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
@@ -21,7 +20,7 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/x-rst
 License-File: LICENSE
 

{pycodestyle-2.12.1 → pycodestyle-2.14.0}/pycodestyle.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pycodestyle
-Version: 2.12.1
+Version: 2.14.0
 Summary: Python style guide checker
 Home-page: https://pycodestyle.pycqa.org/
 Author: Johann C. Rocholl
@@ -13,7 +13,6 @@ Keywords: pycodestyle,pep8,PEP 8,PEP-8,PEP8
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
@@ -21,7 +20,7 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/x-rst
 License-File: LICENSE
 

{pycodestyle-2.12.1 → pycodestyle-2.14.0}/pycodestyle.py

@@ -68,7 +68,7 @@ if (
 ):  # pragma: no cover (<py310)
     tokenize._compile = lru_cache(tokenize._compile)  # type: ignore
 
-__version__ = '2.12.1'
+__version__ = '2.14.0'
 
 DEFAULT_EXCLUDE = '.svn,CVS,.bzr,.hg,.git,__pycache__,.tox'
 DEFAULT_IGNORE = 'E121,E123,E126,E226,E24,E704,W503,W504'
@@ -135,6 +135,7 @@ 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 (
@@ -157,6 +158,13 @@ if sys.version_info >= (3, 12):  # pragma: >=3.12 cover
 else:  # pragma: <3.12 cover
     FSTRING_START = FSTRING_MIDDLE = FSTRING_END = -1
 
+if sys.version_info >= (3, 14):  # pragma: >=3.14 cover
+    TSTRING_START = tokenize.TSTRING_START
+    TSTRING_MIDDLE = tokenize.TSTRING_MIDDLE
+    TSTRING_END = tokenize.TSTRING_END
+else:  # pragma: <3.14 cover
+    TSTRING_START = TSTRING_MIDDLE = TSTRING_END = -1
+
 _checks = {'physical_line': {}, 'logical_line': {}, 'tree': {}}
 
 
@@ -233,9 +241,11 @@ def trailing_whitespace(physical_line):
     W291: spam(1) \n#
     W293: class Foo(object):\n    \n    bang = 12
     """
-    physical_line = physical_line.rstrip('\n')    # chr(10), newline
-    physical_line = physical_line.rstrip('\r')    # chr(13), carriage return
-    physical_line = physical_line.rstrip('\x0c')  # chr(12), form feed, ^L
+    # Strip these trailing characters:
+    # - chr(10), newline
+    # - 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:
@@ -694,7 +704,12 @@ def continued_indentation(logical_line, tokens, indent_level, hang_closing,
             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, FSTRING_START):
+        elif token_type in {
+                tokenize.STRING,
+                tokenize.COMMENT,
+                FSTRING_START,
+                TSTRING_START
+        }:
             indent_chances[start[1]] = str
         # visual indent after assert/raise/with
         elif not row and not depth and text in ["assert", "raise", "with"]:
@@ -783,7 +798,6 @@ def whitespace_before_parameters(logical_line, tokens):
             # 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)
@@ -871,6 +885,8 @@ def missing_whitespace(logical_line, tokens):
             brace_stack.append(text)
         elif token_type == FSTRING_START:  # pragma: >=3.12 cover
             brace_stack.append('f')
+        elif token_type == TSTRING_START:  # pragma: >=3.14 cover
+            brace_stack.append('t')
         elif token_type == tokenize.NAME and text == 'lambda':
             brace_stack.append('l')
         elif brace_stack:
@@ -878,6 +894,8 @@ def missing_whitespace(logical_line, tokens):
                 brace_stack.pop()
             elif token_type == FSTRING_END:  # pragma: >=3.12 cover
                 brace_stack.pop()
+            elif token_type == TSTRING_END:  # pragma: >=3.14 cover
+                brace_stack.pop()
             elif (
                     brace_stack[-1] == 'l' and
                     token_type == tokenize.OP and
@@ -897,6 +915,9 @@ def missing_whitespace(logical_line, tokens):
                 # 3.12+ fstring format specifier
                 elif text == ':' and brace_stack[-2:] == ['f', '{']:  # pragma: >=3.12 cover  # noqa: E501
                     pass
+                # 3.14+ tstring format specifier
+                elif text == ':' and brace_stack[-2:] == ['t', '{']:  # pragma: >=3.14 cover  # noqa: E501
+                    pass
                 # tuple (and list for some reason?)
                 elif text == ',' and next_char in ')]':
                     pass
@@ -946,7 +967,9 @@ def missing_whitespace(logical_line, tokens):
                         # allow keyword args or defaults: foo(bar=None).
                         brace_stack[-1:] == ['('] or
                         # allow python 3.8 fstring repr specifier
-                        brace_stack[-2:] == ['f', '{']
+                        brace_stack[-2:] == ['f', '{'] or
+                        # allow python 3.8 fstring repr specifier
+                        brace_stack[-2:] == ['t', '{']
                     )
             ):
                 pass
@@ -958,10 +981,8 @@ def missing_whitespace(logical_line, tokens):
                 # 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 (
-                        sys.version_info < (3, 9) or
-                        not keyword.issoftkeyword(prev_text)
-                    )
+                    prev_text not in KEYWORDS and
+                    not keyword.issoftkeyword(prev_text)
                 ):
                     need_space = None
             elif text in WS_OPTIONAL_OPERATORS:
@@ -1020,12 +1041,13 @@ def whitespace_around_named_parameter_equals(logical_line, tokens):
     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"
@@ -1043,15 +1065,23 @@ def whitespace_around_named_parameter_equals(logical_line, tokens):
                 yield (prev_end, missing_message)
         if token_type == tokenize.OP:
             if text in '([':
-                parens += 1
-            elif text in ')]':
-                parens -= 1
-            elif in_def and text == ':' and parens == 1:
+                paren_stack.append(text)
+            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 == '=':
-                if annotated_func_arg and parens == 1:
+            elif paren_stack and text == '=':
+                if (
+                        # PEP 696 defaults always use spaced-style `=`
+                        # type A[T = default] = ...
+                        # def f[T = default](): ...
+                        # class C[T = default](): ...
+                        (in_generic and paren_stack == ['[']) or
+                        (annotated_func_arg and paren_stack == ['('])
+                ):
                     require_space = True
                     if start == prev_end:
                         yield (prev_end, missing_message)
@@ -1059,7 +1089,7 @@ def whitespace_around_named_parameter_equals(logical_line, tokens):
                     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
@@ -1631,11 +1661,11 @@ def python_3000_invalid_escape_sequence(logical_line, tokens, noqa):
 
     prefixes = []
     for token_type, text, start, _, _ in tokens:
-        if token_type in {tokenize.STRING, FSTRING_START}:
+        if token_type in {tokenize.STRING, FSTRING_START, TSTRING_START}:
             # Extract string modifiers (e.g. u or r)
             prefixes.append(text[:text.index(text[-1])].lower())
 
-        if token_type in {tokenize.STRING, FSTRING_MIDDLE}:
+        if token_type in {tokenize.STRING, FSTRING_MIDDLE, TSTRING_MIDDLE}:
             if 'r' not in prefixes[-1]:
                 start_line, start_col = start
                 pos = text.find('\\')
@@ -1653,7 +1683,7 @@ def python_3000_invalid_escape_sequence(logical_line, tokens, noqa):
                         )
                     pos = text.find('\\', pos + 1)
 
-        if token_type in {tokenize.STRING, FSTRING_END}:
+        if token_type in {tokenize.STRING, FSTRING_END, TSTRING_END}:
             prefixes.pop()
 
 
@@ -1851,7 +1881,7 @@ class Checker:
         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.fstring_start = self.tstring_start = 0
         self.multiline = False  # in a multiline string?
         self.hang_closing = options.hang_closing
         self.indent_size = options.indent_size
@@ -1910,9 +1940,7 @@ class Checker:
 
     def run_check(self, check, argument_names):
         """Run a check plugin."""
-        arguments = []
-        for name in argument_names:
-            arguments.append(getattr(self, name))
+        arguments = [getattr(self, name) for name in argument_names]
         return check(*arguments)
 
     def init_checker_state(self, name, argument_names):
@@ -1948,7 +1976,7 @@ class Checker:
                 continue
             if token_type == tokenize.STRING:
                 text = mute_string(text)
-            elif token_type == FSTRING_MIDDLE:  # pragma: >=3.12 cover
+            elif token_type in {FSTRING_MIDDLE, TSTRING_MIDDLE}:  # pragma: >=3.12 cover  # noqa: E501
                 # fstring tokens are "unescaped" braces -- re-escape!
                 brace_count = text.count('{') + text.count('}')
                 text = 'x' * (len(text) + brace_count)
@@ -2040,6 +2068,8 @@ class Checker:
 
         if token.type == FSTRING_START:  # pragma: >=3.12 cover
             self.fstring_start = token.start[0]
+        elif token.type == TSTRING_START:  # pragma: >=3.14 cover
+            self.tstring_start = token.start[0]
         # a newline token ends a single physical line.
         elif _is_eol_token(token):
             # if the file does not end with a newline, the NEWLINE
@@ -2051,7 +2081,8 @@ class Checker:
                 self.check_physical(token.line)
         elif (
                 token.type == tokenize.STRING and '\n' in token.string or
-                token.type == FSTRING_END
+                token.type == FSTRING_END or
+                token.type == TSTRING_END
         ):
             # Less obviously, a string that contains newlines is a
             # multiline string, either triple-quoted or with internal
@@ -2072,6 +2103,8 @@ class Checker:
                 return
             if token.type == FSTRING_END:  # pragma: >=3.12 cover
                 start = self.fstring_start
+            elif token.type == TSTRING_END:  # pragma: >=3.12 cover
+                start = self.tstring_start
             else:
                 start = token.start[0]
             end = token.end[0]

{pycodestyle-2.12.1 → pycodestyle-2.14.0}/setup.cfg

@@ -15,7 +15,6 @@ classifiers =
 	Development Status :: 5 - Production/Stable
 	Environment :: Console
 	Intended Audience :: Developers
-	License :: OSI Approved :: MIT License
 	Operating System :: OS Independent
 	Programming Language :: Python
 	Programming Language :: Python :: 3
@@ -29,7 +28,7 @@ project_urls =
 
 [options]
 py_modules = pycodestyle
-python_requires = >=3.8
+python_requires = >=3.9
 include_package_data = True
 zip_safe = False
 

{pycodestyle-2.12.1 → pycodestyle-2.14.0}/tests/test_E901.py

@@ -23,7 +23,7 @@ def lasting(self, duration=300):
 '''
         errors = errors_from_src(src)
         if sys.version_info < (3, 12):  # pragma: <3.12 cover
-            expected = ['E122:4:1', 'E251:5:13', 'E251:5:15']
+            expected = ['E122:4:1']
         else:  # pragma: >=3.12 cover
-            expected = ['E122:4:1', 'E251:5:13', 'E251:5:15', 'E901:5:1']  # noqa: E501
+            expected = ['E122:4:1', 'E901:5:1']  # noqa: E501
         self.assertEqual(errors, expected)