Poésie Python : Gestion moderne et efficace de l’environnement Python et des dépendances

Tutoriels
Python

L’écosystème de Python s’est traditionnellement appuyé sur des outils tels que pip et virtualenv pour gérer les dépendances et les environnements de projet. Bien que ces outils nous aient bien servis, ils entraînent souvent des conflits de dépendances, une gestion manuelle de l’environnement et des configurations de projet incohérentes au sein des équipes.

Python Poetry résout ces défis en fournissant un outil moderne et unifié de gestion des dépendances et des environnements. Il gère tout, des environnements virtuels à la publication de packages, tout en garantissant des constructions reproductibles grâce à une résolution intelligente des dépendances.

Ce guide vous montrera comment utiliser Poetry pour rationaliser votre flux de travail de développement Python et éviter les maux de tête liés aux dépendances courantes.

Python Poetry vs. PIP

Poetry et pip servent à des fins différentes dans l’écosystème Python. Alors que pip est principalement un installateur de packages, Poetry est un outil complet de gestion des dépendances et des projets. Voici les principales différences :

1. Résolution des dépendances

  • Pip : Résolution simple et linéaire des dépendances pouvant entraîner des conflits
  • Poésie : Résolveur de dépendances avancé qui prévient les conflits avant l’installation

2. Gestion de l’environnement virtuel

  • Pip : Nécessite des outils séparés (virtualenv, venv) et une activation manuelle
  • Poésie : Crée et gère automatiquement des environnements virtuels par projet

3. Configuration du projet

  • Pip : Utilise requirements.txt pour les dépendances, setup.py pour les métadonnées du projet
  • Poésie : Un seul fichier pyproject.toml pour tous les besoins de configuration

4. Fichiers de verrouillage

  • Pip : Aucun support intégré pour les fichiers de verrouillage
  • Poésie : Génère poetry.lock pour des constructions reproductibles à travers les environnements

5. Publication de packages

  • Pip : Nécessite des outils supplémentaires (twine, setuptools) pour la publication
  • Poésie : Commandes intégrées pour la construction et la publication de packages

Quand utiliser Poetry plutôt que pip

Choisissez Poetry lorsque :

  • Vous travaillez sur des projets d’équipe nécessitant des environnements reproductibles
  • Vous créez des packages qui seront publiés sur PyPI
  • Vous gérez des arbres de dépendances complexes avec des conflits potentiels
  • Vous avez besoin d’une gestion automatisée des environnements virtuels
  • Vous souhaitez un outil unique pour l’ensemble du flux de développement

Préférez pip lorsque :

  • Travailler sur des scripts simples avec des dépendances minimales
  • Apprendre Python pour la première fois
  • Besoin d’installer rapidement un seul paquet
  • Travailler dans des environnements où l’installation de Poetry n’est pas possible
  • Maintenir des projets hérités déjà configurés avec pip

La règle générale est la suivante : utilisez Poetry pour tout projet qui sera partagé, déployé ou maintenu à long terme. Utilisez pip pour des expériences rapides ou des exercices d’apprentissage.

Cela étant dit, plongeons directement dans l’utilisation de Poetry.

Configuration de Python Poetry

Vous interagirez principalement avec Poetry en tant qu’outil en ligne de commande (CLI), il est donc logique de l’installer de manière globale sur votre machine. Cette section couvre cette étape cruciale initiale et comment définir des configurations par défaut pour Poetry en fonction de vos besoins.

Installation de Poetry

Vous pouvez installer Poetry en utilisant un script d’installation officiel, qui peut être téléchargé et exécuté avec une seule commande.

Pour macOS, Linux et WSL2 :

$ curl -sSL https://install.python-poetry.org | sudo python3 -

Pour Windows Powershell (exécuter avec des privilèges d’administrateur) :

