Le Gestionnaire de dépendances UV

Mise à jour : 25/11/2024

Si tu as déjà été frustré par la gestion des dépendances Python, uv pourrait bien devenir ton nouvel outil préféré. Rapide, moderne et conçu pour simplifier la vie des développeurs, uv permet de gérer facilement les versions de Python, les environnements et les paquets. À mon avis, c’est un vrai pas en avant par rapport aux classiques comme pip ou poetry, surtout pour les projets qui exigent flexibilité et efficacité. Alors, pourquoi ne pas jeter un œil et voir ce qu’il peut offrir ?

Origine de uv

uv n’est pas juste un autre outil dans l’écosystème Python, c’est une réponse aux défis que rencontrent les développeurs au quotidien. À l’origine, il est né de l’insatisfaction face aux limites des gestionnaires de dépendances traditionnels comme pip et poetry. Bien qu’efficaces, ces outils souffrent parfois d’un manque de flexibilité ou d’une configuration complexe.

Avec uv, les créateurs avaient une idée claire : proposer un gestionnaire rapide, léger et capable de détecter automatiquement les versions de Python disponibles sur un système. C’est là où il se distingue. Inspiré par des outils modernes dans d’autres écosystèmes, comme npm pour Node.js, uv apporte une expérience simplifiée pour les développeurs Python.

À mes yeux, c’est ce focus sur l’expérience utilisateur qui le rend si intéressant. Il s’intègre parfaitement dans les flux de travail existants, tout en éliminant les frictions habituelles. Si tu as déjà bataillé avec des fichiers de configuration incompréhensibles ou des erreurs liées aux versions de Python, tu comprendras vite pourquoi uv fait parler de lui.

Les fonctionnalités principales de uv

uv brille par ses nombreuses fonctionnalités, pensées pour simplifier la vie des développeurs Python. Voici les principales :

Gestion des environnements Python : Télécharge, crée et configure des environnements isolés pour chaque projet sans effort.
Installation rapide des paquets : Installe les dépendances en un clin d’œil grâce à un système optimisé.
Détection automatique des versions de Python : Repère automatiquement toutes les versions de Python disponibles sur ton système. (Documentation ↗).
Support des hooks : Ajoute des scripts personnalisés pour automatiser les tâches lors de l’installation des dépendances.
Compatibilité avec d’autres outils : Intègre facilement des projets existants, qu’ils soient configurés avec pip, poetry, ou autres.
Exportation et partage simplifiés : Permet de générer des fichiers de dépendances pour partager ou reproduire un environnement.
Performance accrue : Conçu pour être rapide, même avec des projets complexes.

Installation de uv : de multiples options

L’un des gros avantages de uv, c’est sa flexibilité, même au niveau de l’installation. Peu importe ton système ou ta méthode de travail, tu trouveras une façon d’installer uv qui correspond à tes besoins. Voici les principales méthodes disponibles :

Installation avec pip

La méthode la plus courante et universelle pour installer uv est d’utiliser pip, le gestionnaire de paquets Python. Si tu as Python configuré correctement, il te suffit d’exécuter :

pip install uv

C’est simple, rapide et adapté à la plupart des environnements. Si tu rencontres des problèmes de permissions, ajoute l’option --user pour éviter de modifier les fichiers système :

pip install --user uv

Installation via Homebrew (macOS/Linux)

Si tu es sur macOS ou Linux et que tu utilises Homebrew, tu peux également installer uv directement via cet outil. Cela peut être une méthode plus simple pour gérer les dépendances système.

Commande d’installation avec Homebrew :

brew install astral-sh/tap/uv

Compilation depuis les sources

Pour les utilisateurs avancés ou ceux qui veulent toujours la version la plus récente de uv, il est possible de cloner le dépôt GitHub et de compiler uv depuis les sources.

Étapes pour compiler :

Clone le dépôt :

git clone https://github.com/astral-sh/uv.git
cd uv

Installe avec pip depuis les sources :
Terminal window
```
pip install .
```

À mon avis, cette diversité d’options montre à quel point uv est pensé pour s’adapter à toutes les situations. Que tu sois un développeur sur un Mac flambant neuf, un utilisateur Linux minimaliste ou un fan des conteneurs Docker, il y a toujours une solution adaptée pour installer uv.

Gestion des versions de Python

A la manière de pyenv, uv permet de télécharger des versions spécifiques de pythons.

Pour cela, on utilise la commande python suivie de l’option list :

uv python list

