Pycharm проверка кода на ошибки

Basics

Just a few notes about linters in general and how one can benefit from using them in Python. First of all the main purpose of linters — to check your source code and find possible style, logic and all other kinds of errors (feel free to narrow down the definition to only style errors). As you probably know Python is a dynamic language which leads to a broad field of possible errors which will not be found by the compiler. Obviously linters may eliminate such errors before you or your users will find them. Another great linters advantage is to enforce style of your code (remember PEP8). Good uniform style will result in less errors, maintaining easiness, new contributes convenience, you named it.

Install All the Linters

pip install pylint pydocstyle pycodestyle mypy

pylint

pylint is a well known Python linter and one of my favorite tools which I use extensively in almost every project I have. It’s very strict and highly customizable. To run pylint against your code just type:

python -m pylint <some_dir>

By default it generates a voluminous output with code assessment, different metrics (tables) and so on. The most important here is warnings (top of the report), e.g.:

************* Module src.year2016.day3b
E: 27, 0: Sequence index is not an int, slice, or instance with __index__ (invalid-sequence-index)
C: 44, 8: Invalid variable name "a" (invalid-name)

These two tell us that I used a wrong type inside a slice and an invalid name of the variable (in terms of PEP8). As I said pylint is super strict and some errors may be just false positives, in the case above I really known what I’m doing with the variable name a and wrong type in slice is just a Python 3.6 style type annotation that is not supported by pylint at all at least right now.

To mute such false positives and customize the report one may use pylintrc file, this is in fact a very simple and useful. Just create a pylintrc file in the project root and add some options, my example:

[MESSAGES CONTROL]
disable=locally-disabled,
 # False positive for type annotations with typing module
 invalid-sequence-index,
 # False positive for OK test methods names and few other places
 invalid-name,
 # False positive for test file classes and methods
 missing-docstring

[REPORTS]
# Simplify pylint reports
reports=no

[SIMILARITIES]
min-similarity-lines=10
ignore-docstrings=yes

This will reduce the size of output (I don’t really care about my code assessment rate), enforce some style options like 80 characters per line and disable few inspections globally, e.g. missing docstring — I rely on pydocstyle to check my docstrings. You can also disable a warning per file with comments on top of it, e.g. mute invalid name inspection for specific file:

# pylint: disable=invalid-name
...

or mute all inspections for a specific function:

def main():  # pragma: no cover
    ...

pydocstyle

pydocstyle is a simple tool with goal to check your docstrings for correct style. You’re going to be surprised what errors you’ll see — I never thought there’re such conventions in Python.

Execution is straightforward:

python -m pydocstyle

And the result:

./src/year2016/day4b.py:36 in public function ``solve``:
        D202: No blank lines allowed after function docstring (found 1)
./src/year2016/day4b.py:36 in public function ``solve``:
        D400: First line should end with a period (not 'd')

Here I have two errors: first one points to a blank line after the docstring which is not allowed by the convention and the second one tells that first line of the docstring should end with the dot like a normal sentence does.

There’s no much to elaborate on here, just try it, al least pydocstyle is going to enforce you to place docstring in all of your functions and classes which is kinda nice thing to do (and it will skip tests by default).

pycodestyle

You may think that pycodestyle is needless after you have pylint but it turns out not to be the true story. pydocstyle is intended to find PEP8 errors and as simple as it is often finds some dumb style errors I have that pylint failed to notice. I suspect pylint sometimes thinks such stupid typos are not the thing it is going to spend time reporting.

Very complicated usage:

python -m pycodestyle --select E,W .

Notice the —select flag — it’s intended to enable all errors and warning which pycodestyle can report. Kind of «ultra strict» mode. Try to run it against your sources and be surprised how many PEP8 errors you have. And if you’re not the IDE user there’re going to be tones of errors — brace yourself.

mypy

mypy is a different story. As we all know Python is a dynamic language but you still can type-annotate your code and have it type-checked before runtime with external tools, e.g. PyCharm or mypy. This is a huge topic and you should read some docs to make yourself familiar with type annotations in Python, good start is PEP 484.

Type annotations is a double-edged sword — you’re going to find some errors in your code in advance but you’re also going to introduce a lot of redundant code to your project which is completely useless in the runtime. There’re some ways to separate type annotations from the code itself — with stubs, but it’s a different story, let’s check a simple example:

