Ruff

Ruff is a high performance Python linter and formatter.

Ruff is both a Python tool and Python package. Think of it this way:

• Tool: A command-line utility used by developers.
• Package: A Python package that gets installed via pip.

Installing Ruff

$ pip install ruff

When you install it, you get the ruff command-line tool:

# To link a directory
$ ruff check .

# To format code
$ ruff format

So technically

ruff (python package)
          |  Installs
  ruff (CLI tool)

What Does Ruff Do?

• Ruff is an extremely fast Python code quality tool written in Rust.
• It combines functionality that traditionally requires multiple tools:

• It is designed to analyze Python code for errors, stylistic issues, and suspicious constructs, while also offering code formatting capabilities
• Rust is known for its speed, being 10-100x faster than traditional tools

Key Features

• Speed: Ruff is optimized for performance, making it suitable for larger codebases. For example, it can lint a 2,50,000-lines of codebase in under a second.
• Multi-Tool Replacement: It combines the functionality of tools like Flake8, Black, isort etc, reducing the need for multiple independencies.
• Error Detection and Auto-Fixing: Ruff can identify over 800 types of issues and automatically fix many of them, such as removing unused imports or reformatting code.
• Configuration Suport: Ruff supports configuration through below files, allowing users to customize linting and formatting rules.

- pyproject.toml
or
- ruff.toml
or 
- .ruff.toml

• Editor Integrations: It integrates seamlessly with editors like Visual Studio Code and can be used as pre-commit hook or GitHub action.

Example

Remove Unused Import

Consider this code:

# Filename: app.py

import os
import json

def hello():
    print("hello")

here json is unused.

Now, Run:

$ ruff check app.py

Output:

F401 `json` imported but unused

Lets auto fix it now. Run this code,

$ ruff check --fix app.py

Ruff automatically removes import json so now code will look like

# Filename: app.py

import os

def hello():
    print("hello")

Code Formatting

Ruff can also format code.

Before:

def add(a,b): return a+b

Run:

$ ruff format .

After:

def add(a,b): 
    return a+b

Configuration

Using pyproject.toml :

[tool.ruff]
line-length = 88
target-version = "py3111"

[tool.ruff.format]
quote-style = "single"

[tool.ruff.lint]
select = [
           "E",  # pycodestyle errots
           "F",  # Pyflakes
           "I",  # Import sorting
           "B"   # Bugbear checks
]
ignore = ["E501"] # ignore line-length errors

CI Pipeline

Ruff is commonly run as a quality gate in Github Actions or in any CI pipelines. The idea is simple:

• Developer pushes code
• Github Actions runs
• Ruff checks the code
• If issues are found, the CI jobs fails
• PR can not be merged until issues are fixed

Create:

<your-python-repo>
  .github/
        |___workflows/
            |___ci.yml
   src/
    |____pyproject.toml

name: Python CI

on:
   pull_request:
   push:
       branches:
         - main

jobs:
  quality_gate:
     runs-on: ubuntu-latest
     
     steps:
        - name: Checkout Code
          uses: actions/checkout@v4

        - name: Setup Python
          uses: actions/setup-python@v5
          with:
             python-version: "3.12"

        - name: Install Dependencies
          run: pip install -r requirements.txt

        - name: Ruff Check
          run: ruff check .

        - name: Format Check
          run: ruff format --check .

Extension

Visual Studio Code

The Ruff VS Code Extension is an official extension developed by Astral that integrates the blazing-fast Rust-based Python linter and formatter directly into your editor.

Key Features

• Extreme Speed: Executes tens or hundreds of times faster than traditional Python linters.
• Built-in Executable: Ships with a pre-bundled Ruff binary, meaning you don’t even have to install Ruff separately via pip.
• Unified Tooling: Handles error checking (linting), code formatting, and automatic import sorting.
• Quick Fix Actions: Cleans up unused imports or variables directly via the VS Code “Quick Fix” lightbulb.
• Notebook Support: Seamlessly lints and formats .ipynb cells inside Jupyter Notebooks.

Recommended Configuration

To get the most out of the extension, you should configure it to automatically organize imports and format your Python files every time you save. Open your user settings.json file in VS Code and append the following configuration:

{
  "[python]": {
    "editor.defaultFormatter": "charliermarsh.ruff",
    "editor.formatOnSave": true,
    "editor.codeActionsOnSave": {
      "source.organizeImports.ruff": "explicit",
      "source.fixAll.ruff": "explicit"
    }
  }
}

For more details check this link.