Radon

6.0.1 · active · verified Thu Apr 09

Radon is a Python tool that computes various metrics from the source code, including McCabe's cyclomatic complexity, raw metrics (SLOC, comment lines, blank lines), Halstead metrics, and the Maintainability Index. It can be used via the command line or programmatically through its API. The current version is 6.0.1, released in March 2023, and it maintains a consistent release cycle with several minor and patch updates annually.

Warnings

breaking Python 2.6 is no longer supported since Radon version 2.0.0. Projects still using Python 2.6 will need to use an older Radon version (<= 1.5.0) or upgrade their Python environment.
Fix: Upgrade Python to 2.7+ or 3.4+. For older Python 2.x projects, pin `radon<2.0.0`.
gotcha On Windows, if your Python files contain Unicode characters and your system's default encoding is not UTF-8, Radon might encounter encoding issues.
Fix: Set the `RADONFILESENCODING` environment variable to `UTF-8` before running Radon, e.g., `set RADONFILESENCODING=UTF-8` in CMD or `$env:RADONFILESENCODING='UTF-8'` in PowerShell.
breaking Radon's total complexity calculation for classes was fixed in version 3.0.0, which might lead to different (more accurate) results compared to previous versions.
Fix: Review your CI/CD thresholds if upgrading from pre-3.0.0 versions, as complexity scores for classes might change.
breaking Support for `flake8 < 3.x` was dropped in version 5.0.1, leading to the removal of the `flake8-polyfill` dependency. This was temporarily added back in 4.5.2 and then definitively removed.
Fix: Ensure `flake8` version is 3.x or higher when using Radon's Flake8 plugin.

Install

pip install radon Basic Installation
pip install radon[toml] For pyproject.toml support (Python < 3.11)
pip install nbformat For Jupyter Notebooks support

Imports

cc_visit
```
from radon.complexity import cc_visit
```
For calculating Cyclomatic Complexity programmatically.
mi_visit
```
from radon.metrics import mi_visit
```
For calculating Maintainability Index programmatically.
analyze
```
from radon.raw import analyze
```
For calculating raw metrics (SLOC, comments, etc.) programmatically.
h_visit
```
from radon.halstead import h_visit
```
For calculating Halstead metrics programmatically.

Quickstart

This quickstart demonstrates how to use `radon.complexity.cc_visit` to programmatically analyze Python code for cyclomatic complexity. It shows how to pass a string of code and iterate through the detected code blocks, printing their name, complexity score, and rank.

from radon.complexity import cc_visit

def my_complex_function(x, y):
    if x > 0 and y < 10:
        return x * y
    elif x < 0 or y > 20:
        return x + y
    else:
        return 0

code = """
def example_function(a, b):
    if a > 0:
        if b < 0:
            return a - b
        else:
            return a + b
    else:
        return 0
"""

# Analyze a string of code
complexity_blocks = cc_visit(code)
for block in complexity_blocks:
    print(f"Function: {block.name}, Complexity: {block.real_cc}, Rank: {block.rank}")

# Or analyze a function object directly (Radon works on AST nodes, so you'd typically parse a file or string first)
# For a direct function object like my_complex_function, you would need to parse its source:
import inspect
function_code = inspect.getsource(my_complex_function)
complexity_for_func_obj = cc_visit(function_code)
for block in complexity_for_func_obj:
    print(f"Function: {block.name}, Complexity: {block.real_cc}, Rank: {block.rank}")

view raw JSON →