if leaf.type in CLOSING_BRACKETS:
self.depth -= 1
opening_bracket = self.bracket_match.pop((self.depth, leaf.type))
- leaf.opening_bracket = opening_bracket # type: ignore
- leaf.bracket_depth = self.depth # type: ignore
+ leaf.opening_bracket = opening_bracket
+ leaf.bracket_depth = self.depth
if self.depth == 0:
delim = is_delimiter(leaf)
if delim:
# For parens let's check if it's safe to remove the comma. If the
# trailing one is the only one, we might mistakenly change a tuple
# into a different type by removing the comma.
- depth = closing.bracket_depth + 1 # type: ignore
+ depth = closing.bracket_depth + 1
commas = 0
- opening = closing.opening_bracket # type: ignore
+ opening = closing.opening_bracket
for _opening_index, leaf in enumerate(self.leaves):
if leaf is opening:
break
if leaf is closing:
break
- bracket_depth = leaf.bracket_depth # type: ignore
+ bracket_depth = leaf.bracket_depth
if bracket_depth == depth and leaf.type == token.COMMA:
commas += 1
if commas > 1:
OPENING_BRACKETS = set(BRACKET.keys())
CLOSING_BRACKETS = set(BRACKET.values())
BRACKETS = OPENING_BRACKETS | CLOSING_BRACKETS
+ALWAYS_NO_SPACE = CLOSING_BRACKETS | {token.COMMA, token.COLON, STANDALONE_COMMENT}
def whitespace(leaf: Leaf) -> str:
t = leaf.type
p = leaf.parent
v = leaf.value
- if t == token.COLON:
- return NO
-
- if t == token.COMMA:
- return NO
-
- if t == token.RPAR:
+ if t in ALWAYS_NO_SPACE:
return NO
if t == token.COMMENT:
return DOUBLESPACE
- if t == STANDALONE_COMMENT:
- return NO
-
- if t in CLOSING_BRACKETS:
- return NO
-
assert p is not None, f"INTERNAL ERROR: hand-made leaf without parent: {leaf!r}"
prev = leaf.prev_sibling
if not prev:
if prevp.parent and prevp.parent.type == syms.subscript:
return NO
- elif prevp.parent and prevp.parent.type == syms.factor:
+ elif prevp.parent and prevp.parent.type in {syms.factor, syms.star_expr}:
return NO
elif prev.type in OPENING_BRACKETS:
elif p.type == syms.subscript:
# indexing
- if not prev or prev.type == token.COLON:
+ if not prev:
+ assert p.parent is not None, "subscripts are always parented"
+ if p.parent.type == syms.subscriptlist:
+ return SPACE
+
+ return NO
+
+ elif prev.type == token.COLON:
return NO
elif p.type == syms.atom:
if prev.type == token.DOUBLESTAR:
return NO
- elif p.type == syms.factor or p.type == syms.star_expr:
+ elif p.type in {syms.factor, syms.star_expr}:
# unary ops
if not prev:
prevp = preceding_leaf(p)
if (
current_leaves is body_leaves and
leaf.type in CLOSING_BRACKETS and
- leaf.opening_bracket is matching_bracket # type: ignore
+ leaf.opening_bracket is matching_bracket
):
current_leaves = tail_leaves
current_leaves.append(leaf)
current_leaves.append(leaf)
if current_leaves is tail_leaves:
if leaf.type in CLOSING_BRACKETS:
- opening_bracket = leaf.opening_bracket # type: ignore
+ opening_bracket = leaf.opening_bracket
current_leaves = body_leaves
tail_leaves.reverse()
body_leaves.reverse()
current_line.append(comment_after, preformatted=True)
lowest_depth = min(lowest_depth, leaf.bracket_depth)
if (
- leaf.bracket_depth == lowest_depth and # type: ignore
+ leaf.bracket_depth == lowest_depth and
leaf.type == token.STAR or
leaf.type == token.DOUBLESTAR
):
"""
for n in node.pre_order():
if n.type == token.STRING:
- assert isinstance(n, Leaf)
- if n.value[:2] in {'f"', 'F"', "f'", "F'", 'rf', 'fr', 'RF', 'FR'}:
+ value_head = n.value[:2] # type: ignore
+ if value_head in {'f"', 'F"', "f'", "F'", 'rf', 'fr', 'RF', 'FR'}:
return True
elif (