-If not, *Black* will look at the contents of the first outer matching
-brackets and put that in a separate indented line.
-```py3
-# in:
-
-l = [[n for n in list_bosses()], [n for n in list_employees()]]
-
-# out:
-
-l = [
- [n for n in list_bosses()], [n for n in list_employees()]
-]
-```
-
-If that still doesn't fit the bill, it will decompose the internal
-expression further using the same rule, indenting matching brackets
-every time. If the contents of the matching brackets pair are
-comma-separated (like an argument list, or a dict literal, and so on)
-then *Black* will first try to keep them on the same line with the
-matching brackets. If that doesn't work, it will put all of them in
-separate lines.
-```py3
-# in:
-
-def very_important_function(template: str, *variables, file: os.PathLike, debug: bool = False):
- """Applies `variables` to the `template` and writes to `file`."""
- with open(file, 'w') as f:
- ...
-
-# out:
-
-def very_important_function(
- template: str,
- *variables,
- file: os.PathLike,
- debug: bool = False,
-):
- """Applies `variables` to the `template` and writes to `file`."""
- with open(file, "w") as f:
- ...
-```
-
-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` and
-`include_trailing_comma=True` 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.
-
-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.
projects / etc / vim.git / blobdiff