Environnement virtuel pour Python: projet "template"

Introduction

Python est un langage de programmation très populaire pour le développement de scripts et de petites applications. L’une de ses principales forces est la richesse des librairies disponibles.

Cependant, le partage d’une application écrite en Python n’est pas toujours simple, car cette dernière peut reposer sur un certain nombre de ces librairies, qui ne sont pas forcément installées sur la machine cible. Pire encore, il se peut que la librairie souhaitée soit déjà installée, mais que sa version soit différente de celle qui soit nécessaire (notamment en cas de rupture de compatibilité avec d’anciennes versions de la librairie).

Pour palier à ce problème, on peut peut utiliser les environnement virtuels (ou "virtual environments" en anglais), une une fonctionnalité puissante et très pratique de Python.

Les environnements virtuels, à quoi ça sert ?

Les environnements virtuels permettent de crées des environnements d’exécution isolés pour différents projets. Chaque projet peut avoir ses propres dépendances, indépendamment des autres projets. Un projet A peut avoir besoin d’une certaine librairie en version 2.x, alors qu’un autre projet B peut avoir besoin de la même librairie, mais en version 3.x:

Ainsi, les deux projets peuvent coexister. En installant les librairies nécessaires dans des environnements virtuels pour chacun des projets, on n’est plus dépendant de l’installation de libraries dans l’installation de base de Python.

En pratique, comment ça marche ?

Chaque projet est fourni avec un fichier "requirements.txt", listant les dépendances nécessaires à l’exécution du projet. Après avoir téléchargé le projet localement, on procèdera de la sorte pour installer les dépendances :

1. Créer l'environnement virtuel
2. Activer l’environnement virtuel
3. A l’aide de l’utilitaire pip (gestionnaire de paquets de Python), installer les dépendances requises selon le fichier "requirements.txt"

Pour exécuter le script dans son environnement virtuel, on procède ainsi :

1. Activer l’environnement virtuel
2. Exécuter le script

C’est aussi simple que cela !

Modèle de projet Python avec environnement virtuel

Vous trouver ici un modèle (template) de projet Python : https://github.com/pull-up-dev/python-template.

Il inclut :

• Des scripts ("prepare.ps1" pour Windows et "prepare.sh" pour Linux) permettant de préparer un environnement virtuel avec les dépendances nécessaires (ici la librairie "pyyaml"), à partir d’un fichier "requirements.txt".
• Des scripts ("launch.ps1" pour Windows et "launch.sh" pour Linux) permettant d’activer l’environnement virtuel et d’exécuter un exemple d’application Python.
• Des scripts ("mrproper.ps1" pour Windows et "mrproper.sh" pour Linux) permettant de nettoyer l’environnement virtuel.

Ces divers scripts, ainsi que l’application fournie sont prévus pour servir de point de départ pour des projets Python, que l'on peut ensuite facilement partager.

Les commandes qui se trouvent dans les scripts sont décrites en détails ci-dessous. Concernant les commandes exécutées, il y a certaines différences entre Windows et Linux. En particulier, la commande pour Python sous Windows est "python", alors que sous Linux la commande est "python3". Cela peut également varier en fonction de votre installation de Python et/ou de la distribution Linux que vous utilisez.

Scripts de préparation de l'environnement virtuel

Les scripts "prepare.ps1" (Windows) et "prepare.sh" (Linux) installent tout d'abord le package "virtualenv", permettant l'utilisation des environnements virtuels:

python -m pip install virtualenv

Une fois cela fait, le script crée un environnement virtuel, dans un sous-dossier "virtEnv":

python -m virtualenv --no-setuptools --no-pip --no-wheel --no-download --system-site-packages -p python virtEnv

L'environnement virtuel est ensuite activé. Sous Windows, on exécute simplement la commande "activate" qui se trouve dans l'environnement virtuel:

virtEnv\Scripts\activate

Sous Linux, l'activation est légèrement différente, car "activate" doit être appelé via la commande "source" comme ceci :

source virtEnv/bin/activate

Enfin, les dépendances sont installées, conformément au fichier "requirements.txt":

python -m pip install -r requirements.txt

La syntaxe pour le fichier "requirements.txt" est décrite sur la page suivante : https://pip.pypa.io/en/stable/reference/requirements-file-format/. Il est par exemple possible de définir la version exacte souhaitée pour une librairie, ou une version minimale.

Après l'exécution du script Python, on peut désactiver l'environnement virtuel avec la commande:

deactivate

Scripts d'exécution de l'application Python

En premier lieu, dans les scripts "launch.ps1" (Windows) ou "launch.sh" (Linux), l'environnement virtuel est activé. Sous Windows:

.\virtEnv\Scripts\activate

Ou sous Linux:

source virtEnv/bin/activate

Ensuite, l'application Python est lancée, en transmettant les arguments reçus.

L'application utilise la librairie "argparse" pour gérer les arguments reçus. Dans cet exemple minimal, le seul argument qui peut être fourni à l'application est le chemin vers un fichier YAML de configuration. Si cet argument n'est pas fourni, le fichier "config.yml" (qui est fourni avec le projet) est utilisé. L'application charge le fichier de configuration (à l'aide de la librairie "pyyaml", qui est listée comme dépendance dans le fichier "requirements.txt") et affiche la valeur du paramètre "dummy_param" qui se trouve dans ce fichier.

D'autres paramètres peuvent être définis avec la librairie "argparse". Sa documentation est disponible ici: https://docs.python.org/3/library/argparse.html.

Script de nettoyage

Les scripts "mrproper.ps1" (Windows) et "mrproper.sh" (Linux) suppriment l'environnement virtuel, en supprimant simplement le sous dossier dans lequel ce dernier a été créé.

Conclusion

Le projet fourni est un exemple minimal d'utilisation des environnements virtuels, incluant des scripts permettant de préparer et nettoyer des environnements virtuels, et exécuter une application Python dans cet environnement virtuel.

L'application Python fournie implémente l'utilisation de la librairie "argparse" permettant de recevoir des arguments, ainsi que l'utilisation d'un fichier de configuration en YAML.

Il peut facilement être adapté, et servir de point de départ pour divers projets.