Loading src/black/__init__.py +45 −89 Changes for src/black/__init__.py: 45 added lines, 89 removed lines. Original line number Diff line number Diff line Loading @@ -1494,69 +1494,6 @@ def is_stub_class(self) -> bool: Leaf(token.DOT, ".") for _ in range(3) ] @property def is_collection_with_optional_trailing_comma(self) -> bool: """Is this line a collection literal with a trailing comma that's optional? Note that the trailing comma in a 1-tuple is not optional. """ if not self.leaves or len(self.leaves) < 4: return False # Look for and address a trailing colon. if self.leaves[-1].type == token.COLON: closer = self.leaves[-2] close_index = -2 else: closer = self.leaves[-1] close_index = -1 if closer.type not in CLOSING_BRACKETS or self.inside_brackets: return False if closer.type == token.RPAR: # Tuples require an extra check, because if there's only # one element in the tuple removing the comma unmakes the # tuple. # # We also check for parens before looking for the trailing # comma because in some cases (eg assigning a dict # literal) the literal gets wrapped in temporary parens # during parsing. This case is covered by the # collections.py test data. opener = closer.opening_bracket for _open_index, leaf in enumerate(self.leaves): if leaf is opener: break else: # Couldn't find the matching opening paren, play it safe. return False commas = 0 comma_depth = self.leaves[close_index - 1].bracket_depth for leaf in self.leaves[_open_index + 1 : close_index]: if leaf.bracket_depth == comma_depth and leaf.type == token.COMMA: commas += 1 if commas > 1: # We haven't looked yet for the trailing comma because # we might also have caught noop parens. return self.leaves[close_index - 1].type == token.COMMA elif commas == 1: return False # it's either a one-tuple or didn't have a trailing comma if self.leaves[close_index - 1].type in CLOSING_BRACKETS: close_index -= 1 closer = self.leaves[close_index] if closer.type == token.RPAR: # TODO: this is a gut feeling. Will we ever see this? return False if self.leaves[close_index - 1].type != token.COMMA: return False return True @property def is_def(self) -> bool: """Is this a function definition? (Also returns True for async defs.)""" Loading Loading @@ -1683,41 +1620,61 @@ def contains_multiline_strings(self) -> bool: def maybe_remove_trailing_comma(self, closing: Leaf) -> bool: """Remove trailing comma if there is one and it's safe.""" if not (self.leaves and self.leaves[-1].type == token.COMMA): return False # We remove trailing commas only in the case of importing a # single name from a module. if not ( self.leaves and self.is_import and len(self.leaves) > 4 and self.leaves[-1].type == token.COMMA and closing.type in CLOSING_BRACKETS and self.leaves[-4].type == token.NAME and ( # regular `from foo import bar,` self.leaves[-4].value == "import" # `from foo import (bar as baz,) or ( len(self.leaves) > 6 and self.leaves[-6].value == "import" and self.leaves[-3].value == "as" ) # `from foo import bar as baz,` or ( len(self.leaves) > 5 and self.leaves[-5].value == "import" and self.leaves[-3].value == "as" ) ) and closing.type == token.RPAR ): return False if closing.type == token.RBRACE: self.remove_trailing_comma() return True if closing.type == token.RSQB: comma = self.leaves[-1] if comma.parent and comma.parent.type == syms.listmaker: self.remove_trailing_comma() return True # For parens let's check if it's safe to remove the comma. # Imports are always safe. if self.is_import: self.remove_trailing_comma() return True # Otherwise, 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 commas = 0 opening = closing.opening_bracket for _opening_index, leaf in enumerate(self.leaves): if leaf is opening: break else: return False for leaf in self.leaves[_opening_index + 1 :]: if leaf is closing: break bracket_depth = leaf.bracket_depth if bracket_depth == depth and leaf.type == token.COMMA: commas += 1 if leaf.parent and leaf.parent.type in { syms.arglist, syms.typedargslist, }: commas += 1 break if commas > 1: self.remove_trailing_comma() return True return False def append_comment(self, comment: Leaf) -> bool: """Add an inline or standalone comment to the line.""" if ( Loading Loading @@ -2686,7 +2643,6 @@ def init_st(ST: Type[StringTransformer]) -> StringTransformer: if ( not line.contains_uncollapsable_type_comments() and not line.should_explode and not line.is_collection_with_optional_trailing_comma and ( is_line_short_enough(line, line_length=mode.line_length, line_str=line_str) or line.contains_unsplittable_type_ignore() Loading Loading
src/black/__init__.py +45 −89 Changes for src/black/__init__.py: 45 added lines, 89 removed lines. Original line number Diff line number Diff line Loading @@ -1494,69 +1494,6 @@ def is_stub_class(self) -> bool: Leaf(token.DOT, ".") for _ in range(3) ] @property def is_collection_with_optional_trailing_comma(self) -> bool: """Is this line a collection literal with a trailing comma that's optional? Note that the trailing comma in a 1-tuple is not optional. """ if not self.leaves or len(self.leaves) < 4: return False # Look for and address a trailing colon. if self.leaves[-1].type == token.COLON: closer = self.leaves[-2] close_index = -2 else: closer = self.leaves[-1] close_index = -1 if closer.type not in CLOSING_BRACKETS or self.inside_brackets: return False if closer.type == token.RPAR: # Tuples require an extra check, because if there's only # one element in the tuple removing the comma unmakes the # tuple. # # We also check for parens before looking for the trailing # comma because in some cases (eg assigning a dict # literal) the literal gets wrapped in temporary parens # during parsing. This case is covered by the # collections.py test data. opener = closer.opening_bracket for _open_index, leaf in enumerate(self.leaves): if leaf is opener: break else: # Couldn't find the matching opening paren, play it safe. return False commas = 0 comma_depth = self.leaves[close_index - 1].bracket_depth for leaf in self.leaves[_open_index + 1 : close_index]: if leaf.bracket_depth == comma_depth and leaf.type == token.COMMA: commas += 1 if commas > 1: # We haven't looked yet for the trailing comma because # we might also have caught noop parens. return self.leaves[close_index - 1].type == token.COMMA elif commas == 1: return False # it's either a one-tuple or didn't have a trailing comma if self.leaves[close_index - 1].type in CLOSING_BRACKETS: close_index -= 1 closer = self.leaves[close_index] if closer.type == token.RPAR: # TODO: this is a gut feeling. Will we ever see this? return False if self.leaves[close_index - 1].type != token.COMMA: return False return True @property def is_def(self) -> bool: """Is this a function definition? (Also returns True for async defs.)""" Loading Loading @@ -1683,41 +1620,61 @@ def contains_multiline_strings(self) -> bool: def maybe_remove_trailing_comma(self, closing: Leaf) -> bool: """Remove trailing comma if there is one and it's safe.""" if not (self.leaves and self.leaves[-1].type == token.COMMA): return False # We remove trailing commas only in the case of importing a # single name from a module. if not ( self.leaves and self.is_import and len(self.leaves) > 4 and self.leaves[-1].type == token.COMMA and closing.type in CLOSING_BRACKETS and self.leaves[-4].type == token.NAME and ( # regular `from foo import bar,` self.leaves[-4].value == "import" # `from foo import (bar as baz,) or ( len(self.leaves) > 6 and self.leaves[-6].value == "import" and self.leaves[-3].value == "as" ) # `from foo import bar as baz,` or ( len(self.leaves) > 5 and self.leaves[-5].value == "import" and self.leaves[-3].value == "as" ) ) and closing.type == token.RPAR ): return False if closing.type == token.RBRACE: self.remove_trailing_comma() return True if closing.type == token.RSQB: comma = self.leaves[-1] if comma.parent and comma.parent.type == syms.listmaker: self.remove_trailing_comma() return True # For parens let's check if it's safe to remove the comma. # Imports are always safe. if self.is_import: self.remove_trailing_comma() return True # Otherwise, 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 commas = 0 opening = closing.opening_bracket for _opening_index, leaf in enumerate(self.leaves): if leaf is opening: break else: return False for leaf in self.leaves[_opening_index + 1 :]: if leaf is closing: break bracket_depth = leaf.bracket_depth if bracket_depth == depth and leaf.type == token.COMMA: commas += 1 if leaf.parent and leaf.parent.type in { syms.arglist, syms.typedargslist, }: commas += 1 break if commas > 1: self.remove_trailing_comma() return True return False def append_comment(self, comment: Leaf) -> bool: """Add an inline or standalone comment to the line.""" if ( Loading Loading @@ -2686,7 +2643,6 @@ def init_st(ST: Type[StringTransformer]) -> StringTransformer: if ( not line.contains_uncollapsable_type_comments() and not line.should_explode and not line.is_collection_with_optional_trailing_comma and ( is_line_short_enough(line, line_length=mode.line_length, line_str=line_str) or line.contains_unsplittable_type_ignore() Loading