def foo(a: int) -> bool:
    return str(a % 2 == 0)

Our function checks if a is even and returns True or False. I added types to function declaration with this new shiny Python 3 style, so basically a should be int and function should return boolean. If you’re using PyCharm it will throw a warning right into your type annotated face complaining about wrong output type which is str in fact and no way boolean.

If you’re using some other editor there will be no warning and we obviously want to have one. So to check this code against type errors we’re going to use mypy. Just save the function in sample.py and run:

python -m mypy sample.py

and the result is:

sample.py: note: In function "foo":
sample.py:2: error: Incompatible return value type (got "str", expected "bool")

Not so fast my my sweet dynamic child.

Ok, so I hope you have a broad overview of possibilities now. I’m not in any way an expert in this topic and it’s huge so you should read mypy and typing docs at least if you’re interesting. I run mypy over source code in the continues integration just to check everything outside of PyCharm. You may hate this type-stuff idea in Python all together so feel free to dump it right now but it worth trying I believe.

PyCharm Integration

We’ll use External Tools feature to integrate all four linters with PyCharm to some extent. Open Settings | Tools | External Tools in PyCharm and click a + button to add first external tool in out project.

Let’s start with the most hard to setup — pylint, complete configuration should be similar to image below:

Line by line:

• First of all specify the tool name (any you like), I pick pylint for obvious reasons
• Next select or create a group for this tool to belong to, for us it’ll be linters
• Provide a custom description
• Enable all option in Options paragraph — we really want to see pylint output
• Now a tricky part — configure Output Filters — it’ll allow PyCharm to highlight pylint output by inserting links to files with errors so you will be able to quickly jump to an error or warning in your code. Name and Description is not really important but Regular expression to match output is, so the format for us is $FILE_PATH$:$LINE$:$COLUMN$:.*, $name$ is a special variables used by PyCharm to understand where is file path, line and column in the line (read more in official documentation: External Tools)
• Program is path to pylint executable, we’re using $PyInterpreterDirectory$ template to refer to directory where Python interpreter of the current project is placed
• Parameter field here solves two problems: first it specifies what files and folder should pylint check (main.py src tests, edit according to your code), second it sets output format for pylint errors, it’s required so PyCharm can understand it and provide useful links from errors to source code
• Working directory is easy — just $ContentRoot$ template, which is our project root

You can now access this external tool from Tools | External Tools. Feel free to run it against your code (make sure there’re some PEP8 errors) and check the output. Meanwhile we’re moving to pydocstyle.

pydocstyle is on the way:

• Name, group, description and set of basics options as always
• Executable is pydocstyle
• And $ContentRoot$ as working directory

Now let’s setup pycodestyle:

• Same simple settings for name, group and description
• Enable all options
• Program executable is pycodestyle in $PyInterpreterDirectory$
• For parameters we’re using —select flag to enable all errors and warnings, the dot is target for pycodestyle
• Same working directory as pylint has

And the last one — mypy:

• Everything is the same
• Except executable is mypy
• And parameter is dot — target for mypy

In the result you should have something like this:

And you can access everything from Tools menu and run independently:

The final touch is to add all this external tools to some run configuration, e.g. one to run all the tests:

Now try to execute this run configuration and see additional tabs with linters result:

Live Example

For a live example I choose my simple project with solutions for Advent of Code puzzles. It’s super easy and does not use any specific configuration for linters apart of pylintrc and a little customisation for calls in Makefile.

I usually implement some kind of automation for my projects. I used several different utilities for it (invoke, paver, etc) and now my favorite is simple Makefile. The logic is very simple — Makefile contains commands which you can run with make <command>. This command will execute a bunch of predefined instructions right in your terminal, for example:

lint:
    python -m pylint main.py src tests
    python -m pydocstyle
    python -m pycodestyle --select E,W .
    python -m mypy .

lint command will execute all linters one by one. Each line is straightforward. If there will be errors make will stop and output the captured log. Be aware that you MUST use tabs instead of spaces in makefiles for indentation or everything is going to blow up.

For manual usage I rely on PyCharm integration but it’s very useful to have such automation for continues integration, for example my .travis.yml related part:

install:
  - make update

