flake8-expression-complexity

What it is and what it does

flake8-expression-complexity is a linter plugin that automatically flags expressions in your Python code that exceed a complexity threshold. It integrates directly into flake8's workflow, scoring each expression and raising an ECE001 error when complexity exceeds the configured limit (default 7). This helps catch hard-to-read conditional chains, nested operations, and other expressions that may reduce code maintainability.

The tool is particularly useful in Django projects, where ORM queries can produce long but readable expressions; you can optionally exclude those from complexity checks via a command-line flag. Configuration is straightforward through flake8's standard `--max-expression-complexity` option. The package is actively maintained, supports Python 3.10 through 3.14, and carries no known security vulnerabilities.

Use it for:

• Enforce a team code-style rule that flags overly complex conditional expressions in pull request reviews.
• Automatically detect and refactor deeply nested boolean logic in legacy codebases.
• Configure stricter complexity thresholds in critical modules while relaxing them in Django query-heavy code.
• Integrate into CI/CD pipelines to prevent commits with expressions exceeding a project's complexity budget.
• Identify readability hotspots in conditional chains that would benefit from helper functions or intermediate variables.

Worth the install?

AI-flagged interpretation of the facts on this page — verify before relying

A flake8 extension that detects overly complex expressions in Python code and reports them as style violations, with configurable thresholds and optional Django ORM query exemption.

Yes. This is a lightweight, well-maintained linter plugin with no security issues, permissive licensing, and a clear, narrow purpose. Install it if your team values expression readability and wants automated enforcement; the low friction and active maintenance make it a safe addition to any flake8 setup. Skip it only if your codebase already has strong code-review discipline around complexity or if you prefer other linting approaches.

Install

flake8-expression-complexity on PyPI

pip install flake8-expression-complexity

uv add flake8-expression-complexity

poetry add flake8-expression-complexity

Installing flake8-expression-complexity

Before you install

Low friction installation as a pure Python wheel with a single runtime dependency on flake8. Actively maintained with a recent release and no known vulnerabilities.

License in practice

MIT license permits unrestricted use, modification, and distribution with minimal restrictions—suitable for any project.

Quickstart

pip install flake8-expression-complexity

# Then run flake8 with optional configuration:
flake8 --max-expression-complexity=7 your_code.py
# or to skip Django ORM queries:
flake8 --max-expression-complexity=7 --ignore-django-orm-queries-complexity your_code.py

Requires Python 3.10 or later.

Verify before relying

• How expression complexity is actually scored (the algorithm or heuristic used beyond the example shown).
• Whether the Django ORM query exemption works reliably across common query patterns.
• Performance impact on large codebases or deeply nested expressions.

Package facts

Evidence: flake8_expression_complexity-0.1.1-py3-none-any.whl

Keywords: flake8

Tags

More Python Modules packages