Tool for encouraging best coding practices and helping ensure Python code is secure.

Finding likely bugs and design problems in your program.

Extension that implements misc. lints.

Plugin that helps you to simplify code.

Set of flake8 plugins that test and enforce the OpenStack StyleGuide.

The strictest and most opinionated Python linter ever.

Adds many new rules to improve your code quality and brings a curated and actively maintained list of other plugins…

Plugin which checks for misuse of sys.version or sys.version_info.

Alfred is a flake8 plugin to warn on unsafe/obsolete symbols.

A flake8 plugin that checks for bad async / asyncio practices.

Ensures that modules have defined __all__.

Identify incorrect use of encodings.

Detect usage of mutable objects as default values for arguments.

Detect incorrectly wrapped Qt translation text.

Package requirements checker.

Enforce some secure coding standards for Python.

Require __slots__ to be defined for subclasses of immutable types.

Checks for use of platform-specific strftime codes.

Check that indexed parameters are used in strings.

Warn against unused arguments in functions.

Detect useless assert statements.

Checks for missing timeout parameters in network calls.

Detect usage of deprecated modules, classes, and functions.

Checks that if modules under __all__ are defined as strings.

Checks classes attributes order.

Plugin to enforce a blank line after if/for/while/with/try blocks.

Enforcing trailing commas in Python.

Helps you write better list/set/dict comprehensions.

Plugin to warn the developer of the usage of datetime.utcnow().

A plugin for flake8 to ban the usage of unsafe naive datetime class.

Plugin to encourage correct string literal concatenation.

Plugin to enforce 8-space indentation in function and class definitions.

Enforces consistent styling of string literals.

Plugin to ensure a consistent format for multiline containers.

Ensures the function definition goes below its usage.

Allows to forbid specific imports.

Checks for redundant parentheses and alignment of parentheses and brackets.

Extension for checking quotes in Python.

Plugin that checks return values.

Rules which do have known false-positives but might still be useful for a one-time run.

Plugin that checks SQL code against opinionated style rules.

Checks Python code against a set of opinionated style rules.

Plugin that prevents you from writing 'too many' bad codes.

Prevent exception handling antipatterns.

Report line break with backslash (\).

Report debug statements (pdb, ipdb).

Forbid some functions in some modules.

Reports issues in using the standard library logging module.

Report string formatting inside logging.

Report match statement.

Report implicit string concatenation.

Report implicit namespace packages.

Report %-formatting.

Report print statement.

Report %-formatting.

Report %-formatting and str.format.

Report os.path.

Report walrus operator (:=).

Check for Python builtins being used as variables or parameters.

Validate functions names, decomposition and conformity with annotations.

Checks that test functions names follow a given convention.

Extension that helps to make more readable variables names.

Check the PEP-8 naming conventions.

Extension for measuring Python class cohesion.

Plugin to validate annotations complexity.

Extension for flake8 that validates cognitive functions complexity.

Plugin to validate expressions complexity.

Plugin for validation of function parameters (length, complexity, etc).

Smart line length validation.

Check that all Azure DevOps IDs mentioned in the comments are in the correct format and have the corresponding ADO item.

Checks Python modules for __author__ attributes.

Adds coding magic comment checks (coding:) to flake8.

Reports redundant comments.

Adds copyright checks to flake8.

Plugin to find commented out or dead code.

Plugin for checking executable permissions and shebangs.

Check for FIXME, TODO and other temporary developer notes.

Check that every TODO comment has a valid JIRA issue ID next to it.

Validate # noqa comments.

Checker for assuring that author, copyright, and license are specified in source files.

Check for TODO notes.

Lint TODO comments to be consistent and have an issue linked.

Checks if everything has a docstring.

Include checks provided by pep257.

Linter that checks docstrings of functions, methods and classes.

Validate Python docstrings as reStructuredText (RST).

Spellcheck variables, classnames, comments, docstrings etc.

Check docstrings for double backticked strings which should be links to the Python documentation.

A Python docstring linter that checks arguments, returns, yields, and raises sections.

CLI tool to introspect flake8 plugins and their codes.

Flake8 plug-in loading the configuration from pyproject.toml.

Adds support for reading flake8 config from pyproject.toml.

More powerful configs for flake8.

Wrapper to make it nice, legacy-friendly, and configurable.

Web list of flake8 plugins and their codes, a wrapper around flake8-codes.

Enforce the same lint configuration (flake8, isort, mypy, pylint) across multiple Python projects.

Online playground for wemake-python-styleguide.

A tool to automatically remove unnecessary # noqa comments.

Allow in file ignore e.g. # flake8-in-file-ignores: noqa: E731.

Plugin to require absolute imports.

Checking the order of import statements and the __all__ list.

Enforce importing datetime as dt and time as tm.

Extension to check imports.

How certain packages should be imported or aliased.

Spoqa's import order style for flake8-import-order.

Include checks import order against various Python Style Guides.

Plugin to ensure explicit module imports.

Plugin that reports imports of protected names.

Extension that helps you write tidier imports.

Plugin lets you know which imports to move in or out of type-checking blocks.

Detect modules that can be lazy imported in Python 3.15+.

Lints tests against the Arrange Act Assert pattern.

Unittest assert method checker.

Provides checking mock non-existent methods.

Enforce the use of the spec argument on mocks ensuring that your use of mocks is compliant with the interface of the…

Checks for common style issues or inconsistencies with pytest-based tests.

Enforces to use pytest-style assertions.

Checks TestRail test case IDs.

Plugin to validate annotations coverage.

Plugin for flake8 to check for presence of type annotations in function definitions.

Verifies Python 3.7+ files use from __future__ import annotations.

Plugin to enforce new Union/Optional syntax Foo | Bar | None defined in PEP 604.

Enforce new style annotations from PEP585 such as list[int] instead of typing.List[int].

Forbids use of typing.Union (in favour of |), per PEP 604.

Plugin which checks that typing imports are properly guarded.

Plugin to lint for backwards incompatible database migrations in Django.

Plugin for Django projects.

Checks FastAPI code against opinionated style rules.

Plugin that facilitates code development with numba package.

Plugin to catch common issues on Scrapy spiders.

Plugin that provides opinionated linting for Pandas code.

Plugin for code that uses PyTorch.

Lints Python code blocks in Markdown files using flake8.

Runs flake8 on *.ipynb (Jupyter Notebook) files.

Plugin for Flake8 that provides specializations for type hinting stub files.

Checks on code in *.rst files or in docstrings.

Jupyterlab Python linter for notebooks and text files using flake8.

Wrapper around bandit.

Wrapper around black.

Wrapper around isort.

Wrapper around pylint.

Generates an HTML dashboard.

Generates pylint-style JSON output.

Generates GitHub annotation for PR's.

Generates GitLab Code Quality artifacts.

Generates an HTML report.

Generates JSON output.