X-Git-Url: https://git.madduck.net/etc/vim.git/blobdiff_plain/658eb7161d8d0c23bafe4881e70518c33a74a4c1..e818260f1a223929d8f2056f484b73eaa8687622:/black.py?ds=sidebyside diff --git a/black.py b/black.py index e1a71e8..7dc6ef8 100644 --- a/black.py +++ b/black.py @@ -159,6 +159,23 @@ class Changed(Enum): "silence those with 2>/dev/null." ), ) +@click.option( + "--pyi", + is_flag=True, + help=( + "Consider all input files typing stubs regardless of file extension " + "(useful when piping source on standard input)." + ), +) +@click.option( + "--py36", + is_flag=True, + help=( + "Allow using Python 3.6-only syntax on all input files. This will put " + "trailing commas in function signatures and calls also after *args and " + "**kwargs. [default: per-file auto-detection]" + ), +) @click.version_option(version=__version__) @click.argument( "src", @@ -174,6 +191,8 @@ def main( check: bool, diff: bool, fast: bool, + pyi: bool, + py36: bool, quiet: bool, src: List[str], ) -> None: @@ -204,14 +223,30 @@ def main( return elif len(sources) == 1: - reformat_one(sources[0], line_length, fast, write_back, report) + reformat_one( + src=sources[0], + line_length=line_length, + fast=fast, + pyi=pyi, + py36=py36, + write_back=write_back, + report=report, + ) else: loop = asyncio.get_event_loop() executor = ProcessPoolExecutor(max_workers=os.cpu_count()) try: loop.run_until_complete( schedule_formatting( - sources, line_length, fast, write_back, report, loop, executor + sources=sources, + line_length=line_length, + fast=fast, + pyi=pyi, + py36=py36, + write_back=write_back, + report=report, + loop=loop, + executor=executor, ) ) finally: @@ -223,33 +258,49 @@ def main( def reformat_one( - src: Path, line_length: int, fast: bool, write_back: WriteBack, report: "Report" + src: Path, + line_length: int, + fast: bool, + pyi: bool, + py36: bool, + write_back: WriteBack, + report: "Report", ) -> None: """Reformat a single file under `src` without spawning child processes. If `quiet` is True, non-error messages are not output. `line_length`, - `write_back`, and `fast` options are passed to :func:`format_file_in_place`. + `write_back`, `fast` and `pyi` options are passed to + :func:`format_file_in_place` or :func:`format_stdin_to_stdout`. """ try: changed = Changed.NO if not src.is_file() and str(src) == "-": if format_stdin_to_stdout( - line_length=line_length, fast=fast, write_back=write_back + line_length=line_length, + fast=fast, + is_pyi=pyi, + force_py36=py36, + write_back=write_back, ): changed = Changed.YES else: cache: Cache = {} if write_back != WriteBack.DIFF: - cache = read_cache(line_length) + cache = read_cache(line_length, pyi, py36) src = src.resolve() if src in cache and cache[src] == get_cache_info(src): changed = Changed.CACHED if changed is not Changed.CACHED and format_file_in_place( - src, line_length=line_length, fast=fast, write_back=write_back + src, + line_length=line_length, + fast=fast, + force_pyi=pyi, + force_py36=py36, + write_back=write_back, ): changed = Changed.YES if write_back == WriteBack.YES and changed is not Changed.NO: - write_cache(cache, [src], line_length) + write_cache(cache, [src], line_length, pyi, py36) report.done(src, changed) except Exception as exc: report.failed(src, str(exc)) @@ -259,6 +310,8 @@ async def schedule_formatting( sources: List[Path], line_length: int, fast: bool, + pyi: bool, + py36: bool, write_back: WriteBack, report: "Report", loop: BaseEventLoop, @@ -268,12 +321,12 @@ async def schedule_formatting( (Use ProcessPoolExecutors for actual parallelism.) - `line_length`, `write_back`, and `fast` options are passed to + `line_length`, `write_back`, `fast`, and `pyi` options are passed to :func:`format_file_in_place`. """ cache: Cache = {} if write_back != WriteBack.DIFF: - cache = read_cache(line_length) + cache = read_cache(line_length, pyi, py36) sources, cached = filter_cached(cache, sources) for src in cached: report.done(src, Changed.CACHED) @@ -288,7 +341,15 @@ async def schedule_formatting( lock = manager.Lock() tasks = { loop.run_in_executor( - executor, format_file_in_place, src, line_length, fast, write_back, lock + executor, + format_file_in_place, + src, + line_length, + fast, + pyi, + py36, + write_back, + lock, ): src for src in sorted(sources) } @@ -313,13 +374,15 @@ async def schedule_formatting( if cancelled: await asyncio.gather(*cancelled, loop=loop, return_exceptions=True) if write_back == WriteBack.YES and formatted: - write_cache(cache, formatted, line_length) + write_cache(cache, formatted, line_length, pyi, py36) def format_file_in_place( src: Path, line_length: int, fast: bool, + force_pyi: bool = False, + force_py36: bool = False, write_back: WriteBack = WriteBack.NO, lock: Any = None, # multiprocessing.Manager().Lock() is some crazy proxy ) -> bool: @@ -328,13 +391,17 @@ def format_file_in_place( If `write_back` is True, write reformatted code back to stdout. `line_length` and `fast` options are passed to :func:`format_file_contents`. """ - is_pyi = src.suffix == ".pyi" + is_pyi = force_pyi or src.suffix == ".pyi" with tokenize.open(src) as src_buffer: src_contents = src_buffer.read() try: dst_contents = format_file_contents( - src_contents, line_length=line_length, fast=fast, is_pyi=is_pyi + src_contents, + line_length=line_length, + fast=fast, + is_pyi=is_pyi, + force_py36=force_py36, ) except NothingChanged: return False @@ -357,17 +424,28 @@ def format_file_in_place( def format_stdin_to_stdout( - line_length: int, fast: bool, write_back: WriteBack = WriteBack.NO + line_length: int, + fast: bool, + is_pyi: bool = False, + force_py36: bool = False, + write_back: WriteBack = WriteBack.NO, ) -> bool: """Format file on stdin. Return True if changed. If `write_back` is True, write reformatted code back to stdout. - `line_length` and `fast` arguments are passed to :func:`format_file_contents`. + `line_length`, `fast`, `is_pyi`, and `force_py36` arguments are passed to + :func:`format_file_contents`. """ src = sys.stdin.read() dst = src try: - dst = format_file_contents(src, line_length=line_length, fast=fast) + dst = format_file_contents( + src, + line_length=line_length, + fast=fast, + is_pyi=is_pyi, + force_py36=force_py36, + ) return True except NothingChanged: @@ -383,7 +461,12 @@ def format_stdin_to_stdout( def format_file_contents( - src_contents: str, *, line_length: int, fast: bool, is_pyi: bool = False + src_contents: str, + *, + line_length: int, + fast: bool, + is_pyi: bool = False, + force_py36: bool = False, ) -> FileContent: """Reformat contents a file and return new contents. @@ -394,20 +477,30 @@ def format_file_contents( if src_contents.strip() == "": raise NothingChanged - dst_contents = format_str(src_contents, line_length=line_length, is_pyi=is_pyi) + dst_contents = format_str( + src_contents, line_length=line_length, is_pyi=is_pyi, force_py36=force_py36 + ) if src_contents == dst_contents: raise NothingChanged if not fast: assert_equivalent(src_contents, dst_contents) assert_stable( - src_contents, dst_contents, line_length=line_length, is_pyi=is_pyi + src_contents, + dst_contents, + line_length=line_length, + is_pyi=is_pyi, + force_py36=force_py36, ) return dst_contents def format_str( - src_contents: str, line_length: int, *, is_pyi: bool = False + src_contents: str, + line_length: int, + *, + is_pyi: bool = False, + force_py36: bool = False, ) -> FileContent: """Reformat a string and return new contents. @@ -417,7 +510,7 @@ def format_str( dst_contents = "" future_imports = get_future_imports(src_node) elt = EmptyLineTracker(is_pyi=is_pyi) - py36 = is_python36(src_node) + py36 = force_py36 or is_python36(src_node) lines = LineGenerator( remove_u_prefix=py36 or "unicode_literals" in future_imports, is_pyi=is_pyi ) @@ -878,27 +971,6 @@ class Line: and second_leaf.value == "def" ) - @property - def is_flow_control(self) -> bool: - """Is this line a flow control statement? - - Those are `return`, `raise`, `break`, and `continue`. - """ - return ( - bool(self) - and self.leaves[0].type == token.NAME - and self.leaves[0].value in FLOW_CONTROL - ) - - @property - def is_yield(self) -> bool: - """Is this line a yield statement?""" - return ( - bool(self) - and self.leaves[0].type == token.NAME - and self.leaves[0].value == "yield" - ) - @property def is_class_paren_empty(self) -> bool: """Is this a class with no base classes but using parentheses? @@ -915,6 +987,18 @@ class Line: and self.leaves[3].value == ")" ) + @property + def is_triple_quoted_string(self) -> bool: + """Is the line a triple quoted docstring?""" + return ( + bool(self) + and self.leaves[0].type == token.STRING + and ( + self.leaves[0].value.startswith('"""') + or self.leaves[0].value.startswith("'''") + ) + ) + def contains_standalone_comments(self, depth_limit: int = sys.maxsize) -> bool: """If so, needs to be split before emitting.""" for leaf in self.leaves: @@ -1122,6 +1206,7 @@ class EmptyLineTracker: the prefix of the first leaf consists of optional newlines. Those newlines are consumed by `maybe_empty_lines()` and included in the computation. """ + is_pyi: bool = False previous_line: Optional[Line] = None previous_after: int = 0 @@ -1131,8 +1216,7 @@ class EmptyLineTracker: """Return the number of extra empty lines before and after the `current_line`. This is for separating `def`, `async def` and `class` with extra empty - lines (two on module-level), as well as providing an extra empty line - after flow control keywords to make them more prominent. + lines (two on module-level). """ if isinstance(current_line, UnformattedLines): return 0, 0 @@ -1173,6 +1257,12 @@ class EmptyLineTracker: if self.previous_line.is_decorator: return 0, 0 + if ( + self.previous_line.is_class + and self.previous_line.depth != current_line.depth + ): + return 0, 0 + if ( self.previous_line.is_comment and self.previous_line.depth == current_line.depth @@ -1204,6 +1294,13 @@ class EmptyLineTracker: ): return (before or 1), 0 + if ( + self.previous_line + and self.previous_line.is_class + and current_line.is_triple_quoted_string + ): + return before, 1 + return before, 0 @@ -1214,6 +1311,7 @@ class LineGenerator(Visitor[Line]): Note: destroys the tree it's visiting by mutating prefixes of its leaves in ways that will no longer stringify to valid Python code on the tree. """ + is_pyi: bool = False current_line: Line = Factory(Line) remove_u_prefix: bool = False @@ -2697,6 +2795,7 @@ def gen_python_files_in_dir(path: Path) -> Iterator[Path]: @dataclass class Report: """Provides a reformatting counter. Can be rendered with `str(report)`.""" + check: bool = False quiet: bool = False change_count: int = 0 @@ -2836,9 +2935,13 @@ def assert_equivalent(src: str, dst: str) -> None: ) from None -def assert_stable(src: str, dst: str, line_length: int, is_pyi: bool = False) -> None: +def assert_stable( + src: str, dst: str, line_length: int, is_pyi: bool = False, force_py36: bool = False +) -> None: """Raise AssertionError if `dst` reformats differently the second time.""" - newdst = format_str(dst, line_length=line_length, is_pyi=is_pyi) + newdst = format_str( + dst, line_length=line_length, is_pyi=is_pyi, force_py36=force_py36 + ) if dst != newdst: log = dump_to_file( diff(src, dst, "source", "first pass"), @@ -3049,16 +3152,19 @@ def can_omit_invisible_parens(line: Line, line_length: int) -> bool: return False -def get_cache_file(line_length: int) -> Path: - return CACHE_DIR / f"cache.{line_length}.pickle" +def get_cache_file(line_length: int, pyi: bool = False, py36: bool = False) -> Path: + return ( + CACHE_DIR + / f"cache.{line_length}{'.pyi' if pyi else ''}{'.py36' if py36 else ''}.pickle" + ) -def read_cache(line_length: int) -> Cache: +def read_cache(line_length: int, pyi: bool = False, py36: bool = False) -> Cache: """Read the cache if it exists and is well formed. If it is not well formed, the call to write_cache later should resolve the issue. """ - cache_file = get_cache_file(line_length) + cache_file = get_cache_file(line_length, pyi, py36) if not cache_file.exists(): return {} @@ -3095,9 +3201,15 @@ def filter_cached( return todo, done -def write_cache(cache: Cache, sources: List[Path], line_length: int) -> None: +def write_cache( + cache: Cache, + sources: List[Path], + line_length: int, + pyi: bool = False, + py36: bool = False, +) -> None: """Update the cache file.""" - cache_file = get_cache_file(line_length) + cache_file = get_cache_file(line_length, pyi, py36) try: if not CACHE_DIR.exists(): CACHE_DIR.mkdir(parents=True)