cpython-3.13.0+freethreaded-linux-x86_64-gnu    <download available>
cpython-3.13.0-linux-x86_64-gnu                 /home/bob/.local/share/uv/python/cpython-3.13.0-linux-x86_64-gnu/bin/python3.13
cpython-3.12.7-linux-x86_64-gnu                 /home/bob/.local/share/uv/python/cpython-3.12.7-linux-x86_64-gnu/bin/python3.12
cpython-3.12.3-linux-x86_64-gnu                 /usr/bin/python3.12
cpython-3.12.3-linux-x86_64-gnu                 /usr/bin/python3 -> python3.12
cpython-3.12.3-linux-x86_64-gnu                 /bin/python3.12
cpython-3.12.3-linux-x86_64-gnu                 /bin/python3 -> python3.12
cpython-3.11.10-linux-x86_64-gnu                <download available>
cpython-3.10.15-linux-x86_64-gnu                <download available>
cpython-3.9.20-linux-x86_64-gnu                 <download available>
cpython-3.8.20-linux-x86_64-gnu                 <download available>
cpython-3.7.9-linux-x86_64-gnu                  <download available>
pypy-3.10.14-linux-x86_64-gnu                   <download available>
pypy-3.9.19-linux-x86_64-gnu                    <download available>
pypy-3.8.16-linux-x86_64-gnu                    <download available>
pypy-3.7.13-linux-x86_64-gnu                    <download available>

Vous remarquez que j’ai déjà téléchargé plusieurs versions de python et en plus uv détecte les versions installées avec d’autres méthodes. Pour lister toutes les versions disponibles ajouter l’option --all-versions.

Pour télécharger une nouvelle version, utilisez la commande install :

uv python install cpython-3.11.10-linux-x86_64-gnu

Si une version spécifique est requise pour un projet, utilisez la commande pin. Cela crée un fichier .python-version.

uv python pin python3.11.10

Gestion de projets

uv simplifie la création et la gestion de projets Python en offrant des commandes intuitives et une structure claire. Voici comment tirer parti de ses fonctionnalités pour gérer efficacement vos projets.

Création d’un nouveau projet

Pour initier un nouveau projet, utilisez la commande suivante :

uv init nom_du_projet

Cette commande génère une structure de base comprenant :

pyproject.toml : fichier de configuration du projet.
README.md : fichier de documentation initial.
.python-version : spécifie la version de Python à utiliser.
hello.py : script Python d’exemple.

Par défaut, uv crée un projet de type application.

Création d’une application packagée

Si vous envisagez de distribuer votre application ou d’ajouter des tests, optez pour une application packagée :

uv init --package nom_de_l_application

Cette commande crée une structure avec un répertoire src contenant le code source et définit un système de build dans pyproject.toml.

Création d’une bibliothèque

Pour développer une bibliothèque destinée à être partagée ou publiée, utilisez :

uv init --lib nom_de_la_bibliotheque

Cette commande génère une structure adaptée aux bibliothèques, avec un répertoire src et une configuration prête pour la distribution.

Gestion des dépendances avec uv

uv simplifie la gestion des dépendances dans vos projets Python en offrant des commandes intuitives et une structure claire. Voici comment tirer parti de ses fonctionnalités pour gérer efficacement vos dépendances.

Ajouter une dépendance

Pour ajouter une nouvelle dépendance à votre projet, utilisez la commande suivante :

uv add nom_du_paquet

Cette commande met à jour le fichier pyproject.toml en ajoutant le paquet spécifié à la section des dépendances du projet.

Pour ajouter une dépendance pour le développement, il faut utiliser l’option --dev.

Supprimer une dépendance

Si vous souhaitez retirer une dépendance devenue obsolète ou inutile, exécutez :

uv remove nom_du_paquet

Cette action supprime le paquet concerné du fichier pyproject.toml et de l’environnement virtuel associé.

Mettre à jour une dépendance

Pour modifier les contraintes de version d’une dépendance existante, par exemple en ajoutant une version minimale :

uv add 'nom_du_paquet>=version_minimale'

Cette commande ajuste les spécifications de version dans pyproject.toml.

Si vous souhaitez forcer la mise à jour du paquet vers la dernière version compatible avec les contraintes définies, ajoutez l’option --upgrade-package :

uv add 'nom_du_paquet>=version_minimale' --upgrade-package nom_du_paquet

Gérer les dépendances spécifiques à une plateforme

Pour installer une dépendance uniquement sur une plateforme spécifique, utilisez les marqueurs d’environnement Python. Par exemple, pour installer un paquet uniquement sur Linux :

uv add 'nom_du_paquet; sys_platform == "linux"'

Cette commande ajoute la dépendance avec un marqueur indiquant qu’elle ne doit être installée que sur les systèmes Linux.

Verrouillage des dépendances

Le fichier uv.lock est essentiel pour garantir que les mêmes versions des dépendances soient installées sur différents systèmes ou environnements. Lorsque vous exécutez :

uv lock

uv régénère ce fichier pour s’assurer qu’il reflète l’état actuel des dépendances, y compris leurs sous-dépendances.

Installation depuis le fichier de verrouillage

Pour garantir que votre environnement est identique à celui décrit dans uv.lock, installez les dépendances verrouillées avec :

uv sync

