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.
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
9 from functools import lru_cache, partial, wraps
13 from multiprocessing import Manager, freeze_support
15 from pathlib import Path
45 from typing_extensions import Final
46 from mypy_extensions import mypyc_attr
48 from appdirs import user_cache_dir
49 from dataclasses import dataclass, field, replace
52 from typed_ast import ast3, ast27
53 from pathspec import PathSpec
56 from blib2to3.pytree import Node, Leaf, type_repr
57 from blib2to3 import pygram, pytree
58 from blib2to3.pgen2 import driver, token
59 from blib2to3.pgen2.grammar import Grammar
60 from blib2to3.pgen2.parse import ParseError
62 from _black_version import version as __version__
65 import colorama # noqa: F401
67 DEFAULT_LINE_LENGTH = 88
68 DEFAULT_EXCLUDES = r"/(\.direnv|\.eggs|\.git|\.hg|\.mypy_cache|\.nox|\.tox|\.venv|\.svn|_build|buck-out|build|dist)/" # noqa: B950
69 DEFAULT_INCLUDES = r"\.pyi?$"
70 CACHE_DIR = Path(user_cache_dir("black", version=__version__))
72 STRING_PREFIX_CHARS: Final = "furbFURB" # All possible string prefix characters.
86 LN = Union[Leaf, Node]
87 Transformer = Callable[["Line", Collection["Feature"]], Iterator["Line"]]
90 CacheInfo = Tuple[Timestamp, FileSize]
91 Cache = Dict[Path, CacheInfo]
92 out = partial(click.secho, bold=True, err=True)
93 err = partial(click.secho, fg="red", err=True)
95 pygram.initialize(CACHE_DIR)
96 syms = pygram.python_symbols
99 class NothingChanged(UserWarning):
100 """Raised when reformatted code is the same as source."""
103 class CannotTransform(Exception):
104 """Base class for errors raised by Transformers."""
107 class CannotSplit(CannotTransform):
108 """A readable split that fits the allotted line length is impossible."""
111 class InvalidInput(ValueError):
112 """Raised when input source code fails all parse attempts."""
116 E = TypeVar("E", bound=Exception)
119 class Ok(Generic[T]):
120 def __init__(self, value: T) -> None:
127 class Err(Generic[E]):
128 def __init__(self, e: E) -> None:
135 # The 'Result' return type is used to implement an error-handling model heavily
136 # influenced by that used by the Rust programming language
137 # (see https://doc.rust-lang.org/book/ch09-00-error-handling.html).
138 Result = Union[Ok[T], Err[E]]
139 TResult = Result[T, CannotTransform] # (T)ransform Result
140 TMatchResult = TResult[Index]
143 class WriteBack(Enum):
151 def from_configuration(
152 cls, *, check: bool, diff: bool, color: bool = False
154 if check and not diff:
158 return cls.COLOR_DIFF
160 return cls.DIFF if diff else cls.YES
169 class TargetVersion(Enum):
178 def is_python2(self) -> bool:
179 return self is TargetVersion.PY27
182 PY36_VERSIONS = {TargetVersion.PY36, TargetVersion.PY37, TargetVersion.PY38}
186 # All string literals are unicode
189 NUMERIC_UNDERSCORES = 3
190 TRAILING_COMMA_IN_CALL = 4
191 TRAILING_COMMA_IN_DEF = 5
192 # The following two feature-flags are mutually exclusive, and exactly one should be
193 # set for every version of python.
194 ASYNC_IDENTIFIERS = 6
196 ASSIGNMENT_EXPRESSIONS = 8
197 POS_ONLY_ARGUMENTS = 9
198 FORCE_OPTIONAL_PARENTHESES = 50
201 VERSION_TO_FEATURES: Dict[TargetVersion, Set[Feature]] = {
202 TargetVersion.PY27: {Feature.ASYNC_IDENTIFIERS},
203 TargetVersion.PY33: {Feature.UNICODE_LITERALS, Feature.ASYNC_IDENTIFIERS},
204 TargetVersion.PY34: {Feature.UNICODE_LITERALS, Feature.ASYNC_IDENTIFIERS},
205 TargetVersion.PY35: {
206 Feature.UNICODE_LITERALS,
207 Feature.TRAILING_COMMA_IN_CALL,
208 Feature.ASYNC_IDENTIFIERS,
210 TargetVersion.PY36: {
211 Feature.UNICODE_LITERALS,
213 Feature.NUMERIC_UNDERSCORES,
214 Feature.TRAILING_COMMA_IN_CALL,
215 Feature.TRAILING_COMMA_IN_DEF,
216 Feature.ASYNC_IDENTIFIERS,
218 TargetVersion.PY37: {
219 Feature.UNICODE_LITERALS,
221 Feature.NUMERIC_UNDERSCORES,
222 Feature.TRAILING_COMMA_IN_CALL,
223 Feature.TRAILING_COMMA_IN_DEF,
224 Feature.ASYNC_KEYWORDS,
226 TargetVersion.PY38: {
227 Feature.UNICODE_LITERALS,
229 Feature.NUMERIC_UNDERSCORES,
230 Feature.TRAILING_COMMA_IN_CALL,
231 Feature.TRAILING_COMMA_IN_DEF,
232 Feature.ASYNC_KEYWORDS,
233 Feature.ASSIGNMENT_EXPRESSIONS,
234 Feature.POS_ONLY_ARGUMENTS,
241 target_versions: Set[TargetVersion] = field(default_factory=set)
242 line_length: int = DEFAULT_LINE_LENGTH
243 string_normalization: bool = True
244 experimental_string_processing: bool = False
247 def get_cache_key(self) -> str:
248 if self.target_versions:
249 version_str = ",".join(
251 for version in sorted(self.target_versions, key=lambda v: v.value)
257 str(self.line_length),
258 str(int(self.string_normalization)),
259 str(int(self.is_pyi)),
261 return ".".join(parts)
264 # Legacy name, left for integrations.
268 def supports_feature(target_versions: Set[TargetVersion], feature: Feature) -> bool:
269 return all(feature in VERSION_TO_FEATURES[version] for version in target_versions)
272 def find_pyproject_toml(path_search_start: Iterable[str]) -> Optional[str]:
273 """Find the absolute filepath to a pyproject.toml if it exists"""
274 path_project_root = find_project_root(path_search_start)
275 path_pyproject_toml = path_project_root / "pyproject.toml"
276 return str(path_pyproject_toml) if path_pyproject_toml.is_file() else None
279 def parse_pyproject_toml(path_config: str) -> Dict[str, Any]:
280 """Parse a pyproject toml file, pulling out relevant parts for Black
282 If parsing fails, will raise a toml.TomlDecodeError
284 pyproject_toml = toml.load(path_config)
285 config = pyproject_toml.get("tool", {}).get("black", {})
286 return {k.replace("--", "").replace("-", "_"): v for k, v in config.items()}
289 def read_pyproject_toml(
290 ctx: click.Context, param: click.Parameter, value: Optional[str]
292 """Inject Black configuration from "pyproject.toml" into defaults in `ctx`.
294 Returns the path to a successfully found and read configuration file, None
298 value = find_pyproject_toml(ctx.params.get("src", ()))
303 config = parse_pyproject_toml(value)
304 except (toml.TomlDecodeError, OSError) as e:
305 raise click.FileError(
306 filename=value, hint=f"Error reading configuration file: {e}"
312 # Sanitize the values to be Click friendly. For more information please see:
313 # https://github.com/psf/black/issues/1458
314 # https://github.com/pallets/click/issues/1567
316 k: str(v) if not isinstance(v, (list, dict)) else v
317 for k, v in config.items()
320 target_version = config.get("target_version")
321 if target_version is not None and not isinstance(target_version, list):
322 raise click.BadOptionUsage(
323 "target-version", "Config key target-version must be a list"
326 default_map: Dict[str, Any] = {}
328 default_map.update(ctx.default_map)
329 default_map.update(config)
331 ctx.default_map = default_map
335 def target_version_option_callback(
336 c: click.Context, p: Union[click.Option, click.Parameter], v: Tuple[str, ...]
337 ) -> List[TargetVersion]:
338 """Compute the target versions from a --target-version flag.
340 This is its own function because mypy couldn't infer the type correctly
341 when it was a lambda, causing mypyc trouble.
343 return [TargetVersion[val.upper()] for val in v]
346 @click.command(context_settings=dict(help_option_names=["-h", "--help"]))
347 @click.option("-c", "--code", type=str, help="Format the code passed in as a string.")
352 default=DEFAULT_LINE_LENGTH,
353 help="How many characters per line to allow.",
359 type=click.Choice([v.name.lower() for v in TargetVersion]),
360 callback=target_version_option_callback,
363 "Python versions that should be supported by Black's output. [default: per-file"
371 "Format all input files like typing stubs regardless of file extension (useful"
372 " when piping source on standard input)."
377 "--skip-string-normalization",
379 help="Don't normalize string quotes or prefixes.",
382 "--experimental-string-processing",
386 "Experimental option that performs more normalization on string literals."
387 " Currently disabled because it leads to some crashes."
394 "Don't write the files back, just return the status. Return code 0 means"
395 " nothing would change. Return code 1 means some files would be reformatted."
396 " Return code 123 means there was an internal error."
402 help="Don't write the files back, just output a diff for each file on stdout.",
405 "--color/--no-color",
407 help="Show colored diff. Only applies when `--diff` is given.",
412 help="If --fast given, skip temporary sanity checks. [default: --safe]",
417 default=DEFAULT_INCLUDES,
419 "A regular expression that matches files and directories that should be"
420 " included on recursive searches. An empty value means all files are included"
421 " regardless of the name. Use forward slashes for directories on all platforms"
422 " (Windows, too). Exclusions are calculated first, inclusions later."
429 default=DEFAULT_EXCLUDES,
431 "A regular expression that matches files and directories that should be"
432 " excluded on recursive searches. An empty value means no paths are excluded."
433 " Use forward slashes for directories on all platforms (Windows, too). "
434 " Exclusions are calculated first, inclusions later."
442 "Like --exclude, but files and directories matching this regex will be "
443 "excluded even when they are passed explicitly as arguments"
451 "Don't emit non-error messages to stderr. Errors are still emitted; silence"
452 " those with 2>/dev/null."
460 "Also emit messages to stderr about files that were not changed or were ignored"
461 " due to --exclude=."
464 @click.version_option(version=__version__)
469 exists=True, file_okay=True, dir_okay=True, readable=True, allow_dash=True
484 callback=read_pyproject_toml,
485 help="Read configuration from FILE path.",
492 target_version: List[TargetVersion],
498 skip_string_normalization: bool,
499 experimental_string_processing: bool,
504 force_exclude: Optional[str],
505 src: Tuple[str, ...],
506 config: Optional[str],
508 """The uncompromising code formatter."""
509 write_back = WriteBack.from_configuration(check=check, diff=diff, color=color)
511 versions = set(target_version)
513 # We'll autodetect later.
516 target_versions=versions,
517 line_length=line_length,
519 string_normalization=not skip_string_normalization,
520 experimental_string_processing=experimental_string_processing,
522 if config and verbose:
523 out(f"Using configuration from {config}.", bold=False, fg="blue")
525 print(format_str(code, mode=mode))
527 report = Report(check=check, diff=diff, quiet=quiet, verbose=verbose)
528 sources = get_sources(
535 force_exclude=force_exclude,
541 "No Python files are present to be formatted. Nothing to do 😴",
547 if len(sources) == 1:
551 write_back=write_back,
557 sources=sources, fast=fast, write_back=write_back, mode=mode, report=report
560 if verbose or not quiet:
561 out("Oh no! 💥 💔 💥" if report.return_code else "All done! ✨ 🍰 ✨")
562 click.secho(str(report), err=True)
563 ctx.exit(report.return_code)
569 src: Tuple[str, ...],
574 force_exclude: Optional[str],
577 """Compute the set of files to be formatted."""
579 include_regex = re_compile_maybe_verbose(include)
581 err(f"Invalid regular expression for include given: {include!r}")
584 exclude_regex = re_compile_maybe_verbose(exclude)
586 err(f"Invalid regular expression for exclude given: {exclude!r}")
589 force_exclude_regex = (
590 re_compile_maybe_verbose(force_exclude) if force_exclude else None
593 err(f"Invalid regular expression for force_exclude given: {force_exclude!r}")
596 root = find_project_root(src)
597 sources: Set[Path] = set()
598 path_empty(src, "No Path provided. Nothing to do 😴", quiet, verbose, ctx)
599 gitignore = get_gitignore(root)
618 normalized_path = normalize_path_maybe_ignore(p, root, report)
619 if normalized_path is None:
622 normalized_path = "/" + normalized_path
623 # Hard-exclude any files that matches the `--force-exclude` regex.
624 if force_exclude_regex:
625 force_exclude_match = force_exclude_regex.search(normalized_path)
627 force_exclude_match = None
628 if force_exclude_match and force_exclude_match.group(0):
629 report.path_ignored(p, "matches the --force-exclude regular expression")
634 err(f"invalid path: {s}")
639 src: Sized, msg: str, quiet: bool, verbose: bool, ctx: click.Context
642 Exit if there is no `src` provided for formatting
644 if not src and (verbose or not quiet):
650 src: Path, fast: bool, write_back: WriteBack, mode: Mode, report: "Report"
652 """Reformat a single file under `src` without spawning child processes.
654 `fast`, `write_back`, and `mode` options are passed to
655 :func:`format_file_in_place` or :func:`format_stdin_to_stdout`.
659 if not src.is_file() and str(src) == "-":
660 if format_stdin_to_stdout(fast=fast, write_back=write_back, mode=mode):
661 changed = Changed.YES
664 if write_back != WriteBack.DIFF:
665 cache = read_cache(mode)
666 res_src = src.resolve()
667 if res_src in cache and cache[res_src] == get_cache_info(res_src):
668 changed = Changed.CACHED
669 if changed is not Changed.CACHED and format_file_in_place(
670 src, fast=fast, write_back=write_back, mode=mode
672 changed = Changed.YES
673 if (write_back is WriteBack.YES and changed is not Changed.CACHED) or (
674 write_back is WriteBack.CHECK and changed is Changed.NO
676 write_cache(cache, [src], mode)
677 report.done(src, changed)
678 except Exception as exc:
680 traceback.print_exc()
681 report.failed(src, str(exc))
685 sources: Set[Path], fast: bool, write_back: WriteBack, mode: Mode, report: "Report"
687 """Reformat multiple files using a ProcessPoolExecutor."""
689 loop = asyncio.get_event_loop()
690 worker_count = os.cpu_count()
691 if sys.platform == "win32":
692 # Work around https://bugs.python.org/issue26903
693 worker_count = min(worker_count, 61)
695 executor = ProcessPoolExecutor(max_workers=worker_count)
696 except (ImportError, OSError):
697 # we arrive here if the underlying system does not support multi-processing
698 # like in AWS Lambda or Termux, in which case we gracefully fallback to
699 # a ThreadPollExecutor with just a single worker (more workers would not do us
700 # any good due to the Global Interpreter Lock)
701 executor = ThreadPoolExecutor(max_workers=1)
704 loop.run_until_complete(
708 write_back=write_back,
717 if executor is not None:
721 async def schedule_formatting(
724 write_back: WriteBack,
727 loop: asyncio.AbstractEventLoop,
730 """Run formatting of `sources` in parallel using the provided `executor`.
732 (Use ProcessPoolExecutors for actual parallelism.)
734 `write_back`, `fast`, and `mode` options are passed to
735 :func:`format_file_in_place`.
738 if write_back != WriteBack.DIFF:
739 cache = read_cache(mode)
740 sources, cached = filter_cached(cache, sources)
741 for src in sorted(cached):
742 report.done(src, Changed.CACHED)
747 sources_to_cache = []
749 if write_back == WriteBack.DIFF:
750 # For diff output, we need locks to ensure we don't interleave output
751 # from different processes.
753 lock = manager.Lock()
755 asyncio.ensure_future(
756 loop.run_in_executor(
757 executor, format_file_in_place, src, fast, mode, write_back, lock
760 for src in sorted(sources)
762 pending: Iterable["asyncio.Future[bool]"] = tasks.keys()
764 loop.add_signal_handler(signal.SIGINT, cancel, pending)
765 loop.add_signal_handler(signal.SIGTERM, cancel, pending)
766 except NotImplementedError:
767 # There are no good alternatives for these on Windows.
770 done, _ = await asyncio.wait(pending, return_when=asyncio.FIRST_COMPLETED)
772 src = tasks.pop(task)
774 cancelled.append(task)
775 elif task.exception():
776 report.failed(src, str(task.exception()))
778 changed = Changed.YES if task.result() else Changed.NO
779 # If the file was written back or was successfully checked as
780 # well-formatted, store this information in the cache.
781 if write_back is WriteBack.YES or (
782 write_back is WriteBack.CHECK and changed is Changed.NO
784 sources_to_cache.append(src)
785 report.done(src, changed)
787 await asyncio.gather(*cancelled, loop=loop, return_exceptions=True)
789 write_cache(cache, sources_to_cache, mode)
792 def format_file_in_place(
796 write_back: WriteBack = WriteBack.NO,
797 lock: Any = None, # multiprocessing.Manager().Lock() is some crazy proxy
799 """Format file under `src` path. Return True if changed.
801 If `write_back` is DIFF, write a diff to stdout. If it is YES, write reformatted
803 `mode` and `fast` options are passed to :func:`format_file_contents`.
805 if src.suffix == ".pyi":
806 mode = replace(mode, is_pyi=True)
808 then = datetime.utcfromtimestamp(src.stat().st_mtime)
809 with open(src, "rb") as buf:
810 src_contents, encoding, newline = decode_bytes(buf.read())
812 dst_contents = format_file_contents(src_contents, fast=fast, mode=mode)
813 except NothingChanged:
816 if write_back == WriteBack.YES:
817 with open(src, "w", encoding=encoding, newline=newline) as f:
818 f.write(dst_contents)
819 elif write_back in (WriteBack.DIFF, WriteBack.COLOR_DIFF):
820 now = datetime.utcnow()
821 src_name = f"{src}\t{then} +0000"
822 dst_name = f"{src}\t{now} +0000"
823 diff_contents = diff(src_contents, dst_contents, src_name, dst_name)
825 if write_back == write_back.COLOR_DIFF:
826 diff_contents = color_diff(diff_contents)
828 with lock or nullcontext():
829 f = io.TextIOWrapper(
835 f = wrap_stream_for_windows(f)
836 f.write(diff_contents)
842 def color_diff(contents: str) -> str:
843 """Inject the ANSI color codes to the diff."""
844 lines = contents.split("\n")
845 for i, line in enumerate(lines):
846 if line.startswith("+++") or line.startswith("---"):
847 line = "\033[1;37m" + line + "\033[0m" # bold white, reset
848 if line.startswith("@@"):
849 line = "\033[36m" + line + "\033[0m" # cyan, reset
850 if line.startswith("+"):
851 line = "\033[32m" + line + "\033[0m" # green, reset
852 elif line.startswith("-"):
853 line = "\033[31m" + line + "\033[0m" # red, reset
855 return "\n".join(lines)
858 def wrap_stream_for_windows(
860 ) -> Union[io.TextIOWrapper, "colorama.AnsiToWin32.AnsiToWin32"]:
862 Wrap the stream in colorama's wrap_stream so colors are shown on Windows.
864 If `colorama` is not found, then no change is made. If `colorama` does
865 exist, then it handles the logic to determine whether or not to change
869 from colorama import initialise
871 # We set `strip=False` so that we can don't have to modify
872 # test_express_diff_with_color.
873 f = initialise.wrap_stream(
874 f, convert=None, strip=False, autoreset=False, wrap=True
877 # wrap_stream returns a `colorama.AnsiToWin32.AnsiToWin32` object
878 # which does not have a `detach()` method. So we fake one.
879 f.detach = lambda *args, **kwargs: None # type: ignore
886 def format_stdin_to_stdout(
887 fast: bool, *, write_back: WriteBack = WriteBack.NO, mode: Mode
889 """Format file on stdin. Return True if changed.
891 If `write_back` is YES, write reformatted code back to stdout. If it is DIFF,
892 write a diff to stdout. The `mode` argument is passed to
893 :func:`format_file_contents`.
895 then = datetime.utcnow()
896 src, encoding, newline = decode_bytes(sys.stdin.buffer.read())
899 dst = format_file_contents(src, fast=fast, mode=mode)
902 except NothingChanged:
906 f = io.TextIOWrapper(
907 sys.stdout.buffer, encoding=encoding, newline=newline, write_through=True
909 if write_back == WriteBack.YES:
911 elif write_back in (WriteBack.DIFF, WriteBack.COLOR_DIFF):
912 now = datetime.utcnow()
913 src_name = f"STDIN\t{then} +0000"
914 dst_name = f"STDOUT\t{now} +0000"
915 d = diff(src, dst, src_name, dst_name)
916 if write_back == WriteBack.COLOR_DIFF:
918 f = wrap_stream_for_windows(f)
923 def format_file_contents(src_contents: str, *, fast: bool, mode: Mode) -> FileContent:
924 """Reformat contents a file and return new contents.
926 If `fast` is False, additionally confirm that the reformatted code is
927 valid by calling :func:`assert_equivalent` and :func:`assert_stable` on it.
928 `mode` is passed to :func:`format_str`.
930 if not src_contents.strip():
933 dst_contents = format_str(src_contents, mode=mode)
934 if src_contents == dst_contents:
938 assert_equivalent(src_contents, dst_contents)
939 assert_stable(src_contents, dst_contents, mode=mode)
943 def format_str(src_contents: str, *, mode: Mode) -> FileContent:
944 """Reformat a string and return new contents.
946 `mode` determines formatting options, such as how many characters per line are
950 >>> print(black.format_str("def f(arg:str='')->None:...", mode=Mode()))
951 def f(arg: str = "") -> None:
954 A more complex example:
957 ... black.format_str(
958 ... "def f(arg:str='')->None: hey",
960 ... target_versions={black.TargetVersion.PY36},
962 ... string_normalization=False,
973 src_node = lib2to3_parse(src_contents.lstrip(), mode.target_versions)
975 future_imports = get_future_imports(src_node)
976 if mode.target_versions:
977 versions = mode.target_versions
979 versions = detect_target_versions(src_node)
980 normalize_fmt_off(src_node)
981 lines = LineGenerator(
982 remove_u_prefix="unicode_literals" in future_imports
983 or supports_feature(versions, Feature.UNICODE_LITERALS),
985 normalize_strings=mode.string_normalization,
987 elt = EmptyLineTracker(is_pyi=mode.is_pyi)
990 split_line_features = {
992 for feature in {Feature.TRAILING_COMMA_IN_CALL, Feature.TRAILING_COMMA_IN_DEF}
993 if supports_feature(versions, feature)
995 for current_line in lines.visit(src_node):
996 dst_contents.append(str(empty_line) * after)
997 before, after = elt.maybe_empty_lines(current_line)
998 dst_contents.append(str(empty_line) * before)
999 for line in transform_line(
1000 current_line, mode=mode, features=split_line_features
1002 dst_contents.append(str(line))
1003 return "".join(dst_contents)
1006 def decode_bytes(src: bytes) -> Tuple[FileContent, Encoding, NewLine]:
1007 """Return a tuple of (decoded_contents, encoding, newline).
1009 `newline` is either CRLF or LF but `decoded_contents` is decoded with
1010 universal newlines (i.e. only contains LF).
1012 srcbuf = io.BytesIO(src)
1013 encoding, lines = tokenize.detect_encoding(srcbuf.readline)
1015 return "", encoding, "\n"
1017 newline = "\r\n" if b"\r\n" == lines[0][-2:] else "\n"
1019 with io.TextIOWrapper(srcbuf, encoding) as tiow:
1020 return tiow.read(), encoding, newline
1023 def get_grammars(target_versions: Set[TargetVersion]) -> List[Grammar]:
1024 if not target_versions:
1025 # No target_version specified, so try all grammars.
1028 pygram.python_grammar_no_print_statement_no_exec_statement_async_keywords,
1030 pygram.python_grammar_no_print_statement_no_exec_statement,
1031 # Python 2.7 with future print_function import
1032 pygram.python_grammar_no_print_statement,
1034 pygram.python_grammar,
1037 if all(version.is_python2() for version in target_versions):
1038 # Python 2-only code, so try Python 2 grammars.
1040 # Python 2.7 with future print_function import
1041 pygram.python_grammar_no_print_statement,
1043 pygram.python_grammar,
1046 # Python 3-compatible code, so only try Python 3 grammar.
1048 # If we have to parse both, try to parse async as a keyword first
1049 if not supports_feature(target_versions, Feature.ASYNC_IDENTIFIERS):
1052 pygram.python_grammar_no_print_statement_no_exec_statement_async_keywords
1054 if not supports_feature(target_versions, Feature.ASYNC_KEYWORDS):
1056 grammars.append(pygram.python_grammar_no_print_statement_no_exec_statement)
1057 # At least one of the above branches must have been taken, because every Python
1058 # version has exactly one of the two 'ASYNC_*' flags
1062 def lib2to3_parse(src_txt: str, target_versions: Iterable[TargetVersion] = ()) -> Node:
1063 """Given a string with source, return the lib2to3 Node."""
1064 if not src_txt.endswith("\n"):
1067 for grammar in get_grammars(set(target_versions)):
1068 drv = driver.Driver(grammar, pytree.convert)
1070 result = drv.parse_string(src_txt, True)
1073 except ParseError as pe:
1074 lineno, column = pe.context[1]
1075 lines = src_txt.splitlines()
1077 faulty_line = lines[lineno - 1]
1079 faulty_line = "<line number missing in source>"
1080 exc = InvalidInput(f"Cannot parse: {lineno}:{column}: {faulty_line}")
1084 if isinstance(result, Leaf):
1085 result = Node(syms.file_input, [result])
1089 def lib2to3_unparse(node: Node) -> str:
1090 """Given a lib2to3 node, return its string representation."""
1095 class Visitor(Generic[T]):
1096 """Basic lib2to3 visitor that yields things of type `T` on `visit()`."""
1098 def visit(self, node: LN) -> Iterator[T]:
1099 """Main method to visit `node` and its children.
1101 It tries to find a `visit_*()` method for the given `node.type`, like
1102 `visit_simple_stmt` for Node objects or `visit_INDENT` for Leaf objects.
1103 If no dedicated `visit_*()` method is found, chooses `visit_default()`
1106 Then yields objects of type `T` from the selected visitor.
1109 name = token.tok_name[node.type]
1111 name = str(type_repr(node.type))
1112 # We explicitly branch on whether a visitor exists (instead of
1113 # using self.visit_default as the default arg to getattr) in order
1114 # to save needing to create a bound method object and so mypyc can
1115 # generate a native call to visit_default.
1116 visitf = getattr(self, f"visit_{name}", None)
1118 yield from visitf(node)
1120 yield from self.visit_default(node)
1122 def visit_default(self, node: LN) -> Iterator[T]:
1123 """Default `visit_*()` implementation. Recurses to children of `node`."""
1124 if isinstance(node, Node):
1125 for child in node.children:
1126 yield from self.visit(child)
1130 class DebugVisitor(Visitor[T]):
1133 def visit_default(self, node: LN) -> Iterator[T]:
1134 indent = " " * (2 * self.tree_depth)
1135 if isinstance(node, Node):
1136 _type = type_repr(node.type)
1137 out(f"{indent}{_type}", fg="yellow")
1138 self.tree_depth += 1
1139 for child in node.children:
1140 yield from self.visit(child)
1142 self.tree_depth -= 1
1143 out(f"{indent}/{_type}", fg="yellow", bold=False)
1145 _type = token.tok_name.get(node.type, str(node.type))
1146 out(f"{indent}{_type}", fg="blue", nl=False)
1148 # We don't have to handle prefixes for `Node` objects since
1149 # that delegates to the first child anyway.
1150 out(f" {node.prefix!r}", fg="green", bold=False, nl=False)
1151 out(f" {node.value!r}", fg="blue", bold=False)
1154 def show(cls, code: Union[str, Leaf, Node]) -> None:
1155 """Pretty-print the lib2to3 AST of a given string of `code`.
1157 Convenience method for debugging.
1159 v: DebugVisitor[None] = DebugVisitor()
1160 if isinstance(code, str):
1161 code = lib2to3_parse(code)
1165 WHITESPACE: Final = {token.DEDENT, token.INDENT, token.NEWLINE}
1166 STATEMENT: Final = {
1176 STANDALONE_COMMENT: Final = 153
1177 token.tok_name[STANDALONE_COMMENT] = "STANDALONE_COMMENT"
1178 LOGIC_OPERATORS: Final = {"and", "or"}
1179 COMPARATORS: Final = {
1187 MATH_OPERATORS: Final = {
1203 STARS: Final = {token.STAR, token.DOUBLESTAR}
1204 VARARGS_SPECIALS: Final = STARS | {token.SLASH}
1205 VARARGS_PARENTS: Final = {
1207 syms.argument, # double star in arglist
1208 syms.trailer, # single argument to call
1210 syms.varargslist, # lambdas
1212 UNPACKING_PARENTS: Final = {
1213 syms.atom, # single element of a list or set literal
1217 syms.testlist_star_expr,
1219 TEST_DESCENDANTS: Final = {
1236 ASSIGNMENTS: Final = {
1252 COMPREHENSION_PRIORITY: Final = 20
1253 COMMA_PRIORITY: Final = 18
1254 TERNARY_PRIORITY: Final = 16
1255 LOGIC_PRIORITY: Final = 14
1256 STRING_PRIORITY: Final = 12
1257 COMPARATOR_PRIORITY: Final = 10
1258 MATH_PRIORITIES: Final = {
1260 token.CIRCUMFLEX: 8,
1263 token.RIGHTSHIFT: 6,
1268 token.DOUBLESLASH: 4,
1272 token.DOUBLESTAR: 2,
1274 DOT_PRIORITY: Final = 1
1278 class BracketTracker:
1279 """Keeps track of brackets on a line."""
1282 bracket_match: Dict[Tuple[Depth, NodeType], Leaf] = field(default_factory=dict)
1283 delimiters: Dict[LeafID, Priority] = field(default_factory=dict)
1284 previous: Optional[Leaf] = None
1285 _for_loop_depths: List[int] = field(default_factory=list)
1286 _lambda_argument_depths: List[int] = field(default_factory=list)
1287 invisible: List[Leaf] = field(default_factory=list)
1289 def mark(self, leaf: Leaf) -> None:
1290 """Mark `leaf` with bracket-related metadata. Keep track of delimiters.
1292 All leaves receive an int `bracket_depth` field that stores how deep
1293 within brackets a given leaf is. 0 means there are no enclosing brackets
1294 that started on this line.
1296 If a leaf is itself a closing bracket, it receives an `opening_bracket`
1297 field that it forms a pair with. This is a one-directional link to
1298 avoid reference cycles.
1300 If a leaf is a delimiter (a token on which Black can split the line if
1301 needed) and it's on depth 0, its `id()` is stored in the tracker's
1304 if leaf.type == token.COMMENT:
1307 self.maybe_decrement_after_for_loop_variable(leaf)
1308 self.maybe_decrement_after_lambda_arguments(leaf)
1309 if leaf.type in CLOSING_BRACKETS:
1311 opening_bracket = self.bracket_match.pop((self.depth, leaf.type))
1312 leaf.opening_bracket = opening_bracket
1314 self.invisible.append(leaf)
1315 leaf.bracket_depth = self.depth
1317 delim = is_split_before_delimiter(leaf, self.previous)
1318 if delim and self.previous is not None:
1319 self.delimiters[id(self.previous)] = delim
1321 delim = is_split_after_delimiter(leaf, self.previous)
1323 self.delimiters[id(leaf)] = delim
1324 if leaf.type in OPENING_BRACKETS:
1325 self.bracket_match[self.depth, BRACKET[leaf.type]] = leaf
1328 self.invisible.append(leaf)
1329 self.previous = leaf
1330 self.maybe_increment_lambda_arguments(leaf)
1331 self.maybe_increment_for_loop_variable(leaf)
1333 def any_open_brackets(self) -> bool:
1334 """Return True if there is an yet unmatched open bracket on the line."""
1335 return bool(self.bracket_match)
1337 def max_delimiter_priority(self, exclude: Iterable[LeafID] = ()) -> Priority:
1338 """Return the highest priority of a delimiter found on the line.
1340 Values are consistent with what `is_split_*_delimiter()` return.
1341 Raises ValueError on no delimiters.
1343 return max(v for k, v in self.delimiters.items() if k not in exclude)
1345 def delimiter_count_with_priority(self, priority: Priority = 0) -> int:
1346 """Return the number of delimiters with the given `priority`.
1348 If no `priority` is passed, defaults to max priority on the line.
1350 if not self.delimiters:
1353 priority = priority or self.max_delimiter_priority()
1354 return sum(1 for p in self.delimiters.values() if p == priority)
1356 def maybe_increment_for_loop_variable(self, leaf: Leaf) -> bool:
1357 """In a for loop, or comprehension, the variables are often unpacks.
1359 To avoid splitting on the comma in this situation, increase the depth of
1360 tokens between `for` and `in`.
1362 if leaf.type == token.NAME and leaf.value == "for":
1364 self._for_loop_depths.append(self.depth)
1369 def maybe_decrement_after_for_loop_variable(self, leaf: Leaf) -> bool:
1370 """See `maybe_increment_for_loop_variable` above for explanation."""
1372 self._for_loop_depths
1373 and self._for_loop_depths[-1] == self.depth
1374 and leaf.type == token.NAME
1375 and leaf.value == "in"
1378 self._for_loop_depths.pop()
1383 def maybe_increment_lambda_arguments(self, leaf: Leaf) -> bool:
1384 """In a lambda expression, there might be more than one argument.
1386 To avoid splitting on the comma in this situation, increase the depth of
1387 tokens between `lambda` and `:`.
1389 if leaf.type == token.NAME and leaf.value == "lambda":
1391 self._lambda_argument_depths.append(self.depth)
1396 def maybe_decrement_after_lambda_arguments(self, leaf: Leaf) -> bool:
1397 """See `maybe_increment_lambda_arguments` above for explanation."""
1399 self._lambda_argument_depths
1400 and self._lambda_argument_depths[-1] == self.depth
1401 and leaf.type == token.COLON
1404 self._lambda_argument_depths.pop()
1409 def get_open_lsqb(self) -> Optional[Leaf]:
1410 """Return the most recent opening square bracket (if any)."""
1411 return self.bracket_match.get((self.depth - 1, token.RSQB))
1416 """Holds leaves and comments. Can be printed with `str(line)`."""
1419 leaves: List[Leaf] = field(default_factory=list)
1420 # keys ordered like `leaves`
1421 comments: Dict[LeafID, List[Leaf]] = field(default_factory=dict)
1422 bracket_tracker: BracketTracker = field(default_factory=BracketTracker)
1423 inside_brackets: bool = False
1424 should_explode: bool = False
1426 def append(self, leaf: Leaf, preformatted: bool = False) -> None:
1427 """Add a new `leaf` to the end of the line.
1429 Unless `preformatted` is True, the `leaf` will receive a new consistent
1430 whitespace prefix and metadata applied by :class:`BracketTracker`.
1431 Trailing commas are maybe removed, unpacked for loop variables are
1432 demoted from being delimiters.
1434 Inline comments are put aside.
1436 has_value = leaf.type in BRACKETS or bool(leaf.value.strip())
1440 if token.COLON == leaf.type and self.is_class_paren_empty:
1441 del self.leaves[-2:]
1442 if self.leaves and not preformatted:
1443 # Note: at this point leaf.prefix should be empty except for
1444 # imports, for which we only preserve newlines.
1445 leaf.prefix += whitespace(
1446 leaf, complex_subscript=self.is_complex_subscript(leaf)
1448 if self.inside_brackets or not preformatted:
1449 self.bracket_tracker.mark(leaf)
1450 if self.maybe_should_explode(leaf):
1451 self.should_explode = True
1452 if not self.append_comment(leaf):
1453 self.leaves.append(leaf)
1455 def append_safe(self, leaf: Leaf, preformatted: bool = False) -> None:
1456 """Like :func:`append()` but disallow invalid standalone comment structure.
1458 Raises ValueError when any `leaf` is appended after a standalone comment
1459 or when a standalone comment is not the first leaf on the line.
1461 if self.bracket_tracker.depth == 0:
1463 raise ValueError("cannot append to standalone comments")
1465 if self.leaves and leaf.type == STANDALONE_COMMENT:
1467 "cannot append standalone comments to a populated line"
1470 self.append(leaf, preformatted=preformatted)
1473 def is_comment(self) -> bool:
1474 """Is this line a standalone comment?"""
1475 return len(self.leaves) == 1 and self.leaves[0].type == STANDALONE_COMMENT
1478 def is_decorator(self) -> bool:
1479 """Is this line a decorator?"""
1480 return bool(self) and self.leaves[0].type == token.AT
1483 def is_import(self) -> bool:
1484 """Is this an import line?"""
1485 return bool(self) and is_import(self.leaves[0])
1488 def is_class(self) -> bool:
1489 """Is this line a class definition?"""
1492 and self.leaves[0].type == token.NAME
1493 and self.leaves[0].value == "class"
1497 def is_stub_class(self) -> bool:
1498 """Is this line a class definition with a body consisting only of "..."?"""
1499 return self.is_class and self.leaves[-3:] == [
1500 Leaf(token.DOT, ".") for _ in range(3)
1504 def is_def(self) -> bool:
1505 """Is this a function definition? (Also returns True for async defs.)"""
1507 first_leaf = self.leaves[0]
1512 second_leaf: Optional[Leaf] = self.leaves[1]
1515 return (first_leaf.type == token.NAME and first_leaf.value == "def") or (
1516 first_leaf.type == token.ASYNC
1517 and second_leaf is not None
1518 and second_leaf.type == token.NAME
1519 and second_leaf.value == "def"
1523 def is_class_paren_empty(self) -> bool:
1524 """Is this a class with no base classes but using parentheses?
1526 Those are unnecessary and should be removed.
1530 and len(self.leaves) == 4
1532 and self.leaves[2].type == token.LPAR
1533 and self.leaves[2].value == "("
1534 and self.leaves[3].type == token.RPAR
1535 and self.leaves[3].value == ")"
1539 def is_triple_quoted_string(self) -> bool:
1540 """Is the line a triple quoted string?"""
1543 and self.leaves[0].type == token.STRING
1544 and self.leaves[0].value.startswith(('"""', "'''"))
1547 def contains_standalone_comments(self, depth_limit: int = sys.maxsize) -> bool:
1548 """If so, needs to be split before emitting."""
1549 for leaf in self.leaves:
1550 if leaf.type == STANDALONE_COMMENT and leaf.bracket_depth <= depth_limit:
1555 def contains_uncollapsable_type_comments(self) -> bool:
1558 last_leaf = self.leaves[-1]
1559 ignored_ids.add(id(last_leaf))
1560 if last_leaf.type == token.COMMA or (
1561 last_leaf.type == token.RPAR and not last_leaf.value
1563 # When trailing commas or optional parens are inserted by Black for
1564 # consistency, comments after the previous last element are not moved
1565 # (they don't have to, rendering will still be correct). So we ignore
1566 # trailing commas and invisible.
1567 last_leaf = self.leaves[-2]
1568 ignored_ids.add(id(last_leaf))
1572 # A type comment is uncollapsable if it is attached to a leaf
1573 # that isn't at the end of the line (since that could cause it
1574 # to get associated to a different argument) or if there are
1575 # comments before it (since that could cause it to get hidden
1577 comment_seen = False
1578 for leaf_id, comments in self.comments.items():
1579 for comment in comments:
1580 if is_type_comment(comment):
1581 if comment_seen or (
1582 not is_type_comment(comment, " ignore")
1583 and leaf_id not in ignored_ids
1591 def contains_unsplittable_type_ignore(self) -> bool:
1595 # If a 'type: ignore' is attached to the end of a line, we
1596 # can't split the line, because we can't know which of the
1597 # subexpressions the ignore was meant to apply to.
1599 # We only want this to apply to actual physical lines from the
1600 # original source, though: we don't want the presence of a
1601 # 'type: ignore' at the end of a multiline expression to
1602 # justify pushing it all onto one line. Thus we
1603 # (unfortunately) need to check the actual source lines and
1604 # only report an unsplittable 'type: ignore' if this line was
1605 # one line in the original code.
1607 # Grab the first and last line numbers, skipping generated leaves
1608 first_line = next((leaf.lineno for leaf in self.leaves if leaf.lineno != 0), 0)
1610 (leaf.lineno for leaf in reversed(self.leaves) if leaf.lineno != 0), 0
1613 if first_line == last_line:
1614 # We look at the last two leaves since a comma or an
1615 # invisible paren could have been added at the end of the
1617 for node in self.leaves[-2:]:
1618 for comment in self.comments.get(id(node), []):
1619 if is_type_comment(comment, " ignore"):
1624 def contains_multiline_strings(self) -> bool:
1625 return any(is_multiline_string(leaf) for leaf in self.leaves)
1627 def maybe_should_explode(self, closing: Leaf) -> bool:
1628 """Return True if this line should explode (always be split), that is when:
1629 - there's a trailing comma here; and
1630 - it's not a one-tuple.
1633 closing.type in CLOSING_BRACKETS
1635 and self.leaves[-1].type == token.COMMA
1639 if closing.type in {token.RBRACE, token.RSQB}:
1645 if not is_one_tuple_between(closing.opening_bracket, closing, self.leaves):
1650 def append_comment(self, comment: Leaf) -> bool:
1651 """Add an inline or standalone comment to the line."""
1653 comment.type == STANDALONE_COMMENT
1654 and self.bracket_tracker.any_open_brackets()
1659 if comment.type != token.COMMENT:
1663 comment.type = STANDALONE_COMMENT
1667 last_leaf = self.leaves[-1]
1669 last_leaf.type == token.RPAR
1670 and not last_leaf.value
1671 and last_leaf.parent
1672 and len(list(last_leaf.parent.leaves())) <= 3
1673 and not is_type_comment(comment)
1675 # Comments on an optional parens wrapping a single leaf should belong to
1676 # the wrapped node except if it's a type comment. Pinning the comment like
1677 # this avoids unstable formatting caused by comment migration.
1678 if len(self.leaves) < 2:
1679 comment.type = STANDALONE_COMMENT
1683 last_leaf = self.leaves[-2]
1684 self.comments.setdefault(id(last_leaf), []).append(comment)
1687 def comments_after(self, leaf: Leaf) -> List[Leaf]:
1688 """Generate comments that should appear directly after `leaf`."""
1689 return self.comments.get(id(leaf), [])
1691 def remove_trailing_comma(self) -> None:
1692 """Remove the trailing comma and moves the comments attached to it."""
1693 trailing_comma = self.leaves.pop()
1694 trailing_comma_comments = self.comments.pop(id(trailing_comma), [])
1695 self.comments.setdefault(id(self.leaves[-1]), []).extend(
1696 trailing_comma_comments
1699 def is_complex_subscript(self, leaf: Leaf) -> bool:
1700 """Return True iff `leaf` is part of a slice with non-trivial exprs."""
1701 open_lsqb = self.bracket_tracker.get_open_lsqb()
1702 if open_lsqb is None:
1705 subscript_start = open_lsqb.next_sibling
1707 if isinstance(subscript_start, Node):
1708 if subscript_start.type == syms.listmaker:
1711 if subscript_start.type == syms.subscriptlist:
1712 subscript_start = child_towards(subscript_start, leaf)
1713 return subscript_start is not None and any(
1714 n.type in TEST_DESCENDANTS for n in subscript_start.pre_order()
1717 def clone(self) -> "Line":
1720 inside_brackets=self.inside_brackets,
1721 should_explode=self.should_explode,
1724 def __str__(self) -> str:
1725 """Render the line."""
1729 indent = " " * self.depth
1730 leaves = iter(self.leaves)
1731 first = next(leaves)
1732 res = f"{first.prefix}{indent}{first.value}"
1735 for comment in itertools.chain.from_iterable(self.comments.values()):
1740 def __bool__(self) -> bool:
1741 """Return True if the line has leaves or comments."""
1742 return bool(self.leaves or self.comments)
1746 class EmptyLineTracker:
1747 """Provides a stateful method that returns the number of potential extra
1748 empty lines needed before and after the currently processed line.
1750 Note: this tracker works on lines that haven't been split yet. It assumes
1751 the prefix of the first leaf consists of optional newlines. Those newlines
1752 are consumed by `maybe_empty_lines()` and included in the computation.
1755 is_pyi: bool = False
1756 previous_line: Optional[Line] = None
1757 previous_after: int = 0
1758 previous_defs: List[int] = field(default_factory=list)
1760 def maybe_empty_lines(self, current_line: Line) -> Tuple[int, int]:
1761 """Return the number of extra empty lines before and after the `current_line`.
1763 This is for separating `def`, `async def` and `class` with extra empty
1764 lines (two on module-level).
1766 before, after = self._maybe_empty_lines(current_line)
1768 # Black should not insert empty lines at the beginning
1771 if self.previous_line is None
1772 else before - self.previous_after
1774 self.previous_after = after
1775 self.previous_line = current_line
1776 return before, after
1778 def _maybe_empty_lines(self, current_line: Line) -> Tuple[int, int]:
1780 if current_line.depth == 0:
1781 max_allowed = 1 if self.is_pyi else 2
1782 if current_line.leaves:
1783 # Consume the first leaf's extra newlines.
1784 first_leaf = current_line.leaves[0]
1785 before = first_leaf.prefix.count("\n")
1786 before = min(before, max_allowed)
1787 first_leaf.prefix = ""
1790 depth = current_line.depth
1791 while self.previous_defs and self.previous_defs[-1] >= depth:
1792 self.previous_defs.pop()
1794 before = 0 if depth else 1
1796 before = 1 if depth else 2
1797 if current_line.is_decorator or current_line.is_def or current_line.is_class:
1798 return self._maybe_empty_lines_for_class_or_def(current_line, before)
1802 and self.previous_line.is_import
1803 and not current_line.is_import
1804 and depth == self.previous_line.depth
1806 return (before or 1), 0
1810 and self.previous_line.is_class
1811 and current_line.is_triple_quoted_string
1817 def _maybe_empty_lines_for_class_or_def(
1818 self, current_line: Line, before: int
1819 ) -> Tuple[int, int]:
1820 if not current_line.is_decorator:
1821 self.previous_defs.append(current_line.depth)
1822 if self.previous_line is None:
1823 # Don't insert empty lines before the first line in the file.
1826 if self.previous_line.is_decorator:
1829 if self.previous_line.depth < current_line.depth and (
1830 self.previous_line.is_class or self.previous_line.is_def
1835 self.previous_line.is_comment
1836 and self.previous_line.depth == current_line.depth
1842 if self.previous_line.depth > current_line.depth:
1844 elif current_line.is_class or self.previous_line.is_class:
1845 if current_line.is_stub_class and self.previous_line.is_stub_class:
1846 # No blank line between classes with an empty body
1850 elif current_line.is_def and not self.previous_line.is_def:
1851 # Blank line between a block of functions and a block of non-functions
1857 if current_line.depth and newlines:
1863 class LineGenerator(Visitor[Line]):
1864 """Generates reformatted Line objects. Empty lines are not emitted.
1866 Note: destroys the tree it's visiting by mutating prefixes of its leaves
1867 in ways that will no longer stringify to valid Python code on the tree.
1870 is_pyi: bool = False
1871 normalize_strings: bool = True
1872 current_line: Line = field(default_factory=Line)
1873 remove_u_prefix: bool = False
1875 def line(self, indent: int = 0) -> Iterator[Line]:
1878 If the line is empty, only emit if it makes sense.
1879 If the line is too long, split it first and then generate.
1881 If any lines were generated, set up a new current_line.
1883 if not self.current_line:
1884 self.current_line.depth += indent
1885 return # Line is empty, don't emit. Creating a new one unnecessary.
1887 complete_line = self.current_line
1888 self.current_line = Line(depth=complete_line.depth + indent)
1891 def visit_default(self, node: LN) -> Iterator[Line]:
1892 """Default `visit_*()` implementation. Recurses to children of `node`."""
1893 if isinstance(node, Leaf):
1894 any_open_brackets = self.current_line.bracket_tracker.any_open_brackets()
1895 for comment in generate_comments(node):
1896 if any_open_brackets:
1897 # any comment within brackets is subject to splitting
1898 self.current_line.append(comment)
1899 elif comment.type == token.COMMENT:
1900 # regular trailing comment
1901 self.current_line.append(comment)
1902 yield from self.line()
1905 # regular standalone comment
1906 yield from self.line()
1908 self.current_line.append(comment)
1909 yield from self.line()
1911 normalize_prefix(node, inside_brackets=any_open_brackets)
1912 if self.normalize_strings and node.type == token.STRING:
1913 normalize_string_prefix(node, remove_u_prefix=self.remove_u_prefix)
1914 normalize_string_quotes(node)
1915 if node.type == token.NUMBER:
1916 normalize_numeric_literal(node)
1917 if node.type not in WHITESPACE:
1918 self.current_line.append(node)
1919 yield from super().visit_default(node)
1921 def visit_INDENT(self, node: Leaf) -> Iterator[Line]:
1922 """Increase indentation level, maybe yield a line."""
1923 # In blib2to3 INDENT never holds comments.
1924 yield from self.line(+1)
1925 yield from self.visit_default(node)
1927 def visit_DEDENT(self, node: Leaf) -> Iterator[Line]:
1928 """Decrease indentation level, maybe yield a line."""
1929 # The current line might still wait for trailing comments. At DEDENT time
1930 # there won't be any (they would be prefixes on the preceding NEWLINE).
1931 # Emit the line then.
1932 yield from self.line()
1934 # While DEDENT has no value, its prefix may contain standalone comments
1935 # that belong to the current indentation level. Get 'em.
1936 yield from self.visit_default(node)
1938 # Finally, emit the dedent.
1939 yield from self.line(-1)
1942 self, node: Node, keywords: Set[str], parens: Set[str]
1943 ) -> Iterator[Line]:
1944 """Visit a statement.
1946 This implementation is shared for `if`, `while`, `for`, `try`, `except`,
1947 `def`, `with`, `class`, `assert` and assignments.
1949 The relevant Python language `keywords` for a given statement will be
1950 NAME leaves within it. This methods puts those on a separate line.
1952 `parens` holds a set of string leaf values immediately after which
1953 invisible parens should be put.
1955 normalize_invisible_parens(node, parens_after=parens)
1956 for child in node.children:
1957 if child.type == token.NAME and child.value in keywords: # type: ignore
1958 yield from self.line()
1960 yield from self.visit(child)
1962 def visit_suite(self, node: Node) -> Iterator[Line]:
1963 """Visit a suite."""
1964 if self.is_pyi and is_stub_suite(node):
1965 yield from self.visit(node.children[2])
1967 yield from self.visit_default(node)
1969 def visit_simple_stmt(self, node: Node) -> Iterator[Line]:
1970 """Visit a statement without nested statements."""
1971 is_suite_like = node.parent and node.parent.type in STATEMENT
1973 if self.is_pyi and is_stub_body(node):
1974 yield from self.visit_default(node)
1976 yield from self.line(+1)
1977 yield from self.visit_default(node)
1978 yield from self.line(-1)
1981 if not self.is_pyi or not node.parent or not is_stub_suite(node.parent):
1982 yield from self.line()
1983 yield from self.visit_default(node)
1985 def visit_async_stmt(self, node: Node) -> Iterator[Line]:
1986 """Visit `async def`, `async for`, `async with`."""
1987 yield from self.line()
1989 children = iter(node.children)
1990 for child in children:
1991 yield from self.visit(child)
1993 if child.type == token.ASYNC:
1996 internal_stmt = next(children)
1997 for child in internal_stmt.children:
1998 yield from self.visit(child)
2000 def visit_decorators(self, node: Node) -> Iterator[Line]:
2001 """Visit decorators."""
2002 for child in node.children:
2003 yield from self.line()
2004 yield from self.visit(child)
2006 def visit_SEMI(self, leaf: Leaf) -> Iterator[Line]:
2007 """Remove a semicolon and put the other statement on a separate line."""
2008 yield from self.line()
2010 def visit_ENDMARKER(self, leaf: Leaf) -> Iterator[Line]:
2011 """End of file. Process outstanding comments and end with a newline."""
2012 yield from self.visit_default(leaf)
2013 yield from self.line()
2015 def visit_STANDALONE_COMMENT(self, leaf: Leaf) -> Iterator[Line]:
2016 if not self.current_line.bracket_tracker.any_open_brackets():
2017 yield from self.line()
2018 yield from self.visit_default(leaf)
2020 def visit_factor(self, node: Node) -> Iterator[Line]:
2021 """Force parentheses between a unary op and a binary power:
2023 -2 ** 8 -> -(2 ** 8)
2025 _operator, operand = node.children
2027 operand.type == syms.power
2028 and len(operand.children) == 3
2029 and operand.children[1].type == token.DOUBLESTAR
2031 lpar = Leaf(token.LPAR, "(")
2032 rpar = Leaf(token.RPAR, ")")
2033 index = operand.remove() or 0
2034 node.insert_child(index, Node(syms.atom, [lpar, operand, rpar]))
2035 yield from self.visit_default(node)
2037 def visit_STRING(self, leaf: Leaf) -> Iterator[Line]:
2038 if is_docstring(leaf) and "\\\n" not in leaf.value:
2039 # We're ignoring docstrings with backslash newline escapes because changing
2040 # indentation of those changes the AST representation of the code.
2041 prefix = get_string_prefix(leaf.value)
2042 lead_len = len(prefix) + 3
2044 indent = " " * 4 * self.current_line.depth
2045 docstring = fix_docstring(leaf.value[lead_len:tail_len], indent)
2047 if leaf.value[lead_len - 1] == docstring[0]:
2048 docstring = " " + docstring
2049 if leaf.value[tail_len + 1] == docstring[-1]:
2050 docstring = docstring + " "
2051 leaf.value = leaf.value[0:lead_len] + docstring + leaf.value[tail_len:]
2052 normalize_string_quotes(leaf)
2054 yield from self.visit_default(leaf)
2056 def __post_init__(self) -> None:
2057 """You are in a twisty little maze of passages."""
2060 self.visit_assert_stmt = partial(v, keywords={"assert"}, parens={"assert", ","})
2061 self.visit_if_stmt = partial(
2062 v, keywords={"if", "else", "elif"}, parens={"if", "elif"}
2064 self.visit_while_stmt = partial(v, keywords={"while", "else"}, parens={"while"})
2065 self.visit_for_stmt = partial(v, keywords={"for", "else"}, parens={"for", "in"})
2066 self.visit_try_stmt = partial(
2067 v, keywords={"try", "except", "else", "finally"}, parens=Ø
2069 self.visit_except_clause = partial(v, keywords={"except"}, parens=Ø)
2070 self.visit_with_stmt = partial(v, keywords={"with"}, parens=Ø)
2071 self.visit_funcdef = partial(v, keywords={"def"}, parens=Ø)
2072 self.visit_classdef = partial(v, keywords={"class"}, parens=Ø)
2073 self.visit_expr_stmt = partial(v, keywords=Ø, parens=ASSIGNMENTS)
2074 self.visit_return_stmt = partial(v, keywords={"return"}, parens={"return"})
2075 self.visit_import_from = partial(v, keywords=Ø, parens={"import"})
2076 self.visit_del_stmt = partial(v, keywords=Ø, parens={"del"})
2077 self.visit_async_funcdef = self.visit_async_stmt
2078 self.visit_decorated = self.visit_decorators
2081 IMPLICIT_TUPLE = {syms.testlist, syms.testlist_star_expr, syms.exprlist}
2082 BRACKET = {token.LPAR: token.RPAR, token.LSQB: token.RSQB, token.LBRACE: token.RBRACE}
2083 OPENING_BRACKETS = set(BRACKET.keys())
2084 CLOSING_BRACKETS = set(BRACKET.values())
2085 BRACKETS = OPENING_BRACKETS | CLOSING_BRACKETS
2086 ALWAYS_NO_SPACE = CLOSING_BRACKETS | {token.COMMA, STANDALONE_COMMENT}
2089 def whitespace(leaf: Leaf, *, complex_subscript: bool) -> str: # noqa: C901
2090 """Return whitespace prefix if needed for the given `leaf`.
2092 `complex_subscript` signals whether the given leaf is part of a subscription
2093 which has non-trivial arguments, like arithmetic expressions or function calls.
2101 if t in ALWAYS_NO_SPACE:
2104 if t == token.COMMENT:
2107 assert p is not None, f"INTERNAL ERROR: hand-made leaf without parent: {leaf!r}"
2108 if t == token.COLON and p.type not in {
2115 prev = leaf.prev_sibling
2117 prevp = preceding_leaf(p)
2118 if not prevp or prevp.type in OPENING_BRACKETS:
2121 if t == token.COLON:
2122 if prevp.type == token.COLON:
2125 elif prevp.type != token.COMMA and not complex_subscript:
2130 if prevp.type == token.EQUAL:
2132 if prevp.parent.type in {
2140 elif prevp.parent.type == syms.typedargslist:
2141 # A bit hacky: if the equal sign has whitespace, it means we
2142 # previously found it's a typed argument. So, we're using
2146 elif prevp.type in VARARGS_SPECIALS:
2147 if is_vararg(prevp, within=VARARGS_PARENTS | UNPACKING_PARENTS):
2150 elif prevp.type == token.COLON:
2151 if prevp.parent and prevp.parent.type in {syms.subscript, syms.sliceop}:
2152 return SPACE if complex_subscript else NO
2156 and prevp.parent.type == syms.factor
2157 and prevp.type in MATH_OPERATORS
2162 prevp.type == token.RIGHTSHIFT
2164 and prevp.parent.type == syms.shift_expr
2165 and prevp.prev_sibling
2166 and prevp.prev_sibling.type == token.NAME
2167 and prevp.prev_sibling.value == "print" # type: ignore
2169 # Python 2 print chevron
2172 elif prev.type in OPENING_BRACKETS:
2175 if p.type in {syms.parameters, syms.arglist}:
2176 # untyped function signatures or calls
2177 if not prev or prev.type != token.COMMA:
2180 elif p.type == syms.varargslist:
2182 if prev and prev.type != token.COMMA:
2185 elif p.type == syms.typedargslist:
2186 # typed function signatures
2190 if t == token.EQUAL:
2191 if prev.type != syms.tname:
2194 elif prev.type == token.EQUAL:
2195 # A bit hacky: if the equal sign has whitespace, it means we
2196 # previously found it's a typed argument. So, we're using that, too.
2199 elif prev.type != token.COMMA:
2202 elif p.type == syms.tname:
2205 prevp = preceding_leaf(p)
2206 if not prevp or prevp.type != token.COMMA:
2209 elif p.type == syms.trailer:
2210 # attributes and calls
2211 if t == token.LPAR or t == token.RPAR:
2216 prevp = preceding_leaf(p)
2217 if not prevp or prevp.type != token.NUMBER:
2220 elif t == token.LSQB:
2223 elif prev.type != token.COMMA:
2226 elif p.type == syms.argument:
2228 if t == token.EQUAL:
2232 prevp = preceding_leaf(p)
2233 if not prevp or prevp.type == token.LPAR:
2236 elif prev.type in {token.EQUAL} | VARARGS_SPECIALS:
2239 elif p.type == syms.decorator:
2243 elif p.type == syms.dotted_name:
2247 prevp = preceding_leaf(p)
2248 if not prevp or prevp.type == token.AT or prevp.type == token.DOT:
2251 elif p.type == syms.classdef:
2255 if prev and prev.type == token.LPAR:
2258 elif p.type in {syms.subscript, syms.sliceop}:
2261 assert p.parent is not None, "subscripts are always parented"
2262 if p.parent.type == syms.subscriptlist:
2267 elif not complex_subscript:
2270 elif p.type == syms.atom:
2271 if prev and t == token.DOT:
2272 # dots, but not the first one.
2275 elif p.type == syms.dictsetmaker:
2277 if prev and prev.type == token.DOUBLESTAR:
2280 elif p.type in {syms.factor, syms.star_expr}:
2283 prevp = preceding_leaf(p)
2284 if not prevp or prevp.type in OPENING_BRACKETS:
2287 prevp_parent = prevp.parent
2288 assert prevp_parent is not None
2289 if prevp.type == token.COLON and prevp_parent.type in {
2295 elif prevp.type == token.EQUAL and prevp_parent.type == syms.argument:
2298 elif t in {token.NAME, token.NUMBER, token.STRING}:
2301 elif p.type == syms.import_from:
2303 if prev and prev.type == token.DOT:
2306 elif t == token.NAME:
2310 if prev and prev.type == token.DOT:
2313 elif p.type == syms.sliceop:
2319 def preceding_leaf(node: Optional[LN]) -> Optional[Leaf]:
2320 """Return the first leaf that precedes `node`, if any."""
2322 res = node.prev_sibling
2324 if isinstance(res, Leaf):
2328 return list(res.leaves())[-1]
2337 def prev_siblings_are(node: Optional[LN], tokens: List[Optional[NodeType]]) -> bool:
2338 """Return if the `node` and its previous siblings match types against the provided
2339 list of tokens; the provided `node`has its type matched against the last element in
2340 the list. `None` can be used as the first element to declare that the start of the
2341 list is anchored at the start of its parent's children."""
2344 if tokens[-1] is None:
2348 if node.type != tokens[-1]:
2350 return prev_siblings_are(node.prev_sibling, tokens[:-1])
2353 def child_towards(ancestor: Node, descendant: LN) -> Optional[LN]:
2354 """Return the child of `ancestor` that contains `descendant`."""
2355 node: Optional[LN] = descendant
2356 while node and node.parent != ancestor:
2361 def container_of(leaf: Leaf) -> LN:
2362 """Return `leaf` or one of its ancestors that is the topmost container of it.
2364 By "container" we mean a node where `leaf` is the very first child.
2366 same_prefix = leaf.prefix
2367 container: LN = leaf
2369 parent = container.parent
2373 if parent.children[0].prefix != same_prefix:
2376 if parent.type == syms.file_input:
2379 if parent.prev_sibling is not None and parent.prev_sibling.type in BRACKETS:
2386 def is_split_after_delimiter(leaf: Leaf, previous: Optional[Leaf] = None) -> Priority:
2387 """Return the priority of the `leaf` delimiter, given a line break after it.
2389 The delimiter priorities returned here are from those delimiters that would
2390 cause a line break after themselves.
2392 Higher numbers are higher priority.
2394 if leaf.type == token.COMMA:
2395 return COMMA_PRIORITY
2400 def is_split_before_delimiter(leaf: Leaf, previous: Optional[Leaf] = None) -> Priority:
2401 """Return the priority of the `leaf` delimiter, given a line break before it.
2403 The delimiter priorities returned here are from those delimiters that would
2404 cause a line break before themselves.
2406 Higher numbers are higher priority.
2408 if is_vararg(leaf, within=VARARGS_PARENTS | UNPACKING_PARENTS):
2409 # * and ** might also be MATH_OPERATORS but in this case they are not.
2410 # Don't treat them as a delimiter.
2414 leaf.type == token.DOT
2416 and leaf.parent.type not in {syms.import_from, syms.dotted_name}
2417 and (previous is None or previous.type in CLOSING_BRACKETS)
2422 leaf.type in MATH_OPERATORS
2424 and leaf.parent.type not in {syms.factor, syms.star_expr}
2426 return MATH_PRIORITIES[leaf.type]
2428 if leaf.type in COMPARATORS:
2429 return COMPARATOR_PRIORITY
2432 leaf.type == token.STRING
2433 and previous is not None
2434 and previous.type == token.STRING
2436 return STRING_PRIORITY
2438 if leaf.type not in {token.NAME, token.ASYNC}:
2444 and leaf.parent.type in {syms.comp_for, syms.old_comp_for}
2445 or leaf.type == token.ASYNC
2448 not isinstance(leaf.prev_sibling, Leaf)
2449 or leaf.prev_sibling.value != "async"
2451 return COMPREHENSION_PRIORITY
2456 and leaf.parent.type in {syms.comp_if, syms.old_comp_if}
2458 return COMPREHENSION_PRIORITY
2460 if leaf.value in {"if", "else"} and leaf.parent and leaf.parent.type == syms.test:
2461 return TERNARY_PRIORITY
2463 if leaf.value == "is":
2464 return COMPARATOR_PRIORITY
2469 and leaf.parent.type in {syms.comp_op, syms.comparison}
2471 previous is not None
2472 and previous.type == token.NAME
2473 and previous.value == "not"
2476 return COMPARATOR_PRIORITY
2481 and leaf.parent.type == syms.comp_op
2483 previous is not None
2484 and previous.type == token.NAME
2485 and previous.value == "is"
2488 return COMPARATOR_PRIORITY
2490 if leaf.value in LOGIC_OPERATORS and leaf.parent:
2491 return LOGIC_PRIORITY
2496 FMT_OFF = {"# fmt: off", "# fmt:off", "# yapf: disable"}
2497 FMT_ON = {"# fmt: on", "# fmt:on", "# yapf: enable"}
2500 def generate_comments(leaf: LN) -> Iterator[Leaf]:
2501 """Clean the prefix of the `leaf` and generate comments from it, if any.
2503 Comments in lib2to3 are shoved into the whitespace prefix. This happens
2504 in `pgen2/driver.py:Driver.parse_tokens()`. This was a brilliant implementation
2505 move because it does away with modifying the grammar to include all the
2506 possible places in which comments can be placed.
2508 The sad consequence for us though is that comments don't "belong" anywhere.
2509 This is why this function generates simple parentless Leaf objects for
2510 comments. We simply don't know what the correct parent should be.
2512 No matter though, we can live without this. We really only need to
2513 differentiate between inline and standalone comments. The latter don't
2514 share the line with any code.
2516 Inline comments are emitted as regular token.COMMENT leaves. Standalone
2517 are emitted with a fake STANDALONE_COMMENT token identifier.
2519 for pc in list_comments(leaf.prefix, is_endmarker=leaf.type == token.ENDMARKER):
2520 yield Leaf(pc.type, pc.value, prefix="\n" * pc.newlines)
2525 """Describes a piece of syntax that is a comment.
2527 It's not a :class:`blib2to3.pytree.Leaf` so that:
2529 * it can be cached (`Leaf` objects should not be reused more than once as
2530 they store their lineno, column, prefix, and parent information);
2531 * `newlines` and `consumed` fields are kept separate from the `value`. This
2532 simplifies handling of special marker comments like ``# fmt: off/on``.
2535 type: int # token.COMMENT or STANDALONE_COMMENT
2536 value: str # content of the comment
2537 newlines: int # how many newlines before the comment
2538 consumed: int # how many characters of the original leaf's prefix did we consume
2541 @lru_cache(maxsize=4096)
2542 def list_comments(prefix: str, *, is_endmarker: bool) -> List[ProtoComment]:
2543 """Return a list of :class:`ProtoComment` objects parsed from the given `prefix`."""
2544 result: List[ProtoComment] = []
2545 if not prefix or "#" not in prefix:
2551 for index, line in enumerate(prefix.split("\n")):
2552 consumed += len(line) + 1 # adding the length of the split '\n'
2553 line = line.lstrip()
2556 if not line.startswith("#"):
2557 # Escaped newlines outside of a comment are not really newlines at
2558 # all. We treat a single-line comment following an escaped newline
2559 # as a simple trailing comment.
2560 if line.endswith("\\"):
2564 if index == ignored_lines and not is_endmarker:
2565 comment_type = token.COMMENT # simple trailing comment
2567 comment_type = STANDALONE_COMMENT
2568 comment = make_comment(line)
2571 type=comment_type, value=comment, newlines=nlines, consumed=consumed
2578 def make_comment(content: str) -> str:
2579 """Return a consistently formatted comment from the given `content` string.
2581 All comments (except for "##", "#!", "#:", '#'", "#%%") should have a single
2582 space between the hash sign and the content.
2584 If `content` didn't start with a hash sign, one is provided.
2586 content = content.rstrip()
2590 if content[0] == "#":
2591 content = content[1:]
2592 if content and content[0] not in " !:#'%":
2593 content = " " + content
2594 return "#" + content
2598 line: Line, mode: Mode, features: Collection[Feature] = ()
2599 ) -> Iterator[Line]:
2600 """Transform a `line`, potentially splitting it into many lines.
2602 They should fit in the allotted `line_length` but might not be able to.
2604 `features` are syntactical features that may be used in the output.
2610 line_str = line_to_string(line)
2612 def init_st(ST: Type[StringTransformer]) -> StringTransformer:
2613 """Initialize StringTransformer"""
2614 return ST(mode.line_length, mode.string_normalization)
2616 string_merge = init_st(StringMerger)
2617 string_paren_strip = init_st(StringParenStripper)
2618 string_split = init_st(StringSplitter)
2619 string_paren_wrap = init_st(StringParenWrapper)
2621 transformers: List[Transformer]
2623 not line.contains_uncollapsable_type_comments()
2624 and not line.should_explode
2626 is_line_short_enough(line, line_length=mode.line_length, line_str=line_str)
2627 or line.contains_unsplittable_type_ignore()
2629 and not (line.inside_brackets and line.contains_standalone_comments())
2631 # Only apply basic string preprocessing, since lines shouldn't be split here.
2632 if mode.experimental_string_processing:
2633 transformers = [string_merge, string_paren_strip]
2637 transformers = [left_hand_split]
2640 def rhs(line: Line, features: Collection[Feature]) -> Iterator[Line]:
2641 """Wraps calls to `right_hand_split`.
2643 The calls increasingly `omit` right-hand trailers (bracket pairs with
2644 content), meaning the trailers get glued together to split on another
2645 bracket pair instead.
2647 for omit in generate_trailers_to_omit(line, mode.line_length):
2649 right_hand_split(line, mode.line_length, features, omit=omit)
2651 # Note: this check is only able to figure out if the first line of the
2652 # *current* transformation fits in the line length. This is true only
2653 # for simple cases. All others require running more transforms via
2654 # `transform_line()`. This check doesn't know if those would succeed.
2655 if is_line_short_enough(lines[0], line_length=mode.line_length):
2659 # All splits failed, best effort split with no omits.
2660 # This mostly happens to multiline strings that are by definition
2661 # reported as not fitting a single line, as well as lines that contain
2662 # trailing commas (those have to be exploded).
2663 yield from right_hand_split(
2664 line, line_length=mode.line_length, features=features
2667 if mode.experimental_string_processing:
2668 if line.inside_brackets:
2673 standalone_comment_split,
2687 if line.inside_brackets:
2688 transformers = [delimiter_split, standalone_comment_split, rhs]
2690 transformers = [rhs]
2692 for transform in transformers:
2693 # We are accumulating lines in `result` because we might want to abort
2694 # mission and return the original line in the end, or attempt a different
2697 result = run_transformer(line, transform, mode, features, line_str=line_str)
2698 except CannotTransform:
2708 @dataclass # type: ignore
2709 class StringTransformer(ABC):
2711 An implementation of the Transformer protocol that relies on its
2712 subclasses overriding the template methods `do_match(...)` and
2713 `do_transform(...)`.
2715 This Transformer works exclusively on strings (for example, by merging
2718 The following sections can be found among the docstrings of each concrete
2719 StringTransformer subclass.
2722 Which requirements must be met of the given Line for this
2723 StringTransformer to be applied?
2726 If the given Line meets all of the above requirements, which string
2727 transformations can you expect to be applied to it by this
2731 What contractual agreements does this StringTransformer have with other
2732 StringTransfomers? Such collaborations should be eliminated/minimized
2733 as much as possible.
2737 normalize_strings: bool
2738 __name__ = "StringTransformer"
2741 def do_match(self, line: Line) -> TMatchResult:
2744 * Ok(string_idx) such that `line.leaves[string_idx]` is our target
2745 string, if a match was able to be made.
2747 * Err(CannotTransform), if a match was not able to be made.
2751 def do_transform(self, line: Line, string_idx: int) -> Iterator[TResult[Line]]:
2754 * Ok(new_line) where new_line is the new transformed line.
2756 * Err(CannotTransform) if the transformation failed for some reason. The
2757 `do_match(...)` template method should usually be used to reject
2758 the form of the given Line, but in some cases it is difficult to
2759 know whether or not a Line meets the StringTransformer's
2760 requirements until the transformation is already midway.
2763 This method should NOT mutate @line directly, but it MAY mutate the
2764 Line's underlying Node structure. (WARNING: If the underlying Node
2765 structure IS altered, then this method should NOT be allowed to
2766 yield an CannotTransform after that point.)
2769 def __call__(self, line: Line, _features: Collection[Feature]) -> Iterator[Line]:
2771 StringTransformer instances have a call signature that mirrors that of
2772 the Transformer type.
2775 CannotTransform(...) if the concrete StringTransformer class is unable
2778 # Optimization to avoid calling `self.do_match(...)` when the line does
2779 # not contain any string.
2780 if not any(leaf.type == token.STRING for leaf in line.leaves):
2781 raise CannotTransform("There are no strings in this line.")
2783 match_result = self.do_match(line)
2785 if isinstance(match_result, Err):
2786 cant_transform = match_result.err()
2787 raise CannotTransform(
2788 f"The string transformer {self.__class__.__name__} does not recognize"
2789 " this line as one that it can transform."
2790 ) from cant_transform
2792 string_idx = match_result.ok()
2794 for line_result in self.do_transform(line, string_idx):
2795 if isinstance(line_result, Err):
2796 cant_transform = line_result.err()
2797 raise CannotTransform(
2798 "StringTransformer failed while attempting to transform string."
2799 ) from cant_transform
2800 line = line_result.ok()
2806 """A custom (i.e. manual) string split.
2808 A single CustomSplit instance represents a single substring.
2811 Consider the following string:
2818 This string will correspond to the following three CustomSplit instances:
2820 CustomSplit(False, 16)
2821 CustomSplit(False, 17)
2822 CustomSplit(True, 16)
2830 class CustomSplitMapMixin:
2832 This mixin class is used to map merged strings to a sequence of
2833 CustomSplits, which will then be used to re-split the strings iff none of
2834 the resultant substrings go over the configured max line length.
2837 _Key = Tuple[StringID, str]
2838 _CUSTOM_SPLIT_MAP: Dict[_Key, Tuple[CustomSplit, ...]] = defaultdict(tuple)
2841 def _get_key(string: str) -> "CustomSplitMapMixin._Key":
2844 A unique identifier that is used internally to map @string to a
2845 group of custom splits.
2847 return (id(string), string)
2849 def add_custom_splits(
2850 self, string: str, custom_splits: Iterable[CustomSplit]
2852 """Custom Split Map Setter Method
2855 Adds a mapping from @string to the custom splits @custom_splits.
2857 key = self._get_key(string)
2858 self._CUSTOM_SPLIT_MAP[key] = tuple(custom_splits)
2860 def pop_custom_splits(self, string: str) -> List[CustomSplit]:
2861 """Custom Split Map Getter Method
2864 * A list of the custom splits that are mapped to @string, if any
2870 Deletes the mapping between @string and its associated custom
2871 splits (which are returned to the caller).
2873 key = self._get_key(string)
2875 custom_splits = self._CUSTOM_SPLIT_MAP[key]
2876 del self._CUSTOM_SPLIT_MAP[key]
2878 return list(custom_splits)
2880 def has_custom_splits(self, string: str) -> bool:
2883 True iff @string is associated with a set of custom splits.
2885 key = self._get_key(string)
2886 return key in self._CUSTOM_SPLIT_MAP
2889 class StringMerger(CustomSplitMapMixin, StringTransformer):
2890 """StringTransformer that merges strings together.
2893 (A) The line contains adjacent strings such that at most one substring
2894 has inline comments AND none of those inline comments are pragmas AND
2895 the set of all substring prefixes is either of length 1 or equal to
2896 {"", "f"} AND none of the substrings are raw strings (i.e. are prefixed
2899 (B) The line contains a string which uses line continuation backslashes.
2902 Depending on which of the two requirements above where met, either:
2904 (A) The string group associated with the target string is merged.
2906 (B) All line-continuation backslashes are removed from the target string.
2909 StringMerger provides custom split information to StringSplitter.
2912 def do_match(self, line: Line) -> TMatchResult:
2915 is_valid_index = is_valid_index_factory(LL)
2917 for (i, leaf) in enumerate(LL):
2919 leaf.type == token.STRING
2920 and is_valid_index(i + 1)
2921 and LL[i + 1].type == token.STRING
2925 if leaf.type == token.STRING and "\\\n" in leaf.value:
2928 return TErr("This line has no strings that need merging.")
2930 def do_transform(self, line: Line, string_idx: int) -> Iterator[TResult[Line]]:
2932 rblc_result = self.__remove_backslash_line_continuation_chars(
2933 new_line, string_idx
2935 if isinstance(rblc_result, Ok):
2936 new_line = rblc_result.ok()
2938 msg_result = self.__merge_string_group(new_line, string_idx)
2939 if isinstance(msg_result, Ok):
2940 new_line = msg_result.ok()
2942 if isinstance(rblc_result, Err) and isinstance(msg_result, Err):
2943 msg_cant_transform = msg_result.err()
2944 rblc_cant_transform = rblc_result.err()
2945 cant_transform = CannotTransform(
2946 "StringMerger failed to merge any strings in this line."
2949 # Chain the errors together using `__cause__`.
2950 msg_cant_transform.__cause__ = rblc_cant_transform
2951 cant_transform.__cause__ = msg_cant_transform
2953 yield Err(cant_transform)
2958 def __remove_backslash_line_continuation_chars(
2959 line: Line, string_idx: int
2962 Merge strings that were split across multiple lines using
2963 line-continuation backslashes.
2966 Ok(new_line), if @line contains backslash line-continuation
2969 Err(CannotTransform), otherwise.
2973 string_leaf = LL[string_idx]
2975 string_leaf.type == token.STRING
2976 and "\\\n" in string_leaf.value
2977 and not has_triple_quotes(string_leaf.value)
2980 f"String leaf {string_leaf} does not contain any backslash line"
2981 " continuation characters."
2984 new_line = line.clone()
2985 new_line.comments = line.comments.copy()
2986 append_leaves(new_line, line, LL)
2988 new_string_leaf = new_line.leaves[string_idx]
2989 new_string_leaf.value = new_string_leaf.value.replace("\\\n", "")
2993 def __merge_string_group(self, line: Line, string_idx: int) -> TResult[Line]:
2995 Merges string group (i.e. set of adjacent strings) where the first
2996 string in the group is `line.leaves[string_idx]`.
2999 Ok(new_line), if ALL of the validation checks found in
3000 __validate_msg(...) pass.
3002 Err(CannotTransform), otherwise.
3006 is_valid_index = is_valid_index_factory(LL)
3008 vresult = self.__validate_msg(line, string_idx)
3009 if isinstance(vresult, Err):
3012 # If the string group is wrapped inside an Atom node, we must make sure
3013 # to later replace that Atom with our new (merged) string leaf.
3014 atom_node = LL[string_idx].parent
3016 # We will place BREAK_MARK in between every two substrings that we
3017 # merge. We will then later go through our final result and use the
3018 # various instances of BREAK_MARK we find to add the right values to
3019 # the custom split map.
3020 BREAK_MARK = "@@@@@ BLACK BREAKPOINT MARKER @@@@@"
3022 QUOTE = LL[string_idx].value[-1]
3024 def make_naked(string: str, string_prefix: str) -> str:
3025 """Strip @string (i.e. make it a "naked" string)
3028 * assert_is_leaf_string(@string)
3031 A string that is identical to @string except that
3032 @string_prefix has been stripped, the surrounding QUOTE
3033 characters have been removed, and any remaining QUOTE
3034 characters have been escaped.
3036 assert_is_leaf_string(string)
3038 RE_EVEN_BACKSLASHES = r"(?:(?<!\\)(?:\\\\)*)"
3039 naked_string = string[len(string_prefix) + 1 : -1]
3040 naked_string = re.sub(
3041 "(" + RE_EVEN_BACKSLASHES + ")" + QUOTE, r"\1\\" + QUOTE, naked_string
3045 # Holds the CustomSplit objects that will later be added to the custom
3049 # Temporary storage for the 'has_prefix' part of the CustomSplit objects.
3052 # Sets the 'prefix' variable. This is the prefix that the final merged
3054 next_str_idx = string_idx
3058 and is_valid_index(next_str_idx)
3059 and LL[next_str_idx].type == token.STRING
3061 prefix = get_string_prefix(LL[next_str_idx].value)
3064 # The next loop merges the string group. The final string will be
3067 # The following convenience variables are used:
3072 # NSS: naked next string
3076 next_str_idx = string_idx
3077 while is_valid_index(next_str_idx) and LL[next_str_idx].type == token.STRING:
3080 SS = LL[next_str_idx].value
3081 next_prefix = get_string_prefix(SS)
3083 # If this is an f-string group but this substring is not prefixed
3085 if "f" in prefix and "f" not in next_prefix:
3086 # Then we must escape any braces contained in this substring.
3087 SS = re.subf(r"(\{|\})", "{1}{1}", SS)
3089 NSS = make_naked(SS, next_prefix)
3091 has_prefix = bool(next_prefix)
3092 prefix_tracker.append(has_prefix)
3094 S = prefix + QUOTE + NS + NSS + BREAK_MARK + QUOTE
3095 NS = make_naked(S, prefix)
3099 S_leaf = Leaf(token.STRING, S)
3100 if self.normalize_strings:
3101 normalize_string_quotes(S_leaf)
3103 # Fill the 'custom_splits' list with the appropriate CustomSplit objects.
3104 temp_string = S_leaf.value[len(prefix) + 1 : -1]
3105 for has_prefix in prefix_tracker:
3106 mark_idx = temp_string.find(BREAK_MARK)
3109 ), "Logic error while filling the custom string breakpoint cache."
3111 temp_string = temp_string[mark_idx + len(BREAK_MARK) :]
3112 breakpoint_idx = mark_idx + (len(prefix) if has_prefix else 0) + 1
3113 custom_splits.append(CustomSplit(has_prefix, breakpoint_idx))
3115 string_leaf = Leaf(token.STRING, S_leaf.value.replace(BREAK_MARK, ""))
3117 if atom_node is not None:
3118 replace_child(atom_node, string_leaf)
3120 # Build the final line ('new_line') that this method will later return.
3121 new_line = line.clone()
3122 for (i, leaf) in enumerate(LL):
3124 new_line.append(string_leaf)
3126 if string_idx <= i < string_idx + num_of_strings:
3127 for comment_leaf in line.comments_after(LL[i]):
3128 new_line.append(comment_leaf, preformatted=True)
3131 append_leaves(new_line, line, [leaf])
3133 self.add_custom_splits(string_leaf.value, custom_splits)
3137 def __validate_msg(line: Line, string_idx: int) -> TResult[None]:
3138 """Validate (M)erge (S)tring (G)roup
3140 Transform-time string validation logic for __merge_string_group(...).
3143 * Ok(None), if ALL validation checks (listed below) pass.
3145 * Err(CannotTransform), if any of the following are true:
3146 - The target string is not in a string group (i.e. it has no
3148 - The string group has more than one inline comment.
3149 - The string group has an inline comment that appears to be a pragma.
3150 - The set of all string prefixes in the string group is of
3151 length greater than one and is not equal to {"", "f"}.
3152 - The string group consists of raw strings.
3154 num_of_inline_string_comments = 0
3155 set_of_prefixes = set()
3157 for leaf in line.leaves[string_idx:]:
3158 if leaf.type != token.STRING:
3159 # If the string group is trailed by a comma, we count the
3160 # comments trailing the comma to be one of the string group's
3162 if leaf.type == token.COMMA and id(leaf) in line.comments:
3163 num_of_inline_string_comments += 1
3166 if has_triple_quotes(leaf.value):
3167 return TErr("StringMerger does NOT merge multiline strings.")
3170 prefix = get_string_prefix(leaf.value)
3172 return TErr("StringMerger does NOT merge raw strings.")
3174 set_of_prefixes.add(prefix)
3176 if id(leaf) in line.comments:
3177 num_of_inline_string_comments += 1
3178 if contains_pragma_comment(line.comments[id(leaf)]):
3179 return TErr("Cannot merge strings which have pragma comments.")
3181 if num_of_strings < 2:
3183 f"Not enough strings to merge (num_of_strings={num_of_strings})."
3186 if num_of_inline_string_comments > 1:
3188 f"Too many inline string comments ({num_of_inline_string_comments})."
3191 if len(set_of_prefixes) > 1 and set_of_prefixes != {"", "f"}:
3192 return TErr(f"Too many different prefixes ({set_of_prefixes}).")
3197 class StringParenStripper(StringTransformer):
3198 """StringTransformer that strips surrounding parentheses from strings.
3201 The line contains a string which is surrounded by parentheses and:
3202 - The target string is NOT the only argument to a function call).
3203 - If the target string contains a PERCENT, the brackets are not
3204 preceeded or followed by an operator with higher precedence than
3208 The parentheses mentioned in the 'Requirements' section are stripped.
3211 StringParenStripper has its own inherent usefulness, but it is also
3212 relied on to clean up the parentheses created by StringParenWrapper (in
3213 the event that they are no longer needed).
3216 def do_match(self, line: Line) -> TMatchResult:
3219 is_valid_index = is_valid_index_factory(LL)
3221 for (idx, leaf) in enumerate(LL):
3222 # Should be a string...
3223 if leaf.type != token.STRING:
3226 # Should be preceded by a non-empty LPAR...
3228 not is_valid_index(idx - 1)
3229 or LL[idx - 1].type != token.LPAR
3230 or is_empty_lpar(LL[idx - 1])
3234 # That LPAR should NOT be preceded by a function name or a closing
3235 # bracket (which could be a function which returns a function or a
3236 # list/dictionary that contains a function)...
3237 if is_valid_index(idx - 2) and (
3238 LL[idx - 2].type == token.NAME or LL[idx - 2].type in CLOSING_BRACKETS
3244 # Skip the string trailer, if one exists.
3245 string_parser = StringParser()
3246 next_idx = string_parser.parse(LL, string_idx)
3248 # if the leaves in the parsed string include a PERCENT, we need to
3249 # make sure the initial LPAR is NOT preceded by an operator with
3250 # higher or equal precedence to PERCENT
3251 if is_valid_index(idx - 2):
3252 # mypy can't quite follow unless we name this
3253 before_lpar = LL[idx - 2]
3254 if token.PERCENT in {leaf.type for leaf in LL[idx - 1 : next_idx]} and (
3271 # only unary PLUS/MINUS
3273 and before_lpar.parent.type == syms.factor
3274 and (before_lpar.type in {token.PLUS, token.MINUS})
3279 # Should be followed by a non-empty RPAR...
3281 is_valid_index(next_idx)
3282 and LL[next_idx].type == token.RPAR
3283 and not is_empty_rpar(LL[next_idx])
3285 # That RPAR should NOT be followed by anything with higher
3286 # precedence than PERCENT
3287 if is_valid_index(next_idx + 1) and LL[next_idx + 1].type in {
3295 return Ok(string_idx)
3297 return TErr("This line has no strings wrapped in parens.")
3299 def do_transform(self, line: Line, string_idx: int) -> Iterator[TResult[Line]]:
3302 string_parser = StringParser()
3303 rpar_idx = string_parser.parse(LL, string_idx)
3305 for leaf in (LL[string_idx - 1], LL[rpar_idx]):
3306 if line.comments_after(leaf):
3308 "Will not strip parentheses which have comments attached to them."
3311 new_line = line.clone()
3312 new_line.comments = line.comments.copy()
3313 append_leaves(new_line, line, LL[: string_idx - 1])
3315 string_leaf = Leaf(token.STRING, LL[string_idx].value)
3316 LL[string_idx - 1].remove()
3317 replace_child(LL[string_idx], string_leaf)
3318 new_line.append(string_leaf)
3321 new_line, line, LL[string_idx + 1 : rpar_idx] + LL[rpar_idx + 1 :]
3324 LL[rpar_idx].remove()
3329 class BaseStringSplitter(StringTransformer):
3331 Abstract class for StringTransformers which transform a Line's strings by splitting
3332 them or placing them on their own lines where necessary to avoid going over
3333 the configured line length.
3336 * The target string value is responsible for the line going over the
3337 line length limit. It follows that after all of black's other line
3338 split methods have been exhausted, this line (or one of the resulting
3339 lines after all line splits are performed) would still be over the
3340 line_length limit unless we split this string.
3342 * The target string is NOT a "pointless" string (i.e. a string that has
3343 no parent or siblings).
3345 * The target string is not followed by an inline comment that appears
3348 * The target string is not a multiline (i.e. triple-quote) string.
3352 def do_splitter_match(self, line: Line) -> TMatchResult:
3354 BaseStringSplitter asks its clients to override this method instead of
3355 `StringTransformer.do_match(...)`.
3357 Follows the same protocol as `StringTransformer.do_match(...)`.
3359 Refer to `help(StringTransformer.do_match)` for more information.
3362 def do_match(self, line: Line) -> TMatchResult:
3363 match_result = self.do_splitter_match(line)
3364 if isinstance(match_result, Err):
3367 string_idx = match_result.ok()
3368 vresult = self.__validate(line, string_idx)
3369 if isinstance(vresult, Err):
3374 def __validate(self, line: Line, string_idx: int) -> TResult[None]:
3376 Checks that @line meets all of the requirements listed in this classes'
3377 docstring. Refer to `help(BaseStringSplitter)` for a detailed
3378 description of those requirements.
3381 * Ok(None), if ALL of the requirements are met.
3383 * Err(CannotTransform), if ANY of the requirements are NOT met.
3387 string_leaf = LL[string_idx]
3389 max_string_length = self.__get_max_string_length(line, string_idx)
3390 if len(string_leaf.value) <= max_string_length:
3392 "The string itself is not what is causing this line to be too long."
3395 if not string_leaf.parent or [L.type for L in string_leaf.parent.children] == [
3400 f"This string ({string_leaf.value}) appears to be pointless (i.e. has"
3404 if id(line.leaves[string_idx]) in line.comments and contains_pragma_comment(
3405 line.comments[id(line.leaves[string_idx])]
3408 "Line appears to end with an inline pragma comment. Splitting the line"
3409 " could modify the pragma's behavior."
3412 if has_triple_quotes(string_leaf.value):
3413 return TErr("We cannot split multiline strings.")
3417 def __get_max_string_length(self, line: Line, string_idx: int) -> int:
3419 Calculates the max string length used when attempting to determine
3420 whether or not the target string is responsible for causing the line to
3421 go over the line length limit.
3423 WARNING: This method is tightly coupled to both StringSplitter and
3424 (especially) StringParenWrapper. There is probably a better way to
3425 accomplish what is being done here.
3428 max_string_length: such that `line.leaves[string_idx].value >
3429 max_string_length` implies that the target string IS responsible
3430 for causing this line to exceed the line length limit.
3434 is_valid_index = is_valid_index_factory(LL)
3436 # We use the shorthand "WMA4" in comments to abbreviate "We must
3437 # account for". When giving examples, we use STRING to mean some/any
3440 # Finally, we use the following convenience variables:
3442 # P: The leaf that is before the target string leaf.
3443 # N: The leaf that is after the target string leaf.
3444 # NN: The leaf that is after N.
3446 # WMA4 the whitespace at the beginning of the line.
3447 offset = line.depth * 4
3449 if is_valid_index(string_idx - 1):
3450 p_idx = string_idx - 1
3452 LL[string_idx - 1].type == token.LPAR
3453 and LL[string_idx - 1].value == ""
3456 # If the previous leaf is an empty LPAR placeholder, we should skip it.
3460 if P.type == token.PLUS:
3461 # WMA4 a space and a '+' character (e.g. `+ STRING`).
3464 if P.type == token.COMMA:
3465 # WMA4 a space, a comma, and a closing bracket [e.g. `), STRING`].
3468 if P.type in [token.COLON, token.EQUAL, token.NAME]:
3469 # This conditional branch is meant to handle dictionary keys,
3470 # variable assignments, 'return STRING' statement lines, and
3471 # 'else STRING' ternary expression lines.
3473 # WMA4 a single space.
3476 # WMA4 the lengths of any leaves that came before that space.
3477 for leaf in LL[: p_idx + 1]:
3478 offset += len(str(leaf))
3480 if is_valid_index(string_idx + 1):
3481 N = LL[string_idx + 1]
3482 if N.type == token.RPAR and N.value == "" and len(LL) > string_idx + 2:
3483 # If the next leaf is an empty RPAR placeholder, we should skip it.
3484 N = LL[string_idx + 2]
3486 if N.type == token.COMMA:
3487 # WMA4 a single comma at the end of the string (e.g `STRING,`).
3490 if is_valid_index(string_idx + 2):
3491 NN = LL[string_idx + 2]
3493 if N.type == token.DOT and NN.type == token.NAME:
3494 # This conditional branch is meant to handle method calls invoked
3495 # off of a string literal up to and including the LPAR character.
3497 # WMA4 the '.' character.
3501 is_valid_index(string_idx + 3)
3502 and LL[string_idx + 3].type == token.LPAR
3504 # WMA4 the left parenthesis character.
3507 # WMA4 the length of the method's name.
3508 offset += len(NN.value)
3510 has_comments = False
3511 for comment_leaf in line.comments_after(LL[string_idx]):
3512 if not has_comments:
3514 # WMA4 two spaces before the '#' character.
3517 # WMA4 the length of the inline comment.
3518 offset += len(comment_leaf.value)
3520 max_string_length = self.line_length - offset
3521 return max_string_length
3524 class StringSplitter(CustomSplitMapMixin, BaseStringSplitter):
3526 StringTransformer that splits "atom" strings (i.e. strings which exist on
3527 lines by themselves).
3530 * The line consists ONLY of a single string (with the exception of a
3531 '+' symbol which MAY exist at the start of the line), MAYBE a string
3532 trailer, and MAYBE a trailing comma.
3534 * All of the requirements listed in BaseStringSplitter's docstring.
3537 The string mentioned in the 'Requirements' section is split into as
3538 many substrings as necessary to adhere to the configured line length.
3540 In the final set of substrings, no substring should be smaller than
3541 MIN_SUBSTR_SIZE characters.
3543 The string will ONLY be split on spaces (i.e. each new substring should
3544 start with a space).
3546 If the string is an f-string, it will NOT be split in the middle of an
3547 f-expression (e.g. in f"FooBar: {foo() if x else bar()}", {foo() if x
3548 else bar()} is an f-expression).
3550 If the string that is being split has an associated set of custom split
3551 records and those custom splits will NOT result in any line going over
3552 the configured line length, those custom splits are used. Otherwise the
3553 string is split as late as possible (from left-to-right) while still
3554 adhering to the transformation rules listed above.
3557 StringSplitter relies on StringMerger to construct the appropriate
3558 CustomSplit objects and add them to the custom split map.
3562 # Matches an "f-expression" (e.g. {var}) that might be found in an f-string.
3570 (?<!\})(?:\}\})*\}(?!\})
3573 def do_splitter_match(self, line: Line) -> TMatchResult:
3576 is_valid_index = is_valid_index_factory(LL)
3580 # The first leaf MAY be a '+' symbol...
3581 if is_valid_index(idx) and LL[idx].type == token.PLUS:
3584 # The next/first leaf MAY be an empty LPAR...
3585 if is_valid_index(idx) and is_empty_lpar(LL[idx]):
3588 # The next/first leaf MUST be a string...
3589 if not is_valid_index(idx) or LL[idx].type != token.STRING:
3590 return TErr("Line does not start with a string.")
3594 # Skip the string trailer, if one exists.
3595 string_parser = StringParser()
3596 idx = string_parser.parse(LL, string_idx)
3598 # That string MAY be followed by an empty RPAR...
3599 if is_valid_index(idx) and is_empty_rpar(LL[idx]):
3602 # That string / empty RPAR leaf MAY be followed by a comma...
3603 if is_valid_index(idx) and LL[idx].type == token.COMMA:
3606 # But no more leaves are allowed...
3607 if is_valid_index(idx):
3608 return TErr("This line does not end with a string.")
3610 return Ok(string_idx)
3612 def do_transform(self, line: Line, string_idx: int) -> Iterator[TResult[Line]]:
3615 QUOTE = LL[string_idx].value[-1]
3617 is_valid_index = is_valid_index_factory(LL)
3618 insert_str_child = insert_str_child_factory(LL[string_idx])
3620 prefix = get_string_prefix(LL[string_idx].value)
3622 # We MAY choose to drop the 'f' prefix from substrings that don't
3623 # contain any f-expressions, but ONLY if the original f-string
3624 # contains at least one f-expression. Otherwise, we will alter the AST
3626 drop_pointless_f_prefix = ("f" in prefix) and re.search(
3627 self.RE_FEXPR, LL[string_idx].value, re.VERBOSE
3630 first_string_line = True
3631 starts_with_plus = LL[0].type == token.PLUS
3633 def line_needs_plus() -> bool:
3634 return first_string_line and starts_with_plus
3636 def maybe_append_plus(new_line: Line) -> None:
3639 If @line starts with a plus and this is the first line we are
3640 constructing, this function appends a PLUS leaf to @new_line
3641 and replaces the old PLUS leaf in the node structure. Otherwise
3642 this function does nothing.
3644 if line_needs_plus():
3645 plus_leaf = Leaf(token.PLUS, "+")
3646 replace_child(LL[0], plus_leaf)
3647 new_line.append(plus_leaf)
3650 is_valid_index(string_idx + 1) and LL[string_idx + 1].type == token.COMMA
3653 def max_last_string() -> int:
3656 The max allowed length of the string value used for the last
3657 line we will construct.
3659 result = self.line_length
3660 result -= line.depth * 4
3661 result -= 1 if ends_with_comma else 0
3662 result -= 2 if line_needs_plus() else 0
3665 # --- Calculate Max Break Index (for string value)
3666 # We start with the line length limit
3667 max_break_idx = self.line_length
3668 # The last index of a string of length N is N-1.
3670 # Leading whitespace is not present in the string value (e.g. Leaf.value).
3671 max_break_idx -= line.depth * 4
3672 if max_break_idx < 0:
3674 f"Unable to split {LL[string_idx].value} at such high of a line depth:"
3679 # Check if StringMerger registered any custom splits.
3680 custom_splits = self.pop_custom_splits(LL[string_idx].value)
3681 # We use them ONLY if none of them would produce lines that exceed the
3683 use_custom_breakpoints = bool(
3685 and all(csplit.break_idx <= max_break_idx for csplit in custom_splits)
3688 # Temporary storage for the remaining chunk of the string line that
3689 # can't fit onto the line currently being constructed.
3690 rest_value = LL[string_idx].value
3692 def more_splits_should_be_made() -> bool:
3695 True iff `rest_value` (the remaining string value from the last
3696 split), should be split again.
3698 if use_custom_breakpoints:
3699 return len(custom_splits) > 1
3701 return len(rest_value) > max_last_string()
3703 string_line_results: List[Ok[Line]] = []
3704 while more_splits_should_be_made():
3705 if use_custom_breakpoints:
3706 # Custom User Split (manual)
3707 csplit = custom_splits.pop(0)
3708 break_idx = csplit.break_idx
3710 # Algorithmic Split (automatic)
3711 max_bidx = max_break_idx - 2 if line_needs_plus() else max_break_idx
3712 maybe_break_idx = self.__get_break_idx(rest_value, max_bidx)
3713 if maybe_break_idx is None:
3714 # If we are unable to algorithmically determine a good split
3715 # and this string has custom splits registered to it, we
3716 # fall back to using them--which means we have to start
3717 # over from the beginning.
3719 rest_value = LL[string_idx].value
3720 string_line_results = []
3721 first_string_line = True
3722 use_custom_breakpoints = True
3725 # Otherwise, we stop splitting here.
3728 break_idx = maybe_break_idx
3730 # --- Construct `next_value`
3731 next_value = rest_value[:break_idx] + QUOTE
3733 # Are we allowed to try to drop a pointless 'f' prefix?
3734 drop_pointless_f_prefix
3735 # If we are, will we be successful?
3736 and next_value != self.__normalize_f_string(next_value, prefix)
3738 # If the current custom split did NOT originally use a prefix,
3739 # then `csplit.break_idx` will be off by one after removing
3743 if use_custom_breakpoints and not csplit.has_prefix
3746 next_value = rest_value[:break_idx] + QUOTE
3747 next_value = self.__normalize_f_string(next_value, prefix)
3749 # --- Construct `next_leaf`
3750 next_leaf = Leaf(token.STRING, next_value)
3751 insert_str_child(next_leaf)
3752 self.__maybe_normalize_string_quotes(next_leaf)
3754 # --- Construct `next_line`
3755 next_line = line.clone()
3756 maybe_append_plus(next_line)
3757 next_line.append(next_leaf)
3758 string_line_results.append(Ok(next_line))
3760 rest_value = prefix + QUOTE + rest_value[break_idx:]
3761 first_string_line = False
3763 yield from string_line_results
3765 if drop_pointless_f_prefix:
3766 rest_value = self.__normalize_f_string(rest_value, prefix)
3768 rest_leaf = Leaf(token.STRING, rest_value)
3769 insert_str_child(rest_leaf)
3771 # NOTE: I could not find a test case that verifies that the following
3772 # line is actually necessary, but it seems to be. Otherwise we risk
3773 # not normalizing the last substring, right?
3774 self.__maybe_normalize_string_quotes(rest_leaf)
3776 last_line = line.clone()
3777 maybe_append_plus(last_line)
3779 # If there are any leaves to the right of the target string...
3780 if is_valid_index(string_idx + 1):
3781 # We use `temp_value` here to determine how long the last line
3782 # would be if we were to append all the leaves to the right of the
3783 # target string to the last string line.
3784 temp_value = rest_value
3785 for leaf in LL[string_idx + 1 :]:
3786 temp_value += str(leaf)
3787 if leaf.type == token.LPAR:
3790 # Try to fit them all on the same line with the last substring...
3792 len(temp_value) <= max_last_string()
3793 or LL[string_idx + 1].type == token.COMMA
3795 last_line.append(rest_leaf)
3796 append_leaves(last_line, line, LL[string_idx + 1 :])
3798 # Otherwise, place the last substring on one line and everything
3799 # else on a line below that...
3801 last_line.append(rest_leaf)
3804 non_string_line = line.clone()
3805 append_leaves(non_string_line, line, LL[string_idx + 1 :])
3806 yield Ok(non_string_line)
3807 # Else the target string was the last leaf...
3809 last_line.append(rest_leaf)
3810 last_line.comments = line.comments.copy()
3813 def __get_break_idx(self, string: str, max_break_idx: int) -> Optional[int]:
3815 This method contains the algorithm that StringSplitter uses to
3816 determine which character to split each string at.
3819 @string: The substring that we are attempting to split.
3820 @max_break_idx: The ideal break index. We will return this value if it
3821 meets all the necessary conditions. In the likely event that it
3822 doesn't we will try to find the closest index BELOW @max_break_idx
3823 that does. If that fails, we will expand our search by also
3824 considering all valid indices ABOVE @max_break_idx.
3827 * assert_is_leaf_string(@string)
3828 * 0 <= @max_break_idx < len(@string)
3831 break_idx, if an index is able to be found that meets all of the
3832 conditions listed in the 'Transformations' section of this classes'
3837 is_valid_index = is_valid_index_factory(string)
3839 assert is_valid_index(max_break_idx)
3840 assert_is_leaf_string(string)
3842 _fexpr_slices: Optional[List[Tuple[Index, Index]]] = None
3844 def fexpr_slices() -> Iterator[Tuple[Index, Index]]:
3847 All ranges of @string which, if @string were to be split there,
3848 would result in the splitting of an f-expression (which is NOT
3851 nonlocal _fexpr_slices
3853 if _fexpr_slices is None:
3855 for match in re.finditer(self.RE_FEXPR, string, re.VERBOSE):
3856 _fexpr_slices.append(match.span())
3858 yield from _fexpr_slices
3860 is_fstring = "f" in get_string_prefix(string)
3862 def breaks_fstring_expression(i: Index) -> bool:
3865 True iff returning @i would result in the splitting of an
3866 f-expression (which is NOT allowed).
3871 for (start, end) in fexpr_slices():
3872 if start <= i < end:
3877 def passes_all_checks(i: Index) -> bool:
3880 True iff ALL of the conditions listed in the 'Transformations'
3881 section of this classes' docstring would be be met by returning @i.
3883 is_space = string[i] == " "
3885 len(string[i:]) >= self.MIN_SUBSTR_SIZE
3886 and len(string[:i]) >= self.MIN_SUBSTR_SIZE
3888 return is_space and is_big_enough and not breaks_fstring_expression(i)
3890 # First, we check all indices BELOW @max_break_idx.
3891 break_idx = max_break_idx
3892 while is_valid_index(break_idx - 1) and not passes_all_checks(break_idx):
3895 if not passes_all_checks(break_idx):
3896 # If that fails, we check all indices ABOVE @max_break_idx.
3898 # If we are able to find a valid index here, the next line is going
3899 # to be longer than the specified line length, but it's probably
3900 # better than doing nothing at all.
3901 break_idx = max_break_idx + 1
3902 while is_valid_index(break_idx + 1) and not passes_all_checks(break_idx):
3905 if not is_valid_index(break_idx) or not passes_all_checks(break_idx):
3910 def __maybe_normalize_string_quotes(self, leaf: Leaf) -> None:
3911 if self.normalize_strings:
3912 normalize_string_quotes(leaf)
3914 def __normalize_f_string(self, string: str, prefix: str) -> str:
3917 * assert_is_leaf_string(@string)
3920 * If @string is an f-string that contains no f-expressions, we
3921 return a string identical to @string except that the 'f' prefix
3922 has been stripped and all double braces (i.e. '{{' or '}}') have
3923 been normalized (i.e. turned into '{' or '}').
3925 * Otherwise, we return @string.
3927 assert_is_leaf_string(string)
3929 if "f" in prefix and not re.search(self.RE_FEXPR, string, re.VERBOSE):
3930 new_prefix = prefix.replace("f", "")
3932 temp = string[len(prefix) :]
3933 temp = re.sub(r"\{\{", "{", temp)
3934 temp = re.sub(r"\}\}", "}", temp)
3937 return f"{new_prefix}{new_string}"
3942 class StringParenWrapper(CustomSplitMapMixin, BaseStringSplitter):
3944 StringTransformer that splits non-"atom" strings (i.e. strings that do not
3945 exist on lines by themselves).
3948 All of the requirements listed in BaseStringSplitter's docstring in
3949 addition to the requirements listed below:
3951 * The line is a return/yield statement, which returns/yields a string.
3953 * The line is part of a ternary expression (e.g. `x = y if cond else
3954 z`) such that the line starts with `else <string>`, where <string> is
3957 * The line is an assert statement, which ends with a string.
3959 * The line is an assignment statement (e.g. `x = <string>` or `x +=
3960 <string>`) such that the variable is being assigned the value of some
3963 * The line is a dictionary key assignment where some valid key is being
3964 assigned the value of some string.
3967 The chosen string is wrapped in parentheses and then split at the LPAR.
3969 We then have one line which ends with an LPAR and another line that
3970 starts with the chosen string. The latter line is then split again at
3971 the RPAR. This results in the RPAR (and possibly a trailing comma)
3972 being placed on its own line.
3974 NOTE: If any leaves exist to the right of the chosen string (except
3975 for a trailing comma, which would be placed after the RPAR), those
3976 leaves are placed inside the parentheses. In effect, the chosen
3977 string is not necessarily being "wrapped" by parentheses. We can,
3978 however, count on the LPAR being placed directly before the chosen
3981 In other words, StringParenWrapper creates "atom" strings. These
3982 can then be split again by StringSplitter, if necessary.
3985 In the event that a string line split by StringParenWrapper is
3986 changed such that it no longer needs to be given its own line,
3987 StringParenWrapper relies on StringParenStripper to clean up the
3988 parentheses it created.
3991 def do_splitter_match(self, line: Line) -> TMatchResult:
3995 self._return_match(LL)
3996 or self._else_match(LL)
3997 or self._assert_match(LL)
3998 or self._assign_match(LL)
3999 or self._dict_match(LL)
4002 if string_idx is not None:
4003 string_value = line.leaves[string_idx].value
4004 # If the string has no spaces...
4005 if " " not in string_value:
4006 # And will still violate the line length limit when split...
4007 max_string_length = self.line_length - ((line.depth + 1) * 4)
4008 if len(string_value) > max_string_length:
4009 # And has no associated custom splits...
4010 if not self.has_custom_splits(string_value):
4011 # Then we should NOT put this string on its own line.
4013 "We do not wrap long strings in parentheses when the"
4014 " resultant line would still be over the specified line"
4015 " length and can't be split further by StringSplitter."
4017 return Ok(string_idx)
4019 return TErr("This line does not contain any non-atomic strings.")
4022 def _return_match(LL: List[Leaf]) -> Optional[int]:
4025 string_idx such that @LL[string_idx] is equal to our target (i.e.
4026 matched) string, if this line matches the return/yield statement
4027 requirements listed in the 'Requirements' section of this classes'
4032 # If this line is apart of a return/yield statement and the first leaf
4033 # contains either the "return" or "yield" keywords...
4034 if parent_type(LL[0]) in [syms.return_stmt, syms.yield_expr] and LL[
4036 ].value in ["return", "yield"]:
4037 is_valid_index = is_valid_index_factory(LL)
4039 idx = 2 if is_valid_index(1) and is_empty_par(LL[1]) else 1
4040 # The next visible leaf MUST contain a string...
4041 if is_valid_index(idx) and LL[idx].type == token.STRING:
4047 def _else_match(LL: List[Leaf]) -> Optional[int]:
4050 string_idx such that @LL[string_idx] is equal to our target (i.e.
4051 matched) string, if this line matches the ternary expression
4052 requirements listed in the 'Requirements' section of this classes'
4057 # If this line is apart of a ternary expression and the first leaf
4058 # contains the "else" keyword...
4060 parent_type(LL[0]) == syms.test
4061 and LL[0].type == token.NAME
4062 and LL[0].value == "else"
4064 is_valid_index = is_valid_index_factory(LL)
4066 idx = 2 if is_valid_index(1) and is_empty_par(LL[1]) else 1
4067 # The next visible leaf MUST contain a string...
4068 if is_valid_index(idx) and LL[idx].type == token.STRING:
4074 def _assert_match(LL: List[Leaf]) -> Optional[int]:
4077 string_idx such that @LL[string_idx] is equal to our target (i.e.
4078 matched) string, if this line matches the assert statement
4079 requirements listed in the 'Requirements' section of this classes'
4084 # If this line is apart of an assert statement and the first leaf
4085 # contains the "assert" keyword...
4086 if parent_type(LL[0]) == syms.assert_stmt and LL[0].value == "assert":
4087 is_valid_index = is_valid_index_factory(LL)
4089 for (i, leaf) in enumerate(LL):
4090 # We MUST find a comma...
4091 if leaf.type == token.COMMA:
4092 idx = i + 2 if is_empty_par(LL[i + 1]) else i + 1
4094 # That comma MUST be followed by a string...
4095 if is_valid_index(idx) and LL[idx].type == token.STRING:
4098 # Skip the string trailer, if one exists.
4099 string_parser = StringParser()
4100 idx = string_parser.parse(LL, string_idx)
4102 # But no more leaves are allowed...
4103 if not is_valid_index(idx):
4109 def _assign_match(LL: List[Leaf]) -> Optional[int]:
4112 string_idx such that @LL[string_idx] is equal to our target (i.e.
4113 matched) string, if this line matches the assignment statement
4114 requirements listed in the 'Requirements' section of this classes'
4119 # If this line is apart of an expression statement or is a function
4120 # argument AND the first leaf contains a variable name...
4122 parent_type(LL[0]) in [syms.expr_stmt, syms.argument, syms.power]
4123 and LL[0].type == token.NAME
4125 is_valid_index = is_valid_index_factory(LL)
4127 for (i, leaf) in enumerate(LL):
4128 # We MUST find either an '=' or '+=' symbol...
4129 if leaf.type in [token.EQUAL, token.PLUSEQUAL]:
4130 idx = i + 2 if is_empty_par(LL[i + 1]) else i + 1
4132 # That symbol MUST be followed by a string...
4133 if is_valid_index(idx) and LL[idx].type == token.STRING:
4136 # Skip the string trailer, if one exists.
4137 string_parser = StringParser()
4138 idx = string_parser.parse(LL, string_idx)
4140 # The next leaf MAY be a comma iff this line is apart
4141 # of a function argument...
4143 parent_type(LL[0]) == syms.argument
4144 and is_valid_index(idx)
4145 and LL[idx].type == token.COMMA
4149 # But no more leaves are allowed...
4150 if not is_valid_index(idx):
4156 def _dict_match(LL: List[Leaf]) -> Optional[int]:
4159 string_idx such that @LL[string_idx] is equal to our target (i.e.
4160 matched) string, if this line matches the dictionary key assignment
4161 statement requirements listed in the 'Requirements' section of this
4166 # If this line is apart of a dictionary key assignment...
4167 if syms.dictsetmaker in [parent_type(LL[0]), parent_type(LL[0].parent)]:
4168 is_valid_index = is_valid_index_factory(LL)
4170 for (i, leaf) in enumerate(LL):
4171 # We MUST find a colon...
4172 if leaf.type == token.COLON:
4173 idx = i + 2 if is_empty_par(LL[i + 1]) else i + 1
4175 # That colon MUST be followed by a string...
4176 if is_valid_index(idx) and LL[idx].type == token.STRING:
4179 # Skip the string trailer, if one exists.
4180 string_parser = StringParser()
4181 idx = string_parser.parse(LL, string_idx)
4183 # That string MAY be followed by a comma...
4184 if is_valid_index(idx) and LL[idx].type == token.COMMA:
4187 # But no more leaves are allowed...
4188 if not is_valid_index(idx):
4193 def do_transform(self, line: Line, string_idx: int) -> Iterator[TResult[Line]]:
4196 is_valid_index = is_valid_index_factory(LL)
4197 insert_str_child = insert_str_child_factory(LL[string_idx])
4200 ends_with_comma = False
4201 if LL[comma_idx].type == token.COMMA:
4202 ends_with_comma = True
4204 leaves_to_steal_comments_from = [LL[string_idx]]
4206 leaves_to_steal_comments_from.append(LL[comma_idx])
4209 first_line = line.clone()
4210 left_leaves = LL[:string_idx]
4212 # We have to remember to account for (possibly invisible) LPAR and RPAR
4213 # leaves that already wrapped the target string. If these leaves do
4214 # exist, we will replace them with our own LPAR and RPAR leaves.
4215 old_parens_exist = False
4216 if left_leaves and left_leaves[-1].type == token.LPAR:
4217 old_parens_exist = True
4218 leaves_to_steal_comments_from.append(left_leaves[-1])
4221 append_leaves(first_line, line, left_leaves)
4223 lpar_leaf = Leaf(token.LPAR, "(")
4224 if old_parens_exist:
4225 replace_child(LL[string_idx - 1], lpar_leaf)
4227 insert_str_child(lpar_leaf)
4228 first_line.append(lpar_leaf)
4230 # We throw inline comments that were originally to the right of the
4231 # target string to the top line. They will now be shown to the right of
4233 for leaf in leaves_to_steal_comments_from:
4234 for comment_leaf in line.comments_after(leaf):
4235 first_line.append(comment_leaf, preformatted=True)
4237 yield Ok(first_line)
4239 # --- Middle (String) Line
4240 # We only need to yield one (possibly too long) string line, since the
4241 # `StringSplitter` will break it down further if necessary.
4242 string_value = LL[string_idx].value
4244 depth=line.depth + 1,
4245 inside_brackets=True,
4246 should_explode=line.should_explode,
4248 string_leaf = Leaf(token.STRING, string_value)
4249 insert_str_child(string_leaf)
4250 string_line.append(string_leaf)
4252 old_rpar_leaf = None
4253 if is_valid_index(string_idx + 1):
4254 right_leaves = LL[string_idx + 1 :]
4258 if old_parens_exist:
4260 right_leaves and right_leaves[-1].type == token.RPAR
4261 ), "Apparently, old parentheses do NOT exist?!"
4262 old_rpar_leaf = right_leaves.pop()
4264 append_leaves(string_line, line, right_leaves)
4266 yield Ok(string_line)
4269 last_line = line.clone()
4270 last_line.bracket_tracker = first_line.bracket_tracker
4272 new_rpar_leaf = Leaf(token.RPAR, ")")
4273 if old_rpar_leaf is not None:
4274 replace_child(old_rpar_leaf, new_rpar_leaf)
4276 insert_str_child(new_rpar_leaf)
4277 last_line.append(new_rpar_leaf)
4279 # If the target string ended with a comma, we place this comma to the
4280 # right of the RPAR on the last line.
4282 comma_leaf = Leaf(token.COMMA, ",")
4283 replace_child(LL[comma_idx], comma_leaf)
4284 last_line.append(comma_leaf)
4291 A state machine that aids in parsing a string's "trailer", which can be
4292 either non-existent, an old-style formatting sequence (e.g. `% varX` or `%
4293 (varX, varY)`), or a method-call / attribute access (e.g. `.format(varX,
4296 NOTE: A new StringParser object MUST be instantiated for each string
4297 trailer we need to parse.
4300 We shall assume that `line` equals the `Line` object that corresponds
4301 to the following line of python code:
4303 x = "Some {}.".format("String") + some_other_string
4306 Furthermore, we will assume that `string_idx` is some index such that:
4308 assert line.leaves[string_idx].value == "Some {}."
4311 The following code snippet then holds:
4313 string_parser = StringParser()
4314 idx = string_parser.parse(line.leaves, string_idx)
4315 assert line.leaves[idx].type == token.PLUS
4321 # String Parser States
4331 # Lookup Table for Next State
4332 _goto: Dict[Tuple[ParserState, NodeType], ParserState] = {
4333 # A string trailer may start with '.' OR '%'.
4334 (START, token.DOT): DOT,
4335 (START, token.PERCENT): PERCENT,
4336 (START, DEFAULT_TOKEN): DONE,
4337 # A '.' MUST be followed by an attribute or method name.
4338 (DOT, token.NAME): NAME,
4339 # A method name MUST be followed by an '(', whereas an attribute name
4340 # is the last symbol in the string trailer.
4341 (NAME, token.LPAR): LPAR,
4342 (NAME, DEFAULT_TOKEN): DONE,
4343 # A '%' symbol can be followed by an '(' or a single argument (e.g. a
4344 # string or variable name).
4345 (PERCENT, token.LPAR): LPAR,
4346 (PERCENT, DEFAULT_TOKEN): SINGLE_FMT_ARG,
4347 # If a '%' symbol is followed by a single argument, that argument is
4348 # the last leaf in the string trailer.
4349 (SINGLE_FMT_ARG, DEFAULT_TOKEN): DONE,
4350 # If present, a ')' symbol is the last symbol in a string trailer.
4351 # (NOTE: LPARS and nested RPARS are not included in this lookup table,
4352 # since they are treated as a special case by the parsing logic in this
4353 # classes' implementation.)
4354 (RPAR, DEFAULT_TOKEN): DONE,
4357 def __init__(self) -> None:
4358 self._state = self.START
4359 self._unmatched_lpars = 0
4361 def parse(self, leaves: List[Leaf], string_idx: int) -> int:
4364 * @leaves[@string_idx].type == token.STRING
4367 The index directly after the last leaf which is apart of the string
4368 trailer, if a "trailer" exists.
4370 @string_idx + 1, if no string "trailer" exists.
4372 assert leaves[string_idx].type == token.STRING
4374 idx = string_idx + 1
4375 while idx < len(leaves) and self._next_state(leaves[idx]):
4379 def _next_state(self, leaf: Leaf) -> bool:
4382 * On the first call to this function, @leaf MUST be the leaf that
4383 was directly after the string leaf in question (e.g. if our target
4384 string is `line.leaves[i]` then the first call to this method must
4385 be `line.leaves[i + 1]`).
4386 * On the next call to this function, the leaf parameter passed in
4387 MUST be the leaf directly following @leaf.
4390 True iff @leaf is apart of the string's trailer.
4392 # We ignore empty LPAR or RPAR leaves.
4393 if is_empty_par(leaf):
4396 next_token = leaf.type
4397 if next_token == token.LPAR:
4398 self._unmatched_lpars += 1
4400 current_state = self._state
4402 # The LPAR parser state is a special case. We will return True until we
4403 # find the matching RPAR token.
4404 if current_state == self.LPAR:
4405 if next_token == token.RPAR:
4406 self._unmatched_lpars -= 1
4407 if self._unmatched_lpars == 0:
4408 self._state = self.RPAR
4409 # Otherwise, we use a lookup table to determine the next state.
4411 # If the lookup table matches the current state to the next
4412 # token, we use the lookup table.
4413 if (current_state, next_token) in self._goto:
4414 self._state = self._goto[current_state, next_token]
4416 # Otherwise, we check if a the current state was assigned a
4418 if (current_state, self.DEFAULT_TOKEN) in self._goto:
4419 self._state = self._goto[current_state, self.DEFAULT_TOKEN]
4420 # If no default has been assigned, then this parser has a logic
4423 raise RuntimeError(f"{self.__class__.__name__} LOGIC ERROR!")
4425 if self._state == self.DONE:
4431 def TErr(err_msg: str) -> Err[CannotTransform]:
4434 Convenience function used when working with the TResult type.
4436 cant_transform = CannotTransform(err_msg)
4437 return Err(cant_transform)
4440 def contains_pragma_comment(comment_list: List[Leaf]) -> bool:
4443 True iff one of the comments in @comment_list is a pragma used by one
4444 of the more common static analysis tools for python (e.g. mypy, flake8,
4447 for comment in comment_list:
4448 if comment.value.startswith(("# type:", "# noqa", "# pylint:")):
4454 def insert_str_child_factory(string_leaf: Leaf) -> Callable[[LN], None]:
4456 Factory for a convenience function that is used to orphan @string_leaf
4457 and then insert multiple new leaves into the same part of the node
4458 structure that @string_leaf had originally occupied.
4461 Let `string_leaf = Leaf(token.STRING, '"foo"')` and `N =
4462 string_leaf.parent`. Assume the node `N` has the following
4469 Leaf(STRING, '"foo"'),
4473 We then run the code snippet shown below.
4475 insert_str_child = insert_str_child_factory(string_leaf)
4477 lpar = Leaf(token.LPAR, '(')
4478 insert_str_child(lpar)
4480 bar = Leaf(token.STRING, '"bar"')
4481 insert_str_child(bar)
4483 rpar = Leaf(token.RPAR, ')')
4484 insert_str_child(rpar)
4487 After which point, it follows that `string_leaf.parent is None` and
4488 the node `N` now has the following structure:
4495 Leaf(STRING, '"bar"'),
4500 string_parent = string_leaf.parent
4501 string_child_idx = string_leaf.remove()
4503 def insert_str_child(child: LN) -> None:
4504 nonlocal string_child_idx
4506 assert string_parent is not None
4507 assert string_child_idx is not None
4509 string_parent.insert_child(string_child_idx, child)
4510 string_child_idx += 1
4512 return insert_str_child
4515 def has_triple_quotes(string: str) -> bool:
4518 True iff @string starts with three quotation characters.
4520 raw_string = string.lstrip(STRING_PREFIX_CHARS)
4521 return raw_string[:3] in {'"""', "'''"}
4524 def parent_type(node: Optional[LN]) -> Optional[NodeType]:
4527 @node.parent.type, if @node is not None and has a parent.
4531 if node is None or node.parent is None:
4534 return node.parent.type
4537 def is_empty_par(leaf: Leaf) -> bool:
4538 return is_empty_lpar(leaf) or is_empty_rpar(leaf)
4541 def is_empty_lpar(leaf: Leaf) -> bool:
4542 return leaf.type == token.LPAR and leaf.value == ""
4545 def is_empty_rpar(leaf: Leaf) -> bool:
4546 return leaf.type == token.RPAR and leaf.value == ""
4549 def is_valid_index_factory(seq: Sequence[Any]) -> Callable[[int], bool]:
4555 is_valid_index = is_valid_index_factory(my_list)
4557 assert is_valid_index(0)
4558 assert is_valid_index(2)
4560 assert not is_valid_index(3)
4561 assert not is_valid_index(-1)
4565 def is_valid_index(idx: int) -> bool:
4568 True iff @idx is positive AND seq[@idx] does NOT raise an
4571 return 0 <= idx < len(seq)
4573 return is_valid_index
4576 def line_to_string(line: Line) -> str:
4577 """Returns the string representation of @line.
4579 WARNING: This is known to be computationally expensive.
4581 return str(line).strip("\n")
4584 def append_leaves(new_line: Line, old_line: Line, leaves: List[Leaf]) -> None:
4586 Append leaves (taken from @old_line) to @new_line, making sure to fix the
4587 underlying Node structure where appropriate.
4589 All of the leaves in @leaves are duplicated. The duplicates are then
4590 appended to @new_line and used to replace their originals in the underlying
4591 Node structure. Any comments attached to the old leaves are reattached to
4595 set(@leaves) is a subset of set(@old_line.leaves).
4597 for old_leaf in leaves:
4598 new_leaf = Leaf(old_leaf.type, old_leaf.value)
4599 replace_child(old_leaf, new_leaf)
4600 new_line.append(new_leaf)
4602 for comment_leaf in old_line.comments_after(old_leaf):
4603 new_line.append(comment_leaf, preformatted=True)
4606 def replace_child(old_child: LN, new_child: LN) -> None:
4609 * If @old_child.parent is set, replace @old_child with @new_child in
4610 @old_child's underlying Node structure.
4612 * Otherwise, this function does nothing.
4614 parent = old_child.parent
4618 child_idx = old_child.remove()
4619 if child_idx is not None:
4620 parent.insert_child(child_idx, new_child)
4623 def get_string_prefix(string: str) -> str:
4626 * assert_is_leaf_string(@string)
4629 @string's prefix (e.g. '', 'r', 'f', or 'rf').
4631 assert_is_leaf_string(string)
4635 while string[prefix_idx] in STRING_PREFIX_CHARS:
4636 prefix += string[prefix_idx].lower()
4642 def assert_is_leaf_string(string: str) -> None:
4644 Checks the pre-condition that @string has the format that you would expect
4645 of `leaf.value` where `leaf` is some Leaf such that `leaf.type ==
4646 token.STRING`. A more precise description of the pre-conditions that are
4647 checked are listed below.
4650 * @string starts with either ', ", <prefix>', or <prefix>" where
4651 `set(<prefix>)` is some subset of `set(STRING_PREFIX_CHARS)`.
4652 * @string ends with a quote character (' or ").
4655 AssertionError(...) if the pre-conditions listed above are not
4658 dquote_idx = string.find('"')
4659 squote_idx = string.find("'")
4660 if -1 in [dquote_idx, squote_idx]:
4661 quote_idx = max(dquote_idx, squote_idx)
4663 quote_idx = min(squote_idx, dquote_idx)
4666 0 <= quote_idx < len(string) - 1
4667 ), f"{string!r} is missing a starting quote character (' or \")."
4668 assert string[-1] in (
4671 ), f"{string!r} is missing an ending quote character (' or \")."
4672 assert set(string[:quote_idx]).issubset(
4673 set(STRING_PREFIX_CHARS)
4674 ), f"{set(string[:quote_idx])} is NOT a subset of {set(STRING_PREFIX_CHARS)}."
4677 def left_hand_split(line: Line, _features: Collection[Feature] = ()) -> Iterator[Line]:
4678 """Split line into many lines, starting with the first matching bracket pair.
4680 Note: this usually looks weird, only use this for function definitions.
4681 Prefer RHS otherwise. This is why this function is not symmetrical with
4682 :func:`right_hand_split` which also handles optional parentheses.
4684 tail_leaves: List[Leaf] = []
4685 body_leaves: List[Leaf] = []
4686 head_leaves: List[Leaf] = []
4687 current_leaves = head_leaves
4688 matching_bracket: Optional[Leaf] = None
4689 for leaf in line.leaves:
4691 current_leaves is body_leaves
4692 and leaf.type in CLOSING_BRACKETS
4693 and leaf.opening_bracket is matching_bracket
4695 current_leaves = tail_leaves if body_leaves else head_leaves
4696 current_leaves.append(leaf)
4697 if current_leaves is head_leaves:
4698 if leaf.type in OPENING_BRACKETS:
4699 matching_bracket = leaf
4700 current_leaves = body_leaves
4701 if not matching_bracket:
4702 raise CannotSplit("No brackets found")
4704 head = bracket_split_build_line(head_leaves, line, matching_bracket)
4705 body = bracket_split_build_line(body_leaves, line, matching_bracket, is_body=True)
4706 tail = bracket_split_build_line(tail_leaves, line, matching_bracket)
4707 bracket_split_succeeded_or_raise(head, body, tail)
4708 for result in (head, body, tail):
4713 def right_hand_split(
4716 features: Collection[Feature] = (),
4717 omit: Collection[LeafID] = (),
4718 ) -> Iterator[Line]:
4719 """Split line into many lines, starting with the last matching bracket pair.
4721 If the split was by optional parentheses, attempt splitting without them, too.
4722 `omit` is a collection of closing bracket IDs that shouldn't be considered for
4725 Note: running this function modifies `bracket_depth` on the leaves of `line`.
4727 tail_leaves: List[Leaf] = []
4728 body_leaves: List[Leaf] = []
4729 head_leaves: List[Leaf] = []
4730 current_leaves = tail_leaves
4731 opening_bracket: Optional[Leaf] = None
4732 closing_bracket: Optional[Leaf] = None
4733 for leaf in reversed(line.leaves):
4734 if current_leaves is body_leaves:
4735 if leaf is opening_bracket:
4736 current_leaves = head_leaves if body_leaves else tail_leaves
4737 current_leaves.append(leaf)
4738 if current_leaves is tail_leaves:
4739 if leaf.type in CLOSING_BRACKETS and id(leaf) not in omit:
4740 opening_bracket = leaf.opening_bracket
4741 closing_bracket = leaf
4742 current_leaves = body_leaves
4743 if not (opening_bracket and closing_bracket and head_leaves):
4744 # If there is no opening or closing_bracket that means the split failed and
4745 # all content is in the tail. Otherwise, if `head_leaves` are empty, it means
4746 # the matching `opening_bracket` wasn't available on `line` anymore.
4747 raise CannotSplit("No brackets found")
4749 tail_leaves.reverse()
4750 body_leaves.reverse()
4751 head_leaves.reverse()
4752 head = bracket_split_build_line(head_leaves, line, opening_bracket)
4753 body = bracket_split_build_line(body_leaves, line, opening_bracket, is_body=True)
4754 tail = bracket_split_build_line(tail_leaves, line, opening_bracket)
4755 bracket_split_succeeded_or_raise(head, body, tail)
4757 Feature.FORCE_OPTIONAL_PARENTHESES not in features
4758 # the opening bracket is an optional paren
4759 and opening_bracket.type == token.LPAR
4760 and not opening_bracket.value
4761 # the closing bracket is an optional paren
4762 and closing_bracket.type == token.RPAR
4763 and not closing_bracket.value
4764 # it's not an import (optional parens are the only thing we can split on
4765 # in this case; attempting a split without them is a waste of time)
4766 and not line.is_import
4767 # there are no standalone comments in the body
4768 and not body.contains_standalone_comments(0)
4769 # and we can actually remove the parens
4770 and can_omit_invisible_parens(body, line_length, omit_on_explode=omit)
4772 omit = {id(closing_bracket), *omit}
4774 yield from right_hand_split(line, line_length, features=features, omit=omit)
4780 or is_line_short_enough(body, line_length=line_length)
4783 "Splitting failed, body is still too long and can't be split."
4786 elif head.contains_multiline_strings() or tail.contains_multiline_strings():
4788 "The current optional pair of parentheses is bound to fail to"
4789 " satisfy the splitting algorithm because the head or the tail"
4790 " contains multiline strings which by definition never fit one"
4794 ensure_visible(opening_bracket)
4795 ensure_visible(closing_bracket)
4796 for result in (head, body, tail):
4801 def bracket_split_succeeded_or_raise(head: Line, body: Line, tail: Line) -> None:
4802 """Raise :exc:`CannotSplit` if the last left- or right-hand split failed.
4804 Do nothing otherwise.
4806 A left- or right-hand split is based on a pair of brackets. Content before
4807 (and including) the opening bracket is left on one line, content inside the
4808 brackets is put on a separate line, and finally content starting with and
4809 following the closing bracket is put on a separate line.
4811 Those are called `head`, `body`, and `tail`, respectively. If the split
4812 produced the same line (all content in `head`) or ended up with an empty `body`
4813 and the `tail` is just the closing bracket, then it's considered failed.
4815 tail_len = len(str(tail).strip())
4818 raise CannotSplit("Splitting brackets produced the same line")
4822 f"Splitting brackets on an empty body to save {tail_len} characters is"
4827 def bracket_split_build_line(
4828 leaves: List[Leaf], original: Line, opening_bracket: Leaf, *, is_body: bool = False
4830 """Return a new line with given `leaves` and respective comments from `original`.
4832 If `is_body` is True, the result line is one-indented inside brackets and as such
4833 has its first leaf's prefix normalized and a trailing comma added when expected.
4835 result = Line(depth=original.depth)
4837 result.inside_brackets = True
4840 # Since body is a new indent level, remove spurious leading whitespace.
4841 normalize_prefix(leaves[0], inside_brackets=True)
4842 # Ensure a trailing comma for imports and standalone function arguments, but
4843 # be careful not to add one after any comments or within type annotations.
4846 and opening_bracket.value == "("
4847 and not any(leaf.type == token.COMMA for leaf in leaves)
4850 if original.is_import or no_commas:
4851 for i in range(len(leaves) - 1, -1, -1):
4852 if leaves[i].type == STANDALONE_COMMENT:
4855 if leaves[i].type != token.COMMA:
4856 new_comma = Leaf(token.COMMA, ",")
4857 leaves.insert(i + 1, new_comma)
4862 result.append(leaf, preformatted=True)
4863 for comment_after in original.comments_after(leaf):
4864 result.append(comment_after, preformatted=True)
4865 if is_body and should_split_body_explode(result, opening_bracket):
4866 result.should_explode = True
4870 def dont_increase_indentation(split_func: Transformer) -> Transformer:
4871 """Normalize prefix of the first leaf in every line returned by `split_func`.
4873 This is a decorator over relevant split functions.
4877 def split_wrapper(line: Line, features: Collection[Feature] = ()) -> Iterator[Line]:
4878 for line in split_func(line, features):
4879 normalize_prefix(line.leaves[0], inside_brackets=True)
4882 return split_wrapper
4885 @dont_increase_indentation
4886 def delimiter_split(line: Line, features: Collection[Feature] = ()) -> Iterator[Line]:
4887 """Split according to delimiters of the highest priority.
4889 If the appropriate Features are given, the split will add trailing commas
4890 also in function signatures and calls that contain `*` and `**`.
4893 last_leaf = line.leaves[-1]
4895 raise CannotSplit("Line empty")
4897 bt = line.bracket_tracker
4899 delimiter_priority = bt.max_delimiter_priority(exclude={id(last_leaf)})
4901 raise CannotSplit("No delimiters found")
4903 if delimiter_priority == DOT_PRIORITY:
4904 if bt.delimiter_count_with_priority(delimiter_priority) == 1:
4905 raise CannotSplit("Splitting a single attribute from its owner looks wrong")
4907 current_line = Line(depth=line.depth, inside_brackets=line.inside_brackets)
4908 lowest_depth = sys.maxsize
4909 trailing_comma_safe = True
4911 def append_to_line(leaf: Leaf) -> Iterator[Line]:
4912 """Append `leaf` to current line or to new line if appending impossible."""
4913 nonlocal current_line
4915 current_line.append_safe(leaf, preformatted=True)
4919 current_line = Line(depth=line.depth, inside_brackets=line.inside_brackets)
4920 current_line.append(leaf)
4922 for leaf in line.leaves:
4923 yield from append_to_line(leaf)
4925 for comment_after in line.comments_after(leaf):
4926 yield from append_to_line(comment_after)
4928 lowest_depth = min(lowest_depth, leaf.bracket_depth)
4929 if leaf.bracket_depth == lowest_depth:
4930 if is_vararg(leaf, within={syms.typedargslist}):
4931 trailing_comma_safe = (
4932 trailing_comma_safe and Feature.TRAILING_COMMA_IN_DEF in features
4934 elif is_vararg(leaf, within={syms.arglist, syms.argument}):
4935 trailing_comma_safe = (
4936 trailing_comma_safe and Feature.TRAILING_COMMA_IN_CALL in features
4939 leaf_priority = bt.delimiters.get(id(leaf))
4940 if leaf_priority == delimiter_priority:
4943 current_line = Line(depth=line.depth, inside_brackets=line.inside_brackets)
4947 and delimiter_priority == COMMA_PRIORITY
4948 and current_line.leaves[-1].type != token.COMMA
4949 and current_line.leaves[-1].type != STANDALONE_COMMENT
4951 new_comma = Leaf(token.COMMA, ",")
4952 current_line.append(new_comma)
4956 @dont_increase_indentation
4957 def standalone_comment_split(
4958 line: Line, features: Collection[Feature] = ()
4959 ) -> Iterator[Line]:
4960 """Split standalone comments from the rest of the line."""
4961 if not line.contains_standalone_comments(0):
4962 raise CannotSplit("Line does not have any standalone comments")
4964 current_line = Line(depth=line.depth, inside_brackets=line.inside_brackets)
4966 def append_to_line(leaf: Leaf) -> Iterator[Line]:
4967 """Append `leaf` to current line or to new line if appending impossible."""
4968 nonlocal current_line
4970 current_line.append_safe(leaf, preformatted=True)
4974 current_line = Line(depth=line.depth, inside_brackets=line.inside_brackets)
4975 current_line.append(leaf)
4977 for leaf in line.leaves:
4978 yield from append_to_line(leaf)
4980 for comment_after in line.comments_after(leaf):
4981 yield from append_to_line(comment_after)
4987 def is_import(leaf: Leaf) -> bool:
4988 """Return True if the given leaf starts an import statement."""
4995 (v == "import" and p and p.type == syms.import_name)
4996 or (v == "from" and p and p.type == syms.import_from)
5001 def is_type_comment(leaf: Leaf, suffix: str = "") -> bool:
5002 """Return True if the given leaf is a special comment.
5003 Only returns true for type comments for now."""
5006 return t in {token.COMMENT, STANDALONE_COMMENT} and v.startswith("# type:" + suffix)
5009 def normalize_prefix(leaf: Leaf, *, inside_brackets: bool) -> None:
5010 """Leave existing extra newlines if not `inside_brackets`. Remove everything
5013 Note: don't use backslashes for formatting or you'll lose your voting rights.
5015 if not inside_brackets:
5016 spl = leaf.prefix.split("#")
5017 if "\\" not in spl[0]:
5018 nl_count = spl[-1].count("\n")
5021 leaf.prefix = "\n" * nl_count
5027 def normalize_string_prefix(leaf: Leaf, remove_u_prefix: bool = False) -> None:
5028 """Make all string prefixes lowercase.
5030 If remove_u_prefix is given, also removes any u prefix from the string.
5032 Note: Mutates its argument.
5034 match = re.match(r"^([" + STRING_PREFIX_CHARS + r"]*)(.*)$", leaf.value, re.DOTALL)
5035 assert match is not None, f"failed to match string {leaf.value!r}"
5036 orig_prefix = match.group(1)
5037 new_prefix = orig_prefix.replace("F", "f").replace("B", "b").replace("U", "u")
5039 new_prefix = new_prefix.replace("u", "")
5040 leaf.value = f"{new_prefix}{match.group(2)}"
5043 def normalize_string_quotes(leaf: Leaf) -> None:
5044 """Prefer double quotes but only if it doesn't cause more escaping.
5046 Adds or removes backslashes as appropriate. Doesn't parse and fix
5047 strings nested in f-strings (yet).
5049 Note: Mutates its argument.
5051 value = leaf.value.lstrip(STRING_PREFIX_CHARS)
5052 if value[:3] == '"""':
5055 elif value[:3] == "'''":
5058 elif value[0] == '"':
5064 first_quote_pos = leaf.value.find(orig_quote)
5065 if first_quote_pos == -1:
5066 return # There's an internal error
5068 prefix = leaf.value[:first_quote_pos]
5069 unescaped_new_quote = re.compile(rf"(([^\\]|^)(\\\\)*){new_quote}")
5070 escaped_new_quote = re.compile(rf"([^\\]|^)\\((?:\\\\)*){new_quote}")
5071 escaped_orig_quote = re.compile(rf"([^\\]|^)\\((?:\\\\)*){orig_quote}")
5072 body = leaf.value[first_quote_pos + len(orig_quote) : -len(orig_quote)]
5073 if "r" in prefix.casefold():
5074 if unescaped_new_quote.search(body):
5075 # There's at least one unescaped new_quote in this raw string
5076 # so converting is impossible
5079 # Do not introduce or remove backslashes in raw strings
5082 # remove unnecessary escapes
5083 new_body = sub_twice(escaped_new_quote, rf"\1\2{new_quote}", body)
5084 if body != new_body:
5085 # Consider the string without unnecessary escapes as the original
5087 leaf.value = f"{prefix}{orig_quote}{body}{orig_quote}"
5088 new_body = sub_twice(escaped_orig_quote, rf"\1\2{orig_quote}", new_body)
5089 new_body = sub_twice(unescaped_new_quote, rf"\1\\{new_quote}", new_body)
5090 if "f" in prefix.casefold():
5091 matches = re.findall(
5093 (?:[^{]|^)\{ # start of the string or a non-{ followed by a single {
5094 ([^{].*?) # contents of the brackets except if begins with {{
5095 \}(?:[^}]|$) # A } followed by end of the string or a non-}
5102 # Do not introduce backslashes in interpolated expressions
5105 if new_quote == '"""' and new_body[-1:] == '"':
5107 new_body = new_body[:-1] + '\\"'
5108 orig_escape_count = body.count("\\")
5109 new_escape_count = new_body.count("\\")
5110 if new_escape_count > orig_escape_count:
5111 return # Do not introduce more escaping
5113 if new_escape_count == orig_escape_count and orig_quote == '"':
5114 return # Prefer double quotes
5116 leaf.value = f"{prefix}{new_quote}{new_body}{new_quote}"
5119 def normalize_numeric_literal(leaf: Leaf) -> None:
5120 """Normalizes numeric (float, int, and complex) literals.
5122 All letters used in the representation are normalized to lowercase (except
5123 in Python 2 long literals).
5125 text = leaf.value.lower()
5126 if text.startswith(("0o", "0b")):
5127 # Leave octal and binary literals alone.
5129 elif text.startswith("0x"):
5130 # Change hex literals to upper case.
5131 before, after = text[:2], text[2:]
5132 text = f"{before}{after.upper()}"
5134 before, after = text.split("e")
5136 if after.startswith("-"):
5139 elif after.startswith("+"):
5141 before = format_float_or_int_string(before)
5142 text = f"{before}e{sign}{after}"
5143 elif text.endswith(("j", "l")):
5146 # Capitalize in "2L" because "l" looks too similar to "1".
5149 text = f"{format_float_or_int_string(number)}{suffix}"
5151 text = format_float_or_int_string(text)
5155 def format_float_or_int_string(text: str) -> str:
5156 """Formats a float string like "1.0"."""
5160 before, after = text.split(".")
5161 return f"{before or 0}.{after or 0}"
5164 def normalize_invisible_parens(node: Node, parens_after: Set[str]) -> None:
5165 """Make existing optional parentheses invisible or create new ones.
5167 `parens_after` is a set of string leaf values immediately after which parens
5170 Standardizes on visible parentheses for single-element tuples, and keeps
5171 existing visible parentheses for other tuples and generator expressions.
5173 for pc in list_comments(node.prefix, is_endmarker=False):
5174 if pc.value in FMT_OFF:
5175 # This `node` has a prefix with `# fmt: off`, don't mess with parens.
5178 for index, child in enumerate(list(node.children)):
5179 # Fixes a bug where invisible parens are not properly stripped from
5180 # assignment statements that contain type annotations.
5181 if isinstance(child, Node) and child.type == syms.annassign:
5182 normalize_invisible_parens(child, parens_after=parens_after)
5184 # Add parentheses around long tuple unpacking in assignments.
5187 and isinstance(child, Node)
5188 and child.type == syms.testlist_star_expr
5193 if is_walrus_assignment(child):
5196 if child.type == syms.atom:
5197 if maybe_make_parens_invisible_in_atom(child, parent=node):
5198 wrap_in_parentheses(node, child, visible=False)
5199 elif is_one_tuple(child):
5200 wrap_in_parentheses(node, child, visible=True)
5201 elif node.type == syms.import_from:
5202 # "import from" nodes store parentheses directly as part of
5204 if child.type == token.LPAR:
5205 # make parentheses invisible
5206 child.value = "" # type: ignore
5207 node.children[-1].value = "" # type: ignore
5208 elif child.type != token.STAR:
5209 # insert invisible parentheses
5210 node.insert_child(index, Leaf(token.LPAR, ""))
5211 node.append_child(Leaf(token.RPAR, ""))
5214 elif not (isinstance(child, Leaf) and is_multiline_string(child)):
5215 wrap_in_parentheses(node, child, visible=False)
5217 check_lpar = isinstance(child, Leaf) and child.value in parens_after
5220 def normalize_fmt_off(node: Node) -> None:
5221 """Convert content between `# fmt: off`/`# fmt: on` into standalone comments."""
5224 try_again = convert_one_fmt_off_pair(node)
5227 def convert_one_fmt_off_pair(node: Node) -> bool:
5228 """Convert content of a single `# fmt: off`/`# fmt: on` into a standalone comment.
5230 Returns True if a pair was converted.
5232 for leaf in node.leaves():
5233 previous_consumed = 0
5234 for comment in list_comments(leaf.prefix, is_endmarker=False):
5235 if comment.value in FMT_OFF:
5236 # We only want standalone comments. If there's no previous leaf or
5237 # the previous leaf is indentation, it's a standalone comment in
5239 if comment.type != STANDALONE_COMMENT:
5240 prev = preceding_leaf(leaf)
5241 if prev and prev.type not in WHITESPACE:
5244 ignored_nodes = list(generate_ignored_nodes(leaf))
5245 if not ignored_nodes:
5248 first = ignored_nodes[0] # Can be a container node with the `leaf`.
5249 parent = first.parent
5250 prefix = first.prefix
5251 first.prefix = prefix[comment.consumed :]
5253 comment.value + "\n" + "".join(str(n) for n in ignored_nodes)
5255 if hidden_value.endswith("\n"):
5256 # That happens when one of the `ignored_nodes` ended with a NEWLINE
5257 # leaf (possibly followed by a DEDENT).
5258 hidden_value = hidden_value[:-1]
5259 first_idx: Optional[int] = None
5260 for ignored in ignored_nodes:
5261 index = ignored.remove()
5262 if first_idx is None:
5264 assert parent is not None, "INTERNAL ERROR: fmt: on/off handling (1)"
5265 assert first_idx is not None, "INTERNAL ERROR: fmt: on/off handling (2)"
5266 parent.insert_child(
5271 prefix=prefix[:previous_consumed] + "\n" * comment.newlines,
5276 previous_consumed = comment.consumed
5281 def generate_ignored_nodes(leaf: Leaf) -> Iterator[LN]:
5282 """Starting from the container of `leaf`, generate all leaves until `# fmt: on`.
5284 Stops at the end of the block.
5286 container: Optional[LN] = container_of(leaf)
5287 while container is not None and container.type != token.ENDMARKER:
5288 if is_fmt_on(container):
5291 # fix for fmt: on in children
5292 if contains_fmt_on_at_column(container, leaf.column):
5293 for child in container.children:
5294 if contains_fmt_on_at_column(child, leaf.column):
5299 container = container.next_sibling
5302 def is_fmt_on(container: LN) -> bool:
5303 """Determine whether formatting is switched on within a container.
5304 Determined by whether the last `# fmt:` comment is `on` or `off`.
5307 for comment in list_comments(container.prefix, is_endmarker=False):
5308 if comment.value in FMT_ON:
5310 elif comment.value in FMT_OFF:
5315 def contains_fmt_on_at_column(container: LN, column: int) -> bool:
5316 """Determine if children at a given column have formatting switched on."""
5317 for child in container.children:
5319 isinstance(child, Node)
5320 and first_leaf_column(child) == column
5321 or isinstance(child, Leaf)
5322 and child.column == column
5324 if is_fmt_on(child):
5330 def first_leaf_column(node: Node) -> Optional[int]:
5331 """Returns the column of the first leaf child of a node."""
5332 for child in node.children:
5333 if isinstance(child, Leaf):
5338 def maybe_make_parens_invisible_in_atom(node: LN, parent: LN) -> bool:
5339 """If it's safe, make the parens in the atom `node` invisible, recursively.
5340 Additionally, remove repeated, adjacent invisible parens from the atom `node`
5341 as they are redundant.
5343 Returns whether the node should itself be wrapped in invisible parentheses.
5347 node.type != syms.atom
5348 or is_empty_tuple(node)
5349 or is_one_tuple(node)
5350 or (is_yield(node) and parent.type != syms.expr_stmt)
5351 or max_delimiter_priority_in_atom(node) >= COMMA_PRIORITY
5355 first = node.children[0]
5356 last = node.children[-1]
5357 if first.type == token.LPAR and last.type == token.RPAR:
5358 middle = node.children[1]
5359 # make parentheses invisible
5360 first.value = "" # type: ignore
5361 last.value = "" # type: ignore
5362 maybe_make_parens_invisible_in_atom(middle, parent=parent)
5364 if is_atom_with_invisible_parens(middle):
5365 # Strip the invisible parens from `middle` by replacing
5366 # it with the child in-between the invisible parens
5367 middle.replace(middle.children[1])
5374 def is_atom_with_invisible_parens(node: LN) -> bool:
5375 """Given a `LN`, determines whether it's an atom `node` with invisible
5376 parens. Useful in dedupe-ing and normalizing parens.
5378 if isinstance(node, Leaf) or node.type != syms.atom:
5381 first, last = node.children[0], node.children[-1]
5383 isinstance(first, Leaf)
5384 and first.type == token.LPAR
5385 and first.value == ""
5386 and isinstance(last, Leaf)
5387 and last.type == token.RPAR
5388 and last.value == ""
5392 def is_empty_tuple(node: LN) -> bool:
5393 """Return True if `node` holds an empty tuple."""
5395 node.type == syms.atom
5396 and len(node.children) == 2
5397 and node.children[0].type == token.LPAR
5398 and node.children[1].type == token.RPAR
5402 def unwrap_singleton_parenthesis(node: LN) -> Optional[LN]:
5403 """Returns `wrapped` if `node` is of the shape ( wrapped ).
5405 Parenthesis can be optional. Returns None otherwise"""
5406 if len(node.children) != 3:
5409 lpar, wrapped, rpar = node.children
5410 if not (lpar.type == token.LPAR and rpar.type == token.RPAR):
5416 def wrap_in_parentheses(parent: Node, child: LN, *, visible: bool = True) -> None:
5417 """Wrap `child` in parentheses.
5419 This replaces `child` with an atom holding the parentheses and the old
5420 child. That requires moving the prefix.
5422 If `visible` is False, the leaves will be valueless (and thus invisible).
5424 lpar = Leaf(token.LPAR, "(" if visible else "")
5425 rpar = Leaf(token.RPAR, ")" if visible else "")
5426 prefix = child.prefix
5428 index = child.remove() or 0
5429 new_child = Node(syms.atom, [lpar, child, rpar])
5430 new_child.prefix = prefix
5431 parent.insert_child(index, new_child)
5434 def is_one_tuple(node: LN) -> bool:
5435 """Return True if `node` holds a tuple with one element, with or without parens."""
5436 if node.type == syms.atom:
5437 gexp = unwrap_singleton_parenthesis(node)
5438 if gexp is None or gexp.type != syms.testlist_gexp:
5441 return len(gexp.children) == 2 and gexp.children[1].type == token.COMMA
5444 node.type in IMPLICIT_TUPLE
5445 and len(node.children) == 2
5446 and node.children[1].type == token.COMMA
5450 def is_walrus_assignment(node: LN) -> bool:
5451 """Return True iff `node` is of the shape ( test := test )"""
5452 inner = unwrap_singleton_parenthesis(node)
5453 return inner is not None and inner.type == syms.namedexpr_test
5456 def is_yield(node: LN) -> bool:
5457 """Return True if `node` holds a `yield` or `yield from` expression."""
5458 if node.type == syms.yield_expr:
5461 if node.type == token.NAME and node.value == "yield": # type: ignore
5464 if node.type != syms.atom:
5467 if len(node.children) != 3:
5470 lpar, expr, rpar = node.children
5471 if lpar.type == token.LPAR and rpar.type == token.RPAR:
5472 return is_yield(expr)
5477 def is_vararg(leaf: Leaf, within: Set[NodeType]) -> bool:
5478 """Return True if `leaf` is a star or double star in a vararg or kwarg.
5480 If `within` includes VARARGS_PARENTS, this applies to function signatures.
5481 If `within` includes UNPACKING_PARENTS, it applies to right hand-side
5482 extended iterable unpacking (PEP 3132) and additional unpacking
5483 generalizations (PEP 448).
5485 if leaf.type not in VARARGS_SPECIALS or not leaf.parent:
5489 if p.type == syms.star_expr:
5490 # Star expressions are also used as assignment targets in extended
5491 # iterable unpacking (PEP 3132). See what its parent is instead.
5497 return p.type in within
5500 def is_multiline_string(leaf: Leaf) -> bool:
5501 """Return True if `leaf` is a multiline string that actually spans many lines."""
5502 return has_triple_quotes(leaf.value) and "\n" in leaf.value
5505 def is_stub_suite(node: Node) -> bool:
5506 """Return True if `node` is a suite with a stub body."""
5508 len(node.children) != 4
5509 or node.children[0].type != token.NEWLINE
5510 or node.children[1].type != token.INDENT
5511 or node.children[3].type != token.DEDENT
5515 return is_stub_body(node.children[2])
5518 def is_stub_body(node: LN) -> bool:
5519 """Return True if `node` is a simple statement containing an ellipsis."""
5520 if not isinstance(node, Node) or node.type != syms.simple_stmt:
5523 if len(node.children) != 2:
5526 child = node.children[0]
5528 child.type == syms.atom
5529 and len(child.children) == 3
5530 and all(leaf == Leaf(token.DOT, ".") for leaf in child.children)
5534 def max_delimiter_priority_in_atom(node: LN) -> Priority:
5535 """Return maximum delimiter priority inside `node`.
5537 This is specific to atoms with contents contained in a pair of parentheses.
5538 If `node` isn't an atom or there are no enclosing parentheses, returns 0.
5540 if node.type != syms.atom:
5543 first = node.children[0]
5544 last = node.children[-1]
5545 if not (first.type == token.LPAR and last.type == token.RPAR):
5548 bt = BracketTracker()
5549 for c in node.children[1:-1]:
5550 if isinstance(c, Leaf):
5553 for leaf in c.leaves():
5556 return bt.max_delimiter_priority()
5562 def ensure_visible(leaf: Leaf) -> None:
5563 """Make sure parentheses are visible.
5565 They could be invisible as part of some statements (see
5566 :func:`normalize_invisible_parens` and :func:`visit_import_from`).
5568 if leaf.type == token.LPAR:
5570 elif leaf.type == token.RPAR:
5574 def should_split_body_explode(line: Line, opening_bracket: Leaf) -> bool:
5575 """Should `line` be immediately split with `delimiter_split()` after RHS?"""
5577 if not (opening_bracket.parent and opening_bracket.value in "[{("):
5580 # We're essentially checking if the body is delimited by commas and there's more
5581 # than one of them (we're excluding the trailing comma and if the delimiter priority
5582 # is still commas, that means there's more).
5584 trailing_comma = False
5586 last_leaf = line.leaves[-1]
5587 if last_leaf.type == token.COMMA:
5588 trailing_comma = True
5589 exclude.add(id(last_leaf))
5590 max_priority = line.bracket_tracker.max_delimiter_priority(exclude=exclude)
5591 except (IndexError, ValueError):
5594 return max_priority == COMMA_PRIORITY and (
5596 # always explode imports
5597 or opening_bracket.parent.type in {syms.atom, syms.import_from}
5601 def is_one_tuple_between(opening: Leaf, closing: Leaf, leaves: List[Leaf]) -> bool:
5602 """Return True if content between `opening` and `closing` looks like a one-tuple."""
5603 if opening.type != token.LPAR and closing.type != token.RPAR:
5606 depth = closing.bracket_depth + 1
5607 for _opening_index, leaf in enumerate(leaves):
5612 raise LookupError("Opening paren not found in `leaves`")
5616 for leaf in leaves[_opening_index:]:
5620 bracket_depth = leaf.bracket_depth
5621 if bracket_depth == depth and leaf.type == token.COMMA:
5623 if leaf.parent and leaf.parent.type in {
5633 def get_features_used(node: Node) -> Set[Feature]:
5634 """Return a set of (relatively) new Python features used in this file.
5636 Currently looking for:
5638 - underscores in numeric literals;
5639 - trailing commas after * or ** in function signatures and calls;
5640 - positional only arguments in function signatures and lambdas;
5642 features: Set[Feature] = set()
5643 for n in node.pre_order():
5644 if n.type == token.STRING:
5645 value_head = n.value[:2] # type: ignore
5646 if value_head in {'f"', 'F"', "f'", "F'", "rf", "fr", "RF", "FR"}:
5647 features.add(Feature.F_STRINGS)
5649 elif n.type == token.NUMBER:
5650 if "_" in n.value: # type: ignore
5651 features.add(Feature.NUMERIC_UNDERSCORES)
5653 elif n.type == token.SLASH:
5654 if n.parent and n.parent.type in {syms.typedargslist, syms.arglist}:
5655 features.add(Feature.POS_ONLY_ARGUMENTS)
5657 elif n.type == token.COLONEQUAL:
5658 features.add(Feature.ASSIGNMENT_EXPRESSIONS)
5661 n.type in {syms.typedargslist, syms.arglist}
5663 and n.children[-1].type == token.COMMA
5665 if n.type == syms.typedargslist:
5666 feature = Feature.TRAILING_COMMA_IN_DEF
5668 feature = Feature.TRAILING_COMMA_IN_CALL
5670 for ch in n.children:
5671 if ch.type in STARS:
5672 features.add(feature)
5674 if ch.type == syms.argument:
5675 for argch in ch.children:
5676 if argch.type in STARS:
5677 features.add(feature)
5682 def detect_target_versions(node: Node) -> Set[TargetVersion]:
5683 """Detect the version to target based on the nodes used."""
5684 features = get_features_used(node)
5686 version for version in TargetVersion if features <= VERSION_TO_FEATURES[version]
5690 def generate_trailers_to_omit(line: Line, line_length: int) -> Iterator[Set[LeafID]]:
5691 """Generate sets of closing bracket IDs that should be omitted in a RHS.
5693 Brackets can be omitted if the entire trailer up to and including
5694 a preceding closing bracket fits in one line.
5696 Yielded sets are cumulative (contain results of previous yields, too). First
5697 set is empty, unless the line should explode, in which case bracket pairs until
5698 the one that needs to explode are omitted.
5701 omit: Set[LeafID] = set()
5702 if not line.should_explode:
5705 length = 4 * line.depth
5706 opening_bracket: Optional[Leaf] = None
5707 closing_bracket: Optional[Leaf] = None
5708 inner_brackets: Set[LeafID] = set()
5709 for index, leaf, leaf_length in enumerate_with_length(line, reversed=True):
5710 length += leaf_length
5711 if length > line_length:
5714 has_inline_comment = leaf_length > len(leaf.value) + len(leaf.prefix)
5715 if leaf.type == STANDALONE_COMMENT or has_inline_comment:
5719 if leaf is opening_bracket:
5720 opening_bracket = None
5721 elif leaf.type in CLOSING_BRACKETS:
5722 prev = line.leaves[index - 1] if index > 0 else None
5726 and prev.type == token.COMMA
5727 and not is_one_tuple_between(
5728 leaf.opening_bracket, leaf, line.leaves
5731 # Never omit bracket pairs with trailing commas.
5732 # We need to explode on those.
5735 inner_brackets.add(id(leaf))
5736 elif leaf.type in CLOSING_BRACKETS:
5737 prev = line.leaves[index - 1] if index > 0 else None
5738 if prev and prev.type in OPENING_BRACKETS:
5739 # Empty brackets would fail a split so treat them as "inner"
5740 # brackets (e.g. only add them to the `omit` set if another
5741 # pair of brackets was good enough.
5742 inner_brackets.add(id(leaf))
5746 omit.add(id(closing_bracket))
5747 omit.update(inner_brackets)
5748 inner_brackets.clear()
5754 and prev.type == token.COMMA
5755 and not is_one_tuple_between(leaf.opening_bracket, leaf, line.leaves)
5757 # Never omit bracket pairs with trailing commas.
5758 # We need to explode on those.
5762 opening_bracket = leaf.opening_bracket
5763 closing_bracket = leaf
5766 def get_future_imports(node: Node) -> Set[str]:
5767 """Return a set of __future__ imports in the file."""
5768 imports: Set[str] = set()
5770 def get_imports_from_children(children: List[LN]) -> Generator[str, None, None]:
5771 for child in children:
5772 if isinstance(child, Leaf):
5773 if child.type == token.NAME:
5776 elif child.type == syms.import_as_name:
5777 orig_name = child.children[0]
5778 assert isinstance(orig_name, Leaf), "Invalid syntax parsing imports"
5779 assert orig_name.type == token.NAME, "Invalid syntax parsing imports"
5780 yield orig_name.value
5782 elif child.type == syms.import_as_names:
5783 yield from get_imports_from_children(child.children)
5786 raise AssertionError("Invalid syntax parsing imports")
5788 for child in node.children:
5789 if child.type != syms.simple_stmt:
5792 first_child = child.children[0]
5793 if isinstance(first_child, Leaf):
5794 # Continue looking if we see a docstring; otherwise stop.
5796 len(child.children) == 2
5797 and first_child.type == token.STRING
5798 and child.children[1].type == token.NEWLINE
5804 elif first_child.type == syms.import_from:
5805 module_name = first_child.children[1]
5806 if not isinstance(module_name, Leaf) or module_name.value != "__future__":
5809 imports |= set(get_imports_from_children(first_child.children[3:]))
5817 def get_gitignore(root: Path) -> PathSpec:
5818 """ Return a PathSpec matching gitignore content if present."""
5819 gitignore = root / ".gitignore"
5820 lines: List[str] = []
5821 if gitignore.is_file():
5822 with gitignore.open() as gf:
5823 lines = gf.readlines()
5824 return PathSpec.from_lines("gitwildmatch", lines)
5827 def normalize_path_maybe_ignore(
5828 path: Path, root: Path, report: "Report"
5830 """Normalize `path`. May return `None` if `path` was ignored.
5832 `report` is where "path ignored" output goes.
5835 normalized_path = path.resolve().relative_to(root).as_posix()
5836 except OSError as e:
5837 report.path_ignored(path, f"cannot be read because {e}")
5841 if path.is_symlink():
5842 report.path_ignored(path, f"is a symbolic link that points outside {root}")
5847 return normalized_path
5850 def gen_python_files(
5851 paths: Iterable[Path],
5853 include: Optional[Pattern[str]],
5854 exclude: Pattern[str],
5855 force_exclude: Optional[Pattern[str]],
5857 gitignore: PathSpec,
5858 ) -> Iterator[Path]:
5859 """Generate all files under `path` whose paths are not excluded by the
5860 `exclude_regex` or `force_exclude` regexes, but are included by the `include` regex.
5862 Symbolic links pointing outside of the `root` directory are ignored.
5864 `report` is where output about exclusions goes.
5866 assert root.is_absolute(), f"INTERNAL ERROR: `root` must be absolute but is {root}"
5868 normalized_path = normalize_path_maybe_ignore(child, root, report)
5869 if normalized_path is None:
5872 # First ignore files matching .gitignore
5873 if gitignore.match_file(normalized_path):
5874 report.path_ignored(child, "matches the .gitignore file content")
5877 # Then ignore with `--exclude` and `--force-exclude` options.
5878 normalized_path = "/" + normalized_path
5880 normalized_path += "/"
5882 exclude_match = exclude.search(normalized_path) if exclude else None
5883 if exclude_match and exclude_match.group(0):
5884 report.path_ignored(child, "matches the --exclude regular expression")
5887 force_exclude_match = (
5888 force_exclude.search(normalized_path) if force_exclude else None
5890 if force_exclude_match and force_exclude_match.group(0):
5891 report.path_ignored(child, "matches the --force-exclude regular expression")
5895 yield from gen_python_files(
5905 elif child.is_file():
5906 include_match = include.search(normalized_path) if include else True
5912 def find_project_root(srcs: Iterable[str]) -> Path:
5913 """Return a directory containing .git, .hg, or pyproject.toml.
5915 That directory will be a common parent of all files and directories
5918 If no directory in the tree contains a marker that would specify it's the
5919 project root, the root of the file system is returned.
5922 return Path("/").resolve()
5924 path_srcs = [Path(Path.cwd(), src).resolve() for src in srcs]
5926 # A list of lists of parents for each 'src'. 'src' is included as a
5927 # "parent" of itself if it is a directory
5929 list(path.parents) + ([path] if path.is_dir() else []) for path in path_srcs
5933 set.intersection(*(set(parents) for parents in src_parents)),
5934 key=lambda path: path.parts,
5937 for directory in (common_base, *common_base.parents):
5938 if (directory / ".git").exists():
5941 if (directory / ".hg").is_dir():
5944 if (directory / "pyproject.toml").is_file():
5952 """Provides a reformatting counter. Can be rendered with `str(report)`."""
5957 verbose: bool = False
5958 change_count: int = 0
5960 failure_count: int = 0
5962 def done(self, src: Path, changed: Changed) -> None:
5963 """Increment the counter for successful reformatting. Write out a message."""
5964 if changed is Changed.YES:
5965 reformatted = "would reformat" if self.check or self.diff else "reformatted"
5966 if self.verbose or not self.quiet:
5967 out(f"{reformatted} {src}")
5968 self.change_count += 1
5971 if changed is Changed.NO:
5972 msg = f"{src} already well formatted, good job."
5974 msg = f"{src} wasn't modified on disk since last run."
5975 out(msg, bold=False)
5976 self.same_count += 1
5978 def failed(self, src: Path, message: str) -> None:
5979 """Increment the counter for failed reformatting. Write out a message."""
5980 err(f"error: cannot format {src}: {message}")
5981 self.failure_count += 1
5983 def path_ignored(self, path: Path, message: str) -> None:
5985 out(f"{path} ignored: {message}", bold=False)
5988 def return_code(self) -> int:
5989 """Return the exit code that the app should use.
5991 This considers the current state of changed files and failures:
5992 - if there were any failures, return 123;
5993 - if any files were changed and --check is being used, return 1;
5994 - otherwise return 0.
5996 # According to http://tldp.org/LDP/abs/html/exitcodes.html starting with
5997 # 126 we have special return codes reserved by the shell.
5998 if self.failure_count:
6001 elif self.change_count and self.check:
6006 def __str__(self) -> str:
6007 """Render a color report of the current state.
6009 Use `click.unstyle` to remove colors.
6011 if self.check or self.diff:
6012 reformatted = "would be reformatted"
6013 unchanged = "would be left unchanged"
6014 failed = "would fail to reformat"
6016 reformatted = "reformatted"
6017 unchanged = "left unchanged"
6018 failed = "failed to reformat"
6020 if self.change_count:
6021 s = "s" if self.change_count > 1 else ""
6023 click.style(f"{self.change_count} file{s} {reformatted}", bold=True)
6026 s = "s" if self.same_count > 1 else ""
6027 report.append(f"{self.same_count} file{s} {unchanged}")
6028 if self.failure_count:
6029 s = "s" if self.failure_count > 1 else ""
6031 click.style(f"{self.failure_count} file{s} {failed}", fg="red")
6033 return ", ".join(report) + "."
6036 def parse_ast(src: str) -> Union[ast.AST, ast3.AST, ast27.AST]:
6037 filename = "<unknown>"
6038 if sys.version_info >= (3, 8):
6039 # TODO: support Python 4+ ;)
6040 for minor_version in range(sys.version_info[1], 4, -1):
6042 return ast.parse(src, filename, feature_version=(3, minor_version))
6046 for feature_version in (7, 6):
6048 return ast3.parse(src, filename, feature_version=feature_version)
6052 return ast27.parse(src)
6055 def _fixup_ast_constants(
6056 node: Union[ast.AST, ast3.AST, ast27.AST]
6057 ) -> Union[ast.AST, ast3.AST, ast27.AST]:
6058 """Map ast nodes deprecated in 3.8 to Constant."""
6059 if isinstance(node, (ast.Str, ast3.Str, ast27.Str, ast.Bytes, ast3.Bytes)):
6060 return ast.Constant(value=node.s)
6062 if isinstance(node, (ast.Num, ast3.Num, ast27.Num)):
6063 return ast.Constant(value=node.n)
6065 if isinstance(node, (ast.NameConstant, ast3.NameConstant)):
6066 return ast.Constant(value=node.value)
6072 node: Union[ast.AST, ast3.AST, ast27.AST], depth: int = 0
6074 """Simple visitor generating strings to compare ASTs by content."""
6076 node = _fixup_ast_constants(node)
6078 yield f"{' ' * depth}{node.__class__.__name__}("
6080 for field in sorted(node._fields): # noqa: F402
6081 # TypeIgnore has only one field 'lineno' which breaks this comparison
6082 type_ignore_classes = (ast3.TypeIgnore, ast27.TypeIgnore)
6083 if sys.version_info >= (3, 8):
6084 type_ignore_classes += (ast.TypeIgnore,)
6085 if isinstance(node, type_ignore_classes):
6089 value = getattr(node, field)
6090 except AttributeError:
6093 yield f"{' ' * (depth+1)}{field}="
6095 if isinstance(value, list):
6097 # Ignore nested tuples within del statements, because we may insert
6098 # parentheses and they change the AST.
6101 and isinstance(node, (ast.Delete, ast3.Delete, ast27.Delete))
6102 and isinstance(item, (ast.Tuple, ast3.Tuple, ast27.Tuple))
6104 for item in item.elts:
6105 yield from _stringify_ast(item, depth + 2)
6107 elif isinstance(item, (ast.AST, ast3.AST, ast27.AST)):
6108 yield from _stringify_ast(item, depth + 2)
6110 elif isinstance(value, (ast.AST, ast3.AST, ast27.AST)):
6111 yield from _stringify_ast(value, depth + 2)
6114 # Constant strings may be indented across newlines, if they are
6115 # docstrings; fold spaces after newlines when comparing. Similarly,
6116 # trailing and leading space may be removed.
6118 isinstance(node, ast.Constant)
6119 and field == "value"
6120 and isinstance(value, str)
6122 normalized = re.sub(r" *\n[ \t]*", "\n", value).strip()
6125 yield f"{' ' * (depth+2)}{normalized!r}, # {value.__class__.__name__}"
6127 yield f"{' ' * depth}) # /{node.__class__.__name__}"
6130 def assert_equivalent(src: str, dst: str) -> None:
6131 """Raise AssertionError if `src` and `dst` aren't equivalent."""
6133 src_ast = parse_ast(src)
6134 except Exception as exc:
6135 raise AssertionError(
6136 "cannot use --safe with this file; failed to parse source file. AST"
6137 f" error message: {exc}"
6141 dst_ast = parse_ast(dst)
6142 except Exception as exc:
6143 log = dump_to_file("".join(traceback.format_tb(exc.__traceback__)), dst)
6144 raise AssertionError(
6145 f"INTERNAL ERROR: Black produced invalid code: {exc}. Please report a bug"
6146 " on https://github.com/psf/black/issues. This invalid output might be"
6150 src_ast_str = "\n".join(_stringify_ast(src_ast))
6151 dst_ast_str = "\n".join(_stringify_ast(dst_ast))
6152 if src_ast_str != dst_ast_str:
6153 log = dump_to_file(diff(src_ast_str, dst_ast_str, "src", "dst"))
6154 raise AssertionError(
6155 "INTERNAL ERROR: Black produced code that is not equivalent to the"
6156 " source. Please report a bug on https://github.com/psf/black/issues. "
6157 f" This diff might be helpful: {log}"
6161 def assert_stable(src: str, dst: str, mode: Mode) -> None:
6162 """Raise AssertionError if `dst` reformats differently the second time."""
6163 newdst = format_str(dst, mode=mode)
6167 diff(src, dst, "source", "first pass"),
6168 diff(dst, newdst, "first pass", "second pass"),
6170 raise AssertionError(
6171 "INTERNAL ERROR: Black produced different code on the second pass of the"
6172 " formatter. Please report a bug on https://github.com/psf/black/issues."
6173 f" This diff might be helpful: {log}"
6177 @mypyc_attr(patchable=True)
6178 def dump_to_file(*output: str) -> str:
6179 """Dump `output` to a temporary file. Return path to the file."""
6180 with tempfile.NamedTemporaryFile(
6181 mode="w", prefix="blk_", suffix=".log", delete=False, encoding="utf8"
6183 for lines in output:
6185 if lines and lines[-1] != "\n":
6191 def nullcontext() -> Iterator[None]:
6192 """Return an empty context manager.
6194 To be used like `nullcontext` in Python 3.7.
6199 def diff(a: str, b: str, a_name: str, b_name: str) -> str:
6200 """Return a unified diff string between strings `a` and `b`."""
6203 a_lines = [line + "\n" for line in a.splitlines()]
6204 b_lines = [line + "\n" for line in b.splitlines()]
6206 difflib.unified_diff(a_lines, b_lines, fromfile=a_name, tofile=b_name, n=5)
6210 def cancel(tasks: Iterable["asyncio.Task[Any]"]) -> None:
6211 """asyncio signal handler that cancels all `tasks` and reports to stderr."""
6217 def shutdown(loop: asyncio.AbstractEventLoop) -> None:
6218 """Cancel all pending tasks on `loop`, wait for them, and close the loop."""
6220 if sys.version_info[:2] >= (3, 7):
6221 all_tasks = asyncio.all_tasks
6223 all_tasks = asyncio.Task.all_tasks
6224 # This part is borrowed from asyncio/runners.py in Python 3.7b2.
6225 to_cancel = [task for task in all_tasks(loop) if not task.done()]
6229 for task in to_cancel:
6231 loop.run_until_complete(
6232 asyncio.gather(*to_cancel, loop=loop, return_exceptions=True)
6235 # `concurrent.futures.Future` objects cannot be cancelled once they
6236 # are already running. There might be some when the `shutdown()` happened.
6237 # Silence their logger's spew about the event loop being closed.
6238 cf_logger = logging.getLogger("concurrent.futures")
6239 cf_logger.setLevel(logging.CRITICAL)
6243 def sub_twice(regex: Pattern[str], replacement: str, original: str) -> str:
6244 """Replace `regex` with `replacement` twice on `original`.
6246 This is used by string normalization to perform replaces on
6247 overlapping matches.
6249 return regex.sub(replacement, regex.sub(replacement, original))
6252 def re_compile_maybe_verbose(regex: str) -> Pattern[str]:
6253 """Compile a regular expression string in `regex`.
6255 If it contains newlines, use verbose mode.
6258 regex = "(?x)" + regex
6259 compiled: Pattern[str] = re.compile(regex)
6263 def enumerate_reversed(sequence: Sequence[T]) -> Iterator[Tuple[Index, T]]:
6264 """Like `reversed(enumerate(sequence))` if that were possible."""
6265 index = len(sequence) - 1
6266 for element in reversed(sequence):
6267 yield (index, element)
6271 def enumerate_with_length(
6272 line: Line, reversed: bool = False
6273 ) -> Iterator[Tuple[Index, Leaf, int]]:
6274 """Return an enumeration of leaves with their length.
6276 Stops prematurely on multiline strings and standalone comments.
6279 Callable[[Sequence[Leaf]], Iterator[Tuple[Index, Leaf]]],
6280 enumerate_reversed if reversed else enumerate,
6282 for index, leaf in op(line.leaves):
6283 length = len(leaf.prefix) + len(leaf.value)
6284 if "\n" in leaf.value:
6285 return # Multiline strings, we can't continue.
6287 for comment in line.comments_after(leaf):
6288 length += len(comment.value)
6290 yield index, leaf, length
6293 def is_line_short_enough(line: Line, *, line_length: int, line_str: str = "") -> bool:
6294 """Return True if `line` is no longer than `line_length`.
6296 Uses the provided `line_str` rendering, if any, otherwise computes a new one.
6299 line_str = line_to_string(line)
6301 len(line_str) <= line_length
6302 and "\n" not in line_str # multiline strings
6303 and not line.contains_standalone_comments()
6307 def can_be_split(line: Line) -> bool:
6308 """Return False if the line cannot be split *for sure*.
6310 This is not an exhaustive search but a cheap heuristic that we can use to
6311 avoid some unfortunate formattings (mostly around wrapping unsplittable code
6312 in unnecessary parentheses).
6314 leaves = line.leaves
6318 if leaves[0].type == token.STRING and leaves[1].type == token.DOT:
6322 for leaf in leaves[-2::-1]:
6323 if leaf.type in OPENING_BRACKETS:
6324 if next.type not in CLOSING_BRACKETS:
6328 elif leaf.type == token.DOT:
6330 elif leaf.type == token.NAME:
6331 if not (next.type == token.DOT or next.type in OPENING_BRACKETS):
6334 elif leaf.type not in CLOSING_BRACKETS:
6337 if dot_count > 1 and call_count > 1:
6343 def can_omit_invisible_parens(
6346 omit_on_explode: Collection[LeafID] = (),
6348 """Does `line` have a shape safe to reformat without optional parens around it?
6350 Returns True for only a subset of potentially nice looking formattings but
6351 the point is to not return false positives that end up producing lines that
6354 bt = line.bracket_tracker
6355 if not bt.delimiters:
6356 # Without delimiters the optional parentheses are useless.
6359 max_priority = bt.max_delimiter_priority()
6360 if bt.delimiter_count_with_priority(max_priority) > 1:
6361 # With more than one delimiter of a kind the optional parentheses read better.
6364 if max_priority == DOT_PRIORITY:
6365 # A single stranded method call doesn't require optional parentheses.
6368 assert len(line.leaves) >= 2, "Stranded delimiter"
6370 # With a single delimiter, omit if the expression starts or ends with
6372 first = line.leaves[0]
6373 second = line.leaves[1]
6374 if first.type in OPENING_BRACKETS and second.type not in CLOSING_BRACKETS:
6375 if _can_omit_opening_paren(line, first=first, line_length=line_length):
6378 # Note: we are not returning False here because a line might have *both*
6379 # a leading opening bracket and a trailing closing bracket. If the
6380 # opening bracket doesn't match our rule, maybe the closing will.
6382 penultimate = line.leaves[-2]
6383 last = line.leaves[-1]
6384 if line.should_explode:
6386 penultimate, last = last_two_except(line.leaves, omit=omit_on_explode)
6388 # Turns out we'd omit everything. We cannot skip the optional parentheses.
6392 last.type == token.RPAR
6393 or last.type == token.RBRACE
6395 # don't use indexing for omitting optional parentheses;
6397 last.type == token.RSQB
6399 and last.parent.type != syms.trailer
6402 if penultimate.type in OPENING_BRACKETS:
6403 # Empty brackets don't help.
6406 if is_multiline_string(first):
6407 # Additional wrapping of a multiline string in this situation is
6411 if line.should_explode and penultimate.type == token.COMMA:
6412 # The rightmost non-omitted bracket pair is the one we want to explode on.
6415 if _can_omit_closing_paren(line, last=last, line_length=line_length):
6421 def _can_omit_opening_paren(line: Line, *, first: Leaf, line_length: int) -> bool:
6422 """See `can_omit_invisible_parens`."""
6424 length = 4 * line.depth
6426 for _index, leaf, leaf_length in enumerate_with_length(line):
6427 if leaf.type in CLOSING_BRACKETS and leaf.opening_bracket is first:
6430 length += leaf_length
6431 if length > line_length:
6434 if leaf.type in OPENING_BRACKETS:
6435 # There are brackets we can further split on.
6439 # checked the entire string and line length wasn't exceeded
6440 if len(line.leaves) == _index + 1:
6446 def _can_omit_closing_paren(line: Line, *, last: Leaf, line_length: int) -> bool:
6447 """See `can_omit_invisible_parens`."""
6448 length = 4 * line.depth
6449 seen_other_brackets = False
6450 for _index, leaf, leaf_length in enumerate_with_length(line):
6451 length += leaf_length
6452 if leaf is last.opening_bracket:
6453 if seen_other_brackets or length <= line_length:
6456 elif leaf.type in OPENING_BRACKETS:
6457 # There are brackets we can further split on.
6458 seen_other_brackets = True
6463 def last_two_except(leaves: List[Leaf], omit: Collection[LeafID]) -> Tuple[Leaf, Leaf]:
6464 """Return (penultimate, last) leaves skipping brackets in `omit` and contents."""
6467 for leaf in reversed(leaves):
6469 if leaf is stop_after:
6476 if id(leaf) in omit:
6477 stop_after = leaf.opening_bracket
6481 raise LookupError("Last two leaves were also skipped")
6484 def run_transformer(
6486 transform: Transformer,
6488 features: Collection[Feature],
6493 line_str = line_to_string(line)
6494 result: List[Line] = []
6495 for transformed_line in transform(line, features):
6496 if str(transformed_line).strip("\n") == line_str:
6497 raise CannotTransform("Line transformer returned an unchanged result")
6499 result.extend(transform_line(transformed_line, mode=mode, features=features))
6502 transform.__name__ == "rhs"
6503 and line.bracket_tracker.invisible
6504 and not any(bracket.value for bracket in line.bracket_tracker.invisible)
6505 and not line.contains_multiline_strings()
6506 and not result[0].contains_uncollapsable_type_comments()
6507 and not result[0].contains_unsplittable_type_ignore()
6508 and not is_line_short_enough(result[0], line_length=mode.line_length)
6512 line_copy = line.clone()
6513 append_leaves(line_copy, line, line.leaves)
6514 features_fop = set(features) | {Feature.FORCE_OPTIONAL_PARENTHESES}
6515 second_opinion = run_transformer(
6516 line_copy, transform, mode, features_fop, line_str=line_str
6519 is_line_short_enough(ln, line_length=mode.line_length) for ln in second_opinion
6521 result = second_opinion
6525 def get_cache_file(mode: Mode) -> Path:
6526 return CACHE_DIR / f"cache.{mode.get_cache_key()}.pickle"
6529 def read_cache(mode: Mode) -> Cache:
6530 """Read the cache if it exists and is well formed.
6532 If it is not well formed, the call to write_cache later should resolve the issue.
6534 cache_file = get_cache_file(mode)
6535 if not cache_file.exists():
6538 with cache_file.open("rb") as fobj:
6540 cache: Cache = pickle.load(fobj)
6541 except (pickle.UnpicklingError, ValueError):
6547 def get_cache_info(path: Path) -> CacheInfo:
6548 """Return the information used to check if a file is already formatted or not."""
6550 return stat.st_mtime, stat.st_size
6553 def filter_cached(cache: Cache, sources: Iterable[Path]) -> Tuple[Set[Path], Set[Path]]:
6554 """Split an iterable of paths in `sources` into two sets.
6556 The first contains paths of files that modified on disk or are not in the
6557 cache. The other contains paths to non-modified files.
6559 todo, done = set(), set()
6562 if cache.get(src) != get_cache_info(src):
6569 def write_cache(cache: Cache, sources: Iterable[Path], mode: Mode) -> None:
6570 """Update the cache file."""
6571 cache_file = get_cache_file(mode)
6573 CACHE_DIR.mkdir(parents=True, exist_ok=True)
6574 new_cache = {**cache, **{src.resolve(): get_cache_info(src) for src in sources}}
6575 with tempfile.NamedTemporaryFile(dir=str(cache_file.parent), delete=False) as f:
6576 pickle.dump(new_cache, f, protocol=4)
6577 os.replace(f.name, cache_file)
6582 def patch_click() -> None:
6583 """Make Click not crash.
6585 On certain misconfigured environments, Python 3 selects the ASCII encoding as the
6586 default which restricts paths that it can access during the lifetime of the
6587 application. Click refuses to work in this scenario by raising a RuntimeError.
6589 In case of Black the likelihood that non-ASCII characters are going to be used in
6590 file paths is minimal since it's Python source code. Moreover, this crash was
6591 spurious on Python 3.7 thanks to PEP 538 and PEP 540.
6594 from click import core
6595 from click import _unicodefun # type: ignore
6596 except ModuleNotFoundError:
6599 for module in (core, _unicodefun):
6600 if hasattr(module, "_verify_python3_env"):
6601 module._verify_python3_env = lambda: None
6604 def patched_main() -> None:
6610 def is_docstring(leaf: Leaf) -> bool:
6611 if not is_multiline_string(leaf):
6612 # For the purposes of docstring re-indentation, we don't need to do anything
6613 # with single-line docstrings.
6616 if prev_siblings_are(
6617 leaf.parent, [None, token.NEWLINE, token.INDENT, syms.simple_stmt]
6621 # Multiline docstring on the same line as the `def`.
6622 if prev_siblings_are(leaf.parent, [syms.parameters, token.COLON, syms.simple_stmt]):
6623 # `syms.parameters` is only used in funcdefs and async_funcdefs in the Python
6624 # grammar. We're safe to return True without further checks.
6630 def fix_docstring(docstring: str, prefix: str) -> str:
6631 # https://www.python.org/dev/peps/pep-0257/#handling-docstring-indentation
6634 # Convert tabs to spaces (following the normal Python rules)
6635 # and split into a list of lines:
6636 lines = docstring.expandtabs().splitlines()
6637 # Determine minimum indentation (first line doesn't count):
6638 indent = sys.maxsize
6639 for line in lines[1:]:
6640 stripped = line.lstrip()
6642 indent = min(indent, len(line) - len(stripped))
6643 # Remove indentation (first line is special):
6644 trimmed = [lines[0].strip()]
6645 if indent < sys.maxsize:
6646 last_line_idx = len(lines) - 2
6647 for i, line in enumerate(lines[1:]):
6648 stripped_line = line[indent:].rstrip()
6649 if stripped_line or i == last_line_idx:
6650 trimmed.append(prefix + stripped_line)
6653 return "\n".join(trimmed)
6656 if __name__ == "__main__":