Add a new `leaf` to the end of the line. Unless `preformatted` is True, the `leaf` will receive a new consistent whitespace prefix an

read_data('test_name') -> 'input', 'output

Convenience function to check that Black formats as expected. You can pass @minimum_version if you're passing code with newer syntax to guard

Format code in given cell of Jupyter notebook. General idea is: - if cell has trailing semicolon, remove it; - if cell has IPython m

Does this pattern exactly match a node? Returns True if it matches, False if not. If results is not None, it must be a dict

Pop a nonterminal. (Internal)

Replace this node with a new one in the parent.

Returns: True iff @idx is positive AND seq[@idx] does NOT raise an IndexError.

Main method to visit `node` and its children. It tries to find a `visit_*()` method for the given `node.type`, like `visit_simple_stm

Get case path from name

Examples: ``` my_list = [1, 2, 3] is_valid_index = is_valid_index_factory(my_list) assert is_valid_index(0)

Generate a line. If the line is empty, only emit if it makes sense. If the line is too long, split it first and then generate.

Default `visit_*()` implementation. Recurses to children of `node`.

Generate comments that should appear directly after `leaf`.

Pre-conditions: * @leaves[@string_idx].type == token.STRING Returns: The index directly after the last leaf

(T)ransform Err Convenience function used when working with the TResult type.

Equivalent to 'node.children.insert(i, child)'. This method also sets the child's parent attribute appropriately.

Remove the node from the tree. Returns the position of the node in its parent's children before it was removed.

Return a unified diff string between strings `a` and `b`.

Reformat contents of a file and return new contents. If `fast` is False, additionally confirm that the reformatted code is valid by calling :

Increment the counter for successful reformatting. Write out a message.

Returns: @node.parent.type, if @node is not None and has a parent. OR None, otherwise.

Load the grammar tables from the text files written by pgen.

Wrap `child` in parentheses. This replaces `child` with an atom holding the parentheses and the old child. That requires moving the prefix.

Append leaves (taken from @old_line) to @new_line, making sure to fix the underlying Node structure where appropriate. All of the leaves

Helper method to test the value and exit code of a click Result.

Increment the counter for failed reformatting. Write out a message.

Pre-conditions: * assert_is_leaf_string(@string) Returns: @string's prefix (e.g. '', 'r', 'f', or 'rf').

Load the grammar tables from a pickle file.

Load the grammar tables from a pickle bytes object.

For non-multiline strings, return True if `line` is no longer than `line_length`. For multiline strings, looks at the context around `line` to det

Return True if `leaf` is a multiline string that actually spans many lines.

Yields spans corresponding to expressions in a given f-string. Spans are half-open ranges (left inclusive, right exclusive). Assumes the

Return a list of :class:`ProtoComment` objects parsed from the given `prefix`.

Return the highest priority of a delimiter found on the line. Values are consistent with what `is_split_*_delimiter()` return. Raises

If it's safe, make the parens in the atom `node` invisible, recursively. Additionally, remove repeated, adjacent invisible parens from the atom `n

Side Effects: * If @old_child.parent is set, replace @old_child with @new_child in @old_child's underlying Node structure.

Checks the pre-condition that @string has the format that you would expect of `leaf.value` where `leaf` is some Leaf such that `leaf.type ==

Context manager to temporarily chdir to a different directory.

If so, needs to be split before emitting.

Copy the grammar.

Returns: True iff @string starts with three quotation characters.

Normalize `path`. May return `None` if `path` was ignored. `report` is where "path ignored" output goes.

Prefer double quotes but only if it doesn't cause more escaping. Adds or removes backslashes as appropriate. Doesn't parse and fix strings ne

Return the first leaf that precedes `node`, if any.

Returns: A unique identifier that is used internally to map @string to a group of custom splits.

Check if attribute is IPython magic. Note that the source of the abstract syntax tree will already have been processed by IPython's Trans

Return True if there is an yet unmatched open bracket on the line.

Inject the ANSI color codes to the diff.

Return a tuple of (decoded_contents, encoding, newline). `newline` is either CRLF or LF but `decoded_contents` is decoded with universal newl

Dump the grammar tables to a pickle file.

Make sure parentheses are visible. They could be invisible as part of some statements (see :func:`normalize_invisible_parens` and :func:`visi

Return an enumeration of leaves with their length. Stops prematurely on multiline strings and standalone comments.

Formats a float string like "1.0".

Generator yielding matches for a sequence of patterns and nodes. Args: patterns: a sequence of patterns nodes: a sequence of

Return the information used to check if a file is already formatted or not.

Return True if the given leaf is a special comment. Only returns true for type comments for now.

Return True if `leaf` is a star or double star in a vararg or kwarg. If `within` includes VARARGS_PARENTS, this applies to function signatures.

Returns the string representation of @line. WARNING: This is known to be computationally expensive.

Leave existing extra newlines if not `inside_brackets`. Remove everything else. Note: don't use backslashes for formatting or you'll lose you

Return a pre-order iterator for the tree. This must be implemented by the concrete subclass.

Push a nonterminal. (Internal)

Return the width of `line_str` as it would be displayed in a terminal or editor (which respects Unicode East Asian Width). You could utilize

Returns `wrapped` if `node` is of the shape ( wrapped ). Parenthesis can be optional. Returns None otherwise

Split the line into head, body, tail starting with the last bracket pair. Note: this function should not have side effects. It's relied upon by