Категории правил

Ruff группирует правила в категории по префиксам. Каждый префикс соответствует определённому классу проверок — стиль, безопасность, типы, импорты и так далее. Это позволяет включать или отключать целые группы правил одной строкой конфигурации.

Всего в Ruff более 800 правил, объединённых в ~40 категорий. Категории (префиксы) используются в параметрах select, ignore, fixable и других, как вы уже знаете из урока 4.2.

Категория E — это ядро стилистических проверок. Они следят за соблюдением PEP 8 — официального руководства по стилю кода Python. Эти правила включены по умолчанию вместе с категорией F.

Что проверяет категория E:

• E101-E111 — отступы (пробелы vs табы)
• E201-E262 — пробелы вокруг операторов и скобок
• E301-E306 — количество пустых строк
• E401-E501 — импорты, длина строки
• E701-E742 — составные statements
• W — предупреждения (trailing whitespace, лишние пустые строки)

Самые частые правила:

# E501: line too long (> 88 символов по умолчанию)
x = "very long string that exceeds the maximum line length configured in ruff"  # E501

# E302: expected 2 blank lines before class/function definition
class MyClass:
    pass

# E225: missing whitespace around operator
x=1  # должно быть x = 1

# E111: indentation is not a multiple of 4
  print("wrong indent")  # 2 spaces вместо 4

# W291: trailing whitespace
print("hello")   # пробел в конце строки

Категория F (Pyflakes) — одна из самых важных. Она находит реальные логические ошибки в коде, которые могут привести к багам. Pyflakes известен своей скоростью и точностью — он не выполняет код, но находит проблемы статически.

# F401: imported but unused
import os  # F401 — os не используется

# F841: local variable assigned but never used
def foo():
    result = compute()  # F841 — result нигде не используется
    return "done"

# F811: redefinition of unused variable
def foo():
    x = 1
    x = 2  # F811 — x переопределён без использования

# F821: undefined name
print(undefined_var)  # F821 — имя не определено

# F601: dictionary key repeated
d = {"a": 1, "a": 2}  # F601 — ключ 'a' повторяется

# F403: from module import *
from math import *  # F403 — может конфликтовать с локальными именами

# F541: f-string without any placeholders
x = f"hello"  # F541 — f-string не нужен, можно обычную строку

Категория I заменяет популярный инструмент isort. Она проверяет порядок и группировку импортов согласно PEP 8 и настраиваемым правилам.

Порядок импортов по умолчанию:

1. Стандартная библиотека — os, sys, json, typing...
2. Третьесторонние библиотеки — django, requests, numpy...
3. Локальные модули — импорты из вашего проекта

# I001: Unsorted imports
# Плохо:
from myproject.models import User
import os
import django.db.models

# Хорошо:
import os
import django.db.models
from myproject.models import User

Настройка isort в Ruff:

[tool.ruff.lint]
# Включить сортировку импортов
extend-select = ["I"]

# Настройка порядка импортов
[tool.ruff.lint.isort]
known-third-party = ["django", "flask", "fastapi"]
known-first-party = ["myproject", "tests"]
required-imports = ["from __future__ import annotations"]
extra-standard-library = ["tomllib"]

Категория N проверяет соответствие имён переменных, функций, классов и констант правилам PEP 8:

# N801: класс должен быть CamelCase
class my_class:  # N801
    pass

# N802: функция должна быть snake_case
def MyFunction():  # N802
    pass

# N803: аргумент должен быть snake_case
def foo(MyArg):  # N803
    pass

# N806: константы — UPPER_CASE
my_constant = 42  # N806

Категория UP (pyupgrade) предлагает заменить устаревшие конструкции на современные синтаксические возможности Python. Это помогает поддерживать код в актуальном состоянии и использовать новые возможности языка.

Категория UP зависит от target-version — минимальной версии Python, которую вы поддерживаете:

[tool.ruff]
target-version = "py310"   # минимальная версия — Python 3.10

Примеры правил UP:

# UP006: typing.List/Dict → list/dict (Python 3.9+)
from typing import List
x: List[str] = []      # UP006 → x: list[str] = []

# UP007: Optional/Union → | (Python 3.10+)
from typing import Optional
def foo(x: Optional[str]):  # UP007 → def foo(x: str | None):
    pass

# UP008: super() without arguments
class Child(Parent):
    def __init__(self):
        super(Child, self).__init__()  # UP008 → super().__init__()

