Package: yapf
YAPFIntroductionYAPF is a Python formatter based off ofclang-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.NoteYAPF is not an official Google product (experimental or otherwise), it is
just code that happens to be owned by Google.InstallationTo install YAPF from PyPI:$pipinstallyapfYAPF 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.Note 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 intoDIR, it's
possible to run:$PYTHONPATH=DIRpythonDIR/yapf[options]...Required Python versionsYAPF supports Python 3.7+.NoteYAPF requires the code it formats to be valid Python for the version YAPF
itself runs under.Usageusage: 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-ENDrange of lines to reformat, one-based-e PATTERN, --exclude PATTERNpatterns for files to exclude from formatting--style STYLE         specify formatting style: either a style name (forexample "pep8" or "google"), or the name of a filewith style settings. The default is pep8 unless a.style.yapf or setup.cfg or pyproject.toml filelocated in the same directory as the source or one ofits parent directories (for stdin, the currentdirectory is used).--style-help          show style settings and exit; this output can be savedto .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 processingUsing YAPF within your favorite editorYAPF is supported by multiple editors via community extensions or plugins. SeeEditor Supportfor more info.Return CodesNormally YAPF returns zero on successful program termination and non-zero
otherwise.If--diffis 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.yapfignoreorpyproject.tomllocated 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 usepyproject.toml, exclude patterns are specified byignore_patternskey
in[tool.yapfignore]section. For example:[tool.yapfignore]ignore_patterns=["temp/**/*.py","temp2/*.py"]Formatting styleThe formatting style used by YAPF is configurable and there are many "knobs"
that can be used to tune how YAPF does formatting. See thestyle.pymodule
for the full list.To control the style, run YAPF with the--styleargument. It accepts one of
the predefined styles (e.g.,pep8orgoogle), 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 = valuepairs
with a[style]heading. For example:[style]based_on_style=pep8spaces_before_comment=4split_before_logical_operator=trueThebased_on_stylesetting 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 theGoogle Python Style Guide)yapf(for use with Google open source projects)facebookSee_STYLE_NAME_TO_FACTORYinstyle.pyfor details.It's also possible to do the same on the command line with a dictionary. For
example:--style='{based_on_style: pep8, indent_width: 2}'This will take thepep8base style and modify it to have two space
indentations.YAPF will search for the formatting style in the following manner:Specified on the command lineIn the[style]section of a.style.yapffile in either the current
directory or one of its parent directories.In the[yapf]section of asetup.cfgfile in either the current
directory or one of its parent directories.In the[tool.yapf]section of apyproject.tomlfile in either the current
directory or one of its parent directories.In the[style]section of a~/.config/yapf/stylefile in your home
directory.If none of those files are found, the default style PEP8 is used.ExampleAn 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')classfoo(object):deff(self):return37*-+2defg(self,x,y=42):returnydeff(a):return37+-+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')classfoo(object):deff(self):return37*-+2defg(self,x,y=42):returnydeff(a):return37+-+a[42-x:y**3]Example as a moduleThe two main APIs for calling YAPF areFormatCodeandFormatFile, these
share several arguments which are described below:>>>fromyapf.yapflib.yapf_apiimportFormatCode# reformat a string of code>>>formatted_code,changed=FormatCode("f ( a = 1, b = 2 )")>>>formatted_code'f(a=1, b=2)\n'>>>changedTrueAstyle_configargument: 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 instyle.DEFAULT_STYLE_FACTORY.>>>FormatCode("def g():\nreturn True",style_config='pep8')[0]'def g():\nreturn True\n'Alinesargument: 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( ):\na=1\nb = 2\nreturn a==b",lines=[(1,1),(2,3)])[0]'def g():\na = 1\nb = 2\nreturn a==b\n'Aprint_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: thefilenameargument forFormatCodeis what is inserted into the
diff, the default is<unknown>.FormatFilereturns reformatted code from the passed file along with its encoding:>>>fromyapf.yapflib.yapf_apiimportFormatFile# reformat a file>>>print(open("foo.py").read())# contents of filea==b>>>reformatted_code,encoding,changed=FormatFile("foo.py")>>>formatted_code'a == b\n'>>>encoding'utf-8'>>>changedTrueThein_placeargument 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==bFormatting diffsOptions: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 changedlines. 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 -isvn diff --diff-cmd=diff -x-U0 | yapf-diff -p0 -iIt should be noted that the filename contained in the diff is usedunmodified to determine the source file to update. Users calling this scriptdirectly should be careful to ensure that the path in the diff is correctrelative 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 (forexample "pep8" or "google"), or the name of a filewith style settings. The default is pep8 unless a.style.yapf or setup.cfg or pyproject.toml filelocated in the same directory as the source or one ofits parent directories (for stdin, the currentdirectory is used).--binary BINARY       location of binary to use for YAPFKnobsALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENTAlign closing bracket with visual indentation.ALLOW_MULTILINE_LAMBDASAllow lambdas to be formatted on more than one line.ALLOW_MULTILINE_DICTIONARY_KEYSAllow 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,}ALLOW_SPLIT_BEFORE_DEFAULT_OR_NAMED_ASSIGNSAllow splitting before a default / named assignment in an argument list.ALLOW_SPLIT_BEFORE_DICT_VALUEAllow splits before the dictionary value.ARITHMETIC_PRECEDENCE_INDICATIONLet spacing indicate operator precedence. For example:a=1*2+3/4b=1/2-3*4c=(1+2)*(3-4)d=(1-2)/(3+4)e=1*2-3f=1+2+3+4will be formatted as follows to indicate precedence:a=1*2+3/4b=1/2-3*4c=(1+2)*(3-4)d=(1-2)/(3+4)e=1*2-3f=1+2+3+4BLANK_LINES_AROUND_TOP_LEVEL_DEFINITIONSets the number of desired blank lines surrounding top-level function and
class definitions. For example:classFoo:pass# <------ having two blank lines here# <------ is the default settingclassBar:passBLANK_LINE_BEFORE_CLASS_DOCSTRINGInsert a blank line before a class-level docstring.BLANK_LINE_BEFORE_MODULE_DOCSTRINGInsert a blank line before a module docstring.BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEFInsert a blank line before adeforclassimmediately nested within
anotherdeforclass. For example:classFoo:# <------ this blank linedefmethod():passBLANK_LINES_BETWEEN_TOP_LEVEL_IMPORTS_AND_VARIABLESSets the number of desired blank lines between top-level imports and
variable definitions. Useful for compatibility with tools like isort.COALESCE_BRACKETSDo not split consecutive brackets. Only relevant whenDEDENT_CLOSING_BRACKETSorINDENT_CLOSING_BRACKETSis set. For example:call_func_that_takes_a_dict({'key1':'value1','key2':'value2',})would reformat to:call_func_that_takes_a_dict({'key1':'value1','key2':'value2',})COLUMN_LIMITThe column limit (or max line-length)CONTINUATION_ALIGN_STYLEThe style for continuation alignment. Possible values are:SPACE: Use spaces for continuation alignment. This is default
behavior.FIXED: Use fixed number (CONTINUATION_INDENT_WIDTH) of columns
(i.e.CONTINUATION_INDENT_WIDTH/INDENT_WIDTHtabs orCONTINUATION_INDENT_WIDTHspaces) for continuation alignment.VALIGN-RIGHT: Vertically align continuation lines to multiple ofINDENT_WIDTHcolumns. Slightly right (one tab or a few spaces) if cannot
vertically align continuation lines with indent characters.CONTINUATION_INDENT_WIDTHIndent width used for line continuations.DEDENT_CLOSING_BRACKETSPut 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 linetime_series=self.remote_client.query_entity_counters(entity='dev3246.region1',key='dns.query_latency_tcp',transform=Transformation.AVERAGE(window=timedelta(seconds=60)),start_ts=now()-timedelta(days=3),end_ts=now(),)# <--- this bracket is dedented and on a separate lineDISABLE_ENDING_COMMA_HEURISTICDisable the heuristic which places each list element on a separate line if
the list is comma-terminated.EACH_DICT_ENTRY_ON_SEPARATE_LINEPlace each dictionary entry onto its own line.FORCE_MULTILINE_DICTRespectEACH_DICT_ENTRY_ON_SEPARATE_LINEeven if the line is shorter thanCOLUMN_LIMIT.I18N_COMMENTThe 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.I18N_FUNCTION_CALLThe 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.INDENT_BLANK_LINESSet toTrueto prefer indented blank lines rather than emptyINDENT_CLOSING_BRACKETSPut 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 linetime_series=self.remote_client.query_entity_counters(entity='dev3246.region1',key='dns.query_latency_tcp',transform=Transformation.AVERAGE(window=timedelta(seconds=60)),start_ts=now()-timedelta(days=3),end_ts=now(),)# <--- this bracket is indented and on a separate lineINDENT_DICTIONARY_VALUEIndent the dictionary value if it cannot fit on the same line as the
dictionary key. For example:config={'key1':'value1','key2':value1+value2,}INDENT_WIDTHThe number of columns to use for indentation.JOIN_MULTIPLE_LINESJoin short lines into one line. E.g., single lineifstatements.NO_SPACES_AROUND_SELECTED_BINARY_OPERATORSDo 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/5SPACE_BETWEEN_ENDING_COMMA_AND_CLOSING_BRACKETInsert a space between the ending comma and closing bracket of a list, etc.SPACE_INSIDE_BRACKETSUse spaces inside brackets, braces, and parentheses.  For example:method_call(1)my_dict[3][1][get_index(*args,**kwargs)]my_set={1,2,3}SPACES_AROUND_DEFAULT_OR_NAMED_ASSIGNSet toTrueto prefer spaces around the assignment operator for default
or keyword arguments.SPACES_AROUND_DICT_DELIMITERSAdds a space after the opening '{' and before the ending '}' dict delimiters.{1:2}will be formatted as:{1:2}SPACES_AROUND_LIST_DELIMITERSAdds a space after the opening '[' and before the ending ']' list delimiters.[1,2]will be formatted as:[1,2]SPACES_AROUND_POWER_OPERATORSet toTrueto prefer using spaces around**.SPACES_AROUND_SUBSCRIPT_COLONUse spaces around the subscript / slice operator.  For example:my_list[1:10:2]SPACES_AROUND_TUPLE_DELIMITERSAdds a space after the opening '(' and before the ending ')' tuple delimiters.(1,2,3)will be formatted as:(1,2,3)SPACES_BEFORE_COMMENTThe 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, withspaces_before_comment=5:1+1# Adding valueswill be formatted as:1+1# Adding values <-- 5 spaces between the end of the statement and commentwithspaces_before_comment="15, 20":1+1# Adding valuestwo+two# More addinglonger_statement# This is a longer statementshort# This is a shorter statementa_very_long_statement_that_extends_beyond_the_final_column# Commentshort# This is a shorter statementwill be formatted as:1+1# Adding values <-- end of line comments in block aligned to col 15two+two# More addinglonger_statement# This is a longer statement <-- end of line comments in block aligned to col 20short# This is a shorter statementa_very_long_statement_that_extends_beyond_the_final_column# Comment <-- the end of line comments are aligned based on the line lengthshort# This is a shorter statementSPLIT_ALL_COMMA_SEPARATED_VALUESIf 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.SPLIT_ALL_TOP_LEVEL_COMMA_SEPARATED_VALUESVariation onSPLIT_ALL_COMMA_SEPARATED_VALUESin which, if a
subexpression with a comma fits in its starting line, then the
subexpression is not split. This avoids splits like the one forbin this code:abcdef(aReallyLongThing:int,b:[Int,Int])with the new knob this is split as:abcdef(aReallyLongThing:int,b:[Int,Int])SPLIT_ARGUMENTS_WHEN_COMMA_TERMINATEDSplit before arguments if the argument list is terminated by a comma.SPLIT_BEFORE_ARITHMETIC_OPERATORSet toTrueto prefer splitting before+,-,*,/,//, or@rather than after.SPLIT_BEFORE_BITWISE_OPERATORSet toTrueto prefer splitting before&,|or^rather than after.SPLIT_BEFORE_CLOSING_BRACKETSplit before the closing bracket if alistordictliteral doesn't fit
on a single line.SPLIT_BEFORE_DICT_SET_GENERATORSplit before a dictionary or set generator (comp_for). For example, note
the split before thefor:foo={variable:'Hello world, have a nice day!'forvariableinbarifvariable!=42}SPLIT_BEFORE_DOTSplit 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))SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PARENSplit after the opening paren which surrounds an expression if it doesn't
fit on a single line.SPLIT_BEFORE_FIRST_ARGUMENTIf an argument / parameter list is going to be split, then split before the
first argument.SPLIT_BEFORE_LOGICAL_OPERATORSet toTrueto prefer splitting beforeandororrather than after.SPLIT_BEFORE_NAMED_ASSIGNSSplit named assignments onto individual lines.SPLIT_COMPLEX_COMPREHENSIONFor 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=[a_var+b_varfora_varinxrange(1000)forb_varinxrange(1000)ifa_var%b_var]would reformat to something like:result=[a_var+b_varfora_varinxrange(1000)forb_varinxrange(1000)ifa_var%b_var]SPLIT_PENALTY_AFTER_OPENING_BRACKETThe penalty for splitting right after the opening bracket.SPLIT_PENALTY_AFTER_UNARY_OPERATORThe penalty for splitting the line after a unary operator.SPLIT_PENALTY_ARITHMETIC_OPERATORThe penalty of splitting the line around the+,-,*,/,//,%,
and@operators.SPLIT_PENALTY_BEFORE_IF_EXPRThe penalty for splitting right before anifexpression.SPLIT_PENALTY_BITWISE_OPERATORThe penalty of splitting the line around the&,|, and^operators.SPLIT_PENALTY_COMPREHENSIONThe penalty for splitting a list comprehension or generator expression.SPLIT_PENALTY_EXCESS_CHARACTERThe penalty for characters over the column limit.SPLIT_PENALTY_FOR_ADDED_LINE_SPLITThe penalty incurred by adding a line split to the logical line. The more
line splits added the higher the penalty.SPLIT_PENALTY_IMPORT_NAMESThe penalty of splitting a list ofimport asnames. For example:froma_very_long_or_indented_module_name_yada_yadimport(long_argument_1,long_argument_2,long_argument_3)would reformat to something like:froma_very_long_or_indented_module_name_yada_yadimport(long_argument_1,long_argument_2,long_argument_3)SPLIT_PENALTY_LOGICAL_OPERATORThe penalty of splitting the line around theandandoroperators.USE_TABSUse the Tab character for indentation.(Potentially) Frequently Asked QuestionsWhy 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: disableFOO={# ... some very large, complex data literal.}BAR=[# ... another large data literal.]# yapf: enableYou 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 thededent_closing_bracketsin 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,frommy_packageimportmy_function_1,my_function_2,my_function_3,my_function_4,my_function_5FOO=my_variable_1+my_variable_2+my_variable_3+my_variable_4+my_variable_5+my_variable_6+my_variable_7+my_variable_8won't be split, but you can easily get it right by just adding parentheses:frommy_packageimport(my_function_1,my_function_2,my_function_3,my_function_4,my_function_5)FOO=(my_variable_1+my_variable_2+my_variable_3+my_variable_4+my_variable_5+my_variable_6+my_variable_7+my_variable_8)Gory DetailsAlgorithm DesignThe main data structure in YAPF is theLogicalLineobject. It holds a list
ofFormatToken\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 oneLogicalLineobject at a time.AnLogicalLinetypically won't affect the formatting of lines before or
after it. There is a part of the algorithm that may join two or moreLogicalLine\s into one line. For instance, an if-then statement with a
short body can be placed on a single line:ifa==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.defxxxxxxxxxxx(aaaaaaaaaaaa,bbbbbbbbb,cccccccc,dddddddd,eeeeee):# 1pass# 2For line (1), the algorithm will build a tree where each node (aFormattingDecisionStateobject) is the state of the line at that token given
the decision to split before the token or not. Note: theFormatDecisionStateobjects 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!