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.
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] ...YAPF is supported by multiple editors via community extensions or plugins. See Editor Support for more info.
YAPF supports Python 3.7+.
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 processingNormally 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.
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 seq
Note 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"
]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]
based_on_style = pep8
spaces_before_comment = 4
split_before_logical_operator = trueThe based_on_style 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
See _STYLE_NAME_TO_FACTORY in style.py for 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 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 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.
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]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
TrueA 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.DEFAULT_STYLE_FACTORY.
>>> FormatCode("def g():\n return True", style_config='pep8')[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
TrueThe 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 == bOptions:
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 3.12 – PEP 695 – Type Parameter Syntax – YAPF #1170
- Python 3.12 – PEP 701 – Syntactic formalization of f-strings – YAPF #1136
Align closing bracket with visual indentation.
Allow lambdas to be formatted on more than one line.
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,
}Allow splitting before a default / named assignment in an argument list.
Allow splits before the dictionary value.
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 + 4Sets 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:
passInsert a blank line before a class-level docstring.
Insert a blank line before a module docstring.
Insert a blank line before a
deforclassimmediately nested within anotherdeforclass. For example:
class Foo:
# <------ this blank line
def method():
passSets the number of desired blank lines between top-level imports and variable definitions. Useful for compatibility with tools like isort.
Do not split consecutive brackets. Only relevant when
DEDENT_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',
})The column limit (or max line-length)
The 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.
Indent width used for line continuations.
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
time_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 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,
DISABLE_SPLIT_LIST_WITH_COMMENT, that controls splitting when a list contains a comment. To get the old behavior, set both flags to true. More information in CHANGELOG.md.
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.
Place each dictionary entry onto its own line.
Respect
EACH_DICT_ENTRY_ON_SEPARATE_LINEeven if the line is shorter thanCOLUMN_LIMIT.
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.
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.
Set to
Trueto prefer indented blank lines rather than empty
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
time_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 the dictionary value if it cannot fit on the same line as the dictionary key. For example:
config = {
'key1':
'value1',
'key2': value1 +
value2,
}The number of columns to use for indentation.
Join short lines into one line. E.g., single line
ifstatements.
Do not include spaces around selected binary operators. For example:
1 + 2 * 3 - 4 / 5