29-Outils Modernes

29. Outils Modernes : uv, Ruff, ty, Pyrefly

L’écosystème Python 2026 : uv (projets/paquets), Ruff (lint/format), ty (Astral type checker), Pyrefly (Meta type checker + LSP).

---

29.1 uv — gestionnaire de projets et de paquets

uv d’Astral remplace pip, pip-tools, poetry, conda. Écrit en Rust, 10-100× plus rapide.

# Installation
curl -LsSf https://astral.sh/uv/install.sh | sh
# ou brew install uv

Projet

uv init mon_projet          # crée pyproject.toml + structure
cd mon_projet
uv add numpy                # ajoute et lock
uv add --dev pytest mypy    # dépendance de développement
uv sync                     # installe tout depuis uv.lock
uv lock                     # met à jour uv.lock

Exécution

uv run python script.py     # dans l'environnement du projet
uv run pytest               # sans activer le venv
uvx ruff check              # exécute un outil sans l'installer

Outils globaux

uv tool install ruff        # installe ruff globalement
uv tool list                # liste les outils installés
uvx ty check                # exécute ty sans installation

Python versions

uv python install 3.13      # télécharge et installe CPython
uv python list              # versions disponibles
uv python pin 3.12          # fixe la version du projet

Comparaison uv vs legacy

Opération	Legacy	uv
Installer	pip install	uv pip install (compatible) ou uv add (moderne)
Env. virtuel	python -m venv	uv venv (intégré)
Lock file	pip freeze > requirements.txt	uv lock → uv.lock
Outil temporaire	pip install && use && pip uninstall	uvx outil (éphémère)
Multi-versions	pyenv	uv python install (intégré)

---

29.2 ruff — linter et formateur

ruff d’Astral remplace flake8, isort, black, pyupgrade, pylint (partiellement). Écrit en Rust, 100-1000× plus rapide.

uv tool install ruff
# ou pip install ruff

Linting

ruff check .                 # linter (détection d'erreurs)
ruff check --fix .           # correction automatique
ruff check --select ALL .    # toutes les règles activées

# pyproject.toml
[tool.ruff]
target-version = "py313"
line-length = 100
 
[tool.ruff.lint]
select = ["E", "F", "I", "N", "W", "UP", "ANN", "B", "SIM", "ARG", "PERF"]
ignore = ["ANN101"]  # self: type annotation optionnelle
fixable = ["ALL"]
 
[tool.ruff.format]
quote-style = "double"
indent-style = "space"
line-ending = "lf"

Formatting

ruff format .                # formater tout le projet
ruff format --check .        # vérifier sans modifier
ruff format --diff .         # voir les changements

Règles populaires

Code	Signification	Remplace
E, W	Erreurs de style (pycodestyle)	flake8
F	Erreurs logiques (pyflakes)	flake8
I	Ordre des imports (isort)	isort
N	Conventions de nommage (pep8-naming)	flake8-naming
UP	Modernisation du code (pyupgrade)	pyupgrade
ANN	Annotations de type manquantes	flake8-annotations
B	Erreurs courantes (bugbear)	flake8-bugbear
SIM	Simplification de code	flake8-simplify
ARG	Arguments inutilisés	flake8-unused-arguments
PERF	Performance	perflint
RUF	Règles spécifiques à Ruff	—

Migration depuis black+isort+flake8

ruff check --fix .    # applique les corrections
ruff format .         # remplace black
# Supprimer black, isort, flake8 de pyproject.toml

---

29.3 ty — type checker Astral

ty (prononcé “ti-waï”) est un type checker et language server d’Astral, comme Ruff et uv. 10-100× plus rapide que mypy et Pyright.

uv tool install ty
# ou: uvx ty check

Utilisation

ty check .                    # vérifier tout le projet
ty check mon_fichier.py       # fichier unique
ty server                     # lancer le LSP (VS Code, Neovim...)

Configuration

# pyproject.toml
[tool.ty]
python-version = "3.13"
# Niveaux de règles: "error" (défaut), "warn", "suppress"
target-version = "py313"
 
[tool.ty.per-file-ignores]
"tests/**/*.py" = ["all"]  # désactiver dans les tests
"scripts/**/*.py" = ["all"]

Garantie graduelle

ty implémente une garantie graduelle : les modules non typés ne causent pas d’erreurs dans les modules typés. Contrairement à mypy qui peut paniquer sur Any importé.

# module_non_typé.py
def f(x):     # pas d'annotations
    return x * 2
 
# module_typé.py
from module_non_typé import f
result: int = f("hello")  # ty ne signale pas d'erreur (garantie graduelle)

Diagnostics riches

def get_user(id: int) -> str:
    return id  # ty: Expected type `str`, got `int` (return-type)

ty produit des messages d’erreur très détaillés, avec suggestions de correction.

Fonctionnalités avancées

• Reachability analysis : détection de code mort (if False:)
• Flow-sensitive typing : narrowing avancé après conditions
• Redeclarations : compatible avec les redéclarations de types (pratique pour l’adoption progressive)
• Pas de plugin : ty n’a pas de système de plugins (contrairement à mypy)

