L’environnement de développement

Définition¶

On appelle ici environnement de développement un espace restreint, facile à reproduire et à effacer qui prend en compte l’ensemble des dépendances de notre projet Python. Il permet de travailler de manière isolée. Il permet également à d’autres contributeurs de travailler dans une même configuration.

Les outils¶

Il en existe un certain nombre et c’est en les utilisant que l’on peut se faire sa propre opinion. J’utilise pour ma part mamba et pixi car je ne développe pas qu’en Python et conda-forge est bien pratique lorsqu’on a des dépendances à des librairies écrites dans d’autres langages. Mais, pour des développements que Python, d’autres choix peuvent être plus pertinents.

Voici une liste d’outils que vous pouvez utiliser pour créer vos environnements de développement

venv
Cet outil est disponible depuis la version 3.3 de Python et est installé sur votre système en même temps que Python.
pipenv
Cet outil offre plus de flexibilité que venv.
mamba
Cet outil permet de gérer plusieurs environnements en s’appuyant sur les packages se trouvant sur PyPi et sur les différentes channels de conda. Il est particulièrement utile quand on a des dépendances compilées (C, C++, Fortran).
poetry
Cet outil ressemble à ce que l’on peut trouver lorsqu’on utilise nodejs à savoir que la configuration de votre environnement va évoluer en fonction de ce que vous installez et ce que vous désinstallez. Tous ces changements sont décrits dans un fichier permettant de reproduire un environnement à l’identique.
uv
uv est un gestionnaire de paquets Python nouvelle génération et multiplateforme, développé par Astral (l’équipe derrière Ruff), et écrit en Rust pour des performances exceptionnelles. Il se veut un remplaçant rapide et moderne de pip, pip-tools, poetry, virtualenv, pyenv, pipx, et même twine, en offrant une interface unique et cohérente pour gérer l’installation de paquets, la résolution des dépendances, la gestion des environnements virtuels, et même l’installation de différentes versions de Python
pixi
Pixi est un gestionnaire de paquets moderne et multiplateforme, conçu pour gérer les environnements et dépendances Python (et d’autres langages) de manière rapide, fiable et reproductible. Développé en Rust et basé sur l’écosystème conda, il permet d’installer des paquets depuis conda et PyPI, tout en résolvant automatiquement les dépendances et en générant un fichier de verrouillage (lock file) pour garantir la reproductibilité des environnements. Il est également possible de définir des tâches personnalisées pour automatiser les workflows de développement.

Définir ses dépendances via `requirements.txt` ou `environment.yml`¶

Si nous avons vu précédemment que certains outils pouvaient écrire leur propre fichier indiquant les dépendances d’un environnement, nous allons voir ici deux formats un peu plus universels

requirements.txt est un fichier permettant de décrire les dépendances et peut être utilisé avec l’ensemble des outils cités.
environment.yml est utilisé par les outils s’appuyant sur des packages conda.

Exemple de fichier `requirements.txt`¶

Sans versions définies

numpy
matplotlib
jupyterlab

Avec des versions bien précises

numpy>1.20
matplotlib==3.7.1
jupyterlab>4.0,<4.1

Exemple de fichier `environment.yml`¶

Sans versions définies

name: my-env
channels:
    - conda-forge
dependencies:
    - numpy
    - matplotlib
    - jupyterlab

Avec des versions bien précises

name: my-env
channels:
    - conda-forge
dependencies:
    - numpy>1.20
    - matplotlib=3.7.1
    - jupyterlab>4.0,<4.1

Installer son environnement¶

Avec le fichier `requirements.txt`¶

En utilisant pipenv

pipenv install -r requirements.txt

En utilisant mamba
Il faut d’abord créer un environnement avec la version Python que vous souhaitez
```
mamba create -n my-env python
```
puis l’activer
```
mamba activate my-env
```
Puis installer les dépendances
```
mamba install --file requirements.txt
```

Avec le fichier `environment.yml`¶

Cet étape se fait uniquement avec mamba.

mamba env create --file environment.yml