# UP009: UTF-8 encoding declaration (не нужно в Python 3)
# -*- coding: utf-8 -*-  # UP009 — удалить

# UP012: f-strings with datetime
f"Today is {datetime.now()}"  # UP012 → datetime.now().isoformat()

# UP018: float() → литерал
x = float(1)  # UP018 → x = 1.0

# UP024: replace os.path with pathlib
import os
os.path.join("a", "b")  # UP024 → Path("a") / "b"

# UP025: удалить лишние скобки в кортежах
x = (1 + 2)  # UP025 → x = 1 + 2

# UP031: printf-style → f-string (Python 3.6+)
name = "World"
print("Hello, %s" % name)  # UP031 → f"Hello, {name}"

# UP034: лишние скобки с return
def foo():
    return (x)  # UP034 → return x

Категория B (Bugbear) находит распространённые баги и анти-паттерны в Python-коде. Это одна из самых полезных категорий для production-проектов.

# B006: mutable argument default
def append(item, lst=[]):  # B006 → lst=None
    lst.append(item)
    return lst

# B007: loop variable not used
for i in range(10):  # B007 → for _ in range(10):
    print("hello")

# B008: function call in default argument
def create_user(name, time=datetime.now()):  # B008
    pass

# B009: getattr with constant
value = getattr(obj, "name")  # B009 → obj.name

# B010: setattr with constant
setattr(obj, "name", value)  # B010 → obj.name = value

# B011: assert False
assert False, "error"  # B011 → raise AssertionError или raise ValueError

# B012: return inside finally
def foo():
    try:
        return 1
    finally:
        return 2  # B012 — предыдущий return потерян

# B013: except with tuple
except (ValueError, TypeError):  # B013 → except (ValueError, TypeError):
    pass

# B014: duplicate exception in except
except (ValueError, ValueError):  # B014

# B015: useless comparison
x == 1  # B015 — сравнение без использования

# B016: raise with exception instance
raise ValueError  # B016 → raise ... from ...

Категория S (Bandit) проверяет код на уязвимости безопасности: hardcoded пароли, SQL-инъекции, небезопасные вызовы и другие проблемы.

# S101: use of assert (может быть отключено в production)
assert user.is_admin  # S101

# S102: exec used
exec(code)  # S102 — exec опасен

# S103: eval used
eval("1+1")  # S103 — eval опасен

# S104: hardcoded binding to all interfaces
app.run(host="0.0.0.0")  # S104

# S105: hardcoded password
PASSWORD = "super-secret"  # S105

# S106: hardcoded password (named)
DB_PASSWORD = "password123"  # S106

# S107: hardcoded password in function
def login(password="admin123"):  # S107
    pass

# S108: hardcoded temporary directory
TEMP = "/tmp"  # S108

# S324: subprocess with shell=True
import subprocess
subprocess.run("ls", shell=True)  # S324 — shell injection risk

# S501: request without verification
import requests
requests.get("https://example.com", verify=False)  # S501

# S701: jinja2 with autoescape=False
import jinja2
jinja2.Environment(autoescape=False)  # S701

Ruff включает большую часть правил Pylint (~200 правил с префиксом PL). Pylint — один из самых старых и всесторонних линтеров для Python, но он известен своей медлительностью. Ruff реализует его правила со скоростью Ruff.

# PLR0911: too many return statements
def foo():
    if a: return 1
    if b: return 2
    if c: return 3  # PLR0911

# PLR0913: too many function arguments
def foo(a, b, c, d, e, f):  # PLR0913
    pass

# PLR0915: too many statements
def foo():
    # много строк...
    pass  # PLR0915

# PLC3001: unnecessary lambda
sorted(x, key=lambda a: a.name)  # → attrgetter

# PLR1704: redefined argument name
def foo(x):
    x = 1  # PLR1704

# PLW0120: useless else on loop
for x in items:
    if condition:
        break
else:  # PLW0120 — else не нужен, т.к. без break он всегда выполняется
    print("not found")

Категория RUF содержит правила, созданные специально для Ruff. У них нет аналогов в других инструментах. Эти правила решают проблемы, характерные именно для экосистемы Ruff, или предлагают уникальные проверки.

# RUF100: unused noqa directive
import os  # noqa: F401  # RUF100 — F401 не срабатывает, noqa не нужен

# RUF001: ambiguous unicode character
print("книга")  # RUF001 — если строка содержит кириллицу в ASCII контексте

