---
id: flake8-expression-complexity
version: "0.1.1"
license: MIT
license_treatment: permissive
maintenance: active
---

# flake8-expression-complexity — A flake8 extension that checks expressions complexity

License: permissive · Maintenance: active · Downloads: 341.5K/mo

## 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 above — 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

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

- License: MIT (permissive)
- Python support: supports_current
- Install friction: low
- Maintenance: active
- Downloads: 341.5K/month (top 15,000 on PyPI)
- Known vulnerabilities: none known

## Tags

flake8 expression complexity checker, code complexity linter, expression complexity analysis, flake8 extension, python code quality, detect complex expressions, flake8 plugin, linter, flake8-plugin, code-quality

[View on SkillFed](https://skillfed.io/packages/flake8-expression-complexity) · [View on PyPI](https://pypi.org/project/flake8-expression-complexity/)