]>
git.madduck.net Git - etc/vim.git/blobdiff - black.py
madduck's git repository
Every one of the projects in this repository is available at the canonical
URL git://git.madduck.net/madduck/pub/<projectpath> — see
each project's metadata for the exact URL.
All patches and comments are welcome. Please squash your changes to logical
commits before using git-format-patch and git-send-email to
patches@ git. madduck. net .
If you'd read over the Git project's submission guidelines and adhered to them,
I'd be especially grateful.
SSH access, as well as push access can be individually
arranged .
If you use my repositories frequently, consider adding the following
snippet to ~/.gitconfig and using the third clone URL listed for each
project:
[url "git://git.madduck.net/madduck/"]
insteadOf = madduck:
manager = Manager()
lock = manager.Lock()
tasks = {
manager = Manager()
lock = manager.Lock()
tasks = {
- src: 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, write_back, lock
+ ): src
+ for src in sorted(sources)
- _task_values = list(tasks.values() )
+ pending: Iterable[asyncio.Task] = tasks.keys( )
- loop.add_signal_handler(signal.SIGINT, cancel, _task_values )
- loop.add_signal_handler(signal.SIGTERM, cancel, _task_values )
+ loop.add_signal_handler(signal.SIGINT, cancel, pending )
+ loop.add_signal_handler(signal.SIGTERM, cancel, pending )
except NotImplementedError:
# There are no good alternatives for these on Windows
pass
except NotImplementedError:
# There are no good alternatives for these on Windows
pass
- await asyncio.wait(_task_values)
- for src, task in tasks.items():
- if not task.done():
- report.failed(src, "timed out, cancelling")
- task.cancel()
- cancelled.append(task)
- elif task.cancelled():
- cancelled.append(task)
- elif task.exception():
- report.failed(src, str(task.exception()))
- else:
- formatted.append(src)
- report.done(src, Changed.YES if task.result() else Changed.NO)
-
+ while pending:
+ done, _ = await asyncio.wait(pending, return_when=asyncio.FIRST_COMPLETED)
+ for task in done:
+ src = tasks.pop(task)
+ if task.cancelled():
+ cancelled.append(task)
+ elif task.exception():
+ report.failed(src, str(task.exception()))
+ else:
+ formatted.append(src)
+ report.done(src, Changed.YES if task.result() else Changed.NO)
if cancelled:
await asyncio.gather(*cancelled, loop=loop, return_exceptions=True)
if write_back == WriteBack.YES and formatted:
if cancelled:
await asyncio.gather(*cancelled, loop=loop, return_exceptions=True)
if write_back == WriteBack.YES and formatted:
STRING_PRIORITY = 12
COMPARATOR_PRIORITY = 10
MATH_PRIORITIES = {
STRING_PRIORITY = 12
COMPARATOR_PRIORITY = 10
MATH_PRIORITIES = {
- token.VBAR: 8 ,
- token.CIRCUMFLEX: 7 ,
- token.AMPER: 6 ,
- token.LEFTSHIFT: 5 ,
- token.RIGHTSHIFT: 5 ,
- token.PLUS: 4 ,
- token.MINUS: 4 ,
- token.STAR: 3 ,
- token.SLASH: 3 ,
- token.DOUBLESLASH: 3 ,
- token.PERCENT: 3 ,
- token.AT: 3 ,
- token.TILDE: 2 ,
- token.DOUBLESTAR: 1 ,
+ token.VBAR: 9 ,
+ token.CIRCUMFLEX: 8 ,
+ token.AMPER: 7 ,
+ token.LEFTSHIFT: 6 ,
+ token.RIGHTSHIFT: 6 ,
+ token.PLUS: 5 ,
+ token.MINUS: 5 ,
+ token.STAR: 4 ,
+ token.SLASH: 4 ,
+ token.DOUBLESLASH: 4 ,
+ token.PERCENT: 4 ,
+ token.AT: 4 ,
+ token.TILDE: 3 ,
+ token.DOUBLESTAR: 2 ,
"""
return max(v for k, v in self.delimiters.items() if k not in exclude)
"""
return max(v for k, v in self.delimiters.items() if k not in exclude)
+ def delimiter_count_with_priority(self, priority: int = 0) -> int:
+ """Return the number of delimiters with the given `priority`.
+
+ If no `priority` is passed, defaults to max priority on the line.
+ """
+ if not self.delimiters:
+ return 0
+
+ priority = priority or self.max_delimiter_priority()
+ return sum(1 for p in self.delimiters.values() if p == priority)
+
def maybe_increment_for_loop_variable(self, leaf: Leaf) -> bool:
"""In a for loop, or comprehension, the variables are often unpacks.
def maybe_increment_for_loop_variable(self, leaf: Leaf) -> bool:
"""In a for loop, or comprehension, the variables are often unpacks.
comments: List[Tuple[Index, Leaf]] = Factory(list)
bracket_tracker: BracketTracker = Factory(BracketTracker)
inside_brackets: bool = False
comments: List[Tuple[Index, Leaf]] = Factory(list)
bracket_tracker: BracketTracker = Factory(BracketTracker)
inside_brackets: bool = False
+ should_explode: bool = False
def append(self, leaf: Leaf, preformatted: bool = False) -> None:
"""Add a new `leaf` to the end of the line.
def append(self, leaf: Leaf, preformatted: bool = False) -> None:
"""Add a new `leaf` to the end of the line.
@property
def is_stub_class(self) -> bool:
"""Is this line a class definition with a body consisting only of "..."?"""
@property
def is_stub_class(self) -> bool:
"""Is this line a class definition with a body consisting only of "..."?"""
- return (
- self.is_class
- and self.leaves[-3:] == [Leaf(token.DOT, ".") for _ in range(3)]
- )
+ return self.is_class and self.leaves[-3:] == [
+ Leaf(token.DOT, ".") for _ in range(3)
+ ]
@property
def is_def(self) -> bool:
@property
def is_def(self) -> bool:
The relevant Python language `keywords` for a given statement will be
NAME leaves within it. This methods puts those on a separate line.
The relevant Python language `keywords` for a given statement will be
NAME leaves within it. This methods puts those on a separate line.
- `parens` holds a set of string leaf values immeditely after which
+ `parens` holds a set of string leaf values immedia tely after which
invisible parens should be put.
"""
normalize_invisible_parens(node, parens_after=parens)
invisible parens should be put.
"""
normalize_invisible_parens(node, parens_after=parens)
return DOUBLESPACE
assert p is not None, f"INTERNAL ERROR: hand-made leaf without parent: {leaf!r}"
return DOUBLESPACE
assert p is not None, f"INTERNAL ERROR: hand-made leaf without parent: {leaf!r}"
- if (
- t == token.COLON
- and p.type not in {syms.subscript, syms.subscriptlist, syms.sliceop}
- ):
+ if t == token.COLON and p.type not in {
+ syms.subscript,
+ syms.subscriptlist,
+ syms.sliceop,
+ }:
return NO
prev = leaf.prev_sibling
return NO
prev = leaf.prev_sibling
if prevp.type == token.EQUAL:
if prevp.parent:
if prevp.parent.type in {
if prevp.type == token.EQUAL:
if prevp.parent:
if prevp.parent.type in {
- syms.arglist, syms.argument, syms.parameters, syms.varargslist
+ syms.arglist,
+ syms.argument,
+ syms.parameters,
+ syms.varargslist,
prevp_parent = prevp.parent
assert prevp_parent is not None
prevp_parent = prevp.parent
assert prevp_parent is not None
- if (
- prevp.type == token.COLON
- and prevp_parent.type in {syms.subscript, syms.sliceop}
- ) :
+ if prevp.type == token.COLON and prevp_parent.type in {
+ syms.subscript,
+ syms.sliceop,
+ } :
return NO
elif prevp.type == token.EQUAL and prevp_parent.type == syms.argument:
return NO
elif prevp.type == token.EQUAL and prevp_parent.type == syms.argument:
# Don't treat them as a delimiter.
return 0
# Don't treat them as a delimiter.
return 0
+ if (
+ leaf.type == token.DOT
+ and leaf.parent
+ and leaf.parent.type not in {syms.import_from, syms.dotted_name}
+ and (previous is None or previous.type in CLOSING_BRACKETS)
+ ):
+ return DOT_PRIORITY
+
if (
leaf.type in MATH_OPERATORS
and leaf.parent
if (
leaf.type in MATH_OPERATORS
and leaf.parent
):
return STRING_PRIORITY
):
return STRING_PRIORITY
+ if leaf.type != token.NAME:
+ return 0
+
- leaf.type == token.NAME
- and leaf.value == "for"
and leaf.parent
and leaf.parent.type in {syms.comp_for, syms.old_comp_for}
):
return COMPREHENSION_PRIORITY
if (
and leaf.parent
and leaf.parent.type in {syms.comp_for, syms.old_comp_for}
):
return COMPREHENSION_PRIORITY
if (
- leaf.type == token.NAME
- and leaf.value == "if"
and leaf.parent
and leaf.parent.type in {syms.comp_if, syms.old_comp_if}
):
return COMPREHENSION_PRIORITY
and leaf.parent
and leaf.parent.type in {syms.comp_if, syms.old_comp_if}
):
return COMPREHENSION_PRIORITY
+ if leaf.value in {"if", "else"} and leaf.parent and leaf.parent.type == syms.test:
+ return TERNARY_PRIORITY
+
+ if leaf.value == "is":
+ return COMPARATOR_PRIORITY
+
- leaf.type == token.NAME
- and leaf.value in {"if", "else"}
- and leaf.parent.type == syms.test
+ and leaf.parent.type in {syms.comp_op, syms.comparison}
+ and not (
+ previous is not None
+ and previous.type == token.NAME
+ and previous.value == "not"
+ )
- return TERNARY _PRIORITY
+ return COMPARATOR _PRIORITY
- if leaf.type == token.NAME and leaf.value in LOGIC_OPERATORS and leaf.parent:
+ if (
+ leaf.value == "not"
+ and leaf.parent
+ and leaf.parent.type == syms.comp_op
+ and not (
+ previous is not None
+ and previous.type == token.NAME
+ and previous.value == "is"
+ )
+ ):
+ return COMPARATOR_PRIORITY
+
+ if leaf.value in LOGIC_OPERATORS and leaf.parent:
return LOGIC_PRIORITY
return 0
return LOGIC_PRIORITY
return 0
return
line_str = str(line).strip("\n")
return
line_str = str(line).strip("\n")
- if is_line_short_enough(line, line_length=line_length, line_str=line_str):
+ if not line.should_explode and is_line_short_enough(
+ line, line_length=line_length, line_str=line_str
+ ):
yield line
return
split_funcs: List[SplitFunc]
if line.is_def:
split_funcs = [left_hand_split]
yield line
return
split_funcs: List[SplitFunc]
if line.is_def:
split_funcs = [left_hand_split]
- elif line.is_import:
- split_funcs = [explode_split]
else:
def rhs(line: Line, py36: bool = False) -> Iterator[Line]:
else:
def rhs(line: Line, py36: bool = False) -> Iterator[Line]:
and not line.is_import
):
omit = {id(closing_bracket), *omit}
and not line.is_import
):
omit = {id(closing_bracket), *omit}
- delimiter_count = len(body.bracket_tracker.delimiters )
+ delimiter_count = body.bracket_tracker.delimiter_count_with_priority( )
if (
delimiter_count == 0
or delimiter_count == 1
if (
delimiter_count == 0
or delimiter_count == 1
ensure_visible(opening_bracket)
ensure_visible(closing_bracket)
ensure_visible(opening_bracket)
ensure_visible(closing_bracket)
+ body.should_explode = should_explode(body, opening_bracket)
for result in (head, body, tail):
if result:
yield result
for result in (head, body, tail):
if result:
yield result
except IndexError:
raise CannotSplit("Line empty")
except IndexError:
raise CannotSplit("Line empty")
- delimiters = line.bracket_tracker.delimiters
+ bt = line.bracket_tracker
- delimiter_priority = line.bracket_tracker.max_delimiter_priority(
- exclude={id(last_leaf)}
- )
+ delimiter_priority = bt.max_delimiter_priority(exclude={id(last_leaf)})
except ValueError:
raise CannotSplit("No delimiters found")
except ValueError:
raise CannotSplit("No delimiters found")
+ if delimiter_priority == DOT_PRIORITY:
+ if bt.delimiter_count_with_priority(delimiter_priority) == 1:
+ raise CannotSplit("Splitting a single attribute from its owner looks wrong")
+
current_line = Line(depth=line.depth, inside_brackets=line.inside_brackets)
lowest_depth = sys.maxsize
trailing_comma_safe = True
current_line = Line(depth=line.depth, inside_brackets=line.inside_brackets)
lowest_depth = sys.maxsize
trailing_comma_safe = True
yield from append_to_line(comment_after)
lowest_depth = min(lowest_depth, leaf.bracket_depth)
yield from append_to_line(comment_after)
lowest_depth = min(lowest_depth, leaf.bracket_depth)
- if (
- leaf.bracket_depth == lowest_depth
- and is_vararg(leaf, within=VARARGS_PARENTS)
+ if leaf.bracket_depth == lowest_depth and is_vararg(
+ leaf, within=VARARGS_PARENTS
):
trailing_comma_safe = trailing_comma_safe and py36
):
trailing_comma_safe = trailing_comma_safe and py36
- leaf_priority = delimiters.get(id(leaf))
+ leaf_priority = bt. delimiters.get(id(leaf))
if leaf_priority == delimiter_priority:
yield current_line
if leaf_priority == delimiter_priority:
yield current_line
-def explode_split(
- line: Line, py36: bool = False, omit: Collection[LeafID] = ()
-) -> Iterator[Line]:
- """Split by rightmost bracket and immediately split contents by a delimiter."""
- new_lines = list(right_hand_split(line, py36, omit))
- if len(new_lines) != 3:
- yield from new_lines
- return
-
- yield new_lines[0]
-
- try:
- yield from delimiter_split(new_lines[1], py36)
-
- except CannotSplit:
- yield new_lines[1]
-
- yield new_lines[2]
-
-
def is_import(leaf: Leaf) -> bool:
"""Return True if the given leaf starts an import statement."""
p = leaf.parent
def is_import(leaf: Leaf) -> bool:
"""Return True if the given leaf starts an import statement."""
p = leaf.parent
rpar = Leaf(token.RPAR, ")")
index = child.remove() or 0
node.insert_child(index, Node(syms.atom, [lpar, child, rpar]))
rpar = Leaf(token.RPAR, ")")
index = child.remove() or 0
node.insert_child(index, Node(syms.atom, [lpar, child, rpar]))
+ elif not (isinstance(child, Leaf) and is_multiline_string(child)) :
# wrap child in invisible parentheses
lpar = Leaf(token.LPAR, "")
rpar = Leaf(token.RPAR, "")
# wrap child in invisible parentheses
lpar = Leaf(token.LPAR, "")
rpar = Leaf(token.RPAR, "")
+def is_multiline_string(leaf: Leaf) -> bool:
+ """Return True if `leaf` is a multiline string that actually spans many lines."""
+ value = leaf.value.lstrip("furbFURB")
+ return value[:3] in {'"""', "'''"} and "\n" in value
+
+
def is_stub_suite(node: Node) -> bool:
"""Return True if `node` is a suite with a stub body."""
if (
def is_stub_suite(node: Node) -> bool:
"""Return True if `node` is a suite with a stub body."""
if (
+def should_explode(line: Line, opening_bracket: Leaf) -> bool:
+ """Should `line` immediately be split with `delimiter_split()` after RHS?"""
+ return bool(
+ opening_bracket.parent
+ and opening_bracket.parent.type in {syms.atom, syms.import_from}
+ and opening_bracket.value in "[{("
+ and line.bracket_tracker.delimiters
+ and line.bracket_tracker.max_delimiter_priority() == COMMA_PRIORITY
+ )
+
+
def is_python36(node: Node) -> bool:
"""Return True if the current file is using Python 3.6+ features.
def is_python36(node: Node) -> bool:
"""Return True if the current file is using Python 3.6+ features.
PYTHON_EXTENSIONS = {".py", ".pyi"}
BLACKLISTED_DIRECTORIES = {
PYTHON_EXTENSIONS = {".py", ".pyi"}
BLACKLISTED_DIRECTORIES = {
- "build", "buck-out", "dist", "_build", ".git", ".hg", ".mypy_cache", ".tox", ".venv"
+ "build",
+ "buck-out",
+ "dist",
+ "_build",
+ ".git",
+ ".hg",
+ ".mypy_cache",
+ ".tox",
+ ".venv",
-def cancel(tasks: List [asyncio.Task]) -> None:
+def cancel(tasks: Iterable [asyncio.Task]) -> None:
"""asyncio signal handler that cancels all `tasks` and reports to stderr."""
err("Aborted!")
for task in tasks:
"""asyncio signal handler that cancels all `tasks` and reports to stderr."""
err("Aborted!")
for task in tasks:
projects / etc / vim.git / blobdiff