# RUF002: ambiguous unicode character in docstring
def foo():
    """Описание с кириллицей."""  # RUF002

# RUF003: ambiguous unicode character in comment
# комментарий с кириллицей  # RUF003

# RUF005: use of collections.abc instead of typing
from typing import Iterable  # RUF005 → from collections.abc import Iterable

# RUF006: asyncio.sleep(0) → await asyncio.sleep(0)
import asyncio
asyncio.sleep(0)  # RUF006 → await asyncio.sleep(0)

# RUF010: use of explicit f-string conversion
f"{value!r}"  # RUF010 — можно repr(value)

# RUF012: mutable class attribute
class Foo:
    items = []  # RUF012 — mutable class attribute

SIM — flake8-simplify (упрощение)

# SIM101: duplicate isinstance
if isinstance(x, int) or isinstance(x, float):  # SIM101
    ...

# SIM102: nested if → single if with and
if a:
    if b:  # SIM102 → if a and b:
        pass

# SIM103: unnecessary else after return
def foo():
    if x:
        return True
    else:  # SIM103
        return False

# SIM108: if-else → ternary
if x:
    y = 1
else:  # SIM108 → y = 1 if x else 2
    y = 2

# SIM115: open → Path.open
file = open("file.txt")  # SIM115 → Path("file.txt").open()

ANN — flake8-annotations (типы)

# ANN001: missing type for function argument
def foo(x):  # ANN001 → def foo(x: int):
    pass

# ANN201: missing return type for public function
def foo():  # ANN201 → def foo() -> str:
    return "hello"

# ANN202: missing return type for private function
def _foo():  # ANN202 → def _foo() -> str:
    return "hello"

# ANN401: Any → avoid Any
from typing import Any
def foo(x: Any):  # ANN401 — лучше использовать конкретный тип
    pass

T20 — flake8-print

# T201: print statement in production
print(f"User {user} not found")  # T201 — используй logging

PT — flake8-pytest-style

# PT001: pytest fixtures should use (scope="...")
@pytest.fixture
def user():  # PT001 → @pytest.fixture()
    pass

# PT009: unittest-style assert
assert something == True  # PT009 → assert something

# PT022: no teardown in fixture with yield
@pytest.fixture
def db():
    conn = connect()
    yield conn
    # PT022 — нет conn.close()

C90 — mccabe (цикломатическая сложность)

# C901: function is too complex (по умолчанию > 10)
def very_complex_function():  # C901
    if a:
        for b in c:
            while d:
                if e:
                    # ...
    # сложность > 10

Настройка порога сложности:

[tool.ruff.lint.mccabe]
max-complexity = 15  # по умолчанию 10

D — pydocstyle (документация)

# D100: missing docstring in public module
# D101: missing docstring in public class
# D102: missing docstring in public method
# D103: missing docstring in public function
# D104: missing docstring in public package
# D105: missing docstring in magic method
# D107: missing docstring in __init__

class Calculator:  # D101
    def add(self, x, y):  # D102
        return x + y

Ruff поддерживает все основные стили docstring:

• Google-style
• NumPy-style
• Sphinx-style (reStructuredText)
• PEP 257

[tool.ruff.lint.pydocstyle]
convention = "google"  # google, numpy, pep257 (по умолчанию)

Ruff предоставляет удобные CLI-команды для просмотра документации правил и категорий.

ruff rule — детали конкретного правила

ruff rule F401

# Вывод:
# F401: module-imported-but-unused (Pyflakes)
# A module is imported but not used.
# 
# Пример:
# import os  # F401
# 
# Автоисправление: Safe (удаляет неиспользуемый импорт)

Что показывает ruff rule:

• Код и название правила
• Категорию, к которой относится правило
• Описание нарушения
• Пример кода
• Тип автоисправления (safe / unsafe / none)

ruff rule --all — все правила

ruff rule --all   # очень длинный список

# Фильтрация по категории через grep:
ruff rule --all | grep "^F"      # только Pyflakes
ruff rule --all | grep "^UP"     # только pyupgrade
ruff rule --all | grep "^PLR"    # только Pylint Refactoring

Пример: найти правило для вашей задачи

# Найти все правила, связанные с "except"
ruff rule --all | grep -i "except"

# Найти все правила с автоисправлением
ruff rule --all | grep "Safe fix"

# Найти правила для pandas
ruff rule --all | grep "^PD"

# Сколько всего правил в категории?
ruff rule --all | grep "^B" | wc -l