]> git.madduck.net Git - etc/vim.git/blob - src/black/__init__.py

madduck's git repository

Every one of the projects in this repository is available at the canonical URL git://git.madduck.net/madduck/pub/<projectpath> — see each project's metadata for the exact URL.

All patches and comments are welcome. Please squash your changes to logical commits before using git-format-patch and git-send-email to patches@git.madduck.net. If you'd read over the Git project's submission guidelines and adhered to them, I'd be especially grateful.

SSH access, as well as push access can be individually arranged.

If you use my repositories frequently, consider adding the following snippet to ~/.gitconfig and using the third clone URL listed for each project:

[url "git://git.madduck.net/madduck/"]
  insteadOf = madduck:

Add automatic version tagging to Docker CI Pushes (#2132)
[etc/vim.git] / src / black / __init__.py
1 import ast
2 import asyncio
3 from abc import ABC, abstractmethod
4 from collections import defaultdict
5 from concurrent.futures import Executor, ThreadPoolExecutor, ProcessPoolExecutor
6 from contextlib import contextmanager
7 from datetime import datetime
8 from enum import Enum
9 from functools import lru_cache, partial, wraps
10 import io
11 import itertools
12 import logging
13 from multiprocessing import Manager, freeze_support
14 import os
15 from pathlib import Path
16 import pickle
17 import regex as re
18 import signal
19 import sys
20 import tempfile
21 import tokenize
22 import traceback
23 from typing import (
24     Any,
25     Callable,
26     Collection,
27     Dict,
28     Generator,
29     Generic,
30     Iterable,
31     Iterator,
32     List,
33     Optional,
34     Pattern,
35     Sequence,
36     Set,
37     Sized,
38     Tuple,
39     Type,
40     TypeVar,
41     Union,
42     cast,
43     TYPE_CHECKING,
44 )
45 from mypy_extensions import mypyc_attr
46
47 from appdirs import user_cache_dir
48 from dataclasses import dataclass, field, replace
49 import click
50 import toml
51
52 try:
53     from typed_ast import ast3, ast27
54 except ImportError:
55     if sys.version_info < (3, 8):
56         print(
57             "The typed_ast package is not installed.\n"
58             "You can install it with `python3 -m pip install typed-ast`.",
59             file=sys.stderr,
60         )
61         sys.exit(1)
62     else:
63         ast3 = ast27 = ast
64
65 from pathspec import PathSpec
66
67 # lib2to3 fork
68 from blib2to3.pytree import Node, Leaf, type_repr
69 from blib2to3 import pygram, pytree
70 from blib2to3.pgen2 import driver, token
71 from blib2to3.pgen2.grammar import Grammar
72 from blib2to3.pgen2.parse import ParseError
73
74 from _black_version import version as __version__
75
76 if sys.version_info < (3, 8):
77     from typing_extensions import Final
78 else:
79     from typing import Final
80
81 if TYPE_CHECKING:
82     import colorama  # noqa: F401
83
84 DEFAULT_LINE_LENGTH = 88
85 DEFAULT_EXCLUDES = r"/(\.direnv|\.eggs|\.git|\.hg|\.mypy_cache|\.nox|\.tox|\.venv|venv|\.svn|_build|buck-out|build|dist)/"  # noqa: B950
86 DEFAULT_INCLUDES = r"\.pyi?$"
87 CACHE_DIR = Path(user_cache_dir("black", version=__version__))
88 STDIN_PLACEHOLDER = "__BLACK_STDIN_FILENAME__"
89
90 STRING_PREFIX_CHARS: Final = "furbFURB"  # All possible string prefix characters.
91
92
93 # types
94 FileContent = str
95 Encoding = str
96 NewLine = str
97 Depth = int
98 NodeType = int
99 ParserState = int
100 LeafID = int
101 StringID = int
102 Priority = int
103 Index = int
104 LN = Union[Leaf, Node]
105 Transformer = Callable[["Line", Collection["Feature"]], Iterator["Line"]]
106 Timestamp = float
107 FileSize = int
108 CacheInfo = Tuple[Timestamp, FileSize]
109 Cache = Dict[str, CacheInfo]
110 out = partial(click.secho, bold=True, err=True)
111 err = partial(click.secho, fg="red", err=True)
112
113 pygram.initialize(CACHE_DIR)
114 syms = pygram.python_symbols
115
116
117 class NothingChanged(UserWarning):
118     """Raised when reformatted code is the same as source."""
119
120
121 class CannotTransform(Exception):
122     """Base class for errors raised by Transformers."""
123
124
125 class CannotSplit(CannotTransform):
126     """A readable split that fits the allotted line length is impossible."""
127
128
129 class InvalidInput(ValueError):
130     """Raised when input source code fails all parse attempts."""
131
132
133 class BracketMatchError(KeyError):
134     """Raised when an opening bracket is unable to be matched to a closing bracket."""
135
136
137 T = TypeVar("T")
138 E = TypeVar("E", bound=Exception)
139
140
141 class Ok(Generic[T]):
142     def __init__(self, value: T) -> None:
143         self._value = value
144
145     def ok(self) -> T:
146         return self._value
147
148
149 class Err(Generic[E]):
150     def __init__(self, e: E) -> None:
151         self._e = e
152
153     def err(self) -> E:
154         return self._e
155
156
157 # The 'Result' return type is used to implement an error-handling model heavily
158 # influenced by that used by the Rust programming language
159 # (see https://doc.rust-lang.org/book/ch09-00-error-handling.html).
160 Result = Union[Ok[T], Err[E]]
161 TResult = Result[T, CannotTransform]  # (T)ransform Result
162 TMatchResult = TResult[Index]
163
164
165 class WriteBack(Enum):
166     NO = 0
167     YES = 1
168     DIFF = 2
169     CHECK = 3
170     COLOR_DIFF = 4
171
172     @classmethod
173     def from_configuration(
174         cls, *, check: bool, diff: bool, color: bool = False
175     ) -> "WriteBack":
176         if check and not diff:
177             return cls.CHECK
178
179         if diff and color:
180             return cls.COLOR_DIFF
181
182         return cls.DIFF if diff else cls.YES
183
184
185 class Changed(Enum):
186     NO = 0
187     CACHED = 1
188     YES = 2
189
190
191 class TargetVersion(Enum):
192     PY27 = 2
193     PY33 = 3
194     PY34 = 4
195     PY35 = 5
196     PY36 = 6
197     PY37 = 7
198     PY38 = 8
199     PY39 = 9
200
201     def is_python2(self) -> bool:
202         return self is TargetVersion.PY27
203
204
205 class Feature(Enum):
206     # All string literals are unicode
207     UNICODE_LITERALS = 1
208     F_STRINGS = 2
209     NUMERIC_UNDERSCORES = 3
210     TRAILING_COMMA_IN_CALL = 4
211     TRAILING_COMMA_IN_DEF = 5
212     # The following two feature-flags are mutually exclusive, and exactly one should be
213     # set for every version of python.
214     ASYNC_IDENTIFIERS = 6
215     ASYNC_KEYWORDS = 7
216     ASSIGNMENT_EXPRESSIONS = 8
217     POS_ONLY_ARGUMENTS = 9
218     RELAXED_DECORATORS = 10
219     FORCE_OPTIONAL_PARENTHESES = 50
220
221
222 VERSION_TO_FEATURES: Dict[TargetVersion, Set[Feature]] = {
223     TargetVersion.PY27: {Feature.ASYNC_IDENTIFIERS},
224     TargetVersion.PY33: {Feature.UNICODE_LITERALS, Feature.ASYNC_IDENTIFIERS},
225     TargetVersion.PY34: {Feature.UNICODE_LITERALS, Feature.ASYNC_IDENTIFIERS},
226     TargetVersion.PY35: {
227         Feature.UNICODE_LITERALS,
228         Feature.TRAILING_COMMA_IN_CALL,
229         Feature.ASYNC_IDENTIFIERS,
230     },
231     TargetVersion.PY36: {
232         Feature.UNICODE_LITERALS,
233         Feature.F_STRINGS,
234         Feature.NUMERIC_UNDERSCORES,
235         Feature.TRAILING_COMMA_IN_CALL,
236         Feature.TRAILING_COMMA_IN_DEF,
237         Feature.ASYNC_IDENTIFIERS,
238     },
239     TargetVersion.PY37: {
240         Feature.UNICODE_LITERALS,
241         Feature.F_STRINGS,
242         Feature.NUMERIC_UNDERSCORES,
243         Feature.TRAILING_COMMA_IN_CALL,
244         Feature.TRAILING_COMMA_IN_DEF,
245         Feature.ASYNC_KEYWORDS,
246     },
247     TargetVersion.PY38: {
248         Feature.UNICODE_LITERALS,
249         Feature.F_STRINGS,
250         Feature.NUMERIC_UNDERSCORES,
251         Feature.TRAILING_COMMA_IN_CALL,
252         Feature.TRAILING_COMMA_IN_DEF,
253         Feature.ASYNC_KEYWORDS,
254         Feature.ASSIGNMENT_EXPRESSIONS,
255         Feature.POS_ONLY_ARGUMENTS,
256     },
257     TargetVersion.PY39: {
258         Feature.UNICODE_LITERALS,
259         Feature.F_STRINGS,
260         Feature.NUMERIC_UNDERSCORES,
261         Feature.TRAILING_COMMA_IN_CALL,
262         Feature.TRAILING_COMMA_IN_DEF,
263         Feature.ASYNC_KEYWORDS,
264         Feature.ASSIGNMENT_EXPRESSIONS,
265         Feature.RELAXED_DECORATORS,
266         Feature.POS_ONLY_ARGUMENTS,
267     },
268 }
269
270
271 @dataclass
272 class Mode:
273     target_versions: Set[TargetVersion] = field(default_factory=set)
274     line_length: int = DEFAULT_LINE_LENGTH
275     string_normalization: bool = True
276     is_pyi: bool = False
277     magic_trailing_comma: bool = True
278     experimental_string_processing: bool = False
279
280     def get_cache_key(self) -> str:
281         if self.target_versions:
282             version_str = ",".join(
283                 str(version.value)
284                 for version in sorted(self.target_versions, key=lambda v: v.value)
285             )
286         else:
287             version_str = "-"
288         parts = [
289             version_str,
290             str(self.line_length),
291             str(int(self.string_normalization)),
292             str(int(self.is_pyi)),
293             str(int(self.magic_trailing_comma)),
294             str(int(self.experimental_string_processing)),
295         ]
296         return ".".join(parts)
297
298
299 # Legacy name, left for integrations.
300 FileMode = Mode
301
302
303 def supports_feature(target_versions: Set[TargetVersion], feature: Feature) -> bool:
304     return all(feature in VERSION_TO_FEATURES[version] for version in target_versions)
305
306
307 def find_pyproject_toml(path_search_start: Tuple[str, ...]) -> Optional[str]:
308     """Find the absolute filepath to a pyproject.toml if it exists"""
309     path_project_root = find_project_root(path_search_start)
310     path_pyproject_toml = path_project_root / "pyproject.toml"
311     if path_pyproject_toml.is_file():
312         return str(path_pyproject_toml)
313
314     try:
315         path_user_pyproject_toml = find_user_pyproject_toml()
316         return (
317             str(path_user_pyproject_toml)
318             if path_user_pyproject_toml.is_file()
319             else None
320         )
321     except PermissionError as e:
322         # We do not have access to the user-level config directory, so ignore it.
323         err(f"Ignoring user configuration directory due to {e!r}")
324         return None
325
326
327 def parse_pyproject_toml(path_config: str) -> Dict[str, Any]:
328     """Parse a pyproject toml file, pulling out relevant parts for Black
329
330     If parsing fails, will raise a toml.TomlDecodeError
331     """
332     pyproject_toml = toml.load(path_config)
333     config = pyproject_toml.get("tool", {}).get("black", {})
334     return {k.replace("--", "").replace("-", "_"): v for k, v in config.items()}
335
336
337 def read_pyproject_toml(
338     ctx: click.Context, param: click.Parameter, value: Optional[str]
339 ) -> Optional[str]:
340     """Inject Black configuration from "pyproject.toml" into defaults in `ctx`.
341
342     Returns the path to a successfully found and read configuration file, None
343     otherwise.
344     """
345     if not value:
346         value = find_pyproject_toml(ctx.params.get("src", ()))
347         if value is None:
348             return None
349
350     try:
351         config = parse_pyproject_toml(value)
352     except (toml.TomlDecodeError, OSError) as e:
353         raise click.FileError(
354             filename=value, hint=f"Error reading configuration file: {e}"
355         )
356
357     if not config:
358         return None
359     else:
360         # Sanitize the values to be Click friendly. For more information please see:
361         # https://github.com/psf/black/issues/1458
362         # https://github.com/pallets/click/issues/1567
363         config = {
364             k: str(v) if not isinstance(v, (list, dict)) else v
365             for k, v in config.items()
366         }
367
368     target_version = config.get("target_version")
369     if target_version is not None and not isinstance(target_version, list):
370         raise click.BadOptionUsage(
371             "target-version", "Config key target-version must be a list"
372         )
373
374     default_map: Dict[str, Any] = {}
375     if ctx.default_map:
376         default_map.update(ctx.default_map)
377     default_map.update(config)
378
379     ctx.default_map = default_map
380     return value
381
382
383 def target_version_option_callback(
384     c: click.Context, p: Union[click.Option, click.Parameter], v: Tuple[str, ...]
385 ) -> List[TargetVersion]:
386     """Compute the target versions from a --target-version flag.
387
388     This is its own function because mypy couldn't infer the type correctly
389     when it was a lambda, causing mypyc trouble.
390     """
391     return [TargetVersion[val.upper()] for val in v]
392
393
394 def validate_regex(
395     ctx: click.Context,
396     param: click.Parameter,
397     value: Optional[str],
398 ) -> Optional[Pattern]:
399     try:
400         return re_compile_maybe_verbose(value) if value is not None else None
401     except re.error:
402         raise click.BadParameter("Not a valid regular expression")
403
404
405 @click.command(context_settings=dict(help_option_names=["-h", "--help"]))
406 @click.option("-c", "--code", type=str, help="Format the code passed in as a string.")
407 @click.option(
408     "-l",
409     "--line-length",
410     type=int,
411     default=DEFAULT_LINE_LENGTH,
412     help="How many characters per line to allow.",
413     show_default=True,
414 )
415 @click.option(
416     "-t",
417     "--target-version",
418     type=click.Choice([v.name.lower() for v in TargetVersion]),
419     callback=target_version_option_callback,
420     multiple=True,
421     help=(
422         "Python versions that should be supported by Black's output. [default: per-file"
423         " auto-detection]"
424     ),
425 )
426 @click.option(
427     "--pyi",
428     is_flag=True,
429     help=(
430         "Format all input files like typing stubs regardless of file extension (useful"
431         " when piping source on standard input)."
432     ),
433 )
434 @click.option(
435     "-S",
436     "--skip-string-normalization",
437     is_flag=True,
438     help="Don't normalize string quotes or prefixes.",
439 )
440 @click.option(
441     "-C",
442     "--skip-magic-trailing-comma",
443     is_flag=True,
444     help="Don't use trailing commas as a reason to split lines.",
445 )
446 @click.option(
447     "--experimental-string-processing",
448     is_flag=True,
449     hidden=True,
450     help=(
451         "Experimental option that performs more normalization on string literals."
452         " Currently disabled because it leads to some crashes."
453     ),
454 )
455 @click.option(
456     "--check",
457     is_flag=True,
458     help=(
459         "Don't write the files back, just return the status. Return code 0 means"
460         " nothing would change. Return code 1 means some files would be reformatted."
461         " Return code 123 means there was an internal error."
462     ),
463 )
464 @click.option(
465     "--diff",
466     is_flag=True,
467     help="Don't write the files back, just output a diff for each file on stdout.",
468 )
469 @click.option(
470     "--color/--no-color",
471     is_flag=True,
472     help="Show colored diff. Only applies when `--diff` is given.",
473 )
474 @click.option(
475     "--fast/--safe",
476     is_flag=True,
477     help="If --fast given, skip temporary sanity checks. [default: --safe]",
478 )
479 @click.option(
480     "--include",
481     type=str,
482     default=DEFAULT_INCLUDES,
483     callback=validate_regex,
484     help=(
485         "A regular expression that matches files and directories that should be"
486         " included on recursive searches. An empty value means all files are included"
487         " regardless of the name. Use forward slashes for directories on all platforms"
488         " (Windows, too). Exclusions are calculated first, inclusions later."
489     ),
490     show_default=True,
491 )
492 @click.option(
493     "--exclude",
494     type=str,
495     default=DEFAULT_EXCLUDES,
496     callback=validate_regex,
497     help=(
498         "A regular expression that matches files and directories that should be"
499         " excluded on recursive searches. An empty value means no paths are excluded."
500         " Use forward slashes for directories on all platforms (Windows, too)."
501         " Exclusions are calculated first, inclusions later."
502     ),
503     show_default=True,
504 )
505 @click.option(
506     "--extend-exclude",
507     type=str,
508     callback=validate_regex,
509     help=(
510         "Like --exclude, but adds additional files and directories on top of the"
511         " excluded ones. (Useful if you simply want to add to the default)"
512     ),
513 )
514 @click.option(
515     "--force-exclude",
516     type=str,
517     callback=validate_regex,
518     help=(
519         "Like --exclude, but files and directories matching this regex will be "
520         "excluded even when they are passed explicitly as arguments."
521     ),
522 )
523 @click.option(
524     "--stdin-filename",
525     type=str,
526     help=(
527         "The name of the file when passing it through stdin. Useful to make "
528         "sure Black will respect --force-exclude option on some "
529         "editors that rely on using stdin."
530     ),
531 )
532 @click.option(
533     "-q",
534     "--quiet",
535     is_flag=True,
536     help=(
537         "Don't emit non-error messages to stderr. Errors are still emitted; silence"
538         " those with 2>/dev/null."
539     ),
540 )
541 @click.option(
542     "-v",
543     "--verbose",
544     is_flag=True,
545     help=(
546         "Also emit messages to stderr about files that were not changed or were ignored"
547         " due to exclusion patterns."
548     ),
549 )
550 @click.version_option(version=__version__)
551 @click.argument(
552     "src",
553     nargs=-1,
554     type=click.Path(
555         exists=True, file_okay=True, dir_okay=True, readable=True, allow_dash=True
556     ),
557     is_eager=True,
558 )
559 @click.option(
560     "--config",
561     type=click.Path(
562         exists=True,
563         file_okay=True,
564         dir_okay=False,
565         readable=True,
566         allow_dash=False,
567         path_type=str,
568     ),
569     is_eager=True,
570     callback=read_pyproject_toml,
571     help="Read configuration from FILE path.",
572 )
573 @click.pass_context
574 def main(
575     ctx: click.Context,
576     code: Optional[str],
577     line_length: int,
578     target_version: List[TargetVersion],
579     check: bool,
580     diff: bool,
581     color: bool,
582     fast: bool,
583     pyi: bool,
584     skip_string_normalization: bool,
585     skip_magic_trailing_comma: bool,
586     experimental_string_processing: bool,
587     quiet: bool,
588     verbose: bool,
589     include: Pattern,
590     exclude: Pattern,
591     extend_exclude: Optional[Pattern],
592     force_exclude: Optional[Pattern],
593     stdin_filename: Optional[str],
594     src: Tuple[str, ...],
595     config: Optional[str],
596 ) -> None:
597     """The uncompromising code formatter."""
598     write_back = WriteBack.from_configuration(check=check, diff=diff, color=color)
599     if target_version:
600         versions = set(target_version)
601     else:
602         # We'll autodetect later.
603         versions = set()
604     mode = Mode(
605         target_versions=versions,
606         line_length=line_length,
607         is_pyi=pyi,
608         string_normalization=not skip_string_normalization,
609         magic_trailing_comma=not skip_magic_trailing_comma,
610         experimental_string_processing=experimental_string_processing,
611     )
612     if config and verbose:
613         out(f"Using configuration from {config}.", bold=False, fg="blue")
614     if code is not None:
615         print(format_str(code, mode=mode))
616         ctx.exit(0)
617     report = Report(check=check, diff=diff, quiet=quiet, verbose=verbose)
618     sources = get_sources(
619         ctx=ctx,
620         src=src,
621         quiet=quiet,
622         verbose=verbose,
623         include=include,
624         exclude=exclude,
625         extend_exclude=extend_exclude,
626         force_exclude=force_exclude,
627         report=report,
628         stdin_filename=stdin_filename,
629     )
630
631     path_empty(
632         sources,
633         "No Python files are present to be formatted. Nothing to do 😴",
634         quiet,
635         verbose,
636         ctx,
637     )
638
639     if len(sources) == 1:
640         reformat_one(
641             src=sources.pop(),
642             fast=fast,
643             write_back=write_back,
644             mode=mode,
645             report=report,
646         )
647     else:
648         reformat_many(
649             sources=sources, fast=fast, write_back=write_back, mode=mode, report=report
650         )
651
652     if verbose or not quiet:
653         out("Oh no! 💥 💔 💥" if report.return_code else "All done! ✨ 🍰 ✨")
654         click.secho(str(report), err=True)
655     ctx.exit(report.return_code)
656
657
658 def get_sources(
659     *,
660     ctx: click.Context,
661     src: Tuple[str, ...],
662     quiet: bool,
663     verbose: bool,
664     include: Pattern[str],
665     exclude: Pattern[str],
666     extend_exclude: Optional[Pattern[str]],
667     force_exclude: Optional[Pattern[str]],
668     report: "Report",
669     stdin_filename: Optional[str],
670 ) -> Set[Path]:
671     """Compute the set of files to be formatted."""
672
673     root = find_project_root(src)
674     sources: Set[Path] = set()
675     path_empty(src, "No Path provided. Nothing to do 😴", quiet, verbose, ctx)
676     gitignore = get_gitignore(root)
677
678     for s in src:
679         if s == "-" and stdin_filename:
680             p = Path(stdin_filename)
681             is_stdin = True
682         else:
683             p = Path(s)
684             is_stdin = False
685
686         if is_stdin or p.is_file():
687             normalized_path = normalize_path_maybe_ignore(p, root, report)
688             if normalized_path is None:
689                 continue
690
691             normalized_path = "/" + normalized_path
692             # Hard-exclude any files that matches the `--force-exclude` regex.
693             if force_exclude:
694                 force_exclude_match = force_exclude.search(normalized_path)
695             else:
696                 force_exclude_match = None
697             if force_exclude_match and force_exclude_match.group(0):
698                 report.path_ignored(p, "matches the --force-exclude regular expression")
699                 continue
700
701             if is_stdin:
702                 p = Path(f"{STDIN_PLACEHOLDER}{str(p)}")
703
704             sources.add(p)
705         elif p.is_dir():
706             sources.update(
707                 gen_python_files(
708                     p.iterdir(),
709                     root,
710                     include,
711                     exclude,
712                     extend_exclude,
713                     force_exclude,
714                     report,
715                     gitignore,
716                 )
717             )
718         elif s == "-":
719             sources.add(p)
720         else:
721             err(f"invalid path: {s}")
722     return sources
723
724
725 def path_empty(
726     src: Sized, msg: str, quiet: bool, verbose: bool, ctx: click.Context
727 ) -> None:
728     """
729     Exit if there is no `src` provided for formatting
730     """
731     if not src and (verbose or not quiet):
732         out(msg)
733         ctx.exit(0)
734
735
736 def reformat_one(
737     src: Path, fast: bool, write_back: WriteBack, mode: Mode, report: "Report"
738 ) -> None:
739     """Reformat a single file under `src` without spawning child processes.
740
741     `fast`, `write_back`, and `mode` options are passed to
742     :func:`format_file_in_place` or :func:`format_stdin_to_stdout`.
743     """
744     try:
745         changed = Changed.NO
746
747         if str(src) == "-":
748             is_stdin = True
749         elif str(src).startswith(STDIN_PLACEHOLDER):
750             is_stdin = True
751             # Use the original name again in case we want to print something
752             # to the user
753             src = Path(str(src)[len(STDIN_PLACEHOLDER) :])
754         else:
755             is_stdin = False
756
757         if is_stdin:
758             if format_stdin_to_stdout(fast=fast, write_back=write_back, mode=mode):
759                 changed = Changed.YES
760         else:
761             cache: Cache = {}
762             if write_back not in (WriteBack.DIFF, WriteBack.COLOR_DIFF):
763                 cache = read_cache(mode)
764                 res_src = src.resolve()
765                 res_src_s = str(res_src)
766                 if res_src_s in cache and cache[res_src_s] == get_cache_info(res_src):
767                     changed = Changed.CACHED
768             if changed is not Changed.CACHED and format_file_in_place(
769                 src, fast=fast, write_back=write_back, mode=mode
770             ):
771                 changed = Changed.YES
772             if (write_back is WriteBack.YES and changed is not Changed.CACHED) or (
773                 write_back is WriteBack.CHECK and changed is Changed.NO
774             ):
775                 write_cache(cache, [src], mode)
776         report.done(src, changed)
777     except Exception as exc:
778         if report.verbose:
779             traceback.print_exc()
780         report.failed(src, str(exc))
781
782
783 def reformat_many(
784     sources: Set[Path], fast: bool, write_back: WriteBack, mode: Mode, report: "Report"
785 ) -> None:
786     """Reformat multiple files using a ProcessPoolExecutor."""
787     executor: Executor
788     loop = asyncio.get_event_loop()
789     worker_count = os.cpu_count()
790     if sys.platform == "win32":
791         # Work around https://bugs.python.org/issue26903
792         worker_count = min(worker_count, 60)
793     try:
794         executor = ProcessPoolExecutor(max_workers=worker_count)
795     except (ImportError, OSError):
796         # we arrive here if the underlying system does not support multi-processing
797         # like in AWS Lambda or Termux, in which case we gracefully fallback to
798         # a ThreadPoolExecutor with just a single worker (more workers would not do us
799         # any good due to the Global Interpreter Lock)
800         executor = ThreadPoolExecutor(max_workers=1)
801
802     try:
803         loop.run_until_complete(
804             schedule_formatting(
805                 sources=sources,
806                 fast=fast,
807                 write_back=write_back,
808                 mode=mode,
809                 report=report,
810                 loop=loop,
811                 executor=executor,
812             )
813         )
814     finally:
815         shutdown(loop)
816         if executor is not None:
817             executor.shutdown()
818
819
820 async def schedule_formatting(
821     sources: Set[Path],
822     fast: bool,
823     write_back: WriteBack,
824     mode: Mode,
825     report: "Report",
826     loop: asyncio.AbstractEventLoop,
827     executor: Executor,
828 ) -> None:
829     """Run formatting of `sources` in parallel using the provided `executor`.
830
831     (Use ProcessPoolExecutors for actual parallelism.)
832
833     `write_back`, `fast`, and `mode` options are passed to
834     :func:`format_file_in_place`.
835     """
836     cache: Cache = {}
837     if write_back not in (WriteBack.DIFF, WriteBack.COLOR_DIFF):
838         cache = read_cache(mode)
839         sources, cached = filter_cached(cache, sources)
840         for src in sorted(cached):
841             report.done(src, Changed.CACHED)
842     if not sources:
843         return
844
845     cancelled = []
846     sources_to_cache = []
847     lock = None
848     if write_back in (WriteBack.DIFF, WriteBack.COLOR_DIFF):
849         # For diff output, we need locks to ensure we don't interleave output
850         # from different processes.
851         manager = Manager()
852         lock = manager.Lock()
853     tasks = {
854         asyncio.ensure_future(
855             loop.run_in_executor(
856                 executor, format_file_in_place, src, fast, mode, write_back, lock
857             )
858         ): src
859         for src in sorted(sources)
860     }
861     pending = tasks.keys()
862     try:
863         loop.add_signal_handler(signal.SIGINT, cancel, pending)
864         loop.add_signal_handler(signal.SIGTERM, cancel, pending)
865     except NotImplementedError:
866         # There are no good alternatives for these on Windows.
867         pass
868     while pending:
869         done, _ = await asyncio.wait(pending, return_when=asyncio.FIRST_COMPLETED)
870         for task in done:
871             src = tasks.pop(task)
872             if task.cancelled():
873                 cancelled.append(task)
874             elif task.exception():
875                 report.failed(src, str(task.exception()))
876             else:
877                 changed = Changed.YES if task.result() else Changed.NO
878                 # If the file was written back or was successfully checked as
879                 # well-formatted, store this information in the cache.
880                 if write_back is WriteBack.YES or (
881                     write_back is WriteBack.CHECK and changed is Changed.NO
882                 ):
883                     sources_to_cache.append(src)
884                 report.done(src, changed)
885     if cancelled:
886         await asyncio.gather(*cancelled, loop=loop, return_exceptions=True)
887     if sources_to_cache:
888         write_cache(cache, sources_to_cache, mode)
889
890
891 def format_file_in_place(
892     src: Path,
893     fast: bool,
894     mode: Mode,
895     write_back: WriteBack = WriteBack.NO,
896     lock: Any = None,  # multiprocessing.Manager().Lock() is some crazy proxy
897 ) -> bool:
898     """Format file under `src` path. Return True if changed.
899
900     If `write_back` is DIFF, write a diff to stdout. If it is YES, write reformatted
901     code to the file.
902     `mode` and `fast` options are passed to :func:`format_file_contents`.
903     """
904     if src.suffix == ".pyi":
905         mode = replace(mode, is_pyi=True)
906
907     then = datetime.utcfromtimestamp(src.stat().st_mtime)
908     with open(src, "rb") as buf:
909         src_contents, encoding, newline = decode_bytes(buf.read())
910     try:
911         dst_contents = format_file_contents(src_contents, fast=fast, mode=mode)
912     except NothingChanged:
913         return False
914
915     if write_back == WriteBack.YES:
916         with open(src, "w", encoding=encoding, newline=newline) as f:
917             f.write(dst_contents)
918     elif write_back in (WriteBack.DIFF, WriteBack.COLOR_DIFF):
919         now = datetime.utcnow()
920         src_name = f"{src}\t{then} +0000"
921         dst_name = f"{src}\t{now} +0000"
922         diff_contents = diff(src_contents, dst_contents, src_name, dst_name)
923
924         if write_back == WriteBack.COLOR_DIFF:
925             diff_contents = color_diff(diff_contents)
926
927         with lock or nullcontext():
928             f = io.TextIOWrapper(
929                 sys.stdout.buffer,
930                 encoding=encoding,
931                 newline=newline,
932                 write_through=True,
933             )
934             f = wrap_stream_for_windows(f)
935             f.write(diff_contents)
936             f.detach()
937
938     return True
939
940
941 def color_diff(contents: str) -> str:
942     """Inject the ANSI color codes to the diff."""
943     lines = contents.split("\n")
944     for i, line in enumerate(lines):
945         if line.startswith("+++") or line.startswith("---"):
946             line = "\033[1;37m" + line + "\033[0m"  # bold white, reset
947         elif line.startswith("@@"):
948             line = "\033[36m" + line + "\033[0m"  # cyan, reset
949         elif line.startswith("+"):
950             line = "\033[32m" + line + "\033[0m"  # green, reset
951         elif line.startswith("-"):
952             line = "\033[31m" + line + "\033[0m"  # red, reset
953         lines[i] = line
954     return "\n".join(lines)
955
956
957 def wrap_stream_for_windows(
958     f: io.TextIOWrapper,
959 ) -> Union[io.TextIOWrapper, "colorama.AnsiToWin32"]:
960     """
961     Wrap stream with colorama's wrap_stream so colors are shown on Windows.
962
963     If `colorama` is unavailable, the original stream is returned unmodified.
964     Otherwise, the `wrap_stream()` function determines whether the stream needs
965     to be wrapped for a Windows environment and will accordingly either return
966     an `AnsiToWin32` wrapper or the original stream.
967     """
968     try:
969         from colorama.initialise import wrap_stream
970     except ImportError:
971         return f
972     else:
973         # Set `strip=False` to avoid needing to modify test_express_diff_with_color.
974         return wrap_stream(f, convert=None, strip=False, autoreset=False, wrap=True)
975
976
977 def format_stdin_to_stdout(
978     fast: bool, *, write_back: WriteBack = WriteBack.NO, mode: Mode
979 ) -> bool:
980     """Format file on stdin. Return True if changed.
981
982     If `write_back` is YES, write reformatted code back to stdout. If it is DIFF,
983     write a diff to stdout. The `mode` argument is passed to
984     :func:`format_file_contents`.
985     """
986     then = datetime.utcnow()
987     src, encoding, newline = decode_bytes(sys.stdin.buffer.read())
988     dst = src
989     try:
990         dst = format_file_contents(src, fast=fast, mode=mode)
991         return True
992
993     except NothingChanged:
994         return False
995
996     finally:
997         f = io.TextIOWrapper(
998             sys.stdout.buffer, encoding=encoding, newline=newline, write_through=True
999         )
1000         if write_back == WriteBack.YES:
1001             f.write(dst)
1002         elif write_back in (WriteBack.DIFF, WriteBack.COLOR_DIFF):
1003             now = datetime.utcnow()
1004             src_name = f"STDIN\t{then} +0000"
1005             dst_name = f"STDOUT\t{now} +0000"
1006             d = diff(src, dst, src_name, dst_name)
1007             if write_back == WriteBack.COLOR_DIFF:
1008                 d = color_diff(d)
1009                 f = wrap_stream_for_windows(f)
1010             f.write(d)
1011         f.detach()
1012
1013
1014 def format_file_contents(src_contents: str, *, fast: bool, mode: Mode) -> FileContent:
1015     """Reformat contents of a file and return new contents.
1016
1017     If `fast` is False, additionally confirm that the reformatted code is
1018     valid by calling :func:`assert_equivalent` and :func:`assert_stable` on it.
1019     `mode` is passed to :func:`format_str`.
1020     """
1021     if not src_contents.strip():
1022         raise NothingChanged
1023
1024     dst_contents = format_str(src_contents, mode=mode)
1025     if src_contents == dst_contents:
1026         raise NothingChanged
1027
1028     if not fast:
1029         assert_equivalent(src_contents, dst_contents)
1030
1031         # Forced second pass to work around optional trailing commas (becoming
1032         # forced trailing commas on pass 2) interacting differently with optional
1033         # parentheses.  Admittedly ugly.
1034         dst_contents_pass2 = format_str(dst_contents, mode=mode)
1035         if dst_contents != dst_contents_pass2:
1036             dst_contents = dst_contents_pass2
1037             assert_equivalent(src_contents, dst_contents, pass_num=2)
1038             assert_stable(src_contents, dst_contents, mode=mode)
1039         # Note: no need to explicitly call `assert_stable` if `dst_contents` was
1040         # the same as `dst_contents_pass2`.
1041     return dst_contents
1042
1043
1044 def format_str(src_contents: str, *, mode: Mode) -> FileContent:
1045     """Reformat a string and return new contents.
1046
1047     `mode` determines formatting options, such as how many characters per line are
1048     allowed.  Example:
1049
1050     >>> import black
1051     >>> print(black.format_str("def f(arg:str='')->None:...", mode=black.Mode()))
1052     def f(arg: str = "") -> None:
1053         ...
1054
1055     A more complex example:
1056
1057     >>> print(
1058     ...   black.format_str(
1059     ...     "def f(arg:str='')->None: hey",
1060     ...     mode=black.Mode(
1061     ...       target_versions={black.TargetVersion.PY36},
1062     ...       line_length=10,
1063     ...       string_normalization=False,
1064     ...       is_pyi=False,
1065     ...     ),
1066     ...   ),
1067     ... )
1068     def f(
1069         arg: str = '',
1070     ) -> None:
1071         hey
1072
1073     """
1074     src_node = lib2to3_parse(src_contents.lstrip(), mode.target_versions)
1075     dst_contents = []
1076     future_imports = get_future_imports(src_node)
1077     if mode.target_versions:
1078         versions = mode.target_versions
1079     else:
1080         versions = detect_target_versions(src_node)
1081     normalize_fmt_off(src_node)
1082     lines = LineGenerator(
1083         mode=mode,
1084         remove_u_prefix="unicode_literals" in future_imports
1085         or supports_feature(versions, Feature.UNICODE_LITERALS),
1086     )
1087     elt = EmptyLineTracker(is_pyi=mode.is_pyi)
1088     empty_line = Line(mode=mode)
1089     after = 0
1090     split_line_features = {
1091         feature
1092         for feature in {Feature.TRAILING_COMMA_IN_CALL, Feature.TRAILING_COMMA_IN_DEF}
1093         if supports_feature(versions, feature)
1094     }
1095     for current_line in lines.visit(src_node):
1096         dst_contents.append(str(empty_line) * after)
1097         before, after = elt.maybe_empty_lines(current_line)
1098         dst_contents.append(str(empty_line) * before)
1099         for line in transform_line(
1100             current_line, mode=mode, features=split_line_features
1101         ):
1102             dst_contents.append(str(line))
1103     return "".join(dst_contents)
1104
1105
1106 def decode_bytes(src: bytes) -> Tuple[FileContent, Encoding, NewLine]:
1107     """Return a tuple of (decoded_contents, encoding, newline).
1108
1109     `newline` is either CRLF or LF but `decoded_contents` is decoded with
1110     universal newlines (i.e. only contains LF).
1111     """
1112     srcbuf = io.BytesIO(src)
1113     encoding, lines = tokenize.detect_encoding(srcbuf.readline)
1114     if not lines:
1115         return "", encoding, "\n"
1116
1117     newline = "\r\n" if b"\r\n" == lines[0][-2:] else "\n"
1118     srcbuf.seek(0)
1119     with io.TextIOWrapper(srcbuf, encoding) as tiow:
1120         return tiow.read(), encoding, newline
1121
1122
1123 def get_grammars(target_versions: Set[TargetVersion]) -> List[Grammar]:
1124     if not target_versions:
1125         # No target_version specified, so try all grammars.
1126         return [
1127             # Python 3.7+
1128             pygram.python_grammar_no_print_statement_no_exec_statement_async_keywords,
1129             # Python 3.0-3.6
1130             pygram.python_grammar_no_print_statement_no_exec_statement,
1131             # Python 2.7 with future print_function import
1132             pygram.python_grammar_no_print_statement,
1133             # Python 2.7
1134             pygram.python_grammar,
1135         ]
1136
1137     if all(version.is_python2() for version in target_versions):
1138         # Python 2-only code, so try Python 2 grammars.
1139         return [
1140             # Python 2.7 with future print_function import
1141             pygram.python_grammar_no_print_statement,
1142             # Python 2.7
1143             pygram.python_grammar,
1144         ]
1145
1146     # Python 3-compatible code, so only try Python 3 grammar.
1147     grammars = []
1148     # If we have to parse both, try to parse async as a keyword first
1149     if not supports_feature(target_versions, Feature.ASYNC_IDENTIFIERS):
1150         # Python 3.7+
1151         grammars.append(
1152             pygram.python_grammar_no_print_statement_no_exec_statement_async_keywords
1153         )
1154     if not supports_feature(target_versions, Feature.ASYNC_KEYWORDS):
1155         # Python 3.0-3.6
1156         grammars.append(pygram.python_grammar_no_print_statement_no_exec_statement)
1157     # At least one of the above branches must have been taken, because every Python
1158     # version has exactly one of the two 'ASYNC_*' flags
1159     return grammars
1160
1161
1162 def lib2to3_parse(src_txt: str, target_versions: Iterable[TargetVersion] = ()) -> Node:
1163     """Given a string with source, return the lib2to3 Node."""
1164     if not src_txt.endswith("\n"):
1165         src_txt += "\n"
1166
1167     for grammar in get_grammars(set(target_versions)):
1168         drv = driver.Driver(grammar, pytree.convert)
1169         try:
1170             result = drv.parse_string(src_txt, True)
1171             break
1172
1173         except ParseError as pe:
1174             lineno, column = pe.context[1]
1175             lines = src_txt.splitlines()
1176             try:
1177                 faulty_line = lines[lineno - 1]
1178             except IndexError:
1179                 faulty_line = "<line number missing in source>"
1180             exc = InvalidInput(f"Cannot parse: {lineno}:{column}: {faulty_line}")
1181     else:
1182         raise exc from None
1183
1184     if isinstance(result, Leaf):
1185         result = Node(syms.file_input, [result])
1186     return result
1187
1188
1189 def lib2to3_unparse(node: Node) -> str:
1190     """Given a lib2to3 node, return its string representation."""
1191     code = str(node)
1192     return code
1193
1194
1195 class Visitor(Generic[T]):
1196     """Basic lib2to3 visitor that yields things of type `T` on `visit()`."""
1197
1198     def visit(self, node: LN) -> Iterator[T]:
1199         """Main method to visit `node` and its children.
1200
1201         It tries to find a `visit_*()` method for the given `node.type`, like
1202         `visit_simple_stmt` for Node objects or `visit_INDENT` for Leaf objects.
1203         If no dedicated `visit_*()` method is found, chooses `visit_default()`
1204         instead.
1205
1206         Then yields objects of type `T` from the selected visitor.
1207         """
1208         if node.type < 256:
1209             name = token.tok_name[node.type]
1210         else:
1211             name = str(type_repr(node.type))
1212         # We explicitly branch on whether a visitor exists (instead of
1213         # using self.visit_default as the default arg to getattr) in order
1214         # to save needing to create a bound method object and so mypyc can
1215         # generate a native call to visit_default.
1216         visitf = getattr(self, f"visit_{name}", None)
1217         if visitf:
1218             yield from visitf(node)
1219         else:
1220             yield from self.visit_default(node)
1221
1222     def visit_default(self, node: LN) -> Iterator[T]:
1223         """Default `visit_*()` implementation. Recurses to children of `node`."""
1224         if isinstance(node, Node):
1225             for child in node.children:
1226                 yield from self.visit(child)
1227
1228
1229 @dataclass
1230 class DebugVisitor(Visitor[T]):
1231     tree_depth: int = 0
1232
1233     def visit_default(self, node: LN) -> Iterator[T]:
1234         indent = " " * (2 * self.tree_depth)
1235         if isinstance(node, Node):
1236             _type = type_repr(node.type)
1237             out(f"{indent}{_type}", fg="yellow")
1238             self.tree_depth += 1
1239             for child in node.children:
1240                 yield from self.visit(child)
1241
1242             self.tree_depth -= 1
1243             out(f"{indent}/{_type}", fg="yellow", bold=False)
1244         else:
1245             _type = token.tok_name.get(node.type, str(node.type))
1246             out(f"{indent}{_type}", fg="blue", nl=False)
1247             if node.prefix:
1248                 # We don't have to handle prefixes for `Node` objects since
1249                 # that delegates to the first child anyway.
1250                 out(f" {node.prefix!r}", fg="green", bold=False, nl=False)
1251             out(f" {node.value!r}", fg="blue", bold=False)
1252
1253     @classmethod
1254     def show(cls, code: Union[str, Leaf, Node]) -> None:
1255         """Pretty-print the lib2to3 AST of a given string of `code`.
1256
1257         Convenience method for debugging.
1258         """
1259         v: DebugVisitor[None] = DebugVisitor()
1260         if isinstance(code, str):
1261             code = lib2to3_parse(code)
1262         list(v.visit(code))
1263
1264
1265 WHITESPACE: Final = {token.DEDENT, token.INDENT, token.NEWLINE}
1266 STATEMENT: Final = {
1267     syms.if_stmt,
1268     syms.while_stmt,
1269     syms.for_stmt,
1270     syms.try_stmt,
1271     syms.except_clause,
1272     syms.with_stmt,
1273     syms.funcdef,
1274     syms.classdef,
1275 }
1276 STANDALONE_COMMENT: Final = 153
1277 token.tok_name[STANDALONE_COMMENT] = "STANDALONE_COMMENT"
1278 LOGIC_OPERATORS: Final = {"and", "or"}
1279 COMPARATORS: Final = {
1280     token.LESS,
1281     token.GREATER,
1282     token.EQEQUAL,
1283     token.NOTEQUAL,
1284     token.LESSEQUAL,
1285     token.GREATEREQUAL,
1286 }
1287 MATH_OPERATORS: Final = {
1288     token.VBAR,
1289     token.CIRCUMFLEX,
1290     token.AMPER,
1291     token.LEFTSHIFT,
1292     token.RIGHTSHIFT,
1293     token.PLUS,
1294     token.MINUS,
1295     token.STAR,
1296     token.SLASH,
1297     token.DOUBLESLASH,
1298     token.PERCENT,
1299     token.AT,
1300     token.TILDE,
1301     token.DOUBLESTAR,
1302 }
1303 STARS: Final = {token.STAR, token.DOUBLESTAR}
1304 VARARGS_SPECIALS: Final = STARS | {token.SLASH}
1305 VARARGS_PARENTS: Final = {
1306     syms.arglist,
1307     syms.argument,  # double star in arglist
1308     syms.trailer,  # single argument to call
1309     syms.typedargslist,
1310     syms.varargslist,  # lambdas
1311 }
1312 UNPACKING_PARENTS: Final = {
1313     syms.atom,  # single element of a list or set literal
1314     syms.dictsetmaker,
1315     syms.listmaker,
1316     syms.testlist_gexp,
1317     syms.testlist_star_expr,
1318 }
1319 TEST_DESCENDANTS: Final = {
1320     syms.test,
1321     syms.lambdef,
1322     syms.or_test,
1323     syms.and_test,
1324     syms.not_test,
1325     syms.comparison,
1326     syms.star_expr,
1327     syms.expr,
1328     syms.xor_expr,
1329     syms.and_expr,
1330     syms.shift_expr,
1331     syms.arith_expr,
1332     syms.trailer,
1333     syms.term,
1334     syms.power,
1335 }
1336 ASSIGNMENTS: Final = {
1337     "=",
1338     "+=",
1339     "-=",
1340     "*=",
1341     "@=",
1342     "/=",
1343     "%=",
1344     "&=",
1345     "|=",
1346     "^=",
1347     "<<=",
1348     ">>=",
1349     "**=",
1350     "//=",
1351 }
1352 COMPREHENSION_PRIORITY: Final = 20
1353 COMMA_PRIORITY: Final = 18
1354 TERNARY_PRIORITY: Final = 16
1355 LOGIC_PRIORITY: Final = 14
1356 STRING_PRIORITY: Final = 12
1357 COMPARATOR_PRIORITY: Final = 10
1358 MATH_PRIORITIES: Final = {
1359     token.VBAR: 9,
1360     token.CIRCUMFLEX: 8,
1361     token.AMPER: 7,
1362     token.LEFTSHIFT: 6,
1363     token.RIGHTSHIFT: 6,
1364     token.PLUS: 5,
1365     token.MINUS: 5,
1366     token.STAR: 4,
1367     token.SLASH: 4,
1368     token.DOUBLESLASH: 4,
1369     token.PERCENT: 4,
1370     token.AT: 4,
1371     token.TILDE: 3,
1372     token.DOUBLESTAR: 2,
1373 }
1374 DOT_PRIORITY: Final = 1
1375
1376
1377 @dataclass
1378 class BracketTracker:
1379     """Keeps track of brackets on a line."""
1380
1381     depth: int = 0
1382     bracket_match: Dict[Tuple[Depth, NodeType], Leaf] = field(default_factory=dict)
1383     delimiters: Dict[LeafID, Priority] = field(default_factory=dict)
1384     previous: Optional[Leaf] = None
1385     _for_loop_depths: List[int] = field(default_factory=list)
1386     _lambda_argument_depths: List[int] = field(default_factory=list)
1387     invisible: List[Leaf] = field(default_factory=list)
1388
1389     def mark(self, leaf: Leaf) -> None:
1390         """Mark `leaf` with bracket-related metadata. Keep track of delimiters.
1391
1392         All leaves receive an int `bracket_depth` field that stores how deep
1393         within brackets a given leaf is. 0 means there are no enclosing brackets
1394         that started on this line.
1395
1396         If a leaf is itself a closing bracket, it receives an `opening_bracket`
1397         field that it forms a pair with. This is a one-directional link to
1398         avoid reference cycles.
1399
1400         If a leaf is a delimiter (a token on which Black can split the line if
1401         needed) and it's on depth 0, its `id()` is stored in the tracker's
1402         `delimiters` field.
1403         """
1404         if leaf.type == token.COMMENT:
1405             return
1406
1407         self.maybe_decrement_after_for_loop_variable(leaf)
1408         self.maybe_decrement_after_lambda_arguments(leaf)
1409         if leaf.type in CLOSING_BRACKETS:
1410             self.depth -= 1
1411             try:
1412                 opening_bracket = self.bracket_match.pop((self.depth, leaf.type))
1413             except KeyError as e:
1414                 raise BracketMatchError(
1415                     "Unable to match a closing bracket to the following opening"
1416                     f" bracket: {leaf}"
1417                 ) from e
1418             leaf.opening_bracket = opening_bracket
1419             if not leaf.value:
1420                 self.invisible.append(leaf)
1421         leaf.bracket_depth = self.depth
1422         if self.depth == 0:
1423             delim = is_split_before_delimiter(leaf, self.previous)
1424             if delim and self.previous is not None:
1425                 self.delimiters[id(self.previous)] = delim
1426             else:
1427                 delim = is_split_after_delimiter(leaf, self.previous)
1428                 if delim:
1429                     self.delimiters[id(leaf)] = delim
1430         if leaf.type in OPENING_BRACKETS:
1431             self.bracket_match[self.depth, BRACKET[leaf.type]] = leaf
1432             self.depth += 1
1433             if not leaf.value:
1434                 self.invisible.append(leaf)
1435         self.previous = leaf
1436         self.maybe_increment_lambda_arguments(leaf)
1437         self.maybe_increment_for_loop_variable(leaf)
1438
1439     def any_open_brackets(self) -> bool:
1440         """Return True if there is an yet unmatched open bracket on the line."""
1441         return bool(self.bracket_match)
1442
1443     def max_delimiter_priority(self, exclude: Iterable[LeafID] = ()) -> Priority:
1444         """Return the highest priority of a delimiter found on the line.
1445
1446         Values are consistent with what `is_split_*_delimiter()` return.
1447         Raises ValueError on no delimiters.
1448         """
1449         return max(v for k, v in self.delimiters.items() if k not in exclude)
1450
1451     def delimiter_count_with_priority(self, priority: Priority = 0) -> int:
1452         """Return the number of delimiters with the given `priority`.
1453
1454         If no `priority` is passed, defaults to max priority on the line.
1455         """
1456         if not self.delimiters:
1457             return 0
1458
1459         priority = priority or self.max_delimiter_priority()
1460         return sum(1 for p in self.delimiters.values() if p == priority)
1461
1462     def maybe_increment_for_loop_variable(self, leaf: Leaf) -> bool:
1463         """In a for loop, or comprehension, the variables are often unpacks.
1464
1465         To avoid splitting on the comma in this situation, increase the depth of
1466         tokens between `for` and `in`.
1467         """
1468         if leaf.type == token.NAME and leaf.value == "for":
1469             self.depth += 1
1470             self._for_loop_depths.append(self.depth)
1471             return True
1472
1473         return False
1474
1475     def maybe_decrement_after_for_loop_variable(self, leaf: Leaf) -> bool:
1476         """See `maybe_increment_for_loop_variable` above for explanation."""
1477         if (
1478             self._for_loop_depths
1479             and self._for_loop_depths[-1] == self.depth
1480             and leaf.type == token.NAME
1481             and leaf.value == "in"
1482         ):
1483             self.depth -= 1
1484             self._for_loop_depths.pop()
1485             return True
1486
1487         return False
1488
1489     def maybe_increment_lambda_arguments(self, leaf: Leaf) -> bool:
1490         """In a lambda expression, there might be more than one argument.
1491
1492         To avoid splitting on the comma in this situation, increase the depth of
1493         tokens between `lambda` and `:`.
1494         """
1495         if leaf.type == token.NAME and leaf.value == "lambda":
1496             self.depth += 1
1497             self._lambda_argument_depths.append(self.depth)
1498             return True
1499
1500         return False
1501
1502     def maybe_decrement_after_lambda_arguments(self, leaf: Leaf) -> bool:
1503         """See `maybe_increment_lambda_arguments` above for explanation."""
1504         if (
1505             self._lambda_argument_depths
1506             and self._lambda_argument_depths[-1] == self.depth
1507             and leaf.type == token.COLON
1508         ):
1509             self.depth -= 1
1510             self._lambda_argument_depths.pop()
1511             return True
1512
1513         return False
1514
1515     def get_open_lsqb(self) -> Optional[Leaf]:
1516         """Return the most recent opening square bracket (if any)."""
1517         return self.bracket_match.get((self.depth - 1, token.RSQB))
1518
1519
1520 @dataclass
1521 class Line:
1522     """Holds leaves and comments. Can be printed with `str(line)`."""
1523
1524     mode: Mode
1525     depth: int = 0
1526     leaves: List[Leaf] = field(default_factory=list)
1527     # keys ordered like `leaves`
1528     comments: Dict[LeafID, List[Leaf]] = field(default_factory=dict)
1529     bracket_tracker: BracketTracker = field(default_factory=BracketTracker)
1530     inside_brackets: bool = False
1531     should_split_rhs: bool = False
1532     magic_trailing_comma: Optional[Leaf] = None
1533
1534     def append(self, leaf: Leaf, preformatted: bool = False) -> None:
1535         """Add a new `leaf` to the end of the line.
1536
1537         Unless `preformatted` is True, the `leaf` will receive a new consistent
1538         whitespace prefix and metadata applied by :class:`BracketTracker`.
1539         Trailing commas are maybe removed, unpacked for loop variables are
1540         demoted from being delimiters.
1541
1542         Inline comments are put aside.
1543         """
1544         has_value = leaf.type in BRACKETS or bool(leaf.value.strip())
1545         if not has_value:
1546             return
1547
1548         if token.COLON == leaf.type and self.is_class_paren_empty:
1549             del self.leaves[-2:]
1550         if self.leaves and not preformatted:
1551             # Note: at this point leaf.prefix should be empty except for
1552             # imports, for which we only preserve newlines.
1553             leaf.prefix += whitespace(
1554                 leaf, complex_subscript=self.is_complex_subscript(leaf)
1555             )
1556         if self.inside_brackets or not preformatted:
1557             self.bracket_tracker.mark(leaf)
1558             if self.mode.magic_trailing_comma:
1559                 if self.has_magic_trailing_comma(leaf):
1560                     self.magic_trailing_comma = leaf
1561             elif self.has_magic_trailing_comma(leaf, ensure_removable=True):
1562                 self.remove_trailing_comma()
1563         if not self.append_comment(leaf):
1564             self.leaves.append(leaf)
1565
1566     def append_safe(self, leaf: Leaf, preformatted: bool = False) -> None:
1567         """Like :func:`append()` but disallow invalid standalone comment structure.
1568
1569         Raises ValueError when any `leaf` is appended after a standalone comment
1570         or when a standalone comment is not the first leaf on the line.
1571         """
1572         if self.bracket_tracker.depth == 0:
1573             if self.is_comment:
1574                 raise ValueError("cannot append to standalone comments")
1575
1576             if self.leaves and leaf.type == STANDALONE_COMMENT:
1577                 raise ValueError(
1578                     "cannot append standalone comments to a populated line"
1579                 )
1580
1581         self.append(leaf, preformatted=preformatted)
1582
1583     @property
1584     def is_comment(self) -> bool:
1585         """Is this line a standalone comment?"""
1586         return len(self.leaves) == 1 and self.leaves[0].type == STANDALONE_COMMENT
1587
1588     @property
1589     def is_decorator(self) -> bool:
1590         """Is this line a decorator?"""
1591         return bool(self) and self.leaves[0].type == token.AT
1592
1593     @property
1594     def is_import(self) -> bool:
1595         """Is this an import line?"""
1596         return bool(self) and is_import(self.leaves[0])
1597
1598     @property
1599     def is_class(self) -> bool:
1600         """Is this line a class definition?"""
1601         return (
1602             bool(self)
1603             and self.leaves[0].type == token.NAME
1604             and self.leaves[0].value == "class"
1605         )
1606
1607     @property
1608     def is_stub_class(self) -> bool:
1609         """Is this line a class definition with a body consisting only of "..."?"""
1610         return self.is_class and self.leaves[-3:] == [
1611             Leaf(token.DOT, ".") for _ in range(3)
1612         ]
1613
1614     @property
1615     def is_def(self) -> bool:
1616         """Is this a function definition? (Also returns True for async defs.)"""
1617         try:
1618             first_leaf = self.leaves[0]
1619         except IndexError:
1620             return False
1621
1622         try:
1623             second_leaf: Optional[Leaf] = self.leaves[1]
1624         except IndexError:
1625             second_leaf = None
1626         return (first_leaf.type == token.NAME and first_leaf.value == "def") or (
1627             first_leaf.type == token.ASYNC
1628             and second_leaf is not None
1629             and second_leaf.type == token.NAME
1630             and second_leaf.value == "def"
1631         )
1632
1633     @property
1634     def is_class_paren_empty(self) -> bool:
1635         """Is this a class with no base classes but using parentheses?
1636
1637         Those are unnecessary and should be removed.
1638         """
1639         return (
1640             bool(self)
1641             and len(self.leaves) == 4
1642             and self.is_class
1643             and self.leaves[2].type == token.LPAR
1644             and self.leaves[2].value == "("
1645             and self.leaves[3].type == token.RPAR
1646             and self.leaves[3].value == ")"
1647         )
1648
1649     @property
1650     def is_triple_quoted_string(self) -> bool:
1651         """Is the line a triple quoted string?"""
1652         return (
1653             bool(self)
1654             and self.leaves[0].type == token.STRING
1655             and self.leaves[0].value.startswith(('"""', "'''"))
1656         )
1657
1658     def contains_standalone_comments(self, depth_limit: int = sys.maxsize) -> bool:
1659         """If so, needs to be split before emitting."""
1660         for leaf in self.leaves:
1661             if leaf.type == STANDALONE_COMMENT and leaf.bracket_depth <= depth_limit:
1662                 return True
1663
1664         return False
1665
1666     def contains_uncollapsable_type_comments(self) -> bool:
1667         ignored_ids = set()
1668         try:
1669             last_leaf = self.leaves[-1]
1670             ignored_ids.add(id(last_leaf))
1671             if last_leaf.type == token.COMMA or (
1672                 last_leaf.type == token.RPAR and not last_leaf.value
1673             ):
1674                 # When trailing commas or optional parens are inserted by Black for
1675                 # consistency, comments after the previous last element are not moved
1676                 # (they don't have to, rendering will still be correct).  So we ignore
1677                 # trailing commas and invisible.
1678                 last_leaf = self.leaves[-2]
1679                 ignored_ids.add(id(last_leaf))
1680         except IndexError:
1681             return False
1682
1683         # A type comment is uncollapsable if it is attached to a leaf
1684         # that isn't at the end of the line (since that could cause it
1685         # to get associated to a different argument) or if there are
1686         # comments before it (since that could cause it to get hidden
1687         # behind a comment.
1688         comment_seen = False
1689         for leaf_id, comments in self.comments.items():
1690             for comment in comments:
1691                 if is_type_comment(comment):
1692                     if comment_seen or (
1693                         not is_type_comment(comment, " ignore")
1694                         and leaf_id not in ignored_ids
1695                     ):
1696                         return True
1697
1698                 comment_seen = True
1699
1700         return False
1701
1702     def contains_unsplittable_type_ignore(self) -> bool:
1703         if not self.leaves:
1704             return False
1705
1706         # If a 'type: ignore' is attached to the end of a line, we
1707         # can't split the line, because we can't know which of the
1708         # subexpressions the ignore was meant to apply to.
1709         #
1710         # We only want this to apply to actual physical lines from the
1711         # original source, though: we don't want the presence of a
1712         # 'type: ignore' at the end of a multiline expression to
1713         # justify pushing it all onto one line. Thus we
1714         # (unfortunately) need to check the actual source lines and
1715         # only report an unsplittable 'type: ignore' if this line was
1716         # one line in the original code.
1717
1718         # Grab the first and last line numbers, skipping generated leaves
1719         first_line = next((leaf.lineno for leaf in self.leaves if leaf.lineno != 0), 0)
1720         last_line = next(
1721             (leaf.lineno for leaf in reversed(self.leaves) if leaf.lineno != 0), 0
1722         )
1723
1724         if first_line == last_line:
1725             # We look at the last two leaves since a comma or an
1726             # invisible paren could have been added at the end of the
1727             # line.
1728             for node in self.leaves[-2:]:
1729                 for comment in self.comments.get(id(node), []):
1730                     if is_type_comment(comment, " ignore"):
1731                         return True
1732
1733         return False
1734
1735     def contains_multiline_strings(self) -> bool:
1736         return any(is_multiline_string(leaf) for leaf in self.leaves)
1737
1738     def has_magic_trailing_comma(
1739         self, closing: Leaf, ensure_removable: bool = False
1740     ) -> bool:
1741         """Return True if we have a magic trailing comma, that is when:
1742         - there's a trailing comma here
1743         - it's not a one-tuple
1744         Additionally, if ensure_removable:
1745         - it's not from square bracket indexing
1746         """
1747         if not (
1748             closing.type in CLOSING_BRACKETS
1749             and self.leaves
1750             and self.leaves[-1].type == token.COMMA
1751         ):
1752             return False
1753
1754         if closing.type == token.RBRACE:
1755             return True
1756
1757         if closing.type == token.RSQB:
1758             if not ensure_removable:
1759                 return True
1760             comma = self.leaves[-1]
1761             return bool(comma.parent and comma.parent.type == syms.listmaker)
1762
1763         if self.is_import:
1764             return True
1765
1766         if not is_one_tuple_between(closing.opening_bracket, closing, self.leaves):
1767             return True
1768
1769         return False
1770
1771     def append_comment(self, comment: Leaf) -> bool:
1772         """Add an inline or standalone comment to the line."""
1773         if (
1774             comment.type == STANDALONE_COMMENT
1775             and self.bracket_tracker.any_open_brackets()
1776         ):
1777             comment.prefix = ""
1778             return False
1779
1780         if comment.type != token.COMMENT:
1781             return False
1782
1783         if not self.leaves:
1784             comment.type = STANDALONE_COMMENT
1785             comment.prefix = ""
1786             return False
1787
1788         last_leaf = self.leaves[-1]
1789         if (
1790             last_leaf.type == token.RPAR
1791             and not last_leaf.value
1792             and last_leaf.parent
1793             and len(list(last_leaf.parent.leaves())) <= 3
1794             and not is_type_comment(comment)
1795         ):
1796             # Comments on an optional parens wrapping a single leaf should belong to
1797             # the wrapped node except if it's a type comment. Pinning the comment like
1798             # this avoids unstable formatting caused by comment migration.
1799             if len(self.leaves) < 2:
1800                 comment.type = STANDALONE_COMMENT
1801                 comment.prefix = ""
1802                 return False
1803
1804             last_leaf = self.leaves[-2]
1805         self.comments.setdefault(id(last_leaf), []).append(comment)
1806         return True
1807
1808     def comments_after(self, leaf: Leaf) -> List[Leaf]:
1809         """Generate comments that should appear directly after `leaf`."""
1810         return self.comments.get(id(leaf), [])
1811
1812     def remove_trailing_comma(self) -> None:
1813         """Remove the trailing comma and moves the comments attached to it."""
1814         trailing_comma = self.leaves.pop()
1815         trailing_comma_comments = self.comments.pop(id(trailing_comma), [])
1816         self.comments.setdefault(id(self.leaves[-1]), []).extend(
1817             trailing_comma_comments
1818         )
1819
1820     def is_complex_subscript(self, leaf: Leaf) -> bool:
1821         """Return True iff `leaf` is part of a slice with non-trivial exprs."""
1822         open_lsqb = self.bracket_tracker.get_open_lsqb()
1823         if open_lsqb is None:
1824             return False
1825
1826         subscript_start = open_lsqb.next_sibling
1827
1828         if isinstance(subscript_start, Node):
1829             if subscript_start.type == syms.listmaker:
1830                 return False
1831
1832             if subscript_start.type == syms.subscriptlist:
1833                 subscript_start = child_towards(subscript_start, leaf)
1834         return subscript_start is not None and any(
1835             n.type in TEST_DESCENDANTS for n in subscript_start.pre_order()
1836         )
1837
1838     def clone(self) -> "Line":
1839         return Line(
1840             mode=self.mode,
1841             depth=self.depth,
1842             inside_brackets=self.inside_brackets,
1843             should_split_rhs=self.should_split_rhs,
1844             magic_trailing_comma=self.magic_trailing_comma,
1845         )
1846
1847     def __str__(self) -> str:
1848         """Render the line."""
1849         if not self:
1850             return "\n"
1851
1852         indent = "    " * self.depth
1853         leaves = iter(self.leaves)
1854         first = next(leaves)
1855         res = f"{first.prefix}{indent}{first.value}"
1856         for leaf in leaves:
1857             res += str(leaf)
1858         for comment in itertools.chain.from_iterable(self.comments.values()):
1859             res += str(comment)
1860
1861         return res + "\n"
1862
1863     def __bool__(self) -> bool:
1864         """Return True if the line has leaves or comments."""
1865         return bool(self.leaves or self.comments)
1866
1867
1868 @dataclass
1869 class EmptyLineTracker:
1870     """Provides a stateful method that returns the number of potential extra
1871     empty lines needed before and after the currently processed line.
1872
1873     Note: this tracker works on lines that haven't been split yet.  It assumes
1874     the prefix of the first leaf consists of optional newlines.  Those newlines
1875     are consumed by `maybe_empty_lines()` and included in the computation.
1876     """
1877
1878     is_pyi: bool = False
1879     previous_line: Optional[Line] = None
1880     previous_after: int = 0
1881     previous_defs: List[int] = field(default_factory=list)
1882
1883     def maybe_empty_lines(self, current_line: Line) -> Tuple[int, int]:
1884         """Return the number of extra empty lines before and after the `current_line`.
1885
1886         This is for separating `def`, `async def` and `class` with extra empty
1887         lines (two on module-level).
1888         """
1889         before, after = self._maybe_empty_lines(current_line)
1890         before = (
1891             # Black should not insert empty lines at the beginning
1892             # of the file
1893             0
1894             if self.previous_line is None
1895             else before - self.previous_after
1896         )
1897         self.previous_after = after
1898         self.previous_line = current_line
1899         return before, after
1900
1901     def _maybe_empty_lines(self, current_line: Line) -> Tuple[int, int]:
1902         max_allowed = 1
1903         if current_line.depth == 0:
1904             max_allowed = 1 if self.is_pyi else 2
1905         if current_line.leaves:
1906             # Consume the first leaf's extra newlines.
1907             first_leaf = current_line.leaves[0]
1908             before = first_leaf.prefix.count("\n")
1909             before = min(before, max_allowed)
1910             first_leaf.prefix = ""
1911         else:
1912             before = 0
1913         depth = current_line.depth
1914         while self.previous_defs and self.previous_defs[-1] >= depth:
1915             self.previous_defs.pop()
1916             if self.is_pyi:
1917                 before = 0 if depth else 1
1918             else:
1919                 before = 1 if depth else 2
1920         if current_line.is_decorator or current_line.is_def or current_line.is_class:
1921             return self._maybe_empty_lines_for_class_or_def(current_line, before)
1922
1923         if (
1924             self.previous_line
1925             and self.previous_line.is_import
1926             and not current_line.is_import
1927             and depth == self.previous_line.depth
1928         ):
1929             return (before or 1), 0
1930
1931         if (
1932             self.previous_line
1933             and self.previous_line.is_class
1934             and current_line.is_triple_quoted_string
1935         ):
1936             return before, 1
1937
1938         return before, 0
1939
1940     def _maybe_empty_lines_for_class_or_def(
1941         self, current_line: Line, before: int
1942     ) -> Tuple[int, int]:
1943         if not current_line.is_decorator:
1944             self.previous_defs.append(current_line.depth)
1945         if self.previous_line is None:
1946             # Don't insert empty lines before the first line in the file.
1947             return 0, 0
1948
1949         if self.previous_line.is_decorator:
1950             if self.is_pyi and current_line.is_stub_class:
1951                 # Insert an empty line after a decorated stub class
1952                 return 0, 1
1953
1954             return 0, 0
1955
1956         if self.previous_line.depth < current_line.depth and (
1957             self.previous_line.is_class or self.previous_line.is_def
1958         ):
1959             return 0, 0
1960
1961         if (
1962             self.previous_line.is_comment
1963             and self.previous_line.depth == current_line.depth
1964             and before == 0
1965         ):
1966             return 0, 0
1967
1968         if self.is_pyi:
1969             if self.previous_line.depth > current_line.depth:
1970                 newlines = 1
1971             elif current_line.is_class or self.previous_line.is_class:
1972                 if current_line.is_stub_class and self.previous_line.is_stub_class:
1973                     # No blank line between classes with an empty body
1974                     newlines = 0
1975                 else:
1976                     newlines = 1
1977             elif (
1978                 current_line.is_def or current_line.is_decorator
1979             ) and not self.previous_line.is_def:
1980                 # Blank line between a block of functions (maybe with preceding
1981                 # decorators) and a block of non-functions
1982                 newlines = 1
1983             else:
1984                 newlines = 0
1985         else:
1986             newlines = 2
1987         if current_line.depth and newlines:
1988             newlines -= 1
1989         return newlines, 0
1990
1991
1992 @dataclass
1993 class LineGenerator(Visitor[Line]):
1994     """Generates reformatted Line objects.  Empty lines are not emitted.
1995
1996     Note: destroys the tree it's visiting by mutating prefixes of its leaves
1997     in ways that will no longer stringify to valid Python code on the tree.
1998     """
1999
2000     mode: Mode
2001     remove_u_prefix: bool = False
2002     current_line: Line = field(init=False)
2003
2004     def line(self, indent: int = 0) -> Iterator[Line]:
2005         """Generate a line.
2006
2007         If the line is empty, only emit if it makes sense.
2008         If the line is too long, split it first and then generate.
2009
2010         If any lines were generated, set up a new current_line.
2011         """
2012         if not self.current_line:
2013             self.current_line.depth += indent
2014             return  # Line is empty, don't emit. Creating a new one unnecessary.
2015
2016         complete_line = self.current_line
2017         self.current_line = Line(mode=self.mode, depth=complete_line.depth + indent)
2018         yield complete_line
2019
2020     def visit_default(self, node: LN) -> Iterator[Line]:
2021         """Default `visit_*()` implementation. Recurses to children of `node`."""
2022         if isinstance(node, Leaf):
2023             any_open_brackets = self.current_line.bracket_tracker.any_open_brackets()
2024             for comment in generate_comments(node):
2025                 if any_open_brackets:
2026                     # any comment within brackets is subject to splitting
2027                     self.current_line.append(comment)
2028                 elif comment.type == token.COMMENT:
2029                     # regular trailing comment
2030                     self.current_line.append(comment)
2031                     yield from self.line()
2032
2033                 else:
2034                     # regular standalone comment
2035                     yield from self.line()
2036
2037                     self.current_line.append(comment)
2038                     yield from self.line()
2039
2040             normalize_prefix(node, inside_brackets=any_open_brackets)
2041             if self.mode.string_normalization and node.type == token.STRING:
2042                 normalize_string_prefix(node, remove_u_prefix=self.remove_u_prefix)
2043                 normalize_string_quotes(node)
2044             if node.type == token.NUMBER:
2045                 normalize_numeric_literal(node)
2046             if node.type not in WHITESPACE:
2047                 self.current_line.append(node)
2048         yield from super().visit_default(node)
2049
2050     def visit_INDENT(self, node: Leaf) -> Iterator[Line]:
2051         """Increase indentation level, maybe yield a line."""
2052         # In blib2to3 INDENT never holds comments.
2053         yield from self.line(+1)
2054         yield from self.visit_default(node)
2055
2056     def visit_DEDENT(self, node: Leaf) -> Iterator[Line]:
2057         """Decrease indentation level, maybe yield a line."""
2058         # The current line might still wait for trailing comments.  At DEDENT time
2059         # there won't be any (they would be prefixes on the preceding NEWLINE).
2060         # Emit the line then.
2061         yield from self.line()
2062
2063         # While DEDENT has no value, its prefix may contain standalone comments
2064         # that belong to the current indentation level.  Get 'em.
2065         yield from self.visit_default(node)
2066
2067         # Finally, emit the dedent.
2068         yield from self.line(-1)
2069
2070     def visit_stmt(
2071         self, node: Node, keywords: Set[str], parens: Set[str]
2072     ) -> Iterator[Line]:
2073         """Visit a statement.
2074
2075         This implementation is shared for `if`, `while`, `for`, `try`, `except`,
2076         `def`, `with`, `class`, `assert` and assignments.
2077
2078         The relevant Python language `keywords` for a given statement will be
2079         NAME leaves within it. This methods puts those on a separate line.
2080
2081         `parens` holds a set of string leaf values immediately after which
2082         invisible parens should be put.
2083         """
2084         normalize_invisible_parens(node, parens_after=parens)
2085         for child in node.children:
2086             if child.type == token.NAME and child.value in keywords:  # type: ignore
2087                 yield from self.line()
2088
2089             yield from self.visit(child)
2090
2091     def visit_suite(self, node: Node) -> Iterator[Line]:
2092         """Visit a suite."""
2093         if self.mode.is_pyi and is_stub_suite(node):
2094             yield from self.visit(node.children[2])
2095         else:
2096             yield from self.visit_default(node)
2097
2098     def visit_simple_stmt(self, node: Node) -> Iterator[Line]:
2099         """Visit a statement without nested statements."""
2100         if first_child_is_arith(node):
2101             wrap_in_parentheses(node, node.children[0], visible=False)
2102         is_suite_like = node.parent and node.parent.type in STATEMENT
2103         if is_suite_like:
2104             if self.mode.is_pyi and is_stub_body(node):
2105                 yield from self.visit_default(node)
2106             else:
2107                 yield from self.line(+1)
2108                 yield from self.visit_default(node)
2109                 yield from self.line(-1)
2110
2111         else:
2112             if (
2113                 not self.mode.is_pyi
2114                 or not node.parent
2115                 or not is_stub_suite(node.parent)
2116             ):
2117                 yield from self.line()
2118             yield from self.visit_default(node)
2119
2120     def visit_async_stmt(self, node: Node) -> Iterator[Line]:
2121         """Visit `async def`, `async for`, `async with`."""
2122         yield from self.line()
2123
2124         children = iter(node.children)
2125         for child in children:
2126             yield from self.visit(child)
2127
2128             if child.type == token.ASYNC:
2129                 break
2130
2131         internal_stmt = next(children)
2132         for child in internal_stmt.children:
2133             yield from self.visit(child)
2134
2135     def visit_decorators(self, node: Node) -> Iterator[Line]:
2136         """Visit decorators."""
2137         for child in node.children:
2138             yield from self.line()
2139             yield from self.visit(child)
2140
2141     def visit_SEMI(self, leaf: Leaf) -> Iterator[Line]:
2142         """Remove a semicolon and put the other statement on a separate line."""
2143         yield from self.line()
2144
2145     def visit_ENDMARKER(self, leaf: Leaf) -> Iterator[Line]:
2146         """End of file. Process outstanding comments and end with a newline."""
2147         yield from self.visit_default(leaf)
2148         yield from self.line()
2149
2150     def visit_STANDALONE_COMMENT(self, leaf: Leaf) -> Iterator[Line]:
2151         if not self.current_line.bracket_tracker.any_open_brackets():
2152             yield from self.line()
2153         yield from self.visit_default(leaf)
2154
2155     def visit_factor(self, node: Node) -> Iterator[Line]:
2156         """Force parentheses between a unary op and a binary power:
2157
2158         -2 ** 8 -> -(2 ** 8)
2159         """
2160         _operator, operand = node.children
2161         if (
2162             operand.type == syms.power
2163             and len(operand.children) == 3
2164             and operand.children[1].type == token.DOUBLESTAR
2165         ):
2166             lpar = Leaf(token.LPAR, "(")
2167             rpar = Leaf(token.RPAR, ")")
2168             index = operand.remove() or 0
2169             node.insert_child(index, Node(syms.atom, [lpar, operand, rpar]))
2170         yield from self.visit_default(node)
2171
2172     def visit_STRING(self, leaf: Leaf) -> Iterator[Line]:
2173         if is_docstring(leaf) and "\\\n" not in leaf.value:
2174             # We're ignoring docstrings with backslash newline escapes because changing
2175             # indentation of those changes the AST representation of the code.
2176             prefix = get_string_prefix(leaf.value)
2177             docstring = leaf.value[len(prefix) :]  # Remove the prefix
2178             quote_char = docstring[0]
2179             # A natural way to remove the outer quotes is to do:
2180             #   docstring = docstring.strip(quote_char)
2181             # but that breaks on """""x""" (which is '""x').
2182             # So we actually need to remove the first character and the next two
2183             # characters but only if they are the same as the first.
2184             quote_len = 1 if docstring[1] != quote_char else 3
2185             docstring = docstring[quote_len:-quote_len]
2186
2187             if is_multiline_string(leaf):
2188                 indent = " " * 4 * self.current_line.depth
2189                 docstring = fix_docstring(docstring, indent)
2190             else:
2191                 docstring = docstring.strip()
2192
2193             if docstring:
2194                 # Add some padding if the docstring starts / ends with a quote mark.
2195                 if docstring[0] == quote_char:
2196                     docstring = " " + docstring
2197                 if docstring[-1] == quote_char:
2198                     docstring += " "
2199                 if docstring[-1] == "\\":
2200                     backslash_count = len(docstring) - len(docstring.rstrip("\\"))
2201                     if backslash_count % 2:
2202                         # Odd number of tailing backslashes, add some padding to
2203                         # avoid escaping the closing string quote.
2204                         docstring += " "
2205             else:
2206                 # Add some padding if the docstring is empty.
2207                 docstring = " "
2208
2209             # We could enforce triple quotes at this point.
2210             quote = quote_char * quote_len
2211             leaf.value = prefix + quote + docstring + quote
2212
2213         yield from self.visit_default(leaf)
2214
2215     def __post_init__(self) -> None:
2216         """You are in a twisty little maze of passages."""
2217         self.current_line = Line(mode=self.mode)
2218
2219         v = self.visit_stmt
2220         Ø: Set[str] = set()
2221         self.visit_assert_stmt = partial(v, keywords={"assert"}, parens={"assert", ","})
2222         self.visit_if_stmt = partial(
2223             v, keywords={"if", "else", "elif"}, parens={"if", "elif"}
2224         )
2225         self.visit_while_stmt = partial(v, keywords={"while", "else"}, parens={"while"})
2226         self.visit_for_stmt = partial(v, keywords={"for", "else"}, parens={"for", "in"})
2227         self.visit_try_stmt = partial(
2228             v, keywords={"try", "except", "else", "finally"}, parens=Ø
2229         )
2230         self.visit_except_clause = partial(v, keywords={"except"}, parens=Ø)
2231         self.visit_with_stmt = partial(v, keywords={"with"}, parens=Ø)
2232         self.visit_funcdef = partial(v, keywords={"def"}, parens=Ø)
2233         self.visit_classdef = partial(v, keywords={"class"}, parens=Ø)
2234         self.visit_expr_stmt = partial(v, keywords=Ø, parens=ASSIGNMENTS)
2235         self.visit_return_stmt = partial(v, keywords={"return"}, parens={"return"})
2236         self.visit_import_from = partial(v, keywords=Ø, parens={"import"})
2237         self.visit_del_stmt = partial(v, keywords=Ø, parens={"del"})
2238         self.visit_async_funcdef = self.visit_async_stmt
2239         self.visit_decorated = self.visit_decorators
2240
2241
2242 IMPLICIT_TUPLE = {syms.testlist, syms.testlist_star_expr, syms.exprlist}
2243 BRACKET = {token.LPAR: token.RPAR, token.LSQB: token.RSQB, token.LBRACE: token.RBRACE}
2244 OPENING_BRACKETS = set(BRACKET.keys())
2245 CLOSING_BRACKETS = set(BRACKET.values())
2246 BRACKETS = OPENING_BRACKETS | CLOSING_BRACKETS
2247 ALWAYS_NO_SPACE = CLOSING_BRACKETS | {token.COMMA, STANDALONE_COMMENT}
2248
2249
2250 def whitespace(leaf: Leaf, *, complex_subscript: bool) -> str:  # noqa: C901
2251     """Return whitespace prefix if needed for the given `leaf`.
2252
2253     `complex_subscript` signals whether the given leaf is part of a subscription
2254     which has non-trivial arguments, like arithmetic expressions or function calls.
2255     """
2256     NO = ""
2257     SPACE = " "
2258     DOUBLESPACE = "  "
2259     t = leaf.type
2260     p = leaf.parent
2261     v = leaf.value
2262     if t in ALWAYS_NO_SPACE:
2263         return NO
2264
2265     if t == token.COMMENT:
2266         return DOUBLESPACE
2267
2268     assert p is not None, f"INTERNAL ERROR: hand-made leaf without parent: {leaf!r}"
2269     if t == token.COLON and p.type not in {
2270         syms.subscript,
2271         syms.subscriptlist,
2272         syms.sliceop,
2273     }:
2274         return NO
2275
2276     prev = leaf.prev_sibling
2277     if not prev:
2278         prevp = preceding_leaf(p)
2279         if not prevp or prevp.type in OPENING_BRACKETS:
2280             return NO
2281
2282         if t == token.COLON:
2283             if prevp.type == token.COLON:
2284                 return NO
2285
2286             elif prevp.type != token.COMMA and not complex_subscript:
2287                 return NO
2288
2289             return SPACE
2290
2291         if prevp.type == token.EQUAL:
2292             if prevp.parent:
2293                 if prevp.parent.type in {
2294                     syms.arglist,
2295                     syms.argument,
2296                     syms.parameters,
2297                     syms.varargslist,
2298                 }:
2299                     return NO
2300
2301                 elif prevp.parent.type == syms.typedargslist:
2302                     # A bit hacky: if the equal sign has whitespace, it means we
2303                     # previously found it's a typed argument.  So, we're using
2304                     # that, too.
2305                     return prevp.prefix
2306
2307         elif prevp.type in VARARGS_SPECIALS:
2308             if is_vararg(prevp, within=VARARGS_PARENTS | UNPACKING_PARENTS):
2309                 return NO
2310
2311         elif prevp.type == token.COLON:
2312             if prevp.parent and prevp.parent.type in {syms.subscript, syms.sliceop}:
2313                 return SPACE if complex_subscript else NO
2314
2315         elif (
2316             prevp.parent
2317             and prevp.parent.type == syms.factor
2318             and prevp.type in MATH_OPERATORS
2319         ):
2320             return NO
2321
2322         elif (
2323             prevp.type == token.RIGHTSHIFT
2324             and prevp.parent
2325             and prevp.parent.type == syms.shift_expr
2326             and prevp.prev_sibling
2327             and prevp.prev_sibling.type == token.NAME
2328             and prevp.prev_sibling.value == "print"  # type: ignore
2329         ):
2330             # Python 2 print chevron
2331             return NO
2332         elif prevp.type == token.AT and p.parent and p.parent.type == syms.decorator:
2333             # no space in decorators
2334             return NO
2335
2336     elif prev.type in OPENING_BRACKETS:
2337         return NO
2338
2339     if p.type in {syms.parameters, syms.arglist}:
2340         # untyped function signatures or calls
2341         if not prev or prev.type != token.COMMA:
2342             return NO
2343
2344     elif p.type == syms.varargslist:
2345         # lambdas
2346         if prev and prev.type != token.COMMA:
2347             return NO
2348
2349     elif p.type == syms.typedargslist:
2350         # typed function signatures
2351         if not prev:
2352             return NO
2353
2354         if t == token.EQUAL:
2355             if prev.type != syms.tname:
2356                 return NO
2357
2358         elif prev.type == token.EQUAL:
2359             # A bit hacky: if the equal sign has whitespace, it means we
2360             # previously found it's a typed argument.  So, we're using that, too.
2361             return prev.prefix
2362
2363         elif prev.type != token.COMMA:
2364             return NO
2365
2366     elif p.type == syms.tname:
2367         # type names
2368         if not prev:
2369             prevp = preceding_leaf(p)
2370             if not prevp or prevp.type != token.COMMA:
2371                 return NO
2372
2373     elif p.type == syms.trailer:
2374         # attributes and calls
2375         if t == token.LPAR or t == token.RPAR:
2376             return NO
2377
2378         if not prev:
2379             if t == token.DOT:
2380                 prevp = preceding_leaf(p)
2381                 if not prevp or prevp.type != token.NUMBER:
2382                     return NO
2383
2384             elif t == token.LSQB:
2385                 return NO
2386
2387         elif prev.type != token.COMMA:
2388             return NO
2389
2390     elif p.type == syms.argument:
2391         # single argument
2392         if t == token.EQUAL:
2393             return NO
2394
2395         if not prev:
2396             prevp = preceding_leaf(p)
2397             if not prevp or prevp.type == token.LPAR:
2398                 return NO
2399
2400         elif prev.type in {token.EQUAL} | VARARGS_SPECIALS:
2401             return NO
2402
2403     elif p.type == syms.decorator:
2404         # decorators
2405         return NO
2406
2407     elif p.type == syms.dotted_name:
2408         if prev:
2409             return NO
2410
2411         prevp = preceding_leaf(p)
2412         if not prevp or prevp.type == token.AT or prevp.type == token.DOT:
2413             return NO
2414
2415     elif p.type == syms.classdef:
2416         if t == token.LPAR:
2417             return NO
2418
2419         if prev and prev.type == token.LPAR:
2420             return NO
2421
2422     elif p.type in {syms.subscript, syms.sliceop}:
2423         # indexing
2424         if not prev:
2425             assert p.parent is not None, "subscripts are always parented"
2426             if p.parent.type == syms.subscriptlist:
2427                 return SPACE
2428
2429             return NO
2430
2431         elif not complex_subscript:
2432             return NO
2433
2434     elif p.type == syms.atom:
2435         if prev and t == token.DOT:
2436             # dots, but not the first one.
2437             return NO
2438
2439     elif p.type == syms.dictsetmaker:
2440         # dict unpacking
2441         if prev and prev.type == token.DOUBLESTAR:
2442             return NO
2443
2444     elif p.type in {syms.factor, syms.star_expr}:
2445         # unary ops
2446         if not prev:
2447             prevp = preceding_leaf(p)
2448             if not prevp or prevp.type in OPENING_BRACKETS:
2449                 return NO
2450
2451             prevp_parent = prevp.parent
2452             assert prevp_parent is not None
2453             if prevp.type == token.COLON and prevp_parent.type in {
2454                 syms.subscript,
2455                 syms.sliceop,
2456             }:
2457                 return NO
2458
2459             elif prevp.type == token.EQUAL and prevp_parent.type == syms.argument:
2460                 return NO
2461
2462         elif t in {token.NAME, token.NUMBER, token.STRING}:
2463             return NO
2464
2465     elif p.type == syms.import_from:
2466         if t == token.DOT:
2467             if prev and prev.type == token.DOT:
2468                 return NO
2469
2470         elif t == token.NAME:
2471             if v == "import":
2472                 return SPACE
2473
2474             if prev and prev.type == token.DOT:
2475                 return NO
2476
2477     elif p.type == syms.sliceop:
2478         return NO
2479
2480     return SPACE
2481
2482
2483 def preceding_leaf(node: Optional[LN]) -> Optional[Leaf]:
2484     """Return the first leaf that precedes `node`, if any."""
2485     while node:
2486         res = node.prev_sibling
2487         if res:
2488             if isinstance(res, Leaf):
2489                 return res
2490
2491             try:
2492                 return list(res.leaves())[-1]
2493
2494             except IndexError:
2495                 return None
2496
2497         node = node.parent
2498     return None
2499
2500
2501 def prev_siblings_are(node: Optional[LN], tokens: List[Optional[NodeType]]) -> bool:
2502     """Return if the `node` and its previous siblings match types against the provided
2503     list of tokens; the provided `node`has its type matched against the last element in
2504     the list.  `None` can be used as the first element to declare that the start of the
2505     list is anchored at the start of its parent's children."""
2506     if not tokens:
2507         return True
2508     if tokens[-1] is None:
2509         return node is None
2510     if not node:
2511         return False
2512     if node.type != tokens[-1]:
2513         return False
2514     return prev_siblings_are(node.prev_sibling, tokens[:-1])
2515
2516
2517 def child_towards(ancestor: Node, descendant: LN) -> Optional[LN]:
2518     """Return the child of `ancestor` that contains `descendant`."""
2519     node: Optional[LN] = descendant
2520     while node and node.parent != ancestor:
2521         node = node.parent
2522     return node
2523
2524
2525 def container_of(leaf: Leaf) -> LN:
2526     """Return `leaf` or one of its ancestors that is the topmost container of it.
2527
2528     By "container" we mean a node where `leaf` is the very first child.
2529     """
2530     same_prefix = leaf.prefix
2531     container: LN = leaf
2532     while container:
2533         parent = container.parent
2534         if parent is None:
2535             break
2536
2537         if parent.children[0].prefix != same_prefix:
2538             break
2539
2540         if parent.type == syms.file_input:
2541             break
2542
2543         if parent.prev_sibling is not None and parent.prev_sibling.type in BRACKETS:
2544             break
2545
2546         container = parent
2547     return container
2548
2549
2550 def is_split_after_delimiter(leaf: Leaf, previous: Optional[Leaf] = None) -> Priority:
2551     """Return the priority of the `leaf` delimiter, given a line break after it.
2552
2553     The delimiter priorities returned here are from those delimiters that would
2554     cause a line break after themselves.
2555
2556     Higher numbers are higher priority.
2557     """
2558     if leaf.type == token.COMMA:
2559         return COMMA_PRIORITY
2560
2561     return 0
2562
2563
2564 def is_split_before_delimiter(leaf: Leaf, previous: Optional[Leaf] = None) -> Priority:
2565     """Return the priority of the `leaf` delimiter, given a line break before it.
2566
2567     The delimiter priorities returned here are from those delimiters that would
2568     cause a line break before themselves.
2569
2570     Higher numbers are higher priority.
2571     """
2572     if is_vararg(leaf, within=VARARGS_PARENTS | UNPACKING_PARENTS):
2573         # * and ** might also be MATH_OPERATORS but in this case they are not.
2574         # Don't treat them as a delimiter.
2575         return 0
2576
2577     if (
2578         leaf.type == token.DOT
2579         and leaf.parent
2580         and leaf.parent.type not in {syms.import_from, syms.dotted_name}
2581         and (previous is None or previous.type in CLOSING_BRACKETS)
2582     ):
2583         return DOT_PRIORITY
2584
2585     if (
2586         leaf.type in MATH_OPERATORS
2587         and leaf.parent
2588         and leaf.parent.type not in {syms.factor, syms.star_expr}
2589     ):
2590         return MATH_PRIORITIES[leaf.type]
2591
2592     if leaf.type in COMPARATORS:
2593         return COMPARATOR_PRIORITY
2594
2595     if (
2596         leaf.type == token.STRING
2597         and previous is not None
2598         and previous.type == token.STRING
2599     ):
2600         return STRING_PRIORITY
2601
2602     if leaf.type not in {token.NAME, token.ASYNC}:
2603         return 0
2604
2605     if (
2606         leaf.value == "for"
2607         and leaf.parent
2608         and leaf.parent.type in {syms.comp_for, syms.old_comp_for}
2609         or leaf.type == token.ASYNC
2610     ):
2611         if (
2612             not isinstance(leaf.prev_sibling, Leaf)
2613             or leaf.prev_sibling.value != "async"
2614         ):
2615             return COMPREHENSION_PRIORITY
2616
2617     if (
2618         leaf.value == "if"
2619         and leaf.parent
2620         and leaf.parent.type in {syms.comp_if, syms.old_comp_if}
2621     ):
2622         return COMPREHENSION_PRIORITY
2623
2624     if leaf.value in {"if", "else"} and leaf.parent and leaf.parent.type == syms.test:
2625         return TERNARY_PRIORITY
2626
2627     if leaf.value == "is":
2628         return COMPARATOR_PRIORITY
2629
2630     if (
2631         leaf.value == "in"
2632         and leaf.parent
2633         and leaf.parent.type in {syms.comp_op, syms.comparison}
2634         and not (
2635             previous is not None
2636             and previous.type == token.NAME
2637             and previous.value == "not"
2638         )
2639     ):
2640         return COMPARATOR_PRIORITY
2641
2642     if (
2643         leaf.value == "not"
2644         and leaf.parent
2645         and leaf.parent.type == syms.comp_op
2646         and not (
2647             previous is not None
2648             and previous.type == token.NAME
2649             and previous.value == "is"
2650         )
2651     ):
2652         return COMPARATOR_PRIORITY
2653
2654     if leaf.value in LOGIC_OPERATORS and leaf.parent:
2655         return LOGIC_PRIORITY
2656
2657     return 0
2658
2659
2660 FMT_OFF = {"# fmt: off", "# fmt:off", "# yapf: disable"}
2661 FMT_SKIP = {"# fmt: skip", "# fmt:skip"}
2662 FMT_PASS = {*FMT_OFF, *FMT_SKIP}
2663 FMT_ON = {"# fmt: on", "# fmt:on", "# yapf: enable"}
2664
2665
2666 def generate_comments(leaf: LN) -> Iterator[Leaf]:
2667     """Clean the prefix of the `leaf` and generate comments from it, if any.
2668
2669     Comments in lib2to3 are shoved into the whitespace prefix.  This happens
2670     in `pgen2/driver.py:Driver.parse_tokens()`.  This was a brilliant implementation
2671     move because it does away with modifying the grammar to include all the
2672     possible places in which comments can be placed.
2673
2674     The sad consequence for us though is that comments don't "belong" anywhere.
2675     This is why this function generates simple parentless Leaf objects for
2676     comments.  We simply don't know what the correct parent should be.
2677
2678     No matter though, we can live without this.  We really only need to
2679     differentiate between inline and standalone comments.  The latter don't
2680     share the line with any code.
2681
2682     Inline comments are emitted as regular token.COMMENT leaves.  Standalone
2683     are emitted with a fake STANDALONE_COMMENT token identifier.
2684     """
2685     for pc in list_comments(leaf.prefix, is_endmarker=leaf.type == token.ENDMARKER):
2686         yield Leaf(pc.type, pc.value, prefix="\n" * pc.newlines)
2687
2688
2689 @dataclass
2690 class ProtoComment:
2691     """Describes a piece of syntax that is a comment.
2692
2693     It's not a :class:`blib2to3.pytree.Leaf` so that:
2694
2695     * it can be cached (`Leaf` objects should not be reused more than once as
2696       they store their lineno, column, prefix, and parent information);
2697     * `newlines` and `consumed` fields are kept separate from the `value`. This
2698       simplifies handling of special marker comments like ``# fmt: off/on``.
2699     """
2700
2701     type: int  # token.COMMENT or STANDALONE_COMMENT
2702     value: str  # content of the comment
2703     newlines: int  # how many newlines before the comment
2704     consumed: int  # how many characters of the original leaf's prefix did we consume
2705
2706
2707 @lru_cache(maxsize=4096)
2708 def list_comments(prefix: str, *, is_endmarker: bool) -> List[ProtoComment]:
2709     """Return a list of :class:`ProtoComment` objects parsed from the given `prefix`."""
2710     result: List[ProtoComment] = []
2711     if not prefix or "#" not in prefix:
2712         return result
2713
2714     consumed = 0
2715     nlines = 0
2716     ignored_lines = 0
2717     for index, line in enumerate(re.split("\r?\n", prefix)):
2718         consumed += len(line) + 1  # adding the length of the split '\n'
2719         line = line.lstrip()
2720         if not line:
2721             nlines += 1
2722         if not line.startswith("#"):
2723             # Escaped newlines outside of a comment are not really newlines at
2724             # all. We treat a single-line comment following an escaped newline
2725             # as a simple trailing comment.
2726             if line.endswith("\\"):
2727                 ignored_lines += 1
2728             continue
2729
2730         if index == ignored_lines and not is_endmarker:
2731             comment_type = token.COMMENT  # simple trailing comment
2732         else:
2733             comment_type = STANDALONE_COMMENT
2734         comment = make_comment(line)
2735         result.append(
2736             ProtoComment(
2737                 type=comment_type, value=comment, newlines=nlines, consumed=consumed
2738             )
2739         )
2740         nlines = 0
2741     return result
2742
2743
2744 def make_comment(content: str) -> str:
2745     """Return a consistently formatted comment from the given `content` string.
2746
2747     All comments (except for "##", "#!", "#:", '#'", "#%%") should have a single
2748     space between the hash sign and the content.
2749
2750     If `content` didn't start with a hash sign, one is provided.
2751     """
2752     content = content.rstrip()
2753     if not content:
2754         return "#"
2755
2756     if content[0] == "#":
2757         content = content[1:]
2758     NON_BREAKING_SPACE = " "
2759     if (
2760         content
2761         and content[0] == NON_BREAKING_SPACE
2762         and not content.lstrip().startswith("type:")
2763     ):
2764         content = " " + content[1:]  # Replace NBSP by a simple space
2765     if content and content[0] not in " !:#'%":
2766         content = " " + content
2767     return "#" + content
2768
2769
2770 def transform_line(
2771     line: Line, mode: Mode, features: Collection[Feature] = ()
2772 ) -> Iterator[Line]:
2773     """Transform a `line`, potentially splitting it into many lines.
2774
2775     They should fit in the allotted `line_length` but might not be able to.
2776
2777     `features` are syntactical features that may be used in the output.
2778     """
2779     if line.is_comment:
2780         yield line
2781         return
2782
2783     line_str = line_to_string(line)
2784
2785     def init_st(ST: Type[StringTransformer]) -> StringTransformer:
2786         """Initialize StringTransformer"""
2787         return ST(mode.line_length, mode.string_normalization)
2788
2789     string_merge = init_st(StringMerger)
2790     string_paren_strip = init_st(StringParenStripper)
2791     string_split = init_st(StringSplitter)
2792     string_paren_wrap = init_st(StringParenWrapper)
2793
2794     transformers: List[Transformer]
2795     if (
2796         not line.contains_uncollapsable_type_comments()
2797         and not line.should_split_rhs
2798         and not line.magic_trailing_comma
2799         and (
2800             is_line_short_enough(line, line_length=mode.line_length, line_str=line_str)
2801             or line.contains_unsplittable_type_ignore()
2802         )
2803         and not (line.inside_brackets and line.contains_standalone_comments())
2804     ):
2805         # Only apply basic string preprocessing, since lines shouldn't be split here.
2806         if mode.experimental_string_processing:
2807             transformers = [string_merge, string_paren_strip]
2808         else:
2809             transformers = []
2810     elif line.is_def:
2811         transformers = [left_hand_split]
2812     else:
2813
2814         def rhs(line: Line, features: Collection[Feature]) -> Iterator[Line]:
2815             """Wraps calls to `right_hand_split`.
2816
2817             The calls increasingly `omit` right-hand trailers (bracket pairs with
2818             content), meaning the trailers get glued together to split on another
2819             bracket pair instead.
2820             """
2821             for omit in generate_trailers_to_omit(line, mode.line_length):
2822                 lines = list(
2823                     right_hand_split(line, mode.line_length, features, omit=omit)
2824                 )
2825                 # Note: this check is only able to figure out if the first line of the
2826                 # *current* transformation fits in the line length.  This is true only
2827                 # for simple cases.  All others require running more transforms via
2828                 # `transform_line()`.  This check doesn't know if those would succeed.
2829                 if is_line_short_enough(lines[0], line_length=mode.line_length):
2830                     yield from lines
2831                     return
2832
2833             # All splits failed, best effort split with no omits.
2834             # This mostly happens to multiline strings that are by definition
2835             # reported as not fitting a single line, as well as lines that contain
2836             # trailing commas (those have to be exploded).
2837             yield from right_hand_split(
2838                 line, line_length=mode.line_length, features=features
2839             )
2840
2841         if mode.experimental_string_processing:
2842             if line.inside_brackets:
2843                 transformers = [
2844                     string_merge,
2845                     string_paren_strip,
2846                     string_split,
2847                     delimiter_split,
2848                     standalone_comment_split,
2849                     string_paren_wrap,
2850                     rhs,
2851                 ]
2852             else:
2853                 transformers = [
2854                     string_merge,
2855                     string_paren_strip,
2856                     string_split,
2857                     string_paren_wrap,
2858                     rhs,
2859                 ]
2860         else:
2861             if line.inside_brackets:
2862                 transformers = [delimiter_split, standalone_comment_split, rhs]
2863             else:
2864                 transformers = [rhs]
2865
2866     for transform in transformers:
2867         # We are accumulating lines in `result` because we might want to abort
2868         # mission and return the original line in the end, or attempt a different
2869         # split altogether.
2870         try:
2871             result = run_transformer(line, transform, mode, features, line_str=line_str)
2872         except CannotTransform:
2873             continue
2874         else:
2875             yield from result
2876             break
2877
2878     else:
2879         yield line
2880
2881
2882 @dataclass  # type: ignore
2883 class StringTransformer(ABC):
2884     """
2885     An implementation of the Transformer protocol that relies on its
2886     subclasses overriding the template methods `do_match(...)` and
2887     `do_transform(...)`.
2888
2889     This Transformer works exclusively on strings (for example, by merging
2890     or splitting them).
2891
2892     The following sections can be found among the docstrings of each concrete
2893     StringTransformer subclass.
2894
2895     Requirements:
2896         Which requirements must be met of the given Line for this
2897         StringTransformer to be applied?
2898
2899     Transformations:
2900         If the given Line meets all of the above requirements, which string
2901         transformations can you expect to be applied to it by this
2902         StringTransformer?
2903
2904     Collaborations:
2905         What contractual agreements does this StringTransformer have with other
2906         StringTransfomers? Such collaborations should be eliminated/minimized
2907         as much as possible.
2908     """
2909
2910     line_length: int
2911     normalize_strings: bool
2912     __name__ = "StringTransformer"
2913
2914     @abstractmethod
2915     def do_match(self, line: Line) -> TMatchResult:
2916         """
2917         Returns:
2918             * Ok(string_idx) such that `line.leaves[string_idx]` is our target
2919             string, if a match was able to be made.
2920                 OR
2921             * Err(CannotTransform), if a match was not able to be made.
2922         """
2923
2924     @abstractmethod
2925     def do_transform(self, line: Line, string_idx: int) -> Iterator[TResult[Line]]:
2926         """
2927         Yields:
2928             * Ok(new_line) where new_line is the new transformed line.
2929                 OR
2930             * Err(CannotTransform) if the transformation failed for some reason. The
2931             `do_match(...)` template method should usually be used to reject
2932             the form of the given Line, but in some cases it is difficult to
2933             know whether or not a Line meets the StringTransformer's
2934             requirements until the transformation is already midway.
2935
2936         Side Effects:
2937             This method should NOT mutate @line directly, but it MAY mutate the
2938             Line's underlying Node structure. (WARNING: If the underlying Node
2939             structure IS altered, then this method should NOT be allowed to
2940             yield an CannotTransform after that point.)
2941         """
2942
2943     def __call__(self, line: Line, _features: Collection[Feature]) -> Iterator[Line]:
2944         """
2945         StringTransformer instances have a call signature that mirrors that of
2946         the Transformer type.
2947
2948         Raises:
2949             CannotTransform(...) if the concrete StringTransformer class is unable
2950             to transform @line.
2951         """
2952         # Optimization to avoid calling `self.do_match(...)` when the line does
2953         # not contain any string.
2954         if not any(leaf.type == token.STRING for leaf in line.leaves):
2955             raise CannotTransform("There are no strings in this line.")
2956
2957         match_result = self.do_match(line)
2958
2959         if isinstance(match_result, Err):
2960             cant_transform = match_result.err()
2961             raise CannotTransform(
2962                 f"The string transformer {self.__class__.__name__} does not recognize"
2963                 " this line as one that it can transform."
2964             ) from cant_transform
2965
2966         string_idx = match_result.ok()
2967
2968         for line_result in self.do_transform(line, string_idx):
2969             if isinstance(line_result, Err):
2970                 cant_transform = line_result.err()
2971                 raise CannotTransform(
2972                     "StringTransformer failed while attempting to transform string."
2973                 ) from cant_transform
2974             line = line_result.ok()
2975             yield line
2976
2977
2978 @dataclass
2979 class CustomSplit:
2980     """A custom (i.e. manual) string split.
2981
2982     A single CustomSplit instance represents a single substring.
2983
2984     Examples:
2985         Consider the following string:
2986         ```
2987         "Hi there friend."
2988         " This is a custom"
2989         f" string {split}."
2990         ```
2991
2992         This string will correspond to the following three CustomSplit instances:
2993         ```
2994         CustomSplit(False, 16)
2995         CustomSplit(False, 17)
2996         CustomSplit(True, 16)
2997         ```
2998     """
2999
3000     has_prefix: bool
3001     break_idx: int
3002
3003
3004 class CustomSplitMapMixin:
3005     """
3006     This mixin class is used to map merged strings to a sequence of
3007     CustomSplits, which will then be used to re-split the strings iff none of
3008     the resultant substrings go over the configured max line length.
3009     """
3010
3011     _Key = Tuple[StringID, str]
3012     _CUSTOM_SPLIT_MAP: Dict[_Key, Tuple[CustomSplit, ...]] = defaultdict(tuple)
3013
3014     @staticmethod
3015     def _get_key(string: str) -> "CustomSplitMapMixin._Key":
3016         """
3017         Returns:
3018             A unique identifier that is used internally to map @string to a
3019             group of custom splits.
3020         """
3021         return (id(string), string)
3022
3023     def add_custom_splits(
3024         self, string: str, custom_splits: Iterable[CustomSplit]
3025     ) -> None:
3026         """Custom Split Map Setter Method
3027
3028         Side Effects:
3029             Adds a mapping from @string to the custom splits @custom_splits.
3030         """
3031         key = self._get_key(string)
3032         self._CUSTOM_SPLIT_MAP[key] = tuple(custom_splits)
3033
3034     def pop_custom_splits(self, string: str) -> List[CustomSplit]:
3035         """Custom Split Map Getter Method
3036
3037         Returns:
3038             * A list of the custom splits that are mapped to @string, if any
3039             exist.
3040                 OR
3041             * [], otherwise.
3042
3043         Side Effects:
3044             Deletes the mapping between @string and its associated custom
3045             splits (which are returned to the caller).
3046         """
3047         key = self._get_key(string)
3048
3049         custom_splits = self._CUSTOM_SPLIT_MAP[key]
3050         del self._CUSTOM_SPLIT_MAP[key]
3051
3052         return list(custom_splits)
3053
3054     def has_custom_splits(self, string: str) -> bool:
3055         """
3056         Returns:
3057             True iff @string is associated with a set of custom splits.
3058         """
3059         key = self._get_key(string)
3060         return key in self._CUSTOM_SPLIT_MAP
3061
3062
3063 class StringMerger(CustomSplitMapMixin, StringTransformer):
3064     """StringTransformer that merges strings together.
3065
3066     Requirements:
3067         (A) The line contains adjacent strings such that ALL of the validation checks
3068         listed in StringMerger.__validate_msg(...)'s docstring pass.
3069             OR
3070         (B) The line contains a string which uses line continuation backslashes.
3071
3072     Transformations:
3073         Depending on which of the two requirements above where met, either:
3074
3075         (A) The string group associated with the target string is merged.
3076             OR
3077         (B) All line-continuation backslashes are removed from the target string.
3078
3079     Collaborations:
3080         StringMerger provides custom split information to StringSplitter.
3081     """
3082
3083     def do_match(self, line: Line) -> TMatchResult:
3084         LL = line.leaves
3085
3086         is_valid_index = is_valid_index_factory(LL)
3087
3088         for (i, leaf) in enumerate(LL):
3089             if (
3090                 leaf.type == token.STRING
3091                 and is_valid_index(i + 1)
3092                 and LL[i + 1].type == token.STRING
3093             ):
3094                 return Ok(i)
3095
3096             if leaf.type == token.STRING and "\\\n" in leaf.value:
3097                 return Ok(i)
3098
3099         return TErr("This line has no strings that need merging.")
3100
3101     def do_transform(self, line: Line, string_idx: int) -> Iterator[TResult[Line]]:
3102         new_line = line
3103         rblc_result = self.__remove_backslash_line_continuation_chars(
3104             new_line, string_idx
3105         )
3106         if isinstance(rblc_result, Ok):
3107             new_line = rblc_result.ok()
3108
3109         msg_result = self.__merge_string_group(new_line, string_idx)
3110         if isinstance(msg_result, Ok):
3111             new_line = msg_result.ok()
3112
3113         if isinstance(rblc_result, Err) and isinstance(msg_result, Err):
3114             msg_cant_transform = msg_result.err()
3115             rblc_cant_transform = rblc_result.err()
3116             cant_transform = CannotTransform(
3117                 "StringMerger failed to merge any strings in this line."
3118             )
3119
3120             # Chain the errors together using `__cause__`.
3121             msg_cant_transform.__cause__ = rblc_cant_transform
3122             cant_transform.__cause__ = msg_cant_transform
3123
3124             yield Err(cant_transform)
3125         else:
3126             yield Ok(new_line)
3127
3128     @staticmethod
3129     def __remove_backslash_line_continuation_chars(
3130         line: Line, string_idx: int
3131     ) -> TResult[Line]:
3132         """
3133         Merge strings that were split across multiple lines using
3134         line-continuation backslashes.
3135
3136         Returns:
3137             Ok(new_line), if @line contains backslash line-continuation
3138             characters.
3139                 OR
3140             Err(CannotTransform), otherwise.
3141         """
3142         LL = line.leaves
3143
3144         string_leaf = LL[string_idx]
3145         if not (
3146             string_leaf.type == token.STRING
3147             and "\\\n" in string_leaf.value
3148             and not has_triple_quotes(string_leaf.value)
3149         ):
3150             return TErr(
3151                 f"String leaf {string_leaf} does not contain any backslash line"
3152                 " continuation characters."
3153             )
3154
3155         new_line = line.clone()
3156         new_line.comments = line.comments.copy()
3157         append_leaves(new_line, line, LL)
3158
3159         new_string_leaf = new_line.leaves[string_idx]
3160         new_string_leaf.value = new_string_leaf.value.replace("\\\n", "")
3161
3162         return Ok(new_line)
3163
3164     def __merge_string_group(self, line: Line, string_idx: int) -> TResult[Line]:
3165         """
3166         Merges string group (i.e. set of adjacent strings) where the first
3167         string in the group is `line.leaves[string_idx]`.
3168
3169         Returns:
3170             Ok(new_line), if ALL of the validation checks found in
3171             __validate_msg(...) pass.
3172                 OR
3173             Err(CannotTransform), otherwise.
3174         """
3175         LL = line.leaves
3176
3177         is_valid_index = is_valid_index_factory(LL)
3178
3179         vresult = self.__validate_msg(line, string_idx)
3180         if isinstance(vresult, Err):
3181             return vresult
3182
3183         # If the string group is wrapped inside an Atom node, we must make sure
3184         # to later replace that Atom with our new (merged) string leaf.
3185         atom_node = LL[string_idx].parent
3186
3187         # We will place BREAK_MARK in between every two substrings that we
3188         # merge. We will then later go through our final result and use the
3189         # various instances of BREAK_MARK we find to add the right values to
3190         # the custom split map.
3191         BREAK_MARK = "@@@@@ BLACK BREAKPOINT MARKER @@@@@"
3192
3193         QUOTE = LL[string_idx].value[-1]
3194
3195         def make_naked(string: str, string_prefix: str) -> str:
3196             """Strip @string (i.e. make it a "naked" string)
3197
3198             Pre-conditions:
3199                 * assert_is_leaf_string(@string)
3200
3201             Returns:
3202                 A string that is identical to @string except that
3203                 @string_prefix has been stripped, the surrounding QUOTE
3204                 characters have been removed, and any remaining QUOTE
3205                 characters have been escaped.
3206             """
3207             assert_is_leaf_string(string)
3208
3209             RE_EVEN_BACKSLASHES = r"(?:(?<!\\)(?:\\\\)*)"
3210             naked_string = string[len(string_prefix) + 1 : -1]
3211             naked_string = re.sub(
3212                 "(" + RE_EVEN_BACKSLASHES + ")" + QUOTE, r"\1\\" + QUOTE, naked_string
3213             )
3214             return naked_string
3215
3216         # Holds the CustomSplit objects that will later be added to the custom
3217         # split map.
3218         custom_splits = []
3219
3220         # Temporary storage for the 'has_prefix' part of the CustomSplit objects.
3221         prefix_tracker = []
3222
3223         # Sets the 'prefix' variable. This is the prefix that the final merged
3224         # string will have.
3225         next_str_idx = string_idx
3226         prefix = ""
3227         while (
3228             not prefix
3229             and is_valid_index(next_str_idx)
3230             and LL[next_str_idx].type == token.STRING
3231         ):
3232             prefix = get_string_prefix(LL[next_str_idx].value)
3233             next_str_idx += 1
3234
3235         # The next loop merges the string group. The final string will be
3236         # contained in 'S'.
3237         #
3238         # The following convenience variables are used:
3239         #
3240         #   S: string
3241         #   NS: naked string
3242         #   SS: next string
3243         #   NSS: naked next string
3244         S = ""
3245         NS = ""
3246         num_of_strings = 0
3247         next_str_idx = string_idx
3248         while is_valid_index(next_str_idx) and LL[next_str_idx].type == token.STRING:
3249             num_of_strings += 1
3250
3251             SS = LL[next_str_idx].value
3252             next_prefix = get_string_prefix(SS)
3253
3254             # If this is an f-string group but this substring is not prefixed
3255             # with 'f'...
3256             if "f" in prefix and "f" not in next_prefix:
3257                 # Then we must escape any braces contained in this substring.
3258                 SS = re.subf(r"(\{|\})", "{1}{1}", SS)
3259
3260             NSS = make_naked(SS, next_prefix)
3261
3262             has_prefix = bool(next_prefix)
3263             prefix_tracker.append(has_prefix)
3264
3265             S = prefix + QUOTE + NS + NSS + BREAK_MARK + QUOTE
3266             NS = make_naked(S, prefix)
3267
3268             next_str_idx += 1
3269
3270         S_leaf = Leaf(token.STRING, S)
3271         if self.normalize_strings:
3272             normalize_string_quotes(S_leaf)
3273
3274         # Fill the 'custom_splits' list with the appropriate CustomSplit objects.
3275         temp_string = S_leaf.value[len(prefix) + 1 : -1]
3276         for has_prefix in prefix_tracker:
3277             mark_idx = temp_string.find(BREAK_MARK)
3278             assert (
3279                 mark_idx >= 0
3280             ), "Logic error while filling the custom string breakpoint cache."
3281
3282             temp_string = temp_string[mark_idx + len(BREAK_MARK) :]
3283             breakpoint_idx = mark_idx + (len(prefix) if has_prefix else 0) + 1
3284             custom_splits.append(CustomSplit(has_prefix, breakpoint_idx))
3285
3286         string_leaf = Leaf(token.STRING, S_leaf.value.replace(BREAK_MARK, ""))
3287
3288         if atom_node is not None:
3289             replace_child(atom_node, string_leaf)
3290
3291         # Build the final line ('new_line') that this method will later return.
3292         new_line = line.clone()
3293         for (i, leaf) in enumerate(LL):
3294             if i == string_idx:
3295                 new_line.append(string_leaf)
3296
3297             if string_idx <= i < string_idx + num_of_strings:
3298                 for comment_leaf in line.comments_after(LL[i]):
3299                     new_line.append(comment_leaf, preformatted=True)
3300                 continue
3301
3302             append_leaves(new_line, line, [leaf])
3303
3304         self.add_custom_splits(string_leaf.value, custom_splits)
3305         return Ok(new_line)
3306
3307     @staticmethod
3308     def __validate_msg(line: Line, string_idx: int) -> TResult[None]:
3309         """Validate (M)erge (S)tring (G)roup
3310
3311         Transform-time string validation logic for __merge_string_group(...).
3312
3313         Returns:
3314             * Ok(None), if ALL validation checks (listed below) pass.
3315                 OR
3316             * Err(CannotTransform), if any of the following are true:
3317                 - The target string group does not contain ANY stand-alone comments.
3318                 - The target string is not in a string group (i.e. it has no
3319                   adjacent strings).
3320                 - The string group has more than one inline comment.
3321                 - The string group has an inline comment that appears to be a pragma.
3322                 - The set of all string prefixes in the string group is of
3323                   length greater than one and is not equal to {"", "f"}.
3324                 - The string group consists of raw strings.
3325         """
3326         # We first check for "inner" stand-alone comments (i.e. stand-alone
3327         # comments that have a string leaf before them AND after them).
3328         for inc in [1, -1]:
3329             i = string_idx
3330             found_sa_comment = False
3331             is_valid_index = is_valid_index_factory(line.leaves)
3332             while is_valid_index(i) and line.leaves[i].type in [
3333                 token.STRING,
3334                 STANDALONE_COMMENT,
3335             ]:
3336                 if line.leaves[i].type == STANDALONE_COMMENT:
3337                     found_sa_comment = True
3338                 elif found_sa_comment:
3339                     return TErr(
3340                         "StringMerger does NOT merge string groups which contain "
3341                         "stand-alone comments."
3342                     )
3343
3344                 i += inc
3345
3346         num_of_inline_string_comments = 0
3347         set_of_prefixes = set()
3348         num_of_strings = 0
3349         for leaf in line.leaves[string_idx:]:
3350             if leaf.type != token.STRING:
3351                 # If the string group is trailed by a comma, we count the
3352                 # comments trailing the comma to be one of the string group's
3353                 # comments.
3354                 if leaf.type == token.COMMA and id(leaf) in line.comments:
3355                     num_of_inline_string_comments += 1
3356                 break
3357
3358             if has_triple_quotes(leaf.value):
3359                 return TErr("StringMerger does NOT merge multiline strings.")
3360
3361             num_of_strings += 1
3362             prefix = get_string_prefix(leaf.value)
3363             if "r" in prefix:
3364                 return TErr("StringMerger does NOT merge raw strings.")
3365
3366             set_of_prefixes.add(prefix)
3367
3368             if id(leaf) in line.comments:
3369                 num_of_inline_string_comments += 1
3370                 if contains_pragma_comment(line.comments[id(leaf)]):
3371                     return TErr("Cannot merge strings which have pragma comments.")
3372
3373         if num_of_strings < 2:
3374             return TErr(
3375                 f"Not enough strings to merge (num_of_strings={num_of_strings})."
3376             )
3377
3378         if num_of_inline_string_comments > 1:
3379             return TErr(
3380                 f"Too many inline string comments ({num_of_inline_string_comments})."
3381             )
3382
3383         if len(set_of_prefixes) > 1 and set_of_prefixes != {"", "f"}:
3384             return TErr(f"Too many different prefixes ({set_of_prefixes}).")
3385
3386         return Ok(None)
3387
3388
3389 class StringParenStripper(StringTransformer):
3390     """StringTransformer that strips surrounding parentheses from strings.
3391
3392     Requirements:
3393         The line contains a string which is surrounded by parentheses and:
3394             - The target string is NOT the only argument to a function call.
3395             - The target string is NOT a "pointless" string.
3396             - If the target string contains a PERCENT, the brackets are not
3397               preceeded or followed by an operator with higher precedence than
3398               PERCENT.
3399
3400     Transformations:
3401         The parentheses mentioned in the 'Requirements' section are stripped.
3402
3403     Collaborations:
3404         StringParenStripper has its own inherent usefulness, but it is also
3405         relied on to clean up the parentheses created by StringParenWrapper (in
3406         the event that they are no longer needed).
3407     """
3408
3409     def do_match(self, line: Line) -> TMatchResult:
3410         LL = line.leaves
3411
3412         is_valid_index = is_valid_index_factory(LL)
3413
3414         for (idx, leaf) in enumerate(LL):
3415             # Should be a string...
3416             if leaf.type != token.STRING:
3417                 continue
3418
3419             # If this is a "pointless" string...
3420             if (
3421                 leaf.parent
3422                 and leaf.parent.parent
3423                 and leaf.parent.parent.type == syms.simple_stmt
3424             ):
3425                 continue
3426
3427             # Should be preceded by a non-empty LPAR...
3428             if (
3429                 not is_valid_index(idx - 1)
3430                 or LL[idx - 1].type != token.LPAR
3431                 or is_empty_lpar(LL[idx - 1])
3432             ):
3433                 continue
3434
3435             # That LPAR should NOT be preceded by a function name or a closing
3436             # bracket (which could be a function which returns a function or a
3437             # list/dictionary that contains a function)...
3438             if is_valid_index(idx - 2) and (
3439                 LL[idx - 2].type == token.NAME or LL[idx - 2].type in CLOSING_BRACKETS
3440             ):
3441                 continue
3442
3443             string_idx = idx
3444
3445             # Skip the string trailer, if one exists.
3446             string_parser = StringParser()
3447             next_idx = string_parser.parse(LL, string_idx)
3448
3449             # if the leaves in the parsed string include a PERCENT, we need to
3450             # make sure the initial LPAR is NOT preceded by an operator with
3451             # higher or equal precedence to PERCENT
3452             if is_valid_index(idx - 2):
3453                 # mypy can't quite follow unless we name this
3454                 before_lpar = LL[idx - 2]
3455                 if token.PERCENT in {leaf.type for leaf in LL[idx - 1 : next_idx]} and (
3456                     (
3457                         before_lpar.type
3458                         in {
3459                             token.STAR,
3460                             token.AT,
3461                             token.SLASH,
3462                             token.DOUBLESLASH,
3463                             token.PERCENT,
3464                             token.TILDE,
3465                             token.DOUBLESTAR,
3466                             token.AWAIT,
3467                             token.LSQB,
3468                             token.LPAR,
3469                         }
3470                     )
3471                     or (
3472                         # only unary PLUS/MINUS
3473                         before_lpar.parent
3474                         and before_lpar.parent.type == syms.factor
3475                         and (before_lpar.type in {token.PLUS, token.MINUS})
3476                     )
3477                 ):
3478                     continue
3479
3480             # Should be followed by a non-empty RPAR...
3481             if (
3482                 is_valid_index(next_idx)
3483                 and LL[next_idx].type == token.RPAR
3484                 and not is_empty_rpar(LL[next_idx])
3485             ):
3486                 # That RPAR should NOT be followed by anything with higher
3487                 # precedence than PERCENT
3488                 if is_valid_index(next_idx + 1) and LL[next_idx + 1].type in {
3489                     token.DOUBLESTAR,
3490                     token.LSQB,
3491                     token.LPAR,
3492                     token.DOT,
3493                 }:
3494                     continue
3495
3496                 return Ok(string_idx)
3497
3498         return TErr("This line has no strings wrapped in parens.")
3499
3500     def do_transform(self, line: Line, string_idx: int) -> Iterator[TResult[Line]]:
3501         LL = line.leaves
3502
3503         string_parser = StringParser()
3504         rpar_idx = string_parser.parse(LL, string_idx)
3505
3506         for leaf in (LL[string_idx - 1], LL[rpar_idx]):
3507             if line.comments_after(leaf):
3508                 yield TErr(
3509                     "Will not strip parentheses which have comments attached to them."
3510                 )
3511                 return
3512
3513         new_line = line.clone()
3514         new_line.comments = line.comments.copy()
3515         try:
3516             append_leaves(new_line, line, LL[: string_idx - 1])
3517         except BracketMatchError:
3518             # HACK: I believe there is currently a bug somewhere in
3519             # right_hand_split() that is causing brackets to not be tracked
3520             # properly by a shared BracketTracker.
3521             append_leaves(new_line, line, LL[: string_idx - 1], preformatted=True)
3522
3523         string_leaf = Leaf(token.STRING, LL[string_idx].value)
3524         LL[string_idx - 1].remove()
3525         replace_child(LL[string_idx], string_leaf)
3526         new_line.append(string_leaf)
3527
3528         append_leaves(
3529             new_line, line, LL[string_idx + 1 : rpar_idx] + LL[rpar_idx + 1 :]
3530         )
3531
3532         LL[rpar_idx].remove()
3533
3534         yield Ok(new_line)
3535
3536
3537 class BaseStringSplitter(StringTransformer):
3538     """
3539     Abstract class for StringTransformers which transform a Line's strings by splitting
3540     them or placing them on their own lines where necessary to avoid going over
3541     the configured line length.
3542
3543     Requirements:
3544         * The target string value is responsible for the line going over the
3545         line length limit. It follows that after all of black's other line
3546         split methods have been exhausted, this line (or one of the resulting
3547         lines after all line splits are performed) would still be over the
3548         line_length limit unless we split this string.
3549             AND
3550         * The target string is NOT a "pointless" string (i.e. a string that has
3551         no parent or siblings).
3552             AND
3553         * The target string is not followed by an inline comment that appears
3554         to be a pragma.
3555             AND
3556         * The target string is not a multiline (i.e. triple-quote) string.
3557     """
3558
3559     @abstractmethod
3560     def do_splitter_match(self, line: Line) -> TMatchResult:
3561         """
3562         BaseStringSplitter asks its clients to override this method instead of
3563         `StringTransformer.do_match(...)`.
3564
3565         Follows the same protocol as `StringTransformer.do_match(...)`.
3566
3567         Refer to `help(StringTransformer.do_match)` for more information.
3568         """
3569
3570     def do_match(self, line: Line) -> TMatchResult:
3571         match_result = self.do_splitter_match(line)
3572         if isinstance(match_result, Err):
3573             return match_result
3574
3575         string_idx = match_result.ok()
3576         vresult = self.__validate(line, string_idx)
3577         if isinstance(vresult, Err):
3578             return vresult
3579
3580         return match_result
3581
3582     def __validate(self, line: Line, string_idx: int) -> TResult[None]:
3583         """
3584         Checks that @line meets all of the requirements listed in this classes'
3585         docstring. Refer to `help(BaseStringSplitter)` for a detailed
3586         description of those requirements.
3587
3588         Returns:
3589             * Ok(None), if ALL of the requirements are met.
3590                 OR
3591             * Err(CannotTransform), if ANY of the requirements are NOT met.
3592         """
3593         LL = line.leaves
3594
3595         string_leaf = LL[string_idx]
3596
3597         max_string_length = self.__get_max_string_length(line, string_idx)
3598         if len(string_leaf.value) <= max_string_length:
3599             return TErr(
3600                 "The string itself is not what is causing this line to be too long."
3601             )
3602
3603         if not string_leaf.parent or [L.type for L in string_leaf.parent.children] == [
3604             token.STRING,
3605             token.NEWLINE,
3606         ]:
3607             return TErr(
3608                 f"This string ({string_leaf.value}) appears to be pointless (i.e. has"
3609                 " no parent)."
3610             )
3611
3612         if id(line.leaves[string_idx]) in line.comments and contains_pragma_comment(
3613             line.comments[id(line.leaves[string_idx])]
3614         ):
3615             return TErr(
3616                 "Line appears to end with an inline pragma comment. Splitting the line"
3617                 " could modify the pragma's behavior."
3618             )
3619
3620         if has_triple_quotes(string_leaf.value):
3621             return TErr("We cannot split multiline strings.")
3622
3623         return Ok(None)
3624
3625     def __get_max_string_length(self, line: Line, string_idx: int) -> int:
3626         """
3627         Calculates the max string length used when attempting to determine
3628         whether or not the target string is responsible for causing the line to
3629         go over the line length limit.
3630
3631         WARNING: This method is tightly coupled to both StringSplitter and
3632         (especially) StringParenWrapper. There is probably a better way to
3633         accomplish what is being done here.
3634
3635         Returns:
3636             max_string_length: such that `line.leaves[string_idx].value >
3637             max_string_length` implies that the target string IS responsible
3638             for causing this line to exceed the line length limit.
3639         """
3640         LL = line.leaves
3641
3642         is_valid_index = is_valid_index_factory(LL)
3643
3644         # We use the shorthand "WMA4" in comments to abbreviate "We must
3645         # account for". When giving examples, we use STRING to mean some/any
3646         # valid string.
3647         #
3648         # Finally, we use the following convenience variables:
3649         #
3650         #   P:  The leaf that is before the target string leaf.
3651         #   N:  The leaf that is after the target string leaf.
3652         #   NN: The leaf that is after N.
3653
3654         # WMA4 the whitespace at the beginning of the line.
3655         offset = line.depth * 4
3656
3657         if is_valid_index(string_idx - 1):
3658             p_idx = string_idx - 1
3659             if (
3660                 LL[string_idx - 1].type == token.LPAR
3661                 and LL[string_idx - 1].value == ""
3662                 and string_idx >= 2
3663             ):
3664                 # If the previous leaf is an empty LPAR placeholder, we should skip it.
3665                 p_idx -= 1
3666
3667             P = LL[p_idx]
3668             if P.type == token.PLUS:
3669                 # WMA4 a space and a '+' character (e.g. `+ STRING`).
3670                 offset += 2
3671
3672             if P.type == token.COMMA:
3673                 # WMA4 a space, a comma, and a closing bracket [e.g. `), STRING`].
3674                 offset += 3
3675
3676             if P.type in [token.COLON, token.EQUAL, token.NAME]:
3677                 # This conditional branch is meant to handle dictionary keys,
3678                 # variable assignments, 'return STRING' statement lines, and
3679                 # 'else STRING' ternary expression lines.
3680
3681                 # WMA4 a single space.
3682                 offset += 1
3683
3684                 # WMA4 the lengths of any leaves that came before that space,
3685                 # but after any closing bracket before that space.
3686                 for leaf in reversed(LL[: p_idx + 1]):
3687                     offset += len(str(leaf))
3688                     if leaf.type in CLOSING_BRACKETS:
3689                         break
3690
3691         if is_valid_index(string_idx + 1):
3692             N = LL[string_idx + 1]
3693             if N.type == token.RPAR and N.value == "" and len(LL) > string_idx + 2:
3694                 # If the next leaf is an empty RPAR placeholder, we should skip it.
3695                 N = LL[string_idx + 2]
3696
3697             if N.type == token.COMMA:
3698                 # WMA4 a single comma at the end of the string (e.g `STRING,`).
3699                 offset += 1
3700
3701             if is_valid_index(string_idx + 2):
3702                 NN = LL[string_idx + 2]
3703
3704                 if N.type == token.DOT and NN.type == token.NAME:
3705                     # This conditional branch is meant to handle method calls invoked
3706                     # off of a string literal up to and including the LPAR character.
3707
3708                     # WMA4 the '.' character.
3709                     offset += 1
3710
3711                     if (
3712                         is_valid_index(string_idx + 3)
3713                         and LL[string_idx + 3].type == token.LPAR
3714                     ):
3715                         # WMA4 the left parenthesis character.
3716                         offset += 1
3717
3718                     # WMA4 the length of the method's name.
3719                     offset += len(NN.value)
3720
3721         has_comments = False
3722         for comment_leaf in line.comments_after(LL[string_idx]):
3723             if not has_comments:
3724                 has_comments = True
3725                 # WMA4 two spaces before the '#' character.
3726                 offset += 2
3727
3728             # WMA4 the length of the inline comment.
3729             offset += len(comment_leaf.value)
3730
3731         max_string_length = self.line_length - offset
3732         return max_string_length
3733
3734
3735 class StringSplitter(CustomSplitMapMixin, BaseStringSplitter):
3736     """
3737     StringTransformer that splits "atom" strings (i.e. strings which exist on
3738     lines by themselves).
3739
3740     Requirements:
3741         * The line consists ONLY of a single string (with the exception of a
3742         '+' symbol which MAY exist at the start of the line), MAYBE a string
3743         trailer, and MAYBE a trailing comma.
3744             AND
3745         * All of the requirements listed in BaseStringSplitter's docstring.
3746
3747     Transformations:
3748         The string mentioned in the 'Requirements' section is split into as
3749         many substrings as necessary to adhere to the configured line length.
3750
3751         In the final set of substrings, no substring should be smaller than
3752         MIN_SUBSTR_SIZE characters.
3753
3754         The string will ONLY be split on spaces (i.e. each new substring should
3755         start with a space). Note that the string will NOT be split on a space
3756         which is escaped with a backslash.
3757
3758         If the string is an f-string, it will NOT be split in the middle of an
3759         f-expression (e.g. in f"FooBar: {foo() if x else bar()}", {foo() if x
3760         else bar()} is an f-expression).
3761
3762         If the string that is being split has an associated set of custom split
3763         records and those custom splits will NOT result in any line going over
3764         the configured line length, those custom splits are used. Otherwise the
3765         string is split as late as possible (from left-to-right) while still
3766         adhering to the transformation rules listed above.
3767
3768     Collaborations:
3769         StringSplitter relies on StringMerger to construct the appropriate
3770         CustomSplit objects and add them to the custom split map.
3771     """
3772
3773     MIN_SUBSTR_SIZE = 6
3774     # Matches an "f-expression" (e.g. {var}) that might be found in an f-string.
3775     RE_FEXPR = r"""
3776     (?<!\{) (?:\{\{)* \{ (?!\{)
3777         (?:
3778             [^\{\}]
3779             | \{\{
3780             | \}\}
3781             | (?R)
3782         )+?
3783     (?<!\}) \} (?:\}\})* (?!\})
3784     """
3785
3786     def do_splitter_match(self, line: Line) -> TMatchResult:
3787         LL = line.leaves
3788
3789         is_valid_index = is_valid_index_factory(LL)
3790
3791         idx = 0
3792
3793         # The first leaf MAY be a '+' symbol...
3794         if is_valid_index(idx) and LL[idx].type == token.PLUS:
3795             idx += 1
3796
3797         # The next/first leaf MAY be an empty LPAR...
3798         if is_valid_index(idx) and is_empty_lpar(LL[idx]):
3799             idx += 1
3800
3801         # The next/first leaf MUST be a string...
3802         if not is_valid_index(idx) or LL[idx].type != token.STRING:
3803             return TErr("Line does not start with a string.")
3804
3805         string_idx = idx
3806
3807         # Skip the string trailer, if one exists.
3808         string_parser = StringParser()
3809         idx = string_parser.parse(LL, string_idx)
3810
3811         # That string MAY be followed by an empty RPAR...
3812         if is_valid_index(idx) and is_empty_rpar(LL[idx]):
3813             idx += 1
3814
3815         # That string / empty RPAR leaf MAY be followed by a comma...
3816         if is_valid_index(idx) and LL[idx].type == token.COMMA:
3817             idx += 1
3818
3819         # But no more leaves are allowed...
3820         if is_valid_index(idx):
3821             return TErr("This line does not end with a string.")
3822
3823         return Ok(string_idx)
3824
3825     def do_transform(self, line: Line, string_idx: int) -> Iterator[TResult[Line]]:
3826         LL = line.leaves
3827
3828         QUOTE = LL[string_idx].value[-1]
3829
3830         is_valid_index = is_valid_index_factory(LL)
3831         insert_str_child = insert_str_child_factory(LL[string_idx])
3832
3833         prefix = get_string_prefix(LL[string_idx].value)
3834
3835         # We MAY choose to drop the 'f' prefix from substrings that don't
3836         # contain any f-expressions, but ONLY if the original f-string
3837         # contains at least one f-expression. Otherwise, we will alter the AST
3838         # of the program.
3839         drop_pointless_f_prefix = ("f" in prefix) and re.search(
3840             self.RE_FEXPR, LL[string_idx].value, re.VERBOSE
3841         )
3842
3843         first_string_line = True
3844         starts_with_plus = LL[0].type == token.PLUS
3845
3846         def line_needs_plus() -> bool:
3847             return first_string_line and starts_with_plus
3848
3849         def maybe_append_plus(new_line: Line) -> None:
3850             """
3851             Side Effects:
3852                 If @line starts with a plus and this is the first line we are
3853                 constructing, this function appends a PLUS leaf to @new_line
3854                 and replaces the old PLUS leaf in the node structure. Otherwise
3855                 this function does nothing.
3856             """
3857             if line_needs_plus():
3858                 plus_leaf = Leaf(token.PLUS, "+")
3859                 replace_child(LL[0], plus_leaf)
3860                 new_line.append(plus_leaf)
3861
3862         ends_with_comma = (
3863             is_valid_index(string_idx + 1) and LL[string_idx + 1].type == token.COMMA
3864         )
3865
3866         def max_last_string() -> int:
3867             """
3868             Returns:
3869                 The max allowed length of the string value used for the last
3870                 line we will construct.
3871             """
3872             result = self.line_length
3873             result -= line.depth * 4
3874             result -= 1 if ends_with_comma else 0
3875             result -= 2 if line_needs_plus() else 0
3876             return result
3877
3878         # --- Calculate Max Break Index (for string value)
3879         # We start with the line length limit
3880         max_break_idx = self.line_length
3881         # The last index of a string of length N is N-1.
3882         max_break_idx -= 1
3883         # Leading whitespace is not present in the string value (e.g. Leaf.value).
3884         max_break_idx -= line.depth * 4
3885         if max_break_idx < 0:
3886             yield TErr(
3887                 f"Unable to split {LL[string_idx].value} at such high of a line depth:"
3888                 f" {line.depth}"
3889             )
3890             return
3891
3892         # Check if StringMerger registered any custom splits.
3893         custom_splits = self.pop_custom_splits(LL[string_idx].value)
3894         # We use them ONLY if none of them would produce lines that exceed the
3895         # line limit.
3896         use_custom_breakpoints = bool(
3897             custom_splits
3898             and all(csplit.break_idx <= max_break_idx for csplit in custom_splits)
3899         )
3900
3901         # Temporary storage for the remaining chunk of the string line that
3902         # can't fit onto the line currently being constructed.
3903         rest_value = LL[string_idx].value
3904
3905         def more_splits_should_be_made() -> bool:
3906             """
3907             Returns:
3908                 True iff `rest_value` (the remaining string value from the last
3909                 split), should be split again.
3910             """
3911             if use_custom_breakpoints:
3912                 return len(custom_splits) > 1
3913             else:
3914                 return len(rest_value) > max_last_string()
3915
3916         string_line_results: List[Ok[Line]] = []
3917         while more_splits_should_be_made():
3918             if use_custom_breakpoints:
3919                 # Custom User Split (manual)
3920                 csplit = custom_splits.pop(0)
3921                 break_idx = csplit.break_idx
3922             else:
3923                 # Algorithmic Split (automatic)
3924                 max_bidx = max_break_idx - 2 if line_needs_plus() else max_break_idx
3925                 maybe_break_idx = self.__get_break_idx(rest_value, max_bidx)
3926                 if maybe_break_idx is None:
3927                     # If we are unable to algorithmically determine a good split
3928                     # and this string has custom splits registered to it, we
3929                     # fall back to using them--which means we have to start
3930                     # over from the beginning.
3931                     if custom_splits:
3932                         rest_value = LL[string_idx].value
3933                         string_line_results = []
3934                         first_string_line = True
3935                         use_custom_breakpoints = True
3936                         continue
3937
3938                     # Otherwise, we stop splitting here.
3939                     break
3940
3941                 break_idx = maybe_break_idx
3942
3943             # --- Construct `next_value`
3944             next_value = rest_value[:break_idx] + QUOTE
3945             if (
3946                 # Are we allowed to try to drop a pointless 'f' prefix?
3947                 drop_pointless_f_prefix
3948                 # If we are, will we be successful?
3949                 and next_value != self.__normalize_f_string(next_value, prefix)
3950             ):
3951                 # If the current custom split did NOT originally use a prefix,
3952                 # then `csplit.break_idx` will be off by one after removing
3953                 # the 'f' prefix.
3954                 break_idx = (
3955                     break_idx + 1
3956                     if use_custom_breakpoints and not csplit.has_prefix
3957                     else break_idx
3958                 )
3959                 next_value = rest_value[:break_idx] + QUOTE
3960                 next_value = self.__normalize_f_string(next_value, prefix)
3961
3962             # --- Construct `next_leaf`
3963             next_leaf = Leaf(token.STRING, next_value)
3964             insert_str_child(next_leaf)
3965             self.__maybe_normalize_string_quotes(next_leaf)
3966
3967             # --- Construct `next_line`
3968             next_line = line.clone()
3969             maybe_append_plus(next_line)
3970             next_line.append(next_leaf)
3971             string_line_results.append(Ok(next_line))
3972
3973             rest_value = prefix + QUOTE + rest_value[break_idx:]
3974             first_string_line = False
3975
3976         yield from string_line_results
3977
3978         if drop_pointless_f_prefix:
3979             rest_value = self.__normalize_f_string(rest_value, prefix)
3980
3981         rest_leaf = Leaf(token.STRING, rest_value)
3982         insert_str_child(rest_leaf)
3983
3984         # NOTE: I could not find a test case that verifies that the following
3985         # line is actually necessary, but it seems to be. Otherwise we risk
3986         # not normalizing the last substring, right?
3987         self.__maybe_normalize_string_quotes(rest_leaf)
3988
3989         last_line = line.clone()
3990         maybe_append_plus(last_line)
3991
3992         # If there are any leaves to the right of the target string...
3993         if is_valid_index(string_idx + 1):
3994             # We use `temp_value` here to determine how long the last line
3995             # would be if we were to append all the leaves to the right of the
3996             # target string to the last string line.
3997             temp_value = rest_value
3998             for leaf in LL[string_idx + 1 :]:
3999                 temp_value += str(leaf)
4000                 if leaf.type == token.LPAR:
4001                     break
4002
4003             # Try to fit them all on the same line with the last substring...
4004             if (
4005                 len(temp_value) <= max_last_string()
4006                 or LL[string_idx + 1].type == token.COMMA
4007             ):
4008                 last_line.append(rest_leaf)
4009                 append_leaves(last_line, line, LL[string_idx + 1 :])
4010                 yield Ok(last_line)
4011             # Otherwise, place the last substring on one line and everything
4012             # else on a line below that...
4013             else:
4014                 last_line.append(rest_leaf)
4015                 yield Ok(last_line)
4016
4017                 non_string_line = line.clone()
4018                 append_leaves(non_string_line, line, LL[string_idx + 1 :])
4019                 yield Ok(non_string_line)
4020         # Else the target string was the last leaf...
4021         else:
4022             last_line.append(rest_leaf)
4023             last_line.comments = line.comments.copy()
4024             yield Ok(last_line)
4025
4026     def __get_break_idx(self, string: str, max_break_idx: int) -> Optional[int]:
4027         """
4028         This method contains the algorithm that StringSplitter uses to
4029         determine which character to split each string at.
4030
4031         Args:
4032             @string: The substring that we are attempting to split.
4033             @max_break_idx: The ideal break index. We will return this value if it
4034             meets all the necessary conditions. In the likely event that it
4035             doesn't we will try to find the closest index BELOW @max_break_idx
4036             that does. If that fails, we will expand our search by also
4037             considering all valid indices ABOVE @max_break_idx.
4038
4039         Pre-Conditions:
4040             * assert_is_leaf_string(@string)
4041             * 0 <= @max_break_idx < len(@string)
4042
4043         Returns:
4044             break_idx, if an index is able to be found that meets all of the
4045             conditions listed in the 'Transformations' section of this classes'
4046             docstring.
4047                 OR
4048             None, otherwise.
4049         """
4050         is_valid_index = is_valid_index_factory(string)
4051
4052         assert is_valid_index(max_break_idx)
4053         assert_is_leaf_string(string)
4054
4055         _fexpr_slices: Optional[List[Tuple[Index, Index]]] = None
4056
4057         def fexpr_slices() -> Iterator[Tuple[Index, Index]]:
4058             """
4059             Yields:
4060                 All ranges of @string which, if @string were to be split there,
4061                 would result in the splitting of an f-expression (which is NOT
4062                 allowed).
4063             """
4064             nonlocal _fexpr_slices
4065
4066             if _fexpr_slices is None:
4067                 _fexpr_slices = []
4068                 for match in re.finditer(self.RE_FEXPR, string, re.VERBOSE):
4069                     _fexpr_slices.append(match.span())
4070
4071             yield from _fexpr_slices
4072
4073         is_fstring = "f" in get_string_prefix(string)
4074
4075         def breaks_fstring_expression(i: Index) -> bool:
4076             """
4077             Returns:
4078                 True iff returning @i would result in the splitting of an
4079                 f-expression (which is NOT allowed).
4080             """
4081             if not is_fstring:
4082                 return False
4083
4084             for (start, end) in fexpr_slices():
4085                 if start <= i < end:
4086                     return True
4087
4088             return False
4089
4090         def passes_all_checks(i: Index) -> bool:
4091             """
4092             Returns:
4093                 True iff ALL of the conditions listed in the 'Transformations'
4094                 section of this classes' docstring would be be met by returning @i.
4095             """
4096             is_space = string[i] == " "
4097
4098             is_not_escaped = True
4099             j = i - 1
4100             while is_valid_index(j) and string[j] == "\\":
4101                 is_not_escaped = not is_not_escaped
4102                 j -= 1
4103
4104             is_big_enough = (
4105                 len(string[i:]) >= self.MIN_SUBSTR_SIZE
4106                 and len(string[:i]) >= self.MIN_SUBSTR_SIZE
4107             )
4108             return (
4109                 is_space
4110                 and is_not_escaped
4111                 and is_big_enough
4112                 and not breaks_fstring_expression(i)
4113             )
4114
4115         # First, we check all indices BELOW @max_break_idx.
4116         break_idx = max_break_idx
4117         while is_valid_index(break_idx - 1) and not passes_all_checks(break_idx):
4118             break_idx -= 1
4119
4120         if not passes_all_checks(break_idx):
4121             # If that fails, we check all indices ABOVE @max_break_idx.
4122             #
4123             # If we are able to find a valid index here, the next line is going
4124             # to be longer than the specified line length, but it's probably
4125             # better than doing nothing at all.
4126             break_idx = max_break_idx + 1
4127             while is_valid_index(break_idx + 1) and not passes_all_checks(break_idx):
4128                 break_idx += 1
4129
4130             if not is_valid_index(break_idx) or not passes_all_checks(break_idx):
4131                 return None
4132
4133         return break_idx
4134
4135     def __maybe_normalize_string_quotes(self, leaf: Leaf) -> None:
4136         if self.normalize_strings:
4137             normalize_string_quotes(leaf)
4138
4139     def __normalize_f_string(self, string: str, prefix: str) -> str:
4140         """
4141         Pre-Conditions:
4142             * assert_is_leaf_string(@string)
4143
4144         Returns:
4145             * If @string is an f-string that contains no f-expressions, we
4146             return a string identical to @string except that the 'f' prefix
4147             has been stripped and all double braces (i.e. '{{' or '}}') have
4148             been normalized (i.e. turned into '{' or '}').
4149                 OR
4150             * Otherwise, we return @string.
4151         """
4152         assert_is_leaf_string(string)
4153
4154         if "f" in prefix and not re.search(self.RE_FEXPR, string, re.VERBOSE):
4155             new_prefix = prefix.replace("f", "")
4156
4157             temp = string[len(prefix) :]
4158             temp = re.sub(r"\{\{", "{", temp)
4159             temp = re.sub(r"\}\}", "}", temp)
4160             new_string = temp
4161
4162             return f"{new_prefix}{new_string}"
4163         else:
4164             return string
4165
4166
4167 class StringParenWrapper(CustomSplitMapMixin, BaseStringSplitter):
4168     """
4169     StringTransformer that splits non-"atom" strings (i.e. strings that do not
4170     exist on lines by themselves).
4171
4172     Requirements:
4173         All of the requirements listed in BaseStringSplitter's docstring in
4174         addition to the requirements listed below:
4175
4176         * The line is a return/yield statement, which returns/yields a string.
4177             OR
4178         * The line is part of a ternary expression (e.g. `x = y if cond else
4179         z`) such that the line starts with `else <string>`, where <string> is
4180         some string.
4181             OR
4182         * The line is an assert statement, which ends with a string.
4183             OR
4184         * The line is an assignment statement (e.g. `x = <string>` or `x +=
4185         <string>`) such that the variable is being assigned the value of some
4186         string.
4187             OR
4188         * The line is a dictionary key assignment where some valid key is being
4189         assigned the value of some string.
4190
4191     Transformations:
4192         The chosen string is wrapped in parentheses and then split at the LPAR.
4193
4194         We then have one line which ends with an LPAR and another line that
4195         starts with the chosen string. The latter line is then split again at
4196         the RPAR. This results in the RPAR (and possibly a trailing comma)
4197         being placed on its own line.
4198
4199         NOTE: If any leaves exist to the right of the chosen string (except
4200         for a trailing comma, which would be placed after the RPAR), those
4201         leaves are placed inside the parentheses.  In effect, the chosen
4202         string is not necessarily being "wrapped" by parentheses. We can,
4203         however, count on the LPAR being placed directly before the chosen
4204         string.
4205
4206         In other words, StringParenWrapper creates "atom" strings. These
4207         can then be split again by StringSplitter, if necessary.
4208
4209     Collaborations:
4210         In the event that a string line split by StringParenWrapper is
4211         changed such that it no longer needs to be given its own line,
4212         StringParenWrapper relies on StringParenStripper to clean up the
4213         parentheses it created.
4214     """
4215
4216     def do_splitter_match(self, line: Line) -> TMatchResult:
4217         LL = line.leaves
4218
4219         string_idx = (
4220             self._return_match(LL)
4221             or self._else_match(LL)
4222             or self._assert_match(LL)
4223             or self._assign_match(LL)
4224             or self._dict_match(LL)
4225         )
4226
4227         if string_idx is not None:
4228             string_value = line.leaves[string_idx].value
4229             # If the string has no spaces...
4230             if " " not in string_value:
4231                 # And will still violate the line length limit when split...
4232                 max_string_length = self.line_length - ((line.depth + 1) * 4)
4233                 if len(string_value) > max_string_length:
4234                     # And has no associated custom splits...
4235                     if not self.has_custom_splits(string_value):
4236                         # Then we should NOT put this string on its own line.
4237                         return TErr(
4238                             "We do not wrap long strings in parentheses when the"
4239                             " resultant line would still be over the specified line"
4240                             " length and can't be split further by StringSplitter."
4241                         )
4242             return Ok(string_idx)
4243
4244         return TErr("This line does not contain any non-atomic strings.")
4245
4246     @staticmethod
4247     def _return_match(LL: List[Leaf]) -> Optional[int]:
4248         """
4249         Returns:
4250             string_idx such that @LL[string_idx] is equal to our target (i.e.
4251             matched) string, if this line matches the return/yield statement
4252             requirements listed in the 'Requirements' section of this classes'
4253             docstring.
4254                 OR
4255             None, otherwise.
4256         """
4257         # If this line is apart of a return/yield statement and the first leaf
4258         # contains either the "return" or "yield" keywords...
4259         if parent_type(LL[0]) in [syms.return_stmt, syms.yield_expr] and LL[
4260             0
4261         ].value in ["return", "yield"]:
4262             is_valid_index = is_valid_index_factory(LL)
4263
4264             idx = 2 if is_valid_index(1) and is_empty_par(LL[1]) else 1
4265             # The next visible leaf MUST contain a string...
4266             if is_valid_index(idx) and LL[idx].type == token.STRING:
4267                 return idx
4268
4269         return None
4270
4271     @staticmethod
4272     def _else_match(LL: List[Leaf]) -> Optional[int]:
4273         """
4274         Returns:
4275             string_idx such that @LL[string_idx] is equal to our target (i.e.
4276             matched) string, if this line matches the ternary expression
4277             requirements listed in the 'Requirements' section of this classes'
4278             docstring.
4279                 OR
4280             None, otherwise.
4281         """
4282         # If this line is apart of a ternary expression and the first leaf
4283         # contains the "else" keyword...
4284         if (
4285             parent_type(LL[0]) == syms.test
4286             and LL[0].type == token.NAME
4287             and LL[0].value == "else"
4288         ):
4289             is_valid_index = is_valid_index_factory(LL)
4290
4291             idx = 2 if is_valid_index(1) and is_empty_par(LL[1]) else 1
4292             # The next visible leaf MUST contain a string...
4293             if is_valid_index(idx) and LL[idx].type == token.STRING:
4294                 return idx
4295
4296         return None
4297
4298     @staticmethod
4299     def _assert_match(LL: List[Leaf]) -> Optional[int]:
4300         """
4301         Returns:
4302             string_idx such that @LL[string_idx] is equal to our target (i.e.
4303             matched) string, if this line matches the assert statement
4304             requirements listed in the 'Requirements' section of this classes'
4305             docstring.
4306                 OR
4307             None, otherwise.
4308         """
4309         # If this line is apart of an assert statement and the first leaf
4310         # contains the "assert" keyword...
4311         if parent_type(LL[0]) == syms.assert_stmt and LL[0].value == "assert":
4312             is_valid_index = is_valid_index_factory(LL)
4313
4314             for (i, leaf) in enumerate(LL):
4315                 # We MUST find a comma...
4316                 if leaf.type == token.COMMA:
4317                     idx = i + 2 if is_empty_par(LL[i + 1]) else i + 1
4318
4319                     # That comma MUST be followed by a string...
4320                     if is_valid_index(idx) and LL[idx].type == token.STRING:
4321                         string_idx = idx
4322
4323                         # Skip the string trailer, if one exists.
4324                         string_parser = StringParser()
4325                         idx = string_parser.parse(LL, string_idx)
4326
4327                         # But no more leaves are allowed...
4328                         if not is_valid_index(idx):
4329                             return string_idx
4330
4331         return None
4332
4333     @staticmethod
4334     def _assign_match(LL: List[Leaf]) -> Optional[int]:
4335         """
4336         Returns:
4337             string_idx such that @LL[string_idx] is equal to our target (i.e.
4338             matched) string, if this line matches the assignment statement
4339             requirements listed in the 'Requirements' section of this classes'
4340             docstring.
4341                 OR
4342             None, otherwise.
4343         """
4344         # If this line is apart of an expression statement or is a function
4345         # argument AND the first leaf contains a variable name...
4346         if (
4347             parent_type(LL[0]) in [syms.expr_stmt, syms.argument, syms.power]
4348             and LL[0].type == token.NAME
4349         ):
4350             is_valid_index = is_valid_index_factory(LL)
4351
4352             for (i, leaf) in enumerate(LL):
4353                 # We MUST find either an '=' or '+=' symbol...
4354                 if leaf.type in [token.EQUAL, token.PLUSEQUAL]:
4355                     idx = i + 2 if is_empty_par(LL[i + 1]) else i + 1
4356
4357                     # That symbol MUST be followed by a string...
4358                     if is_valid_index(idx) and LL[idx].type == token.STRING:
4359                         string_idx = idx
4360
4361                         # Skip the string trailer, if one exists.
4362                         string_parser = StringParser()
4363                         idx = string_parser.parse(LL, string_idx)
4364
4365                         # The next leaf MAY be a comma iff this line is apart
4366                         # of a function argument...
4367                         if (
4368                             parent_type(LL[0]) == syms.argument
4369                             and is_valid_index(idx)
4370                             and LL[idx].type == token.COMMA
4371                         ):
4372                             idx += 1
4373
4374                         # But no more leaves are allowed...
4375                         if not is_valid_index(idx):
4376                             return string_idx
4377
4378         return None
4379
4380     @staticmethod
4381     def _dict_match(LL: List[Leaf]) -> Optional[int]:
4382         """
4383         Returns:
4384             string_idx such that @LL[string_idx] is equal to our target (i.e.
4385             matched) string, if this line matches the dictionary key assignment
4386             statement requirements listed in the 'Requirements' section of this
4387             classes' docstring.
4388                 OR
4389             None, otherwise.
4390         """
4391         # If this line is apart of a dictionary key assignment...
4392         if syms.dictsetmaker in [parent_type(LL[0]), parent_type(LL[0].parent)]:
4393             is_valid_index = is_valid_index_factory(LL)
4394
4395             for (i, leaf) in enumerate(LL):
4396                 # We MUST find a colon...
4397                 if leaf.type == token.COLON:
4398                     idx = i + 2 if is_empty_par(LL[i + 1]) else i + 1
4399
4400                     # That colon MUST be followed by a string...
4401                     if is_valid_index(idx) and LL[idx].type == token.STRING:
4402                         string_idx = idx
4403
4404                         # Skip the string trailer, if one exists.
4405                         string_parser = StringParser()
4406                         idx = string_parser.parse(LL, string_idx)
4407
4408                         # That string MAY be followed by a comma...
4409                         if is_valid_index(idx) and LL[idx].type == token.COMMA:
4410                             idx += 1
4411
4412                         # But no more leaves are allowed...
4413                         if not is_valid_index(idx):
4414                             return string_idx
4415
4416         return None
4417
4418     def do_transform(self, line: Line, string_idx: int) -> Iterator[TResult[Line]]:
4419         LL = line.leaves
4420
4421         is_valid_index = is_valid_index_factory(LL)
4422         insert_str_child = insert_str_child_factory(LL[string_idx])
4423
4424         comma_idx = -1
4425         ends_with_comma = False
4426         if LL[comma_idx].type == token.COMMA:
4427             ends_with_comma = True
4428
4429         leaves_to_steal_comments_from = [LL[string_idx]]
4430         if ends_with_comma:
4431             leaves_to_steal_comments_from.append(LL[comma_idx])
4432
4433         # --- First Line
4434         first_line = line.clone()
4435         left_leaves = LL[:string_idx]
4436
4437         # We have to remember to account for (possibly invisible) LPAR and RPAR
4438         # leaves that already wrapped the target string. If these leaves do
4439         # exist, we will replace them with our own LPAR and RPAR leaves.
4440         old_parens_exist = False
4441         if left_leaves and left_leaves[-1].type == token.LPAR:
4442             old_parens_exist = True
4443             leaves_to_steal_comments_from.append(left_leaves[-1])
4444             left_leaves.pop()
4445
4446         append_leaves(first_line, line, left_leaves)
4447
4448         lpar_leaf = Leaf(token.LPAR, "(")
4449         if old_parens_exist:
4450             replace_child(LL[string_idx - 1], lpar_leaf)
4451         else:
4452             insert_str_child(lpar_leaf)
4453         first_line.append(lpar_leaf)
4454
4455         # We throw inline comments that were originally to the right of the
4456         # target string to the top line. They will now be shown to the right of
4457         # the LPAR.
4458         for leaf in leaves_to_steal_comments_from:
4459             for comment_leaf in line.comments_after(leaf):
4460                 first_line.append(comment_leaf, preformatted=True)
4461
4462         yield Ok(first_line)
4463
4464         # --- Middle (String) Line
4465         # We only need to yield one (possibly too long) string line, since the
4466         # `StringSplitter` will break it down further if necessary.
4467         string_value = LL[string_idx].value
4468         string_line = Line(
4469             mode=line.mode,
4470             depth=line.depth + 1,
4471             inside_brackets=True,
4472             should_split_rhs=line.should_split_rhs,
4473             magic_trailing_comma=line.magic_trailing_comma,
4474         )
4475         string_leaf = Leaf(token.STRING, string_value)
4476         insert_str_child(string_leaf)
4477         string_line.append(string_leaf)
4478
4479         old_rpar_leaf = None
4480         if is_valid_index(string_idx + 1):
4481             right_leaves = LL[string_idx + 1 :]
4482             if ends_with_comma:
4483                 right_leaves.pop()
4484
4485             if old_parens_exist:
4486                 assert (
4487                     right_leaves and right_leaves[-1].type == token.RPAR
4488                 ), "Apparently, old parentheses do NOT exist?!"
4489                 old_rpar_leaf = right_leaves.pop()
4490
4491             append_leaves(string_line, line, right_leaves)
4492
4493         yield Ok(string_line)
4494
4495         # --- Last Line
4496         last_line = line.clone()
4497         last_line.bracket_tracker = first_line.bracket_tracker
4498
4499         new_rpar_leaf = Leaf(token.RPAR, ")")
4500         if old_rpar_leaf is not None:
4501             replace_child(old_rpar_leaf, new_rpar_leaf)
4502         else:
4503             insert_str_child(new_rpar_leaf)
4504         last_line.append(new_rpar_leaf)
4505
4506         # If the target string ended with a comma, we place this comma to the
4507         # right of the RPAR on the last line.
4508         if ends_with_comma:
4509             comma_leaf = Leaf(token.COMMA, ",")
4510             replace_child(LL[comma_idx], comma_leaf)
4511             last_line.append(comma_leaf)
4512
4513         yield Ok(last_line)
4514
4515
4516 class StringParser:
4517     """
4518     A state machine that aids in parsing a string's "trailer", which can be
4519     either non-existent, an old-style formatting sequence (e.g. `% varX` or `%
4520     (varX, varY)`), or a method-call / attribute access (e.g. `.format(varX,
4521     varY)`).
4522
4523     NOTE: A new StringParser object MUST be instantiated for each string
4524     trailer we need to parse.
4525
4526     Examples:
4527         We shall assume that `line` equals the `Line` object that corresponds
4528         to the following line of python code:
4529         ```
4530         x = "Some {}.".format("String") + some_other_string
4531         ```
4532
4533         Furthermore, we will assume that `string_idx` is some index such that:
4534         ```
4535         assert line.leaves[string_idx].value == "Some {}."
4536         ```
4537
4538         The following code snippet then holds:
4539         ```
4540         string_parser = StringParser()
4541         idx = string_parser.parse(line.leaves, string_idx)
4542         assert line.leaves[idx].type == token.PLUS
4543         ```
4544     """
4545
4546     DEFAULT_TOKEN = -1
4547
4548     # String Parser States
4549     START = 1
4550     DOT = 2
4551     NAME = 3
4552     PERCENT = 4
4553     SINGLE_FMT_ARG = 5
4554     LPAR = 6
4555     RPAR = 7
4556     DONE = 8
4557
4558     # Lookup Table for Next State
4559     _goto: Dict[Tuple[ParserState, NodeType], ParserState] = {
4560         # A string trailer may start with '.' OR '%'.
4561         (START, token.DOT): DOT,
4562         (START, token.PERCENT): PERCENT,
4563         (START, DEFAULT_TOKEN): DONE,
4564         # A '.' MUST be followed by an attribute or method name.
4565         (DOT, token.NAME): NAME,
4566         # A method name MUST be followed by an '(', whereas an attribute name
4567         # is the last symbol in the string trailer.
4568         (NAME, token.LPAR): LPAR,
4569         (NAME, DEFAULT_TOKEN): DONE,
4570         # A '%' symbol can be followed by an '(' or a single argument (e.g. a
4571         # string or variable name).
4572         (PERCENT, token.LPAR): LPAR,
4573         (PERCENT, DEFAULT_TOKEN): SINGLE_FMT_ARG,
4574         # If a '%' symbol is followed by a single argument, that argument is
4575         # the last leaf in the string trailer.
4576         (SINGLE_FMT_ARG, DEFAULT_TOKEN): DONE,
4577         # If present, a ')' symbol is the last symbol in a string trailer.
4578         # (NOTE: LPARS and nested RPARS are not included in this lookup table,
4579         # since they are treated as a special case by the parsing logic in this
4580         # classes' implementation.)
4581         (RPAR, DEFAULT_TOKEN): DONE,
4582     }
4583
4584     def __init__(self) -> None:
4585         self._state = self.START
4586         self._unmatched_lpars = 0
4587
4588     def parse(self, leaves: List[Leaf], string_idx: int) -> int:
4589         """
4590         Pre-conditions:
4591             * @leaves[@string_idx].type == token.STRING
4592
4593         Returns:
4594             The index directly after the last leaf which is apart of the string
4595             trailer, if a "trailer" exists.
4596                 OR
4597             @string_idx + 1, if no string "trailer" exists.
4598         """
4599         assert leaves[string_idx].type == token.STRING
4600
4601         idx = string_idx + 1
4602         while idx < len(leaves) and self._next_state(leaves[idx]):
4603             idx += 1
4604         return idx
4605
4606     def _next_state(self, leaf: Leaf) -> bool:
4607         """
4608         Pre-conditions:
4609             * On the first call to this function, @leaf MUST be the leaf that
4610             was directly after the string leaf in question (e.g. if our target
4611             string is `line.leaves[i]` then the first call to this method must
4612             be `line.leaves[i + 1]`).
4613             * On the next call to this function, the leaf parameter passed in
4614             MUST be the leaf directly following @leaf.
4615
4616         Returns:
4617             True iff @leaf is apart of the string's trailer.
4618         """
4619         # We ignore empty LPAR or RPAR leaves.
4620         if is_empty_par(leaf):
4621             return True
4622
4623         next_token = leaf.type
4624         if next_token == token.LPAR:
4625             self._unmatched_lpars += 1
4626
4627         current_state = self._state
4628
4629         # The LPAR parser state is a special case. We will return True until we
4630         # find the matching RPAR token.
4631         if current_state == self.LPAR:
4632             if next_token == token.RPAR:
4633                 self._unmatched_lpars -= 1
4634                 if self._unmatched_lpars == 0:
4635                     self._state = self.RPAR
4636         # Otherwise, we use a lookup table to determine the next state.
4637         else:
4638             # If the lookup table matches the current state to the next
4639             # token, we use the lookup table.
4640             if (current_state, next_token) in self._goto:
4641                 self._state = self._goto[current_state, next_token]
4642             else:
4643                 # Otherwise, we check if a the current state was assigned a
4644                 # default.
4645                 if (current_state, self.DEFAULT_TOKEN) in self._goto:
4646                     self._state = self._goto[current_state, self.DEFAULT_TOKEN]
4647                 # If no default has been assigned, then this parser has a logic
4648                 # error.
4649                 else:
4650                     raise RuntimeError(f"{self.__class__.__name__} LOGIC ERROR!")
4651
4652             if self._state == self.DONE:
4653                 return False
4654
4655         return True
4656
4657
4658 def TErr(err_msg: str) -> Err[CannotTransform]:
4659     """(T)ransform Err
4660
4661     Convenience function used when working with the TResult type.
4662     """
4663     cant_transform = CannotTransform(err_msg)
4664     return Err(cant_transform)
4665
4666
4667 def contains_pragma_comment(comment_list: List[Leaf]) -> bool:
4668     """
4669     Returns:
4670         True iff one of the comments in @comment_list is a pragma used by one
4671         of the more common static analysis tools for python (e.g. mypy, flake8,
4672         pylint).
4673     """
4674     for comment in comment_list:
4675         if comment.value.startswith(("# type:", "# noqa", "# pylint:")):
4676             return True
4677
4678     return False
4679
4680
4681 def insert_str_child_factory(string_leaf: Leaf) -> Callable[[LN], None]:
4682     """
4683     Factory for a convenience function that is used to orphan @string_leaf
4684     and then insert multiple new leaves into the same part of the node
4685     structure that @string_leaf had originally occupied.
4686
4687     Examples:
4688         Let `string_leaf = Leaf(token.STRING, '"foo"')` and `N =
4689         string_leaf.parent`. Assume the node `N` has the following
4690         original structure:
4691
4692         Node(
4693             expr_stmt, [
4694                 Leaf(NAME, 'x'),
4695                 Leaf(EQUAL, '='),
4696                 Leaf(STRING, '"foo"'),
4697             ]
4698         )
4699
4700         We then run the code snippet shown below.
4701         ```
4702         insert_str_child = insert_str_child_factory(string_leaf)
4703
4704         lpar = Leaf(token.LPAR, '(')
4705         insert_str_child(lpar)
4706
4707         bar = Leaf(token.STRING, '"bar"')
4708         insert_str_child(bar)
4709
4710         rpar = Leaf(token.RPAR, ')')
4711         insert_str_child(rpar)
4712         ```
4713
4714         After which point, it follows that `string_leaf.parent is None` and
4715         the node `N` now has the following structure:
4716
4717         Node(
4718             expr_stmt, [
4719                 Leaf(NAME, 'x'),
4720                 Leaf(EQUAL, '='),
4721                 Leaf(LPAR, '('),
4722                 Leaf(STRING, '"bar"'),
4723                 Leaf(RPAR, ')'),
4724             ]
4725         )
4726     """
4727     string_parent = string_leaf.parent
4728     string_child_idx = string_leaf.remove()
4729
4730     def insert_str_child(child: LN) -> None:
4731         nonlocal string_child_idx
4732
4733         assert string_parent is not None
4734         assert string_child_idx is not None
4735
4736         string_parent.insert_child(string_child_idx, child)
4737         string_child_idx += 1
4738
4739     return insert_str_child
4740
4741
4742 def has_triple_quotes(string: str) -> bool:
4743     """
4744     Returns:
4745         True iff @string starts with three quotation characters.
4746     """
4747     raw_string = string.lstrip(STRING_PREFIX_CHARS)
4748     return raw_string[:3] in {'"""', "'''"}
4749
4750
4751 def parent_type(node: Optional[LN]) -> Optional[NodeType]:
4752     """
4753     Returns:
4754         @node.parent.type, if @node is not None and has a parent.
4755             OR
4756         None, otherwise.
4757     """
4758     if node is None or node.parent is None:
4759         return None
4760
4761     return node.parent.type
4762
4763
4764 def is_empty_par(leaf: Leaf) -> bool:
4765     return is_empty_lpar(leaf) or is_empty_rpar(leaf)
4766
4767
4768 def is_empty_lpar(leaf: Leaf) -> bool:
4769     return leaf.type == token.LPAR and leaf.value == ""
4770
4771
4772 def is_empty_rpar(leaf: Leaf) -> bool:
4773     return leaf.type == token.RPAR and leaf.value == ""
4774
4775
4776 def is_valid_index_factory(seq: Sequence[Any]) -> Callable[[int], bool]:
4777     """
4778     Examples:
4779         ```
4780         my_list = [1, 2, 3]
4781
4782         is_valid_index = is_valid_index_factory(my_list)
4783
4784         assert is_valid_index(0)
4785         assert is_valid_index(2)
4786
4787         assert not is_valid_index(3)
4788         assert not is_valid_index(-1)
4789         ```
4790     """
4791
4792     def is_valid_index(idx: int) -> bool:
4793         """
4794         Returns:
4795             True iff @idx is positive AND seq[@idx] does NOT raise an
4796             IndexError.
4797         """
4798         return 0 <= idx < len(seq)
4799
4800     return is_valid_index
4801
4802
4803 def line_to_string(line: Line) -> str:
4804     """Returns the string representation of @line.
4805
4806     WARNING: This is known to be computationally expensive.
4807     """
4808     return str(line).strip("\n")
4809
4810
4811 def append_leaves(
4812     new_line: Line, old_line: Line, leaves: List[Leaf], preformatted: bool = False
4813 ) -> None:
4814     """
4815     Append leaves (taken from @old_line) to @new_line, making sure to fix the
4816     underlying Node structure where appropriate.
4817
4818     All of the leaves in @leaves are duplicated. The duplicates are then
4819     appended to @new_line and used to replace their originals in the underlying
4820     Node structure. Any comments attached to the old leaves are reattached to
4821     the new leaves.
4822
4823     Pre-conditions:
4824         set(@leaves) is a subset of set(@old_line.leaves).
4825     """
4826     for old_leaf in leaves:
4827         new_leaf = Leaf(old_leaf.type, old_leaf.value)
4828         replace_child(old_leaf, new_leaf)
4829         new_line.append(new_leaf, preformatted=preformatted)
4830
4831         for comment_leaf in old_line.comments_after(old_leaf):
4832             new_line.append(comment_leaf, preformatted=True)
4833
4834
4835 def replace_child(old_child: LN, new_child: LN) -> None:
4836     """
4837     Side Effects:
4838         * If @old_child.parent is set, replace @old_child with @new_child in
4839         @old_child's underlying Node structure.
4840             OR
4841         * Otherwise, this function does nothing.
4842     """
4843     parent = old_child.parent
4844     if not parent:
4845         return
4846
4847     child_idx = old_child.remove()
4848     if child_idx is not None:
4849         parent.insert_child(child_idx, new_child)
4850
4851
4852 def get_string_prefix(string: str) -> str:
4853     """
4854     Pre-conditions:
4855         * assert_is_leaf_string(@string)
4856
4857     Returns:
4858         @string's prefix (e.g. '', 'r', 'f', or 'rf').
4859     """
4860     assert_is_leaf_string(string)
4861
4862     prefix = ""
4863     prefix_idx = 0
4864     while string[prefix_idx] in STRING_PREFIX_CHARS:
4865         prefix += string[prefix_idx].lower()
4866         prefix_idx += 1
4867
4868     return prefix
4869
4870
4871 def assert_is_leaf_string(string: str) -> None:
4872     """
4873     Checks the pre-condition that @string has the format that you would expect
4874     of `leaf.value` where `leaf` is some Leaf such that `leaf.type ==
4875     token.STRING`. A more precise description of the pre-conditions that are
4876     checked are listed below.
4877
4878     Pre-conditions:
4879         * @string starts with either ', ", <prefix>', or <prefix>" where
4880         `set(<prefix>)` is some subset of `set(STRING_PREFIX_CHARS)`.
4881         * @string ends with a quote character (' or ").
4882
4883     Raises:
4884         AssertionError(...) if the pre-conditions listed above are not
4885         satisfied.
4886     """
4887     dquote_idx = string.find('"')
4888     squote_idx = string.find("'")
4889     if -1 in [dquote_idx, squote_idx]:
4890         quote_idx = max(dquote_idx, squote_idx)
4891     else:
4892         quote_idx = min(squote_idx, dquote_idx)
4893
4894     assert (
4895         0 <= quote_idx < len(string) - 1
4896     ), f"{string!r} is missing a starting quote character (' or \")."
4897     assert string[-1] in (
4898         "'",
4899         '"',
4900     ), f"{string!r} is missing an ending quote character (' or \")."
4901     assert set(string[:quote_idx]).issubset(
4902         set(STRING_PREFIX_CHARS)
4903     ), f"{set(string[:quote_idx])} is NOT a subset of {set(STRING_PREFIX_CHARS)}."
4904
4905
4906 def left_hand_split(line: Line, _features: Collection[Feature] = ()) -> Iterator[Line]:
4907     """Split line into many lines, starting with the first matching bracket pair.
4908
4909     Note: this usually looks weird, only use this for function definitions.
4910     Prefer RHS otherwise.  This is why this function is not symmetrical with
4911     :func:`right_hand_split` which also handles optional parentheses.
4912     """
4913     tail_leaves: List[Leaf] = []
4914     body_leaves: List[Leaf] = []
4915     head_leaves: List[Leaf] = []
4916     current_leaves = head_leaves
4917     matching_bracket: Optional[Leaf] = None
4918     for leaf in line.leaves:
4919         if (
4920             current_leaves is body_leaves
4921             and leaf.type in CLOSING_BRACKETS
4922             and leaf.opening_bracket is matching_bracket
4923         ):
4924             current_leaves = tail_leaves if body_leaves else head_leaves
4925         current_leaves.append(leaf)
4926         if current_leaves is head_leaves:
4927             if leaf.type in OPENING_BRACKETS:
4928                 matching_bracket = leaf
4929                 current_leaves = body_leaves
4930     if not matching_bracket:
4931         raise CannotSplit("No brackets found")
4932
4933     head = bracket_split_build_line(head_leaves, line, matching_bracket)
4934     body = bracket_split_build_line(body_leaves, line, matching_bracket, is_body=True)
4935     tail = bracket_split_build_line(tail_leaves, line, matching_bracket)
4936     bracket_split_succeeded_or_raise(head, body, tail)
4937     for result in (head, body, tail):
4938         if result:
4939             yield result
4940
4941
4942 def right_hand_split(
4943     line: Line,
4944     line_length: int,
4945     features: Collection[Feature] = (),
4946     omit: Collection[LeafID] = (),
4947 ) -> Iterator[Line]:
4948     """Split line into many lines, starting with the last matching bracket pair.
4949
4950     If the split was by optional parentheses, attempt splitting without them, too.
4951     `omit` is a collection of closing bracket IDs that shouldn't be considered for
4952     this split.
4953
4954     Note: running this function modifies `bracket_depth` on the leaves of `line`.
4955     """
4956     tail_leaves: List[Leaf] = []
4957     body_leaves: List[Leaf] = []
4958     head_leaves: List[Leaf] = []
4959     current_leaves = tail_leaves
4960     opening_bracket: Optional[Leaf] = None
4961     closing_bracket: Optional[Leaf] = None
4962     for leaf in reversed(line.leaves):
4963         if current_leaves is body_leaves:
4964             if leaf is opening_bracket:
4965                 current_leaves = head_leaves if body_leaves else tail_leaves
4966         current_leaves.append(leaf)
4967         if current_leaves is tail_leaves:
4968             if leaf.type in CLOSING_BRACKETS and id(leaf) not in omit:
4969                 opening_bracket = leaf.opening_bracket
4970                 closing_bracket = leaf
4971                 current_leaves = body_leaves
4972     if not (opening_bracket and closing_bracket and head_leaves):
4973         # If there is no opening or closing_bracket that means the split failed and
4974         # all content is in the tail.  Otherwise, if `head_leaves` are empty, it means
4975         # the matching `opening_bracket` wasn't available on `line` anymore.
4976         raise CannotSplit("No brackets found")
4977
4978     tail_leaves.reverse()
4979     body_leaves.reverse()
4980     head_leaves.reverse()
4981     head = bracket_split_build_line(head_leaves, line, opening_bracket)
4982     body = bracket_split_build_line(body_leaves, line, opening_bracket, is_body=True)
4983     tail = bracket_split_build_line(tail_leaves, line, opening_bracket)
4984     bracket_split_succeeded_or_raise(head, body, tail)
4985     if (
4986         Feature.FORCE_OPTIONAL_PARENTHESES not in features
4987         # the opening bracket is an optional paren
4988         and opening_bracket.type == token.LPAR
4989         and not opening_bracket.value
4990         # the closing bracket is an optional paren
4991         and closing_bracket.type == token.RPAR
4992         and not closing_bracket.value
4993         # it's not an import (optional parens are the only thing we can split on
4994         # in this case; attempting a split without them is a waste of time)
4995         and not line.is_import
4996         # there are no standalone comments in the body
4997         and not body.contains_standalone_comments(0)
4998         # and we can actually remove the parens
4999         and can_omit_invisible_parens(body, line_length, omit_on_explode=omit)
5000     ):
5001         omit = {id(closing_bracket), *omit}
5002         try:
5003             yield from right_hand_split(line, line_length, features=features, omit=omit)
5004             return
5005
5006         except CannotSplit:
5007             if not (
5008                 can_be_split(body)
5009                 or is_line_short_enough(body, line_length=line_length)
5010             ):
5011                 raise CannotSplit(
5012                     "Splitting failed, body is still too long and can't be split."
5013                 )
5014
5015             elif head.contains_multiline_strings() or tail.contains_multiline_strings():
5016                 raise CannotSplit(
5017                     "The current optional pair of parentheses is bound to fail to"
5018                     " satisfy the splitting algorithm because the head or the tail"
5019                     " contains multiline strings which by definition never fit one"
5020                     " line."
5021                 )
5022
5023     ensure_visible(opening_bracket)
5024     ensure_visible(closing_bracket)
5025     for result in (head, body, tail):
5026         if result:
5027             yield result
5028
5029
5030 def bracket_split_succeeded_or_raise(head: Line, body: Line, tail: Line) -> None:
5031     """Raise :exc:`CannotSplit` if the last left- or right-hand split failed.
5032
5033     Do nothing otherwise.
5034
5035     A left- or right-hand split is based on a pair of brackets. Content before
5036     (and including) the opening bracket is left on one line, content inside the
5037     brackets is put on a separate line, and finally content starting with and
5038     following the closing bracket is put on a separate line.
5039
5040     Those are called `head`, `body`, and `tail`, respectively. If the split
5041     produced the same line (all content in `head`) or ended up with an empty `body`
5042     and the `tail` is just the closing bracket, then it's considered failed.
5043     """
5044     tail_len = len(str(tail).strip())
5045     if not body:
5046         if tail_len == 0:
5047             raise CannotSplit("Splitting brackets produced the same line")
5048
5049         elif tail_len < 3:
5050             raise CannotSplit(
5051                 f"Splitting brackets on an empty body to save {tail_len} characters is"
5052                 " not worth it"
5053             )
5054
5055
5056 def bracket_split_build_line(
5057     leaves: List[Leaf], original: Line, opening_bracket: Leaf, *, is_body: bool = False
5058 ) -> Line:
5059     """Return a new line with given `leaves` and respective comments from `original`.
5060
5061     If `is_body` is True, the result line is one-indented inside brackets and as such
5062     has its first leaf's prefix normalized and a trailing comma added when expected.
5063     """
5064     result = Line(mode=original.mode, depth=original.depth)
5065     if is_body:
5066         result.inside_brackets = True
5067         result.depth += 1
5068         if leaves:
5069             # Since body is a new indent level, remove spurious leading whitespace.
5070             normalize_prefix(leaves[0], inside_brackets=True)
5071             # Ensure a trailing comma for imports and standalone function arguments, but
5072             # be careful not to add one after any comments or within type annotations.
5073             no_commas = (
5074                 original.is_def
5075                 and opening_bracket.value == "("
5076                 and not any(leaf.type == token.COMMA for leaf in leaves)
5077             )
5078
5079             if original.is_import or no_commas:
5080                 for i in range(len(leaves) - 1, -1, -1):
5081                     if leaves[i].type == STANDALONE_COMMENT:
5082                         continue
5083
5084                     if leaves[i].type != token.COMMA:
5085                         new_comma = Leaf(token.COMMA, ",")
5086                         leaves.insert(i + 1, new_comma)
5087                     break
5088
5089     # Populate the line
5090     for leaf in leaves:
5091         result.append(leaf, preformatted=True)
5092         for comment_after in original.comments_after(leaf):
5093             result.append(comment_after, preformatted=True)
5094     if is_body and should_split_line(result, opening_bracket):
5095         result.should_split_rhs = True
5096     return result
5097
5098
5099 def dont_increase_indentation(split_func: Transformer) -> Transformer:
5100     """Normalize prefix of the first leaf in every line returned by `split_func`.
5101
5102     This is a decorator over relevant split functions.
5103     """
5104
5105     @wraps(split_func)
5106     def split_wrapper(line: Line, features: Collection[Feature] = ()) -> Iterator[Line]:
5107         for line in split_func(line, features):
5108             normalize_prefix(line.leaves[0], inside_brackets=True)
5109             yield line
5110
5111     return split_wrapper
5112
5113
5114 @dont_increase_indentation
5115 def delimiter_split(line: Line, features: Collection[Feature] = ()) -> Iterator[Line]:
5116     """Split according to delimiters of the highest priority.
5117
5118     If the appropriate Features are given, the split will add trailing commas
5119     also in function signatures and calls that contain `*` and `**`.
5120     """
5121     try:
5122         last_leaf = line.leaves[-1]
5123     except IndexError:
5124         raise CannotSplit("Line empty")
5125
5126     bt = line.bracket_tracker
5127     try:
5128         delimiter_priority = bt.max_delimiter_priority(exclude={id(last_leaf)})
5129     except ValueError:
5130         raise CannotSplit("No delimiters found")
5131
5132     if delimiter_priority == DOT_PRIORITY:
5133         if bt.delimiter_count_with_priority(delimiter_priority) == 1:
5134             raise CannotSplit("Splitting a single attribute from its owner looks wrong")
5135
5136     current_line = Line(
5137         mode=line.mode, depth=line.depth, inside_brackets=line.inside_brackets
5138     )
5139     lowest_depth = sys.maxsize
5140     trailing_comma_safe = True
5141
5142     def append_to_line(leaf: Leaf) -> Iterator[Line]:
5143         """Append `leaf` to current line or to new line if appending impossible."""
5144         nonlocal current_line
5145         try:
5146             current_line.append_safe(leaf, preformatted=True)
5147         except ValueError:
5148             yield current_line
5149
5150             current_line = Line(
5151                 mode=line.mode, depth=line.depth, inside_brackets=line.inside_brackets
5152             )
5153             current_line.append(leaf)
5154
5155     for leaf in line.leaves:
5156         yield from append_to_line(leaf)
5157
5158         for comment_after in line.comments_after(leaf):
5159             yield from append_to_line(comment_after)
5160
5161         lowest_depth = min(lowest_depth, leaf.bracket_depth)
5162         if leaf.bracket_depth == lowest_depth:
5163             if is_vararg(leaf, within={syms.typedargslist}):
5164                 trailing_comma_safe = (
5165                     trailing_comma_safe and Feature.TRAILING_COMMA_IN_DEF in features
5166                 )
5167             elif is_vararg(leaf, within={syms.arglist, syms.argument}):
5168                 trailing_comma_safe = (
5169                     trailing_comma_safe and Feature.TRAILING_COMMA_IN_CALL in features
5170                 )
5171
5172         leaf_priority = bt.delimiters.get(id(leaf))
5173         if leaf_priority == delimiter_priority:
5174             yield current_line
5175
5176             current_line = Line(
5177                 mode=line.mode, depth=line.depth, inside_brackets=line.inside_brackets
5178             )
5179     if current_line:
5180         if (
5181             trailing_comma_safe
5182             and delimiter_priority == COMMA_PRIORITY
5183             and current_line.leaves[-1].type != token.COMMA
5184             and current_line.leaves[-1].type != STANDALONE_COMMENT
5185         ):
5186             new_comma = Leaf(token.COMMA, ",")
5187             current_line.append(new_comma)
5188         yield current_line
5189
5190
5191 @dont_increase_indentation
5192 def standalone_comment_split(
5193     line: Line, features: Collection[Feature] = ()
5194 ) -> Iterator[Line]:
5195     """Split standalone comments from the rest of the line."""
5196     if not line.contains_standalone_comments(0):
5197         raise CannotSplit("Line does not have any standalone comments")
5198
5199     current_line = Line(
5200         mode=line.mode, depth=line.depth, inside_brackets=line.inside_brackets
5201     )
5202
5203     def append_to_line(leaf: Leaf) -> Iterator[Line]:
5204         """Append `leaf` to current line or to new line if appending impossible."""
5205         nonlocal current_line
5206         try:
5207             current_line.append_safe(leaf, preformatted=True)
5208         except ValueError:
5209             yield current_line
5210
5211             current_line = Line(
5212                 line.mode, depth=line.depth, inside_brackets=line.inside_brackets
5213             )
5214             current_line.append(leaf)
5215
5216     for leaf in line.leaves:
5217         yield from append_to_line(leaf)
5218
5219         for comment_after in line.comments_after(leaf):
5220             yield from append_to_line(comment_after)
5221
5222     if current_line:
5223         yield current_line
5224
5225
5226 def is_import(leaf: Leaf) -> bool:
5227     """Return True if the given leaf starts an import statement."""
5228     p = leaf.parent
5229     t = leaf.type
5230     v = leaf.value
5231     return bool(
5232         t == token.NAME
5233         and (
5234             (v == "import" and p and p.type == syms.import_name)
5235             or (v == "from" and p and p.type == syms.import_from)
5236         )
5237     )
5238
5239
5240 def is_type_comment(leaf: Leaf, suffix: str = "") -> bool:
5241     """Return True if the given leaf is a special comment.
5242     Only returns true for type comments for now."""
5243     t = leaf.type
5244     v = leaf.value
5245     return t in {token.COMMENT, STANDALONE_COMMENT} and v.startswith("# type:" + suffix)
5246
5247
5248 def normalize_prefix(leaf: Leaf, *, inside_brackets: bool) -> None:
5249     """Leave existing extra newlines if not `inside_brackets`. Remove everything
5250     else.
5251
5252     Note: don't use backslashes for formatting or you'll lose your voting rights.
5253     """
5254     if not inside_brackets:
5255         spl = leaf.prefix.split("#")
5256         if "\\" not in spl[0]:
5257             nl_count = spl[-1].count("\n")
5258             if len(spl) > 1:
5259                 nl_count -= 1
5260             leaf.prefix = "\n" * nl_count
5261             return
5262
5263     leaf.prefix = ""
5264
5265
5266 def normalize_string_prefix(leaf: Leaf, remove_u_prefix: bool = False) -> None:
5267     """Make all string prefixes lowercase.
5268
5269     If remove_u_prefix is given, also removes any u prefix from the string.
5270
5271     Note: Mutates its argument.
5272     """
5273     match = re.match(r"^([" + STRING_PREFIX_CHARS + r"]*)(.*)$", leaf.value, re.DOTALL)
5274     assert match is not None, f"failed to match string {leaf.value!r}"
5275     orig_prefix = match.group(1)
5276     new_prefix = orig_prefix.replace("F", "f").replace("B", "b").replace("U", "u")
5277     if remove_u_prefix:
5278         new_prefix = new_prefix.replace("u", "")
5279     leaf.value = f"{new_prefix}{match.group(2)}"
5280
5281
5282 def normalize_string_quotes(leaf: Leaf) -> None:
5283     """Prefer double quotes but only if it doesn't cause more escaping.
5284
5285     Adds or removes backslashes as appropriate. Doesn't parse and fix
5286     strings nested in f-strings (yet).
5287
5288     Note: Mutates its argument.
5289     """
5290     value = leaf.value.lstrip(STRING_PREFIX_CHARS)
5291     if value[:3] == '"""':
5292         return
5293
5294     elif value[:3] == "'''":
5295         orig_quote = "'''"
5296         new_quote = '"""'
5297     elif value[0] == '"':
5298         orig_quote = '"'
5299         new_quote = "'"
5300     else:
5301         orig_quote = "'"
5302         new_quote = '"'
5303     first_quote_pos = leaf.value.find(orig_quote)
5304     if first_quote_pos == -1:
5305         return  # There's an internal error
5306
5307     prefix = leaf.value[:first_quote_pos]
5308     unescaped_new_quote = re.compile(rf"(([^\\]|^)(\\\\)*){new_quote}")
5309     escaped_new_quote = re.compile(rf"([^\\]|^)\\((?:\\\\)*){new_quote}")
5310     escaped_orig_quote = re.compile(rf"([^\\]|^)\\((?:\\\\)*){orig_quote}")
5311     body = leaf.value[first_quote_pos + len(orig_quote) : -len(orig_quote)]
5312     if "r" in prefix.casefold():
5313         if unescaped_new_quote.search(body):
5314             # There's at least one unescaped new_quote in this raw string
5315             # so converting is impossible
5316             return
5317
5318         # Do not introduce or remove backslashes in raw strings
5319         new_body = body
5320     else:
5321         # remove unnecessary escapes
5322         new_body = sub_twice(escaped_new_quote, rf"\1\2{new_quote}", body)
5323         if body != new_body:
5324             # Consider the string without unnecessary escapes as the original
5325             body = new_body
5326             leaf.value = f"{prefix}{orig_quote}{body}{orig_quote}"
5327         new_body = sub_twice(escaped_orig_quote, rf"\1\2{orig_quote}", new_body)
5328         new_body = sub_twice(unescaped_new_quote, rf"\1\\{new_quote}", new_body)
5329     if "f" in prefix.casefold():
5330         matches = re.findall(
5331             r"""
5332             (?:[^{]|^)\{  # start of the string or a non-{ followed by a single {
5333                 ([^{].*?)  # contents of the brackets except if begins with {{
5334             \}(?:[^}]|$)  # A } followed by end of the string or a non-}
5335             """,
5336             new_body,
5337             re.VERBOSE,
5338         )
5339         for m in matches:
5340             if "\\" in str(m):
5341                 # Do not introduce backslashes in interpolated expressions
5342                 return
5343
5344     if new_quote == '"""' and new_body[-1:] == '"':
5345         # edge case:
5346         new_body = new_body[:-1] + '\\"'
5347     orig_escape_count = body.count("\\")
5348     new_escape_count = new_body.count("\\")
5349     if new_escape_count > orig_escape_count:
5350         return  # Do not introduce more escaping
5351
5352     if new_escape_count == orig_escape_count and orig_quote == '"':
5353         return  # Prefer double quotes
5354
5355     leaf.value = f"{prefix}{new_quote}{new_body}{new_quote}"
5356
5357
5358 def normalize_numeric_literal(leaf: Leaf) -> None:
5359     """Normalizes numeric (float, int, and complex) literals.
5360
5361     All letters used in the representation are normalized to lowercase (except
5362     in Python 2 long literals).
5363     """
5364     text = leaf.value.lower()
5365     if text.startswith(("0o", "0b")):
5366         # Leave octal and binary literals alone.
5367         pass
5368     elif text.startswith("0x"):
5369         text = format_hex(text)
5370     elif "e" in text:
5371         text = format_scientific_notation(text)
5372     elif text.endswith(("j", "l")):
5373         text = format_long_or_complex_number(text)
5374     else:
5375         text = format_float_or_int_string(text)
5376     leaf.value = text
5377
5378
5379 def format_hex(text: str) -> str:
5380     """
5381     Formats a hexadecimal string like "0x12B3"
5382     """
5383     before, after = text[:2], text[2:]
5384     return f"{before}{after.upper()}"
5385
5386
5387 def format_scientific_notation(text: str) -> str:
5388     """Formats a numeric string utilizing scentific notation"""
5389     before, after = text.split("e")
5390     sign = ""
5391     if after.startswith("-"):
5392         after = after[1:]
5393         sign = "-"
5394     elif after.startswith("+"):
5395         after = after[1:]
5396     before = format_float_or_int_string(before)
5397     return f"{before}e{sign}{after}"
5398
5399
5400 def format_long_or_complex_number(text: str) -> str:
5401     """Formats a long or complex string like `10L` or `10j`"""
5402     number = text[:-1]
5403     suffix = text[-1]
5404     # Capitalize in "2L" because "l" looks too similar to "1".
5405     if suffix == "l":
5406         suffix = "L"
5407     return f"{format_float_or_int_string(number)}{suffix}"
5408
5409
5410 def format_float_or_int_string(text: str) -> str:
5411     """Formats a float string like "1.0"."""
5412     if "." not in text:
5413         return text
5414
5415     before, after = text.split(".")
5416     return f"{before or 0}.{after or 0}"
5417
5418
5419 def normalize_invisible_parens(node: Node, parens_after: Set[str]) -> None:
5420     """Make existing optional parentheses invisible or create new ones.
5421
5422     `parens_after` is a set of string leaf values immediately after which parens
5423     should be put.
5424
5425     Standardizes on visible parentheses for single-element tuples, and keeps
5426     existing visible parentheses for other tuples and generator expressions.
5427     """
5428     for pc in list_comments(node.prefix, is_endmarker=False):
5429         if pc.value in FMT_OFF:
5430             # This `node` has a prefix with `# fmt: off`, don't mess with parens.
5431             return
5432     check_lpar = False
5433     for index, child in enumerate(list(node.children)):
5434         # Fixes a bug where invisible parens are not properly stripped from
5435         # assignment statements that contain type annotations.
5436         if isinstance(child, Node) and child.type == syms.annassign:
5437             normalize_invisible_parens(child, parens_after=parens_after)
5438
5439         # Add parentheses around long tuple unpacking in assignments.
5440         if (
5441             index == 0
5442             and isinstance(child, Node)
5443             and child.type == syms.testlist_star_expr
5444         ):
5445             check_lpar = True
5446
5447         if check_lpar:
5448             if child.type == syms.atom:
5449                 if maybe_make_parens_invisible_in_atom(child, parent=node):
5450                     wrap_in_parentheses(node, child, visible=False)
5451             elif is_one_tuple(child):
5452                 wrap_in_parentheses(node, child, visible=True)
5453             elif node.type == syms.import_from:
5454                 # "import from" nodes store parentheses directly as part of
5455                 # the statement
5456                 if child.type == token.LPAR:
5457                     # make parentheses invisible
5458                     child.value = ""  # type: ignore
5459                     node.children[-1].value = ""  # type: ignore
5460                 elif child.type != token.STAR:
5461                     # insert invisible parentheses
5462                     node.insert_child(index, Leaf(token.LPAR, ""))
5463                     node.append_child(Leaf(token.RPAR, ""))
5464                 break
5465
5466             elif not (isinstance(child, Leaf) and is_multiline_string(child)):
5467                 wrap_in_parentheses(node, child, visible=False)
5468
5469         check_lpar = isinstance(child, Leaf) and child.value in parens_after
5470
5471
5472 def normalize_fmt_off(node: Node) -> None:
5473     """Convert content between `# fmt: off`/`# fmt: on` into standalone comments."""
5474     try_again = True
5475     while try_again:
5476         try_again = convert_one_fmt_off_pair(node)
5477
5478
5479 def convert_one_fmt_off_pair(node: Node) -> bool:
5480     """Convert content of a single `# fmt: off`/`# fmt: on` into a standalone comment.
5481
5482     Returns True if a pair was converted.
5483     """
5484     for leaf in node.leaves():
5485         previous_consumed = 0
5486         for comment in list_comments(leaf.prefix, is_endmarker=False):
5487             if comment.value not in FMT_PASS:
5488                 previous_consumed = comment.consumed
5489                 continue
5490             # We only want standalone comments. If there's no previous leaf or
5491             # the previous leaf is indentation, it's a standalone comment in
5492             # disguise.
5493             if comment.value in FMT_PASS and comment.type != STANDALONE_COMMENT:
5494                 prev = preceding_leaf(leaf)
5495                 if prev:
5496                     if comment.value in FMT_OFF and prev.type not in WHITESPACE:
5497                         continue
5498                     if comment.value in FMT_SKIP and prev.type in WHITESPACE:
5499                         continue
5500
5501             ignored_nodes = list(generate_ignored_nodes(leaf, comment))
5502             if not ignored_nodes:
5503                 continue
5504
5505             first = ignored_nodes[0]  # Can be a container node with the `leaf`.
5506             parent = first.parent
5507             prefix = first.prefix
5508             first.prefix = prefix[comment.consumed :]
5509             hidden_value = "".join(str(n) for n in ignored_nodes)
5510             if comment.value in FMT_OFF:
5511                 hidden_value = comment.value + "\n" + hidden_value
5512             if comment.value in FMT_SKIP:
5513                 hidden_value += "  " + comment.value
5514             if hidden_value.endswith("\n"):
5515                 # That happens when one of the `ignored_nodes` ended with a NEWLINE
5516                 # leaf (possibly followed by a DEDENT).
5517                 hidden_value = hidden_value[:-1]
5518             first_idx: Optional[int] = None
5519             for ignored in ignored_nodes:
5520                 index = ignored.remove()
5521                 if first_idx is None:
5522                     first_idx = index
5523             assert parent is not None, "INTERNAL ERROR: fmt: on/off handling (1)"
5524             assert first_idx is not None, "INTERNAL ERROR: fmt: on/off handling (2)"
5525             parent.insert_child(
5526                 first_idx,
5527                 Leaf(
5528                     STANDALONE_COMMENT,
5529                     hidden_value,
5530                     prefix=prefix[:previous_consumed] + "\n" * comment.newlines,
5531                 ),
5532             )
5533             return True
5534
5535     return False
5536
5537
5538 def generate_ignored_nodes(leaf: Leaf, comment: ProtoComment) -> Iterator[LN]:
5539     """Starting from the container of `leaf`, generate all leaves until `# fmt: on`.
5540
5541     If comment is skip, returns leaf only.
5542     Stops at the end of the block.
5543     """
5544     container: Optional[LN] = container_of(leaf)
5545     if comment.value in FMT_SKIP:
5546         prev_sibling = leaf.prev_sibling
5547         if comment.value in leaf.prefix and prev_sibling is not None:
5548             leaf.prefix = leaf.prefix.replace(comment.value, "")
5549             siblings = [prev_sibling]
5550             while (
5551                 "\n" not in prev_sibling.prefix
5552                 and prev_sibling.prev_sibling is not None
5553             ):
5554                 prev_sibling = prev_sibling.prev_sibling
5555                 siblings.insert(0, prev_sibling)
5556             for sibling in siblings:
5557                 yield sibling
5558         elif leaf.parent is not None:
5559             yield leaf.parent
5560         return
5561     while container is not None and container.type != token.ENDMARKER:
5562         if is_fmt_on(container):
5563             return
5564
5565         # fix for fmt: on in children
5566         if contains_fmt_on_at_column(container, leaf.column):
5567             for child in container.children:
5568                 if contains_fmt_on_at_column(child, leaf.column):
5569                     return
5570                 yield child
5571         else:
5572             yield container
5573             container = container.next_sibling
5574
5575
5576 def is_fmt_on(container: LN) -> bool:
5577     """Determine whether formatting is switched on within a container.
5578     Determined by whether the last `# fmt:` comment is `on` or `off`.
5579     """
5580     fmt_on = False
5581     for comment in list_comments(container.prefix, is_endmarker=False):
5582         if comment.value in FMT_ON:
5583             fmt_on = True
5584         elif comment.value in FMT_OFF:
5585             fmt_on = False
5586     return fmt_on
5587
5588
5589 def contains_fmt_on_at_column(container: LN, column: int) -> bool:
5590     """Determine if children at a given column have formatting switched on."""
5591     for child in container.children:
5592         if (
5593             isinstance(child, Node)
5594             and first_leaf_column(child) == column
5595             or isinstance(child, Leaf)
5596             and child.column == column
5597         ):
5598             if is_fmt_on(child):
5599                 return True
5600
5601     return False
5602
5603
5604 def first_leaf_column(node: Node) -> Optional[int]:
5605     """Returns the column of the first leaf child of a node."""
5606     for child in node.children:
5607         if isinstance(child, Leaf):
5608             return child.column
5609     return None
5610
5611
5612 def maybe_make_parens_invisible_in_atom(node: LN, parent: LN) -> bool:
5613     """If it's safe, make the parens in the atom `node` invisible, recursively.
5614     Additionally, remove repeated, adjacent invisible parens from the atom `node`
5615     as they are redundant.
5616
5617     Returns whether the node should itself be wrapped in invisible parentheses.
5618
5619     """
5620
5621     if (
5622         node.type != syms.atom
5623         or is_empty_tuple(node)
5624         or is_one_tuple(node)
5625         or (is_yield(node) and parent.type != syms.expr_stmt)
5626         or max_delimiter_priority_in_atom(node) >= COMMA_PRIORITY
5627     ):
5628         return False
5629
5630     if is_walrus_assignment(node):
5631         if parent.type in [
5632             syms.annassign,
5633             syms.expr_stmt,
5634             syms.assert_stmt,
5635             syms.return_stmt,
5636             # these ones aren't useful to end users, but they do please fuzzers
5637             syms.for_stmt,
5638             syms.del_stmt,
5639         ]:
5640             return False
5641
5642     first = node.children[0]
5643     last = node.children[-1]
5644     if first.type == token.LPAR and last.type == token.RPAR:
5645         middle = node.children[1]
5646         # make parentheses invisible
5647         first.value = ""  # type: ignore
5648         last.value = ""  # type: ignore
5649         maybe_make_parens_invisible_in_atom(middle, parent=parent)
5650
5651         if is_atom_with_invisible_parens(middle):
5652             # Strip the invisible parens from `middle` by replacing
5653             # it with the child in-between the invisible parens
5654             middle.replace(middle.children[1])
5655
5656         return False
5657
5658     return True
5659
5660
5661 def is_atom_with_invisible_parens(node: LN) -> bool:
5662     """Given a `LN`, determines whether it's an atom `node` with invisible
5663     parens. Useful in dedupe-ing and normalizing parens.
5664     """
5665     if isinstance(node, Leaf) or node.type != syms.atom:
5666         return False
5667
5668     first, last = node.children[0], node.children[-1]
5669     return (
5670         isinstance(first, Leaf)
5671         and first.type == token.LPAR
5672         and first.value == ""
5673         and isinstance(last, Leaf)
5674         and last.type == token.RPAR
5675         and last.value == ""
5676     )
5677
5678
5679 def is_empty_tuple(node: LN) -> bool:
5680     """Return True if `node` holds an empty tuple."""
5681     return (
5682         node.type == syms.atom
5683         and len(node.children) == 2
5684         and node.children[0].type == token.LPAR
5685         and node.children[1].type == token.RPAR
5686     )
5687
5688
5689 def unwrap_singleton_parenthesis(node: LN) -> Optional[LN]:
5690     """Returns `wrapped` if `node` is of the shape ( wrapped ).
5691
5692     Parenthesis can be optional. Returns None otherwise"""
5693     if len(node.children) != 3:
5694         return None
5695
5696     lpar, wrapped, rpar = node.children
5697     if not (lpar.type == token.LPAR and rpar.type == token.RPAR):
5698         return None
5699
5700     return wrapped
5701
5702
5703 def first_child_is_arith(node: Node) -> bool:
5704     """Whether first child is an arithmetic or a binary arithmetic expression"""
5705     expr_types = {
5706         syms.arith_expr,
5707         syms.shift_expr,
5708         syms.xor_expr,
5709         syms.and_expr,
5710     }
5711     return bool(node.children and node.children[0].type in expr_types)
5712
5713
5714 def wrap_in_parentheses(parent: Node, child: LN, *, visible: bool = True) -> None:
5715     """Wrap `child` in parentheses.
5716
5717     This replaces `child` with an atom holding the parentheses and the old
5718     child.  That requires moving the prefix.
5719
5720     If `visible` is False, the leaves will be valueless (and thus invisible).
5721     """
5722     lpar = Leaf(token.LPAR, "(" if visible else "")
5723     rpar = Leaf(token.RPAR, ")" if visible else "")
5724     prefix = child.prefix
5725     child.prefix = ""
5726     index = child.remove() or 0
5727     new_child = Node(syms.atom, [lpar, child, rpar])
5728     new_child.prefix = prefix
5729     parent.insert_child(index, new_child)
5730
5731
5732 def is_one_tuple(node: LN) -> bool:
5733     """Return True if `node` holds a tuple with one element, with or without parens."""
5734     if node.type == syms.atom:
5735         gexp = unwrap_singleton_parenthesis(node)
5736         if gexp is None or gexp.type != syms.testlist_gexp:
5737             return False
5738
5739         return len(gexp.children) == 2 and gexp.children[1].type == token.COMMA
5740
5741     return (
5742         node.type in IMPLICIT_TUPLE
5743         and len(node.children) == 2
5744         and node.children[1].type == token.COMMA
5745     )
5746
5747
5748 def is_walrus_assignment(node: LN) -> bool:
5749     """Return True iff `node` is of the shape ( test := test )"""
5750     inner = unwrap_singleton_parenthesis(node)
5751     return inner is not None and inner.type == syms.namedexpr_test
5752
5753
5754 def is_simple_decorator_trailer(node: LN, last: bool = False) -> bool:
5755     """Return True iff `node` is a trailer valid in a simple decorator"""
5756     return node.type == syms.trailer and (
5757         (
5758             len(node.children) == 2
5759             and node.children[0].type == token.DOT
5760             and node.children[1].type == token.NAME
5761         )
5762         # last trailer can be arguments
5763         or (
5764             last
5765             and len(node.children) == 3
5766             and node.children[0].type == token.LPAR
5767             # and node.children[1].type == syms.argument
5768             and node.children[2].type == token.RPAR
5769         )
5770     )
5771
5772
5773 def is_simple_decorator_expression(node: LN) -> bool:
5774     """Return True iff `node` could be a 'dotted name' decorator
5775
5776     This function takes the node of the 'namedexpr_test' of the new decorator
5777     grammar and test if it would be valid under the old decorator grammar.
5778
5779     The old grammar was: decorator: @ dotted_name [arguments] NEWLINE
5780     The new grammar is : decorator: @ namedexpr_test NEWLINE
5781     """
5782     if node.type == token.NAME:
5783         return True
5784     if node.type == syms.power:
5785         if node.children:
5786             return (
5787                 node.children[0].type == token.NAME
5788                 and all(map(is_simple_decorator_trailer, node.children[1:-1]))
5789                 and (
5790                     len(node.children) < 2
5791                     or is_simple_decorator_trailer(node.children[-1], last=True)
5792                 )
5793             )
5794     return False
5795
5796
5797 def is_yield(node: LN) -> bool:
5798     """Return True if `node` holds a `yield` or `yield from` expression."""
5799     if node.type == syms.yield_expr:
5800         return True
5801
5802     if node.type == token.NAME and node.value == "yield":  # type: ignore
5803         return True
5804
5805     if node.type != syms.atom:
5806         return False
5807
5808     if len(node.children) != 3:
5809         return False
5810
5811     lpar, expr, rpar = node.children
5812     if lpar.type == token.LPAR and rpar.type == token.RPAR:
5813         return is_yield(expr)
5814
5815     return False
5816
5817
5818 def is_vararg(leaf: Leaf, within: Set[NodeType]) -> bool:
5819     """Return True if `leaf` is a star or double star in a vararg or kwarg.
5820
5821     If `within` includes VARARGS_PARENTS, this applies to function signatures.
5822     If `within` includes UNPACKING_PARENTS, it applies to right hand-side
5823     extended iterable unpacking (PEP 3132) and additional unpacking
5824     generalizations (PEP 448).
5825     """
5826     if leaf.type not in VARARGS_SPECIALS or not leaf.parent:
5827         return False
5828
5829     p = leaf.parent
5830     if p.type == syms.star_expr:
5831         # Star expressions are also used as assignment targets in extended
5832         # iterable unpacking (PEP 3132).  See what its parent is instead.
5833         if not p.parent:
5834             return False
5835
5836         p = p.parent
5837
5838     return p.type in within
5839
5840
5841 def is_multiline_string(leaf: Leaf) -> bool:
5842     """Return True if `leaf` is a multiline string that actually spans many lines."""
5843     return has_triple_quotes(leaf.value) and "\n" in leaf.value
5844
5845
5846 def is_stub_suite(node: Node) -> bool:
5847     """Return True if `node` is a suite with a stub body."""
5848     if (
5849         len(node.children) != 4
5850         or node.children[0].type != token.NEWLINE
5851         or node.children[1].type != token.INDENT
5852         or node.children[3].type != token.DEDENT
5853     ):
5854         return False
5855
5856     return is_stub_body(node.children[2])
5857
5858
5859 def is_stub_body(node: LN) -> bool:
5860     """Return True if `node` is a simple statement containing an ellipsis."""
5861     if not isinstance(node, Node) or node.type != syms.simple_stmt:
5862         return False
5863
5864     if len(node.children) != 2:
5865         return False
5866
5867     child = node.children[0]
5868     return (
5869         child.type == syms.atom
5870         and len(child.children) == 3
5871         and all(leaf == Leaf(token.DOT, ".") for leaf in child.children)
5872     )
5873
5874
5875 def max_delimiter_priority_in_atom(node: LN) -> Priority:
5876     """Return maximum delimiter priority inside `node`.
5877
5878     This is specific to atoms with contents contained in a pair of parentheses.
5879     If `node` isn't an atom or there are no enclosing parentheses, returns 0.
5880     """
5881     if node.type != syms.atom:
5882         return 0
5883
5884     first = node.children[0]
5885     last = node.children[-1]
5886     if not (first.type == token.LPAR and last.type == token.RPAR):
5887         return 0
5888
5889     bt = BracketTracker()
5890     for c in node.children[1:-1]:
5891         if isinstance(c, Leaf):
5892             bt.mark(c)
5893         else:
5894             for leaf in c.leaves():
5895                 bt.mark(leaf)
5896     try:
5897         return bt.max_delimiter_priority()
5898
5899     except ValueError:
5900         return 0
5901
5902
5903 def ensure_visible(leaf: Leaf) -> None:
5904     """Make sure parentheses are visible.
5905
5906     They could be invisible as part of some statements (see
5907     :func:`normalize_invisible_parens` and :func:`visit_import_from`).
5908     """
5909     if leaf.type == token.LPAR:
5910         leaf.value = "("
5911     elif leaf.type == token.RPAR:
5912         leaf.value = ")"
5913
5914
5915 def should_split_line(line: Line, opening_bracket: Leaf) -> bool:
5916     """Should `line` be immediately split with `delimiter_split()` after RHS?"""
5917
5918     if not (opening_bracket.parent and opening_bracket.value in "[{("):
5919         return False
5920
5921     # We're essentially checking if the body is delimited by commas and there's more
5922     # than one of them (we're excluding the trailing comma and if the delimiter priority
5923     # is still commas, that means there's more).
5924     exclude = set()
5925     trailing_comma = False
5926     try:
5927         last_leaf = line.leaves[-1]
5928         if last_leaf.type == token.COMMA:
5929             trailing_comma = True
5930             exclude.add(id(last_leaf))
5931         max_priority = line.bracket_tracker.max_delimiter_priority(exclude=exclude)
5932     except (IndexError, ValueError):
5933         return False
5934
5935     return max_priority == COMMA_PRIORITY and (
5936         (line.mode.magic_trailing_comma and trailing_comma)
5937         # always explode imports
5938         or opening_bracket.parent.type in {syms.atom, syms.import_from}
5939     )
5940
5941
5942 def is_one_tuple_between(opening: Leaf, closing: Leaf, leaves: List[Leaf]) -> bool:
5943     """Return True if content between `opening` and `closing` looks like a one-tuple."""
5944     if opening.type != token.LPAR and closing.type != token.RPAR:
5945         return False
5946
5947     depth = closing.bracket_depth + 1
5948     for _opening_index, leaf in enumerate(leaves):
5949         if leaf is opening:
5950             break
5951
5952     else:
5953         raise LookupError("Opening paren not found in `leaves`")
5954
5955     commas = 0
5956     _opening_index += 1
5957     for leaf in leaves[_opening_index:]:
5958         if leaf is closing:
5959             break
5960
5961         bracket_depth = leaf.bracket_depth
5962         if bracket_depth == depth and leaf.type == token.COMMA:
5963             commas += 1
5964             if leaf.parent and leaf.parent.type in {
5965                 syms.arglist,
5966                 syms.typedargslist,
5967             }:
5968                 commas += 1
5969                 break
5970
5971     return commas < 2
5972
5973
5974 def get_features_used(node: Node) -> Set[Feature]:
5975     """Return a set of (relatively) new Python features used in this file.
5976
5977     Currently looking for:
5978     - f-strings;
5979     - underscores in numeric literals;
5980     - trailing commas after * or ** in function signatures and calls;
5981     - positional only arguments in function signatures and lambdas;
5982     - assignment expression;
5983     - relaxed decorator syntax;
5984     """
5985     features: Set[Feature] = set()
5986     for n in node.pre_order():
5987         if n.type == token.STRING:
5988             value_head = n.value[:2]  # type: ignore
5989             if value_head in {'f"', 'F"', "f'", "F'", "rf", "fr", "RF", "FR"}:
5990                 features.add(Feature.F_STRINGS)
5991
5992         elif n.type == token.NUMBER:
5993             if "_" in n.value:  # type: ignore
5994                 features.add(Feature.NUMERIC_UNDERSCORES)
5995
5996         elif n.type == token.SLASH:
5997             if n.parent and n.parent.type in {syms.typedargslist, syms.arglist}:
5998                 features.add(Feature.POS_ONLY_ARGUMENTS)
5999
6000         elif n.type == token.COLONEQUAL:
6001             features.add(Feature.ASSIGNMENT_EXPRESSIONS)
6002
6003         elif n.type == syms.decorator:
6004             if len(n.children) > 1 and not is_simple_decorator_expression(
6005                 n.children[1]
6006             ):
6007                 features.add(Feature.RELAXED_DECORATORS)
6008
6009         elif (
6010             n.type in {syms.typedargslist, syms.arglist}
6011             and n.children
6012             and n.children[-1].type == token.COMMA
6013         ):
6014             if n.type == syms.typedargslist:
6015                 feature = Feature.TRAILING_COMMA_IN_DEF
6016             else:
6017                 feature = Feature.TRAILING_COMMA_IN_CALL
6018
6019             for ch in n.children:
6020                 if ch.type in STARS:
6021                     features.add(feature)
6022
6023                 if ch.type == syms.argument:
6024                     for argch in ch.children:
6025                         if argch.type in STARS:
6026                             features.add(feature)
6027
6028     return features
6029
6030
6031 def detect_target_versions(node: Node) -> Set[TargetVersion]:
6032     """Detect the version to target based on the nodes used."""
6033     features = get_features_used(node)
6034     return {
6035         version for version in TargetVersion if features <= VERSION_TO_FEATURES[version]
6036     }
6037
6038
6039 def generate_trailers_to_omit(line: Line, line_length: int) -> Iterator[Set[LeafID]]:
6040     """Generate sets of closing bracket IDs that should be omitted in a RHS.
6041
6042     Brackets can be omitted if the entire trailer up to and including
6043     a preceding closing bracket fits in one line.
6044
6045     Yielded sets are cumulative (contain results of previous yields, too).  First
6046     set is empty, unless the line should explode, in which case bracket pairs until
6047     the one that needs to explode are omitted.
6048     """
6049
6050     omit: Set[LeafID] = set()
6051     if not line.magic_trailing_comma:
6052         yield omit
6053
6054     length = 4 * line.depth
6055     opening_bracket: Optional[Leaf] = None
6056     closing_bracket: Optional[Leaf] = None
6057     inner_brackets: Set[LeafID] = set()
6058     for index, leaf, leaf_length in enumerate_with_length(line, reversed=True):
6059         length += leaf_length
6060         if length > line_length:
6061             break
6062
6063         has_inline_comment = leaf_length > len(leaf.value) + len(leaf.prefix)
6064         if leaf.type == STANDALONE_COMMENT or has_inline_comment:
6065             break
6066
6067         if opening_bracket:
6068             if leaf is opening_bracket:
6069                 opening_bracket = None
6070             elif leaf.type in CLOSING_BRACKETS:
6071                 prev = line.leaves[index - 1] if index > 0 else None
6072                 if (
6073                     prev
6074                     and prev.type == token.COMMA
6075                     and not is_one_tuple_between(
6076                         leaf.opening_bracket, leaf, line.leaves
6077                     )
6078                 ):
6079                     # Never omit bracket pairs with trailing commas.
6080                     # We need to explode on those.
6081                     break
6082
6083                 inner_brackets.add(id(leaf))
6084         elif leaf.type in CLOSING_BRACKETS:
6085             prev = line.leaves[index - 1] if index > 0 else None
6086             if prev and prev.type in OPENING_BRACKETS:
6087                 # Empty brackets would fail a split so treat them as "inner"
6088                 # brackets (e.g. only add them to the `omit` set if another
6089                 # pair of brackets was good enough.
6090                 inner_brackets.add(id(leaf))
6091                 continue
6092
6093             if closing_bracket:
6094                 omit.add(id(closing_bracket))
6095                 omit.update(inner_brackets)
6096                 inner_brackets.clear()
6097                 yield omit
6098
6099             if (
6100                 prev
6101                 and prev.type == token.COMMA
6102                 and not is_one_tuple_between(leaf.opening_bracket, leaf, line.leaves)
6103             ):
6104                 # Never omit bracket pairs with trailing commas.
6105                 # We need to explode on those.
6106                 break
6107
6108             if leaf.value:
6109                 opening_bracket = leaf.opening_bracket
6110                 closing_bracket = leaf
6111
6112
6113 def get_future_imports(node: Node) -> Set[str]:
6114     """Return a set of __future__ imports in the file."""
6115     imports: Set[str] = set()
6116
6117     def get_imports_from_children(children: List[LN]) -> Generator[str, None, None]:
6118         for child in children:
6119             if isinstance(child, Leaf):
6120                 if child.type == token.NAME:
6121                     yield child.value
6122
6123             elif child.type == syms.import_as_name:
6124                 orig_name = child.children[0]
6125                 assert isinstance(orig_name, Leaf), "Invalid syntax parsing imports"
6126                 assert orig_name.type == token.NAME, "Invalid syntax parsing imports"
6127                 yield orig_name.value
6128
6129             elif child.type == syms.import_as_names:
6130                 yield from get_imports_from_children(child.children)
6131
6132             else:
6133                 raise AssertionError("Invalid syntax parsing imports")
6134
6135     for child in node.children:
6136         if child.type != syms.simple_stmt:
6137             break
6138
6139         first_child = child.children[0]
6140         if isinstance(first_child, Leaf):
6141             # Continue looking if we see a docstring; otherwise stop.
6142             if (
6143                 len(child.children) == 2
6144                 and first_child.type == token.STRING
6145                 and child.children[1].type == token.NEWLINE
6146             ):
6147                 continue
6148
6149             break
6150
6151         elif first_child.type == syms.import_from:
6152             module_name = first_child.children[1]
6153             if not isinstance(module_name, Leaf) or module_name.value != "__future__":
6154                 break
6155
6156             imports |= set(get_imports_from_children(first_child.children[3:]))
6157         else:
6158             break
6159
6160     return imports
6161
6162
6163 @lru_cache()
6164 def get_gitignore(root: Path) -> PathSpec:
6165     """Return a PathSpec matching gitignore content if present."""
6166     gitignore = root / ".gitignore"
6167     lines: List[str] = []
6168     if gitignore.is_file():
6169         with gitignore.open() as gf:
6170             lines = gf.readlines()
6171     return PathSpec.from_lines("gitwildmatch", lines)
6172
6173
6174 def normalize_path_maybe_ignore(
6175     path: Path, root: Path, report: "Report"
6176 ) -> Optional[str]:
6177     """Normalize `path`. May return `None` if `path` was ignored.
6178
6179     `report` is where "path ignored" output goes.
6180     """
6181     try:
6182         abspath = path if path.is_absolute() else Path.cwd() / path
6183         normalized_path = abspath.resolve().relative_to(root).as_posix()
6184     except OSError as e:
6185         report.path_ignored(path, f"cannot be read because {e}")
6186         return None
6187
6188     except ValueError:
6189         if path.is_symlink():
6190             report.path_ignored(path, f"is a symbolic link that points outside {root}")
6191             return None
6192
6193         raise
6194
6195     return normalized_path
6196
6197
6198 def path_is_excluded(
6199     normalized_path: str,
6200     pattern: Optional[Pattern[str]],
6201 ) -> bool:
6202     match = pattern.search(normalized_path) if pattern else None
6203     return bool(match and match.group(0))
6204
6205
6206 def gen_python_files(
6207     paths: Iterable[Path],
6208     root: Path,
6209     include: Optional[Pattern[str]],
6210     exclude: Pattern[str],
6211     extend_exclude: Optional[Pattern[str]],
6212     force_exclude: Optional[Pattern[str]],
6213     report: "Report",
6214     gitignore: PathSpec,
6215 ) -> Iterator[Path]:
6216     """Generate all files under `path` whose paths are not excluded by the
6217     `exclude_regex`, `extend_exclude`, or `force_exclude` regexes,
6218     but are included by the `include` regex.
6219
6220     Symbolic links pointing outside of the `root` directory are ignored.
6221
6222     `report` is where output about exclusions goes.
6223     """
6224     assert root.is_absolute(), f"INTERNAL ERROR: `root` must be absolute but is {root}"
6225     for child in paths:
6226         normalized_path = normalize_path_maybe_ignore(child, root, report)
6227         if normalized_path is None:
6228             continue
6229
6230         # First ignore files matching .gitignore
6231         if gitignore.match_file(normalized_path):
6232             report.path_ignored(child, "matches the .gitignore file content")
6233             continue
6234
6235         # Then ignore with `--exclude` `--extend-exclude` and `--force-exclude` options.
6236         normalized_path = "/" + normalized_path
6237         if child.is_dir():
6238             normalized_path += "/"
6239
6240         if path_is_excluded(normalized_path, exclude):
6241             report.path_ignored(child, "matches the --exclude regular expression")
6242             continue
6243
6244         if path_is_excluded(normalized_path, extend_exclude):
6245             report.path_ignored(
6246                 child, "matches the --extend-exclude regular expression"
6247             )
6248             continue
6249
6250         if path_is_excluded(normalized_path, force_exclude):
6251             report.path_ignored(child, "matches the --force-exclude regular expression")
6252             continue
6253
6254         if child.is_dir():
6255             yield from gen_python_files(
6256                 child.iterdir(),
6257                 root,
6258                 include,
6259                 exclude,
6260                 extend_exclude,
6261                 force_exclude,
6262                 report,
6263                 gitignore,
6264             )
6265
6266         elif child.is_file():
6267             include_match = include.search(normalized_path) if include else True
6268             if include_match:
6269                 yield child
6270
6271
6272 @lru_cache()
6273 def find_project_root(srcs: Tuple[str, ...]) -> Path:
6274     """Return a directory containing .git, .hg, or pyproject.toml.
6275
6276     That directory will be a common parent of all files and directories
6277     passed in `srcs`.
6278
6279     If no directory in the tree contains a marker that would specify it's the
6280     project root, the root of the file system is returned.
6281     """
6282     if not srcs:
6283         return Path("/").resolve()
6284
6285     path_srcs = [Path(Path.cwd(), src).resolve() for src in srcs]
6286
6287     # A list of lists of parents for each 'src'. 'src' is included as a
6288     # "parent" of itself if it is a directory
6289     src_parents = [
6290         list(path.parents) + ([path] if path.is_dir() else []) for path in path_srcs
6291     ]
6292
6293     common_base = max(
6294         set.intersection(*(set(parents) for parents in src_parents)),
6295         key=lambda path: path.parts,
6296     )
6297
6298     for directory in (common_base, *common_base.parents):
6299         if (directory / ".git").exists():
6300             return directory
6301
6302         if (directory / ".hg").is_dir():
6303             return directory
6304
6305         if (directory / "pyproject.toml").is_file():
6306             return directory
6307
6308     return directory
6309
6310
6311 @lru_cache()
6312 def find_user_pyproject_toml() -> Path:
6313     r"""Return the path to the top-level user configuration for black.
6314
6315     This looks for ~\.black on Windows and ~/.config/black on Linux and other
6316     Unix systems.
6317     """
6318     if sys.platform == "win32":
6319         # Windows
6320         user_config_path = Path.home() / ".black"
6321     else:
6322         config_root = os.environ.get("XDG_CONFIG_HOME", "~/.config")
6323         user_config_path = Path(config_root).expanduser() / "black"
6324     return user_config_path.resolve()
6325
6326
6327 @dataclass
6328 class Report:
6329     """Provides a reformatting counter. Can be rendered with `str(report)`."""
6330
6331     check: bool = False
6332     diff: bool = False
6333     quiet: bool = False
6334     verbose: bool = False
6335     change_count: int = 0
6336     same_count: int = 0
6337     failure_count: int = 0
6338
6339     def done(self, src: Path, changed: Changed) -> None:
6340         """Increment the counter for successful reformatting. Write out a message."""
6341         if changed is Changed.YES:
6342             reformatted = "would reformat" if self.check or self.diff else "reformatted"
6343             if self.verbose or not self.quiet:
6344                 out(f"{reformatted} {src}")
6345             self.change_count += 1
6346         else:
6347             if self.verbose:
6348                 if changed is Changed.NO:
6349                     msg = f"{src} already well formatted, good job."
6350                 else:
6351                     msg = f"{src} wasn't modified on disk since last run."
6352                 out(msg, bold=False)
6353             self.same_count += 1
6354
6355     def failed(self, src: Path, message: str) -> None:
6356         """Increment the counter for failed reformatting. Write out a message."""
6357         err(f"error: cannot format {src}: {message}")
6358         self.failure_count += 1
6359
6360     def path_ignored(self, path: Path, message: str) -> None:
6361         if self.verbose:
6362             out(f"{path} ignored: {message}", bold=False)
6363
6364     @property
6365     def return_code(self) -> int:
6366         """Return the exit code that the app should use.
6367
6368         This considers the current state of changed files and failures:
6369         - if there were any failures, return 123;
6370         - if any files were changed and --check is being used, return 1;
6371         - otherwise return 0.
6372         """
6373         # According to http://tldp.org/LDP/abs/html/exitcodes.html starting with
6374         # 126 we have special return codes reserved by the shell.
6375         if self.failure_count:
6376             return 123
6377
6378         elif self.change_count and self.check:
6379             return 1
6380
6381         return 0
6382
6383     def __str__(self) -> str:
6384         """Render a color report of the current state.
6385
6386         Use `click.unstyle` to remove colors.
6387         """
6388         if self.check or self.diff:
6389             reformatted = "would be reformatted"
6390             unchanged = "would be left unchanged"
6391             failed = "would fail to reformat"
6392         else:
6393             reformatted = "reformatted"
6394             unchanged = "left unchanged"
6395             failed = "failed to reformat"
6396         report = []
6397         if self.change_count:
6398             s = "s" if self.change_count > 1 else ""
6399             report.append(
6400                 click.style(f"{self.change_count} file{s} {reformatted}", bold=True)
6401             )
6402         if self.same_count:
6403             s = "s" if self.same_count > 1 else ""
6404             report.append(f"{self.same_count} file{s} {unchanged}")
6405         if self.failure_count:
6406             s = "s" if self.failure_count > 1 else ""
6407             report.append(
6408                 click.style(f"{self.failure_count} file{s} {failed}", fg="red")
6409             )
6410         return ", ".join(report) + "."
6411
6412
6413 def parse_ast(src: str) -> Union[ast.AST, ast3.AST, ast27.AST]:
6414     filename = "<unknown>"
6415     if sys.version_info >= (3, 8):
6416         # TODO: support Python 4+ ;)
6417         for minor_version in range(sys.version_info[1], 4, -1):
6418             try:
6419                 return ast.parse(src, filename, feature_version=(3, minor_version))
6420             except SyntaxError:
6421                 continue
6422     else:
6423         for feature_version in (7, 6):
6424             try:
6425                 return ast3.parse(src, filename, feature_version=feature_version)
6426             except SyntaxError:
6427                 continue
6428     if ast27.__name__ == "ast":
6429         raise SyntaxError(
6430             "The requested source code has invalid Python 3 syntax.\n"
6431             "If you are trying to format Python 2 files please reinstall Black"
6432             " with the 'python2' extra: `python3 -m pip install black[python2]`."
6433         )
6434     return ast27.parse(src)
6435
6436
6437 def _fixup_ast_constants(
6438     node: Union[ast.AST, ast3.AST, ast27.AST]
6439 ) -> Union[ast.AST, ast3.AST, ast27.AST]:
6440     """Map ast nodes deprecated in 3.8 to Constant."""
6441     if isinstance(node, (ast.Str, ast3.Str, ast27.Str, ast.Bytes, ast3.Bytes)):
6442         return ast.Constant(value=node.s)
6443
6444     if isinstance(node, (ast.Num, ast3.Num, ast27.Num)):
6445         return ast.Constant(value=node.n)
6446
6447     if isinstance(node, (ast.NameConstant, ast3.NameConstant)):
6448         return ast.Constant(value=node.value)
6449
6450     return node
6451
6452
6453 def _stringify_ast(
6454     node: Union[ast.AST, ast3.AST, ast27.AST], depth: int = 0
6455 ) -> Iterator[str]:
6456     """Simple visitor generating strings to compare ASTs by content."""
6457
6458     node = _fixup_ast_constants(node)
6459
6460     yield f"{'  ' * depth}{node.__class__.__name__}("
6461
6462     for field in sorted(node._fields):  # noqa: F402
6463         # TypeIgnore has only one field 'lineno' which breaks this comparison
6464         type_ignore_classes = (ast3.TypeIgnore, ast27.TypeIgnore)
6465         if sys.version_info >= (3, 8):
6466             type_ignore_classes += (ast.TypeIgnore,)
6467         if isinstance(node, type_ignore_classes):
6468             break
6469
6470         try:
6471             value = getattr(node, field)
6472         except AttributeError:
6473             continue
6474
6475         yield f"{'  ' * (depth+1)}{field}="
6476
6477         if isinstance(value, list):
6478             for item in value:
6479                 # Ignore nested tuples within del statements, because we may insert
6480                 # parentheses and they change the AST.
6481                 if (
6482                     field == "targets"
6483                     and isinstance(node, (ast.Delete, ast3.Delete, ast27.Delete))
6484                     and isinstance(item, (ast.Tuple, ast3.Tuple, ast27.Tuple))
6485                 ):
6486                     for item in item.elts:
6487                         yield from _stringify_ast(item, depth + 2)
6488
6489                 elif isinstance(item, (ast.AST, ast3.AST, ast27.AST)):
6490                     yield from _stringify_ast(item, depth + 2)
6491
6492         elif isinstance(value, (ast.AST, ast3.AST, ast27.AST)):
6493             yield from _stringify_ast(value, depth + 2)
6494
6495         else:
6496             # Constant strings may be indented across newlines, if they are
6497             # docstrings; fold spaces after newlines when comparing. Similarly,
6498             # trailing and leading space may be removed.
6499             # Note that when formatting Python 2 code, at least with Windows
6500             # line-endings, docstrings can end up here as bytes instead of
6501             # str so make sure that we handle both cases.
6502             if (
6503                 isinstance(node, ast.Constant)
6504                 and field == "value"
6505                 and isinstance(value, (str, bytes))
6506             ):
6507                 lineend = "\n" if isinstance(value, str) else b"\n"
6508                 # To normalize, we strip any leading and trailing space from
6509                 # each line...
6510                 stripped = [line.strip() for line in value.splitlines()]
6511                 normalized = lineend.join(stripped)  # type: ignore[attr-defined]
6512                 # ...and remove any blank lines at the beginning and end of
6513                 # the whole string
6514                 normalized = normalized.strip()
6515             else:
6516                 normalized = value
6517             yield f"{'  ' * (depth+2)}{normalized!r},  # {value.__class__.__name__}"
6518
6519     yield f"{'  ' * depth})  # /{node.__class__.__name__}"
6520
6521
6522 def assert_equivalent(src: str, dst: str, *, pass_num: int = 1) -> None:
6523     """Raise AssertionError if `src` and `dst` aren't equivalent."""
6524     try:
6525         src_ast = parse_ast(src)
6526     except Exception as exc:
6527         raise AssertionError(
6528             "cannot use --safe with this file; failed to parse source file.  AST"
6529             f" error message: {exc}"
6530         )
6531
6532     try:
6533         dst_ast = parse_ast(dst)
6534     except Exception as exc:
6535         log = dump_to_file("".join(traceback.format_tb(exc.__traceback__)), dst)
6536         raise AssertionError(
6537             f"INTERNAL ERROR: Black produced invalid code on pass {pass_num}: {exc}. "
6538             "Please report a bug on https://github.com/psf/black/issues.  "
6539             f"This invalid output might be helpful: {log}"
6540         ) from None
6541
6542     src_ast_str = "\n".join(_stringify_ast(src_ast))
6543     dst_ast_str = "\n".join(_stringify_ast(dst_ast))
6544     if src_ast_str != dst_ast_str:
6545         log = dump_to_file(diff(src_ast_str, dst_ast_str, "src", "dst"))
6546         raise AssertionError(
6547             "INTERNAL ERROR: Black produced code that is not equivalent to the"
6548             f" source on pass {pass_num}.  Please report a bug on "
6549             f"https://github.com/psf/black/issues.  This diff might be helpful: {log}"
6550         ) from None
6551
6552
6553 def assert_stable(src: str, dst: str, mode: Mode) -> None:
6554     """Raise AssertionError if `dst` reformats differently the second time."""
6555     newdst = format_str(dst, mode=mode)
6556     if dst != newdst:
6557         log = dump_to_file(
6558             str(mode),
6559             diff(src, dst, "source", "first pass"),
6560             diff(dst, newdst, "first pass", "second pass"),
6561         )
6562         raise AssertionError(
6563             "INTERNAL ERROR: Black produced different code on the second pass of the"
6564             " formatter.  Please report a bug on https://github.com/psf/black/issues."
6565             f"  This diff might be helpful: {log}"
6566         ) from None
6567
6568
6569 @mypyc_attr(patchable=True)
6570 def dump_to_file(*output: str, ensure_final_newline: bool = True) -> str:
6571     """Dump `output` to a temporary file. Return path to the file."""
6572     with tempfile.NamedTemporaryFile(
6573         mode="w", prefix="blk_", suffix=".log", delete=False, encoding="utf8"
6574     ) as f:
6575         for lines in output:
6576             f.write(lines)
6577             if ensure_final_newline and lines and lines[-1] != "\n":
6578                 f.write("\n")
6579     return f.name
6580
6581
6582 @contextmanager
6583 def nullcontext() -> Iterator[None]:
6584     """Return an empty context manager.
6585
6586     To be used like `nullcontext` in Python 3.7.
6587     """
6588     yield
6589
6590
6591 def diff(a: str, b: str, a_name: str, b_name: str) -> str:
6592     """Return a unified diff string between strings `a` and `b`."""
6593     import difflib
6594
6595     a_lines = [line for line in a.splitlines(keepends=True)]
6596     b_lines = [line for line in b.splitlines(keepends=True)]
6597     diff_lines = []
6598     for line in difflib.unified_diff(
6599         a_lines, b_lines, fromfile=a_name, tofile=b_name, n=5
6600     ):
6601         # Work around https://bugs.python.org/issue2142
6602         # See https://www.gnu.org/software/diffutils/manual/html_node/Incomplete-Lines.html
6603         if line[-1] == "\n":
6604             diff_lines.append(line)
6605         else:
6606             diff_lines.append(line + "\n")
6607             diff_lines.append("\\ No newline at end of file\n")
6608     return "".join(diff_lines)
6609
6610
6611 def cancel(tasks: Iterable["asyncio.Task[Any]"]) -> None:
6612     """asyncio signal handler that cancels all `tasks` and reports to stderr."""
6613     err("Aborted!")
6614     for task in tasks:
6615         task.cancel()
6616
6617
6618 def shutdown(loop: asyncio.AbstractEventLoop) -> None:
6619     """Cancel all pending tasks on `loop`, wait for them, and close the loop."""
6620     try:
6621         if sys.version_info[:2] >= (3, 7):
6622             all_tasks = asyncio.all_tasks
6623         else:
6624             all_tasks = asyncio.Task.all_tasks
6625         # This part is borrowed from asyncio/runners.py in Python 3.7b2.
6626         to_cancel = [task for task in all_tasks(loop) if not task.done()]
6627         if not to_cancel:
6628             return
6629
6630         for task in to_cancel:
6631             task.cancel()
6632         loop.run_until_complete(
6633             asyncio.gather(*to_cancel, loop=loop, return_exceptions=True)
6634         )
6635     finally:
6636         # `concurrent.futures.Future` objects cannot be cancelled once they
6637         # are already running. There might be some when the `shutdown()` happened.
6638         # Silence their logger's spew about the event loop being closed.
6639         cf_logger = logging.getLogger("concurrent.futures")
6640         cf_logger.setLevel(logging.CRITICAL)
6641         loop.close()
6642
6643
6644 def sub_twice(regex: Pattern[str], replacement: str, original: str) -> str:
6645     """Replace `regex` with `replacement` twice on `original`.
6646
6647     This is used by string normalization to perform replaces on
6648     overlapping matches.
6649     """
6650     return regex.sub(replacement, regex.sub(replacement, original))
6651
6652
6653 def re_compile_maybe_verbose(regex: str) -> Pattern[str]:
6654     """Compile a regular expression string in `regex`.
6655
6656     If it contains newlines, use verbose mode.
6657     """
6658     if "\n" in regex:
6659         regex = "(?x)" + regex
6660     compiled: Pattern[str] = re.compile(regex)
6661     return compiled
6662
6663
6664 def enumerate_reversed(sequence: Sequence[T]) -> Iterator[Tuple[Index, T]]:
6665     """Like `reversed(enumerate(sequence))` if that were possible."""
6666     index = len(sequence) - 1
6667     for element in reversed(sequence):
6668         yield (index, element)
6669         index -= 1
6670
6671
6672 def enumerate_with_length(
6673     line: Line, reversed: bool = False
6674 ) -> Iterator[Tuple[Index, Leaf, int]]:
6675     """Return an enumeration of leaves with their length.
6676
6677     Stops prematurely on multiline strings and standalone comments.
6678     """
6679     op = cast(
6680         Callable[[Sequence[Leaf]], Iterator[Tuple[Index, Leaf]]],
6681         enumerate_reversed if reversed else enumerate,
6682     )
6683     for index, leaf in op(line.leaves):
6684         length = len(leaf.prefix) + len(leaf.value)
6685         if "\n" in leaf.value:
6686             return  # Multiline strings, we can't continue.
6687
6688         for comment in line.comments_after(leaf):
6689             length += len(comment.value)
6690
6691         yield index, leaf, length
6692
6693
6694 def is_line_short_enough(line: Line, *, line_length: int, line_str: str = "") -> bool:
6695     """Return True if `line` is no longer than `line_length`.
6696
6697     Uses the provided `line_str` rendering, if any, otherwise computes a new one.
6698     """
6699     if not line_str:
6700         line_str = line_to_string(line)
6701     return (
6702         len(line_str) <= line_length
6703         and "\n" not in line_str  # multiline strings
6704         and not line.contains_standalone_comments()
6705     )
6706
6707
6708 def can_be_split(line: Line) -> bool:
6709     """Return False if the line cannot be split *for sure*.
6710
6711     This is not an exhaustive search but a cheap heuristic that we can use to
6712     avoid some unfortunate formattings (mostly around wrapping unsplittable code
6713     in unnecessary parentheses).
6714     """
6715     leaves = line.leaves
6716     if len(leaves) < 2:
6717         return False
6718
6719     if leaves[0].type == token.STRING and leaves[1].type == token.DOT:
6720         call_count = 0
6721         dot_count = 0
6722         next = leaves[-1]
6723         for leaf in leaves[-2::-1]:
6724             if leaf.type in OPENING_BRACKETS:
6725                 if next.type not in CLOSING_BRACKETS:
6726                     return False
6727
6728                 call_count += 1
6729             elif leaf.type == token.DOT:
6730                 dot_count += 1
6731             elif leaf.type == token.NAME:
6732                 if not (next.type == token.DOT or next.type in OPENING_BRACKETS):
6733                     return False
6734
6735             elif leaf.type not in CLOSING_BRACKETS:
6736                 return False
6737
6738             if dot_count > 1 and call_count > 1:
6739                 return False
6740
6741     return True
6742
6743
6744 def can_omit_invisible_parens(
6745     line: Line,
6746     line_length: int,
6747     omit_on_explode: Collection[LeafID] = (),
6748 ) -> bool:
6749     """Does `line` have a shape safe to reformat without optional parens around it?
6750
6751     Returns True for only a subset of potentially nice looking formattings but
6752     the point is to not return false positives that end up producing lines that
6753     are too long.
6754     """
6755     bt = line.bracket_tracker
6756     if not bt.delimiters:
6757         # Without delimiters the optional parentheses are useless.
6758         return True
6759
6760     max_priority = bt.max_delimiter_priority()
6761     if bt.delimiter_count_with_priority(max_priority) > 1:
6762         # With more than one delimiter of a kind the optional parentheses read better.
6763         return False
6764
6765     if max_priority == DOT_PRIORITY:
6766         # A single stranded method call doesn't require optional parentheses.
6767         return True
6768
6769     assert len(line.leaves) >= 2, "Stranded delimiter"
6770
6771     # With a single delimiter, omit if the expression starts or ends with
6772     # a bracket.
6773     first = line.leaves[0]
6774     second = line.leaves[1]
6775     if first.type in OPENING_BRACKETS and second.type not in CLOSING_BRACKETS:
6776         if _can_omit_opening_paren(line, first=first, line_length=line_length):
6777             return True
6778
6779         # Note: we are not returning False here because a line might have *both*
6780         # a leading opening bracket and a trailing closing bracket.  If the
6781         # opening bracket doesn't match our rule, maybe the closing will.
6782
6783     penultimate = line.leaves[-2]
6784     last = line.leaves[-1]
6785     if line.magic_trailing_comma:
6786         try:
6787             penultimate, last = last_two_except(line.leaves, omit=omit_on_explode)
6788         except LookupError:
6789             # Turns out we'd omit everything.  We cannot skip the optional parentheses.
6790             return False
6791
6792     if (
6793         last.type == token.RPAR
6794         or last.type == token.RBRACE
6795         or (
6796             # don't use indexing for omitting optional parentheses;
6797             # it looks weird
6798             last.type == token.RSQB
6799             and last.parent
6800             and last.parent.type != syms.trailer
6801         )
6802     ):
6803         if penultimate.type in OPENING_BRACKETS:
6804             # Empty brackets don't help.
6805             return False
6806
6807         if is_multiline_string(first):
6808             # Additional wrapping of a multiline string in this situation is
6809             # unnecessary.
6810             return True
6811
6812         if line.magic_trailing_comma and penultimate.type == token.COMMA:
6813             # The rightmost non-omitted bracket pair is the one we want to explode on.
6814             return True
6815
6816         if _can_omit_closing_paren(line, last=last, line_length=line_length):
6817             return True
6818
6819     return False
6820
6821
6822 def _can_omit_opening_paren(line: Line, *, first: Leaf, line_length: int) -> bool:
6823     """See `can_omit_invisible_parens`."""
6824     remainder = False
6825     length = 4 * line.depth
6826     _index = -1
6827     for _index, leaf, leaf_length in enumerate_with_length(line):
6828         if leaf.type in CLOSING_BRACKETS and leaf.opening_bracket is first:
6829             remainder = True
6830         if remainder:
6831             length += leaf_length
6832             if length > line_length:
6833                 break
6834
6835             if leaf.type in OPENING_BRACKETS:
6836                 # There are brackets we can further split on.
6837                 remainder = False
6838
6839     else:
6840         # checked the entire string and line length wasn't exceeded
6841         if len(line.leaves) == _index + 1:
6842             return True
6843
6844     return False
6845
6846
6847 def _can_omit_closing_paren(line: Line, *, last: Leaf, line_length: int) -> bool:
6848     """See `can_omit_invisible_parens`."""
6849     length = 4 * line.depth
6850     seen_other_brackets = False
6851     for _index, leaf, leaf_length in enumerate_with_length(line):
6852         length += leaf_length
6853         if leaf is last.opening_bracket:
6854             if seen_other_brackets or length <= line_length:
6855                 return True
6856
6857         elif leaf.type in OPENING_BRACKETS:
6858             # There are brackets we can further split on.
6859             seen_other_brackets = True
6860
6861     return False
6862
6863
6864 def last_two_except(leaves: List[Leaf], omit: Collection[LeafID]) -> Tuple[Leaf, Leaf]:
6865     """Return (penultimate, last) leaves skipping brackets in `omit` and contents."""
6866     stop_after = None
6867     last = None
6868     for leaf in reversed(leaves):
6869         if stop_after:
6870             if leaf is stop_after:
6871                 stop_after = None
6872             continue
6873
6874         if last:
6875             return leaf, last
6876
6877         if id(leaf) in omit:
6878             stop_after = leaf.opening_bracket
6879         else:
6880             last = leaf
6881     else:
6882         raise LookupError("Last two leaves were also skipped")
6883
6884
6885 def run_transformer(
6886     line: Line,
6887     transform: Transformer,
6888     mode: Mode,
6889     features: Collection[Feature],
6890     *,
6891     line_str: str = "",
6892 ) -> List[Line]:
6893     if not line_str:
6894         line_str = line_to_string(line)
6895     result: List[Line] = []
6896     for transformed_line in transform(line, features):
6897         if str(transformed_line).strip("\n") == line_str:
6898             raise CannotTransform("Line transformer returned an unchanged result")
6899
6900         result.extend(transform_line(transformed_line, mode=mode, features=features))
6901
6902     if not (
6903         transform.__name__ == "rhs"
6904         and line.bracket_tracker.invisible
6905         and not any(bracket.value for bracket in line.bracket_tracker.invisible)
6906         and not line.contains_multiline_strings()
6907         and not result[0].contains_uncollapsable_type_comments()
6908         and not result[0].contains_unsplittable_type_ignore()
6909         and not is_line_short_enough(result[0], line_length=mode.line_length)
6910     ):
6911         return result
6912
6913     line_copy = line.clone()
6914     append_leaves(line_copy, line, line.leaves)
6915     features_fop = set(features) | {Feature.FORCE_OPTIONAL_PARENTHESES}
6916     second_opinion = run_transformer(
6917         line_copy, transform, mode, features_fop, line_str=line_str
6918     )
6919     if all(
6920         is_line_short_enough(ln, line_length=mode.line_length) for ln in second_opinion
6921     ):
6922         result = second_opinion
6923     return result
6924
6925
6926 def get_cache_file(mode: Mode) -> Path:
6927     return CACHE_DIR / f"cache.{mode.get_cache_key()}.pickle"
6928
6929
6930 def read_cache(mode: Mode) -> Cache:
6931     """Read the cache if it exists and is well formed.
6932
6933     If it is not well formed, the call to write_cache later should resolve the issue.
6934     """
6935     cache_file = get_cache_file(mode)
6936     if not cache_file.exists():
6937         return {}
6938
6939     with cache_file.open("rb") as fobj:
6940         try:
6941             cache: Cache = pickle.load(fobj)
6942         except (pickle.UnpicklingError, ValueError):
6943             return {}
6944
6945     return cache
6946
6947
6948 def get_cache_info(path: Path) -> CacheInfo:
6949     """Return the information used to check if a file is already formatted or not."""
6950     stat = path.stat()
6951     return stat.st_mtime, stat.st_size
6952
6953
6954 def filter_cached(cache: Cache, sources: Iterable[Path]) -> Tuple[Set[Path], Set[Path]]:
6955     """Split an iterable of paths in `sources` into two sets.
6956
6957     The first contains paths of files that modified on disk or are not in the
6958     cache. The other contains paths to non-modified files.
6959     """
6960     todo, done = set(), set()
6961     for src in sources:
6962         res_src = src.resolve()
6963         if cache.get(str(res_src)) != get_cache_info(res_src):
6964             todo.add(src)
6965         else:
6966             done.add(src)
6967     return todo, done
6968
6969
6970 def write_cache(cache: Cache, sources: Iterable[Path], mode: Mode) -> None:
6971     """Update the cache file."""
6972     cache_file = get_cache_file(mode)
6973     try:
6974         CACHE_DIR.mkdir(parents=True, exist_ok=True)
6975         new_cache = {
6976             **cache,
6977             **{str(src.resolve()): get_cache_info(src) for src in sources},
6978         }
6979         with tempfile.NamedTemporaryFile(dir=str(cache_file.parent), delete=False) as f:
6980             pickle.dump(new_cache, f, protocol=4)
6981         os.replace(f.name, cache_file)
6982     except OSError:
6983         pass
6984
6985
6986 def patch_click() -> None:
6987     """Make Click not crash.
6988
6989     On certain misconfigured environments, Python 3 selects the ASCII encoding as the
6990     default which restricts paths that it can access during the lifetime of the
6991     application.  Click refuses to work in this scenario by raising a RuntimeError.
6992
6993     In case of Black the likelihood that non-ASCII characters are going to be used in
6994     file paths is minimal since it's Python source code.  Moreover, this crash was
6995     spurious on Python 3.7 thanks to PEP 538 and PEP 540.
6996     """
6997     try:
6998         from click import core
6999         from click import _unicodefun  # type: ignore
7000     except ModuleNotFoundError:
7001         return
7002
7003     for module in (core, _unicodefun):
7004         if hasattr(module, "_verify_python3_env"):
7005             module._verify_python3_env = lambda: None
7006
7007
7008 def patched_main() -> None:
7009     freeze_support()
7010     patch_click()
7011     main()
7012
7013
7014 def is_docstring(leaf: Leaf) -> bool:
7015     if prev_siblings_are(
7016         leaf.parent, [None, token.NEWLINE, token.INDENT, syms.simple_stmt]
7017     ):
7018         return True
7019
7020     # Multiline docstring on the same line as the `def`.
7021     if prev_siblings_are(leaf.parent, [syms.parameters, token.COLON, syms.simple_stmt]):
7022         # `syms.parameters` is only used in funcdefs and async_funcdefs in the Python
7023         # grammar. We're safe to return True without further checks.
7024         return True
7025
7026     return False
7027
7028
7029 def lines_with_leading_tabs_expanded(s: str) -> List[str]:
7030     """
7031     Splits string into lines and expands only leading tabs (following the normal
7032     Python rules)
7033     """
7034     lines = []
7035     for line in s.splitlines():
7036         # Find the index of the first non-whitespace character after a string of
7037         # whitespace that includes at least one tab
7038         match = re.match(r"\s*\t+\s*(\S)", line)
7039         if match:
7040             first_non_whitespace_idx = match.start(1)
7041
7042             lines.append(
7043                 line[:first_non_whitespace_idx].expandtabs()
7044                 + line[first_non_whitespace_idx:]
7045             )
7046         else:
7047             lines.append(line)
7048     return lines
7049
7050
7051 def fix_docstring(docstring: str, prefix: str) -> str:
7052     # https://www.python.org/dev/peps/pep-0257/#handling-docstring-indentation
7053     if not docstring:
7054         return ""
7055     lines = lines_with_leading_tabs_expanded(docstring)
7056     # Determine minimum indentation (first line doesn't count):
7057     indent = sys.maxsize
7058     for line in lines[1:]:
7059         stripped = line.lstrip()
7060         if stripped:
7061             indent = min(indent, len(line) - len(stripped))
7062     # Remove indentation (first line is special):
7063     trimmed = [lines[0].strip()]
7064     if indent < sys.maxsize:
7065         last_line_idx = len(lines) - 2
7066         for i, line in enumerate(lines[1:]):
7067             stripped_line = line[indent:].rstrip()
7068             if stripped_line or i == last_line_idx:
7069                 trimmed.append(prefix + stripped_line)
7070             else:
7071                 trimmed.append("")
7072     return "\n".join(trimmed)
7073
7074
7075 if __name__ == "__main__":
7076     patched_main()