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 mypy_extensions import mypyc_attr
47 from appdirs import user_cache_dir
48 from dataclasses import dataclass, field, replace
53 from typed_ast import ast3, ast27
55 if sys.version_info < (3, 8):
57 "The typed_ast package is not installed.\n"
58 "You can install it with `python3 -m pip install typed-ast`.",
65 from pathspec import PathSpec
68 from blib2to3.pytree import Node, Leaf, type_repr
69 from blib2to3 import pygram, pytree
70 from blib2to3.pgen2 import driver, token
71 from blib2to3.pgen2.grammar import Grammar
72 from blib2to3.pgen2.parse import ParseError
74 from _black_version import version as __version__
76 if sys.version_info < (3, 8):
77 from typing_extensions import Final
79 from typing import Final
82 import colorama # noqa: F401
84 DEFAULT_LINE_LENGTH = 88
85 DEFAULT_EXCLUDES = r"/(\.direnv|\.eggs|\.git|\.hg|\.mypy_cache|\.nox|\.tox|\.venv|venv|\.svn|_build|buck-out|build|dist)/" # noqa: B950
86 DEFAULT_INCLUDES = r"\.pyi?$"
87 CACHE_DIR = Path(user_cache_dir("black", version=__version__))
88 STDIN_PLACEHOLDER = "__BLACK_STDIN_FILENAME__"
90 STRING_PREFIX_CHARS: Final = "furbFURB" # All possible string prefix characters.
104 LN = Union[Leaf, Node]
105 Transformer = Callable[["Line", Collection["Feature"]], Iterator["Line"]]
108 CacheInfo = Tuple[Timestamp, FileSize]
109 Cache = Dict[str, CacheInfo]
110 out = partial(click.secho, bold=True, err=True)
111 err = partial(click.secho, fg="red", err=True)
113 pygram.initialize(CACHE_DIR)
114 syms = pygram.python_symbols
117 class NothingChanged(UserWarning):
118 """Raised when reformatted code is the same as source."""
121 class CannotTransform(Exception):
122 """Base class for errors raised by Transformers."""
125 class CannotSplit(CannotTransform):
126 """A readable split that fits the allotted line length is impossible."""
129 class InvalidInput(ValueError):
130 """Raised when input source code fails all parse attempts."""
133 class BracketMatchError(KeyError):
134 """Raised when an opening bracket is unable to be matched to a closing bracket."""
138 E = TypeVar("E", bound=Exception)
141 class Ok(Generic[T]):
142 def __init__(self, value: T) -> None:
149 class Err(Generic[E]):
150 def __init__(self, e: E) -> None:
157 # The 'Result' return type is used to implement an error-handling model heavily
158 # influenced by that used by the Rust programming language
159 # (see https://doc.rust-lang.org/book/ch09-00-error-handling.html).
160 Result = Union[Ok[T], Err[E]]
161 TResult = Result[T, CannotTransform] # (T)ransform Result
162 TMatchResult = TResult[Index]
165 class WriteBack(Enum):
173 def from_configuration(
174 cls, *, check: bool, diff: bool, color: bool = False
176 if check and not diff:
180 return cls.COLOR_DIFF
182 return cls.DIFF if diff else cls.YES
191 class TargetVersion(Enum):
201 def is_python2(self) -> bool:
202 return self is TargetVersion.PY27
206 # All string literals are unicode
209 NUMERIC_UNDERSCORES = 3
210 TRAILING_COMMA_IN_CALL = 4
211 TRAILING_COMMA_IN_DEF = 5
212 # The following two feature-flags are mutually exclusive, and exactly one should be
213 # set for every version of python.
214 ASYNC_IDENTIFIERS = 6
216 ASSIGNMENT_EXPRESSIONS = 8
217 POS_ONLY_ARGUMENTS = 9
218 RELAXED_DECORATORS = 10
219 FORCE_OPTIONAL_PARENTHESES = 50
222 VERSION_TO_FEATURES: Dict[TargetVersion, Set[Feature]] = {
223 TargetVersion.PY27: {Feature.ASYNC_IDENTIFIERS},
224 TargetVersion.PY33: {Feature.UNICODE_LITERALS, Feature.ASYNC_IDENTIFIERS},
225 TargetVersion.PY34: {Feature.UNICODE_LITERALS, Feature.ASYNC_IDENTIFIERS},
226 TargetVersion.PY35: {
227 Feature.UNICODE_LITERALS,
228 Feature.TRAILING_COMMA_IN_CALL,
229 Feature.ASYNC_IDENTIFIERS,
231 TargetVersion.PY36: {
232 Feature.UNICODE_LITERALS,
234 Feature.NUMERIC_UNDERSCORES,
235 Feature.TRAILING_COMMA_IN_CALL,
236 Feature.TRAILING_COMMA_IN_DEF,
237 Feature.ASYNC_IDENTIFIERS,
239 TargetVersion.PY37: {
240 Feature.UNICODE_LITERALS,
242 Feature.NUMERIC_UNDERSCORES,
243 Feature.TRAILING_COMMA_IN_CALL,
244 Feature.TRAILING_COMMA_IN_DEF,
245 Feature.ASYNC_KEYWORDS,
247 TargetVersion.PY38: {
248 Feature.UNICODE_LITERALS,
250 Feature.NUMERIC_UNDERSCORES,
251 Feature.TRAILING_COMMA_IN_CALL,
252 Feature.TRAILING_COMMA_IN_DEF,
253 Feature.ASYNC_KEYWORDS,
254 Feature.ASSIGNMENT_EXPRESSIONS,
255 Feature.POS_ONLY_ARGUMENTS,
257 TargetVersion.PY39: {
258 Feature.UNICODE_LITERALS,
260 Feature.NUMERIC_UNDERSCORES,
261 Feature.TRAILING_COMMA_IN_CALL,
262 Feature.TRAILING_COMMA_IN_DEF,
263 Feature.ASYNC_KEYWORDS,
264 Feature.ASSIGNMENT_EXPRESSIONS,
265 Feature.RELAXED_DECORATORS,
266 Feature.POS_ONLY_ARGUMENTS,
273 target_versions: Set[TargetVersion] = field(default_factory=set)
274 line_length: int = DEFAULT_LINE_LENGTH
275 string_normalization: bool = True
277 magic_trailing_comma: bool = True
278 experimental_string_processing: bool = False
280 def get_cache_key(self) -> str:
281 if self.target_versions:
282 version_str = ",".join(
284 for version in sorted(self.target_versions, key=lambda v: v.value)
290 str(self.line_length),
291 str(int(self.string_normalization)),
292 str(int(self.is_pyi)),
293 str(int(self.magic_trailing_comma)),
294 str(int(self.experimental_string_processing)),
296 return ".".join(parts)
299 # Legacy name, left for integrations.
303 def supports_feature(target_versions: Set[TargetVersion], feature: Feature) -> bool:
304 return all(feature in VERSION_TO_FEATURES[version] for version in target_versions)
307 def find_pyproject_toml(path_search_start: Tuple[str, ...]) -> Optional[str]:
308 """Find the absolute filepath to a pyproject.toml if it exists"""
309 path_project_root = find_project_root(path_search_start)
310 path_pyproject_toml = path_project_root / "pyproject.toml"
311 if path_pyproject_toml.is_file():
312 return str(path_pyproject_toml)
315 path_user_pyproject_toml = find_user_pyproject_toml()
317 str(path_user_pyproject_toml)
318 if path_user_pyproject_toml.is_file()
321 except PermissionError as e:
322 # We do not have access to the user-level config directory, so ignore it.
323 err(f"Ignoring user configuration directory due to {e!r}")
327 def parse_pyproject_toml(path_config: str) -> Dict[str, Any]:
328 """Parse a pyproject toml file, pulling out relevant parts for Black
330 If parsing fails, will raise a toml.TomlDecodeError
332 pyproject_toml = toml.load(path_config)
333 config = pyproject_toml.get("tool", {}).get("black", {})
334 return {k.replace("--", "").replace("-", "_"): v for k, v in config.items()}
337 def read_pyproject_toml(
338 ctx: click.Context, param: click.Parameter, value: Optional[str]
340 """Inject Black configuration from "pyproject.toml" into defaults in `ctx`.
342 Returns the path to a successfully found and read configuration file, None
346 value = find_pyproject_toml(ctx.params.get("src", ()))
351 config = parse_pyproject_toml(value)
352 except (toml.TomlDecodeError, OSError) as e:
353 raise click.FileError(
354 filename=value, hint=f"Error reading configuration file: {e}"
360 # Sanitize the values to be Click friendly. For more information please see:
361 # https://github.com/psf/black/issues/1458
362 # https://github.com/pallets/click/issues/1567
364 k: str(v) if not isinstance(v, (list, dict)) else v
365 for k, v in config.items()
368 target_version = config.get("target_version")
369 if target_version is not None and not isinstance(target_version, list):
370 raise click.BadOptionUsage(
371 "target-version", "Config key target-version must be a list"
374 default_map: Dict[str, Any] = {}
376 default_map.update(ctx.default_map)
377 default_map.update(config)
379 ctx.default_map = default_map
383 def target_version_option_callback(
384 c: click.Context, p: Union[click.Option, click.Parameter], v: Tuple[str, ...]
385 ) -> List[TargetVersion]:
386 """Compute the target versions from a --target-version flag.
388 This is its own function because mypy couldn't infer the type correctly
389 when it was a lambda, causing mypyc trouble.
391 return [TargetVersion[val.upper()] for val in v]
396 param: click.Parameter,
397 value: Optional[str],
398 ) -> Optional[Pattern]:
400 return re_compile_maybe_verbose(value) if value is not None else None
402 raise click.BadParameter("Not a valid regular expression")
405 @click.command(context_settings=dict(help_option_names=["-h", "--help"]))
406 @click.option("-c", "--code", type=str, help="Format the code passed in as a string.")
411 default=DEFAULT_LINE_LENGTH,
412 help="How many characters per line to allow.",
418 type=click.Choice([v.name.lower() for v in TargetVersion]),
419 callback=target_version_option_callback,
422 "Python versions that should be supported by Black's output. [default: per-file"
430 "Format all input files like typing stubs regardless of file extension (useful"
431 " when piping source on standard input)."
436 "--skip-string-normalization",
438 help="Don't normalize string quotes or prefixes.",
442 "--skip-magic-trailing-comma",
444 help="Don't use trailing commas as a reason to split lines.",
447 "--experimental-string-processing",
451 "Experimental option that performs more normalization on string literals."
452 " Currently disabled because it leads to some crashes."
459 "Don't write the files back, just return the status. Return code 0 means"
460 " nothing would change. Return code 1 means some files would be reformatted."
461 " Return code 123 means there was an internal error."
467 help="Don't write the files back, just output a diff for each file on stdout.",
470 "--color/--no-color",
472 help="Show colored diff. Only applies when `--diff` is given.",
477 help="If --fast given, skip temporary sanity checks. [default: --safe]",
482 default=DEFAULT_INCLUDES,
483 callback=validate_regex,
485 "A regular expression that matches files and directories that should be"
486 " included on recursive searches. An empty value means all files are included"
487 " regardless of the name. Use forward slashes for directories on all platforms"
488 " (Windows, too). Exclusions are calculated first, inclusions later."
495 default=DEFAULT_EXCLUDES,
496 callback=validate_regex,
498 "A regular expression that matches files and directories that should be"
499 " excluded on recursive searches. An empty value means no paths are excluded."
500 " Use forward slashes for directories on all platforms (Windows, too)."
501 " Exclusions are calculated first, inclusions later."
508 callback=validate_regex,
510 "Like --exclude, but adds additional files and directories on top of the"
511 " excluded ones. (Useful if you simply want to add to the default)"
517 callback=validate_regex,
519 "Like --exclude, but files and directories matching this regex will be "
520 "excluded even when they are passed explicitly as arguments."
527 "The name of the file when passing it through stdin. Useful to make "
528 "sure Black will respect --force-exclude option on some "
529 "editors that rely on using stdin."
537 "Don't emit non-error messages to stderr. Errors are still emitted; silence"
538 " those with 2>/dev/null."
546 "Also emit messages to stderr about files that were not changed or were ignored"
547 " due to exclusion patterns."
550 @click.version_option(version=__version__)
555 exists=True, file_okay=True, dir_okay=True, readable=True, allow_dash=True
570 callback=read_pyproject_toml,
571 help="Read configuration from FILE path.",
578 target_version: List[TargetVersion],
584 skip_string_normalization: bool,
585 skip_magic_trailing_comma: bool,
586 experimental_string_processing: bool,
591 extend_exclude: Optional[Pattern],
592 force_exclude: Optional[Pattern],
593 stdin_filename: Optional[str],
594 src: Tuple[str, ...],
595 config: Optional[str],
597 """The uncompromising code formatter."""
598 write_back = WriteBack.from_configuration(check=check, diff=diff, color=color)
600 versions = set(target_version)
602 # We'll autodetect later.
605 target_versions=versions,
606 line_length=line_length,
608 string_normalization=not skip_string_normalization,
609 magic_trailing_comma=not skip_magic_trailing_comma,
610 experimental_string_processing=experimental_string_processing,
612 if config and verbose:
613 out(f"Using configuration from {config}.", bold=False, fg="blue")
615 print(format_str(code, mode=mode))
617 report = Report(check=check, diff=diff, quiet=quiet, verbose=verbose)
618 sources = get_sources(
625 extend_exclude=extend_exclude,
626 force_exclude=force_exclude,
628 stdin_filename=stdin_filename,
633 "No Python files are present to be formatted. Nothing to do 😴",
639 if len(sources) == 1:
643 write_back=write_back,
649 sources=sources, fast=fast, write_back=write_back, mode=mode, report=report
652 if verbose or not quiet:
653 out("Oh no! 💥 💔 💥" if report.return_code else "All done! ✨ 🍰 ✨")
654 click.secho(str(report), err=True)
655 ctx.exit(report.return_code)
661 src: Tuple[str, ...],
664 include: Pattern[str],
665 exclude: Pattern[str],
666 extend_exclude: Optional[Pattern[str]],
667 force_exclude: Optional[Pattern[str]],
669 stdin_filename: Optional[str],
671 """Compute the set of files to be formatted."""
673 root = find_project_root(src)
674 sources: Set[Path] = set()
675 path_empty(src, "No Path provided. Nothing to do 😴", quiet, verbose, ctx)
676 gitignore = get_gitignore(root)
679 if s == "-" and stdin_filename:
680 p = Path(stdin_filename)
686 if is_stdin or p.is_file():
687 normalized_path = normalize_path_maybe_ignore(p, root, report)
688 if normalized_path is None:
691 normalized_path = "/" + normalized_path
692 # Hard-exclude any files that matches the `--force-exclude` regex.
694 force_exclude_match = force_exclude.search(normalized_path)
696 force_exclude_match = None
697 if force_exclude_match and force_exclude_match.group(0):
698 report.path_ignored(p, "matches the --force-exclude regular expression")
702 p = Path(f"{STDIN_PLACEHOLDER}{str(p)}")
721 err(f"invalid path: {s}")
726 src: Sized, msg: str, quiet: bool, verbose: bool, ctx: click.Context
729 Exit if there is no `src` provided for formatting
731 if not src and (verbose or not quiet):
737 src: Path, fast: bool, write_back: WriteBack, mode: Mode, report: "Report"
739 """Reformat a single file under `src` without spawning child processes.
741 `fast`, `write_back`, and `mode` options are passed to
742 :func:`format_file_in_place` or :func:`format_stdin_to_stdout`.
749 elif str(src).startswith(STDIN_PLACEHOLDER):
751 # Use the original name again in case we want to print something
753 src = Path(str(src)[len(STDIN_PLACEHOLDER) :])
758 if src.suffix == ".pyi":
759 mode = replace(mode, is_pyi=True)
760 if format_stdin_to_stdout(fast=fast, write_back=write_back, mode=mode):
761 changed = Changed.YES
764 if write_back not in (WriteBack.DIFF, WriteBack.COLOR_DIFF):
765 cache = read_cache(mode)
766 res_src = src.resolve()
767 res_src_s = str(res_src)
768 if res_src_s in cache and cache[res_src_s] == get_cache_info(res_src):
769 changed = Changed.CACHED
770 if changed is not Changed.CACHED and format_file_in_place(
771 src, fast=fast, write_back=write_back, mode=mode
773 changed = Changed.YES
774 if (write_back is WriteBack.YES and changed is not Changed.CACHED) or (
775 write_back is WriteBack.CHECK and changed is Changed.NO
777 write_cache(cache, [src], mode)
778 report.done(src, changed)
779 except Exception as exc:
781 traceback.print_exc()
782 report.failed(src, str(exc))
786 sources: Set[Path], fast: bool, write_back: WriteBack, mode: Mode, report: "Report"
788 """Reformat multiple files using a ProcessPoolExecutor."""
790 loop = asyncio.get_event_loop()
791 worker_count = os.cpu_count()
792 if sys.platform == "win32":
793 # Work around https://bugs.python.org/issue26903
794 worker_count = min(worker_count, 60)
796 executor = ProcessPoolExecutor(max_workers=worker_count)
797 except (ImportError, OSError):
798 # we arrive here if the underlying system does not support multi-processing
799 # like in AWS Lambda or Termux, in which case we gracefully fallback to
800 # a ThreadPoolExecutor with just a single worker (more workers would not do us
801 # any good due to the Global Interpreter Lock)
802 executor = ThreadPoolExecutor(max_workers=1)
805 loop.run_until_complete(
809 write_back=write_back,
818 if executor is not None:
822 async def schedule_formatting(
825 write_back: WriteBack,
828 loop: asyncio.AbstractEventLoop,
831 """Run formatting of `sources` in parallel using the provided `executor`.
833 (Use ProcessPoolExecutors for actual parallelism.)
835 `write_back`, `fast`, and `mode` options are passed to
836 :func:`format_file_in_place`.
839 if write_back not in (WriteBack.DIFF, WriteBack.COLOR_DIFF):
840 cache = read_cache(mode)
841 sources, cached = filter_cached(cache, sources)
842 for src in sorted(cached):
843 report.done(src, Changed.CACHED)
848 sources_to_cache = []
850 if write_back in (WriteBack.DIFF, WriteBack.COLOR_DIFF):
851 # For diff output, we need locks to ensure we don't interleave output
852 # from different processes.
854 lock = manager.Lock()
856 asyncio.ensure_future(
857 loop.run_in_executor(
858 executor, format_file_in_place, src, fast, mode, write_back, lock
861 for src in sorted(sources)
863 pending = tasks.keys()
865 loop.add_signal_handler(signal.SIGINT, cancel, pending)
866 loop.add_signal_handler(signal.SIGTERM, cancel, pending)
867 except NotImplementedError:
868 # There are no good alternatives for these on Windows.
871 done, _ = await asyncio.wait(pending, return_when=asyncio.FIRST_COMPLETED)
873 src = tasks.pop(task)
875 cancelled.append(task)
876 elif task.exception():
877 report.failed(src, str(task.exception()))
879 changed = Changed.YES if task.result() else Changed.NO
880 # If the file was written back or was successfully checked as
881 # well-formatted, store this information in the cache.
882 if write_back is WriteBack.YES or (
883 write_back is WriteBack.CHECK and changed is Changed.NO
885 sources_to_cache.append(src)
886 report.done(src, changed)
888 await asyncio.gather(*cancelled, loop=loop, return_exceptions=True)
890 write_cache(cache, sources_to_cache, mode)
893 def format_file_in_place(
897 write_back: WriteBack = WriteBack.NO,
898 lock: Any = None, # multiprocessing.Manager().Lock() is some crazy proxy
900 """Format file under `src` path. Return True if changed.
902 If `write_back` is DIFF, write a diff to stdout. If it is YES, write reformatted
904 `mode` and `fast` options are passed to :func:`format_file_contents`.
906 if src.suffix == ".pyi":
907 mode = replace(mode, is_pyi=True)
909 then = datetime.utcfromtimestamp(src.stat().st_mtime)
910 with open(src, "rb") as buf:
911 src_contents, encoding, newline = decode_bytes(buf.read())
913 dst_contents = format_file_contents(src_contents, fast=fast, mode=mode)
914 except NothingChanged:
917 if write_back == WriteBack.YES:
918 with open(src, "w", encoding=encoding, newline=newline) as f:
919 f.write(dst_contents)
920 elif write_back in (WriteBack.DIFF, WriteBack.COLOR_DIFF):
921 now = datetime.utcnow()
922 src_name = f"{src}\t{then} +0000"
923 dst_name = f"{src}\t{now} +0000"
924 diff_contents = diff(src_contents, dst_contents, src_name, dst_name)
926 if write_back == WriteBack.COLOR_DIFF:
927 diff_contents = color_diff(diff_contents)
929 with lock or nullcontext():
930 f = io.TextIOWrapper(
936 f = wrap_stream_for_windows(f)
937 f.write(diff_contents)
943 def color_diff(contents: str) -> str:
944 """Inject the ANSI color codes to the diff."""
945 lines = contents.split("\n")
946 for i, line in enumerate(lines):
947 if line.startswith("+++") or line.startswith("---"):
948 line = "\033[1;37m" + line + "\033[0m" # bold white, reset
949 elif line.startswith("@@"):
950 line = "\033[36m" + line + "\033[0m" # cyan, reset
951 elif line.startswith("+"):
952 line = "\033[32m" + line + "\033[0m" # green, reset
953 elif line.startswith("-"):
954 line = "\033[31m" + line + "\033[0m" # red, reset
956 return "\n".join(lines)
959 def wrap_stream_for_windows(
961 ) -> Union[io.TextIOWrapper, "colorama.AnsiToWin32"]:
963 Wrap stream with colorama's wrap_stream so colors are shown on Windows.
965 If `colorama` is unavailable, the original stream is returned unmodified.
966 Otherwise, the `wrap_stream()` function determines whether the stream needs
967 to be wrapped for a Windows environment and will accordingly either return
968 an `AnsiToWin32` wrapper or the original stream.
971 from colorama.initialise import wrap_stream
975 # Set `strip=False` to avoid needing to modify test_express_diff_with_color.
976 return wrap_stream(f, convert=None, strip=False, autoreset=False, wrap=True)
979 def format_stdin_to_stdout(
980 fast: bool, *, write_back: WriteBack = WriteBack.NO, mode: Mode
982 """Format file on stdin. Return True if changed.
984 If `write_back` is YES, write reformatted code back to stdout. If it is DIFF,
985 write a diff to stdout. The `mode` argument is passed to
986 :func:`format_file_contents`.
988 then = datetime.utcnow()
989 src, encoding, newline = decode_bytes(sys.stdin.buffer.read())
992 dst = format_file_contents(src, fast=fast, mode=mode)
995 except NothingChanged:
999 f = io.TextIOWrapper(
1000 sys.stdout.buffer, encoding=encoding, newline=newline, write_through=True
1002 if write_back == WriteBack.YES:
1004 elif write_back in (WriteBack.DIFF, WriteBack.COLOR_DIFF):
1005 now = datetime.utcnow()
1006 src_name = f"STDIN\t{then} +0000"
1007 dst_name = f"STDOUT\t{now} +0000"
1008 d = diff(src, dst, src_name, dst_name)
1009 if write_back == WriteBack.COLOR_DIFF:
1011 f = wrap_stream_for_windows(f)
1016 def format_file_contents(src_contents: str, *, fast: bool, mode: Mode) -> FileContent:
1017 """Reformat contents of a file and return new contents.
1019 If `fast` is False, additionally confirm that the reformatted code is
1020 valid by calling :func:`assert_equivalent` and :func:`assert_stable` on it.
1021 `mode` is passed to :func:`format_str`.
1023 if not src_contents.strip():
1024 raise NothingChanged
1026 dst_contents = format_str(src_contents, mode=mode)
1027 if src_contents == dst_contents:
1028 raise NothingChanged
1031 assert_equivalent(src_contents, dst_contents)
1033 # Forced second pass to work around optional trailing commas (becoming
1034 # forced trailing commas on pass 2) interacting differently with optional
1035 # parentheses. Admittedly ugly.
1036 dst_contents_pass2 = format_str(dst_contents, mode=mode)
1037 if dst_contents != dst_contents_pass2:
1038 dst_contents = dst_contents_pass2
1039 assert_equivalent(src_contents, dst_contents, pass_num=2)
1040 assert_stable(src_contents, dst_contents, mode=mode)
1041 # Note: no need to explicitly call `assert_stable` if `dst_contents` was
1042 # the same as `dst_contents_pass2`.
1046 def format_str(src_contents: str, *, mode: Mode) -> FileContent:
1047 """Reformat a string and return new contents.
1049 `mode` determines formatting options, such as how many characters per line are
1053 >>> print(black.format_str("def f(arg:str='')->None:...", mode=black.Mode()))
1054 def f(arg: str = "") -> None:
1057 A more complex example:
1060 ... black.format_str(
1061 ... "def f(arg:str='')->None: hey",
1062 ... mode=black.Mode(
1063 ... target_versions={black.TargetVersion.PY36},
1065 ... string_normalization=False,
1076 src_node = lib2to3_parse(src_contents.lstrip(), mode.target_versions)
1078 future_imports = get_future_imports(src_node)
1079 if mode.target_versions:
1080 versions = mode.target_versions
1082 versions = detect_target_versions(src_node)
1083 normalize_fmt_off(src_node)
1084 lines = LineGenerator(
1086 remove_u_prefix="unicode_literals" in future_imports
1087 or supports_feature(versions, Feature.UNICODE_LITERALS),
1089 elt = EmptyLineTracker(is_pyi=mode.is_pyi)
1090 empty_line = Line(mode=mode)
1092 split_line_features = {
1094 for feature in {Feature.TRAILING_COMMA_IN_CALL, Feature.TRAILING_COMMA_IN_DEF}
1095 if supports_feature(versions, feature)
1097 for current_line in lines.visit(src_node):
1098 dst_contents.append(str(empty_line) * after)
1099 before, after = elt.maybe_empty_lines(current_line)
1100 dst_contents.append(str(empty_line) * before)
1101 for line in transform_line(
1102 current_line, mode=mode, features=split_line_features
1104 dst_contents.append(str(line))
1105 return "".join(dst_contents)
1108 def decode_bytes(src: bytes) -> Tuple[FileContent, Encoding, NewLine]:
1109 """Return a tuple of (decoded_contents, encoding, newline).
1111 `newline` is either CRLF or LF but `decoded_contents` is decoded with
1112 universal newlines (i.e. only contains LF).
1114 srcbuf = io.BytesIO(src)
1115 encoding, lines = tokenize.detect_encoding(srcbuf.readline)
1117 return "", encoding, "\n"
1119 newline = "\r\n" if b"\r\n" == lines[0][-2:] else "\n"
1121 with io.TextIOWrapper(srcbuf, encoding) as tiow:
1122 return tiow.read(), encoding, newline
1125 def get_grammars(target_versions: Set[TargetVersion]) -> List[Grammar]:
1126 if not target_versions:
1127 # No target_version specified, so try all grammars.
1130 pygram.python_grammar_no_print_statement_no_exec_statement_async_keywords,
1132 pygram.python_grammar_no_print_statement_no_exec_statement,
1133 # Python 2.7 with future print_function import
1134 pygram.python_grammar_no_print_statement,
1136 pygram.python_grammar,
1139 if all(version.is_python2() for version in target_versions):
1140 # Python 2-only code, so try Python 2 grammars.
1142 # Python 2.7 with future print_function import
1143 pygram.python_grammar_no_print_statement,
1145 pygram.python_grammar,
1148 # Python 3-compatible code, so only try Python 3 grammar.
1150 # If we have to parse both, try to parse async as a keyword first
1151 if not supports_feature(target_versions, Feature.ASYNC_IDENTIFIERS):
1154 pygram.python_grammar_no_print_statement_no_exec_statement_async_keywords
1156 if not supports_feature(target_versions, Feature.ASYNC_KEYWORDS):
1158 grammars.append(pygram.python_grammar_no_print_statement_no_exec_statement)
1159 # At least one of the above branches must have been taken, because every Python
1160 # version has exactly one of the two 'ASYNC_*' flags
1164 def lib2to3_parse(src_txt: str, target_versions: Iterable[TargetVersion] = ()) -> Node:
1165 """Given a string with source, return the lib2to3 Node."""
1166 if not src_txt.endswith("\n"):
1169 for grammar in get_grammars(set(target_versions)):
1170 drv = driver.Driver(grammar, pytree.convert)
1172 result = drv.parse_string(src_txt, True)
1175 except ParseError as pe:
1176 lineno, column = pe.context[1]
1177 lines = src_txt.splitlines()
1179 faulty_line = lines[lineno - 1]
1181 faulty_line = "<line number missing in source>"
1182 exc = InvalidInput(f"Cannot parse: {lineno}:{column}: {faulty_line}")
1186 if isinstance(result, Leaf):
1187 result = Node(syms.file_input, [result])
1191 def lib2to3_unparse(node: Node) -> str:
1192 """Given a lib2to3 node, return its string representation."""
1197 class Visitor(Generic[T]):
1198 """Basic lib2to3 visitor that yields things of type `T` on `visit()`."""
1200 def visit(self, node: LN) -> Iterator[T]:
1201 """Main method to visit `node` and its children.
1203 It tries to find a `visit_*()` method for the given `node.type`, like
1204 `visit_simple_stmt` for Node objects or `visit_INDENT` for Leaf objects.
1205 If no dedicated `visit_*()` method is found, chooses `visit_default()`
1208 Then yields objects of type `T` from the selected visitor.
1211 name = token.tok_name[node.type]
1213 name = str(type_repr(node.type))
1214 # We explicitly branch on whether a visitor exists (instead of
1215 # using self.visit_default as the default arg to getattr) in order
1216 # to save needing to create a bound method object and so mypyc can
1217 # generate a native call to visit_default.
1218 visitf = getattr(self, f"visit_{name}", None)
1220 yield from visitf(node)
1222 yield from self.visit_default(node)
1224 def visit_default(self, node: LN) -> Iterator[T]:
1225 """Default `visit_*()` implementation. Recurses to children of `node`."""
1226 if isinstance(node, Node):
1227 for child in node.children:
1228 yield from self.visit(child)
1232 class DebugVisitor(Visitor[T]):
1235 def visit_default(self, node: LN) -> Iterator[T]:
1236 indent = " " * (2 * self.tree_depth)
1237 if isinstance(node, Node):
1238 _type = type_repr(node.type)
1239 out(f"{indent}{_type}", fg="yellow")
1240 self.tree_depth += 1
1241 for child in node.children:
1242 yield from self.visit(child)
1244 self.tree_depth -= 1
1245 out(f"{indent}/{_type}", fg="yellow", bold=False)
1247 _type = token.tok_name.get(node.type, str(node.type))
1248 out(f"{indent}{_type}", fg="blue", nl=False)
1250 # We don't have to handle prefixes for `Node` objects since
1251 # that delegates to the first child anyway.
1252 out(f" {node.prefix!r}", fg="green", bold=False, nl=False)
1253 out(f" {node.value!r}", fg="blue", bold=False)
1256 def show(cls, code: Union[str, Leaf, Node]) -> None:
1257 """Pretty-print the lib2to3 AST of a given string of `code`.
1259 Convenience method for debugging.
1261 v: DebugVisitor[None] = DebugVisitor()
1262 if isinstance(code, str):
1263 code = lib2to3_parse(code)
1267 WHITESPACE: Final = {token.DEDENT, token.INDENT, token.NEWLINE}
1268 STATEMENT: Final = {
1278 STANDALONE_COMMENT: Final = 153
1279 token.tok_name[STANDALONE_COMMENT] = "STANDALONE_COMMENT"
1280 LOGIC_OPERATORS: Final = {"and", "or"}
1281 COMPARATORS: Final = {
1289 MATH_OPERATORS: Final = {
1305 STARS: Final = {token.STAR, token.DOUBLESTAR}
1306 VARARGS_SPECIALS: Final = STARS | {token.SLASH}
1307 VARARGS_PARENTS: Final = {
1309 syms.argument, # double star in arglist
1310 syms.trailer, # single argument to call
1312 syms.varargslist, # lambdas
1314 UNPACKING_PARENTS: Final = {
1315 syms.atom, # single element of a list or set literal
1319 syms.testlist_star_expr,
1321 TEST_DESCENDANTS: Final = {
1338 ASSIGNMENTS: Final = {
1354 COMPREHENSION_PRIORITY: Final = 20
1355 COMMA_PRIORITY: Final = 18
1356 TERNARY_PRIORITY: Final = 16
1357 LOGIC_PRIORITY: Final = 14
1358 STRING_PRIORITY: Final = 12
1359 COMPARATOR_PRIORITY: Final = 10
1360 MATH_PRIORITIES: Final = {
1362 token.CIRCUMFLEX: 8,
1365 token.RIGHTSHIFT: 6,
1370 token.DOUBLESLASH: 4,
1374 token.DOUBLESTAR: 2,
1376 DOT_PRIORITY: Final = 1
1380 class BracketTracker:
1381 """Keeps track of brackets on a line."""
1384 bracket_match: Dict[Tuple[Depth, NodeType], Leaf] = field(default_factory=dict)
1385 delimiters: Dict[LeafID, Priority] = field(default_factory=dict)
1386 previous: Optional[Leaf] = None
1387 _for_loop_depths: List[int] = field(default_factory=list)
1388 _lambda_argument_depths: List[int] = field(default_factory=list)
1389 invisible: List[Leaf] = field(default_factory=list)
1391 def mark(self, leaf: Leaf) -> None:
1392 """Mark `leaf` with bracket-related metadata. Keep track of delimiters.
1394 All leaves receive an int `bracket_depth` field that stores how deep
1395 within brackets a given leaf is. 0 means there are no enclosing brackets
1396 that started on this line.
1398 If a leaf is itself a closing bracket, it receives an `opening_bracket`
1399 field that it forms a pair with. This is a one-directional link to
1400 avoid reference cycles.
1402 If a leaf is a delimiter (a token on which Black can split the line if
1403 needed) and it's on depth 0, its `id()` is stored in the tracker's
1406 if leaf.type == token.COMMENT:
1409 self.maybe_decrement_after_for_loop_variable(leaf)
1410 self.maybe_decrement_after_lambda_arguments(leaf)
1411 if leaf.type in CLOSING_BRACKETS:
1414 opening_bracket = self.bracket_match.pop((self.depth, leaf.type))
1415 except KeyError as e:
1416 raise BracketMatchError(
1417 "Unable to match a closing bracket to the following opening"
1420 leaf.opening_bracket = opening_bracket
1422 self.invisible.append(leaf)
1423 leaf.bracket_depth = self.depth
1425 delim = is_split_before_delimiter(leaf, self.previous)
1426 if delim and self.previous is not None:
1427 self.delimiters[id(self.previous)] = delim
1429 delim = is_split_after_delimiter(leaf, self.previous)
1431 self.delimiters[id(leaf)] = delim
1432 if leaf.type in OPENING_BRACKETS:
1433 self.bracket_match[self.depth, BRACKET[leaf.type]] = leaf
1436 self.invisible.append(leaf)
1437 self.previous = leaf
1438 self.maybe_increment_lambda_arguments(leaf)
1439 self.maybe_increment_for_loop_variable(leaf)
1441 def any_open_brackets(self) -> bool:
1442 """Return True if there is an yet unmatched open bracket on the line."""
1443 return bool(self.bracket_match)
1445 def max_delimiter_priority(self, exclude: Iterable[LeafID] = ()) -> Priority:
1446 """Return the highest priority of a delimiter found on the line.
1448 Values are consistent with what `is_split_*_delimiter()` return.
1449 Raises ValueError on no delimiters.
1451 return max(v for k, v in self.delimiters.items() if k not in exclude)
1453 def delimiter_count_with_priority(self, priority: Priority = 0) -> int:
1454 """Return the number of delimiters with the given `priority`.
1456 If no `priority` is passed, defaults to max priority on the line.
1458 if not self.delimiters:
1461 priority = priority or self.max_delimiter_priority()
1462 return sum(1 for p in self.delimiters.values() if p == priority)
1464 def maybe_increment_for_loop_variable(self, leaf: Leaf) -> bool:
1465 """In a for loop, or comprehension, the variables are often unpacks.
1467 To avoid splitting on the comma in this situation, increase the depth of
1468 tokens between `for` and `in`.
1470 if leaf.type == token.NAME and leaf.value == "for":
1472 self._for_loop_depths.append(self.depth)
1477 def maybe_decrement_after_for_loop_variable(self, leaf: Leaf) -> bool:
1478 """See `maybe_increment_for_loop_variable` above for explanation."""
1480 self._for_loop_depths
1481 and self._for_loop_depths[-1] == self.depth
1482 and leaf.type == token.NAME
1483 and leaf.value == "in"
1486 self._for_loop_depths.pop()
1491 def maybe_increment_lambda_arguments(self, leaf: Leaf) -> bool:
1492 """In a lambda expression, there might be more than one argument.
1494 To avoid splitting on the comma in this situation, increase the depth of
1495 tokens between `lambda` and `:`.
1497 if leaf.type == token.NAME and leaf.value == "lambda":
1499 self._lambda_argument_depths.append(self.depth)
1504 def maybe_decrement_after_lambda_arguments(self, leaf: Leaf) -> bool:
1505 """See `maybe_increment_lambda_arguments` above for explanation."""
1507 self._lambda_argument_depths
1508 and self._lambda_argument_depths[-1] == self.depth
1509 and leaf.type == token.COLON
1512 self._lambda_argument_depths.pop()
1517 def get_open_lsqb(self) -> Optional[Leaf]:
1518 """Return the most recent opening square bracket (if any)."""
1519 return self.bracket_match.get((self.depth - 1, token.RSQB))
1524 """Holds leaves and comments. Can be printed with `str(line)`."""
1528 leaves: List[Leaf] = field(default_factory=list)
1529 # keys ordered like `leaves`
1530 comments: Dict[LeafID, List[Leaf]] = field(default_factory=dict)
1531 bracket_tracker: BracketTracker = field(default_factory=BracketTracker)
1532 inside_brackets: bool = False
1533 should_split_rhs: bool = False
1534 magic_trailing_comma: Optional[Leaf] = None
1536 def append(self, leaf: Leaf, preformatted: bool = False) -> None:
1537 """Add a new `leaf` to the end of the line.
1539 Unless `preformatted` is True, the `leaf` will receive a new consistent
1540 whitespace prefix and metadata applied by :class:`BracketTracker`.
1541 Trailing commas are maybe removed, unpacked for loop variables are
1542 demoted from being delimiters.
1544 Inline comments are put aside.
1546 has_value = leaf.type in BRACKETS or bool(leaf.value.strip())
1550 if token.COLON == leaf.type and self.is_class_paren_empty:
1551 del self.leaves[-2:]
1552 if self.leaves and not preformatted:
1553 # Note: at this point leaf.prefix should be empty except for
1554 # imports, for which we only preserve newlines.
1555 leaf.prefix += whitespace(
1556 leaf, complex_subscript=self.is_complex_subscript(leaf)
1558 if self.inside_brackets or not preformatted:
1559 self.bracket_tracker.mark(leaf)
1560 if self.mode.magic_trailing_comma:
1561 if self.has_magic_trailing_comma(leaf):
1562 self.magic_trailing_comma = leaf
1563 elif self.has_magic_trailing_comma(leaf, ensure_removable=True):
1564 self.remove_trailing_comma()
1565 if not self.append_comment(leaf):
1566 self.leaves.append(leaf)
1568 def append_safe(self, leaf: Leaf, preformatted: bool = False) -> None:
1569 """Like :func:`append()` but disallow invalid standalone comment structure.
1571 Raises ValueError when any `leaf` is appended after a standalone comment
1572 or when a standalone comment is not the first leaf on the line.
1574 if self.bracket_tracker.depth == 0:
1576 raise ValueError("cannot append to standalone comments")
1578 if self.leaves and leaf.type == STANDALONE_COMMENT:
1580 "cannot append standalone comments to a populated line"
1583 self.append(leaf, preformatted=preformatted)
1586 def is_comment(self) -> bool:
1587 """Is this line a standalone comment?"""
1588 return len(self.leaves) == 1 and self.leaves[0].type == STANDALONE_COMMENT
1591 def is_decorator(self) -> bool:
1592 """Is this line a decorator?"""
1593 return bool(self) and self.leaves[0].type == token.AT
1596 def is_import(self) -> bool:
1597 """Is this an import line?"""
1598 return bool(self) and is_import(self.leaves[0])
1601 def is_class(self) -> bool:
1602 """Is this line a class definition?"""
1605 and self.leaves[0].type == token.NAME
1606 and self.leaves[0].value == "class"
1610 def is_stub_class(self) -> bool:
1611 """Is this line a class definition with a body consisting only of "..."?"""
1612 return self.is_class and self.leaves[-3:] == [
1613 Leaf(token.DOT, ".") for _ in range(3)
1617 def is_def(self) -> bool:
1618 """Is this a function definition? (Also returns True for async defs.)"""
1620 first_leaf = self.leaves[0]
1625 second_leaf: Optional[Leaf] = self.leaves[1]
1628 return (first_leaf.type == token.NAME and first_leaf.value == "def") or (
1629 first_leaf.type == token.ASYNC
1630 and second_leaf is not None
1631 and second_leaf.type == token.NAME
1632 and second_leaf.value == "def"
1636 def is_class_paren_empty(self) -> bool:
1637 """Is this a class with no base classes but using parentheses?
1639 Those are unnecessary and should be removed.
1643 and len(self.leaves) == 4
1645 and self.leaves[2].type == token.LPAR
1646 and self.leaves[2].value == "("
1647 and self.leaves[3].type == token.RPAR
1648 and self.leaves[3].value == ")"
1652 def is_triple_quoted_string(self) -> bool:
1653 """Is the line a triple quoted string?"""
1656 and self.leaves[0].type == token.STRING
1657 and self.leaves[0].value.startswith(('"""', "'''"))
1660 def contains_standalone_comments(self, depth_limit: int = sys.maxsize) -> bool:
1661 """If so, needs to be split before emitting."""
1662 for leaf in self.leaves:
1663 if leaf.type == STANDALONE_COMMENT and leaf.bracket_depth <= depth_limit:
1668 def contains_uncollapsable_type_comments(self) -> bool:
1671 last_leaf = self.leaves[-1]
1672 ignored_ids.add(id(last_leaf))
1673 if last_leaf.type == token.COMMA or (
1674 last_leaf.type == token.RPAR and not last_leaf.value
1676 # When trailing commas or optional parens are inserted by Black for
1677 # consistency, comments after the previous last element are not moved
1678 # (they don't have to, rendering will still be correct). So we ignore
1679 # trailing commas and invisible.
1680 last_leaf = self.leaves[-2]
1681 ignored_ids.add(id(last_leaf))
1685 # A type comment is uncollapsable if it is attached to a leaf
1686 # that isn't at the end of the line (since that could cause it
1687 # to get associated to a different argument) or if there are
1688 # comments before it (since that could cause it to get hidden
1690 comment_seen = False
1691 for leaf_id, comments in self.comments.items():
1692 for comment in comments:
1693 if is_type_comment(comment):
1694 if comment_seen or (
1695 not is_type_comment(comment, " ignore")
1696 and leaf_id not in ignored_ids
1704 def contains_unsplittable_type_ignore(self) -> bool:
1708 # If a 'type: ignore' is attached to the end of a line, we
1709 # can't split the line, because we can't know which of the
1710 # subexpressions the ignore was meant to apply to.
1712 # We only want this to apply to actual physical lines from the
1713 # original source, though: we don't want the presence of a
1714 # 'type: ignore' at the end of a multiline expression to
1715 # justify pushing it all onto one line. Thus we
1716 # (unfortunately) need to check the actual source lines and
1717 # only report an unsplittable 'type: ignore' if this line was
1718 # one line in the original code.
1720 # Grab the first and last line numbers, skipping generated leaves
1721 first_line = next((leaf.lineno for leaf in self.leaves if leaf.lineno != 0), 0)
1723 (leaf.lineno for leaf in reversed(self.leaves) if leaf.lineno != 0), 0
1726 if first_line == last_line:
1727 # We look at the last two leaves since a comma or an
1728 # invisible paren could have been added at the end of the
1730 for node in self.leaves[-2:]:
1731 for comment in self.comments.get(id(node), []):
1732 if is_type_comment(comment, " ignore"):
1737 def contains_multiline_strings(self) -> bool:
1738 return any(is_multiline_string(leaf) for leaf in self.leaves)
1740 def has_magic_trailing_comma(
1741 self, closing: Leaf, ensure_removable: bool = False
1743 """Return True if we have a magic trailing comma, that is when:
1744 - there's a trailing comma here
1745 - it's not a one-tuple
1746 Additionally, if ensure_removable:
1747 - it's not from square bracket indexing
1750 closing.type in CLOSING_BRACKETS
1752 and self.leaves[-1].type == token.COMMA
1756 if closing.type == token.RBRACE:
1759 if closing.type == token.RSQB:
1760 if not ensure_removable:
1762 comma = self.leaves[-1]
1763 return bool(comma.parent and comma.parent.type == syms.listmaker)
1768 if not is_one_tuple_between(closing.opening_bracket, closing, self.leaves):
1773 def append_comment(self, comment: Leaf) -> bool:
1774 """Add an inline or standalone comment to the line."""
1776 comment.type == STANDALONE_COMMENT
1777 and self.bracket_tracker.any_open_brackets()
1782 if comment.type != token.COMMENT:
1786 comment.type = STANDALONE_COMMENT
1790 last_leaf = self.leaves[-1]
1792 last_leaf.type == token.RPAR
1793 and not last_leaf.value
1794 and last_leaf.parent
1795 and len(list(last_leaf.parent.leaves())) <= 3
1796 and not is_type_comment(comment)
1798 # Comments on an optional parens wrapping a single leaf should belong to
1799 # the wrapped node except if it's a type comment. Pinning the comment like
1800 # this avoids unstable formatting caused by comment migration.
1801 if len(self.leaves) < 2:
1802 comment.type = STANDALONE_COMMENT
1806 last_leaf = self.leaves[-2]
1807 self.comments.setdefault(id(last_leaf), []).append(comment)
1810 def comments_after(self, leaf: Leaf) -> List[Leaf]:
1811 """Generate comments that should appear directly after `leaf`."""
1812 return self.comments.get(id(leaf), [])
1814 def remove_trailing_comma(self) -> None:
1815 """Remove the trailing comma and moves the comments attached to it."""
1816 trailing_comma = self.leaves.pop()
1817 trailing_comma_comments = self.comments.pop(id(trailing_comma), [])
1818 self.comments.setdefault(id(self.leaves[-1]), []).extend(
1819 trailing_comma_comments
1822 def is_complex_subscript(self, leaf: Leaf) -> bool:
1823 """Return True iff `leaf` is part of a slice with non-trivial exprs."""
1824 open_lsqb = self.bracket_tracker.get_open_lsqb()
1825 if open_lsqb is None:
1828 subscript_start = open_lsqb.next_sibling
1830 if isinstance(subscript_start, Node):
1831 if subscript_start.type == syms.listmaker:
1834 if subscript_start.type == syms.subscriptlist:
1835 subscript_start = child_towards(subscript_start, leaf)
1836 return subscript_start is not None and any(
1837 n.type in TEST_DESCENDANTS for n in subscript_start.pre_order()
1840 def clone(self) -> "Line":
1844 inside_brackets=self.inside_brackets,
1845 should_split_rhs=self.should_split_rhs,
1846 magic_trailing_comma=self.magic_trailing_comma,
1849 def __str__(self) -> str:
1850 """Render the line."""
1854 indent = " " * self.depth
1855 leaves = iter(self.leaves)
1856 first = next(leaves)
1857 res = f"{first.prefix}{indent}{first.value}"
1860 for comment in itertools.chain.from_iterable(self.comments.values()):
1865 def __bool__(self) -> bool:
1866 """Return True if the line has leaves or comments."""
1867 return bool(self.leaves or self.comments)
1871 class EmptyLineTracker:
1872 """Provides a stateful method that returns the number of potential extra
1873 empty lines needed before and after the currently processed line.
1875 Note: this tracker works on lines that haven't been split yet. It assumes
1876 the prefix of the first leaf consists of optional newlines. Those newlines
1877 are consumed by `maybe_empty_lines()` and included in the computation.
1880 is_pyi: bool = False
1881 previous_line: Optional[Line] = None
1882 previous_after: int = 0
1883 previous_defs: List[int] = field(default_factory=list)
1885 def maybe_empty_lines(self, current_line: Line) -> Tuple[int, int]:
1886 """Return the number of extra empty lines before and after the `current_line`.
1888 This is for separating `def`, `async def` and `class` with extra empty
1889 lines (two on module-level).
1891 before, after = self._maybe_empty_lines(current_line)
1893 # Black should not insert empty lines at the beginning
1896 if self.previous_line is None
1897 else before - self.previous_after
1899 self.previous_after = after
1900 self.previous_line = current_line
1901 return before, after
1903 def _maybe_empty_lines(self, current_line: Line) -> Tuple[int, int]:
1905 if current_line.depth == 0:
1906 max_allowed = 1 if self.is_pyi else 2
1907 if current_line.leaves:
1908 # Consume the first leaf's extra newlines.
1909 first_leaf = current_line.leaves[0]
1910 before = first_leaf.prefix.count("\n")
1911 before = min(before, max_allowed)
1912 first_leaf.prefix = ""
1915 depth = current_line.depth
1916 while self.previous_defs and self.previous_defs[-1] >= depth:
1917 self.previous_defs.pop()
1919 before = 0 if depth else 1
1921 before = 1 if depth else 2
1922 if current_line.is_decorator or current_line.is_def or current_line.is_class:
1923 return self._maybe_empty_lines_for_class_or_def(current_line, before)
1927 and self.previous_line.is_import
1928 and not current_line.is_import
1929 and depth == self.previous_line.depth
1931 return (before or 1), 0
1935 and self.previous_line.is_class
1936 and current_line.is_triple_quoted_string
1942 def _maybe_empty_lines_for_class_or_def(
1943 self, current_line: Line, before: int
1944 ) -> Tuple[int, int]:
1945 if not current_line.is_decorator:
1946 self.previous_defs.append(current_line.depth)
1947 if self.previous_line is None:
1948 # Don't insert empty lines before the first line in the file.
1951 if self.previous_line.is_decorator:
1952 if self.is_pyi and current_line.is_stub_class:
1953 # Insert an empty line after a decorated stub class
1958 if self.previous_line.depth < current_line.depth and (
1959 self.previous_line.is_class or self.previous_line.is_def
1964 self.previous_line.is_comment
1965 and self.previous_line.depth == current_line.depth
1971 if self.previous_line.depth > current_line.depth:
1973 elif current_line.is_class or self.previous_line.is_class:
1974 if current_line.is_stub_class and self.previous_line.is_stub_class:
1975 # No blank line between classes with an empty body
1980 current_line.is_def or current_line.is_decorator
1981 ) and not self.previous_line.is_def:
1982 # Blank line between a block of functions (maybe with preceding
1983 # decorators) and a block of non-functions
1989 if current_line.depth and newlines:
1995 class LineGenerator(Visitor[Line]):
1996 """Generates reformatted Line objects. Empty lines are not emitted.
1998 Note: destroys the tree it's visiting by mutating prefixes of its leaves
1999 in ways that will no longer stringify to valid Python code on the tree.
2003 remove_u_prefix: bool = False
2004 current_line: Line = field(init=False)
2006 def line(self, indent: int = 0) -> Iterator[Line]:
2009 If the line is empty, only emit if it makes sense.
2010 If the line is too long, split it first and then generate.
2012 If any lines were generated, set up a new current_line.
2014 if not self.current_line:
2015 self.current_line.depth += indent
2016 return # Line is empty, don't emit. Creating a new one unnecessary.
2018 complete_line = self.current_line
2019 self.current_line = Line(mode=self.mode, depth=complete_line.depth + indent)
2022 def visit_default(self, node: LN) -> Iterator[Line]:
2023 """Default `visit_*()` implementation. Recurses to children of `node`."""
2024 if isinstance(node, Leaf):
2025 any_open_brackets = self.current_line.bracket_tracker.any_open_brackets()
2026 for comment in generate_comments(node):
2027 if any_open_brackets:
2028 # any comment within brackets is subject to splitting
2029 self.current_line.append(comment)
2030 elif comment.type == token.COMMENT:
2031 # regular trailing comment
2032 self.current_line.append(comment)
2033 yield from self.line()
2036 # regular standalone comment
2037 yield from self.line()
2039 self.current_line.append(comment)
2040 yield from self.line()
2042 normalize_prefix(node, inside_brackets=any_open_brackets)
2043 if self.mode.string_normalization and node.type == token.STRING:
2044 normalize_string_prefix(node, remove_u_prefix=self.remove_u_prefix)
2045 normalize_string_quotes(node)
2046 if node.type == token.NUMBER:
2047 normalize_numeric_literal(node)
2048 if node.type not in WHITESPACE:
2049 self.current_line.append(node)
2050 yield from super().visit_default(node)
2052 def visit_INDENT(self, node: Leaf) -> Iterator[Line]:
2053 """Increase indentation level, maybe yield a line."""
2054 # In blib2to3 INDENT never holds comments.
2055 yield from self.line(+1)
2056 yield from self.visit_default(node)
2058 def visit_DEDENT(self, node: Leaf) -> Iterator[Line]:
2059 """Decrease indentation level, maybe yield a line."""
2060 # The current line might still wait for trailing comments. At DEDENT time
2061 # there won't be any (they would be prefixes on the preceding NEWLINE).
2062 # Emit the line then.
2063 yield from self.line()
2065 # While DEDENT has no value, its prefix may contain standalone comments
2066 # that belong to the current indentation level. Get 'em.
2067 yield from self.visit_default(node)
2069 # Finally, emit the dedent.
2070 yield from self.line(-1)
2073 self, node: Node, keywords: Set[str], parens: Set[str]
2074 ) -> Iterator[Line]:
2075 """Visit a statement.
2077 This implementation is shared for `if`, `while`, `for`, `try`, `except`,
2078 `def`, `with`, `class`, `assert` and assignments.
2080 The relevant Python language `keywords` for a given statement will be
2081 NAME leaves within it. This methods puts those on a separate line.
2083 `parens` holds a set of string leaf values immediately after which
2084 invisible parens should be put.
2086 normalize_invisible_parens(node, parens_after=parens)
2087 for child in node.children:
2088 if child.type == token.NAME and child.value in keywords: # type: ignore
2089 yield from self.line()
2091 yield from self.visit(child)
2093 def visit_suite(self, node: Node) -> Iterator[Line]:
2094 """Visit a suite."""
2095 if self.mode.is_pyi and is_stub_suite(node):
2096 yield from self.visit(node.children[2])
2098 yield from self.visit_default(node)
2100 def visit_simple_stmt(self, node: Node) -> Iterator[Line]:
2101 """Visit a statement without nested statements."""
2102 if first_child_is_arith(node):
2103 wrap_in_parentheses(node, node.children[0], visible=False)
2104 is_suite_like = node.parent and node.parent.type in STATEMENT
2106 if self.mode.is_pyi and is_stub_body(node):
2107 yield from self.visit_default(node)
2109 yield from self.line(+1)
2110 yield from self.visit_default(node)
2111 yield from self.line(-1)
2115 not self.mode.is_pyi
2117 or not is_stub_suite(node.parent)
2119 yield from self.line()
2120 yield from self.visit_default(node)
2122 def visit_async_stmt(self, node: Node) -> Iterator[Line]:
2123 """Visit `async def`, `async for`, `async with`."""
2124 yield from self.line()
2126 children = iter(node.children)
2127 for child in children:
2128 yield from self.visit(child)
2130 if child.type == token.ASYNC:
2133 internal_stmt = next(children)
2134 for child in internal_stmt.children:
2135 yield from self.visit(child)
2137 def visit_decorators(self, node: Node) -> Iterator[Line]:
2138 """Visit decorators."""
2139 for child in node.children:
2140 yield from self.line()
2141 yield from self.visit(child)
2143 def visit_SEMI(self, leaf: Leaf) -> Iterator[Line]:
2144 """Remove a semicolon and put the other statement on a separate line."""
2145 yield from self.line()
2147 def visit_ENDMARKER(self, leaf: Leaf) -> Iterator[Line]:
2148 """End of file. Process outstanding comments and end with a newline."""
2149 yield from self.visit_default(leaf)
2150 yield from self.line()
2152 def visit_STANDALONE_COMMENT(self, leaf: Leaf) -> Iterator[Line]:
2153 if not self.current_line.bracket_tracker.any_open_brackets():
2154 yield from self.line()
2155 yield from self.visit_default(leaf)
2157 def visit_factor(self, node: Node) -> Iterator[Line]:
2158 """Force parentheses between a unary op and a binary power:
2160 -2 ** 8 -> -(2 ** 8)
2162 _operator, operand = node.children
2164 operand.type == syms.power
2165 and len(operand.children) == 3
2166 and operand.children[1].type == token.DOUBLESTAR
2168 lpar = Leaf(token.LPAR, "(")
2169 rpar = Leaf(token.RPAR, ")")
2170 index = operand.remove() or 0
2171 node.insert_child(index, Node(syms.atom, [lpar, operand, rpar]))
2172 yield from self.visit_default(node)
2174 def visit_STRING(self, leaf: Leaf) -> Iterator[Line]:
2175 if is_docstring(leaf) and "\\\n" not in leaf.value:
2176 # We're ignoring docstrings with backslash newline escapes because changing
2177 # indentation of those changes the AST representation of the code.
2178 prefix = get_string_prefix(leaf.value)
2179 docstring = leaf.value[len(prefix) :] # Remove the prefix
2180 quote_char = docstring[0]
2181 # A natural way to remove the outer quotes is to do:
2182 # docstring = docstring.strip(quote_char)
2183 # but that breaks on """""x""" (which is '""x').
2184 # So we actually need to remove the first character and the next two
2185 # characters but only if they are the same as the first.
2186 quote_len = 1 if docstring[1] != quote_char else 3
2187 docstring = docstring[quote_len:-quote_len]
2189 if is_multiline_string(leaf):
2190 indent = " " * 4 * self.current_line.depth
2191 docstring = fix_docstring(docstring, indent)
2193 docstring = docstring.strip()
2196 # Add some padding if the docstring starts / ends with a quote mark.
2197 if docstring[0] == quote_char:
2198 docstring = " " + docstring
2199 if docstring[-1] == quote_char:
2201 if docstring[-1] == "\\":
2202 backslash_count = len(docstring) - len(docstring.rstrip("\\"))
2203 if backslash_count % 2:
2204 # Odd number of tailing backslashes, add some padding to
2205 # avoid escaping the closing string quote.
2208 # Add some padding if the docstring is empty.
2211 # We could enforce triple quotes at this point.
2212 quote = quote_char * quote_len
2213 leaf.value = prefix + quote + docstring + quote
2215 yield from self.visit_default(leaf)
2217 def __post_init__(self) -> None:
2218 """You are in a twisty little maze of passages."""
2219 self.current_line = Line(mode=self.mode)
2223 self.visit_assert_stmt = partial(v, keywords={"assert"}, parens={"assert", ","})
2224 self.visit_if_stmt = partial(
2225 v, keywords={"if", "else", "elif"}, parens={"if", "elif"}
2227 self.visit_while_stmt = partial(v, keywords={"while", "else"}, parens={"while"})
2228 self.visit_for_stmt = partial(v, keywords={"for", "else"}, parens={"for", "in"})
2229 self.visit_try_stmt = partial(
2230 v, keywords={"try", "except", "else", "finally"}, parens=Ø
2232 self.visit_except_clause = partial(v, keywords={"except"}, parens=Ø)
2233 self.visit_with_stmt = partial(v, keywords={"with"}, parens=Ø)
2234 self.visit_funcdef = partial(v, keywords={"def"}, parens=Ø)
2235 self.visit_classdef = partial(v, keywords={"class"}, parens=Ø)
2236 self.visit_expr_stmt = partial(v, keywords=Ø, parens=ASSIGNMENTS)
2237 self.visit_return_stmt = partial(v, keywords={"return"}, parens={"return"})
2238 self.visit_import_from = partial(v, keywords=Ø, parens={"import"})
2239 self.visit_del_stmt = partial(v, keywords=Ø, parens={"del"})
2240 self.visit_async_funcdef = self.visit_async_stmt
2241 self.visit_decorated = self.visit_decorators
2244 IMPLICIT_TUPLE = {syms.testlist, syms.testlist_star_expr, syms.exprlist}
2245 BRACKET = {token.LPAR: token.RPAR, token.LSQB: token.RSQB, token.LBRACE: token.RBRACE}
2246 OPENING_BRACKETS = set(BRACKET.keys())
2247 CLOSING_BRACKETS = set(BRACKET.values())
2248 BRACKETS = OPENING_BRACKETS | CLOSING_BRACKETS
2249 ALWAYS_NO_SPACE = CLOSING_BRACKETS | {token.COMMA, STANDALONE_COMMENT}
2252 def whitespace(leaf: Leaf, *, complex_subscript: bool) -> str: # noqa: C901
2253 """Return whitespace prefix if needed for the given `leaf`.
2255 `complex_subscript` signals whether the given leaf is part of a subscription
2256 which has non-trivial arguments, like arithmetic expressions or function calls.
2264 if t in ALWAYS_NO_SPACE:
2267 if t == token.COMMENT:
2270 assert p is not None, f"INTERNAL ERROR: hand-made leaf without parent: {leaf!r}"
2271 if t == token.COLON and p.type not in {
2278 prev = leaf.prev_sibling
2280 prevp = preceding_leaf(p)
2281 if not prevp or prevp.type in OPENING_BRACKETS:
2284 if t == token.COLON:
2285 if prevp.type == token.COLON:
2288 elif prevp.type != token.COMMA and not complex_subscript:
2293 if prevp.type == token.EQUAL:
2295 if prevp.parent.type in {
2303 elif prevp.parent.type == syms.typedargslist:
2304 # A bit hacky: if the equal sign has whitespace, it means we
2305 # previously found it's a typed argument. So, we're using
2309 elif prevp.type in VARARGS_SPECIALS:
2310 if is_vararg(prevp, within=VARARGS_PARENTS | UNPACKING_PARENTS):
2313 elif prevp.type == token.COLON:
2314 if prevp.parent and prevp.parent.type in {syms.subscript, syms.sliceop}:
2315 return SPACE if complex_subscript else NO
2319 and prevp.parent.type == syms.factor
2320 and prevp.type in MATH_OPERATORS
2325 prevp.type == token.RIGHTSHIFT
2327 and prevp.parent.type == syms.shift_expr
2328 and prevp.prev_sibling
2329 and prevp.prev_sibling.type == token.NAME
2330 and prevp.prev_sibling.value == "print" # type: ignore
2332 # Python 2 print chevron
2334 elif prevp.type == token.AT and p.parent and p.parent.type == syms.decorator:
2335 # no space in decorators
2338 elif prev.type in OPENING_BRACKETS:
2341 if p.type in {syms.parameters, syms.arglist}:
2342 # untyped function signatures or calls
2343 if not prev or prev.type != token.COMMA:
2346 elif p.type == syms.varargslist:
2348 if prev and prev.type != token.COMMA:
2351 elif p.type == syms.typedargslist:
2352 # typed function signatures
2356 if t == token.EQUAL:
2357 if prev.type != syms.tname:
2360 elif prev.type == token.EQUAL:
2361 # A bit hacky: if the equal sign has whitespace, it means we
2362 # previously found it's a typed argument. So, we're using that, too.
2365 elif prev.type != token.COMMA:
2368 elif p.type == syms.tname:
2371 prevp = preceding_leaf(p)
2372 if not prevp or prevp.type != token.COMMA:
2375 elif p.type == syms.trailer:
2376 # attributes and calls
2377 if t == token.LPAR or t == token.RPAR:
2382 prevp = preceding_leaf(p)
2383 if not prevp or prevp.type != token.NUMBER:
2386 elif t == token.LSQB:
2389 elif prev.type != token.COMMA:
2392 elif p.type == syms.argument:
2394 if t == token.EQUAL:
2398 prevp = preceding_leaf(p)
2399 if not prevp or prevp.type == token.LPAR:
2402 elif prev.type in {token.EQUAL} | VARARGS_SPECIALS:
2405 elif p.type == syms.decorator:
2409 elif p.type == syms.dotted_name:
2413 prevp = preceding_leaf(p)
2414 if not prevp or prevp.type == token.AT or prevp.type == token.DOT:
2417 elif p.type == syms.classdef:
2421 if prev and prev.type == token.LPAR:
2424 elif p.type in {syms.subscript, syms.sliceop}:
2427 assert p.parent is not None, "subscripts are always parented"
2428 if p.parent.type == syms.subscriptlist:
2433 elif not complex_subscript:
2436 elif p.type == syms.atom:
2437 if prev and t == token.DOT:
2438 # dots, but not the first one.
2441 elif p.type == syms.dictsetmaker:
2443 if prev and prev.type == token.DOUBLESTAR:
2446 elif p.type in {syms.factor, syms.star_expr}:
2449 prevp = preceding_leaf(p)
2450 if not prevp or prevp.type in OPENING_BRACKETS:
2453 prevp_parent = prevp.parent
2454 assert prevp_parent is not None
2455 if prevp.type == token.COLON and prevp_parent.type in {
2461 elif prevp.type == token.EQUAL and prevp_parent.type == syms.argument:
2464 elif t in {token.NAME, token.NUMBER, token.STRING}:
2467 elif p.type == syms.import_from:
2469 if prev and prev.type == token.DOT:
2472 elif t == token.NAME:
2476 if prev and prev.type == token.DOT:
2479 elif p.type == syms.sliceop:
2485 def preceding_leaf(node: Optional[LN]) -> Optional[Leaf]:
2486 """Return the first leaf that precedes `node`, if any."""
2488 res = node.prev_sibling
2490 if isinstance(res, Leaf):
2494 return list(res.leaves())[-1]
2503 def prev_siblings_are(node: Optional[LN], tokens: List[Optional[NodeType]]) -> bool:
2504 """Return if the `node` and its previous siblings match types against the provided
2505 list of tokens; the provided `node`has its type matched against the last element in
2506 the list. `None` can be used as the first element to declare that the start of the
2507 list is anchored at the start of its parent's children."""
2510 if tokens[-1] is None:
2514 if node.type != tokens[-1]:
2516 return prev_siblings_are(node.prev_sibling, tokens[:-1])
2519 def child_towards(ancestor: Node, descendant: LN) -> Optional[LN]:
2520 """Return the child of `ancestor` that contains `descendant`."""
2521 node: Optional[LN] = descendant
2522 while node and node.parent != ancestor:
2527 def container_of(leaf: Leaf) -> LN:
2528 """Return `leaf` or one of its ancestors that is the topmost container of it.
2530 By "container" we mean a node where `leaf` is the very first child.
2532 same_prefix = leaf.prefix
2533 container: LN = leaf
2535 parent = container.parent
2539 if parent.children[0].prefix != same_prefix:
2542 if parent.type == syms.file_input:
2545 if parent.prev_sibling is not None and parent.prev_sibling.type in BRACKETS:
2552 def is_split_after_delimiter(leaf: Leaf, previous: Optional[Leaf] = None) -> Priority:
2553 """Return the priority of the `leaf` delimiter, given a line break after it.
2555 The delimiter priorities returned here are from those delimiters that would
2556 cause a line break after themselves.
2558 Higher numbers are higher priority.
2560 if leaf.type == token.COMMA:
2561 return COMMA_PRIORITY
2566 def is_split_before_delimiter(leaf: Leaf, previous: Optional[Leaf] = None) -> Priority:
2567 """Return the priority of the `leaf` delimiter, given a line break before it.
2569 The delimiter priorities returned here are from those delimiters that would
2570 cause a line break before themselves.
2572 Higher numbers are higher priority.
2574 if is_vararg(leaf, within=VARARGS_PARENTS | UNPACKING_PARENTS):
2575 # * and ** might also be MATH_OPERATORS but in this case they are not.
2576 # Don't treat them as a delimiter.
2580 leaf.type == token.DOT
2582 and leaf.parent.type not in {syms.import_from, syms.dotted_name}
2583 and (previous is None or previous.type in CLOSING_BRACKETS)
2588 leaf.type in MATH_OPERATORS
2590 and leaf.parent.type not in {syms.factor, syms.star_expr}
2592 return MATH_PRIORITIES[leaf.type]
2594 if leaf.type in COMPARATORS:
2595 return COMPARATOR_PRIORITY
2598 leaf.type == token.STRING
2599 and previous is not None
2600 and previous.type == token.STRING
2602 return STRING_PRIORITY
2604 if leaf.type not in {token.NAME, token.ASYNC}:
2610 and leaf.parent.type in {syms.comp_for, syms.old_comp_for}
2611 or leaf.type == token.ASYNC
2614 not isinstance(leaf.prev_sibling, Leaf)
2615 or leaf.prev_sibling.value != "async"
2617 return COMPREHENSION_PRIORITY
2622 and leaf.parent.type in {syms.comp_if, syms.old_comp_if}
2624 return COMPREHENSION_PRIORITY
2626 if leaf.value in {"if", "else"} and leaf.parent and leaf.parent.type == syms.test:
2627 return TERNARY_PRIORITY
2629 if leaf.value == "is":
2630 return COMPARATOR_PRIORITY
2635 and leaf.parent.type in {syms.comp_op, syms.comparison}
2637 previous is not None
2638 and previous.type == token.NAME
2639 and previous.value == "not"
2642 return COMPARATOR_PRIORITY
2647 and leaf.parent.type == syms.comp_op
2649 previous is not None
2650 and previous.type == token.NAME
2651 and previous.value == "is"
2654 return COMPARATOR_PRIORITY
2656 if leaf.value in LOGIC_OPERATORS and leaf.parent:
2657 return LOGIC_PRIORITY
2662 FMT_OFF = {"# fmt: off", "# fmt:off", "# yapf: disable"}
2663 FMT_SKIP = {"# fmt: skip", "# fmt:skip"}
2664 FMT_PASS = {*FMT_OFF, *FMT_SKIP}
2665 FMT_ON = {"# fmt: on", "# fmt:on", "# yapf: enable"}
2668 def generate_comments(leaf: LN) -> Iterator[Leaf]:
2669 """Clean the prefix of the `leaf` and generate comments from it, if any.
2671 Comments in lib2to3 are shoved into the whitespace prefix. This happens
2672 in `pgen2/driver.py:Driver.parse_tokens()`. This was a brilliant implementation
2673 move because it does away with modifying the grammar to include all the
2674 possible places in which comments can be placed.
2676 The sad consequence for us though is that comments don't "belong" anywhere.
2677 This is why this function generates simple parentless Leaf objects for
2678 comments. We simply don't know what the correct parent should be.
2680 No matter though, we can live without this. We really only need to
2681 differentiate between inline and standalone comments. The latter don't
2682 share the line with any code.
2684 Inline comments are emitted as regular token.COMMENT leaves. Standalone
2685 are emitted with a fake STANDALONE_COMMENT token identifier.
2687 for pc in list_comments(leaf.prefix, is_endmarker=leaf.type == token.ENDMARKER):
2688 yield Leaf(pc.type, pc.value, prefix="\n" * pc.newlines)
2693 """Describes a piece of syntax that is a comment.
2695 It's not a :class:`blib2to3.pytree.Leaf` so that:
2697 * it can be cached (`Leaf` objects should not be reused more than once as
2698 they store their lineno, column, prefix, and parent information);
2699 * `newlines` and `consumed` fields are kept separate from the `value`. This
2700 simplifies handling of special marker comments like ``# fmt: off/on``.
2703 type: int # token.COMMENT or STANDALONE_COMMENT
2704 value: str # content of the comment
2705 newlines: int # how many newlines before the comment
2706 consumed: int # how many characters of the original leaf's prefix did we consume
2709 @lru_cache(maxsize=4096)
2710 def list_comments(prefix: str, *, is_endmarker: bool) -> List[ProtoComment]:
2711 """Return a list of :class:`ProtoComment` objects parsed from the given `prefix`."""
2712 result: List[ProtoComment] = []
2713 if not prefix or "#" not in prefix:
2719 for index, line in enumerate(re.split("\r?\n", prefix)):
2720 consumed += len(line) + 1 # adding the length of the split '\n'
2721 line = line.lstrip()
2724 if not line.startswith("#"):
2725 # Escaped newlines outside of a comment are not really newlines at
2726 # all. We treat a single-line comment following an escaped newline
2727 # as a simple trailing comment.
2728 if line.endswith("\\"):
2732 if index == ignored_lines and not is_endmarker:
2733 comment_type = token.COMMENT # simple trailing comment
2735 comment_type = STANDALONE_COMMENT
2736 comment = make_comment(line)
2739 type=comment_type, value=comment, newlines=nlines, consumed=consumed
2746 def make_comment(content: str) -> str:
2747 """Return a consistently formatted comment from the given `content` string.
2749 All comments (except for "##", "#!", "#:", '#'", "#%%") should have a single
2750 space between the hash sign and the content.
2752 If `content` didn't start with a hash sign, one is provided.
2754 content = content.rstrip()
2758 if content[0] == "#":
2759 content = content[1:]
2760 NON_BREAKING_SPACE = " "
2763 and content[0] == NON_BREAKING_SPACE
2764 and not content.lstrip().startswith("type:")
2766 content = " " + content[1:] # Replace NBSP by a simple space
2767 if content and content[0] not in " !:#'%":
2768 content = " " + content
2769 return "#" + content
2773 line: Line, mode: Mode, features: Collection[Feature] = ()
2774 ) -> Iterator[Line]:
2775 """Transform a `line`, potentially splitting it into many lines.
2777 They should fit in the allotted `line_length` but might not be able to.
2779 `features` are syntactical features that may be used in the output.
2785 line_str = line_to_string(line)
2787 def init_st(ST: Type[StringTransformer]) -> StringTransformer:
2788 """Initialize StringTransformer"""
2789 return ST(mode.line_length, mode.string_normalization)
2791 string_merge = init_st(StringMerger)
2792 string_paren_strip = init_st(StringParenStripper)
2793 string_split = init_st(StringSplitter)
2794 string_paren_wrap = init_st(StringParenWrapper)
2796 transformers: List[Transformer]
2798 not line.contains_uncollapsable_type_comments()
2799 and not line.should_split_rhs
2800 and not line.magic_trailing_comma
2802 is_line_short_enough(line, line_length=mode.line_length, line_str=line_str)
2803 or line.contains_unsplittable_type_ignore()
2805 and not (line.inside_brackets and line.contains_standalone_comments())
2807 # Only apply basic string preprocessing, since lines shouldn't be split here.
2808 if mode.experimental_string_processing:
2809 transformers = [string_merge, string_paren_strip]
2813 transformers = [left_hand_split]
2816 def rhs(line: Line, features: Collection[Feature]) -> Iterator[Line]:
2817 """Wraps calls to `right_hand_split`.
2819 The calls increasingly `omit` right-hand trailers (bracket pairs with
2820 content), meaning the trailers get glued together to split on another
2821 bracket pair instead.
2823 for omit in generate_trailers_to_omit(line, mode.line_length):
2825 right_hand_split(line, mode.line_length, features, omit=omit)
2827 # Note: this check is only able to figure out if the first line of the
2828 # *current* transformation fits in the line length. This is true only
2829 # for simple cases. All others require running more transforms via
2830 # `transform_line()`. This check doesn't know if those would succeed.
2831 if is_line_short_enough(lines[0], line_length=mode.line_length):
2835 # All splits failed, best effort split with no omits.
2836 # This mostly happens to multiline strings that are by definition
2837 # reported as not fitting a single line, as well as lines that contain
2838 # trailing commas (those have to be exploded).
2839 yield from right_hand_split(
2840 line, line_length=mode.line_length, features=features
2843 if mode.experimental_string_processing:
2844 if line.inside_brackets:
2850 standalone_comment_split,
2863 if line.inside_brackets:
2864 transformers = [delimiter_split, standalone_comment_split, rhs]
2866 transformers = [rhs]
2868 for transform in transformers:
2869 # We are accumulating lines in `result` because we might want to abort
2870 # mission and return the original line in the end, or attempt a different
2873 result = run_transformer(line, transform, mode, features, line_str=line_str)
2874 except CannotTransform:
2884 @dataclass # type: ignore
2885 class StringTransformer(ABC):
2887 An implementation of the Transformer protocol that relies on its
2888 subclasses overriding the template methods `do_match(...)` and
2889 `do_transform(...)`.
2891 This Transformer works exclusively on strings (for example, by merging
2894 The following sections can be found among the docstrings of each concrete
2895 StringTransformer subclass.
2898 Which requirements must be met of the given Line for this
2899 StringTransformer to be applied?
2902 If the given Line meets all of the above requirements, which string
2903 transformations can you expect to be applied to it by this
2907 What contractual agreements does this StringTransformer have with other
2908 StringTransfomers? Such collaborations should be eliminated/minimized
2909 as much as possible.
2913 normalize_strings: bool
2914 __name__ = "StringTransformer"
2917 def do_match(self, line: Line) -> TMatchResult:
2920 * Ok(string_idx) such that `line.leaves[string_idx]` is our target
2921 string, if a match was able to be made.
2923 * Err(CannotTransform), if a match was not able to be made.
2927 def do_transform(self, line: Line, string_idx: int) -> Iterator[TResult[Line]]:
2930 * Ok(new_line) where new_line is the new transformed line.
2932 * Err(CannotTransform) if the transformation failed for some reason. The
2933 `do_match(...)` template method should usually be used to reject
2934 the form of the given Line, but in some cases it is difficult to
2935 know whether or not a Line meets the StringTransformer's
2936 requirements until the transformation is already midway.
2939 This method should NOT mutate @line directly, but it MAY mutate the
2940 Line's underlying Node structure. (WARNING: If the underlying Node
2941 structure IS altered, then this method should NOT be allowed to
2942 yield an CannotTransform after that point.)
2945 def __call__(self, line: Line, _features: Collection[Feature]) -> Iterator[Line]:
2947 StringTransformer instances have a call signature that mirrors that of
2948 the Transformer type.
2951 CannotTransform(...) if the concrete StringTransformer class is unable
2954 # Optimization to avoid calling `self.do_match(...)` when the line does
2955 # not contain any string.
2956 if not any(leaf.type == token.STRING for leaf in line.leaves):
2957 raise CannotTransform("There are no strings in this line.")
2959 match_result = self.do_match(line)
2961 if isinstance(match_result, Err):
2962 cant_transform = match_result.err()
2963 raise CannotTransform(
2964 f"The string transformer {self.__class__.__name__} does not recognize"
2965 " this line as one that it can transform."
2966 ) from cant_transform
2968 string_idx = match_result.ok()
2970 for line_result in self.do_transform(line, string_idx):
2971 if isinstance(line_result, Err):
2972 cant_transform = line_result.err()
2973 raise CannotTransform(
2974 "StringTransformer failed while attempting to transform string."
2975 ) from cant_transform
2976 line = line_result.ok()
2982 """A custom (i.e. manual) string split.
2984 A single CustomSplit instance represents a single substring.
2987 Consider the following string:
2994 This string will correspond to the following three CustomSplit instances:
2996 CustomSplit(False, 16)
2997 CustomSplit(False, 17)
2998 CustomSplit(True, 16)
3006 class CustomSplitMapMixin:
3008 This mixin class is used to map merged strings to a sequence of
3009 CustomSplits, which will then be used to re-split the strings iff none of
3010 the resultant substrings go over the configured max line length.
3013 _Key = Tuple[StringID, str]
3014 _CUSTOM_SPLIT_MAP: Dict[_Key, Tuple[CustomSplit, ...]] = defaultdict(tuple)
3017 def _get_key(string: str) -> "CustomSplitMapMixin._Key":
3020 A unique identifier that is used internally to map @string to a
3021 group of custom splits.
3023 return (id(string), string)
3025 def add_custom_splits(
3026 self, string: str, custom_splits: Iterable[CustomSplit]
3028 """Custom Split Map Setter Method
3031 Adds a mapping from @string to the custom splits @custom_splits.
3033 key = self._get_key(string)
3034 self._CUSTOM_SPLIT_MAP[key] = tuple(custom_splits)
3036 def pop_custom_splits(self, string: str) -> List[CustomSplit]:
3037 """Custom Split Map Getter Method
3040 * A list of the custom splits that are mapped to @string, if any
3046 Deletes the mapping between @string and its associated custom
3047 splits (which are returned to the caller).
3049 key = self._get_key(string)
3051 custom_splits = self._CUSTOM_SPLIT_MAP[key]
3052 del self._CUSTOM_SPLIT_MAP[key]
3054 return list(custom_splits)
3056 def has_custom_splits(self, string: str) -> bool:
3059 True iff @string is associated with a set of custom splits.
3061 key = self._get_key(string)
3062 return key in self._CUSTOM_SPLIT_MAP
3065 class StringMerger(CustomSplitMapMixin, StringTransformer):
3066 """StringTransformer that merges strings together.
3069 (A) The line contains adjacent strings such that ALL of the validation checks
3070 listed in StringMerger.__validate_msg(...)'s docstring pass.
3072 (B) The line contains a string which uses line continuation backslashes.
3075 Depending on which of the two requirements above where met, either:
3077 (A) The string group associated with the target string is merged.
3079 (B) All line-continuation backslashes are removed from the target string.
3082 StringMerger provides custom split information to StringSplitter.
3085 def do_match(self, line: Line) -> TMatchResult:
3088 is_valid_index = is_valid_index_factory(LL)
3090 for (i, leaf) in enumerate(LL):
3092 leaf.type == token.STRING
3093 and is_valid_index(i + 1)
3094 and LL[i + 1].type == token.STRING
3098 if leaf.type == token.STRING and "\\\n" in leaf.value:
3101 return TErr("This line has no strings that need merging.")
3103 def do_transform(self, line: Line, string_idx: int) -> Iterator[TResult[Line]]:
3105 rblc_result = self.__remove_backslash_line_continuation_chars(
3106 new_line, string_idx
3108 if isinstance(rblc_result, Ok):
3109 new_line = rblc_result.ok()
3111 msg_result = self.__merge_string_group(new_line, string_idx)
3112 if isinstance(msg_result, Ok):
3113 new_line = msg_result.ok()
3115 if isinstance(rblc_result, Err) and isinstance(msg_result, Err):
3116 msg_cant_transform = msg_result.err()
3117 rblc_cant_transform = rblc_result.err()
3118 cant_transform = CannotTransform(
3119 "StringMerger failed to merge any strings in this line."
3122 # Chain the errors together using `__cause__`.
3123 msg_cant_transform.__cause__ = rblc_cant_transform
3124 cant_transform.__cause__ = msg_cant_transform
3126 yield Err(cant_transform)
3131 def __remove_backslash_line_continuation_chars(
3132 line: Line, string_idx: int
3135 Merge strings that were split across multiple lines using
3136 line-continuation backslashes.
3139 Ok(new_line), if @line contains backslash line-continuation
3142 Err(CannotTransform), otherwise.
3146 string_leaf = LL[string_idx]
3148 string_leaf.type == token.STRING
3149 and "\\\n" in string_leaf.value
3150 and not has_triple_quotes(string_leaf.value)
3153 f"String leaf {string_leaf} does not contain any backslash line"
3154 " continuation characters."
3157 new_line = line.clone()
3158 new_line.comments = line.comments.copy()
3159 append_leaves(new_line, line, LL)
3161 new_string_leaf = new_line.leaves[string_idx]
3162 new_string_leaf.value = new_string_leaf.value.replace("\\\n", "")
3166 def __merge_string_group(self, line: Line, string_idx: int) -> TResult[Line]:
3168 Merges string group (i.e. set of adjacent strings) where the first
3169 string in the group is `line.leaves[string_idx]`.
3172 Ok(new_line), if ALL of the validation checks found in
3173 __validate_msg(...) pass.
3175 Err(CannotTransform), otherwise.
3179 is_valid_index = is_valid_index_factory(LL)
3181 vresult = self.__validate_msg(line, string_idx)
3182 if isinstance(vresult, Err):
3185 # If the string group is wrapped inside an Atom node, we must make sure
3186 # to later replace that Atom with our new (merged) string leaf.
3187 atom_node = LL[string_idx].parent
3189 # We will place BREAK_MARK in between every two substrings that we
3190 # merge. We will then later go through our final result and use the
3191 # various instances of BREAK_MARK we find to add the right values to
3192 # the custom split map.
3193 BREAK_MARK = "@@@@@ BLACK BREAKPOINT MARKER @@@@@"
3195 QUOTE = LL[string_idx].value[-1]
3197 def make_naked(string: str, string_prefix: str) -> str:
3198 """Strip @string (i.e. make it a "naked" string)
3201 * assert_is_leaf_string(@string)
3204 A string that is identical to @string except that
3205 @string_prefix has been stripped, the surrounding QUOTE
3206 characters have been removed, and any remaining QUOTE
3207 characters have been escaped.
3209 assert_is_leaf_string(string)
3211 RE_EVEN_BACKSLASHES = r"(?:(?<!\\)(?:\\\\)*)"
3212 naked_string = string[len(string_prefix) + 1 : -1]
3213 naked_string = re.sub(
3214 "(" + RE_EVEN_BACKSLASHES + ")" + QUOTE, r"\1\\" + QUOTE, naked_string
3218 # Holds the CustomSplit objects that will later be added to the custom
3222 # Temporary storage for the 'has_prefix' part of the CustomSplit objects.
3225 # Sets the 'prefix' variable. This is the prefix that the final merged
3227 next_str_idx = string_idx
3231 and is_valid_index(next_str_idx)
3232 and LL[next_str_idx].type == token.STRING
3234 prefix = get_string_prefix(LL[next_str_idx].value)
3237 # The next loop merges the string group. The final string will be
3240 # The following convenience variables are used:
3245 # NSS: naked next string
3249 next_str_idx = string_idx
3250 while is_valid_index(next_str_idx) and LL[next_str_idx].type == token.STRING:
3253 SS = LL[next_str_idx].value
3254 next_prefix = get_string_prefix(SS)
3256 # If this is an f-string group but this substring is not prefixed
3258 if "f" in prefix and "f" not in next_prefix:
3259 # Then we must escape any braces contained in this substring.
3260 SS = re.subf(r"(\{|\})", "{1}{1}", SS)
3262 NSS = make_naked(SS, next_prefix)
3264 has_prefix = bool(next_prefix)
3265 prefix_tracker.append(has_prefix)
3267 S = prefix + QUOTE + NS + NSS + BREAK_MARK + QUOTE
3268 NS = make_naked(S, prefix)
3272 S_leaf = Leaf(token.STRING, S)
3273 if self.normalize_strings:
3274 normalize_string_quotes(S_leaf)
3276 # Fill the 'custom_splits' list with the appropriate CustomSplit objects.
3277 temp_string = S_leaf.value[len(prefix) + 1 : -1]
3278 for has_prefix in prefix_tracker:
3279 mark_idx = temp_string.find(BREAK_MARK)
3282 ), "Logic error while filling the custom string breakpoint cache."
3284 temp_string = temp_string[mark_idx + len(BREAK_MARK) :]
3285 breakpoint_idx = mark_idx + (len(prefix) if has_prefix else 0) + 1
3286 custom_splits.append(CustomSplit(has_prefix, breakpoint_idx))
3288 string_leaf = Leaf(token.STRING, S_leaf.value.replace(BREAK_MARK, ""))
3290 if atom_node is not None:
3291 replace_child(atom_node, string_leaf)
3293 # Build the final line ('new_line') that this method will later return.
3294 new_line = line.clone()
3295 for (i, leaf) in enumerate(LL):
3297 new_line.append(string_leaf)
3299 if string_idx <= i < string_idx + num_of_strings:
3300 for comment_leaf in line.comments_after(LL[i]):
3301 new_line.append(comment_leaf, preformatted=True)
3304 append_leaves(new_line, line, [leaf])
3306 self.add_custom_splits(string_leaf.value, custom_splits)
3310 def __validate_msg(line: Line, string_idx: int) -> TResult[None]:
3311 """Validate (M)erge (S)tring (G)roup
3313 Transform-time string validation logic for __merge_string_group(...).
3316 * Ok(None), if ALL validation checks (listed below) pass.
3318 * Err(CannotTransform), if any of the following are true:
3319 - The target string group does not contain ANY stand-alone comments.
3320 - The target string is not in a string group (i.e. it has no
3322 - The string group has more than one inline comment.
3323 - The string group has an inline comment that appears to be a pragma.
3324 - The set of all string prefixes in the string group is of
3325 length greater than one and is not equal to {"", "f"}.
3326 - The string group consists of raw strings.
3328 # We first check for "inner" stand-alone comments (i.e. stand-alone
3329 # comments that have a string leaf before them AND after them).
3332 found_sa_comment = False
3333 is_valid_index = is_valid_index_factory(line.leaves)
3334 while is_valid_index(i) and line.leaves[i].type in [
3338 if line.leaves[i].type == STANDALONE_COMMENT:
3339 found_sa_comment = True
3340 elif found_sa_comment:
3342 "StringMerger does NOT merge string groups which contain "
3343 "stand-alone comments."
3348 num_of_inline_string_comments = 0
3349 set_of_prefixes = set()
3351 for leaf in line.leaves[string_idx:]:
3352 if leaf.type != token.STRING:
3353 # If the string group is trailed by a comma, we count the
3354 # comments trailing the comma to be one of the string group's
3356 if leaf.type == token.COMMA and id(leaf) in line.comments:
3357 num_of_inline_string_comments += 1
3360 if has_triple_quotes(leaf.value):
3361 return TErr("StringMerger does NOT merge multiline strings.")
3364 prefix = get_string_prefix(leaf.value)
3366 return TErr("StringMerger does NOT merge raw strings.")
3368 set_of_prefixes.add(prefix)
3370 if id(leaf) in line.comments:
3371 num_of_inline_string_comments += 1
3372 if contains_pragma_comment(line.comments[id(leaf)]):
3373 return TErr("Cannot merge strings which have pragma comments.")
3375 if num_of_strings < 2:
3377 f"Not enough strings to merge (num_of_strings={num_of_strings})."
3380 if num_of_inline_string_comments > 1:
3382 f"Too many inline string comments ({num_of_inline_string_comments})."
3385 if len(set_of_prefixes) > 1 and set_of_prefixes != {"", "f"}:
3386 return TErr(f"Too many different prefixes ({set_of_prefixes}).")
3391 class StringParenStripper(StringTransformer):
3392 """StringTransformer that strips surrounding parentheses from strings.
3395 The line contains a string which is surrounded by parentheses and:
3396 - The target string is NOT the only argument to a function call.
3397 - The target string is NOT a "pointless" string.
3398 - If the target string contains a PERCENT, the brackets are not
3399 preceeded or followed by an operator with higher precedence than
3403 The parentheses mentioned in the 'Requirements' section are stripped.
3406 StringParenStripper has its own inherent usefulness, but it is also
3407 relied on to clean up the parentheses created by StringParenWrapper (in
3408 the event that they are no longer needed).
3411 def do_match(self, line: Line) -> TMatchResult:
3414 is_valid_index = is_valid_index_factory(LL)
3416 for (idx, leaf) in enumerate(LL):
3417 # Should be a string...
3418 if leaf.type != token.STRING:
3421 # If this is a "pointless" string...
3424 and leaf.parent.parent
3425 and leaf.parent.parent.type == syms.simple_stmt
3429 # Should be preceded by a non-empty LPAR...
3431 not is_valid_index(idx - 1)
3432 or LL[idx - 1].type != token.LPAR
3433 or is_empty_lpar(LL[idx - 1])
3437 # That LPAR should NOT be preceded by a function name or a closing
3438 # bracket (which could be a function which returns a function or a
3439 # list/dictionary that contains a function)...
3440 if is_valid_index(idx - 2) and (
3441 LL[idx - 2].type == token.NAME or LL[idx - 2].type in CLOSING_BRACKETS
3447 # Skip the string trailer, if one exists.
3448 string_parser = StringParser()
3449 next_idx = string_parser.parse(LL, string_idx)
3451 # if the leaves in the parsed string include a PERCENT, we need to
3452 # make sure the initial LPAR is NOT preceded by an operator with
3453 # higher or equal precedence to PERCENT
3454 if is_valid_index(idx - 2):
3455 # mypy can't quite follow unless we name this
3456 before_lpar = LL[idx - 2]
3457 if token.PERCENT in {leaf.type for leaf in LL[idx - 1 : next_idx]} and (
3474 # only unary PLUS/MINUS
3476 and before_lpar.parent.type == syms.factor
3477 and (before_lpar.type in {token.PLUS, token.MINUS})
3482 # Should be followed by a non-empty RPAR...
3484 is_valid_index(next_idx)
3485 and LL[next_idx].type == token.RPAR
3486 and not is_empty_rpar(LL[next_idx])
3488 # That RPAR should NOT be followed by anything with higher
3489 # precedence than PERCENT
3490 if is_valid_index(next_idx + 1) and LL[next_idx + 1].type in {
3498 return Ok(string_idx)
3500 return TErr("This line has no strings wrapped in parens.")
3502 def do_transform(self, line: Line, string_idx: int) -> Iterator[TResult[Line]]:
3505 string_parser = StringParser()
3506 rpar_idx = string_parser.parse(LL, string_idx)
3508 for leaf in (LL[string_idx - 1], LL[rpar_idx]):
3509 if line.comments_after(leaf):
3511 "Will not strip parentheses which have comments attached to them."
3515 new_line = line.clone()
3516 new_line.comments = line.comments.copy()
3518 append_leaves(new_line, line, LL[: string_idx - 1])
3519 except BracketMatchError:
3520 # HACK: I believe there is currently a bug somewhere in
3521 # right_hand_split() that is causing brackets to not be tracked
3522 # properly by a shared BracketTracker.
3523 append_leaves(new_line, line, LL[: string_idx - 1], preformatted=True)
3525 string_leaf = Leaf(token.STRING, LL[string_idx].value)
3526 LL[string_idx - 1].remove()
3527 replace_child(LL[string_idx], string_leaf)
3528 new_line.append(string_leaf)
3531 new_line, line, LL[string_idx + 1 : rpar_idx] + LL[rpar_idx + 1 :]
3534 LL[rpar_idx].remove()
3539 class BaseStringSplitter(StringTransformer):
3541 Abstract class for StringTransformers which transform a Line's strings by splitting
3542 them or placing them on their own lines where necessary to avoid going over
3543 the configured line length.
3546 * The target string value is responsible for the line going over the
3547 line length limit. It follows that after all of black's other line
3548 split methods have been exhausted, this line (or one of the resulting
3549 lines after all line splits are performed) would still be over the
3550 line_length limit unless we split this string.
3552 * The target string is NOT a "pointless" string (i.e. a string that has
3553 no parent or siblings).
3555 * The target string is not followed by an inline comment that appears
3558 * The target string is not a multiline (i.e. triple-quote) string.
3562 def do_splitter_match(self, line: Line) -> TMatchResult:
3564 BaseStringSplitter asks its clients to override this method instead of
3565 `StringTransformer.do_match(...)`.
3567 Follows the same protocol as `StringTransformer.do_match(...)`.
3569 Refer to `help(StringTransformer.do_match)` for more information.
3572 def do_match(self, line: Line) -> TMatchResult:
3573 match_result = self.do_splitter_match(line)
3574 if isinstance(match_result, Err):
3577 string_idx = match_result.ok()
3578 vresult = self.__validate(line, string_idx)
3579 if isinstance(vresult, Err):
3584 def __validate(self, line: Line, string_idx: int) -> TResult[None]:
3586 Checks that @line meets all of the requirements listed in this classes'
3587 docstring. Refer to `help(BaseStringSplitter)` for a detailed
3588 description of those requirements.
3591 * Ok(None), if ALL of the requirements are met.
3593 * Err(CannotTransform), if ANY of the requirements are NOT met.
3597 string_leaf = LL[string_idx]
3599 max_string_length = self.__get_max_string_length(line, string_idx)
3600 if len(string_leaf.value) <= max_string_length:
3602 "The string itself is not what is causing this line to be too long."
3605 if not string_leaf.parent or [L.type for L in string_leaf.parent.children] == [
3610 f"This string ({string_leaf.value}) appears to be pointless (i.e. has"
3614 if id(line.leaves[string_idx]) in line.comments and contains_pragma_comment(
3615 line.comments[id(line.leaves[string_idx])]
3618 "Line appears to end with an inline pragma comment. Splitting the line"
3619 " could modify the pragma's behavior."
3622 if has_triple_quotes(string_leaf.value):
3623 return TErr("We cannot split multiline strings.")
3627 def __get_max_string_length(self, line: Line, string_idx: int) -> int:
3629 Calculates the max string length used when attempting to determine
3630 whether or not the target string is responsible for causing the line to
3631 go over the line length limit.
3633 WARNING: This method is tightly coupled to both StringSplitter and
3634 (especially) StringParenWrapper. There is probably a better way to
3635 accomplish what is being done here.
3638 max_string_length: such that `line.leaves[string_idx].value >
3639 max_string_length` implies that the target string IS responsible
3640 for causing this line to exceed the line length limit.
3644 is_valid_index = is_valid_index_factory(LL)
3646 # We use the shorthand "WMA4" in comments to abbreviate "We must
3647 # account for". When giving examples, we use STRING to mean some/any
3650 # Finally, we use the following convenience variables:
3652 # P: The leaf that is before the target string leaf.
3653 # N: The leaf that is after the target string leaf.
3654 # NN: The leaf that is after N.
3656 # WMA4 the whitespace at the beginning of the line.
3657 offset = line.depth * 4
3659 if is_valid_index(string_idx - 1):
3660 p_idx = string_idx - 1
3662 LL[string_idx - 1].type == token.LPAR
3663 and LL[string_idx - 1].value == ""
3666 # If the previous leaf is an empty LPAR placeholder, we should skip it.
3670 if P.type == token.PLUS:
3671 # WMA4 a space and a '+' character (e.g. `+ STRING`).
3674 if P.type == token.COMMA:
3675 # WMA4 a space, a comma, and a closing bracket [e.g. `), STRING`].
3678 if P.type in [token.COLON, token.EQUAL, token.NAME]:
3679 # This conditional branch is meant to handle dictionary keys,
3680 # variable assignments, 'return STRING' statement lines, and
3681 # 'else STRING' ternary expression lines.
3683 # WMA4 a single space.
3686 # WMA4 the lengths of any leaves that came before that space,
3687 # but after any closing bracket before that space.
3688 for leaf in reversed(LL[: p_idx + 1]):
3689 offset += len(str(leaf))
3690 if leaf.type in CLOSING_BRACKETS:
3693 if is_valid_index(string_idx + 1):
3694 N = LL[string_idx + 1]
3695 if N.type == token.RPAR and N.value == "" and len(LL) > string_idx + 2:
3696 # If the next leaf is an empty RPAR placeholder, we should skip it.
3697 N = LL[string_idx + 2]
3699 if N.type == token.COMMA:
3700 # WMA4 a single comma at the end of the string (e.g `STRING,`).
3703 if is_valid_index(string_idx + 2):
3704 NN = LL[string_idx + 2]
3706 if N.type == token.DOT and NN.type == token.NAME:
3707 # This conditional branch is meant to handle method calls invoked
3708 # off of a string literal up to and including the LPAR character.
3710 # WMA4 the '.' character.
3714 is_valid_index(string_idx + 3)
3715 and LL[string_idx + 3].type == token.LPAR
3717 # WMA4 the left parenthesis character.
3720 # WMA4 the length of the method's name.
3721 offset += len(NN.value)
3723 has_comments = False
3724 for comment_leaf in line.comments_after(LL[string_idx]):
3725 if not has_comments:
3727 # WMA4 two spaces before the '#' character.
3730 # WMA4 the length of the inline comment.
3731 offset += len(comment_leaf.value)
3733 max_string_length = self.line_length - offset
3734 return max_string_length
3737 class StringSplitter(CustomSplitMapMixin, BaseStringSplitter):
3739 StringTransformer that splits "atom" strings (i.e. strings which exist on
3740 lines by themselves).
3743 * The line consists ONLY of a single string (with the exception of a
3744 '+' symbol which MAY exist at the start of the line), MAYBE a string
3745 trailer, and MAYBE a trailing comma.
3747 * All of the requirements listed in BaseStringSplitter's docstring.
3750 The string mentioned in the 'Requirements' section is split into as
3751 many substrings as necessary to adhere to the configured line length.
3753 In the final set of substrings, no substring should be smaller than
3754 MIN_SUBSTR_SIZE characters.
3756 The string will ONLY be split on spaces (i.e. each new substring should
3757 start with a space). Note that the string will NOT be split on a space
3758 which is escaped with a backslash.
3760 If the string is an f-string, it will NOT be split in the middle of an
3761 f-expression (e.g. in f"FooBar: {foo() if x else bar()}", {foo() if x
3762 else bar()} is an f-expression).
3764 If the string that is being split has an associated set of custom split
3765 records and those custom splits will NOT result in any line going over
3766 the configured line length, those custom splits are used. Otherwise the
3767 string is split as late as possible (from left-to-right) while still
3768 adhering to the transformation rules listed above.
3771 StringSplitter relies on StringMerger to construct the appropriate
3772 CustomSplit objects and add them to the custom split map.
3776 # Matches an "f-expression" (e.g. {var}) that might be found in an f-string.
3778 (?<!\{) (?:\{\{)* \{ (?!\{)
3785 (?<!\}) \} (?:\}\})* (?!\})
3788 def do_splitter_match(self, line: Line) -> TMatchResult:
3791 is_valid_index = is_valid_index_factory(LL)
3795 # The first leaf MAY be a '+' symbol...
3796 if is_valid_index(idx) and LL[idx].type == token.PLUS:
3799 # The next/first leaf MAY be an empty LPAR...
3800 if is_valid_index(idx) and is_empty_lpar(LL[idx]):
3803 # The next/first leaf MUST be a string...
3804 if not is_valid_index(idx) or LL[idx].type != token.STRING:
3805 return TErr("Line does not start with a string.")
3809 # Skip the string trailer, if one exists.
3810 string_parser = StringParser()
3811 idx = string_parser.parse(LL, string_idx)
3813 # That string MAY be followed by an empty RPAR...
3814 if is_valid_index(idx) and is_empty_rpar(LL[idx]):
3817 # That string / empty RPAR leaf MAY be followed by a comma...
3818 if is_valid_index(idx) and LL[idx].type == token.COMMA:
3821 # But no more leaves are allowed...
3822 if is_valid_index(idx):
3823 return TErr("This line does not end with a string.")
3825 return Ok(string_idx)
3827 def do_transform(self, line: Line, string_idx: int) -> Iterator[TResult[Line]]:
3830 QUOTE = LL[string_idx].value[-1]
3832 is_valid_index = is_valid_index_factory(LL)
3833 insert_str_child = insert_str_child_factory(LL[string_idx])
3835 prefix = get_string_prefix(LL[string_idx].value)
3837 # We MAY choose to drop the 'f' prefix from substrings that don't
3838 # contain any f-expressions, but ONLY if the original f-string
3839 # contains at least one f-expression. Otherwise, we will alter the AST
3841 drop_pointless_f_prefix = ("f" in prefix) and re.search(
3842 self.RE_FEXPR, LL[string_idx].value, re.VERBOSE
3845 first_string_line = True
3846 starts_with_plus = LL[0].type == token.PLUS
3848 def line_needs_plus() -> bool:
3849 return first_string_line and starts_with_plus
3851 def maybe_append_plus(new_line: Line) -> None:
3854 If @line starts with a plus and this is the first line we are
3855 constructing, this function appends a PLUS leaf to @new_line
3856 and replaces the old PLUS leaf in the node structure. Otherwise
3857 this function does nothing.
3859 if line_needs_plus():
3860 plus_leaf = Leaf(token.PLUS, "+")
3861 replace_child(LL[0], plus_leaf)
3862 new_line.append(plus_leaf)
3865 is_valid_index(string_idx + 1) and LL[string_idx + 1].type == token.COMMA
3868 def max_last_string() -> int:
3871 The max allowed length of the string value used for the last
3872 line we will construct.
3874 result = self.line_length
3875 result -= line.depth * 4
3876 result -= 1 if ends_with_comma else 0
3877 result -= 2 if line_needs_plus() else 0
3880 # --- Calculate Max Break Index (for string value)
3881 # We start with the line length limit
3882 max_break_idx = self.line_length
3883 # The last index of a string of length N is N-1.
3885 # Leading whitespace is not present in the string value (e.g. Leaf.value).
3886 max_break_idx -= line.depth * 4
3887 if max_break_idx < 0:
3889 f"Unable to split {LL[string_idx].value} at such high of a line depth:"
3894 # Check if StringMerger registered any custom splits.
3895 custom_splits = self.pop_custom_splits(LL[string_idx].value)
3896 # We use them ONLY if none of them would produce lines that exceed the
3898 use_custom_breakpoints = bool(
3900 and all(csplit.break_idx <= max_break_idx for csplit in custom_splits)
3903 # Temporary storage for the remaining chunk of the string line that
3904 # can't fit onto the line currently being constructed.
3905 rest_value = LL[string_idx].value
3907 def more_splits_should_be_made() -> bool:
3910 True iff `rest_value` (the remaining string value from the last
3911 split), should be split again.
3913 if use_custom_breakpoints:
3914 return len(custom_splits) > 1
3916 return len(rest_value) > max_last_string()
3918 string_line_results: List[Ok[Line]] = []
3919 while more_splits_should_be_made():
3920 if use_custom_breakpoints:
3921 # Custom User Split (manual)
3922 csplit = custom_splits.pop(0)
3923 break_idx = csplit.break_idx
3925 # Algorithmic Split (automatic)
3926 max_bidx = max_break_idx - 2 if line_needs_plus() else max_break_idx
3927 maybe_break_idx = self.__get_break_idx(rest_value, max_bidx)
3928 if maybe_break_idx is None:
3929 # If we are unable to algorithmically determine a good split
3930 # and this string has custom splits registered to it, we
3931 # fall back to using them--which means we have to start
3932 # over from the beginning.
3934 rest_value = LL[string_idx].value
3935 string_line_results = []
3936 first_string_line = True
3937 use_custom_breakpoints = True
3940 # Otherwise, we stop splitting here.
3943 break_idx = maybe_break_idx
3945 # --- Construct `next_value`
3946 next_value = rest_value[:break_idx] + QUOTE
3948 # Are we allowed to try to drop a pointless 'f' prefix?
3949 drop_pointless_f_prefix
3950 # If we are, will we be successful?
3951 and next_value != self.__normalize_f_string(next_value, prefix)
3953 # If the current custom split did NOT originally use a prefix,
3954 # then `csplit.break_idx` will be off by one after removing
3958 if use_custom_breakpoints and not csplit.has_prefix
3961 next_value = rest_value[:break_idx] + QUOTE
3962 next_value = self.__normalize_f_string(next_value, prefix)
3964 # --- Construct `next_leaf`
3965 next_leaf = Leaf(token.STRING, next_value)
3966 insert_str_child(next_leaf)
3967 self.__maybe_normalize_string_quotes(next_leaf)
3969 # --- Construct `next_line`
3970 next_line = line.clone()
3971 maybe_append_plus(next_line)
3972 next_line.append(next_leaf)
3973 string_line_results.append(Ok(next_line))
3975 rest_value = prefix + QUOTE + rest_value[break_idx:]
3976 first_string_line = False
3978 yield from string_line_results
3980 if drop_pointless_f_prefix:
3981 rest_value = self.__normalize_f_string(rest_value, prefix)
3983 rest_leaf = Leaf(token.STRING, rest_value)
3984 insert_str_child(rest_leaf)
3986 # NOTE: I could not find a test case that verifies that the following
3987 # line is actually necessary, but it seems to be. Otherwise we risk
3988 # not normalizing the last substring, right?
3989 self.__maybe_normalize_string_quotes(rest_leaf)
3991 last_line = line.clone()
3992 maybe_append_plus(last_line)
3994 # If there are any leaves to the right of the target string...
3995 if is_valid_index(string_idx + 1):
3996 # We use `temp_value` here to determine how long the last line
3997 # would be if we were to append all the leaves to the right of the
3998 # target string to the last string line.
3999 temp_value = rest_value
4000 for leaf in LL[string_idx + 1 :]:
4001 temp_value += str(leaf)
4002 if leaf.type == token.LPAR:
4005 # Try to fit them all on the same line with the last substring...
4007 len(temp_value) <= max_last_string()
4008 or LL[string_idx + 1].type == token.COMMA
4010 last_line.append(rest_leaf)
4011 append_leaves(last_line, line, LL[string_idx + 1 :])
4013 # Otherwise, place the last substring on one line and everything
4014 # else on a line below that...
4016 last_line.append(rest_leaf)
4019 non_string_line = line.clone()
4020 append_leaves(non_string_line, line, LL[string_idx + 1 :])
4021 yield Ok(non_string_line)
4022 # Else the target string was the last leaf...
4024 last_line.append(rest_leaf)
4025 last_line.comments = line.comments.copy()
4028 def __get_break_idx(self, string: str, max_break_idx: int) -> Optional[int]:
4030 This method contains the algorithm that StringSplitter uses to
4031 determine which character to split each string at.
4034 @string: The substring that we are attempting to split.
4035 @max_break_idx: The ideal break index. We will return this value if it
4036 meets all the necessary conditions. In the likely event that it
4037 doesn't we will try to find the closest index BELOW @max_break_idx
4038 that does. If that fails, we will expand our search by also
4039 considering all valid indices ABOVE @max_break_idx.
4042 * assert_is_leaf_string(@string)
4043 * 0 <= @max_break_idx < len(@string)
4046 break_idx, if an index is able to be found that meets all of the
4047 conditions listed in the 'Transformations' section of this classes'
4052 is_valid_index = is_valid_index_factory(string)
4054 assert is_valid_index(max_break_idx)
4055 assert_is_leaf_string(string)
4057 _fexpr_slices: Optional[List[Tuple[Index, Index]]] = None
4059 def fexpr_slices() -> Iterator[Tuple[Index, Index]]:
4062 All ranges of @string which, if @string were to be split there,
4063 would result in the splitting of an f-expression (which is NOT
4066 nonlocal _fexpr_slices
4068 if _fexpr_slices is None:
4070 for match in re.finditer(self.RE_FEXPR, string, re.VERBOSE):
4071 _fexpr_slices.append(match.span())
4073 yield from _fexpr_slices
4075 is_fstring = "f" in get_string_prefix(string)
4077 def breaks_fstring_expression(i: Index) -> bool:
4080 True iff returning @i would result in the splitting of an
4081 f-expression (which is NOT allowed).
4086 for (start, end) in fexpr_slices():
4087 if start <= i < end:
4092 def passes_all_checks(i: Index) -> bool:
4095 True iff ALL of the conditions listed in the 'Transformations'
4096 section of this classes' docstring would be be met by returning @i.
4098 is_space = string[i] == " "
4100 is_not_escaped = True
4102 while is_valid_index(j) and string[j] == "\\":
4103 is_not_escaped = not is_not_escaped
4107 len(string[i:]) >= self.MIN_SUBSTR_SIZE
4108 and len(string[:i]) >= self.MIN_SUBSTR_SIZE
4114 and not breaks_fstring_expression(i)
4117 # First, we check all indices BELOW @max_break_idx.
4118 break_idx = max_break_idx
4119 while is_valid_index(break_idx - 1) and not passes_all_checks(break_idx):
4122 if not passes_all_checks(break_idx):
4123 # If that fails, we check all indices ABOVE @max_break_idx.
4125 # If we are able to find a valid index here, the next line is going
4126 # to be longer than the specified line length, but it's probably
4127 # better than doing nothing at all.
4128 break_idx = max_break_idx + 1
4129 while is_valid_index(break_idx + 1) and not passes_all_checks(break_idx):
4132 if not is_valid_index(break_idx) or not passes_all_checks(break_idx):
4137 def __maybe_normalize_string_quotes(self, leaf: Leaf) -> None:
4138 if self.normalize_strings:
4139 normalize_string_quotes(leaf)
4141 def __normalize_f_string(self, string: str, prefix: str) -> str:
4144 * assert_is_leaf_string(@string)
4147 * If @string is an f-string that contains no f-expressions, we
4148 return a string identical to @string except that the 'f' prefix
4149 has been stripped and all double braces (i.e. '{{' or '}}') have
4150 been normalized (i.e. turned into '{' or '}').
4152 * Otherwise, we return @string.
4154 assert_is_leaf_string(string)
4156 if "f" in prefix and not re.search(self.RE_FEXPR, string, re.VERBOSE):
4157 new_prefix = prefix.replace("f", "")
4159 temp = string[len(prefix) :]
4160 temp = re.sub(r"\{\{", "{", temp)
4161 temp = re.sub(r"\}\}", "}", temp)
4164 return f"{new_prefix}{new_string}"
4169 class StringParenWrapper(CustomSplitMapMixin, BaseStringSplitter):
4171 StringTransformer that splits non-"atom" strings (i.e. strings that do not
4172 exist on lines by themselves).
4175 All of the requirements listed in BaseStringSplitter's docstring in
4176 addition to the requirements listed below:
4178 * The line is a return/yield statement, which returns/yields a string.
4180 * The line is part of a ternary expression (e.g. `x = y if cond else
4181 z`) such that the line starts with `else <string>`, where <string> is
4184 * The line is an assert statement, which ends with a string.
4186 * The line is an assignment statement (e.g. `x = <string>` or `x +=
4187 <string>`) such that the variable is being assigned the value of some
4190 * The line is a dictionary key assignment where some valid key is being
4191 assigned the value of some string.
4194 The chosen string is wrapped in parentheses and then split at the LPAR.
4196 We then have one line which ends with an LPAR and another line that
4197 starts with the chosen string. The latter line is then split again at
4198 the RPAR. This results in the RPAR (and possibly a trailing comma)
4199 being placed on its own line.
4201 NOTE: If any leaves exist to the right of the chosen string (except
4202 for a trailing comma, which would be placed after the RPAR), those
4203 leaves are placed inside the parentheses. In effect, the chosen
4204 string is not necessarily being "wrapped" by parentheses. We can,
4205 however, count on the LPAR being placed directly before the chosen
4208 In other words, StringParenWrapper creates "atom" strings. These
4209 can then be split again by StringSplitter, if necessary.
4212 In the event that a string line split by StringParenWrapper is
4213 changed such that it no longer needs to be given its own line,
4214 StringParenWrapper relies on StringParenStripper to clean up the
4215 parentheses it created.
4218 def do_splitter_match(self, line: Line) -> TMatchResult:
4222 self._return_match(LL)
4223 or self._else_match(LL)
4224 or self._assert_match(LL)
4225 or self._assign_match(LL)
4226 or self._dict_match(LL)
4229 if string_idx is not None:
4230 string_value = line.leaves[string_idx].value
4231 # If the string has no spaces...
4232 if " " not in string_value:
4233 # And will still violate the line length limit when split...
4234 max_string_length = self.line_length - ((line.depth + 1) * 4)
4235 if len(string_value) > max_string_length:
4236 # And has no associated custom splits...
4237 if not self.has_custom_splits(string_value):
4238 # Then we should NOT put this string on its own line.
4240 "We do not wrap long strings in parentheses when the"
4241 " resultant line would still be over the specified line"
4242 " length and can't be split further by StringSplitter."
4244 return Ok(string_idx)
4246 return TErr("This line does not contain any non-atomic strings.")
4249 def _return_match(LL: List[Leaf]) -> Optional[int]:
4252 string_idx such that @LL[string_idx] is equal to our target (i.e.
4253 matched) string, if this line matches the return/yield statement
4254 requirements listed in the 'Requirements' section of this classes'
4259 # If this line is apart of a return/yield statement and the first leaf
4260 # contains either the "return" or "yield" keywords...
4261 if parent_type(LL[0]) in [syms.return_stmt, syms.yield_expr] and LL[
4263 ].value in ["return", "yield"]:
4264 is_valid_index = is_valid_index_factory(LL)
4266 idx = 2 if is_valid_index(1) and is_empty_par(LL[1]) else 1
4267 # The next visible leaf MUST contain a string...
4268 if is_valid_index(idx) and LL[idx].type == token.STRING:
4274 def _else_match(LL: List[Leaf]) -> Optional[int]:
4277 string_idx such that @LL[string_idx] is equal to our target (i.e.
4278 matched) string, if this line matches the ternary expression
4279 requirements listed in the 'Requirements' section of this classes'
4284 # If this line is apart of a ternary expression and the first leaf
4285 # contains the "else" keyword...
4287 parent_type(LL[0]) == syms.test
4288 and LL[0].type == token.NAME
4289 and LL[0].value == "else"
4291 is_valid_index = is_valid_index_factory(LL)
4293 idx = 2 if is_valid_index(1) and is_empty_par(LL[1]) else 1
4294 # The next visible leaf MUST contain a string...
4295 if is_valid_index(idx) and LL[idx].type == token.STRING:
4301 def _assert_match(LL: List[Leaf]) -> Optional[int]:
4304 string_idx such that @LL[string_idx] is equal to our target (i.e.
4305 matched) string, if this line matches the assert statement
4306 requirements listed in the 'Requirements' section of this classes'
4311 # If this line is apart of an assert statement and the first leaf
4312 # contains the "assert" keyword...
4313 if parent_type(LL[0]) == syms.assert_stmt and LL[0].value == "assert":
4314 is_valid_index = is_valid_index_factory(LL)
4316 for (i, leaf) in enumerate(LL):
4317 # We MUST find a comma...
4318 if leaf.type == token.COMMA:
4319 idx = i + 2 if is_empty_par(LL[i + 1]) else i + 1
4321 # That comma MUST be followed by a string...
4322 if is_valid_index(idx) and LL[idx].type == token.STRING:
4325 # Skip the string trailer, if one exists.
4326 string_parser = StringParser()
4327 idx = string_parser.parse(LL, string_idx)
4329 # But no more leaves are allowed...
4330 if not is_valid_index(idx):
4336 def _assign_match(LL: List[Leaf]) -> Optional[int]:
4339 string_idx such that @LL[string_idx] is equal to our target (i.e.
4340 matched) string, if this line matches the assignment statement
4341 requirements listed in the 'Requirements' section of this classes'
4346 # If this line is apart of an expression statement or is a function
4347 # argument AND the first leaf contains a variable name...
4349 parent_type(LL[0]) in [syms.expr_stmt, syms.argument, syms.power]
4350 and LL[0].type == token.NAME
4352 is_valid_index = is_valid_index_factory(LL)
4354 for (i, leaf) in enumerate(LL):
4355 # We MUST find either an '=' or '+=' symbol...
4356 if leaf.type in [token.EQUAL, token.PLUSEQUAL]:
4357 idx = i + 2 if is_empty_par(LL[i + 1]) else i + 1
4359 # That symbol MUST be followed by a string...
4360 if is_valid_index(idx) and LL[idx].type == token.STRING:
4363 # Skip the string trailer, if one exists.
4364 string_parser = StringParser()
4365 idx = string_parser.parse(LL, string_idx)
4367 # The next leaf MAY be a comma iff this line is apart
4368 # of a function argument...
4370 parent_type(LL[0]) == syms.argument
4371 and is_valid_index(idx)
4372 and LL[idx].type == token.COMMA
4376 # But no more leaves are allowed...
4377 if not is_valid_index(idx):
4383 def _dict_match(LL: List[Leaf]) -> Optional[int]:
4386 string_idx such that @LL[string_idx] is equal to our target (i.e.
4387 matched) string, if this line matches the dictionary key assignment
4388 statement requirements listed in the 'Requirements' section of this
4393 # If this line is apart of a dictionary key assignment...
4394 if syms.dictsetmaker in [parent_type(LL[0]), parent_type(LL[0].parent)]:
4395 is_valid_index = is_valid_index_factory(LL)
4397 for (i, leaf) in enumerate(LL):
4398 # We MUST find a colon...
4399 if leaf.type == token.COLON:
4400 idx = i + 2 if is_empty_par(LL[i + 1]) else i + 1
4402 # That colon MUST be followed by a string...
4403 if is_valid_index(idx) and LL[idx].type == token.STRING:
4406 # Skip the string trailer, if one exists.
4407 string_parser = StringParser()
4408 idx = string_parser.parse(LL, string_idx)
4410 # That string MAY be followed by a comma...
4411 if is_valid_index(idx) and LL[idx].type == token.COMMA:
4414 # But no more leaves are allowed...
4415 if not is_valid_index(idx):
4420 def do_transform(self, line: Line, string_idx: int) -> Iterator[TResult[Line]]:
4423 is_valid_index = is_valid_index_factory(LL)
4424 insert_str_child = insert_str_child_factory(LL[string_idx])
4427 ends_with_comma = False
4428 if LL[comma_idx].type == token.COMMA:
4429 ends_with_comma = True
4431 leaves_to_steal_comments_from = [LL[string_idx]]
4433 leaves_to_steal_comments_from.append(LL[comma_idx])
4436 first_line = line.clone()
4437 left_leaves = LL[:string_idx]
4439 # We have to remember to account for (possibly invisible) LPAR and RPAR
4440 # leaves that already wrapped the target string. If these leaves do
4441 # exist, we will replace them with our own LPAR and RPAR leaves.
4442 old_parens_exist = False
4443 if left_leaves and left_leaves[-1].type == token.LPAR:
4444 old_parens_exist = True
4445 leaves_to_steal_comments_from.append(left_leaves[-1])
4448 append_leaves(first_line, line, left_leaves)
4450 lpar_leaf = Leaf(token.LPAR, "(")
4451 if old_parens_exist:
4452 replace_child(LL[string_idx - 1], lpar_leaf)
4454 insert_str_child(lpar_leaf)
4455 first_line.append(lpar_leaf)
4457 # We throw inline comments that were originally to the right of the
4458 # target string to the top line. They will now be shown to the right of
4460 for leaf in leaves_to_steal_comments_from:
4461 for comment_leaf in line.comments_after(leaf):
4462 first_line.append(comment_leaf, preformatted=True)
4464 yield Ok(first_line)
4466 # --- Middle (String) Line
4467 # We only need to yield one (possibly too long) string line, since the
4468 # `StringSplitter` will break it down further if necessary.
4469 string_value = LL[string_idx].value
4472 depth=line.depth + 1,
4473 inside_brackets=True,
4474 should_split_rhs=line.should_split_rhs,
4475 magic_trailing_comma=line.magic_trailing_comma,
4477 string_leaf = Leaf(token.STRING, string_value)
4478 insert_str_child(string_leaf)
4479 string_line.append(string_leaf)
4481 old_rpar_leaf = None
4482 if is_valid_index(string_idx + 1):
4483 right_leaves = LL[string_idx + 1 :]
4487 if old_parens_exist:
4489 right_leaves and right_leaves[-1].type == token.RPAR
4490 ), "Apparently, old parentheses do NOT exist?!"
4491 old_rpar_leaf = right_leaves.pop()
4493 append_leaves(string_line, line, right_leaves)
4495 yield Ok(string_line)
4498 last_line = line.clone()
4499 last_line.bracket_tracker = first_line.bracket_tracker
4501 new_rpar_leaf = Leaf(token.RPAR, ")")
4502 if old_rpar_leaf is not None:
4503 replace_child(old_rpar_leaf, new_rpar_leaf)
4505 insert_str_child(new_rpar_leaf)
4506 last_line.append(new_rpar_leaf)
4508 # If the target string ended with a comma, we place this comma to the
4509 # right of the RPAR on the last line.
4511 comma_leaf = Leaf(token.COMMA, ",")
4512 replace_child(LL[comma_idx], comma_leaf)
4513 last_line.append(comma_leaf)
4520 A state machine that aids in parsing a string's "trailer", which can be
4521 either non-existent, an old-style formatting sequence (e.g. `% varX` or `%
4522 (varX, varY)`), or a method-call / attribute access (e.g. `.format(varX,
4525 NOTE: A new StringParser object MUST be instantiated for each string
4526 trailer we need to parse.
4529 We shall assume that `line` equals the `Line` object that corresponds
4530 to the following line of python code:
4532 x = "Some {}.".format("String") + some_other_string
4535 Furthermore, we will assume that `string_idx` is some index such that:
4537 assert line.leaves[string_idx].value == "Some {}."
4540 The following code snippet then holds:
4542 string_parser = StringParser()
4543 idx = string_parser.parse(line.leaves, string_idx)
4544 assert line.leaves[idx].type == token.PLUS
4550 # String Parser States
4560 # Lookup Table for Next State
4561 _goto: Dict[Tuple[ParserState, NodeType], ParserState] = {
4562 # A string trailer may start with '.' OR '%'.
4563 (START, token.DOT): DOT,
4564 (START, token.PERCENT): PERCENT,
4565 (START, DEFAULT_TOKEN): DONE,
4566 # A '.' MUST be followed by an attribute or method name.
4567 (DOT, token.NAME): NAME,
4568 # A method name MUST be followed by an '(', whereas an attribute name
4569 # is the last symbol in the string trailer.
4570 (NAME, token.LPAR): LPAR,
4571 (NAME, DEFAULT_TOKEN): DONE,
4572 # A '%' symbol can be followed by an '(' or a single argument (e.g. a
4573 # string or variable name).
4574 (PERCENT, token.LPAR): LPAR,
4575 (PERCENT, DEFAULT_TOKEN): SINGLE_FMT_ARG,
4576 # If a '%' symbol is followed by a single argument, that argument is
4577 # the last leaf in the string trailer.
4578 (SINGLE_FMT_ARG, DEFAULT_TOKEN): DONE,
4579 # If present, a ')' symbol is the last symbol in a string trailer.
4580 # (NOTE: LPARS and nested RPARS are not included in this lookup table,
4581 # since they are treated as a special case by the parsing logic in this
4582 # classes' implementation.)
4583 (RPAR, DEFAULT_TOKEN): DONE,
4586 def __init__(self) -> None:
4587 self._state = self.START
4588 self._unmatched_lpars = 0
4590 def parse(self, leaves: List[Leaf], string_idx: int) -> int:
4593 * @leaves[@string_idx].type == token.STRING
4596 The index directly after the last leaf which is apart of the string
4597 trailer, if a "trailer" exists.
4599 @string_idx + 1, if no string "trailer" exists.
4601 assert leaves[string_idx].type == token.STRING
4603 idx = string_idx + 1
4604 while idx < len(leaves) and self._next_state(leaves[idx]):
4608 def _next_state(self, leaf: Leaf) -> bool:
4611 * On the first call to this function, @leaf MUST be the leaf that
4612 was directly after the string leaf in question (e.g. if our target
4613 string is `line.leaves[i]` then the first call to this method must
4614 be `line.leaves[i + 1]`).
4615 * On the next call to this function, the leaf parameter passed in
4616 MUST be the leaf directly following @leaf.
4619 True iff @leaf is apart of the string's trailer.
4621 # We ignore empty LPAR or RPAR leaves.
4622 if is_empty_par(leaf):
4625 next_token = leaf.type
4626 if next_token == token.LPAR:
4627 self._unmatched_lpars += 1
4629 current_state = self._state
4631 # The LPAR parser state is a special case. We will return True until we
4632 # find the matching RPAR token.
4633 if current_state == self.LPAR:
4634 if next_token == token.RPAR:
4635 self._unmatched_lpars -= 1
4636 if self._unmatched_lpars == 0:
4637 self._state = self.RPAR
4638 # Otherwise, we use a lookup table to determine the next state.
4640 # If the lookup table matches the current state to the next
4641 # token, we use the lookup table.
4642 if (current_state, next_token) in self._goto:
4643 self._state = self._goto[current_state, next_token]
4645 # Otherwise, we check if a the current state was assigned a
4647 if (current_state, self.DEFAULT_TOKEN) in self._goto:
4648 self._state = self._goto[current_state, self.DEFAULT_TOKEN]
4649 # If no default has been assigned, then this parser has a logic
4652 raise RuntimeError(f"{self.__class__.__name__} LOGIC ERROR!")
4654 if self._state == self.DONE:
4660 def TErr(err_msg: str) -> Err[CannotTransform]:
4663 Convenience function used when working with the TResult type.
4665 cant_transform = CannotTransform(err_msg)
4666 return Err(cant_transform)
4669 def contains_pragma_comment(comment_list: List[Leaf]) -> bool:
4672 True iff one of the comments in @comment_list is a pragma used by one
4673 of the more common static analysis tools for python (e.g. mypy, flake8,
4676 for comment in comment_list:
4677 if comment.value.startswith(("# type:", "# noqa", "# pylint:")):
4683 def insert_str_child_factory(string_leaf: Leaf) -> Callable[[LN], None]:
4685 Factory for a convenience function that is used to orphan @string_leaf
4686 and then insert multiple new leaves into the same part of the node
4687 structure that @string_leaf had originally occupied.
4690 Let `string_leaf = Leaf(token.STRING, '"foo"')` and `N =
4691 string_leaf.parent`. Assume the node `N` has the following
4698 Leaf(STRING, '"foo"'),
4702 We then run the code snippet shown below.
4704 insert_str_child = insert_str_child_factory(string_leaf)
4706 lpar = Leaf(token.LPAR, '(')
4707 insert_str_child(lpar)
4709 bar = Leaf(token.STRING, '"bar"')
4710 insert_str_child(bar)
4712 rpar = Leaf(token.RPAR, ')')
4713 insert_str_child(rpar)
4716 After which point, it follows that `string_leaf.parent is None` and
4717 the node `N` now has the following structure:
4724 Leaf(STRING, '"bar"'),
4729 string_parent = string_leaf.parent
4730 string_child_idx = string_leaf.remove()
4732 def insert_str_child(child: LN) -> None:
4733 nonlocal string_child_idx
4735 assert string_parent is not None
4736 assert string_child_idx is not None
4738 string_parent.insert_child(string_child_idx, child)
4739 string_child_idx += 1
4741 return insert_str_child
4744 def has_triple_quotes(string: str) -> bool:
4747 True iff @string starts with three quotation characters.
4749 raw_string = string.lstrip(STRING_PREFIX_CHARS)
4750 return raw_string[:3] in {'"""', "'''"}
4753 def parent_type(node: Optional[LN]) -> Optional[NodeType]:
4756 @node.parent.type, if @node is not None and has a parent.
4760 if node is None or node.parent is None:
4763 return node.parent.type
4766 def is_empty_par(leaf: Leaf) -> bool:
4767 return is_empty_lpar(leaf) or is_empty_rpar(leaf)
4770 def is_empty_lpar(leaf: Leaf) -> bool:
4771 return leaf.type == token.LPAR and leaf.value == ""
4774 def is_empty_rpar(leaf: Leaf) -> bool:
4775 return leaf.type == token.RPAR and leaf.value == ""
4778 def is_valid_index_factory(seq: Sequence[Any]) -> Callable[[int], bool]:
4784 is_valid_index = is_valid_index_factory(my_list)
4786 assert is_valid_index(0)
4787 assert is_valid_index(2)
4789 assert not is_valid_index(3)
4790 assert not is_valid_index(-1)
4794 def is_valid_index(idx: int) -> bool:
4797 True iff @idx is positive AND seq[@idx] does NOT raise an
4800 return 0 <= idx < len(seq)
4802 return is_valid_index
4805 def line_to_string(line: Line) -> str:
4806 """Returns the string representation of @line.
4808 WARNING: This is known to be computationally expensive.
4810 return str(line).strip("\n")
4814 new_line: Line, old_line: Line, leaves: List[Leaf], preformatted: bool = False
4817 Append leaves (taken from @old_line) to @new_line, making sure to fix the
4818 underlying Node structure where appropriate.
4820 All of the leaves in @leaves are duplicated. The duplicates are then
4821 appended to @new_line and used to replace their originals in the underlying
4822 Node structure. Any comments attached to the old leaves are reattached to
4826 set(@leaves) is a subset of set(@old_line.leaves).
4828 for old_leaf in leaves:
4829 new_leaf = Leaf(old_leaf.type, old_leaf.value)
4830 replace_child(old_leaf, new_leaf)
4831 new_line.append(new_leaf, preformatted=preformatted)
4833 for comment_leaf in old_line.comments_after(old_leaf):
4834 new_line.append(comment_leaf, preformatted=True)
4837 def replace_child(old_child: LN, new_child: LN) -> None:
4840 * If @old_child.parent is set, replace @old_child with @new_child in
4841 @old_child's underlying Node structure.
4843 * Otherwise, this function does nothing.
4845 parent = old_child.parent
4849 child_idx = old_child.remove()
4850 if child_idx is not None:
4851 parent.insert_child(child_idx, new_child)
4854 def get_string_prefix(string: str) -> str:
4857 * assert_is_leaf_string(@string)
4860 @string's prefix (e.g. '', 'r', 'f', or 'rf').
4862 assert_is_leaf_string(string)
4866 while string[prefix_idx] in STRING_PREFIX_CHARS:
4867 prefix += string[prefix_idx].lower()
4873 def assert_is_leaf_string(string: str) -> None:
4875 Checks the pre-condition that @string has the format that you would expect
4876 of `leaf.value` where `leaf` is some Leaf such that `leaf.type ==
4877 token.STRING`. A more precise description of the pre-conditions that are
4878 checked are listed below.
4881 * @string starts with either ', ", <prefix>', or <prefix>" where
4882 `set(<prefix>)` is some subset of `set(STRING_PREFIX_CHARS)`.
4883 * @string ends with a quote character (' or ").
4886 AssertionError(...) if the pre-conditions listed above are not
4889 dquote_idx = string.find('"')
4890 squote_idx = string.find("'")
4891 if -1 in [dquote_idx, squote_idx]:
4892 quote_idx = max(dquote_idx, squote_idx)
4894 quote_idx = min(squote_idx, dquote_idx)
4897 0 <= quote_idx < len(string) - 1
4898 ), f"{string!r} is missing a starting quote character (' or \")."
4899 assert string[-1] in (
4902 ), f"{string!r} is missing an ending quote character (' or \")."
4903 assert set(string[:quote_idx]).issubset(
4904 set(STRING_PREFIX_CHARS)
4905 ), f"{set(string[:quote_idx])} is NOT a subset of {set(STRING_PREFIX_CHARS)}."
4908 def left_hand_split(line: Line, _features: Collection[Feature] = ()) -> Iterator[Line]:
4909 """Split line into many lines, starting with the first matching bracket pair.
4911 Note: this usually looks weird, only use this for function definitions.
4912 Prefer RHS otherwise. This is why this function is not symmetrical with
4913 :func:`right_hand_split` which also handles optional parentheses.
4915 tail_leaves: List[Leaf] = []
4916 body_leaves: List[Leaf] = []
4917 head_leaves: List[Leaf] = []
4918 current_leaves = head_leaves
4919 matching_bracket: Optional[Leaf] = None
4920 for leaf in line.leaves:
4922 current_leaves is body_leaves
4923 and leaf.type in CLOSING_BRACKETS
4924 and leaf.opening_bracket is matching_bracket
4926 current_leaves = tail_leaves if body_leaves else head_leaves
4927 current_leaves.append(leaf)
4928 if current_leaves is head_leaves:
4929 if leaf.type in OPENING_BRACKETS:
4930 matching_bracket = leaf
4931 current_leaves = body_leaves
4932 if not matching_bracket:
4933 raise CannotSplit("No brackets found")
4935 head = bracket_split_build_line(head_leaves, line, matching_bracket)
4936 body = bracket_split_build_line(body_leaves, line, matching_bracket, is_body=True)
4937 tail = bracket_split_build_line(tail_leaves, line, matching_bracket)
4938 bracket_split_succeeded_or_raise(head, body, tail)
4939 for result in (head, body, tail):
4944 def right_hand_split(
4947 features: Collection[Feature] = (),
4948 omit: Collection[LeafID] = (),
4949 ) -> Iterator[Line]:
4950 """Split line into many lines, starting with the last matching bracket pair.
4952 If the split was by optional parentheses, attempt splitting without them, too.
4953 `omit` is a collection of closing bracket IDs that shouldn't be considered for
4956 Note: running this function modifies `bracket_depth` on the leaves of `line`.
4958 tail_leaves: List[Leaf] = []
4959 body_leaves: List[Leaf] = []
4960 head_leaves: List[Leaf] = []
4961 current_leaves = tail_leaves
4962 opening_bracket: Optional[Leaf] = None
4963 closing_bracket: Optional[Leaf] = None
4964 for leaf in reversed(line.leaves):
4965 if current_leaves is body_leaves:
4966 if leaf is opening_bracket:
4967 current_leaves = head_leaves if body_leaves else tail_leaves
4968 current_leaves.append(leaf)
4969 if current_leaves is tail_leaves:
4970 if leaf.type in CLOSING_BRACKETS and id(leaf) not in omit:
4971 opening_bracket = leaf.opening_bracket
4972 closing_bracket = leaf
4973 current_leaves = body_leaves
4974 if not (opening_bracket and closing_bracket and head_leaves):
4975 # If there is no opening or closing_bracket that means the split failed and
4976 # all content is in the tail. Otherwise, if `head_leaves` are empty, it means
4977 # the matching `opening_bracket` wasn't available on `line` anymore.
4978 raise CannotSplit("No brackets found")
4980 tail_leaves.reverse()
4981 body_leaves.reverse()
4982 head_leaves.reverse()
4983 head = bracket_split_build_line(head_leaves, line, opening_bracket)
4984 body = bracket_split_build_line(body_leaves, line, opening_bracket, is_body=True)
4985 tail = bracket_split_build_line(tail_leaves, line, opening_bracket)
4986 bracket_split_succeeded_or_raise(head, body, tail)
4988 Feature.FORCE_OPTIONAL_PARENTHESES not in features
4989 # the opening bracket is an optional paren
4990 and opening_bracket.type == token.LPAR
4991 and not opening_bracket.value
4992 # the closing bracket is an optional paren
4993 and closing_bracket.type == token.RPAR
4994 and not closing_bracket.value
4995 # it's not an import (optional parens are the only thing we can split on
4996 # in this case; attempting a split without them is a waste of time)
4997 and not line.is_import
4998 # there are no standalone comments in the body
4999 and not body.contains_standalone_comments(0)
5000 # and we can actually remove the parens
5001 and can_omit_invisible_parens(body, line_length, omit_on_explode=omit)
5003 omit = {id(closing_bracket), *omit}
5005 yield from right_hand_split(line, line_length, features=features, omit=omit)
5011 or is_line_short_enough(body, line_length=line_length)
5014 "Splitting failed, body is still too long and can't be split."
5017 elif head.contains_multiline_strings() or tail.contains_multiline_strings():
5019 "The current optional pair of parentheses is bound to fail to"
5020 " satisfy the splitting algorithm because the head or the tail"
5021 " contains multiline strings which by definition never fit one"
5025 ensure_visible(opening_bracket)
5026 ensure_visible(closing_bracket)
5027 for result in (head, body, tail):
5032 def bracket_split_succeeded_or_raise(head: Line, body: Line, tail: Line) -> None:
5033 """Raise :exc:`CannotSplit` if the last left- or right-hand split failed.
5035 Do nothing otherwise.
5037 A left- or right-hand split is based on a pair of brackets. Content before
5038 (and including) the opening bracket is left on one line, content inside the
5039 brackets is put on a separate line, and finally content starting with and
5040 following the closing bracket is put on a separate line.
5042 Those are called `head`, `body`, and `tail`, respectively. If the split
5043 produced the same line (all content in `head`) or ended up with an empty `body`
5044 and the `tail` is just the closing bracket, then it's considered failed.
5046 tail_len = len(str(tail).strip())
5049 raise CannotSplit("Splitting brackets produced the same line")
5053 f"Splitting brackets on an empty body to save {tail_len} characters is"
5058 def bracket_split_build_line(
5059 leaves: List[Leaf], original: Line, opening_bracket: Leaf, *, is_body: bool = False
5061 """Return a new line with given `leaves` and respective comments from `original`.
5063 If `is_body` is True, the result line is one-indented inside brackets and as such
5064 has its first leaf's prefix normalized and a trailing comma added when expected.
5066 result = Line(mode=original.mode, depth=original.depth)
5068 result.inside_brackets = True
5071 # Since body is a new indent level, remove spurious leading whitespace.
5072 normalize_prefix(leaves[0], inside_brackets=True)
5073 # Ensure a trailing comma for imports and standalone function arguments, but
5074 # be careful not to add one after any comments or within type annotations.
5077 and opening_bracket.value == "("
5078 and not any(leaf.type == token.COMMA for leaf in leaves)
5081 if original.is_import or no_commas:
5082 for i in range(len(leaves) - 1, -1, -1):
5083 if leaves[i].type == STANDALONE_COMMENT:
5086 if leaves[i].type != token.COMMA:
5087 new_comma = Leaf(token.COMMA, ",")
5088 leaves.insert(i + 1, new_comma)
5093 result.append(leaf, preformatted=True)
5094 for comment_after in original.comments_after(leaf):
5095 result.append(comment_after, preformatted=True)
5096 if is_body and should_split_line(result, opening_bracket):
5097 result.should_split_rhs = True
5101 def dont_increase_indentation(split_func: Transformer) -> Transformer:
5102 """Normalize prefix of the first leaf in every line returned by `split_func`.
5104 This is a decorator over relevant split functions.
5108 def split_wrapper(line: Line, features: Collection[Feature] = ()) -> Iterator[Line]:
5109 for line in split_func(line, features):
5110 normalize_prefix(line.leaves[0], inside_brackets=True)
5113 return split_wrapper
5116 @dont_increase_indentation
5117 def delimiter_split(line: Line, features: Collection[Feature] = ()) -> Iterator[Line]:
5118 """Split according to delimiters of the highest priority.
5120 If the appropriate Features are given, the split will add trailing commas
5121 also in function signatures and calls that contain `*` and `**`.
5124 last_leaf = line.leaves[-1]
5126 raise CannotSplit("Line empty")
5128 bt = line.bracket_tracker
5130 delimiter_priority = bt.max_delimiter_priority(exclude={id(last_leaf)})
5132 raise CannotSplit("No delimiters found")
5134 if delimiter_priority == DOT_PRIORITY:
5135 if bt.delimiter_count_with_priority(delimiter_priority) == 1:
5136 raise CannotSplit("Splitting a single attribute from its owner looks wrong")
5138 current_line = Line(
5139 mode=line.mode, depth=line.depth, inside_brackets=line.inside_brackets
5141 lowest_depth = sys.maxsize
5142 trailing_comma_safe = True
5144 def append_to_line(leaf: Leaf) -> Iterator[Line]:
5145 """Append `leaf` to current line or to new line if appending impossible."""
5146 nonlocal current_line
5148 current_line.append_safe(leaf, preformatted=True)
5152 current_line = Line(
5153 mode=line.mode, depth=line.depth, inside_brackets=line.inside_brackets
5155 current_line.append(leaf)
5157 for leaf in line.leaves:
5158 yield from append_to_line(leaf)
5160 for comment_after in line.comments_after(leaf):
5161 yield from append_to_line(comment_after)
5163 lowest_depth = min(lowest_depth, leaf.bracket_depth)
5164 if leaf.bracket_depth == lowest_depth:
5165 if is_vararg(leaf, within={syms.typedargslist}):
5166 trailing_comma_safe = (
5167 trailing_comma_safe and Feature.TRAILING_COMMA_IN_DEF in features
5169 elif is_vararg(leaf, within={syms.arglist, syms.argument}):
5170 trailing_comma_safe = (
5171 trailing_comma_safe and Feature.TRAILING_COMMA_IN_CALL in features
5174 leaf_priority = bt.delimiters.get(id(leaf))
5175 if leaf_priority == delimiter_priority:
5178 current_line = Line(
5179 mode=line.mode, depth=line.depth, inside_brackets=line.inside_brackets
5184 and delimiter_priority == COMMA_PRIORITY
5185 and current_line.leaves[-1].type != token.COMMA
5186 and current_line.leaves[-1].type != STANDALONE_COMMENT
5188 new_comma = Leaf(token.COMMA, ",")
5189 current_line.append(new_comma)
5193 @dont_increase_indentation
5194 def standalone_comment_split(
5195 line: Line, features: Collection[Feature] = ()
5196 ) -> Iterator[Line]:
5197 """Split standalone comments from the rest of the line."""
5198 if not line.contains_standalone_comments(0):
5199 raise CannotSplit("Line does not have any standalone comments")
5201 current_line = Line(
5202 mode=line.mode, depth=line.depth, inside_brackets=line.inside_brackets
5205 def append_to_line(leaf: Leaf) -> Iterator[Line]:
5206 """Append `leaf` to current line or to new line if appending impossible."""
5207 nonlocal current_line
5209 current_line.append_safe(leaf, preformatted=True)
5213 current_line = Line(
5214 line.mode, depth=line.depth, inside_brackets=line.inside_brackets
5216 current_line.append(leaf)
5218 for leaf in line.leaves:
5219 yield from append_to_line(leaf)
5221 for comment_after in line.comments_after(leaf):
5222 yield from append_to_line(comment_after)
5228 def is_import(leaf: Leaf) -> bool:
5229 """Return True if the given leaf starts an import statement."""
5236 (v == "import" and p and p.type == syms.import_name)
5237 or (v == "from" and p and p.type == syms.import_from)
5242 def is_type_comment(leaf: Leaf, suffix: str = "") -> bool:
5243 """Return True if the given leaf is a special comment.
5244 Only returns true for type comments for now."""
5247 return t in {token.COMMENT, STANDALONE_COMMENT} and v.startswith("# type:" + suffix)
5250 def normalize_prefix(leaf: Leaf, *, inside_brackets: bool) -> None:
5251 """Leave existing extra newlines if not `inside_brackets`. Remove everything
5254 Note: don't use backslashes for formatting or you'll lose your voting rights.
5256 if not inside_brackets:
5257 spl = leaf.prefix.split("#")
5258 if "\\" not in spl[0]:
5259 nl_count = spl[-1].count("\n")
5262 leaf.prefix = "\n" * nl_count
5268 def normalize_string_prefix(leaf: Leaf, remove_u_prefix: bool = False) -> None:
5269 """Make all string prefixes lowercase.
5271 If remove_u_prefix is given, also removes any u prefix from the string.
5273 Note: Mutates its argument.
5275 match = re.match(r"^([" + STRING_PREFIX_CHARS + r"]*)(.*)$", leaf.value, re.DOTALL)
5276 assert match is not None, f"failed to match string {leaf.value!r}"
5277 orig_prefix = match.group(1)
5278 new_prefix = orig_prefix.replace("F", "f").replace("B", "b").replace("U", "u")
5280 new_prefix = new_prefix.replace("u", "")
5281 leaf.value = f"{new_prefix}{match.group(2)}"
5284 def normalize_string_quotes(leaf: Leaf) -> None:
5285 """Prefer double quotes but only if it doesn't cause more escaping.
5287 Adds or removes backslashes as appropriate. Doesn't parse and fix
5288 strings nested in f-strings (yet).
5290 Note: Mutates its argument.
5292 value = leaf.value.lstrip(STRING_PREFIX_CHARS)
5293 if value[:3] == '"""':
5296 elif value[:3] == "'''":
5299 elif value[0] == '"':
5305 first_quote_pos = leaf.value.find(orig_quote)
5306 if first_quote_pos == -1:
5307 return # There's an internal error
5309 prefix = leaf.value[:first_quote_pos]
5310 unescaped_new_quote = re.compile(rf"(([^\\]|^)(\\\\)*){new_quote}")
5311 escaped_new_quote = re.compile(rf"([^\\]|^)\\((?:\\\\)*){new_quote}")
5312 escaped_orig_quote = re.compile(rf"([^\\]|^)\\((?:\\\\)*){orig_quote}")
5313 body = leaf.value[first_quote_pos + len(orig_quote) : -len(orig_quote)]
5314 if "r" in prefix.casefold():
5315 if unescaped_new_quote.search(body):
5316 # There's at least one unescaped new_quote in this raw string
5317 # so converting is impossible
5320 # Do not introduce or remove backslashes in raw strings
5323 # remove unnecessary escapes
5324 new_body = sub_twice(escaped_new_quote, rf"\1\2{new_quote}", body)
5325 if body != new_body:
5326 # Consider the string without unnecessary escapes as the original
5328 leaf.value = f"{prefix}{orig_quote}{body}{orig_quote}"
5329 new_body = sub_twice(escaped_orig_quote, rf"\1\2{orig_quote}", new_body)
5330 new_body = sub_twice(unescaped_new_quote, rf"\1\\{new_quote}", new_body)
5331 if "f" in prefix.casefold():
5332 matches = re.findall(
5334 (?:[^{]|^)\{ # start of the string or a non-{ followed by a single {
5335 ([^{].*?) # contents of the brackets except if begins with {{
5336 \}(?:[^}]|$) # A } followed by end of the string or a non-}
5343 # Do not introduce backslashes in interpolated expressions
5346 if new_quote == '"""' and new_body[-1:] == '"':
5348 new_body = new_body[:-1] + '\\"'
5349 orig_escape_count = body.count("\\")
5350 new_escape_count = new_body.count("\\")
5351 if new_escape_count > orig_escape_count:
5352 return # Do not introduce more escaping
5354 if new_escape_count == orig_escape_count and orig_quote == '"':
5355 return # Prefer double quotes
5357 leaf.value = f"{prefix}{new_quote}{new_body}{new_quote}"
5360 def normalize_numeric_literal(leaf: Leaf) -> None:
5361 """Normalizes numeric (float, int, and complex) literals.
5363 All letters used in the representation are normalized to lowercase (except
5364 in Python 2 long literals).
5366 text = leaf.value.lower()
5367 if text.startswith(("0o", "0b")):
5368 # Leave octal and binary literals alone.
5370 elif text.startswith("0x"):
5371 text = format_hex(text)
5373 text = format_scientific_notation(text)
5374 elif text.endswith(("j", "l")):
5375 text = format_long_or_complex_number(text)
5377 text = format_float_or_int_string(text)
5381 def format_hex(text: str) -> str:
5383 Formats a hexadecimal string like "0x12B3"
5385 before, after = text[:2], text[2:]
5386 return f"{before}{after.upper()}"
5389 def format_scientific_notation(text: str) -> str:
5390 """Formats a numeric string utilizing scentific notation"""
5391 before, after = text.split("e")
5393 if after.startswith("-"):
5396 elif after.startswith("+"):
5398 before = format_float_or_int_string(before)
5399 return f"{before}e{sign}{after}"
5402 def format_long_or_complex_number(text: str) -> str:
5403 """Formats a long or complex string like `10L` or `10j`"""
5406 # Capitalize in "2L" because "l" looks too similar to "1".
5409 return f"{format_float_or_int_string(number)}{suffix}"
5412 def format_float_or_int_string(text: str) -> str:
5413 """Formats a float string like "1.0"."""
5417 before, after = text.split(".")
5418 return f"{before or 0}.{after or 0}"
5421 def normalize_invisible_parens(node: Node, parens_after: Set[str]) -> None:
5422 """Make existing optional parentheses invisible or create new ones.
5424 `parens_after` is a set of string leaf values immediately after which parens
5427 Standardizes on visible parentheses for single-element tuples, and keeps
5428 existing visible parentheses for other tuples and generator expressions.
5430 for pc in list_comments(node.prefix, is_endmarker=False):
5431 if pc.value in FMT_OFF:
5432 # This `node` has a prefix with `# fmt: off`, don't mess with parens.
5435 for index, child in enumerate(list(node.children)):
5436 # Fixes a bug where invisible parens are not properly stripped from
5437 # assignment statements that contain type annotations.
5438 if isinstance(child, Node) and child.type == syms.annassign:
5439 normalize_invisible_parens(child, parens_after=parens_after)
5441 # Add parentheses around long tuple unpacking in assignments.
5444 and isinstance(child, Node)
5445 and child.type == syms.testlist_star_expr
5450 if child.type == syms.atom:
5451 if maybe_make_parens_invisible_in_atom(child, parent=node):
5452 wrap_in_parentheses(node, child, visible=False)
5453 elif is_one_tuple(child):
5454 wrap_in_parentheses(node, child, visible=True)
5455 elif node.type == syms.import_from:
5456 # "import from" nodes store parentheses directly as part of
5458 if child.type == token.LPAR:
5459 # make parentheses invisible
5460 child.value = "" # type: ignore
5461 node.children[-1].value = "" # type: ignore
5462 elif child.type != token.STAR:
5463 # insert invisible parentheses
5464 node.insert_child(index, Leaf(token.LPAR, ""))
5465 node.append_child(Leaf(token.RPAR, ""))
5468 elif not (isinstance(child, Leaf) and is_multiline_string(child)):
5469 wrap_in_parentheses(node, child, visible=False)
5471 check_lpar = isinstance(child, Leaf) and child.value in parens_after
5474 def normalize_fmt_off(node: Node) -> None:
5475 """Convert content between `# fmt: off`/`# fmt: on` into standalone comments."""
5478 try_again = convert_one_fmt_off_pair(node)
5481 def convert_one_fmt_off_pair(node: Node) -> bool:
5482 """Convert content of a single `# fmt: off`/`# fmt: on` into a standalone comment.
5484 Returns True if a pair was converted.
5486 for leaf in node.leaves():
5487 previous_consumed = 0
5488 for comment in list_comments(leaf.prefix, is_endmarker=False):
5489 if comment.value not in FMT_PASS:
5490 previous_consumed = comment.consumed
5492 # We only want standalone comments. If there's no previous leaf or
5493 # the previous leaf is indentation, it's a standalone comment in
5495 if comment.value in FMT_PASS and comment.type != STANDALONE_COMMENT:
5496 prev = preceding_leaf(leaf)
5498 if comment.value in FMT_OFF and prev.type not in WHITESPACE:
5500 if comment.value in FMT_SKIP and prev.type in WHITESPACE:
5503 ignored_nodes = list(generate_ignored_nodes(leaf, comment))
5504 if not ignored_nodes:
5507 first = ignored_nodes[0] # Can be a container node with the `leaf`.
5508 parent = first.parent
5509 prefix = first.prefix
5510 first.prefix = prefix[comment.consumed :]
5511 hidden_value = "".join(str(n) for n in ignored_nodes)
5512 if comment.value in FMT_OFF:
5513 hidden_value = comment.value + "\n" + hidden_value
5514 if comment.value in FMT_SKIP:
5515 hidden_value += " " + comment.value
5516 if hidden_value.endswith("\n"):
5517 # That happens when one of the `ignored_nodes` ended with a NEWLINE
5518 # leaf (possibly followed by a DEDENT).
5519 hidden_value = hidden_value[:-1]
5520 first_idx: Optional[int] = None
5521 for ignored in ignored_nodes:
5522 index = ignored.remove()
5523 if first_idx is None:
5525 assert parent is not None, "INTERNAL ERROR: fmt: on/off handling (1)"
5526 assert first_idx is not None, "INTERNAL ERROR: fmt: on/off handling (2)"
5527 parent.insert_child(
5532 prefix=prefix[:previous_consumed] + "\n" * comment.newlines,
5540 def generate_ignored_nodes(leaf: Leaf, comment: ProtoComment) -> Iterator[LN]:
5541 """Starting from the container of `leaf`, generate all leaves until `# fmt: on`.
5543 If comment is skip, returns leaf only.
5544 Stops at the end of the block.
5546 container: Optional[LN] = container_of(leaf)
5547 if comment.value in FMT_SKIP:
5548 prev_sibling = leaf.prev_sibling
5549 if comment.value in leaf.prefix and prev_sibling is not None:
5550 leaf.prefix = leaf.prefix.replace(comment.value, "")
5551 siblings = [prev_sibling]
5553 "\n" not in prev_sibling.prefix
5554 and prev_sibling.prev_sibling is not None
5556 prev_sibling = prev_sibling.prev_sibling
5557 siblings.insert(0, prev_sibling)
5558 for sibling in siblings:
5560 elif leaf.parent is not None:
5563 while container is not None and container.type != token.ENDMARKER:
5564 if is_fmt_on(container):
5567 # fix for fmt: on in children
5568 if contains_fmt_on_at_column(container, leaf.column):
5569 for child in container.children:
5570 if contains_fmt_on_at_column(child, leaf.column):
5575 container = container.next_sibling
5578 def is_fmt_on(container: LN) -> bool:
5579 """Determine whether formatting is switched on within a container.
5580 Determined by whether the last `# fmt:` comment is `on` or `off`.
5583 for comment in list_comments(container.prefix, is_endmarker=False):
5584 if comment.value in FMT_ON:
5586 elif comment.value in FMT_OFF:
5591 def contains_fmt_on_at_column(container: LN, column: int) -> bool:
5592 """Determine if children at a given column have formatting switched on."""
5593 for child in container.children:
5595 isinstance(child, Node)
5596 and first_leaf_column(child) == column
5597 or isinstance(child, Leaf)
5598 and child.column == column
5600 if is_fmt_on(child):
5606 def first_leaf_column(node: Node) -> Optional[int]:
5607 """Returns the column of the first leaf child of a node."""
5608 for child in node.children:
5609 if isinstance(child, Leaf):
5614 def maybe_make_parens_invisible_in_atom(node: LN, parent: LN) -> bool:
5615 """If it's safe, make the parens in the atom `node` invisible, recursively.
5616 Additionally, remove repeated, adjacent invisible parens from the atom `node`
5617 as they are redundant.
5619 Returns whether the node should itself be wrapped in invisible parentheses.
5624 node.type != syms.atom
5625 or is_empty_tuple(node)
5626 or is_one_tuple(node)
5627 or (is_yield(node) and parent.type != syms.expr_stmt)
5628 or max_delimiter_priority_in_atom(node) >= COMMA_PRIORITY
5632 if is_walrus_assignment(node):
5638 # these ones aren't useful to end users, but they do please fuzzers
5644 first = node.children[0]
5645 last = node.children[-1]
5646 if first.type == token.LPAR and last.type == token.RPAR:
5647 middle = node.children[1]
5648 # make parentheses invisible
5649 first.value = "" # type: ignore
5650 last.value = "" # type: ignore
5651 maybe_make_parens_invisible_in_atom(middle, parent=parent)
5653 if is_atom_with_invisible_parens(middle):
5654 # Strip the invisible parens from `middle` by replacing
5655 # it with the child in-between the invisible parens
5656 middle.replace(middle.children[1])
5663 def is_atom_with_invisible_parens(node: LN) -> bool:
5664 """Given a `LN`, determines whether it's an atom `node` with invisible
5665 parens. Useful in dedupe-ing and normalizing parens.
5667 if isinstance(node, Leaf) or node.type != syms.atom:
5670 first, last = node.children[0], node.children[-1]
5672 isinstance(first, Leaf)
5673 and first.type == token.LPAR
5674 and first.value == ""
5675 and isinstance(last, Leaf)
5676 and last.type == token.RPAR
5677 and last.value == ""
5681 def is_empty_tuple(node: LN) -> bool:
5682 """Return True if `node` holds an empty tuple."""
5684 node.type == syms.atom
5685 and len(node.children) == 2
5686 and node.children[0].type == token.LPAR
5687 and node.children[1].type == token.RPAR
5691 def unwrap_singleton_parenthesis(node: LN) -> Optional[LN]:
5692 """Returns `wrapped` if `node` is of the shape ( wrapped ).
5694 Parenthesis can be optional. Returns None otherwise"""
5695 if len(node.children) != 3:
5698 lpar, wrapped, rpar = node.children
5699 if not (lpar.type == token.LPAR and rpar.type == token.RPAR):
5705 def first_child_is_arith(node: Node) -> bool:
5706 """Whether first child is an arithmetic or a binary arithmetic expression"""
5713 return bool(node.children and node.children[0].type in expr_types)
5716 def wrap_in_parentheses(parent: Node, child: LN, *, visible: bool = True) -> None:
5717 """Wrap `child` in parentheses.
5719 This replaces `child` with an atom holding the parentheses and the old
5720 child. That requires moving the prefix.
5722 If `visible` is False, the leaves will be valueless (and thus invisible).
5724 lpar = Leaf(token.LPAR, "(" if visible else "")
5725 rpar = Leaf(token.RPAR, ")" if visible else "")
5726 prefix = child.prefix
5728 index = child.remove() or 0
5729 new_child = Node(syms.atom, [lpar, child, rpar])
5730 new_child.prefix = prefix
5731 parent.insert_child(index, new_child)
5734 def is_one_tuple(node: LN) -> bool:
5735 """Return True if `node` holds a tuple with one element, with or without parens."""
5736 if node.type == syms.atom:
5737 gexp = unwrap_singleton_parenthesis(node)
5738 if gexp is None or gexp.type != syms.testlist_gexp:
5741 return len(gexp.children) == 2 and gexp.children[1].type == token.COMMA
5744 node.type in IMPLICIT_TUPLE
5745 and len(node.children) == 2
5746 and node.children[1].type == token.COMMA
5750 def is_walrus_assignment(node: LN) -> bool:
5751 """Return True iff `node` is of the shape ( test := test )"""
5752 inner = unwrap_singleton_parenthesis(node)
5753 return inner is not None and inner.type == syms.namedexpr_test
5756 def is_simple_decorator_trailer(node: LN, last: bool = False) -> bool:
5757 """Return True iff `node` is a trailer valid in a simple decorator"""
5758 return node.type == syms.trailer and (
5760 len(node.children) == 2
5761 and node.children[0].type == token.DOT
5762 and node.children[1].type == token.NAME
5764 # last trailer can be an argument-less parentheses pair
5767 and len(node.children) == 2
5768 and node.children[0].type == token.LPAR
5769 and node.children[1].type == token.RPAR
5771 # last trailer can be arguments
5774 and len(node.children) == 3
5775 and node.children[0].type == token.LPAR
5776 # and node.children[1].type == syms.argument
5777 and node.children[2].type == token.RPAR
5782 def is_simple_decorator_expression(node: LN) -> bool:
5783 """Return True iff `node` could be a 'dotted name' decorator
5785 This function takes the node of the 'namedexpr_test' of the new decorator
5786 grammar and test if it would be valid under the old decorator grammar.
5788 The old grammar was: decorator: @ dotted_name [arguments] NEWLINE
5789 The new grammar is : decorator: @ namedexpr_test NEWLINE
5791 if node.type == token.NAME:
5793 if node.type == syms.power:
5796 node.children[0].type == token.NAME
5797 and all(map(is_simple_decorator_trailer, node.children[1:-1]))
5799 len(node.children) < 2
5800 or is_simple_decorator_trailer(node.children[-1], last=True)
5806 def is_yield(node: LN) -> bool:
5807 """Return True if `node` holds a `yield` or `yield from` expression."""
5808 if node.type == syms.yield_expr:
5811 if node.type == token.NAME and node.value == "yield": # type: ignore
5814 if node.type != syms.atom:
5817 if len(node.children) != 3:
5820 lpar, expr, rpar = node.children
5821 if lpar.type == token.LPAR and rpar.type == token.RPAR:
5822 return is_yield(expr)
5827 def is_vararg(leaf: Leaf, within: Set[NodeType]) -> bool:
5828 """Return True if `leaf` is a star or double star in a vararg or kwarg.
5830 If `within` includes VARARGS_PARENTS, this applies to function signatures.
5831 If `within` includes UNPACKING_PARENTS, it applies to right hand-side
5832 extended iterable unpacking (PEP 3132) and additional unpacking
5833 generalizations (PEP 448).
5835 if leaf.type not in VARARGS_SPECIALS or not leaf.parent:
5839 if p.type == syms.star_expr:
5840 # Star expressions are also used as assignment targets in extended
5841 # iterable unpacking (PEP 3132). See what its parent is instead.
5847 return p.type in within
5850 def is_multiline_string(leaf: Leaf) -> bool:
5851 """Return True if `leaf` is a multiline string that actually spans many lines."""
5852 return has_triple_quotes(leaf.value) and "\n" in leaf.value
5855 def is_stub_suite(node: Node) -> bool:
5856 """Return True if `node` is a suite with a stub body."""
5858 len(node.children) != 4
5859 or node.children[0].type != token.NEWLINE
5860 or node.children[1].type != token.INDENT
5861 or node.children[3].type != token.DEDENT
5865 return is_stub_body(node.children[2])
5868 def is_stub_body(node: LN) -> bool:
5869 """Return True if `node` is a simple statement containing an ellipsis."""
5870 if not isinstance(node, Node) or node.type != syms.simple_stmt:
5873 if len(node.children) != 2:
5876 child = node.children[0]
5878 child.type == syms.atom
5879 and len(child.children) == 3
5880 and all(leaf == Leaf(token.DOT, ".") for leaf in child.children)
5884 def max_delimiter_priority_in_atom(node: LN) -> Priority:
5885 """Return maximum delimiter priority inside `node`.
5887 This is specific to atoms with contents contained in a pair of parentheses.
5888 If `node` isn't an atom or there are no enclosing parentheses, returns 0.
5890 if node.type != syms.atom:
5893 first = node.children[0]
5894 last = node.children[-1]
5895 if not (first.type == token.LPAR and last.type == token.RPAR):
5898 bt = BracketTracker()
5899 for c in node.children[1:-1]:
5900 if isinstance(c, Leaf):
5903 for leaf in c.leaves():
5906 return bt.max_delimiter_priority()
5912 def ensure_visible(leaf: Leaf) -> None:
5913 """Make sure parentheses are visible.
5915 They could be invisible as part of some statements (see
5916 :func:`normalize_invisible_parens` and :func:`visit_import_from`).
5918 if leaf.type == token.LPAR:
5920 elif leaf.type == token.RPAR:
5924 def should_split_line(line: Line, opening_bracket: Leaf) -> bool:
5925 """Should `line` be immediately split with `delimiter_split()` after RHS?"""
5927 if not (opening_bracket.parent and opening_bracket.value in "[{("):
5930 # We're essentially checking if the body is delimited by commas and there's more
5931 # than one of them (we're excluding the trailing comma and if the delimiter priority
5932 # is still commas, that means there's more).
5934 trailing_comma = False
5936 last_leaf = line.leaves[-1]
5937 if last_leaf.type == token.COMMA:
5938 trailing_comma = True
5939 exclude.add(id(last_leaf))
5940 max_priority = line.bracket_tracker.max_delimiter_priority(exclude=exclude)
5941 except (IndexError, ValueError):
5944 return max_priority == COMMA_PRIORITY and (
5945 (line.mode.magic_trailing_comma and trailing_comma)
5946 # always explode imports
5947 or opening_bracket.parent.type in {syms.atom, syms.import_from}
5951 def is_one_tuple_between(opening: Leaf, closing: Leaf, leaves: List[Leaf]) -> bool:
5952 """Return True if content between `opening` and `closing` looks like a one-tuple."""
5953 if opening.type != token.LPAR and closing.type != token.RPAR:
5956 depth = closing.bracket_depth + 1
5957 for _opening_index, leaf in enumerate(leaves):
5962 raise LookupError("Opening paren not found in `leaves`")
5966 for leaf in leaves[_opening_index:]:
5970 bracket_depth = leaf.bracket_depth
5971 if bracket_depth == depth and leaf.type == token.COMMA:
5973 if leaf.parent and leaf.parent.type in {
5983 def get_features_used(node: Node) -> Set[Feature]:
5984 """Return a set of (relatively) new Python features used in this file.
5986 Currently looking for:
5988 - underscores in numeric literals;
5989 - trailing commas after * or ** in function signatures and calls;
5990 - positional only arguments in function signatures and lambdas;
5991 - assignment expression;
5992 - relaxed decorator syntax;
5994 features: Set[Feature] = set()
5995 for n in node.pre_order():
5996 if n.type == token.STRING:
5997 value_head = n.value[:2] # type: ignore
5998 if value_head in {'f"', 'F"', "f'", "F'", "rf", "fr", "RF", "FR"}:
5999 features.add(Feature.F_STRINGS)
6001 elif n.type == token.NUMBER:
6002 if "_" in n.value: # type: ignore
6003 features.add(Feature.NUMERIC_UNDERSCORES)
6005 elif n.type == token.SLASH:
6006 if n.parent and n.parent.type in {syms.typedargslist, syms.arglist}:
6007 features.add(Feature.POS_ONLY_ARGUMENTS)
6009 elif n.type == token.COLONEQUAL:
6010 features.add(Feature.ASSIGNMENT_EXPRESSIONS)
6012 elif n.type == syms.decorator:
6013 if len(n.children) > 1 and not is_simple_decorator_expression(
6016 features.add(Feature.RELAXED_DECORATORS)
6019 n.type in {syms.typedargslist, syms.arglist}
6021 and n.children[-1].type == token.COMMA
6023 if n.type == syms.typedargslist:
6024 feature = Feature.TRAILING_COMMA_IN_DEF
6026 feature = Feature.TRAILING_COMMA_IN_CALL
6028 for ch in n.children:
6029 if ch.type in STARS:
6030 features.add(feature)
6032 if ch.type == syms.argument:
6033 for argch in ch.children:
6034 if argch.type in STARS:
6035 features.add(feature)
6040 def detect_target_versions(node: Node) -> Set[TargetVersion]:
6041 """Detect the version to target based on the nodes used."""
6042 features = get_features_used(node)
6044 version for version in TargetVersion if features <= VERSION_TO_FEATURES[version]
6048 def generate_trailers_to_omit(line: Line, line_length: int) -> Iterator[Set[LeafID]]:
6049 """Generate sets of closing bracket IDs that should be omitted in a RHS.
6051 Brackets can be omitted if the entire trailer up to and including
6052 a preceding closing bracket fits in one line.
6054 Yielded sets are cumulative (contain results of previous yields, too). First
6055 set is empty, unless the line should explode, in which case bracket pairs until
6056 the one that needs to explode are omitted.
6059 omit: Set[LeafID] = set()
6060 if not line.magic_trailing_comma:
6063 length = 4 * line.depth
6064 opening_bracket: Optional[Leaf] = None
6065 closing_bracket: Optional[Leaf] = None
6066 inner_brackets: Set[LeafID] = set()
6067 for index, leaf, leaf_length in enumerate_with_length(line, reversed=True):
6068 length += leaf_length
6069 if length > line_length:
6072 has_inline_comment = leaf_length > len(leaf.value) + len(leaf.prefix)
6073 if leaf.type == STANDALONE_COMMENT or has_inline_comment:
6077 if leaf is opening_bracket:
6078 opening_bracket = None
6079 elif leaf.type in CLOSING_BRACKETS:
6080 prev = line.leaves[index - 1] if index > 0 else None
6083 and prev.type == token.COMMA
6084 and not is_one_tuple_between(
6085 leaf.opening_bracket, leaf, line.leaves
6088 # Never omit bracket pairs with trailing commas.
6089 # We need to explode on those.
6092 inner_brackets.add(id(leaf))
6093 elif leaf.type in CLOSING_BRACKETS:
6094 prev = line.leaves[index - 1] if index > 0 else None
6095 if prev and prev.type in OPENING_BRACKETS:
6096 # Empty brackets would fail a split so treat them as "inner"
6097 # brackets (e.g. only add them to the `omit` set if another
6098 # pair of brackets was good enough.
6099 inner_brackets.add(id(leaf))
6103 omit.add(id(closing_bracket))
6104 omit.update(inner_brackets)
6105 inner_brackets.clear()
6110 and prev.type == token.COMMA
6111 and not is_one_tuple_between(leaf.opening_bracket, leaf, line.leaves)
6113 # Never omit bracket pairs with trailing commas.
6114 # We need to explode on those.
6118 opening_bracket = leaf.opening_bracket
6119 closing_bracket = leaf
6122 def get_future_imports(node: Node) -> Set[str]:
6123 """Return a set of __future__ imports in the file."""
6124 imports: Set[str] = set()
6126 def get_imports_from_children(children: List[LN]) -> Generator[str, None, None]:
6127 for child in children:
6128 if isinstance(child, Leaf):
6129 if child.type == token.NAME:
6132 elif child.type == syms.import_as_name:
6133 orig_name = child.children[0]
6134 assert isinstance(orig_name, Leaf), "Invalid syntax parsing imports"
6135 assert orig_name.type == token.NAME, "Invalid syntax parsing imports"
6136 yield orig_name.value
6138 elif child.type == syms.import_as_names:
6139 yield from get_imports_from_children(child.children)
6142 raise AssertionError("Invalid syntax parsing imports")
6144 for child in node.children:
6145 if child.type != syms.simple_stmt:
6148 first_child = child.children[0]
6149 if isinstance(first_child, Leaf):
6150 # Continue looking if we see a docstring; otherwise stop.
6152 len(child.children) == 2
6153 and first_child.type == token.STRING
6154 and child.children[1].type == token.NEWLINE
6160 elif first_child.type == syms.import_from:
6161 module_name = first_child.children[1]
6162 if not isinstance(module_name, Leaf) or module_name.value != "__future__":
6165 imports |= set(get_imports_from_children(first_child.children[3:]))
6173 def get_gitignore(root: Path) -> PathSpec:
6174 """Return a PathSpec matching gitignore content if present."""
6175 gitignore = root / ".gitignore"
6176 lines: List[str] = []
6177 if gitignore.is_file():
6178 with gitignore.open() as gf:
6179 lines = gf.readlines()
6180 return PathSpec.from_lines("gitwildmatch", lines)
6183 def normalize_path_maybe_ignore(
6184 path: Path, root: Path, report: "Report"
6186 """Normalize `path`. May return `None` if `path` was ignored.
6188 `report` is where "path ignored" output goes.
6191 abspath = path if path.is_absolute() else Path.cwd() / path
6192 normalized_path = abspath.resolve().relative_to(root).as_posix()
6193 except OSError as e:
6194 report.path_ignored(path, f"cannot be read because {e}")
6198 if path.is_symlink():
6199 report.path_ignored(path, f"is a symbolic link that points outside {root}")
6204 return normalized_path
6207 def path_is_excluded(
6208 normalized_path: str,
6209 pattern: Optional[Pattern[str]],
6211 match = pattern.search(normalized_path) if pattern else None
6212 return bool(match and match.group(0))
6215 def gen_python_files(
6216 paths: Iterable[Path],
6218 include: Optional[Pattern[str]],
6219 exclude: Pattern[str],
6220 extend_exclude: Optional[Pattern[str]],
6221 force_exclude: Optional[Pattern[str]],
6223 gitignore: PathSpec,
6224 ) -> Iterator[Path]:
6225 """Generate all files under `path` whose paths are not excluded by the
6226 `exclude_regex`, `extend_exclude`, or `force_exclude` regexes,
6227 but are included by the `include` regex.
6229 Symbolic links pointing outside of the `root` directory are ignored.
6231 `report` is where output about exclusions goes.
6233 assert root.is_absolute(), f"INTERNAL ERROR: `root` must be absolute but is {root}"
6235 normalized_path = normalize_path_maybe_ignore(child, root, report)
6236 if normalized_path is None:
6239 # First ignore files matching .gitignore
6240 if gitignore.match_file(normalized_path):
6241 report.path_ignored(child, "matches the .gitignore file content")
6244 # Then ignore with `--exclude` `--extend-exclude` and `--force-exclude` options.
6245 normalized_path = "/" + normalized_path
6247 normalized_path += "/"
6249 if path_is_excluded(normalized_path, exclude):
6250 report.path_ignored(child, "matches the --exclude regular expression")
6253 if path_is_excluded(normalized_path, extend_exclude):
6254 report.path_ignored(
6255 child, "matches the --extend-exclude regular expression"
6259 if path_is_excluded(normalized_path, force_exclude):
6260 report.path_ignored(child, "matches the --force-exclude regular expression")
6264 yield from gen_python_files(
6275 elif child.is_file():
6276 include_match = include.search(normalized_path) if include else True
6282 def find_project_root(srcs: Tuple[str, ...]) -> Path:
6283 """Return a directory containing .git, .hg, or pyproject.toml.
6285 That directory will be a common parent of all files and directories
6288 If no directory in the tree contains a marker that would specify it's the
6289 project root, the root of the file system is returned.
6292 return Path("/").resolve()
6294 path_srcs = [Path(Path.cwd(), src).resolve() for src in srcs]
6296 # A list of lists of parents for each 'src'. 'src' is included as a
6297 # "parent" of itself if it is a directory
6299 list(path.parents) + ([path] if path.is_dir() else []) for path in path_srcs
6303 set.intersection(*(set(parents) for parents in src_parents)),
6304 key=lambda path: path.parts,
6307 for directory in (common_base, *common_base.parents):
6308 if (directory / ".git").exists():
6311 if (directory / ".hg").is_dir():
6314 if (directory / "pyproject.toml").is_file():
6321 def find_user_pyproject_toml() -> Path:
6322 r"""Return the path to the top-level user configuration for black.
6324 This looks for ~\.black on Windows and ~/.config/black on Linux and other
6327 if sys.platform == "win32":
6329 user_config_path = Path.home() / ".black"
6331 config_root = os.environ.get("XDG_CONFIG_HOME", "~/.config")
6332 user_config_path = Path(config_root).expanduser() / "black"
6333 return user_config_path.resolve()
6338 """Provides a reformatting counter. Can be rendered with `str(report)`."""
6343 verbose: bool = False
6344 change_count: int = 0
6346 failure_count: int = 0
6348 def done(self, src: Path, changed: Changed) -> None:
6349 """Increment the counter for successful reformatting. Write out a message."""
6350 if changed is Changed.YES:
6351 reformatted = "would reformat" if self.check or self.diff else "reformatted"
6352 if self.verbose or not self.quiet:
6353 out(f"{reformatted} {src}")
6354 self.change_count += 1
6357 if changed is Changed.NO:
6358 msg = f"{src} already well formatted, good job."
6360 msg = f"{src} wasn't modified on disk since last run."
6361 out(msg, bold=False)
6362 self.same_count += 1
6364 def failed(self, src: Path, message: str) -> None:
6365 """Increment the counter for failed reformatting. Write out a message."""
6366 err(f"error: cannot format {src}: {message}")
6367 self.failure_count += 1
6369 def path_ignored(self, path: Path, message: str) -> None:
6371 out(f"{path} ignored: {message}", bold=False)
6374 def return_code(self) -> int:
6375 """Return the exit code that the app should use.
6377 This considers the current state of changed files and failures:
6378 - if there were any failures, return 123;
6379 - if any files were changed and --check is being used, return 1;
6380 - otherwise return 0.
6382 # According to http://tldp.org/LDP/abs/html/exitcodes.html starting with
6383 # 126 we have special return codes reserved by the shell.
6384 if self.failure_count:
6387 elif self.change_count and self.check:
6392 def __str__(self) -> str:
6393 """Render a color report of the current state.
6395 Use `click.unstyle` to remove colors.
6397 if self.check or self.diff:
6398 reformatted = "would be reformatted"
6399 unchanged = "would be left unchanged"
6400 failed = "would fail to reformat"
6402 reformatted = "reformatted"
6403 unchanged = "left unchanged"
6404 failed = "failed to reformat"
6406 if self.change_count:
6407 s = "s" if self.change_count > 1 else ""
6409 click.style(f"{self.change_count} file{s} {reformatted}", bold=True)
6412 s = "s" if self.same_count > 1 else ""
6413 report.append(f"{self.same_count} file{s} {unchanged}")
6414 if self.failure_count:
6415 s = "s" if self.failure_count > 1 else ""
6417 click.style(f"{self.failure_count} file{s} {failed}", fg="red")
6419 return ", ".join(report) + "."
6422 def parse_ast(src: str) -> Union[ast.AST, ast3.AST, ast27.AST]:
6423 filename = "<unknown>"
6424 if sys.version_info >= (3, 8):
6425 # TODO: support Python 4+ ;)
6426 for minor_version in range(sys.version_info[1], 4, -1):
6428 return ast.parse(src, filename, feature_version=(3, minor_version))
6432 for feature_version in (7, 6):
6434 return ast3.parse(src, filename, feature_version=feature_version)
6437 if ast27.__name__ == "ast":
6439 "The requested source code has invalid Python 3 syntax.\n"
6440 "If you are trying to format Python 2 files please reinstall Black"
6441 " with the 'python2' extra: `python3 -m pip install black[python2]`."
6443 return ast27.parse(src)
6446 def _fixup_ast_constants(
6447 node: Union[ast.AST, ast3.AST, ast27.AST]
6448 ) -> Union[ast.AST, ast3.AST, ast27.AST]:
6449 """Map ast nodes deprecated in 3.8 to Constant."""
6450 if isinstance(node, (ast.Str, ast3.Str, ast27.Str, ast.Bytes, ast3.Bytes)):
6451 return ast.Constant(value=node.s)
6453 if isinstance(node, (ast.Num, ast3.Num, ast27.Num)):
6454 return ast.Constant(value=node.n)
6456 if isinstance(node, (ast.NameConstant, ast3.NameConstant)):
6457 return ast.Constant(value=node.value)
6463 node: Union[ast.AST, ast3.AST, ast27.AST], depth: int = 0
6465 """Simple visitor generating strings to compare ASTs by content."""
6467 node = _fixup_ast_constants(node)
6469 yield f"{' ' * depth}{node.__class__.__name__}("
6471 for field in sorted(node._fields): # noqa: F402
6472 # TypeIgnore has only one field 'lineno' which breaks this comparison
6473 type_ignore_classes = (ast3.TypeIgnore, ast27.TypeIgnore)
6474 if sys.version_info >= (3, 8):
6475 type_ignore_classes += (ast.TypeIgnore,)
6476 if isinstance(node, type_ignore_classes):
6480 value = getattr(node, field)
6481 except AttributeError:
6484 yield f"{' ' * (depth+1)}{field}="
6486 if isinstance(value, list):
6488 # Ignore nested tuples within del statements, because we may insert
6489 # parentheses and they change the AST.
6492 and isinstance(node, (ast.Delete, ast3.Delete, ast27.Delete))
6493 and isinstance(item, (ast.Tuple, ast3.Tuple, ast27.Tuple))
6495 for item in item.elts:
6496 yield from _stringify_ast(item, depth + 2)
6498 elif isinstance(item, (ast.AST, ast3.AST, ast27.AST)):
6499 yield from _stringify_ast(item, depth + 2)
6501 elif isinstance(value, (ast.AST, ast3.AST, ast27.AST)):
6502 yield from _stringify_ast(value, depth + 2)
6505 # Constant strings may be indented across newlines, if they are
6506 # docstrings; fold spaces after newlines when comparing. Similarly,
6507 # trailing and leading space may be removed.
6508 # Note that when formatting Python 2 code, at least with Windows
6509 # line-endings, docstrings can end up here as bytes instead of
6510 # str so make sure that we handle both cases.
6512 isinstance(node, ast.Constant)
6513 and field == "value"
6514 and isinstance(value, (str, bytes))
6516 lineend = "\n" if isinstance(value, str) else b"\n"
6517 # To normalize, we strip any leading and trailing space from
6519 stripped = [line.strip() for line in value.splitlines()]
6520 normalized = lineend.join(stripped) # type: ignore[attr-defined]
6521 # ...and remove any blank lines at the beginning and end of
6523 normalized = normalized.strip()
6526 yield f"{' ' * (depth+2)}{normalized!r}, # {value.__class__.__name__}"
6528 yield f"{' ' * depth}) # /{node.__class__.__name__}"
6531 def assert_equivalent(src: str, dst: str, *, pass_num: int = 1) -> None:
6532 """Raise AssertionError if `src` and `dst` aren't equivalent."""
6534 src_ast = parse_ast(src)
6535 except Exception as exc:
6536 raise AssertionError(
6537 "cannot use --safe with this file; failed to parse source file. AST"
6538 f" error message: {exc}"
6542 dst_ast = parse_ast(dst)
6543 except Exception as exc:
6544 log = dump_to_file("".join(traceback.format_tb(exc.__traceback__)), dst)
6545 raise AssertionError(
6546 f"INTERNAL ERROR: Black produced invalid code on pass {pass_num}: {exc}. "
6547 "Please report a bug on https://github.com/psf/black/issues. "
6548 f"This invalid output might be helpful: {log}"
6551 src_ast_str = "\n".join(_stringify_ast(src_ast))
6552 dst_ast_str = "\n".join(_stringify_ast(dst_ast))
6553 if src_ast_str != dst_ast_str:
6554 log = dump_to_file(diff(src_ast_str, dst_ast_str, "src", "dst"))
6555 raise AssertionError(
6556 "INTERNAL ERROR: Black produced code that is not equivalent to the"
6557 f" source on pass {pass_num}. Please report a bug on "
6558 f"https://github.com/psf/black/issues. This diff might be helpful: {log}"
6562 def assert_stable(src: str, dst: str, mode: Mode) -> None:
6563 """Raise AssertionError if `dst` reformats differently the second time."""
6564 newdst = format_str(dst, mode=mode)
6568 diff(src, dst, "source", "first pass"),
6569 diff(dst, newdst, "first pass", "second pass"),
6571 raise AssertionError(
6572 "INTERNAL ERROR: Black produced different code on the second pass of the"
6573 " formatter. Please report a bug on https://github.com/psf/black/issues."
6574 f" This diff might be helpful: {log}"
6578 @mypyc_attr(patchable=True)
6579 def dump_to_file(*output: str, ensure_final_newline: bool = True) -> str:
6580 """Dump `output` to a temporary file. Return path to the file."""
6581 with tempfile.NamedTemporaryFile(
6582 mode="w", prefix="blk_", suffix=".log", delete=False, encoding="utf8"
6584 for lines in output:
6586 if ensure_final_newline and lines and lines[-1] != "\n":
6592 def nullcontext() -> Iterator[None]:
6593 """Return an empty context manager.
6595 To be used like `nullcontext` in Python 3.7.
6600 def diff(a: str, b: str, a_name: str, b_name: str) -> str:
6601 """Return a unified diff string between strings `a` and `b`."""
6604 a_lines = [line for line in a.splitlines(keepends=True)]
6605 b_lines = [line for line in b.splitlines(keepends=True)]
6607 for line in difflib.unified_diff(
6608 a_lines, b_lines, fromfile=a_name, tofile=b_name, n=5
6610 # Work around https://bugs.python.org/issue2142
6611 # See https://www.gnu.org/software/diffutils/manual/html_node/Incomplete-Lines.html
6612 if line[-1] == "\n":
6613 diff_lines.append(line)
6615 diff_lines.append(line + "\n")
6616 diff_lines.append("\\ No newline at end of file\n")
6617 return "".join(diff_lines)
6620 def cancel(tasks: Iterable["asyncio.Task[Any]"]) -> None:
6621 """asyncio signal handler that cancels all `tasks` and reports to stderr."""
6627 def shutdown(loop: asyncio.AbstractEventLoop) -> None:
6628 """Cancel all pending tasks on `loop`, wait for them, and close the loop."""
6630 if sys.version_info[:2] >= (3, 7):
6631 all_tasks = asyncio.all_tasks
6633 all_tasks = asyncio.Task.all_tasks
6634 # This part is borrowed from asyncio/runners.py in Python 3.7b2.
6635 to_cancel = [task for task in all_tasks(loop) if not task.done()]
6639 for task in to_cancel:
6641 loop.run_until_complete(
6642 asyncio.gather(*to_cancel, loop=loop, return_exceptions=True)
6645 # `concurrent.futures.Future` objects cannot be cancelled once they
6646 # are already running. There might be some when the `shutdown()` happened.
6647 # Silence their logger's spew about the event loop being closed.
6648 cf_logger = logging.getLogger("concurrent.futures")
6649 cf_logger.setLevel(logging.CRITICAL)
6653 def sub_twice(regex: Pattern[str], replacement: str, original: str) -> str:
6654 """Replace `regex` with `replacement` twice on `original`.
6656 This is used by string normalization to perform replaces on
6657 overlapping matches.
6659 return regex.sub(replacement, regex.sub(replacement, original))
6662 def re_compile_maybe_verbose(regex: str) -> Pattern[str]:
6663 """Compile a regular expression string in `regex`.
6665 If it contains newlines, use verbose mode.
6668 regex = "(?x)" + regex
6669 compiled: Pattern[str] = re.compile(regex)
6673 def enumerate_reversed(sequence: Sequence[T]) -> Iterator[Tuple[Index, T]]:
6674 """Like `reversed(enumerate(sequence))` if that were possible."""
6675 index = len(sequence) - 1
6676 for element in reversed(sequence):
6677 yield (index, element)
6681 def enumerate_with_length(
6682 line: Line, reversed: bool = False
6683 ) -> Iterator[Tuple[Index, Leaf, int]]:
6684 """Return an enumeration of leaves with their length.
6686 Stops prematurely on multiline strings and standalone comments.
6689 Callable[[Sequence[Leaf]], Iterator[Tuple[Index, Leaf]]],
6690 enumerate_reversed if reversed else enumerate,
6692 for index, leaf in op(line.leaves):
6693 length = len(leaf.prefix) + len(leaf.value)
6694 if "\n" in leaf.value:
6695 return # Multiline strings, we can't continue.
6697 for comment in line.comments_after(leaf):
6698 length += len(comment.value)
6700 yield index, leaf, length
6703 def is_line_short_enough(line: Line, *, line_length: int, line_str: str = "") -> bool:
6704 """Return True if `line` is no longer than `line_length`.
6706 Uses the provided `line_str` rendering, if any, otherwise computes a new one.
6709 line_str = line_to_string(line)
6711 len(line_str) <= line_length
6712 and "\n" not in line_str # multiline strings
6713 and not line.contains_standalone_comments()
6717 def can_be_split(line: Line) -> bool:
6718 """Return False if the line cannot be split *for sure*.
6720 This is not an exhaustive search but a cheap heuristic that we can use to
6721 avoid some unfortunate formattings (mostly around wrapping unsplittable code
6722 in unnecessary parentheses).
6724 leaves = line.leaves
6728 if leaves[0].type == token.STRING and leaves[1].type == token.DOT:
6732 for leaf in leaves[-2::-1]:
6733 if leaf.type in OPENING_BRACKETS:
6734 if next.type not in CLOSING_BRACKETS:
6738 elif leaf.type == token.DOT:
6740 elif leaf.type == token.NAME:
6741 if not (next.type == token.DOT or next.type in OPENING_BRACKETS):
6744 elif leaf.type not in CLOSING_BRACKETS:
6747 if dot_count > 1 and call_count > 1:
6753 def can_omit_invisible_parens(
6756 omit_on_explode: Collection[LeafID] = (),
6758 """Does `line` have a shape safe to reformat without optional parens around it?
6760 Returns True for only a subset of potentially nice looking formattings but
6761 the point is to not return false positives that end up producing lines that
6764 bt = line.bracket_tracker
6765 if not bt.delimiters:
6766 # Without delimiters the optional parentheses are useless.
6769 max_priority = bt.max_delimiter_priority()
6770 if bt.delimiter_count_with_priority(max_priority) > 1:
6771 # With more than one delimiter of a kind the optional parentheses read better.
6774 if max_priority == DOT_PRIORITY:
6775 # A single stranded method call doesn't require optional parentheses.
6778 assert len(line.leaves) >= 2, "Stranded delimiter"
6780 # With a single delimiter, omit if the expression starts or ends with
6782 first = line.leaves[0]
6783 second = line.leaves[1]
6784 if first.type in OPENING_BRACKETS and second.type not in CLOSING_BRACKETS:
6785 if _can_omit_opening_paren(line, first=first, line_length=line_length):
6788 # Note: we are not returning False here because a line might have *both*
6789 # a leading opening bracket and a trailing closing bracket. If the
6790 # opening bracket doesn't match our rule, maybe the closing will.
6792 penultimate = line.leaves[-2]
6793 last = line.leaves[-1]
6794 if line.magic_trailing_comma:
6796 penultimate, last = last_two_except(line.leaves, omit=omit_on_explode)
6798 # Turns out we'd omit everything. We cannot skip the optional parentheses.
6802 last.type == token.RPAR
6803 or last.type == token.RBRACE
6805 # don't use indexing for omitting optional parentheses;
6807 last.type == token.RSQB
6809 and last.parent.type != syms.trailer
6812 if penultimate.type in OPENING_BRACKETS:
6813 # Empty brackets don't help.
6816 if is_multiline_string(first):
6817 # Additional wrapping of a multiline string in this situation is
6821 if line.magic_trailing_comma and penultimate.type == token.COMMA:
6822 # The rightmost non-omitted bracket pair is the one we want to explode on.
6825 if _can_omit_closing_paren(line, last=last, line_length=line_length):
6831 def _can_omit_opening_paren(line: Line, *, first: Leaf, line_length: int) -> bool:
6832 """See `can_omit_invisible_parens`."""
6834 length = 4 * line.depth
6836 for _index, leaf, leaf_length in enumerate_with_length(line):
6837 if leaf.type in CLOSING_BRACKETS and leaf.opening_bracket is first:
6840 length += leaf_length
6841 if length > line_length:
6844 if leaf.type in OPENING_BRACKETS:
6845 # There are brackets we can further split on.
6849 # checked the entire string and line length wasn't exceeded
6850 if len(line.leaves) == _index + 1:
6856 def _can_omit_closing_paren(line: Line, *, last: Leaf, line_length: int) -> bool:
6857 """See `can_omit_invisible_parens`."""
6858 length = 4 * line.depth
6859 seen_other_brackets = False
6860 for _index, leaf, leaf_length in enumerate_with_length(line):
6861 length += leaf_length
6862 if leaf is last.opening_bracket:
6863 if seen_other_brackets or length <= line_length:
6866 elif leaf.type in OPENING_BRACKETS:
6867 # There are brackets we can further split on.
6868 seen_other_brackets = True
6873 def last_two_except(leaves: List[Leaf], omit: Collection[LeafID]) -> Tuple[Leaf, Leaf]:
6874 """Return (penultimate, last) leaves skipping brackets in `omit` and contents."""
6877 for leaf in reversed(leaves):
6879 if leaf is stop_after:
6886 if id(leaf) in omit:
6887 stop_after = leaf.opening_bracket
6891 raise LookupError("Last two leaves were also skipped")
6894 def run_transformer(
6896 transform: Transformer,
6898 features: Collection[Feature],
6903 line_str = line_to_string(line)
6904 result: List[Line] = []
6905 for transformed_line in transform(line, features):
6906 if str(transformed_line).strip("\n") == line_str:
6907 raise CannotTransform("Line transformer returned an unchanged result")
6909 result.extend(transform_line(transformed_line, mode=mode, features=features))
6912 transform.__name__ == "rhs"
6913 and line.bracket_tracker.invisible
6914 and not any(bracket.value for bracket in line.bracket_tracker.invisible)
6915 and not line.contains_multiline_strings()
6916 and not result[0].contains_uncollapsable_type_comments()
6917 and not result[0].contains_unsplittable_type_ignore()
6918 and not is_line_short_enough(result[0], line_length=mode.line_length)
6922 line_copy = line.clone()
6923 append_leaves(line_copy, line, line.leaves)
6924 features_fop = set(features) | {Feature.FORCE_OPTIONAL_PARENTHESES}
6925 second_opinion = run_transformer(
6926 line_copy, transform, mode, features_fop, line_str=line_str
6929 is_line_short_enough(ln, line_length=mode.line_length) for ln in second_opinion
6931 result = second_opinion
6935 def get_cache_file(mode: Mode) -> Path:
6936 return CACHE_DIR / f"cache.{mode.get_cache_key()}.pickle"
6939 def read_cache(mode: Mode) -> Cache:
6940 """Read the cache if it exists and is well formed.
6942 If it is not well formed, the call to write_cache later should resolve the issue.
6944 cache_file = get_cache_file(mode)
6945 if not cache_file.exists():
6948 with cache_file.open("rb") as fobj:
6950 cache: Cache = pickle.load(fobj)
6951 except (pickle.UnpicklingError, ValueError):
6957 def get_cache_info(path: Path) -> CacheInfo:
6958 """Return the information used to check if a file is already formatted or not."""
6960 return stat.st_mtime, stat.st_size
6963 def filter_cached(cache: Cache, sources: Iterable[Path]) -> Tuple[Set[Path], Set[Path]]:
6964 """Split an iterable of paths in `sources` into two sets.
6966 The first contains paths of files that modified on disk or are not in the
6967 cache. The other contains paths to non-modified files.
6969 todo, done = set(), set()
6971 res_src = src.resolve()
6972 if cache.get(str(res_src)) != get_cache_info(res_src):
6979 def write_cache(cache: Cache, sources: Iterable[Path], mode: Mode) -> None:
6980 """Update the cache file."""
6981 cache_file = get_cache_file(mode)
6983 CACHE_DIR.mkdir(parents=True, exist_ok=True)
6986 **{str(src.resolve()): get_cache_info(src) for src in sources},
6988 with tempfile.NamedTemporaryFile(dir=str(cache_file.parent), delete=False) as f:
6989 pickle.dump(new_cache, f, protocol=4)
6990 os.replace(f.name, cache_file)
6995 def patch_click() -> None:
6996 """Make Click not crash.
6998 On certain misconfigured environments, Python 3 selects the ASCII encoding as the
6999 default which restricts paths that it can access during the lifetime of the
7000 application. Click refuses to work in this scenario by raising a RuntimeError.
7002 In case of Black the likelihood that non-ASCII characters are going to be used in
7003 file paths is minimal since it's Python source code. Moreover, this crash was
7004 spurious on Python 3.7 thanks to PEP 538 and PEP 540.
7007 from click import core
7008 from click import _unicodefun # type: ignore
7009 except ModuleNotFoundError:
7012 for module in (core, _unicodefun):
7013 if hasattr(module, "_verify_python3_env"):
7014 module._verify_python3_env = lambda: None
7017 def patched_main() -> None:
7023 def is_docstring(leaf: Leaf) -> bool:
7024 if prev_siblings_are(
7025 leaf.parent, [None, token.NEWLINE, token.INDENT, syms.simple_stmt]
7029 # Multiline docstring on the same line as the `def`.
7030 if prev_siblings_are(leaf.parent, [syms.parameters, token.COLON, syms.simple_stmt]):
7031 # `syms.parameters` is only used in funcdefs and async_funcdefs in the Python
7032 # grammar. We're safe to return True without further checks.
7038 def lines_with_leading_tabs_expanded(s: str) -> List[str]:
7040 Splits string into lines and expands only leading tabs (following the normal
7044 for line in s.splitlines():
7045 # Find the index of the first non-whitespace character after a string of
7046 # whitespace that includes at least one tab
7047 match = re.match(r"\s*\t+\s*(\S)", line)
7049 first_non_whitespace_idx = match.start(1)
7052 line[:first_non_whitespace_idx].expandtabs()
7053 + line[first_non_whitespace_idx:]
7060 def fix_docstring(docstring: str, prefix: str) -> str:
7061 # https://www.python.org/dev/peps/pep-0257/#handling-docstring-indentation
7064 lines = lines_with_leading_tabs_expanded(docstring)
7065 # Determine minimum indentation (first line doesn't count):
7066 indent = sys.maxsize
7067 for line in lines[1:]:
7068 stripped = line.lstrip()
7070 indent = min(indent, len(line) - len(stripped))
7071 # Remove indentation (first line is special):
7072 trimmed = [lines[0].strip()]
7073 if indent < sys.maxsize:
7074 last_line_idx = len(lines) - 2
7075 for i, line in enumerate(lines[1:]):
7076 stripped_line = line[indent:].rstrip()
7077 if stripped_line or i == last_line_idx:
7078 trimmed.append(prefix + stripped_line)
7081 return "\n".join(trimmed)
7084 if __name__ == "__main__":