A formatter for Python files
YAPF
Introduction
YAPF is a Python formatter based on clang-format (developed by Daniel Jasper). In essence, the algorithm takes the code and calculates the best formatting that conforms to the configured style. It takes away a lot of the drudgery of maintaining your code.
The ultimate goal is that the code YAPF produces is as good as the code that a programmer would write if they were following the style guide.
Note
YAPF is not an official Google product (experimental or otherwise), it is
just code that happens to be owned by Google.
Installation
To install YAPF from PyPI:
$ pip install yapfYAPF is still considered in "beta" stage, and the released version may change often; therefore, the best way to keep up-to-date with the latest development is to clone this repository or install directly from github:
$ pip install git+https://github.com/google/yapf.gitNote that if you intend to use YAPF as a command-line tool rather than as a library, installation is not necessary. YAPF supports being run as a directory by the Python interpreter. If you cloned/unzipped YAPF into DIR, it's possible to run:
$ PYTHONPATH=DIR python DIR/yapf [options] ...Using YAPF within your favorite editor
YAPF is supported by multiple editors via community extensions or plugins. See Editor Support for more info.Required Python versions
YAPF supports Python 3.7+.
Usage
usage: yapf [-h] [-v] [-d | -i | -q] [-r | -l START-END] [-e PATTERN]
[--style STYLE] [--style-help] [--no-local-style] [-p] [-m] [-vv]
[files ...]
Formatter for Python code.
positional arguments: files reads from stdin when no files are specified.
optional arguments: -h, --help show this help message and exit -v, --version show program's version number and exit -d, --diff print the diff for the fixed source -i, --in-place make changes to files in place -q, --quiet output nothing and set return value -r, --recursive run recursively over directories -l START-END, --lines START-END range of lines to reformat, one-based -e PATTERN, --exclude PATTERN patterns for files to exclude from formatting --style STYLE specify formatting style: either a style name (for example "pep8" or "google"), or the name of a file with style settings. The default is pep8 unless a .style.yapf or setup.cfg or pyproject.toml file located in the same directory as the source or one of its parent directories (for stdin, the current directory is used). --style-help show style settings and exit; this output can be saved to .style.yapf to make your settings permanent --no-local-style don't search for local style definition -p, --parallel run YAPF in parallel when formatting multiple files. -m, --print-modified print out file names of modified files -vv, --verbose print out file names while processing
Return Codes
Normally YAPF returns zero on successful program termination and non-zero otherwise.
If --diff is supplied, YAPF returns zero when no changes were necessary, non-zero otherwise (including program error). You can use this in a CI workflow to test that code has been YAPF-formatted.
Excluding files from formatting (.yapfignore or pyproject.toml)
In addition to exclude patterns provided on commandline, YAPF looks for additional patterns specified in a file named .yapfignore or pyproject.toml located in the working directory from which YAPF is invoked.
.yapfignore's syntax is similar to UNIX's filename pattern matching:
* matches everything
? matches any single character
[seq] matches any character in seq
[!seq] matches any character not in seqNote that no entry should begin with ./.
If you use pyproject.toml, exclude patterns are specified by ignore_patterns key in [tool.yapfignore] section. For example:
[tool.yapfignore]
ignore_patterns = [
"temp/*/.py",
"temp2/*.py"
]Formatting style ================
The formatting style used by YAPF is configurable and there are many "knobs" that can be used to tune how YAPF does formatting. See the style.py module for the full list.
To control the style, run YAPF with the --style argument. It accepts one of the predefined styles (e.g., pep8 or google), a path to a configuration file that specifies the desired style, or a dictionary of key/value pairs.
The config file is a simple listing of (case-insensitive) key = value pairs with a [style] heading. For example:
[style]
basedonstyle = pep8
spacesbeforecomment = 4
splitbeforelogical_operator = trueThe basedonstyle setting determines which of the predefined styles this custom style is based on (think of it like subclassing). Four styles are predefined:
pep8(default)google(based off of the Google Python Style Guide)yapf(for use with Google open source projects)facebook
STYLENAMETOFACTORY in style.py for details.
It's also possible to do the same on the command line with a dictionary. For example:
--style='{basedonstyle: pep8, indent_width: 2}'This will take the pep8 base style and modify it to have two space indentations.
YAPF will search for the formatting style in the following manner:
- Specified on the command line
- In the
[style]section of a.style.yapffile in either the current
- In the
[yapf]section of asetup.cfgfile in either the current
- In the
[tool.yapf]section of apyproject.tomlfile in either the current
- In the
[style]section of a~/.config/yapf/stylefile in your home
If none of those files are found, the default style PEP8 is used.
Example =======
An example of the type of formatting that YAPF can do, it will take this ugly code:
x = { 'a':37,'b':42,
'c':927}
y = 'hello ''world' z = 'hello '+'world' a = 'hello {}'.format('world') class foo ( object ): def f (self ): return 37*-+2 def g(self, x,y=42): return y def f ( a ) : return 37+-+a[42-x : y**3]
and reformat it into:
x = {'a': 37, 'b': 42, 'c': 927}
y = 'hello ' 'world' z = 'hello ' + 'world' a = 'hello {}'.format('world')
class foo(object): def f(self): return 37 * -+2
def g(self, x, y=42): return y
def f(a): return 37 + -+a[42 - x:y**3]
Example as a module
The two main APIs for calling YAPF are FormatCode and FormatFile, these share several arguments which are described below:
>>> from yapf.yapflib.yapf_api import FormatCode # reformat a string of code
>>> formatted_code, changed = FormatCode("f ( a = 1, b = 2 )") >>> formatted_code 'f(a=1, b=2)\n' >>> changed True
A style_config argument: Either a style name or a path to a file that contains formatting style settings. If None is specified, use the default style as set in style.DEFAULTSTYLEFACTORY.
>>> FormatCode("def g():\n return True", style_c)[0]
'def g():\n return True\n'A lines argument: A list of tuples of lines (ints), [start, end], that we want to format. The lines are 1-based indexed. It can be used by third-party code (e.g., IDEs) when reformatting a snippet of code rather than a whole file.
>>> FormatCode("def g( ):\n a=1\n b = 2\n return a==b", lines=[(1, 1), (2, 3)])[0]
'def g():\n a = 1\n b = 2\n return a==b\n'A print_diff (bool): Instead of returning the reformatted source, return a diff that turns the formatted source into reformatted source.
>>> print(FormatCode("a==b", filename="foo.py", print_diff=True)[0])
--- foo.py (original)
+++ foo.py (reformatted)
@@ -1 +1 @@
-a==b
+a == bNote: the filename argument for FormatCode is what is inserted into the diff, the default is <unknown>.
FormatFile returns reformatted code from the passed file along with its encoding:
>>> from yapf.yapflib.yapf_api import FormatFile # reformat a file
>>> print(open("foo.py").read()) # contents of file a==b
>>> reformatted_code, encoding, changed = FormatFile("foo.py") >>> formatted_code 'a == b\n' >>> encoding 'utf-8' >>> changed True
The in_place argument saves the reformatted code back to the file:
>>> FormatFile("foo.py", in_place=True)[:2]
(None, 'utf-8')
>>> print(open("foo.py").read()) # contents of file (now fixed) a == b
Formatting diffs
Options:
usage: yapf-diff [-h] [-i] [-p NUM] [--regex PATTERN] [--iregex PATTERN][-v]
[--style STYLE] [--binary BINARY]
This script reads input from a unified diff and reformats all the changed lines. This is useful to reformat all the lines touched by a specific patch. Example usage for git/svn users:
git diff -U0 --no-color --relative HEAD^ | yapf-diff -i svn diff --diff-cmd=diff -x-U0 | yapf-diff -p0 -i
It should be noted that the filename contained in the diff is used unmodified to determine the source file to update. Users calling this script directly should be careful to ensure that the path in the diff is correct relative to the current working directory.
optional arguments: -h, --help show this help message and exit -i, --in-place apply edits to files instead of displaying a diff -p NUM, --prefix NUM strip the smallest prefix containing P slashes --regex PATTERN custom pattern selecting file paths to reformat (case sensitive, overrides -iregex) --iregex PATTERN custom pattern selecting file paths to reformat (case insensitive, overridden by -regex) -v, --verbose be more verbose, ineffective without -i --style STYLE specify formatting style: either a style name (for example "pep8" or "google"), or the name of a file with style settings. The default is pep8 unless a .style.yapf or setup.cfg or pyproject.toml file located in the same directory as the source or one of its parent directories (for stdin, the current directory is used). --binary BINARY location of binary to use for YAPF
Python features not yet supported
- Python 3.12 – PEP 695 – Type Parameter Syntax – YAPF #1170
- Python 3.12 – PEP 701 – Syntactic formalization of f-strings – YAPF #1136
Knobs
ALIGNCLOSINGBRACKETWITHVISUAL_INDENT
Align closing bracket with visual indentation.
ALLOWMULTILINELAMBDAS
Allow lambdas to be formatted on more than one line.
ALLOWMULTILINEDICTIONARY_KEYS
Allow dictionary keys to exist on multiple lines. For example:
x = {
('this is the first element of a tuple',
'this is the second element of a tuple'):
value,
}ALLOWSPLITBEFOREDEFAULTORNAMEDASSIGNS
Allow splitting before a default / named assignment in an argument list.
ALLOWSPLITBEFOREDICTVALUE
Allow splits before the dictionary value.
ARITHMETICPRECEDENCEINDICATION
Let spacing indicate operator precedence. For example:
a = 1 * 2 + 3 / 4
b = 1 / 2 - 3 * 4
c = (1 + 2) * (3 - 4)
d = (1 - 2) / (3 + 4)
e = 1 * 2 - 3
f = 1 + 2 + 3 + 4will be formatted as follows to indicate precedence:
a = 1*2 + 3/4
b = 1/2 - 3*4
c = (1+2) * (3-4)
d = (1-2) / (3+4)
e = 1*2 - 3
f = 1 + 2 + 3 + 4BLANKLINESAROUNDTOPLEVEL_DEFINITION
Sets the number of desired blank lines surrounding top-level function and
class definitions. For example:
class Foo:
pass
# <------ having two blank lines here
# <------ is the default setting
class Bar:
passBLANKLINEBEFORECLASSDOCSTRING
Insert a blank line before a class-level docstring.
BLANKLINEBEFOREMODULEDOCSTRING
Insert a blank line before a module docstring.
BLANKLINEBEFORENESTEDCLASSORDEF
Insert a blank line before adeforclassimmediately nested within
anotherdeforclass. For example:
class Foo:
# <------ this blank line
def method():
passBLANKLINESBETWEENTOPLEVELIMPORTSAND_VARIABLES
Sets the number of desired blank lines between top-level imports and
variable definitions. Useful for compatibility with tools like isort.
COALESCE_BRACKETS
Do not split consecutive brackets. Only relevant when
DEDENTCLOSINGBRACKETSorINDENTCLOSINGBRACKETSis set. For example:
callfuncthattakesa_dict(
{
'key1': 'value1',
'key2': 'value2',
}
)would reformat to:
callfuncthattakesa_dict({
'key1': 'value1',
'key2': 'value2',
})COLUMN_LIMIT
The column limit (or max line-length)
CONTINUATIONALIGNSTYLE
The style for continuation alignment. Possible values are:
- SPACE: Use spaces for continuation alignment. This is default
behavior.
-FIXED: Use fixed number (CONTINUATIONINDENTWIDTH) of columns
(i.e.CONTINUATIONINDENTWIDTH/INDENT_WIDTHtabs or
CONTINUATIONINDENTWIDTH spaces) for continuation alignment.
- VALIGN-RIGHT: Vertically align continuation lines to multiple of
INDENT_WIDTH columns. Slightly right (one tab or a few spaces) if cannot
vertically align continuation lines with indent characters.
CONTINUATIONINDENTWIDTH
Indent width used for line continuations.
DEDENTCLOSINGBRACKETS
Put closing brackets on a separate line, dedented, if the bracketed
expression can't fit in a single line. Applies to all kinds of brackets,
including function definitions and calls. For example:
config = {
'key1': 'value1',
'key2': 'value2',
} # <--- this bracket is dedented and on a separate line
timeseries = self.remoteclient.queryentitycounters( entity='dev3246.region1', key='dns.querylatencytcp', transform=Transformation.AVERAGE(window=timedelta(seconds=60)), start_ts=now()-timedelta(days=3), end_ts=now(), ) # <--- this bracket is dedented and on a separate line
DISABLEENDINGCOMMA_HEURISTIC
Disable the heuristic which places each list element on a separate line if
the list is comma-terminated.>
Note: The behavior of this flag changed in v0.40.3. Before, if this flag
was true, we would split lists that contained a trailing comma or a
comment. Now, we have a separate flag, DISABLESPLITLISTWITHCOMMENT,
that controls splitting when a list contains a comment. To get the old
behavior, set both flags to true. More information in
CHANGELOG.md.
DISABLESPLITLISTWITHCOMMENT
Don't put every element on a new line within a list that contains
interstitial comments.>
Without this flag (default):>
> a, > b, # > c > ] > >> [
With this flag:>
> a, b, # > c > ] > >> [
This mirrors the behavior of clang-format and is useful for forming
"logical groups" of elements in a list. It also works in function
declarations.
EACHDICTENTRYONSEPARATE_LINE
Place each dictionary entry onto its own line.
FORCEMULTILINEDICT
Respect EACHDICTENTRYONSEPARATE_LINE even if the line is shorter than
COLUMN_LIMIT.
I18N_COMMENT
The regex for an internationalization comment. The presence of this comment
stops reformatting of that line, because the comments are required to be
next to the string they translate.
I18NFUNCTIONCALL
The internationalization function call names. The presence of this function
stops reformatting on that line, because the string it has cannot be moved
away from the i18n comment.
INDENTBLANKLINES
Set to True to prefer indented blank lines rather than empty
INDENTCLOSINGBRACKETS
Put closing brackets on a separate line, indented, if the bracketed
expression can't fit in a single line. Applies to all kinds of brackets,
including function definitions and calls. For example:
config = {
'key1': 'value1',
'key2': 'value2',
} # <--- this bracket is indented and on a separate line
timeseries = self.remoteclient.queryentitycounters( entity='dev3246.region1', key='dns.querylatencytcp', transform=Transformation.AVERAGE(window=timedelta(seconds=60)), start_ts=now()-timedelta(days=3), end_ts=now(), ) # <--- this bracket is indented and on a separate line
INDENTDICTIONARYVALUE
Indent the dictionary value if it cannot fit on the same line as the
dictionary key. For example:
config = {
'key1':
'value1',
'key2': value1 +
value2,
}INDENT_WIDTH
The number of columns to use for indentation.
JOINMULTIPLELINES
Join short lines into one line. E.g., single line if statements.
NOSPACESAROUNDSELECTEDBINARY_OPERATORS
Do not include spaces around selected binary operators. For example:
1 + 2 * 3 - 4 / 5will be formatted as follows when configured with*,/:
1 + 2*3 - 4/5SPACEBETWEENENDINGCOMMAANDCLOSINGBRACKET
Insert a space between the ending comma and closing bracket of a list, etc.
SPACEINSIDEBRACKETS
Use spaces inside brackets, braces, and parentheses. For example:
method_call( 1 )
mydict[ 3 ][ 1 ][ getindex( args, *kwargs ) ]
my_set = { 1, 2, 3 }SPACESAROUNDDEFAULTORNAMED_ASSIGN
Set to True to prefer spaces around the assignment operator for default
or keyword arguments.
SPACESAROUNDDICT_DELIMITERS
Adds a space after the opening '{' and before the ending '}' dict delimiters.
{1: 2}will be formatted as:
{ 1: 2 }SPACESAROUNDLIST_DELIMITERS
Adds a space after the opening '[' and before the ending ']' list delimiters.
[1, 2]will be formatted as:
[ 1, 2 ]SPACESAROUNDPOWER_OPERATOR
Set toTrueto prefer using spaces around**.
SPACESAROUNDSUBSCRIPT_COLON
Use spaces around the subscript / slice operator. For example:
my_list[1 : 10 : 2]SPACESAROUNDTUPLE_DELIMITERS
Adds a space after the opening '(' and before the ending ')' tuple delimiters.
(1, 2, 3)will be formatted as:
( 1, 2, 3 )SPACESBEFORECOMMENT
The number of spaces required before a trailing comment.
This can be a single value (representing the number of spaces
before each trailing comment) or list of values (representing
alignment column values; trailing comments within a block will
be aligned to the first column value that is greater than the maximum
line length within the block).
Note: Lists of values may need to be quoted in some contexts
(eg. shells or editor config files).
For example, with spacesbeforecomment=5:
1 + 1 # Adding valueswill be formatted as:
1 + 1 # Adding values <-- 5 spaces between the end of the statement and comment with spacesbeforecomment="15, 20":
1 + 1 # Adding values
two + two # More adding
longer_statement # This is a longer statement short # This is a shorter statement
averylongstatementthatextendsbeyondthefinal_column # Comment short # This is a shorter statement
will be formatted as:
1 + 1 # Adding values <-- end of line comments in block aligned to col 15
two + two # More adding
longer_statement # This is a longer statement <-- end of line comments in block aligned to col 20 short # This is a shorter statement
averylongstatementthatextendsbeyondthefinal_column # Comment <-- the end of line comments are aligned based on the line length short # This is a shorter statement
SPLITALLCOMMASEPARATEDVALUES
If a comma separated list (dict,list,tuple, or functiondef) is
on a line that is too long, split such that each element is on a separate
line.
SPLITALLTOPLEVELCOMMASEPARATEDVALUES
Variation on SPLITALLCOMMASEPARATEDVALUES in which, if a
subexpression with a comma fits in its starting line, then the
subexpression is not split. This avoids splits like the one for
b in this code:
abcdef(
aReallyLongThing: int,
b: [Int,
Int])with the new knob this is split as:
abcdef(
aReallyLongThing: int,
b: [Int, Int])SPLITARGUMENTSWHENCOMMATERMINATED
Split before arguments if the argument list is terminated by a comma.
SPLITBEFOREARITHMETIC_OPERATOR
Set toTrueto prefer splitting before+,-,*,/,//, or@
rather than after.
SPLITBEFOREBITWISE_OPERATOR
Set toTrueto prefer splitting before&,|or^rather than after.
SPLITBEFORECLOSING_BRACKET
Split before the closing bracket if alistordictliteral doesn't fit
on a single line.
SPLITBEFOREDICTSETGENERATOR
Split before a dictionary or set generator (comp_for). For example, note
the split before the for:
foo = {
variable: 'Hello world, have a nice day!'
for variable in bar if variable != 42
}SPLITBEFOREDOT
Split before the . if we need to split a longer expression:
foo = ('This is a really long string: {}, {}, {}, {}'.format(a, b, c, d))would reformat to something like:
foo = ('This is a really long string: {}, {}, {}, {}'
.format(a, b, c, d))SPLITBEFOREEXPRESSIONAFTEROPENING_PAREN
Split after the opening paren which surrounds an expression if it doesn't
fit on a single line.
SPLITBEFOREFIRST_ARGUMENT
If an argument / parameter list is going to be split, then split before the
first argument.
SPLITBEFORELOGICAL_OPERATOR
Set toTrueto prefer splitting beforeandororrather than after.
SPLITBEFORENAMED_ASSIGNS
Split named assignments onto individual lines.
SPLITCOMPLEXCOMPREHENSION
For list comprehensions and generator expressions with multiple clauses
(e.g multipleforcalls,iffilter expressions) and which need to be
reflowed, split each clause onto its own line. For example:
result = [
avar + bvar for avar in xrange(1000) for bvar in xrange(1000)
if avar % bvar]would reformat to something like:
result = [
avar + bvar
for a_var in xrange(1000)
for b_var in xrange(1000)
if avar % bvar]SPLITPENALTYAFTEROPENINGBRACKET
The penalty for splitting right after the opening bracket.
SPLITPENALTYAFTERUNARYOPERATOR
The penalty for splitting the line after a unary operator.
SPLITPENALTYARITHMETIC_OPERATOR
The penalty of splitting the line around the+,-,*,/,//,%,
and @ operators.
SPLITPENALTYBEFOREIFEXPR
The penalty for splitting right before an if expression.
SPLITPENALTYBITWISE_OPERATOR
The penalty of splitting the line around the&,|, and^operators.
SPLITPENALTYCOMPREHENSION
The penalty for splitting a list comprehension or generator expression.
SPLITPENALTYEXCESS_CHARACTER
The penalty for characters over the column limit.
SPLITPENALTYFORADDEDLINE_SPLIT
The penalty incurred by adding a line split to the logical line. The more
line splits added the higher the penalty.
SPLITPENALTYIMPORT_NAMES
The penalty of splitting a list of import as names. For example:
from averylongorindentedmodulenameyadayad import (longargument1,
longargument2,
longargument3)would reformat to something like:
from averylongorindentedmodulenameyadayad import (
longargument1, longargument2, longargument3)SPLITPENALTYLOGICAL_OPERATOR
The penalty of splitting the line around theandandoroperators.
USE_TABS
Use the Tab character for indentation.
(Potentially) Frequently Asked Questions
Why does YAPF destroy my awesome formatting?
YAPF tries very hard to get the formatting correct. But for some code, it won't be as good as hand-formatting. In particular, large data literals may become horribly disfigured under YAPF.
The reasons for this are manyfold. In short, YAPF is simply a tool to help with development. It will format things to coincide with the style guide, but that may not equate with readability.
What can be done to alleviate this situation is to indicate regions YAPF should ignore when reformatting something:
# yapf: disable
FOO = {
# ... some very large, complex data literal.
}
BAR = [ # ... another large data literal. ]
yapf: enable
You can also disable formatting for a single literal like this:
BAZ = {
(1, 2, 3, 4),
(5, 6, 7, 8),
(9, 10, 11, 12),
} # yapf: disableTo preserve the nice dedented closing brackets, use the dedentclosingbrackets in your style. Note that in this case all brackets, including function definitions and calls, are going to use that style. This provides consistency across the formatted codebase.
Why Not Improve Existing Tools?
We wanted to use clang-format's reformatting algorithm. It's very powerful and designed to come up with the best formatting possible. Existing tools were created with different goals in mind, and would require extensive modifications to convert to using clang-format's algorithm.
Can I Use YAPF In My Program?
Please do! YAPF was designed to be used as a library as well as a command line tool. This means that a tool or IDE plugin is free to use YAPF.
I still get non-PEP8 compliant code! Why?
YAPF tries very hard to be fully PEP 8 compliant. However, it is paramount to not risk altering the semantics of your code. Thus, YAPF tries to be as safe as possible and does not change the token stream (e.g., by adding parentheses). All these cases however, can be easily fixed manually. For instance,
from mypackage import myfunction1, myfunction2, myfunction3, myfunction4, myfunction_5
FOO = myvariable1 + myvariable2 + myvariable3 + myvariable4 + myvariable5 + myvariable6 + myvariable7 + myvariable8
won't be split, but you can easily get it right by just adding parentheses:
from mypackage import (myfunction1, myfunction2, myfunction_3,
myfunction4, myfunction5)
FOO = (myvariable1 + myvariable2 + myvariable3 + myvariable4 + myvariable5 + myvariable6 + myvariable7 + myvariable8)
Gory Details
Algorithm Design
The main data structure in YAPF is the LogicalLine object. It holds a list of FormatToken\s, that we would want to place on a single line if there were no column limit. An exception being a comment in the middle of an expression statement will force the line to be formatted on more than one line. The formatter works on one LogicalLine object at a time.
An LogicalLine typically won't affect the formatting of lines before or after it. There is a part of the algorithm that may join two or more LogicalLine\s into one line. For instance, an if-then statement with a short body can be placed on a single line:
if a == 42: continueYAPF's formatting algorithm creates a weighted tree that acts as the solution space for the algorithm. Each node in the tree represents the result of a formatting decision --- i.e., whether to split or not to split before a token. Each formatting decision has a cost associated with it. Therefore, the cost is realized on the edge between two nodes. (In reality, the weighted tree doesn't have separate edge objects, so the cost resides on the nodes themselves.)
For example, take the following Python code snippet. For the sake of this example, assume that line (1) violates the column limit restriction and needs to be reformatted.
def xxxxxxxxxxx(aaaaaaaaaaaa, bbbbbbbbb, cccccccc, dddddddd, eeeeee): # 1
pass # 2For line (1), the algorithm will build a tree where each node (a FormattingDecisionState object) is the state of the line at that token given the decision to split before the token or not. Note: the FormatDecisionState objects are copied by value so each node in the graph is unique and a change in one doesn't affect other nodes.
Heuristics are used to determine the costs of splitting or not splitting. Because a node holds the state of the tree up to a token's insertion, it can easily determine if a splitting decision will violate one of the style requirements. For instance, the heuristic is able to apply an extra penalty to the edge when not splitting between the previous token and the one being added.
There are some instances where we will never want to split the line, because doing so will always be detrimental (i.e., it will require a backslash-newline, which is very rarely desirable). For line (1), we will never want to split the first three tokens: def, xxxxxxxxxxx, and (. Nor will we want to split between the ) and the : at the end. These regions are said to be "unbreakable." This is reflected in the tree by there not being a "split" decision (left hand branch) within the unbreakable region.
Now that we have the tree, we determine what the "best" formatting is by finding the path through the tree with the lowest cost.
And that's it!
