Black is a popular Python code formatter. By using it, contributors
don't need to think about the project's styles preferences and avoids
the need for hand-formatting. Instead, let the tool handle it. This can
help smooth the review process.
Updated existing tools to follow the integration docs:
https://black.readthedocs.io/en/stable/guides/using_black_with_other_tools.html
For more details, see the project:
https://github.com/psf/black
Provide type annotations and use mypy for static type checking. Type
checkers help ensure that the project is using variables and functions
in the code correctly. With mypy, CI will warn when those types are used
incorrectly.
The mypy project and docs:
https://github.com/python/mypyhttps://mypy.readthedocs.io/en/stable/index.html
* DeepSource issue: Built-in function `len` used as condition
Using the `len` function to check if a sequence is empty is not idiomatic
and can be less performant than checking the truthiness of the object.
`len` doesn't know the context in which it is called, so if computing the
length means traversing the entire sequence, it must; it doesn't know
that the result is just being compared to 0. Computing the boolean value
can stop after it sees the first element, regardless of how long the
sequence actually is.
* DeepSource issue: Consider using literal syntax to create the data structure
Using the literal syntax can give minor performance bumps compared to
using function calls to create `dict`, `list` and `tuple`.
This is because here, the name dict must be looked up in the global
scope in case it has been rebound. Same goes for the other two types
`list()` and `tuple()`.
* DeepSource issue: Consider decorating method with `@staticmethod`
The method doesn't use its bound instance. Decorate this method with
`@staticmethod` decorator, so that Python does not have to instantiate
a bound method for every instance of this class thereby saving memory
and computation. Read more about staticmethods here.
* DeepSource issue: Consider using `in`
To check if a variable is equal to one of many values, combine the values
into a tuple and check if the variable is contained `in` it instead of
checking for equality against each of the values. This is faster, less
verbose, and more readable.
* DeepSource issue: Implicit enumerate calls found
Using `range(len(...))` is not pythonic. Python does not have not
index-based loops. Instead, it uses collection iterators.
Python has a built-in method enumerate which adds a counter to an
iterable. Using this, you can access the counter and the value from
the iterable at the same time. It is therefore recommended to replace
`range(len(...))` with `enumerate(...)`.
isort is a utility to sort Python imports alphabetically, and
automatically separate into sections and by type. This will provide a
consistent import style from contributors. As well, by using a tool, a
contributor doesn't need to think about or anticipate the project's
preferred style, just let the tool handle it.
Run isort GitHub action as part of CI.
Update patterns to modern Python syntax and features. Drops unnecessary
legacy syntax that was required for Python 2 (removed in
9c3db1a5c5e02739eedba9e9915acd51736300b3).
Details on pyupgrade can be found at:
https://github.com/asottile/pyupgrade
The encoding detection code was trying to catch encoding-related
exceptions when the file is opened. This doesn't make sense, because
at this point no data has been read, therefore no encoding errors can be
detected. Instead, catch encoding-related exceptions when the file
contents are read.
Also avoid bailing out with `Exception('Unknown encoding')` on empty
files.
The list comprehension is shorter than the map() version.
I feel it is also simpler, although that is debatable.
This is consistent with the previous commit.
