Environnements virtuels Python

Les scripts Python utilisent souvent des paquets et modules qui ne font pas partie de la bibliothèque standard. Ils nécessitent aussi, parfois, une version spécifique d'une bibliothèque, par exemple parce qu'un certain bug a été corrigé ou encore que le programme a été implémenté en utilisant une version obsolète de l'interface de cette bibliothèque.

Comment alors pouvoir exploiter une version n d'un module dans un programme et une version n-1 dans un autre. C'est pour cela que le mécanisme des environnement virtuels à été crée.

Bon maintenant il est devenu obligatoire dans pas mal d'installations de base. C'est par exemple le cas pour Raspberry OS (Debian pour Raspberry PI), en tout cas pour ma version Debian GNU/Linux 12 (bookworm).

Dans cette page on va réutiliser l'exemple de la doc.

tutorial-env

Création et utilisation

Création d'un environnement.

Pour créer un environnement on se déplace dans son répertoire parente et on le crée:

cd sources
python -m venv tutorial-env

C'est parfois un peu lent. prendre patience.

Activation

Un fois crée il faut l'activer :

source tutorial-env/bin/activate

l'environnement est alors lancé et configuré. On sait qu'on est connecté à un venv car l'invite de commande est changée. Le nom de l'environnement est ajouté avant.

$ source tutorial-env/bin/activate
(tutorial-env) $

On devra relancer le source chaque fois qu'on se délogue/relogue.

Désactivation

Le but initial est de pouvoir travailler sur plusieurs programmes sur la même machine qui possède des dépendances différentes. Il faut pouvoir changer de venv. Pour cela on a une commande pour "désactiver" un environnement. C'est la fonction symétrique de activate.

(tutorial-env) $ deactivate
$

Gestion des paquets

On utilise pip comme d'habitude. Par exemple si je veux installer pyttsx3:

python -m pip install pyttsx3

qui fonctionne comme si on était dans un environnement classique :

Looking in indexes: https://pypi.org/simple, https://www.piwheels.org/simple
Collecting pyttsx3
  Downloading https://www.piwheels.org/simple/pyttsx3/pyttsx3-2.99-py3-none-any.whl (32 kB)
Installing collected packages: pyttsx3
Successfully installed pyttsx3-2.99

on peut alors utiliser le module.

(tutorial-env) $ python3
Python 3.11.2 (main, Nov 30 2024, 21:22:50) [GCC 12.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import pyttsx3
>>> engine = pyttsx3.init()
>>>

si on désactive le venv avec deactivate :

(tutorial-env) $ deactivate
$ python3
Python 3.11.2 (main, Nov 30 2024, 21:22:50) [GCC 12.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import pyttsx3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ModuleNotFoundError: No module named 'pyttsx3'
>>>

voila le module n'est plus installé.

Lors de la rédaction de cette page j'ai utilisé la doc officielle :https://docs.python.org/fr/3/tutorial/venv.html et l'aide de copilot https://m365.cloud.microsoft/chat/.

Utilisation de Git et des environnements virtuels Python (venv)

Cette page décrit une méthode simple pour gérer un projet Python avec Git et un environnement virtuel (venv).

Principe général

Le dépôt Git contient :

• le code source ;
• la documentation ;
• les fichiers de configuration ;
• la liste des dépendances Python.

Le dépôt Git ne contient pas :

• le venv ;
• les modules installés ;
• les fichiers temporaires Python.

L'environnement virtuel est recréé sur chaque machine à partir du fichier requirements.txt.

Structure recommandée

elec-lab/
├── .git/
├── .gitignore
├── .venv/
├── README.md
├── requirements.txt
├── src/
└── tests/

Création du dépôt

Créer un dépôt vide sur le serveur Git :

repo/elec-lab

Puis cloner le projet :

git clone git:repo/elec-lab
cd elec-lab

Création du venv

Depuis la racine du dépôt :

python3 -m venv .venv

Activation :

source .venv/bin/activate

L'invite change généralement :

(.venv) admin@machine:~/sources/elec-lab$

Installation des modules

Exemple :

pip install pyserial
pip install tenma

Vérifier les modules installés :

pip list

Fichier .gitignore

Créer un fichier :

.gitignore

Contenu conseillé :

# Environnement virtuel
.venv/

# Cache Python
__pycache__/
*.pyc

# Fichiers d'éditeur
.vscode/
.idea/

# Fichiers temporaires
*.log

Génération du fichier requirements.txt

Après installation des dépendances :

pip freeze > requirements.txt

Exemple :

pyserial==3.5
tenma==1.1.1

Premier commit

Ajouter les fichiers :

git add .

Créer un commit :

git commit -m "Initial commit"

Envoyer sur le serveur :

git push -u origin master

ou selon la configuration :

git push -u origin main

Cycle de développement quotidien

Modifier les fichiers puis :

git status
git add .
git commit -m "Description de la modification"
git push

Récupération du projet sur un autre poste

Cloner le dépôt :

git clone git:repo/elec-lab
cd elec-lab

Créer un nouveau venv :

python3 -m venv .venv

Activer le venv :

source .venv/bin/activate

Réinstaller les dépendances :

pip install -r requirements.txt

Le projet est alors prêt à être utilisé.

Moi je crée un petit script bash:

python3 -m venv .venv
source .venv/bin/activate
pip install -r requirement.txt