X-Git-Url: https://git.madduck.net/etc/vim.git/blobdiff_plain/b250aed47bf11240b460bf4ecb57ba3f28078fd1..31fbd1982f9511c5b7bce93eb133110811f90e0f:/README.md diff --git a/README.md b/README.md index a589d0d..f587744 100644 --- a/README.md +++ b/README.md @@ -3,10 +3,10 @@

Build Status -Documentation Status +Documentation Status Coverage Status -License: MIT -PyPI +License: MIT +PyPI Code style: black

@@ -14,7 +14,7 @@ *Black* is the uncompromising Python code formatter. By using it, you -agree to cease control over minutiae of hand-formatting. In return, +agree to cede control over minutiae of hand-formatting. In return, *Black* gives you speed, determinism, and freedom from `pycodestyle` nagging about formatting. You will save time and mental energy for more important matters. @@ -74,7 +74,7 @@ Options: * it will read from standard input and write to standard output if `-` is used as the filename; * it only outputs messages to users on standard error; -* exits with code 0 unless an internal error occured (or `--check` was +* exits with code 0 unless an internal error occurred (or `--check` was used). @@ -106,9 +106,9 @@ the same effect, as a courtesy for straddling code. *Black* ignores previous formatting and applies uniform horizontal and vertical whitespace to your code. The rules for horizontal -whitespace are pretty obvious and can be summarized as: do whatever -makes `pycodestyle` happy. The coding style used by *Black* can be -viewed as a strict subset of PEP 8. +whitespace can be summarized as: do whatever makes `pycodestyle` happy. +The coding style used by *Black* can be viewed as a strict subset of +PEP 8. As for vertical whitespace, *Black* tries to render one full expression or simple statement per line. If this fits the allotted line length, @@ -131,13 +131,13 @@ brackets and put that in a separate indented line. ```py3 # in: -l = [[n for n in list_bosses()], [n for n in list_employees()]] +TracebackException.from_exception(exc, limit, lookup_lines, capture_locals) # out: -l = [ - [n for n in list_bosses()], [n for n in list_employees()] -] +TracebackException.from_exception( + exc, limit, lookup_lines, capture_locals +) ``` If that still doesn't fit the bill, it will decompose the internal @@ -176,6 +176,14 @@ 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 data structure literal (tuple, list, set, dict) or a line of "from" +imports cannot fit in the allotted length, it's always split into one +per line. This minimizes diffs as well as enables readers of code to +find which commit introduced a particular entry. This 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 @@ -260,12 +268,18 @@ 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 @@ -284,6 +298,7 @@ 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 @@ -295,6 +310,21 @@ 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 @@ -306,10 +336,86 @@ interesting cases: - `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. Otherwise, the parentheses are always added. +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]`. ## Editor integration @@ -388,7 +494,7 @@ Python version and automatically installs *Black*. You can upgrade it later by calling `:BlackUpgrade` and restarting Vim. If you need to do anything special to make your virtualenv work and -install *Black* (for example you want to run a version from master), just +install *Black* (for example you want to run a version from master), create a virtualenv manually and point `g:black_virtualenv` to it. The plugin will use it. @@ -404,10 +510,17 @@ to do this. Use [joslarson.black-vscode](https://marketplace.visualstudio.com/items?itemName=joslarson.black-vscode). + ### SublimeText 3 Use [sublack plugin](https://github.com/jgirardet/sublack). + +### IPython Notebook Magic + +Use [blackcellmagic](https://github.com/csurfer/blackcellmagic). + + ### Other editors Atom/Nuclide integration is planned by the author, others will @@ -499,8 +612,8 @@ MIT ## Contributing to Black -In terms of inspiration, *Black* is about as configurable as *gofmt* and -*rustfmt* are. This is deliberate. +In terms of inspiration, *Black* is about as configurable as *gofmt*. +This is deliberate. Bug reports and fixes are always welcome! However, before you suggest a new feature or configuration knob, ask yourself why you want it. If it @@ -515,7 +628,70 @@ More details can be found in [CONTRIBUTING](CONTRIBUTING.md). ## Change Log -### 18.4a3 (unreleased) +### 18.5a0 (unreleased) + +* call chains are now formatted according to the + [fluent interfaces](https://en.wikipedia.org/wiki/Fluent_interface) + style (#67) + +* data structure literals (tuples, lists, dictionaries, and sets) are + now also always exploded like imports when they don't fit in a single + line (#152) + +* slices are now formatted according to PEP 8 (#178) + +* parentheses are now also managed automatically on the right-hand side + of assignments and return statements (#140) + +* math operators now use their respective priorities for delimiting multiline + expressions (#148) + +* optional parentheses are now omitted on expressions that start or end + with a bracket and only contain a single operator (#177) + +* empty parentheses in a class definition are now removed (#145, #180) + +* string prefixes are now standardized to lowercase and `u` is removed + on Python 3.6+ only code and Python 2.7+ code with the `unicode_literals` + future import (#188, #198, #199) + +* typing stub files (`.pyi`) are now formatted in a style that is consistent + with PEP 484 (#207, #210) + +* progress when reformatting many files is now reported incrementally + +* fixed trailers (content with brackets) being unnecessarily exploded + into their own lines after a dedented closing bracket (#119) + +* fixed an invalid trailing comma sometimes left in imports (#185) + +* fixed non-deterministic formatting when multiple pairs of removable parentheses + were used (#183) + +* fixed multiline strings being unnecessarily wrapped in optional + parentheses in long assignments (#215) + +* fixed not splitting long from-imports with only a single name + +* fixed Python 3.6+ file discovery by also looking at function calls with + unpacking. This fixed non-deterministic formatting if trailing commas + where used both in function signatures with stars and function calls + with stars but the former would be reformatted to a single line. + +* fixed crash on dealing with optional parentheses (#193) + +* fixed "is", "is not", "in", and "not in" not considered operators for + splitting purposes + +* fixed crash when dead symlinks where encountered + + +### 18.4a4 + +* don't populate the cache on `--check` (#175) + + +### 18.4a3 * added a "cache"; files already reformatted that haven't changed on disk won't be reformatted again (#109) @@ -528,6 +704,8 @@ More details can be found in [CONTRIBUTING](CONTRIBUTING.md). * Black no longer enforces putting empty lines behind control flow statements (#90) +* Black now splits imports like "Mode 3 + trailing comma" of isort (#127) + * fixed comment indentation when a standalone comment closes a block (#16, #32) * fixed standalone comments receiving extra empty lines if immediately preceding @@ -542,6 +720,7 @@ More details can be found in [CONTRIBUTING](CONTRIBUTING.md). * fixed missing splits of ternary expressions (#141) + ### 18.4a2 * fixed parsing of unaligned standalone comments (#99, #112) @@ -699,10 +878,14 @@ Maintained with [Carol Willing](mailto:carolcode@willingconsulting.com), Multiple contributions by: * [Anthony Sottile](mailto:asottile@umich.edu) * [Artem Malyshev](mailto:proofit404@gmail.com) +* [Christian Heimes](mailto:christian@python.org) * [Daniel M. Capella](mailto:polycitizen@gmail.com) * [Eli Treuherz](mailto:eli.treuherz@cgi.com) * Hugo van Kemenade * [Ivan Katanić](mailto:ivan.katanic@gmail.com) +* [Jelle Zijlstra](mailto:jelle.zijlstra@gmail.com) * [Jonas Obrist](mailto:ojiidotch@gmail.com) +* [Miguel Gaiowski](mailto:miggaiowski@gmail.com) * [Osaetin Daniel](mailto:osaetindaniel@gmail.com) +* [Sunil Kapil](mailto:snlkapil@gmail.com) * [Vishwas B Sharma](mailto:sharma.vishwas88@gmail.com)