Python UV : Le guide ultime du gestionnaire de paquets Python le plus rapide

Qu'est-ce que Python UV ?

UV est un gestionnaire de paquets et un installateur Python moderne et performant écrit en Rust. Il sert de remplacement direct aux outils traditionnels de gestion de paquets Python tels que pip, offrant des améliorations significatives en termes de vitesse, de fiabilité et de résolution des dépendances.

Cet outil représente une nouvelle génération de gestionnaires de paquets Python, conçus pour répondre aux points douloureux communs de l'écosystème Python, tels que la lenteur des installations, les conflits de dépendances et la complexité de la gestion de l'environnement. UV y parvient grâce à son architecture innovante et à sa mise en œuvre efficace, ce qui le rend 10 à 100 fois plus rapide que les gestionnaires de paquets traditionnels.

Les principales caractéristiques qui distinguent l'UV :

• Installation des paquets et résolution des dépendances à la vitesse de l'éclair
• Compatible avec les outils et flux de travail Python existants
• Gestion intégrée de l'environnement virtuel
• Soutien aux normes modernes d'emballage
• Verrouillage fiable des dépendances et environnements reproductibles
• Fonctionnement économe en mémoire, en particulier pour les projets de grande envergure

Que vous travailliez sur de petits projets personnels ou que vous gériez des applications Python à grande échelle, UV fournit une solution robuste et efficace pour la gestion des paquets. Dans ce tutoriel, nous allons couvrir tous les aspects essentiels de l'UV afin que vous puissiez commencer à l'utiliser immédiatement.

La différence entre UV, Poetry, PIP, Conda et virtualenv

La première question que les développeurs se posent souvent avant d'adopter un nouvel outil est la suivante : "Comment se situe-t-il par rapport à celui que j'utilise déjà ? Dans le domaine de la gestion des dépendances et des projets Python, ces quatre outils sont déjà les plus répandus :

• PIP
• Poetry
• Conda
• virtualenv

Comparons UV avec chacun de ces outils pour vous aider à décider si UV est le bon choix pour vos besoins avant de plonger dans les détails.

UV vs. PIP et virtualenv

PIP et virtualenv sont les outils traditionnels pour la gestion des paquets Python et la création d'environnements virtuels. Bien qu'ils soient efficaces, les UV offrent plusieurs avantages convaincants :

• La vitesse : L'implémentation Rust d'UV le rend nettement plus rapide que PIP pour l'installation des paquets et la résolution des dépendances, réalisant souvent en quelques secondes des tâches qui prendraient des minutes à PIP.
• Gestion intégrée de l'environnement : Alors que virtualenv ne gère que la création d'environnement et que PIP ne gère que la gestion des paquets, UV combine les deux fonctionnalités en un seul outil, rationalisant ainsi le flux de travail.

UV maintient une compatibilité totale avec l'écosystème de PIP tout en tenant compte de ses principales limitations. Il peut utiliser les mêmes fichiers requirements.txt et les mêmes index de paquets, ce qui rend la migration transparente. Les principales différences sont les suivantes :

• Performance: Les téléchargements parallèles et le résolveur de dépendances optimisé d'UV le rendent 10 à 100 fois plus rapide que PIP pour les projets de grande envergure.
• Utilisation de la mémoire: UV utilise beaucoup moins de mémoire que PIP lors de l'installation des paquets et de la résolution des dépendances.
• Gestion des erreurs: UV fournit des messages d'erreur plus clairs et une meilleure résolution des conflits lorsque les dépendances sont incompatibles.
• Reproductibilité: L'approche du fichier de verrouillage d'UV garantit des environnements cohérents entre différents systèmes, ce qui n'est pas le cas avec les fichiers de base requirements.txt.

Si PIP et virtualenv restent des options viables, l'architecture moderne et les fonctionnalités combinées d'UV en font une alternative intéressante pour les développeurs à la recherche de meilleures performances et d'un flux de travail plus rationalisé. La possibilité de déposer l'UV dans des projets existants sans perturber les processus établis la rend particulièrement attrayante pour les équipes qui cherchent à moderniser progressivement leur chaîne d'outils de développement Python.

UV vs. Conda