Il ne reste plus qu’à activer l’environment

mamba activate my-env

On va voir comment initialiser un environnement avec deux outils modernes : uv et pixi. Ces deux-là sont écrits en Rust, donc très rapides, et apportent des fonctionnalités bien au-delà de la simple gestion de dépendances.

Utilisation de uv¶

Il est également possible de construire son environnement via uv de manière incrémentale en ajoutant au fur et à mesure les dépendances de son projet et en créant un ensemble de tâches nous facilitant le travail.

La première chose à faire est d’installer uv en suivant ce lien: https://docs.astral.sh/uv/getting-started/installation/

Placez-vous dans le répertoire practical_session, puis initialiser l’environnement de développement en utilisant la commande suivante

uv init

Vous avez à présent un fichier pyproject.toml qui initialise votre environnement de développement. Il contient normalement au moins les éléments suivants

[project]
name = "project-name"
version = "0.1.0"
description = "Add your description here"
readme = "README.md"
requires-python = ">=3.10"
dependencies = []

Vous pouvez facilement ajouter vos dépendances à l’aide de la commande uv add.

uv add numpy

Vous pouvez mettre à jour votre environnement avec la commande

uv sync

uv est super pour des projets purement Python. Mais dans cette formation, on va utiliser pixi. Pourquoi ? Parce que pixi s’appuie sur l’écosystème conda, ce qui le rend très pratique dès qu’on a des dépendances compilées (du C, du C++, du Fortran). Et puis, il a un système de features et d’environnements qui permet de bien organiser les différents outils dont on a besoin au cours du développement (linter, tests, documentation, build...).

Vous verrez, on va l’utiliser tout au long de la formation et vous allez vite l’adopter !

Utilisation de pixi¶

Il est également possible de construire son environnement via pixi de manière incrémentale en ajoutant au fur et à mesure les dépendances de son projet et en créant un ensemble de tâches nous facilitant le travail.

La première chose à faire est d’installer pixi en suivant ce lien: https://pixi.sh/latest/installation/

Placez-vous dans le répertoire practical_session, puis initialiser l’environnement de développement en utilisant la commande suivante

pixi init

Vous avez à présent un fichier pixi.toml qui initialise votre environnement de développement. Il contient normalement au moins les éléments suivants

[project]
name = "project name"
channels = ["conda-forge"]
platforms = ["osx-arm64"]

[tasks]

[dependencies]

La section projet vous permet de spécifier où aller chercher les paquets (ici conda-forge) et pour quel type de plateforme (ici osx-arm64).

Vous pouvez facilement ajouter vos dépendances à l’aide de la commande pixi add.

pixi add numpy

Si vous retournez dans le fichier pixi.toml vous devriez voir l’ajout de numpy dans les dépendances avec une version fixée. Un fichier pixi.lock a également été créé. Ce fichier contient l’arbre des dépendances permettant de réinstaller à l’identique votre environnement de développement.

Nous souhaiterions à présent que cet environnement soit installable sur différentes plateformes (linux, macos, windows). Nous allons ici ajouter la plateforme linux-64 directement dans le fichier pixi.toml. Avec la commande

pixi update

nous mettons à jour pixi.lock.

Pour travailler dans l’environnement, vous disposez de deux commandes pixi runpour exécuter une ligne de commande ou pixi shell qui peut être vu comme l’équivalent de l’activation de l’environnement pour mamba.

Ce qu’on a accompli¶

Et voilà, vous avez posé la première pierre de l’édifice. Vous savez maintenant :

Ce qu’est un environnement de développement et pourquoi c’est indispensable
Quels outils existent et dans quels cas les utiliser
Comment décrire des dépendances avec requirements.txt et environment.yml
Comment initialiser un projet avec pixi et ajouter des dépendances
Comment utiliser l’environnement avec pixi run et pixi shell

On a aussi ajouté la plateforme linux-64 pour que notre environnement soit utilisable sur d’autres machines. C’est un premier pas vers la reproductibilité complète.

Prêt pour la suite ? On va maintenant transformer notre code en un véritable package Python !