pycodestyle VS yapf

PEP8 (pycodestyle): Named after Python’s PEP 8 style guide, this tool checks your Python code against some of the style conventions in PEP 8.

pycodestyle linter (used in Flake8 under the hood by default) already has E501 and W505 rules to validate the line length. flake8-length provides an alternative check that is smarter and more forgiving.

[flake8] max-line-length = 88 ignore = # False positive whitespace before ':' on list slice. # See https://github.com/PyCQA/pycodestyle/issues/373 for details E203

Linters analyze code to detect various categories of issues like logistical issue and stylistic issues. Some popular linters are Pylint, pycodestyle, Flake8 and Pylama.

Regarding item 4), sorry to make a relatively minor correction to your very helpful post, but you linked to a four-year-old version of a tool that has received many updates since. Here is the current version (note that the project has been renamed). In addition, it is decidedly not an official tool; making its unofficial status clear was the reason for the name change.

Link. When I write Python I usually have pycodestyle as my linter, and this got me thinking: If I already have a linter configuration for a project, why not just use the linter configuration as my editor configuration as well? The linter configuration is useful to others even if they use a different editor and I don't have to duplicate it in a local vimrc or editorconfig file. I can just use what I already have.

setuptools provides an easy way to do this via entry_points. Here's the relevant part of setup.py in pycodestyle

YAPF (Yet Another Python Formatter): YAPF takes a different approach in that it’s based off of ‘clang-format’, a popular formatter for C++ code. YAPF reformats Python code so that it conforms to the style guide and looks good.

I think I agree about the testing and labor of complicated translation rules.

But it doesn't appear that almost every pretty printer uses the Wadler pretty printing paper. It seems like MOST of them don't?

e.g. clang-format is one of the biggest and best, and it has a model that includes "unwrapped lines", a "layouter", a line break cost function, exhaustive search with memoization, and Dijikstra's algorithm:

https://llvm.org/devmtg/2013-04/jasper-slides.pdf

The YAPF Python formatter is based on this same algorithm - https://github.com/google/yapf

The Dart formatter used a model of "chunks, rules, and spans"

https://journal.stuffwithstuff.com/2015/09/08/the-hardest-pr...

It almost seems like there are 2 camps -- the functional algorithms for functional/expression-based languages, and other algorithms for more statement-based languages.

Though I guess Prettier/JavaScript falls on the functional side.

I just ran across this survey on lobste.rs and it seems to cover the functional pretty printing languages influenced by Wadler, but functional style, but not the other kind of formatter ("Google" formatters perhaps)

https://arxiv.org/pdf/2310.01530.pdf

To get all your code into a consistent format the next step is to run a formatter. I recommend black, the well-known uncompromising code formatter, which is the most popular choice. Alternatives to black are autoflake, prettier and yapf, if you do not agree with blacks constraints.

Use yapf to format code -> https://github.com/google/yapf

Google is surprisingly rigorous when it comes to code formatting. I have been a software engineer at Amazon and it was nothing like what the book says happens at Google. So the conventions you see for python docstring formatting are primarily designed to integrate with Google's internal tooling. By using docstrings following the Google conventions, you will ultimately end up with automated documentation and other fancy automated things (like type checking which they did in the docstring before there were type hints). Also notably, Google has an open source python formatting tool that they use internally called YAPF (which stands for "Yet Another Python Formatter". So if you really want to go all-in on Google python style, grab that, too.

https://github.com/google/yapf has configs, do ctrl+f SPLIT_COMPLEX_COMPREHENSION in the readme

Only as recommendation: If the lines of the source code (here: you C code you aim to document) are kept short, in manageable bytes (similar to entries parser.add_argument in Clark's "Tiny Python Projects", example seldomly pass beyond the frequently recommended threshold of 80 characters/line), reporting with listings becomes easier (equally, the reading of the difference logs/views by git and vimdiff), than with lines of say 120 characters per line. Though we no longer are constrained to 80 characters per line by terminals/screens and punch cards (when Fortran still was FORTRAN), this is a reason e.g., yapf for Python allows you to choose between 4 spaces/indentation (PEP8 style), or 2 spaces/indentation (Google style).

There is also a formatter for Python files called yapf that your team can use to avoid arguing over formatting conventions. Plus, Google also provides a settings file for Vim, noting that the default settings should be enough if you're using Emacs.