Les personnes qui n'utilisent pas PIP et virtualenv se tournent généralement vers Conda, et elles ont de bonnes raisons de le faire :

• Conda fournit une solution complète de gestion des paquets qui gère non seulement les paquets Python, mais aussi les dépendances au niveau du système
• Il excelle dans la gestion d'environnements de calcul scientifique complexes avec des packages tels que NumPy, SciPy et TensorFlow.
• Les environnements Conda sont plus isolés et reproductibles sur différents systèmes d'exploitation.
• Il dispose d'une prise en charge intégrée des différentes versions de Python et peut passer de l'une à l'autre facilement
• La distribution Anaconda est livrée avec de nombreux paquets scientifiques préinstallés, ce qui est pratique pour les scientifiques des données.

Mais même les utilisateurs inconditionnels de Conda devraient envisager de passer à l'UV pour diverses raisons. L'installation rapide des paquets et la résolution des dépendances d'UV peuvent accélérer considérablement l'installation de l'environnement par rapport aux performances parfois léthargiques de Conda. Son empreinte minimale sur les ressources signifie une utilisation réduite de la mémoire et des démarrages plus rapides. UV s'intègre également de manière transparente aux normes et outils d'empaquetage Python existants, ce qui facilite la collaboration avec l'écosystème Python au sens large. Pour les projets qui ne nécessitent pas la gestion des paquets non Python de Conda, UV fournit une solution plus rationalisée et efficace qui peut améliorer considérablement les flux de développement.

UV vs. Poésie

J'ai été un utilisateur de Conda pendant près de trois ans, mais après avoir essayé Poetry quelques fois, je n'ai plus jamais touché à Conda à vitesse de tortue. Alors que je commençais à me sentir à l'aise avec la poésie, j'ai découvert l'UV, qui semble promettre pratiquement les mêmes choses que la poésie :

• Gestion de la dépendance: Les deux outils gèrent efficacement les dépendances des paquets et les environnements virtuels
• Structure du projet: Tous deux fournissent des outils pour initialiser et structurer les projets Python
• Verrouillez les fichiers: Tous deux génèrent des fichiers de verrouillage afin de garantir des environnements reproductibles
• Édition de paquets: Les deux permettent de publier des paquets sur PyPI
• Outillage moderne: Les deux représentent des approches modernes de la gestion de projets Python

Cependant, la caractéristique principale de l'UV est sa vitesse fulgurante et son utilisation minimale des ressources. Si Poetry constitue une amélioration significative par rapport aux outils traditionnels, UV porte les performances à un autre niveau grâce à son implémentation en rouille. De plus, la compatibilité d'UV avec l'emballage Python existant signifie qu'il peut fonctionner avec d'autres outils tels que pip, offrant une flexibilité que l'approche de Python, qui est davantage axée sur l'opinion, n'a parfois pas.

Voici un tableau résumant les différences que nous venons d'aborder : 

Si vous pensez que l'UV vaut la peine d'être changée, lisez ce qui suit.

Démarrer avec UV pour les projets Python

Dans cette section, nous verrons comment démarrer un projet à partir de zéro à l'aide d'UV. Nous verrons plus loin comment migrer des projets existants vers UV.

Installation des UV

UV peut être installé sur l'ensemble du système à l'aide de cURL sous macOS et Linux :

$ curl -LsSf https://astral.sh/uv/install.sh | sudo sh