Cette commande installe précisément les versions spécifiées dans uv.lock, ce qui évite les erreurs dues à des incompatibilités de versions.

Exécution de commandes avec uv

Avec uv, l’exécution de commandes dans un environnement Python est simple, efficace, et parfaitement isolée. Voici comment utiliser cette fonctionnalité pour lancer des scripts, des outils, ou toute commande Python dans le cadre de votre projet.

Pour exécuter un script Python en utilisant l’environnement configuré par uv, il suffit d’utiliser la commande uv run :

uv run script.py

uv permet également d’exécuter toute commande ou outil disponible dans l’environnement virtuel du projet. Par exemple, pour lancer un serveur local :

uv run python -m http.server

Pour simplifier l’exécution de tâches répétitives, vous pouvez définir des commandes personnalisées dans le fichier pyproject.toml. Ajoutez une section [tool.uv.scripts] comme suit :

[tool.uv.scripts]
serve = "python -m http.server"
test = "pytest"

Ensuite, pour exécuter ces commandes, il suffit d’utiliser :

uv run serve
uv run test

uv prend également en charge l’ajout de conditions à vos scripts. Par exemple, vous pouvez définir un script qui s’exécute uniquement sur un système Linux :

[tool.uv.scripts]
linux_only = 'python my_script.py; sys_platform == "linux"'

Si vous exécutez ce script sur une autre plateforme, uv ignorera simplement la commande.

Construction et distribution de projets avec uv

uv simplifie le processus de construction et de distribution de vos projets Python, en vous permettant de créer des distributions source et binaire prêtes à être partagées ou déployées. Voici comment procéder :

Pour générer les distributions de votre projet, utilisez la commande suivante :

uv build

Par défaut, uv construit le projet dans le répertoire courant et place les artefacts générés dans un sous-répertoire dist/. Après exécution, vous devriez voir des fichiers tels que :

dist/
├── votre_projet-0.1.0-py3-none-any.whl
└── votre_projet-0.1.0.tar.gz

Ces fichiers représentent respectivement la distribution binaire (wheel) et la distribution source de votre projet.

Si vous souhaitez construire uniquement une distribution source ou binaire, uv offre des options dédiées :

Pour une distribution source uniquement :
Terminal window
```
uv build --sdist
```
Pour une distribution binaire uniquement :
Terminal window
```
uv build --wheel
```

Ces commandes vous permettent de contrôler précisément le type de distribution que vous souhaitez générer.

Gestion des espaces de travail avec uv

uv offre une fonctionnalité puissante appelée espaces de travail (workspaces), inspirée du concept de Cargo ↗, le gestionnaire de paquets de Rust. Un espace de travail est une collection de plusieurs paquets, appelés membres, gérés ensemble au sein d’un même projet. Cette approche est particulièrement utile pour organiser de grands projets en plusieurs paquets partageant des dépendances communes.

Pour créer un espace de travail, ajoutez une section [tool.uv.workspace] dans le fichier pyproject.toml du projet racine. Cette section doit spécifier les membres de l’espace de travail à l’aide des clés members (obligatoire) et exclude (optionnelle) :

[tool.uv.workspace]
members = ["packages/*"]
exclude = ["packages/seeds"]

Dans cet exemple, tous les projets situés sous le répertoire packages seront inclus en tant que membres de l’espace de travail, à l’exception de packages/seeds. Chaque membre doit contenir son propre fichier pyproject.toml.

Les dépendances entre les membres de l’espace de travail peuvent être définies dans la section [tool.uv.sources] du fichier pyproject.toml du projet racine. Par exemple, si le projet principal albatross dépend du membre bird-feeder :

[tool.uv.sources]
bird-feeder = { workspace = true }

Cette configuration indique que la dépendance bird-feeder doit être résolue au sein de l’espace de travail, plutôt que d’être récupérée depuis un registre externe.

Conclusion

Après quelques heures d’utilisation, uv semble être un outil puissant et moderne pour gérer des projets Python. Que ce soit pour créer des environnements, verrouiller des dépendances, exécuter des commandes, ou gérer des espaces de travail complexes, uv offre une solution complète, rapide, et flexible.

À mon avis, ce qui distingue uv, c’est sa capacité à simplifier des tâches souvent fastidieuses, tout en assurant une reproductibilité et une modularité exemplaires. Grâce à des fonctionnalités comme le verrouillage des versions, la gestion des workspaces, ou encore l’intégration facile des outils existants, uv s’intègre parfaitement dans les workflows des développeurs, qu’ils soient débutants ou expérimentés.

Je vous encourage à essayer uv dans vos projets. Avec un peu de pratique, vous verrez rapidement comment il peut transformer votre manière de gérer vos dépendances et vos environnements Python.

Pour approfondir vos connaissances, consultez la documentation officielle ↗ et n’hésitez pas à explorer son potentiel au quotidien. 🚀