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 yapf

YAPF 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.git

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 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 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"
]

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]
based_on_style = pep8
spaces_before_comment = 4
split_before_logical_operator = true

The 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:

1. Specified on the command line
2. In the [style] section of a .style.yapf file in either the current directory or one of its parent directories.
3. In the [yapf] section of a setup.cfg file in either the current directory or one of its parent directories.
4. In the [tool.yapf] section of a pyproject.toml file in either the current directory or one of its parent directories.
5. In the [style] section of a ~/.config/yapf/style file in your home directory.

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.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 == b

Note: 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

ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT

Align closing bracket with visual indentation.

ALLOW_MULTILINE_LAMBDAS

Allow lambdas to be formatted on more than one line.

ALLOW_MULTILINE_DICTIONARY_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,
    }

ALLOW_SPLIT_BEFORE_DEFAULT_OR_NAMED_ASSIGNS

Allow splitting before a default / named assignment in an argument list.

ALLOW_SPLIT_BEFORE_DICT_VALUE

Allow splits before the dictionary value.

ARITHMETIC_PRECEDENCE_INDICATION

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 + 4

will 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 + 4

BLANK_LINES_AROUND_TOP_LEVEL_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:
        pass

BLANK_LINE_BEFORE_CLASS_DOCSTRING

Insert a blank line before a class-level docstring.

BLANK_LINE_BEFORE_MODULE_DOCSTRING

Insert a blank line before a module docstring.

BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF

Insert a blank line before a def or class immediately nested within another def or class. For example:

    class Foo:
                       # <------ this blank line
        def method():
            pass

BLANK_LINES_BETWEEN_TOP_LEVEL_IMPORTS_AND_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 DEDENT_CLOSING_BRACKETS or INDENT_CLOSING_BRACKETS is 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_LIMIT

The column limit (or max line-length)

CONTINUATION_ALIGN_STYLE

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_WIDTH tabs or CONTINUATION_INDENT_WIDTH spaces) for continuation alignment.
• VALIGN-RIGHT: Vertically align continuation lines to multiple of