ty vs mypy

Critère	mypy	ty
Vitesse	Baseline	10-100× plus rapide
LSP intégré	dmypy (daemon séparé)	Serveur LSP natif
Garantie graduelle	Non	Oui
Complexité	20+ ans de legacy	Propre, moderne
Plugins	Oui (Django, Pydantic…)	Non (encore)

---

29.4 pyrefly — type checker Meta

Pyrefly est un type checker et language server en Rust développé par Meta (ex-Pyre). Utilisé en production sur Instagram (20M+ lignes).

pip install pyrefly
# ou: uv tool install pyrefly

Utilisation

pyrefly init                  # crée pyrefly.toml
pyrefly check .               # vérifier tout le projet
pyrefly check --fix .         # appliquer les corrections automatiques
pyrefly lsp                   # lancer le serveur LSP
pyrefly infer                 # ajouter les annotations automatiquement
pyrefly suppress              # silencer les erreurs existantes

Configuration

# pyrefly.toml
python_version = "3.13"
strict = false                # mode strict : toutes les erreurs activées
include = ["src/**/*.py"]
exclude = ["tests/**"]
 
[tool.pyrefly.per-file-ignores]
"**/__init__.py" = ["all"]

Performance

Pyrefly check 1.85 million de lignes par seconde. Exemple concrets :

Projet	mypy	Pyright	Pyrefly
PyTorch	~8 min	~70 s	~5 s
NumPy	~8 s	~70 s	~5 s

Tensor Shapes (expérimental)

Fonctionnalité unique : typer les dimensions des tenseurs PyTorch :

from pyrefly.tensor import Dim, Tensor
 
Batch = Dim["batch"]
Features = Dim["features"]
 
def normalize(x: Tensor[Batch, Features]) -> Tensor[Batch, Features]:
    mean = x.mean(dim=0)  # pyrefly infère: Tensor[Features]
    return x - mean

Pyrefly vs ty

Critère	ty (Astral)	Pyrefly (Meta)
Vitesse CLI	10-100× mypy	15× mypy (mais plus lent que ty)
Vitesse IDE incrémentale	4.7ms (PyTorch)	2.38s (PyTorch)
Garantie graduelle	Oui	Non
Framework support	Non (pas de plugins)	Pydantic, Django natif
Tensor shapes	Non	Oui (expérimental)
Conformance typing	Partielle	90%+ (1.0 stable)
Maturité	Beta	Stable (v1.0)
pyrefly infer	Non	Oui (auto-annotation)

---

29.5 Les autres outils

mypy — le pionnier (2012)

pip install mypy
mypy mon_fichier.py
mypy --strict mon_projet/

• Le plus mature, plus grande couverture de features
• Système de plugins (Django, Pydantic, SQLAlchemy)
• Lent sur les gros codebases
• dmypy pour le daemon (accélère les rechecks)

pyright / pylance — Microsoft

npm install -g pyright
pyright mon_fichier.py

• Rapide (mais derrière ty/pyrefly)
• Pylance = version VS Code (closed source)
• Bon support des frameworks
• Nécessite Node.js

basedpyright — fork open-source

pip install basedpyright

• Fork de Pyright avec plus de fonctionnalités
• Politique de version plus permissive
• Utilisable dans n’importe quel éditeur

---

29.6 Flux de travail complet

Nouveau projet

uv init mon_projet
cd mon_projet
uv add numpy torch
uv add --dev pytest ruff ty
# + VS Code : installer extensions Ruff, ty

Configuration complète pyproject.toml

[project]
name = "mon-projet"
version = "0.1.0"
requires-python = ">=3.13"
dependencies = [...]
 
[project.optional-dependencies]
dev = ["pytest", "ruff", "ty"]
 
[tool.ruff]
target-version = "py313"
line-length = 100
 
[tool.ruff.lint]
select = ["E", "F", "I", "N", "UP", "ANN", "B", "SIM"]
fixable = ["ALL"]
 
[tool.ty]
python-version = "3.13"
 
[tool.pytest.ini_options]
testpaths = ["tests"]

Scripts CI

# .github/workflows/ci.yml
- run: uv sync
- run: ruff check .
- run: ruff format --check .
- run: ty check src/
- run: pytest

Tâches Makefile

.PHONY: lint format typecheck test
 
lint:
    ruff check .
 
format:
    ruff format .
 
typecheck:
    ty check src/
 
test:
    pytest
 
all: lint format typecheck test

---

29.7 Résumé

Outil	Rôle	Alternative legacy	Auteur
uv	Projet + paquets + Python	pip+poetry+pyenv	Astral
Ruff	Linter + formateur	flake8+black+isort	Astral
ty	Type checker + LSP	mypy+pyright	Astral
Pyrefly	Type checker + LSP (infer, tensor shapes)	mypy+pyright	Meta

Recommandation : uv + ruff + ty (écosystème Astral unifié). Ajouter pyrefly si tu as besoin de l’auto-annotation (pyrefly infer), de la détection de formes de tenseurs PyTorch, ou si tu travailles avec Pydantic/Django.

---

🔗 ← Retour au cours · ← précédent · Suivant →