Et avec Powershell sous Windows (assurez-vous de lancer Powershell avec des privilèges d'administrateur) :

$ powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

L'UV est également disponible via Homebrew :

$ brew install uv

Une installation PIP est possible mais n'est pas recommandée :

$ pip install uv  # Make sure you have a virtual environment activated

Vous pouvez ensuite vérifier l'installation en lançant uv version:

$ uv version
uv 0.4.25 (97eb6ab4a 2024-10-21)

Initialiser un nouveau projet

Travailler sur des projets est au cœur de l'expérience de l'UV. Vous commencez par initialiser un projet vide à l'aide de la commande uv init:

$ uv init explore-uv
Initialized project explore-uv at /Users/bexgboost/projects/explore-uv

La commande crée immédiatement un nouveau répertoire explore-uv avec le contenu suivant :

$ cd explore-uv
$ tree -a
.
├── .gitignore
├── .python-version
├── README.md
├── hello.py
└── pyproject.toml

Git est automatiquement initialisé et les principaux fichiers liés à Git comme .gitignore et un fichier vide README.md sont générés. Le fichier .python-version contient la version de Python utilisée pour le projet, tandis que pyproject.toml sert de fichier de configuration principal pour les métadonnées et les dépendances du projet. Un exemple de fichier hello.py est également créé pour vous aider à démarrer rapidement.

Pour en savoir plus sur la création de projets, consultez la documentation de l'UV.

Ajouter les dépendances initiales au projet

UV combine la création de l'environnement et l'installation des dépendances en une seule commande - uv add:

$ uv add scikit-learn xgboost
Using CPython 3.9.20 interpreter at: /opt/homebrew/opt/python@3.9/bin/python3.9
Creating virtual environment at: .venv
Resolved 6 packages in 1.78s
⠧ Preparing packages... (2/5)
Prepared 5 packages in 1m 23s
Installed 5 packages in 45ms
 + joblib==1.4.2
 + numpy==2.0.2
 + scikit-learn==1.5.2
 ...

La première fois que vous exécutez la commande add, UV crée un nouvel environnement virtuel dans le répertoire de travail actuel et installe les dépendances spécifiées. Lors des exécutions suivantes, UV réutilisera l'environnement virtuel existant et n'installera ou ne mettra à jour que les nouveaux paquets demandés, garantissant ainsi une gestion efficace des dépendances.

Un autre processus important qui se produit pour chaque commande add est la résolution des dépendances. UV utilise un résolveur de dépendances moderne qui analyse l'ensemble du graphe de dépendances pour trouver un ensemble compatible de versions de paquets qui satisfont à toutes les exigences. Cela permet d'éviter les conflits de versions et de garantir des environnements reproductibles. Le résolveur prend en compte des facteurs tels que les contraintes de version, la compatibilité des versions de Python et les exigences spécifiques à la plateforme pour déterminer l'ensemble optimal de paquets à installer.

UV met également à jour les fichiers pyproject.toml et uv.lock après chaque commande add. Voici à quoi ressemble le fichier TOML après l'installation de Scikit-learn et de XGBoost :

$ cat pyproject.toml
[project]
name = "explore-uv"
version = "0.1.0"
description = "Add your description here"
readme = "README.md"
requires-python = ">=3.9"
dependencies = [
    "scikit-learn>=1.5.2",
    "xgboost>=2.0.3",
]

Pour supprimer une dépendance de l'environnement et du fichier pyproject.toml, vous pouvez utiliser la commande uv remove. Il désinstallera le paquet et toutes ses dépendances :

$ uv remove scikit-learn

Nous aborderons la gestion des dépendances plus en détail dans une section ultérieure.

Exécuter des scripts Python avec UV

Une fois que vous avez installé les dépendances nécessaires, vous pouvez commencer à travailler sur vos scripts Python comme d'habitude. UV propose différentes manières d'exécuter du code Python :

Pour exécuter directement un script Python, vous pouvez utiliser la commande uv run suivie du nom de votre script au lieu de la syntaxe habituelle python script.py:

$ uv run hello.py

La commande run garantit que le script est exécuté dans l'environnement virtuel UV créé pour le projet. 

Gestion des versions de Python dans UV

La gestion des versions de Python est un élément clé de la gestion des dépendances. UV fournit des commandes simples pour contrôler la version de Python que vous utilisez. Voyons comment utiliser la commande uv python.

Liste des versions existantes de Python

Comme il est courant que Python soit déjà installé sur les systèmes, UV peut découvrir ces installations existantes par défaut. Par exemple, pour dresser la liste de toutes les versions de Python détectées par UV sur votre système, exécutez la commande suivante :

$ uv python list --only-installed
cpython-3.13.0-macos-aarch64-none     /opt/homebrew/opt/python@3.13/bin/python3.13 -> ../Frameworks/Python.framework/Versions/3.13/bin/python3.13
cpython-3.12.7-macos-aarch64-none     /opt/homebrew/opt/python@3.12/bin/python3.12 -> ../Frameworks/Python.framework/Versions/3.12/bin/python3.12
cpython-3.12.5-macos-aarch64-none     /Users/bexgboost/miniforge3/bin/python3.12
cpython-3.12.5-macos-aarch64-none     /Users/bexgboost/miniforge3/bin/python3 -> python3.12
cpython-3.12.5-macos-aarch64-none     /Users/bexgboost/miniforge3/bin/python -> python3.12
cpython-3.11.10-macos-aarch64-none    /opt/homebrew/opt/python@3.11/bin/python3.11 -> ../Frameworks/Python.framework/Versions/3.11/bin/python3.11
cpython-3.11.7-macos-aarch64-none     /Users/bexgboost/.local/share/uv/python/cpython-3.11.7-macos-aarch64-none/bin/python3 -> python3.11
cpython-3.10.15-macos-aarch64-none    /opt/homebrew/opt/python@3.10/bin/python3.10 -> ../Frameworks/Python.framework/Versions/3.10/bin/python3.10
cpython-3.9.20-macos-aarch64-none     /opt/homebrew/opt/python@3.9/bin/python3.9 -> ../Frameworks/Python.framework/Versions/3.9/bin/python3.9
cpython-3.9.6-macos-aarch64-none      /Library/Developer/CommandLineTools/usr/bin/python3 -> ../../Library/Frameworks/Python3.framework/Versions/3.9/bin/python3

La commande a correctement détecté mes versions de Python installées sur Conda et Brew.

Modifier les versions de Python pour le projet en cours 

Vous pouvez changer de version de Python pour votre projet UV actuel à tout moment, tant que la nouvelle version satisfait aux spécifications de votre fichier pyproject.toml. Par exemple, le fichier suivant nécessite les versions 3.9 et supérieures de Python :

...
requires-python = ">=3.9"

Cela signifie que vous pouvez changer la version de Python dans le fichier .python-version pour n'importe quelle version supérieure, comme 3.11.7. Appelez ensuite uv sync.

La commande vérifie d'abord les installations Python existantes. Si la version demandée n'est pas trouvée, UV la télécharge et l'installe dans le chemin d'accès /Users/username/.local/share/uv/python. UV crée également un nouvel environnement virtuel dans le répertoire du projet, qui remplace l'ancien. 

Ce nouvel environnement n'a pas les dépendances listées dans votre fichier pyproject.toml, vous devez donc les installer avec la commande suivante :

$ uv pip install -e .

Notez que les commandes uv peuvent parfois provoquer des erreurs Permission Denied. Dans ce cas, assurez-vous d'utiliser la commande sudo si vous êtes sous macOS ou Linux ou exécutez votre invite de commande avec des privilèges d'administrateur si vous êtes sous Windows. Une meilleure solution consisterait à changer la propriété du répertoire personnel de l'UV en faveur de l'utilisateur :

$ sudo chown -R $USER ~/.local/share/uv  # macOS or Linux

Pour en savoir plus sur la gestion des versions de Python avec UV, reportez-vous à la documentation. 

Que sont les outils UV et comment les utiliser ?

Certains paquets Python sont présentés sous forme d'outils en ligne de commande, tels que black pour le formatage du code, flake8 pour le linting, pytest pour les tests, mypy pour la vérification des types, etc. UV fournit deux interfaces spéciales pour gérer ces paquets :

1. Utilisation de uv tool run:

$ uv tool run black hello.py

2. Utiliser la commande uvx, plus courte et plus pratique :

$ uvx black hello.py

Lorsque ces commandes sont exécutées, UV crée un environnement virtuel temporaire dans son cache. L'outil demandé est installé et exécuté à partir de là. En d'autres termes, vous pouvez utiliser des outils en ligne de commande sans les installer dans l'environnement virtuel du projet, ce qui permet une exécution plus rapide et des dépendances plus propres.

Points clés concernant les interfaces d'exécution de l'outil :

• Fonctionne avec n'importe quel paquetage Python qui fournit des outils en ligne de commande comme flake8, mypy, black ou pytest.
• Les environnements mis en cache sont automatiquement nettoyés lorsque l'on vide le cache de l'UV.
• De nouveaux environnements mis en cache sont créés à la demande en cas de besoin.
• Parfait pour l'utilisation occasionnelle d'outils de développement

Lisez la section Outils UV de la documentation pour en savoir plus sur ces interfaces.

Que sont les fichiers de verrouillage dans UV ?

Les fichiers de verrouillage (uv.lock) sont une partie essentielle de la gestion des dépendances dans UV. Lorsque vous exécutez des commandes uv add pour installer des dépendances, UV génère et met à jour automatiquement un fichier uv.lock. Ce fichier de verrouillage remplit plusieurs fonctions essentielles :

• Il enregistre les versions exactes de toutes les dépendances et de leurs sous-dépendances qui ont été installées.
• Il garantit des constructions reproductibles en "verrouillant" les versions des dépendances dans différents environnements.
• Il permet d'éviter l'enfer des dépendances en maintenant des versions cohérentes des paquets.
• Cela accélère les installations puisque l'UV peut utiliser les versions verrouillées au lieu de résoudre à nouveau les dépendances.

UV gère le fichier de verrouillage automatiquement - vous n'avez pas besoin de le modifier manuellement. Le fichier de verrouillage doit être soumis au contrôle de version afin de garantir que tous les développeurs utilisent les mêmes versions des dépendances.

La différence entre les fichiers de verrouillage et les requirements.txt

Bien que les fichiers de verrouillage et requirements.txt servent tous deux à suivre les dépendances, ils ont des objectifs et des cas d'utilisation distincts. Les fichiers de verrouillage contiennent des informations détaillées sur les versions exactes des paquets et l'arbre complet de leurs dépendances, ce qui garantit la cohérence des environnements lors du développement. Les fichiers Requirements.txt sont plus simples, ne listant généralement que les dépendances directes, et sont largement pris en charge par les outils Python.

Les fichiers de verrouillage sont essentiels pour le développement afin de maintenir des constructions reproductibles et d'éviter les conflits de dépendance. Les fichiers Requirements.txt sont mieux adaptés aux scénarios de déploiement ou au partage du code avec des utilisateurs qui n'utiliseront peut-être pas UV. Ils sont également nécessaires pour assurer la compatibilité avec les outils et les services qui ne prennent pas en charge le format de fichier de verrouillage de l'UV.

Vous pouvez gérer les deux fichiers en utilisant le fichier de verrouillage de l'UV pour le développement et en générant un fichier requirements.txt pour le déploiement. Pour générer un site requirements.txt à partir d'un fichier de verrouillage UV, utilisez la commande suivante :

$ uv export -o requirements.txt

Cela crée le fichier texte avec les versions épinglées basées sur votre fichier de verrouillage, ce qui facilite le partage des dépendances de votre projet dans un format standard tout en bénéficiant de la gestion avancée des dépendances d'UV pendant le développement.

Pour en savoir plus sur la gestion des fichiers de verrouillage, consultez la documentation. 

Gestion avancée des dépendances avec UV

Dans cette section, nous allons explorer des méthodes plus sophistiquées pour gérer les dépendances dans UV. Nous apprendrons à mettre à jour les dépendances, à les rendre optionnelles ou à les intégrer à un groupe de dépendances.

Mise à jour des dépendances

Dans les projets à long terme, il est courant de mettre à jour les tableaux que vous utilisez pour apporter les fonctionnalités les plus récentes au tableau. Il arrive aussi qu'un paquetage que vous utilisez introduise des changements radicaux et que vous souhaitiez vous assurer que cette version ne sera pas installée accidentellement dans votre environnement. La commande add peut être utilisée à nouveau dans ces cas et dans tout autre scénario où vous devez modifier les contraintes ou les versions des dépendances existantes.

1. Installer la dernière version d'un paquet :

$ uv add requests

2. Installation d'une version spécifique :

$ uv add requests=2.1.2

3. Modifier les limites des contraintes d'un paquet :

$ uv add 'requests<3.0.0'

4. Rendre une dépendance spécifique à une plate-forme :

$ uv add 'requests; sys_platform="linux"' 

Ajouter des dépendances optionnelles

Les dépendances optionnelles sont des paquets qui ne sont pas nécessaires pour la fonctionnalité de base de votre projet, mais qui peuvent être nécessaires pour des fonctionnalités spécifiques. Par exemple, Pandas dispose d'un extra excel et d'un extra plot pour éviter l'installation des analyseurs Excel et de matplotlib à moins que quelqu'un ne les exige explicitement. Les options sont généralement installées à l'aide de la syntaxe pip install pandas[plot, excel]. 

Avec UV, cette syntaxe est légèrement différente. Tout d'abord, assurez-vous que le paquetage Pandas est installé :

$ uv add pandas

Ajoutez ensuite ses dépendances optionnelles :

$ uv add pandas --optional plot excel

Une fois résolus, ils seront répertoriés sur votre site pyproject.toml sous le format suivant :

[project]
name = "explore-uv"
version = "0.1.0"
description = "Add your description here"
readme = "README.md"
requires-python = ">=3.9"
dependencies = [
    "pandas>=2.2.3",
    "requests>=2.32.3",
]
[project.optional-dependencies]
plot = [
    "excel>=1.0.1",
    ...
]

Groupes de dépendance

Les groupes de dépendances vous permettent d'organiser vos dépendances en groupes logiques, tels que les dépendances de développement, les dépendances de test ou les dépendances de documentation. Cela permet de séparer les dépendances de production des dépendances de développement.

Pour ajouter une dépendance à un groupe spécifique, utilisez l'option --group:

$ uv add --group group_name package_name

Ensuite, les utilisateurs pourront contrôler les groupes à installer à l'aide des balises --group, --only-group, et --no-group.

Passer de PIP et Virtualenv à UV

La migration de PIP et virtualenv vers UV est simple car UV maintient la compatibilité avec les normes d'empaquetage Python existantes. Voici un guide étape par étape pour faciliter la transition :

1. Convertir un projet virtualenv existant

Si vous avez un projet existant utilisant virtualenv et pip, commencez par générer un fichier requirements.txt à partir de votre environnement actuel si ce n'est pas déjà fait :

$ pip freeze > requirements.txt

Créez ensuite un nouveau projet UV dans le même répertoire :

$ uv init .

Enfin, installez les dépendances de votre fichier d'exigences :

$ uv pip install -r requirements.txt

2. Remplacement des commandes pip/virtualenv courantes

Voici une référence rapide pour remplacer les commandes pip et virtualenv courantes par leurs équivalents UV :

Après la migration, vous pouvez supprimer en toute sécurité votre ancien répertoire virtualenv et commencer à utiliser la gestion de l'environnement virtuel d'UV. La transition est généralement transparente, et vous pouvez toujours revenir aux commandes pip via la couche de compatibilité pip d'UV si nécessaire.

Conclusion

UV représente une avancée significative dans la gestion des paquets Python, offrant une alternative moderne, rapide et efficace aux outils traditionnels. Ses principaux avantages sont les suivants :

• Des performances ultra-rapides avec des améliorations de 10 à 100 fois par rapport à pip
• Intégration transparente avec les normes d'emballage Python existantes
• Gestion intégrée de l'environnement virtuel
• Résolution efficace des dépendances et prise en charge des fichiers de verrouillage
• Faible empreinte mémoire et faible utilisation des ressources

Que vous commenciez un nouveau projet ou que vous migriez un projet existant, UV fournit une solution robuste qui peut améliorer de manière significative votre flux de travail de développement Python. Sa compatibilité avec les outils existants en fait un choix facile pour les développeurs qui cherchent à moderniser leur chaîne d'outils sans perturber leurs processus actuels.

Alors que l'écosystème Python continue d'évoluer, des outils comme UV démontrent comment des technologies modernes comme Rust peuvent améliorer l'expérience de développement tout en conservant la simplicité et l'accessibilité auxquelles les développeurs Python sont attachés.

Si vous souhaitez en savoir plus sur la gestion des dépendances ou sur Python en général, consultez ces sources supplémentaires :

• Tutoriel Python pour les débutants
• Tutoriel PIP Python : Guide définitif
• Cours sur le développement de paquets Python
• Les 9 meilleures alternatives à Anaconda pour la gestion de l'environnement Python
• Data Scientist en Python | Apprendre Python pour la science des données
• Python Poetry : Gestion moderne et efficace de l'environnement et des dépendances en Python