$ (Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | py -

Si vous utilisez Windows et avez installé Python depuis le Microsoft Store (pour une raison étrange), remplacez py par python dans la commande ci-dessus.

Après la fin du script d’installation, il affiche un message vous demandant d’ajouter Poetry à votre PATH afin que la commande poetry soit disponible partout.

Pour macOS, Linux et WSL2, ajoutez la ligne suivante à votre script shell comme .bashrc ou .zshrc:

$ export PATH="/Users/bexgboost/.local/bin:$PATH"

Pour Windows, vous pouvez suivre les instructions de sortie.

Ensuite, vérifiez votre installation en exécutant poetry --version.

Configuration de Poetry

La plupart de la configuration de Poetry concerne la manière dont les environnements virtuels sont créés et comment les packages sont installés. Vous pouvez afficher une liste (presque) complète des configurations de Poetry avec :

$ poetry config --list

La sortie ressemblera à quelque chose comme ci-dessous :

cache-dir = "/Users/bexgboost/Library/Caches/pypoetry"
experimental.system-git-client = false
installer.max-workers = null
installer.modern-installation = true
installer.no-binary = null
installer.parallel = true
keyring.enabled = true
solver.lazy-wheel = true
virtualenvs.create = true
virtualenvs.in-project = null
virtualenvs.options.always-copy = false
virtualenvs.options.no-pip = false
virtualenvs.options.no-setuptools = false
virtualenvs.options.system-site-packages = false
virtualenvs.path = "{cache-dir}/virtualenvs"  # /Users/bexgboost/Library/Caches/pypoetry/virtualenvs
virtualenvs.prefer-active-python = false
virtualenvs.prompt = "{project_name}-py{python_version}"
warnings.export = true

Dans la première ligne, nous voyons un chemin vers le cache de Poetry. Il est principalement utilisé pour stocker les distributions de packages téléchargées et les environnements virtuels. Tous les environnements virtuels que vous créez sont stockés ici par défaut. Si vous souhaitez modifier cela, vous pouvez exécuter la commande suivante :

$ poetry config virtualenvs.path path/to/new/virtualenv/dir

Une autre configuration importante est le nombre de cœurs utilisés lors des installations. Par défaut, il est réglé sur quatre, mais nous pouvons le rendre plus rapide en utilisant tous les cœurs du CPU. Tout d’abord, découvrez le nombre de cœurs de votre machine en exécutant os.cpu_count() dans l’interpréteur Python. Ensuite, définissez la sortie :

$ poetry config installer.max-workers = 10

Une configuration facultative consiste à choisir si vous souhaitez créer des environnements virtuels dans votre répertoire de travail ou dans le cache. Cela est contrôlé via virtualenvs.in-project option. Si vous le définissez sur True, le répertoire .venv sera toujours créé dans votre répertoire de travail:

$ poetry config virtualenvs.in-project true

Création d’un nouveau projet avec Poetry

Plongeons dans les étapes clés de la création d’un nouveau projet Poetry et de la compréhension de son fichier de configuration principal.

Initialisation d’un nouveau projet Poetry

L’utilisation de la poésie commence généralement par la création d’un nouveau projet avec la poetry new commande:

$ poetry new explore-poetry
$ cd explore-poetry

La commande crée un répertoire explore-poetry pré-rempli avec les fichiers et répertoires suivants:

explore-poetry
├── pyproject.toml
├── README.md
├── explore-poetry
│   └── __init__.py
└── tests
   └── __init__.py

Cette structure de répertoire suit les meilleures pratiques de Python:

  • pyproject.toml: Le fichier de configuration principal qui définit les métadonnées du projet et les dépendances
  • README.md: Fichier de documentation expliquant le projet
  • explore-poetry/: Répertoire du code source contenant le code du package principal, avec __init__.py pour en faire un package
  • tests/: Répertoire pour les fichiers de test, avec __init__.py pour en faire un package (importable)

Comprendre pyproject.toml

Ici, le fichier pyproject.toml demande une attention particulière car c’est le seul fichier non vide généré par Poetry :

[tool.poetry]
name = "explore-poetry"
version = "0.1.0"
description = ""
authors = ["BexTuychiev <[email protected]>"]
readme = "README.md"
[tool.poetry.dependencies]
python = "^3.8"
[build-system]
requires = ["poetry-core"]
build-backend = "poetry.core.masonry.api"

Ce fichier orchestre votre projet et ses dépendances. Il utilise Tom’s Obvious, Minimal Language, qui a été convenu comme le langage de configuration standard pour les packages Python dans PEP 518.

Tous lespyproject.toml fichiers sont divisés en sections appelées tables en utilisant des crochets comme tool.poetry ou build-system. Poetry utilise ces tables pour gérer les dépendances, les exigences de construction du projet ou effectuer d’autres tâches.

En exécutant les commandes Poetry décrites dans les sections suivantes, le pyproject.toml fichier sera automatiquement mis à jour.

Travailler avec des environnements virtuels dans Poetry

Dans cette section, vous découvrirez les tenants et aboutissants de la gestion des environnements virtuels dans Poetry une fois que vous l’aurez configuré. Vous apprendrez pourquoi les environnements virtuels sont importants, comment Poetry les gère automatiquement, et les commandes de base pour les manipuler, comme la création, l’activation et le changement. Vous apprendrez également comment gérer les versions de Python avec Poetry.

Création et activation d’un environnement virtuel

Lorsque vous installez Poetry pour la première fois, il ne dispose d’aucun environnement intégré, comme en témoigne une sortie vide lorsque vous exécutez poetry env list:

$ poetry env list  # aucune sortie

Mais dès que vous commencez à ajouter des dépendances (nous en parlerons plus tard) avec poetry add nom-du-paquet, il crée automatiquement un environnement dans le répertoire cache du projet. Par exemple, essayons d’ajouter requests en tant que dépendance :

$ poetry add requests

Vous devriez recevoir une sortie similaire à ce qui suit :

Creating virtualenv explore-poetry--I9GJYUn-py3.8 in /Users/bexgboost/Library/Caches/pypoetry/virtualenvs
Using version ^2.32.3 for requests
Updating dependencies
Resolving dependencies... (2.5s)
Package operations: 5 installs, 0 updates, 0 removals
 - Installing certifi (2024.8.30)
 - Installing charset-normalizer (3.4.0)
 - Installing idna (3.10)
 - Installing urllib3 (2.2.3)
 - Installing requests (2.32.3)
Writing lock file

La première ligne indique que la poésie a créé l’environnement dans le cache. Les lignes suivantes informent que les dépendances pour requests sont résolues avec succès, et un fichier de verrouillage est généré (nous en parlerons plus tard, également).

Prêtez attention au nom de l’environnement: explore-poetry--I9GJYUn-py3.8. Le nom inclut le nom du répertoire du projet, suivi d’un identifiant unique, puis de la version de Python utilisée par l’environnement.

La prochaine fois que vous ajoutez une dépendance, Poetry utilise automatiquement cet environnement pour installer des packages :

$ poetry add beautifulsoup4
Using version ^4.12.3 for beautifulsoup4
Updating dependencies
Resolving dependencies... (1.1s)
Package operations: 2 installs, 0 updates, 0 removals
 - Installing soupsieve (2.6)
 - Installing beautifulsoup4 (4.12.3)
Writing lock file

Lorsque vous utilisez Poetry, votre terminal ne montre pas quel environnement virtuel Poetry est actif. Pour voir cette information, vous devez exécuter poetry env list:

$ poetry env list
explore-poetry--I9GJYUn-py3.8 (Activated)

Pour interagir avec l’environnement Poetry actif, vous pouvez exécuter poetry shell: 

$ poetry shell

La commande ouvre une nouvelle session shell dans celle en cours, et vous pouvez exécuter des commandes comme python ou pytest.

Par exemple, pour exécuter des scripts Python:

$ poetry shell
$ python script.py

Pour exécuter des frameworks de développement comme Streamlit:

# À l'intérieur du shell
$ streamlit run app.py

Ensuite, vous pouvez quitter le shell en appelant exit.

Alternativement, vous pouvez exécuter des commandes dans le shell Poetry sans y entrer avec poetry run:

$ poetry run python script.py
$ poetry run streamlit run app.py

Configuration de la version Python

Lorsque vous exécutezpoetry add ou poetry install, Poetry utilise automatiquement la version de Python spécifiée dans votre fichier pyproject.toml. Pour spécifier une version de Python différente, vous pouvez exécuter la commande env use:

$ poetry env use python3.11

Notez que Python 3.11 doit être installé à l’échelle du système sur votre machine pour que la commande fonctionne.

Vérifiez que Poetry utilise l’environnement avec la nouvelle version de Python :

$ poetry env list
explore-poetry--I9GJYUn-py3.11 (Activated)
explore-poetry--I9GJYUn-py3.8

Remarquez comment le nouvel environnement est automatiquement attaché à notre projet (les ID sont les mêmes). Une fois que vous avez configuré votre version de Python, vous pouvez supprimer les environnements avec d’autres versions pour libérer de l’espace disque :

$ poetry env remove python3.8

Lors de la suppression d’un environnement, vous devez uniquement spécifier la version de Python. Vous pouvez également supprimer tous les environnements et recommencer à zéro :

$ poetry env remove --all

N’oubliez pas que --all tag supprime tous les environnements associés au projet actuel, pas les environnements des autres projets.

Si vous travaillez sur des projets d’équipe, il est souvent préférable de conserver l’environnement virtuel dans le répertoire du projet :

$ poetry config virtualenvs.in-project true

Cette commande n’aura aucun effet si vous avez déjà un environnement pour le projet dans le cache. Pour créer un environnement local, supprimez d’abord tous ceux qui existent dans le cache.

Cela crée un .venv dossier dans votre répertoire de travail, que vous devriez ajouter à votre .gitignore fichier.

Gestion des dépendances avec Poetry

La gestion des dépendances est là où Poetry brille. Il offre des fonctionnalités complètes pour spécifier, installer et gérer les dépendances afin que vous ne rencontriez jamais de conflits de dépendances infernaux. 

Dans cette section, vous apprendrez à ajouter et installer des dépendances, à créer des groupes de dépendances, à spécifier la syntaxe des dépendances dans pyproject.toml et les fichiers de verrouillage.

Ajout de dépendances dans Poetry

Lorsque vous utilisez Poetry, vous utiliserez la commande poetry add nom-du-package pour installer des packages à partir de PyPI au lieu de pip install. Cela présente quelques avantages :

  1. Ajoute automatiquement le package à pyproject.toml avec la contrainte de version correcte
  2. Met à jour le fichier de verrouillage pour garantir des constructions reproductibles
  3. Résout les dépendances pour éviter les conflits
  4. Installe le package et toutes ses dépendances dans l’environnement virtuel

Par exemple, commençons par ajouter Numpy en tant que dépendance:

$ poetry add numpy

Immédiatement, vous devriez recevoir un conflit de résolution de dépendance indiquant que la version de Numpy qui est en train d’être installée n’est pas compatible avec votre version de Python. La raison en est que lorsque nous avons basculé vers l’environnement Python 3.11, nous n’avons pas mis à jour le fichier pyproject.toml actuel ressemble à ceci:

[tool.poetry.dependencies]
python = "^3.8"
requests = "^2.32.3"
beautifulsoup4 = "^4.12.3"

Le symbole caret ^ est utilisé pour indiquer que notre projet explore-poetry est compatible avec n’importe quelle version de Python jusqu’à Python 4, mais la plage de versions de Numpy ne prend en charge que les versions de Python entre 3.8 et 3.12, ce qui est une plage plus étroite. L’erreur de conflit provient de ce fait.

Donc, pour corriger l’erreur, vous devez mettre à jour la plage de versions de Python comme suit:

python = ">=3.8, <3.12"

Une fois que vous avez effectué ce changement, poetry add numpy la commande devrait fonctionner comme prévu.

Vous venez d’observer l’une des meilleures fonctionnalités de Poetry — détecter les conflits de version avant d’installer des paquets au lieu de vous informer des incompatibilités de version par la suite, comme pip.

La syntaxe pour spécifier les versions de dépendance

La poésie utilise une syntaxe puissante pour spécifier une large gamme de versions afin d’assurer la meilleure synchronisation entre les dépendances. Voici les symboles les plus souvent utilisés :

  1. Accent circonflexe (^): Permet les mises à jour de patch et mineures mais pas majeures. Exemple : ^1.2.3 permet les mises à jour de 1.2.3 à 1.9.9 mais pas 2.0.0.
  2. Til de (~): Permet uniquement les mises à jour de patch. Exemple : ~1.2.3 permet les mises à jour de 1.2.3 à 1.2.9 mais pas 1.3.0.
  3. Version exacte : Spécifie le numéro de version exact. Exemple : 1.2.3 autorise uniquement la version 1.2.3
  4. Supérieur à (>) : Autorise toute version supérieure à celle spécifiée. Exemple : >1.2.3 autorise 1.2.4, 1.3.0, 2.0.0, etc.
  5. Inférieur à (<) : Permet toute version inférieure à celle spécifiée. Exemple : <2.0.0 permet tout ce qui est inférieur à 2.0.0.
  6. Supérieur ou égal (>=) : Permet la version spécifiée et supérieure. Exemple : >=1.2.3 permet la version 1.2.3 et toute version ultérieure.
  7. Moins que ou égal (<=): Permet la version spécifiée et en dessous. Exemple: <=2.0.0 permet 2.0.0 et toute version inférieure.
  8. Plage de versions: Combine les contraintes avec des virgules. Exemple: >=1.2.3,<2.0.0 permet les versions de 1.2.3 à 1.9.9
  9. Caractère générique (*): Correspond à n’importe quelle version. Exemple : 1.2.* correspond à n’importe quelle version commençant par 1.2

Bien sûr, vous pouvez combiner ces éléments selon vos besoins.

Création de groupes de dépendances dans Poetry

Dans des projets complexes avec de nombreux composants en mouvement, vous devez souvent gérer différentes catégories de dépendances.

Par exemple, dans un projet d’apprentissage automatique, vous créez souvent différents pipelines et composants pour l’ingestion des données, le nettoyage des données, l’ingénierie des fonctionnalités, la formation des modèles, le déploiement et la surveillance. Sans oublier, vous devez également compléter la documentation et exécuter des tests. Toutes ces étapes ont leur propre écosystème d’outils, et mélanger leurs dépendances alourdit votre package final.

Avec Poetry, vous pouvez créer des groupes de dépendances avec des noms arbitraires afin de pouvoir les installer uniquement quand c’est nécessaire. Ou la meilleure partie – les utilisateurs de votre package peuvent également choisir d’installer les parties dont ils ont besoin.

$ poetry add --group ui streamlit plotly dash
$ poetry add --group dev black flake8 isort mypy pylint

Les commandes ci-dessus créent deux groupes de dépendances, ui et dev (s’ils n’existent pas déjà), et deux sous-tableaux dans pyproject.toml:

[tool.poetry.dependencies]
python = "^3.11"
requests = "^2.32.3"
beautifulsoup4 = "^4.12.3"
numpy = "^2.1.3"
[tool.poetry.group.ui.dependencies]
streamlit = "^1.39.0"
plotly = "^5.24.1"
dash = "^2.18.2"
[tool.poetry.group.dev.dependencies]
black = "^24.10.0"
flake8 = "^7.1.1"
isort = "^5.13.2"
mypy = "^1.13.0"
pylint = "^3.3.1"

Même si les groupes de dépendances sont séparés, ils sont toujours résolus les uns par rapport aux autres. En d’autres termes, s’il y a une dev dépendance en conflit avec un package dans ui, Poetry n’exécutera pas l’installation.

Dans certains cas, vous pouvez créer des groupes de dépendances facultatifs ou rendre facultatifs les groupes existants afin qu’ils ne soient pas installés par défaut lorsque l’utilisateur recrée l’environnement de votre projet. Pour ce faire, vous devez créer une nouvelle sous-table dans le pyproject.toml fichier. Par exemple, nous rendrons le groupe ui facultatif ci-dessous:

[tool.poetry.group.ui]
optional = true
[tool.poetry.group.ui.dependencies]
streamlit = "^1.39.0"
plotly = "^5.24.1"
dash = "^2.18.2"

Cela se fait en définissant le optionnel paramètre à vrai avant de déclarer les dépendances du groupe.

Reproduire un projet Poetry avec le fichier poetry.lock

Si quelqu’un clone votre dépôt GitHub contenant un projet Poetry, il peut recréer une copie parfaite de l’environnement virtuel de votre projet en exécutant une seule commande : poetry install.

Le commande d’installation utilise le fichier plus complet poetry.lock. Contrairement à pyproject.toml, le fichier de verrouillage liste :

  • Les versions exactes des principales dépendances listées dans pyproject.toml
  • Les versions exactes des dépendances des principales dépendances (dépendances transitives)

Par exemple, requests dépend de urllib3, certifi, charset-normalizer et idna. Sans fichier de verrouillage, ces sous-dépendances pourraient se résoudre à différentes versions sur différentes machines.

Le fichier de verrouillage garantit que chaque membre de votre équipe obtient les mêmes versions de dépendance, empêchant le problème du « ça fonctionne sur ma machine ».

La différence entre poetry add et poetry install

Nous allons expliquer la différence entre add et install commandes de Poetry avec un cas d’utilisation.

Supposons que vous travaillez sur un projet de détection de fraude. Vous ajoutez vos dépendances initiales :

$ poetry add pandas scikit-learn

Cela ajoute les paquets au verrou et pyproject.toml fichiers. Ensuite, votre collègue clone le dépôt :

$ git clone fraud-detection-repo-link
$ cd fraud-detection
$ poetry install

Ils exécutent la install commande pour installer tout ce qui est listé dans le fichier de verrou.

Plus tard, vous devez ajouter un nouveau paquet :

$ poetry add xgboost

Votre collègue tire les modifications :

$ git pull
$ poetry install

Ils exécutent la install commande pour installer le nouveau package. Donc,

  • Utilisez poetry add lorsque vous ajoutez de nouvelles dépendances
  • Utilisez poetry install lorsque vous devez configurer un projet existant
  • Engagez toujours pyproject.toml et poetry.lock dans le contrôle de version

Installation des groupes de dépendances avec la commande poetry install

Auparavant, nous avons appris à regrouper les dépendances dans Poetry. Lorsque vous exécutez poetry install, il installe par défaut tous les groupes non optionnels, ce qui peut ne pas être ce que vous souhaitez dans tous les cas.

Par exemple, vous pouvez cloner un dépôt uniquement pour travailler sur la documentation. Ou vous souhaitez travailler sur le code principal du dépôt, sauf pour les aspects de documentation et de test. La install commande est suffisamment flexible pour couvrir tous ces cas :

Exclure certains groupes :

$ poetry install --without ui,dev

Installation de groupes optionnels également :

# Installation du groupe de docs optionnel
$ poetry install --with docs

Installation de groupes spécifiques uniquement :

$ poetry install --only ui

Installation uniquement des dépendances d’exécution du projet (les dépendances mentionnées en dehors des groupes, ajoutées avec la commande simple poetry add package ) :

$ poetry install --only main

Suppression des dépendances dans Poetry

Supprimer une dépendance est simple en utilisant la commande remove :

$ poetry remove requests

Cela supprime requests des dépendances principales du projet. Pour supprimer un package d’une dépendance de groupe, vous pouvez à nouveau utiliser la balise --group :

$ poetry remove streamlit --group ui

La remove commande désinstalle proprement le paquet, ainsi que ses dépendances transitives.

Publier un projet avec Poetry sur PyPI

Si votre projet est prêt pour la distribution, le publier sur PyPI (Python Package Index) permet à d’autres développeurs d’installer et d’utiliser facilement votre code via pip. Poetry rend ce processus extrêmement simple avec seulement deux commandes :

$ poetry build  # Construire des distributions
$ poetry publish  # Publier sur PyPI

Cependant, avant d’exécuter ces commandes, vous devez configurer correctement vos identifiants PyPI. Tout d’abord, créez vos comptes sur :

  1. PyPI
  2. TestPyPI

Configurez Poetry avec vos identifiants :

$ poetry config pypi-token.pypi your-pypi-token
$ poetry config pypi-token.testpypi your-test-pypi-token

Maintenant, testez d’abord votre paquet :

# Configurez le dépôt TestPyPI
$ poetry config repositories.testpypi https://test.pypi.org/legacy/
# Publiez sur TestPyPI
$ poetry build
$ poetry publish -r testpypi

Après avoir publié sur TestPyPI, vous pouvez essayer d’installer votre package pour vérifier que tout fonctionne bien :

$ pip install --index-url https://test.pypi.org/simple/ your-package-name

Si tout va bien, vous pouvez publier sur PyPI lui-même :

$ poetry publish

Meilleures pratiques lors de l’utilisation de Poetry

Il y a de nombreux pièges et meilleures pratiques lors de l’utilisation de Poetry, et bien sûr, nous ne pouvons pas tous les mentionner dans un seul article. Mais voici quelques-unes que vous pouvez appliquer immédiatement :

  1. Utilisez toujours des environnements virtuels — Poetry les crée automatiquement pour chaque projet
  2. Conservez votre pyproject.toml sous contrôle de version mais excluez poetry.lock pour les bibliothèques
  3. Incluez poetry.lock dans le contrôle de version pour les applications afin d’assurer des builds reproductibles
  4. Utilisez la version sémantique pour les versions de votre package (majeure.mineure.correctif). Vous pouvez utiliser les commandes poetry version correctif/mineure/majeure pour augmenter les versions du package de un. Par exemple, poetry version majeure change 0.2.0 en 1.0.0 dans votre fichier pyproject.toml.
  5. Spécifiez soigneusement les contraintes de version des dépendances pour éviter les conflits
  6. Mettez régulièrement à jour les dépendances avec poetry update mais testez soigneusement après les mises à jour
  7. Utilisez poetry add --group dev pour les dépendances de développement afin de les garder séparées
  8. Documentez tous les objectifs des dépendances dans pyproject.toml en utilisant des commentaires
  9. Exécutez poetry check avant les validations des commits pour vérifier la syntaxe de pyproject.toml. Vous pouvez également envisager des hooks pre-commit.
  10. Utilisez poetry export pour générer requirements.txt lorsque nécessaire pour d’autres outils.
  11. Gardez les dépendances de production minimales — déplacez les fonctionnalités optionnelles vers des extras
  12. Testez l’installation de votre paquet dans un environnement propre avant de le publier
  13. Utilisez TestPyPI avant de publier sur le dépôt principal de PyPI
  14. Conservez un CHANGELOG.md pour suivre les changements de version
  15. Utilisez poetry run pour l’exécution de scripts afin de garantir une utilisation correcte de l’environnement

Conclusion et étapes suivantes

Poetry a révolutionné la gestion des dépendances Python en offrant une solution robuste et intuitive aux défis courants de la gestion des paquets. Ses fonctionnalités puissantes pour la résolution des dépendances, la gestion des environnements virtuels et la publication de projets en font un outil inestimable pour le développement Python moderne.

Pour poursuivre votre parcours de développement Python, envisagez d’explorer ces parcours d’apprentissage complets :

N’oubliez pas, la gestion efficace des dépendances n’est qu’un aspect du développement professionnel en Python. À mesure que vous continuez à évoluer en tant que développeur, des outils comme Poetry vous aideront à créer des projets Python plus maintenables et fiables.

Source:
https://www.datacamp.com/tutorial/python-poetry