script:
  - make test
  - make lint

Very concise and reusable.

Resume

That was the basic linters usage in Python overview with a few simple real world examples. I hope you found it useful. Linters as probably any other tools are not a silver bullet which will solve all of your problems, in fact I skip using them entirely for some projects so feel free to decide for yourself is it worth trying and using or not.

Please leave any recommendations, suggestions and general notes in the comments below — I would love to incorporate any tips in the post and my routine workflow. I’m also working on my English writing skills — so any feedback is appreciated. Thank you for reading!

CHANGE INSPECTION SEVERITY | PYCHARM

CREATE CUSTOM INSPECTIONS | PYCHARM

INSPECTIONS | PYCHARM — PLEIADES

DISABLING AND ENABLING INSPECTIONS | PYCHARM

RUN INSPECTIONS | PYCHARM

CODE INSPECTION NOT WORKING — IDES SUPPORT (INTELLIJ PLATFORM)

Oct 31, 2018 Code Inspection not working. my problem is the following: When I am executing the code inspection PyCharm just says «No suspicious code found», even when I add errors …
From intellij-support.jetbrains.com

PYTHON — PYCHARM NOINSPECTION FOR WHOLE FILE? — STACK OVERFLOW

2022-10-22Using PyCharm 2020.2 (Professional Edition) Build #PY-202.6397.98, built on July 27, 2020 and putting # noinspection PyUnusedLocal as the very first line of the file appears to work for me, …
From stackoverflow.com

PYCHARM INSPECTIONS — ÖZCAN YARıMDüNYA

2022-10-22Özcan Yarımdünya … Skip to content
From yarimdunya.com

PYTHON — DISABLE INSPECTION IN PYCHARM — STACK OVERFLOW

Jul 3, 2018 3. If you click alt+enter on the errors, you can see some choices. For example, Suppress for class, Suppress for function, Suppress for statement. You can choose one of …
From stackoverflow.com

HOW TO SUPPRESS SYNTAX INSPECTION IN PYCHARM? — STACK OVERFLOW

Jul 2, 2015 For most if not all PyCharm inspections I can write a # noinspection comment in the right place and turn the inspection off for some piece of code. I did so, to turn off the …
From stackoverflow.com

RUN CODE INSPECTIONS FROM THE COMMAND LINE | PYCHARM

May 23, 2022 PyCharm runs code inspections to find and highlight syntax errors, dead code, possible bugs, bad coding style, and other problems. You can also run all the configured …
From jetbrains.com

PYCHARM NOT INSPECTING IMPORTS CORRECTLY — STACK OVERFLOW

Jun 19, 2015 Thus to fix the error, either change the root setting in the project structure preferences for pycharm OR change the cwd of where you run the interpreter. Right click on …
From stackoverflow.com

PYTHON — PYCHARM — ALWAYS SHOW INSPECTIONS — STACK …

Aug 31, 2016 PyCharm displays little bars on the scroll bar for things like code warnings. This feature is called «inspection». If you move the mouse cursor over a bar, it shows a preview of …
From stackoverflow.com

PYCHARM NOINSPECTION FOR WHOLE FILE? – PYTHON

2022-10-22Select correct entry from appeared popup menu. Using Arrow Right key expand submenu. Look for “Suppress inspection” option. This is how it looks in PhpStorm (screenshot shows …
From python.tutorialink.com

PYCHARM CODE INSPECTION NOT WORKING – IDES SUPPORT … — JETBRAINS

Jan 15, 2021 Here is what I’ve tried to date that hasn’t worked: Exit out of pycharm completely and restart. Downgrade back to previous version (2020.3) Recreated the project code …
From intellij-support.jetbrains.com

PYCHARM INSPECTIONS · GITHUB — GIST

Oct 18, 2022 As on December 14th 2020, some warnings, e.g. PyShadowingBuiltins are not included. Luckily, official documentation now describes how you can do it. To suppress a …
From gist.github.com

CODE QUALITY ASSISTANCE TIPS AND TRICKS, OR HOW TO MAKE …

Mar 17, 2022 If you explore the list of inspections (Ctrl+Alt+S — Inspections), you will see that PyCharm launches the pep8.py tool on your code, and pinpoints the code style violations. …
From jetbrains.com