]> 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:

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