-You might have noticed that closing brackets are always dedented and
-that a trailing comma is always added. Such formatting produces smaller
-diffs; when you add or remove an element, it's always just one line.
-Also, having the closing bracket dedented provides a clear delimiter
-between two distinct sections of the code that otherwise share the same
-indentation level (like the arguments list and the docstring in the
-example above).
-
-If a line of "from" imports cannot fit in the allotted length, it's always split
-into one per line. Imports tend to change often and this minimizes diffs, as well
-as enables readers of code to easily find which commit introduced a particular
-import. This exception also makes *Black* compatible with
-[isort](https://pypi.org/p/isort/). Use `multi_line_output=3`,
-`include_trailing_comma=True`, `force_grid_wrap=0`, and `line_length=88` in your
-isort config.
-
-
-### Line length
-
-You probably noticed the peculiar default line length. *Black* defaults
-to 88 characters per line, which happens to be 10% over 80. This number
-was found to produce significantly shorter files than sticking with 80
-(the most popular), or even 79 (used by the standard library). In
-general, [90-ish seems like the wise choice](https://youtu.be/wf-BqAjZb8M?t=260).
-
-If you're paid by the line of code you write, you can pass
-`--line-length` with a lower number. *Black* will try to respect that.
-However, sometimes it won't be able to without breaking other rules. In
-those rare cases, auto-formatted code will exceed your allotted limit.
-
-You can also increase it, but remember that people with sight disabilities
-find it harder to work with line lengths exceeding 100 characters.
-It also adversely affects side-by-side diff review on typical screen
-resolutions. Long lines also make it harder to present code neatly
-in documentation or talk slides.
-
-If you're using Flake8, you can bump `max-line-length` to 88 and forget
-about it. Alternatively, use [Bugbear](https://github.com/PyCQA/flake8-bugbear)'s
-B950 warning instead of E501 and keep the max line length at 80 which
-you are probably already using. You'd do it like this:
-```ini
-[flake8]
-max-line-length = 80
-...
-select = C,E,F,W,B,B950
-ignore = E501
-```
-
-You'll find *Black*'s own .flake8 config file is configured like this.
-If you're curious about the reasoning behind B950, Bugbear's documentation
-explains it. The tl;dr is "it's like highway speed limits, we won't
-bother you if you overdo it by a few km/h".
-
-
-### Empty lines
-
-*Black* avoids spurious vertical whitespace. This is in the spirit of
-PEP 8 which says that in-function vertical whitespace should only be
-used sparingly.
-
-*Black* will allow single empty lines inside functions, and single and
-double empty lines on module level left by the original editors, except
-when they're within parenthesized expressions. Since such expressions
-are always reformatted to fit minimal space, this whitespace is lost.
-
-It will also insert proper spacing before and after function definitions.
-It's one line before and after inner functions and two lines before and
-after module-level functions. *Black* will not put empty lines between
-function/class definitions and standalone comments that immediately precede
-the given function/class.
-
-
-### Trailing commas
-
-*Black* will add trailing commas to expressions that are split
-by comma where each element is on its own line. This includes function
-signatures.
-
-Unnecessary trailing commas are removed if an expression fits in one
-line. This makes it 1% more likely that your line won't exceed the
-allotted line length limit. Moreover, in this scenario, if you added
-another argument to your call, you'd probably fit it in the same line
-anyway. That doesn't make diffs any larger.
-
-One exception to removing trailing commas is tuple expressions with
-just one element. In this case *Black* won't touch the single trailing
-comma as this would unexpectedly change the underlying data type. Note
-that this is also the case when commas are used while indexing. This is
-a tuple in disguise: ```numpy_array[3, ]```.
-
-One exception to adding trailing commas is function signatures
-containing `*`, `*args`, or `**kwargs`. In this case a trailing comma
-is only safe to use on Python 3.6. *Black* will detect if your file is
-already 3.6+ only and use trailing commas in this situation. If you
-wonder how it knows, it looks for f-strings and existing use of trailing
-commas in function signatures that have stars in them. In other words,
-if you'd like a trailing comma in this situation and *Black* didn't
-recognize it was safe to do so, put it there manually and *Black* will
-keep it.
-
-### Strings
-
-*Black* prefers double quotes (`"` and `"""`) over single quotes (`'`
-and `'''`). It will replace the latter with the former as long as it
-does not result in more backslash escapes than before.
-
-*Black* also standardizes string prefixes, making them always lowercase.
-On top of that, if your code is already Python 3.6+ only or it's using
-the `unicode_literals` future import, *Black* will remove `u` from the
-string prefix as it is meaningless in those scenarios.
-
-The main reason to standardize on a single form of quotes is aesthetics.
-Having one kind of quotes everywhere reduces reader distraction.
-It will also enable a future version of *Black* to merge consecutive
-string literals that ended up on the same line (see
-[#26](https://github.com/ambv/black/issues/26) for details).
-
-Why settle on double quotes? They anticipate apostrophes in English
-text. They match the docstring standard described in PEP 257. An
-empty string in double quotes (`""`) is impossible to confuse with
-a one double-quote regardless of fonts and syntax highlighting used.
-On top of this, double quotes for strings are consistent with C which
-Python interacts a lot with.
-
-On certain keyboard layouts like US English, typing single quotes is
-a bit easier than double quotes. The latter requires use of the Shift
-key. My recommendation here is to keep using whatever is faster to type
-and let *Black* handle the transformation.
-
-### Line Breaks & Binary Operators
-
-*Black* will break a line before a binary operator when splitting a block
-of code over multiple lines. This is so that *Black* is compliant with the
-recent changes in the [PEP 8](https://www.python.org/dev/peps/pep-0008/#should-a-line-break-before-or-after-a-binary-operator)
-style guide, which emphasizes that this approach improves readability.
-
-This behaviour may raise ``W503 line break before binary operator`` warnings in
-style guide enforcement tools like Flake8. Since ``W503`` is not PEP 8 compliant,
-you should tell Flake8 to ignore these warnings.
-
-### Slices
-
-PEP 8 [recommends](https://www.python.org/dev/peps/pep-0008/#whitespace-in-expressions-and-statements)
-to treat ``:`` in slices as a binary operator with the lowest priority, and to
-leave an equal amount of space on either side, except if a parameter is omitted
-(e.g. ``ham[1 + 1 :]``). It also states that for extended slices, both ``:``
-operators have to have the same amount of spacing, except if a parameter is
-omitted (``ham[1 + 1 ::]``). *Black* enforces these rules consistently.
-
-This behaviour may raise ``E203 whitespace before ':'`` warnings in style guide
-enforcement tools like Flake8. Since ``E203`` is not PEP 8 compliant, you should
-tell Flake8 to ignore these warnings.
-
-### Parentheses
-
-Some parentheses are optional in the Python grammar. Any expression can
-be wrapped in a pair of parentheses to form an atom. There are a few
-interesting cases:
-
-- `if (...):`
-- `while (...):`
-- `for (...) in (...):`
-- `assert (...), (...)`
-- `from X import (...)`
-- assignments like:
- - `target = (...)`
- - `target: type = (...)`
- - `some, *un, packing = (...)`
- - `augmented += (...)`
-
-In those cases, parentheses are removed when the entire statement fits
-in one line, or if the inner expression doesn't have any delimiters to
-further split on. If there is only a single delimiter and the expression
-starts or ends with a bracket, the parenthesis can also be successfully
-omitted since the existing bracket pair will organize the expression
-neatly anyway. Otherwise, the parentheses are added.
-
-Please note that *Black* does not add or remove any additional nested
-parentheses that you might want to have for clarity or further
-code organization. For example those parentheses are not going to be
-removed:
-```py3
-return not (this or that)
-decision = (maybe.this() and values > 0) or (maybe.that() and values < 0)
-```
-
-### Call chains
-
-Some popular APIs, like ORMs, use call chaining. This API style is known
-as a [fluent interface](https://en.wikipedia.org/wiki/Fluent_interface).
-*Black* formats those treating dots that follow a call or an indexing
-operation like a very low priority delimiter. It's easier to show the
-behavior than to explain it. Look at the example::
-```py3
-def example(session):
- result = (
- session.query(models.Customer.id)
- .filter(
- models.Customer.account_id == account_id,
- models.Customer.email == email_address,
- )
- .order_by(models.Customer.id.asc())
- .all()
- )
-```
-
-### Typing stub files
-
-PEP 484 describes the syntax for type hints in Python. One of the
-use cases for typing is providing type annotations for modules which
-cannot contain them directly (they might be written in C, or they might
-be third-party, or their implementation may be overly dynamic, and so on).
-
-To solve this, [stub files with the `.pyi` file
-extension](https://www.python.org/dev/peps/pep-0484/#stub-files) can be
-used to describe typing information for an external module. Those stub
-files omit the implementation of classes and functions they
-describe, instead they only contain the structure of the file (listing
-globals, functions, and classes with their members). The recommended
-code style for those files is more terse than PEP 8:
-
-* prefer `...` on the same line as the class/function signature;
-* avoid vertical whitespace between consecutive module-level functions,
- names, or methods and fields within a single class;
-* use a single blank line between top-level class definitions, or none
- if the classes are very small.
-
-*Black* enforces the above rules. There are additional guidelines for
-formatting `.pyi` file that are not enforced yet but might be in
-a future version of the formatter:
-
-* all function bodies should be empty (contain `...` instead of the body);
-* do not use docstrings;
-* prefer `...` over `pass`;
-* for arguments with a default, use `...` instead of the actual default;
-* avoid using string literals in type annotations, stub files support
- forward references natively (like Python 3.7 code with `from __future__
- import annotations`);
-* use variable annotations instead of type comments, even for stubs that
- target older versions of Python;
-* for arguments that default to `None`, use `Optional[]` explicitly;
-* use `float` instead of `Union[int, float]`.
projects / etc / vim.git / blobdiff