---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | import re
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | from dataclasses import dataclass
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | from functools import lru_cache
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | from typing import Collection, Final, Iterator, List, Optional, Tuple, Union
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | 
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | from black.mode import Mode, Preview
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | from black.nodes import (
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- |     CLOSING_BRACKETS,
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- |     STANDALONE_COMMENT,
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- |     WHITESPACE,
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- |     container_of,
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- |     first_leaf_of,
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- |     make_simple_prefix,
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- |     preceding_leaf,
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- |     syms,
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | )
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | from blib2to3.pgen2 import token
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | from blib2to3.pytree import Leaf, Node
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | 
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | # types
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | LN = Union[Leaf, Node]
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | 
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | FMT_OFF: Final = {"# fmt: off", "# fmt:off", "# yapf: disable"}
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | FMT_SKIP: Final = {"# fmt: skip", "# fmt:skip"}
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | FMT_ON: Final = {"# fmt: on", "# fmt:on", "# yapf: enable"}
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | 
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | COMMENT_EXCEPTIONS = " !:#'"
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | _COMMENT_PREFIX = "# "
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | _COMMENT_LIST_SEPARATOR = ";"
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | 
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | 
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | @dataclass
---- ---- ---- ---- ---- ---- ---- 01 -- --- --- --- --- --- --- ------- ------- ------- | class ProtoComment:
---- ---- ---- ---- ---- ---- ---- 01 -- --- --- --- --- --- --- ------- ------- ------- |     """Describes a piece of syntax that is a comment.
---- ---- ---- ---- ---- ---- ---- 01 -- --- --- --- --- --- --- ------- ------- ------- | 
---- ---- ---- ---- ---- ---- ---- 01 -- --- --- --- --- --- --- ------- ------- ------- |     It's not a :class:`blib2to3.pytree.Leaf` so that:
---- ---- ---- ---- ---- ---- ---- 01 -- --- --- --- --- --- --- ------- ------- ------- | 
---- ---- ---- ---- ---- ---- ---- 01 -- --- --- --- --- --- --- ------- ------- ------- |     * it can be cached (`Leaf` objects should not be reused more than once as
---- ---- ---- ---- ---- ---- ---- 01 -- --- --- --- --- --- --- ------- ------- ------- |       they store their lineno, column, prefix, and parent information);
---- ---- ---- ---- ---- ---- ---- 01 -- --- --- --- --- --- --- ------- ------- ------- |     * `newlines` and `consumed` fields are kept separate from the `value`. This
---- ---- ---- ---- ---- ---- ---- 01 -- --- --- --- --- --- --- ------- ------- ------- |       simplifies handling of special marker comments like ``# fmt: off/on``.
---- ---- ---- ---- ---- ---- ---- 01 -- --- --- --- --- --- --- ------- ------- ------- |     """
---- ---- ---- ---- ---- ---- ---- 01 -- --- --- --- --- --- --- ------- ------- ------- | 
---- ---- ---- ---- ---- ---- ---- 01 -- --- --- --- --- --- --- ------- ------- ------- |     type: int  # token.COMMENT or STANDALONE_COMMENT
---- ---- ---- ---- ---- ---- ---- 01 -- --- --- --- --- --- --- ------- ------- ------- |     value: str  # content of the comment
---- ---- ---- ---- ---- ---- ---- 01 -- --- --- --- --- --- --- ------- ------- ------- |     newlines: int  # how many newlines before the comment
---- ---- ---- ---- ---- ---- ---- 01 -- --- --- --- --- --- --- ------- ------- ------- |     consumed: int  # how many characters of the original leaf's prefix did we consume
---- ---- ---- ---- ---- ---- ---- 01 -- --- --- --- --- --- --- ------- ------- ------- |     form_feed: bool  # is there a form feed before the comment
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | 
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | 
0025 0008 0007 0000 0014 0004 0000 -- 02 001 002 001 002 003 003 0004.75 0002.38 0000.50 | def generate_comments(leaf: LN) -> Iterator[Leaf]:
0025 0008 0007 0000 0014 0004 0000 -- 02 001 002 001 002 003 003 0004.75 0002.38 0000.50 |     """Clean the prefix of the `leaf` and generate comments from it, if any.
0025 0008 0007 0000 0014 0004 0000 -- 02 001 002 001 002 003 003 0004.75 0002.38 0000.50 | 
0025 0008 0007 0000 0014 0004 0000 -- 02 001 002 001 002 003 003 0004.75 0002.38 0000.50 |     Comments in lib2to3 are shoved into the whitespace prefix.  This happens
0025 0008 0007 0000 0014 0004 0000 -- 02 001 002 001 002 003 003 0004.75 0002.38 0000.50 |     in `pgen2/driver.py:Driver.parse_tokens()`.  This was a brilliant implementation
0025 0008 0007 0000 0014 0004 0000 -- 02 001 002 001 002 003 003 0004.75 0002.38 0000.50 |     move because it does away with modifying the grammar to include all the
0025 0008 0007 0000 0014 0004 0000 -- 02 001 002 001 002 003 003 0004.75 0002.38 0000.50 |     possible places in which comments can be placed.
0025 0008 0007 0000 0014 0004 0000 -- 02 001 002 001 002 003 003 0004.75 0002.38 0000.50 | 
0025 0008 0007 0000 0014 0004 0000 -- 02 001 002 001 002 003 003 0004.75 0002.38 0000.50 |     The sad consequence for us though is that comments don't "belong" anywhere.
0025 0008 0007 0000 0014 0004 0000 -- 02 001 002 001 002 003 003 0004.75 0002.38 0000.50 |     This is why this function generates simple parentless Leaf objects for
0025 0008 0007 0000 0014 0004 0000 -- 02 001 002 001 002 003 003 0004.75 0002.38 0000.50 |     comments.  We simply don't know what the correct parent should be.
0025 0008 0007 0000 0014 0004 0000 -- 02 001 002 001 002 003 003 0004.75 0002.38 0000.50 | 
0025 0008 0007 0000 0014 0004 0000 -- 02 001 002 001 002 003 003 0004.75 0002.38 0000.50 |     No matter though, we can live without this.  We really only need to
0025 0008 0007 0000 0014 0004 0000 -- 02 001 002 001 002 003 003 0004.75 0002.38 0000.50 |     differentiate between inline and standalone comments.  The latter don't
0025 0008 0007 0000 0014 0004 0000 -- 02 001 002 001 002 003 003 0004.75 0002.38 0000.50 |     share the line with any code.
0025 0008 0007 0000 0014 0004 0000 -- 02 001 002 001 002 003 003 0004.75 0002.38 0000.50 | 
0025 0008 0007 0000 0014 0004 0000 -- 02 001 002 001 002 003 003 0004.75 0002.38 0000.50 |     Inline comments are emitted as regular token.COMMENT leaves.  Standalone
0025 0008 0007 0000 0014 0004 0000 -- 02 001 002 001 002 003 003 0004.75 0002.38 0000.50 |     are emitted with a fake STANDALONE_COMMENT token identifier.
0025 0008 0007 0000 0014 0004 0000 -- 02 001 002 001 002 003 003 0004.75 0002.38 0000.50 |     """
0025 0008 0007 0000 0014 0004 0000 -- 02 001 002 001 002 003 003 0004.75 0002.38 0000.50 |     total_consumed = 0
0025 0008 0007 0000 0014 0004 0000 -- 02 001 002 001 002 003 003 0004.75 0002.38 0000.50 |     for pc in list_comments(leaf.prefix, is_endmarker=leaf.type == token.ENDMARKER):
0025 0008 0007 0000 0014 0004 0000 -- 02 001 002 001 002 003 003 0004.75 0002.38 0000.50 |         total_consumed = pc.consumed
0025 0008 0007 0000 0014 0004 0000 -- 02 001 002 001 002 003 003 0004.75 0002.38 0000.50 |         prefix = make_simple_prefix(pc.newlines, pc.form_feed)
0025 0008 0007 0000 0014 0004 0000 -- 02 001 002 001 002 003 003 0004.75 0002.38 0000.50 |         yield Leaf(pc.type, pc.value, prefix=prefix)
0025 0008 0007 0000 0014 0004 0000 -- 02 001 002 001 002 003 003 0004.75 0002.38 0000.50 |     normalize_trailing_prefix(leaf, total_consumed)
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | 
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | 
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | @lru_cache(maxsize=4096)
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 | def list_comments(prefix: str, *, is_endmarker: bool) -> List[ProtoComment]:
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |     """Return a list of :class:`ProtoComment` objects parsed from the given `prefix`."""
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |     result: List[ProtoComment] = []
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |     if not prefix or "#" not in prefix:
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |         return result
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 | 
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |     consumed = 0
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |     nlines = 0
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |     ignored_lines = 0
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |     form_feed = False
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |     for index, full_line in enumerate(re.split("\r?\n", prefix)):
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |         consumed += len(full_line) + 1  # adding the length of the split '\n'
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |         line = full_line.lstrip()
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |         if not line:
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |             nlines += 1
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |             if "\f" in full_line:
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |                 form_feed = True
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |         if not line.startswith("#"):
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |             # Escaped newlines outside of a comment are not really newlines at
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |             # all. We treat a single-line comment following an escaped newline
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |             # as a simple trailing comment.
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |             if line.endswith("\\"):
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |                 ignored_lines += 1
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |             continue
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 | 
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |         if index == ignored_lines and not is_endmarker:
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |             comment_type = token.COMMENT  # simple trailing comment
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |         else:
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |             comment_type = STANDALONE_COMMENT
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |         comment = make_comment(line)
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |         result.append(
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |             ProtoComment(
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |                 type=comment_type,
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |                 value=comment,
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |                 newlines=nlines,
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |                 consumed=consumed,
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |                 form_feed=form_feed,
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |             )
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |         )
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |         form_feed = False
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |         nlines = 0
0043 0031 0037 0005 0000 0002 0004 -- 10 007 018 013 022 025 035 0162.53 0695.29 0004.28 |     return result
0043 0031 0037 0005 0000 0002 0004 -- -- --- --- --- --- --- --- ------- ------- ------- | 
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | 
0013 0010 0008 0000 0003 0002 0000 -- 03 003 005 003 006 008 009 0027.00 0048.60 0001.80 | def normalize_trailing_prefix(leaf: LN, total_consumed: int) -> None:
0013 0010 0008 0000 0003 0002 0000 -- 03 003 005 003 006 008 009 0027.00 0048.60 0001.80 |     """Normalize the prefix that's left over after generating comments.
0013 0010 0008 0000 0003 0002 0000 -- 03 003 005 003 006 008 009 0027.00 0048.60 0001.80 | 
0013 0010 0008 0000 0003 0002 0000 -- 03 003 005 003 006 008 009 0027.00 0048.60 0001.80 |     Note: don't use backslashes for formatting or you'll lose your voting rights.
0013 0010 0008 0000 0003 0002 0000 -- 03 003 005 003 006 008 009 0027.00 0048.60 0001.80 |     """
0013 0010 0008 0000 0003 0002 0000 -- 03 003 005 003 006 008 009 0027.00 0048.60 0001.80 |     remainder = leaf.prefix[total_consumed:]
0013 0010 0008 0000 0003 0002 0000 -- 03 003 005 003 006 008 009 0027.00 0048.60 0001.80 |     if "\\" not in remainder:
0013 0010 0008 0000 0003 0002 0000 -- 03 003 005 003 006 008 009 0027.00 0048.60 0001.80 |         nl_count = remainder.count("\n")
0013 0010 0008 0000 0003 0002 0000 -- 03 003 005 003 006 008 009 0027.00 0048.60 0001.80 |         form_feed = "\f" in remainder and remainder.endswith("\n")
0013 0010 0008 0000 0003 0002 0000 -- 03 003 005 003 006 008 009 0027.00 0048.60 0001.80 |         leaf.prefix = make_simple_prefix(nl_count, form_feed)
0013 0010 0008 0000 0003 0002 0000 -- 03 003 005 003 006 008 009 0027.00 0048.60 0001.80 |         return
0013 0010 0008 0000 0003 0002 0000 -- 03 003 005 003 006 008 009 0027.00 0048.60 0001.80 | 
0013 0010 0008 0000 0003 0002 0000 -- 03 003 005 003 006 008 009 0027.00 0048.60 0001.80 |     leaf.prefix = ""
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | 
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | 
0024 0015 0016 0001 0005 0003 0000 -- 08 005 013 010 019 018 029 0120.93 0441.85 0003.65 | def make_comment(content: str) -> str:
0024 0015 0016 0001 0005 0003 0000 -- 08 005 013 010 019 018 029 0120.93 0441.85 0003.65 |     """Return a consistently formatted comment from the given `content` string.
0024 0015 0016 0001 0005 0003 0000 -- 08 005 013 010 019 018 029 0120.93 0441.85 0003.65 | 
0024 0015 0016 0001 0005 0003 0000 -- 08 005 013 010 019 018 029 0120.93 0441.85 0003.65 |     All comments (except for "##", "#!", "#:", '#'") should have a single
0024 0015 0016 0001 0005 0003 0000 -- 08 005 013 010 019 018 029 0120.93 0441.85 0003.65 |     space between the hash sign and the content.
0024 0015 0016 0001 0005 0003 0000 -- 08 005 013 010 019 018 029 0120.93 0441.85 0003.65 | 
0024 0015 0016 0001 0005 0003 0000 -- 08 005 013 010 019 018 029 0120.93 0441.85 0003.65 |     If `content` didn't start with a hash sign, one is provided.
0024 0015 0016 0001 0005 0003 0000 -- 08 005 013 010 019 018 029 0120.93 0441.85 0003.65 |     """
0024 0015 0016 0001 0005 0003 0000 -- 08 005 013 010 019 018 029 0120.93 0441.85 0003.65 |     content = content.rstrip()
0024 0015 0016 0001 0005 0003 0000 -- 08 005 013 010 019 018 029 0120.93 0441.85 0003.65 |     if not content:
0024 0015 0016 0001 0005 0003 0000 -- 08 005 013 010 019 018 029 0120.93 0441.85 0003.65 |         return "#"
0024 0015 0016 0001 0005 0003 0000 -- 08 005 013 010 019 018 029 0120.93 0441.85 0003.65 | 
0024 0015 0016 0001 0005 0003 0000 -- 08 005 013 010 019 018 029 0120.93 0441.85 0003.65 |     if content[0] == "#":
0024 0015 0016 0001 0005 0003 0000 -- 08 005 013 010 019 018 029 0120.93 0441.85 0003.65 |         content = content[1:]
0024 0015 0016 0001 0005 0003 0000 -- 08 005 013 010 019 018 029 0120.93 0441.85 0003.65 |     NON_BREAKING_SPACE = " "
0024 0015 0016 0001 0005 0003 0000 -- 08 005 013 010 019 018 029 0120.93 0441.85 0003.65 |     if (
0024 0015 0016 0001 0005 0003 0000 -- 08 005 013 010 019 018 029 0120.93 0441.85 0003.65 |         content
0024 0015 0016 0001 0005 0003 0000 -- 08 005 013 010 019 018 029 0120.93 0441.85 0003.65 |         and content[0] == NON_BREAKING_SPACE
0024 0015 0016 0001 0005 0003 0000 -- 08 005 013 010 019 018 029 0120.93 0441.85 0003.65 |         and not content.lstrip().startswith("type:")
0024 0015 0016 0001 0005 0003 0000 -- 08 005 013 010 019 018 029 0120.93 0441.85 0003.65 |     ):
0024 0015 0016 0001 0005 0003 0000 -- 08 005 013 010 019 018 029 0120.93 0441.85 0003.65 |         content = " " + content[1:]  # Replace NBSP by a simple space
0024 0015 0016 0001 0005 0003 0000 -- 08 005 013 010 019 018 029 0120.93 0441.85 0003.65 |     if content and content[0] not in COMMENT_EXCEPTIONS:
0024 0015 0016 0001 0005 0003 0000 -- 08 005 013 010 019 018 029 0120.93 0441.85 0003.65 |         content = " " + content
0024 0015 0016 0001 0005 0003 0000 -- 08 005 013 010 019 018 029 0120.93 0441.85 0003.65 |     return "#" + content
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | 
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | 
0007 0005 0006 0000 0000 0000 0001 -- 02 000 000 000 000 000 000 0000.00 0000.00 0000.00 | def normalize_fmt_off(
0007 0005 0006 0000 0000 0000 0001 -- 02 000 000 000 000 000 000 0000.00 0000.00 0000.00 |     node: Node, mode: Mode, lines: Collection[Tuple[int, int]]
0007 0005 0006 0000 0000 0000 0001 -- 02 000 000 000 000 000 000 0000.00 0000.00 0000.00 | ) -> None:
0007 0005 0006 0000 0000 0000 0001 -- 02 000 000 000 000 000 000 0000.00 0000.00 0000.00 |     """Convert content between `# fmt: off`/`# fmt: on` into standalone comments."""
0007 0005 0006 0000 0000 0000 0001 -- 02 000 000 000 000 000 000 0000.00 0000.00 0000.00 |     try_again = True
0007 0005 0006 0000 0000 0000 0001 -- 02 000 000 000 000 000 000 0000.00 0000.00 0000.00 |     while try_again:
0007 0005 0006 0000 0000 0000 0001 -- 02 000 000 000 000 000 000 0000.00 0000.00 0000.00 |         try_again = convert_one_fmt_off_pair(node, mode, lines)
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | 
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | 
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 | def convert_one_fmt_off_pair(
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |     node: Node, mode: Mode, lines: Collection[Tuple[int, int]]
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 | ) -> bool:
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |     """Convert content of a single `# fmt: off`/`# fmt: on` into a standalone comment.
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 | 
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |     Returns True if a pair was converted.
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |     """
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |     for leaf in node.leaves():
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |         previous_consumed = 0
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |         for comment in list_comments(leaf.prefix, is_endmarker=False):
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |             should_pass_fmt = comment.value in FMT_OFF or _contains_fmt_skip_comment(
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                 comment.value, mode
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |             )
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |             if not should_pass_fmt:
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                 previous_consumed = comment.consumed
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                 continue
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |             # We only want standalone comments. If there's no previous leaf or
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |             # the previous leaf is indentation, it's a standalone comment in
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |             # disguise.
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |             if should_pass_fmt and comment.type != STANDALONE_COMMENT:
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                 prev = preceding_leaf(leaf)
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                 if prev:
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                     if comment.value in FMT_OFF and prev.type not in WHITESPACE:
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                         continue
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                     if (
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                         _contains_fmt_skip_comment(comment.value, mode)
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                         and prev.type in WHITESPACE
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                     ):
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                         continue
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 | 
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |             ignored_nodes = list(generate_ignored_nodes(leaf, comment, mode))
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |             if not ignored_nodes:
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                 continue
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 | 
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |             first = ignored_nodes[0]  # Can be a container node with the `leaf`.
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |             parent = first.parent
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |             prefix = first.prefix
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |             if comment.value in FMT_OFF:
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                 first.prefix = prefix[comment.consumed :]
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |             if _contains_fmt_skip_comment(comment.value, mode):
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                 first.prefix = ""
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                 standalone_comment_prefix = prefix
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |             else:
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                 standalone_comment_prefix = (
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                     prefix[:previous_consumed] + "\n" * comment.newlines
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                 )
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |             hidden_value = "".join(str(n) for n in ignored_nodes)
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |             comment_lineno = leaf.lineno - comment.newlines
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |             if comment.value in FMT_OFF:
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                 fmt_off_prefix = ""
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                 if len(lines) > 0 and not any(
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                     line[0] <= comment_lineno <= line[1] for line in lines
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                 ):
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                     # keeping indentation of comment by preserving original whitespaces.
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                     fmt_off_prefix = prefix.split(comment.value)[0]
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                     if "\n" in fmt_off_prefix:
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                         fmt_off_prefix = fmt_off_prefix.split("\n")[-1]
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                 standalone_comment_prefix += fmt_off_prefix
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                 hidden_value = comment.value + "\n" + hidden_value
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |             if _contains_fmt_skip_comment(comment.value, mode):
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                 hidden_value += "  " + comment.value
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |             if hidden_value.endswith("\n"):
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                 # That happens when one of the `ignored_nodes` ended with a NEWLINE
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                 # leaf (possibly followed by a DEDENT).
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                 hidden_value = hidden_value[:-1]
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |             first_idx: Optional[int] = None
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |             for ignored in ignored_nodes:
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                 index = ignored.remove()
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                 if first_idx is None:
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                     first_idx = index
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |             assert parent is not None, "INTERNAL ERROR: fmt: on/off handling (1)"
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |             assert first_idx is not None, "INTERNAL ERROR: fmt: on/off handling (2)"
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |             parent.insert_child(
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                 first_idx,
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                 Leaf(
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                     STANDALONE_COMMENT,
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                     hidden_value,
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                     prefix=standalone_comment_prefix,
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                     fmt_pass_converted_first_leaf=first_leaf_of(first),
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |                 ),
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |             )
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |             return True
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 | 
0084 0057 0071 0007 0003 0004 0006 -- 25 014 037 032 058 051 090 0510.52 5601.90 0010.97 |     return False
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | 
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | 
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 | def generate_ignored_nodes(
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |     leaf: Leaf, comment: ProtoComment, mode: Mode
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 | ) -> Iterator[LN]:
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |     """Starting from the container of `leaf`, generate all leaves until `# fmt: on`.
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 | 
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |     If comment is skip, returns leaf only.
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |     Stops at the end of the block.
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |     """
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |     if _contains_fmt_skip_comment(comment.value, mode):
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |         yield from _generate_ignored_nodes_from_fmt_skip(leaf, comment)
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |         return
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |     container: Optional[LN] = container_of(leaf)
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |     while container is not None and container.type != token.ENDMARKER:
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |         if is_fmt_on(container):
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |             return
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 | 
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |         # fix for fmt: on in children
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |         if children_contains_fmt_on(container):
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |             for index, child in enumerate(container.children):
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |                 if isinstance(child, Leaf) and is_fmt_on(child):
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |                     if child.type in CLOSING_BRACKETS:
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |                         # This means `# fmt: on` is placed at a different bracket level
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |                         # than `# fmt: off`. This is an invalid use, but as a courtesy,
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |                         # we include this closing bracket in the ignored nodes.
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |                         # The alternative is to fail the formatting.
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |                         yield child
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |                     return
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |                 if (
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |                     child.type == token.INDENT
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |                     and index < len(container.children) - 1
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |                     and children_contains_fmt_on(container.children[index + 1])
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |                 ):
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |                     # This means `# fmt: on` is placed right after an indentation
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |                     # level, and we shouldn't swallow the previous INDENT token.
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |                     return
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |                 if children_contains_fmt_on(child):
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |                     return
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |                 yield child
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |         else:
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |             if container.type == token.DEDENT and container.next_sibling is None:
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |                 # This can happen when there is no matching `# fmt: on` comment at the
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |                 # same level as `# fmt: on`. We need to keep this DEDENT.
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |                 return
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |             yield container
0045 0026 0030 0009 0004 0002 0009 -- 16 009 021 013 027 030 040 0196.28 1135.59 0005.79 |             container = container.next_sibling
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | 
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | 
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 | def _generate_ignored_nodes_from_fmt_skip(
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |     leaf: Leaf, comment: ProtoComment
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 | ) -> Iterator[LN]:
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |     """Generate all leaves that should be ignored by the `# fmt: skip` from `leaf`."""
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |     prev_sibling = leaf.prev_sibling
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |     parent = leaf.parent
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |     # Need to properly format the leaf prefix to compare it to comment.value,
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |     # which is also formatted
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |     comments = list_comments(leaf.prefix, is_endmarker=False)
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |     if not comments or comment.value != comments[0].value:
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |         return
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |     if prev_sibling is not None:
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |         leaf.prefix = ""
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |         siblings = [prev_sibling]
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |         while "\n" not in prev_sibling.prefix and prev_sibling.prev_sibling is not None:
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |             prev_sibling = prev_sibling.prev_sibling
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |             siblings.insert(0, prev_sibling)
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |         yield from siblings
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |     elif (
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |         parent is not None and parent.type == syms.suite and leaf.type == token.NEWLINE
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |     ):
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |         # The `# fmt: skip` is on the colon line of the if/while/def/class/...
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |         # statements. The ignored nodes should be previous siblings of the
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |         # parent suite node.
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |         leaf.prefix = ""
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |         ignored_nodes: List[LN] = []
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |         parent_sibling = parent.prev_sibling
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |         while parent_sibling is not None and parent_sibling.type != syms.suite:
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |             ignored_nodes.insert(0, parent_sibling)
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |             parent_sibling = parent_sibling.prev_sibling
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |         # Special case for `async_stmt` where the ASYNC token is on the
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |         # grandparent node.
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |         grandparent = parent.parent
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |         if (
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |             grandparent is not None
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |             and grandparent.prev_sibling is not None
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |             and grandparent.prev_sibling.type == token.ASYNC
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |         ):
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |             ignored_nodes.insert(0, grandparent.prev_sibling)
0040 0026 0032 0007 0000 0000 0008 -- 14 007 025 018 037 032 055 0275.00 1424.50 0005.18 |         yield from iter(ignored_nodes)
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | 
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | 
0011 0009 0008 0000 0003 0000 0000 -- 04 001 003 002 004 004 006 0012.00 0008.00 0000.67 | def is_fmt_on(container: LN) -> bool:
0011 0009 0008 0000 0003 0000 0000 -- 04 001 003 002 004 004 006 0012.00 0008.00 0000.67 |     """Determine whether formatting is switched on within a container.
0011 0009 0008 0000 0003 0000 0000 -- 04 001 003 002 004 004 006 0012.00 0008.00 0000.67 |     Determined by whether the last `# fmt:` comment is `on` or `off`.
0011 0009 0008 0000 0003 0000 0000 -- 04 001 003 002 004 004 006 0012.00 0008.00 0000.67 |     """
0011 0009 0008 0000 0003 0000 0000 -- 04 001 003 002 004 004 006 0012.00 0008.00 0000.67 |     fmt_on = False
0011 0009 0008 0000 0003 0000 0000 -- 04 001 003 002 004 004 006 0012.00 0008.00 0000.67 |     for comment in list_comments(container.prefix, is_endmarker=False):
0011 0009 0008 0000 0003 0000 0000 -- 04 001 003 002 004 004 006 0012.00 0008.00 0000.67 |         if comment.value in FMT_ON:
0011 0009 0008 0000 0003 0000 0000 -- 04 001 003 002 004 004 006 0012.00 0008.00 0000.67 |             fmt_on = True
0011 0009 0008 0000 0003 0000 0000 -- 04 001 003 002 004 004 006 0012.00 0008.00 0000.67 |         elif comment.value in FMT_OFF:
0011 0009 0008 0000 0003 0000 0000 -- 04 001 003 002 004 004 006 0012.00 0008.00 0000.67 |             fmt_on = False
0011 0009 0008 0000 0003 0000 0000 -- 04 001 003 002 004 004 006 0012.00 0008.00 0000.67 |     return fmt_on
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | 
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | 
0008 0007 0006 0000 0000 0001 0001 -- 04 002 004 002 004 006 006 0015.51 0015.51 0001.00 | def children_contains_fmt_on(container: LN) -> bool:
0008 0007 0006 0000 0000 0001 0001 -- 04 002 004 002 004 006 006 0015.51 0015.51 0001.00 |     """Determine if children have formatting switched on."""
0008 0007 0006 0000 0000 0001 0001 -- 04 002 004 002 004 006 006 0015.51 0015.51 0001.00 |     for child in container.children:
0008 0007 0006 0000 0000 0001 0001 -- 04 002 004 002 004 006 006 0015.51 0015.51 0001.00 |         leaf = first_leaf_of(child)
0008 0007 0006 0000 0000 0001 0001 -- 04 002 004 002 004 006 006 0015.51 0015.51 0001.00 |         if leaf is not None and is_fmt_on(leaf):
0008 0007 0006 0000 0000 0001 0001 -- 04 002 004 002 004 006 006 0015.51 0015.51 0001.00 |             return True
0008 0007 0006 0000 0000 0001 0001 -- 04 002 004 002 004 006 006 0015.51 0015.51 0001.00 | 
0008 0007 0006 0000 0000 0001 0001 -- 04 002 004 002 004 006 006 0015.51 0015.51 0001.00 |     return False
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | 
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | 
0012 0006 0005 0000 0006 0001 0000 -- 03 000 000 000 000 000 000 0000.00 0000.00 0000.00 | def contains_pragma_comment(comment_list: List[Leaf]) -> bool:
0012 0006 0005 0000 0006 0001 0000 -- 03 000 000 000 000 000 000 0000.00 0000.00 0000.00 |     """
0012 0006 0005 0000 0006 0001 0000 -- 03 000 000 000 000 000 000 0000.00 0000.00 0000.00 |     Returns:
0012 0006 0005 0000 0006 0001 0000 -- 03 000 000 000 000 000 000 0000.00 0000.00 0000.00 |         True iff one of the comments in @comment_list is a pragma used by one
0012 0006 0005 0000 0006 0001 0000 -- 03 000 000 000 000 000 000 0000.00 0000.00 0000.00 |         of the more common static analysis tools for python (e.g. mypy, flake8,
0012 0006 0005 0000 0006 0001 0000 -- 03 000 000 000 000 000 000 0000.00 0000.00 0000.00 |         pylint).
0012 0006 0005 0000 0006 0001 0000 -- 03 000 000 000 000 000 000 0000.00 0000.00 0000.00 |     """
0012 0006 0005 0000 0006 0001 0000 -- 03 000 000 000 000 000 000 0000.00 0000.00 0000.00 |     for comment in comment_list:
0012 0006 0005 0000 0006 0001 0000 -- 03 000 000 000 000 000 000 0000.00 0000.00 0000.00 |         if comment.value.startswith(("# type:", "# noqa", "# pylint:")):
0012 0006 0005 0000 0006 0001 0000 -- 03 000 000 000 000 000 000 0000.00 0000.00 0000.00 |             return True
0012 0006 0005 0000 0006 0001 0000 -- 03 000 000 000 000 000 000 0000.00 0000.00 0000.00 | 
0012 0006 0005 0000 0006 0001 0000 -- 03 000 000 000 000 000 000 0000.00 0000.00 0000.00 |     return False
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | 
---- ---- ---- ---- ---- ---- ---- -- -- --- --- --- --- --- --- ------- ------- ------- | 
0027 0005 0019 0000 0007 0001 0000 -- 05 002 007 004 008 009 012 0038.04 0043.47 0001.14 | def _contains_fmt_skip_comment(comment_line: str, mode: Mode) -> bool:
0027 0005 0019 0000 0007 0001 0000 -- 05 002 007 004 008 009 012 0038.04 0043.47 0001.14 |     """
0027 0005 0019 0000 0007 0001 0000 -- 05 002 007 004 008 009 012 0038.04 0043.47 0001.14 |     Checks if the given comment contains FMT_SKIP alone or paired with other comments.
0027 0005 0019 0000 0007 0001 0000 -- 05 002 007 004 008 009 012 0038.04 0043.47 0001.14 |     Matching styles:
0027 0005 0019 0000 0007 0001 0000 -- 05 002 007 004 008 009 012 0038.04 0043.47 0001.14 |       # fmt:skip                           <-- single comment
0027 0005 0019 0000 0007 0001 0000 -- 05 002 007 004 008 009 012 0038.04 0043.47 0001.14 |       # noqa:XXX # fmt:skip # a nice line  <-- multiple comments (Preview)
0027 0005 0019 0000 0007 0001 0000 -- 05 002 007 004 008 009 012 0038.04 0043.47 0001.14 |       # pylint:XXX; fmt:skip               <-- list of comments (; separated, Preview)
0027 0005 0019 0000 0007 0001 0000 -- 05 002 007 004 008 009 012 0038.04 0043.47 0001.14 |     """
0027 0005 0019 0000 0007 0001 0000 -- 05 002 007 004 008 009 012 0038.04 0043.47 0001.14 |     semantic_comment_blocks = (
0027 0005 0019 0000 0007 0001 0000 -- 05 002 007 004 008 009 012 0038.04 0043.47 0001.14 |         [
0027 0005 0019 0000 0007 0001 0000 -- 05 002 007 004 008 009 012 0038.04 0043.47 0001.14 |             comment_line,
0027 0005 0019 0000 0007 0001 0000 -- 05 002 007 004 008 009 012 0038.04 0043.47 0001.14 |             *[
0027 0005 0019 0000 0007 0001 0000 -- 05 002 007 004 008 009 012 0038.04 0043.47 0001.14 |                 _COMMENT_PREFIX + comment.strip()
0027 0005 0019 0000 0007 0001 0000 -- 05 002 007 004 008 009 012 0038.04 0043.47 0001.14 |                 for comment in comment_line.split(_COMMENT_PREFIX)[1:]
0027 0005 0019 0000 0007 0001 0000 -- 05 002 007 004 008 009 012 0038.04 0043.47 0001.14 |             ],
0027 0005 0019 0000 0007 0001 0000 -- 05 002 007 004 008 009 012 0038.04 0043.47 0001.14 |             *[
0027 0005 0019 0000 0007 0001 0000 -- 05 002 007 004 008 009 012 0038.04 0043.47 0001.14 |                 _COMMENT_PREFIX + comment.strip()
0027 0005 0019 0000 0007 0001 0000 -- 05 002 007 004 008 009 012 0038.04 0043.47 0001.14 |                 for comment in comment_line.strip(_COMMENT_PREFIX).split(
0027 0005 0019 0000 0007 0001 0000 -- 05 002 007 004 008 009 012 0038.04 0043.47 0001.14 |                     _COMMENT_LIST_SEPARATOR
0027 0005 0019 0000 0007 0001 0000 -- 05 002 007 004 008 009 012 0038.04 0043.47 0001.14 |                 )
0027 0005 0019 0000 0007 0001 0000 -- 05 002 007 004 008 009 012 0038.04 0043.47 0001.14 |             ],
0027 0005 0019 0000 0007 0001 0000 -- 05 002 007 004 008 009 012 0038.04 0043.47 0001.14 |         ]
0027 0005 0019 0000 0007 0001 0000 -- 05 002 007 004 008 009 012 0038.04 0043.47 0001.14 |         if Preview.single_line_format_skip_with_multiple_comments in mode
0027 0005 0019 0000 0007 0001 0000 -- 05 002 007 004 008 009 012 0038.04 0043.47 0001.14 |         else [comment_line]
0027 0005 0019 0000 0007 0001 0000 -- 05 002 007 004 008 009 012 0038.04 0043.47 0001.14 |     )
0027 0005 0019 0000 0007 0001 0000 -- 05 002 007 004 008 009 012 0038.04 0043.47 0001.14 | 
0027 0005 0019 0000 0007 0001 0000 -- 05 002 007 004 008 009 012 0038.04 0043.47 0001.14 |     return any(comment in FMT_SKIP for comment in semantic_comment_blocks)