URL:     https://linuxfr.org/news/environnement-moderne-de-travail-python
Title:   Environnement moderne de travail Python
Authors: sispheor
         palm123, Pierre Jarillon, Ysabeau, Nils Ratusznik et ted
Date:    2022-05-19T17:05:36+02:00
License: CC By-SA
Tags:    python3
Score:   3


# Environnement moderne de travail Python



Si vous développez ou utilisez des programmes s’exécutant au-dessus de l’interpréteur Python, il peut arriver que vous vous retrouviez avec un environnement très dégradé sur votre poste de travail..


Je propose ici de découvrir un ensemble d’outils permettant de configurer des environnements Python qui vous éviteront de polluer votre système ou vos futurs environnements de développement. En effet, entre votre système Linux et les multiples projets de développement sur lequel vous travaillez vous avez souvent besoin d’interpréteur Python dans des versions différentes ou de librairies dans des versions particulières.



Dans ce guide, nous allons voir comment installer un environnement Python répondant aux cas d’usage suivants :



- gestion facile de multiple versions de l’interpréteur Python ;
- isolation d’applications CLI basées sur Python ;
- création d’environnements de développement isolés les uns des autres.

----


----

# Installation de l’environnement



Nous allons utiliser les outils suivants:



- pyenv ;
- pip ;
- pipx ;
- poetry.


## Pyenv



[Pyenv](https://github.com/pyenv/pyenv) est un outil qui permet d’installer et gérer facilement vos interpréteurs Python. Il vous permet d’utiliser un interpréteur qui n’est pas celui de votre système.


Les distributions Linux sont souvent livrées avec un Python pré-installé (généralement sous /bin/python) permettant de gérer des programmes nécessaires au bon fonctionnement de votre système. Certains de ces programmes sont critiques et il est donc recommandé de **ne pas toucher à l’interpréteur natif de votre système Linux**.



Installation de Pyenv



```bash
curl https://pyenv.run | bash
```





Une fois installé, il faut modifier la configuration de votre shell afin qu’il initialise Pyenv à chaque ouverture de terminal.



Ajoutez ces lignes a votre bashrc (ou zshrc):



```bash
export PYENV_ROOT="$HOME/.pyenv"
command -v pyenv >/dev/null || export PATH="$PYENV_ROOT/bin:$PATH"
eval "$(pyenv init -)"
```





Ouvrez un nouveau terminal et testez que pyenv :


```bash
pyenv
pyenv 2.3.0
```





Pour installer une version particulière de Python, utilisez la commande `pyenv install`. Par exemple :


```bash
pyenv install 3.9.10
```





Vous pouvez lister les versions de Python installées


```bash
pyenv versions
```





## Pip



Pip est tout simplement un installeur de librairie Python disponible sur [https://pypi.org/](https://pypi.org/).


On télécharge l’installeur officiel :


```bash
wget https://bootstrap.pypa.io/get-pip.py
```





On le lance (avec le python3 du système)



```bash
sudo python3 get-pip.py
```





On vérifie que pip3 est bien installé pour notre interpréteur système


```bash
pip3 --version
pip 22.1 from /usr/local/lib/python3.10/dist-packages/pip (python 3.10)
```





## Pipx



[Pipx](https://pypa.github.io/pipx/) permet d’installer des outils CLI dans des environnements isolés et les expose de la même façon que s’ils avaient été installés par pip ou un paquet système.



Très pratique pour éviter les conflits entre plusieurs outils de CLI qui reposent souvent sur des librairies open-source communes mais dans des versions différentes. Il permet aussi d’installer plusieurs versions différentes d’une application CLI.



Installation du paquet `venv` qui permet de créer des environnements virtuels. Cette librairie est utilisée par pipx pour isoler les installations.



```bash
sudo apt install python3-venv
```





Installation de pipx via pip



```bash
sudo pip3 install pipx virtualenv
```





Pipx expose les applications qu’il installe en ajoutant un lien dans le chemin `~/.local/bin`. Il faut donc ajouter ce chemin à votre « PATH ». Dans votre bashrc (ou zshrcè) :


```bash
export PATH="$PATH:$HOME/.local/bin/"
```





On va à présent installer une application basée sur Python. Prenons par exemple Ansible. Ici, nous précisons à pipx d’utiliser l’interpréteur Python installé avec Pyenv précédemment :


```bash
pipx install --python /home/nico/.pyenv/versions/3.9.10/bin/python3.9 ansible --include-deps
```





Ansible est à présent installé dans un environnement virtuel. Les bibliothèques qu’il utilise sont isolées des bibliothèques Python utilisées par le système.


Pour lister les programmes que vous avez installés via pipx :



```bash
pipx list
```





Si le programme que vous avez installé a lui-même besoin d’autres bibliothèques Python pour fonctionner, c’est le cas, par exemple, avec Ansible dont les modules reposent parfois sur des bibliothèques communautaires, vous pouvez les injecter dans l’environnement virtuel. Dans cet exemple, on injecte les bibliothèques pyvmomi, python-ldap, kubernetes et hvac à notre environnement `ansible` :


```bash
pipx inject ansible pyvmomi python-ldap kubernetes hvac
```





Il est possible également de gérer plusieurs versions d’un même programme et de l’exposer au système avec un suffixe différent. Ainsi, je souhaite installer la dernière version d’Ansible (Ansible 5) tout en gardant la première version installée :



```bash
pipx install --suffix -5 --python /home/nico/.pyenv/versions/3.9.10/bin/python3.9 --include-deps ansible
```





La commande `ansible-playbook` pour cette version est alors exposée sous `ansible-playbook-5`.



```bash
ansible-playbook-5 --version
ansible-playbook [core 2.12.5]
  config file = None
  configured module search path = ['/home/nico/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules']
  ansible python module location = /home/nico/.local/pipx/venvs/ansible/lib/python3.9/site-packages/ansible
  ansible collection location = /home/nico/.ansible/collections:/usr/share/ansible/collections
  executable location = /home/nico/.local/bin//ansible-playbook
  python version = 3.9.10 (main, May 19 2022, 14:16:15) [GCC 11.2.0]
  jinja version = 3.1.2
  libyaml = True
```





## Poetry



[Poetry](https://python-poetry.org/) est un gestionnaire de dépendances Python. C’est une sorte de pip++. Il permet d’installer des librairies Python, de s’assurer que l’environnement de développement d’un projet soit isolé et identique pour tous les développeurs, de gérer les conflits d’installation ou encore de publier son paquet Python.


Poetry est un outil CLI écrit en Python, pour l’installation nous pouvons donc utiliser pipx :



```bash
pipx install poetry
```





On vérifie l’installation



```bash
poetry --version
Poetry version 1.1.13
```





   Création d’un projet


```bash
poetry new poetry-demo
```





Cette commande effectue 2 choses :


- la création d’un répertoire pour le projet avec des fichiers nécessaires à la gestion des dépendances,
- la création d’un environnement virtuel pour le projet.

```bash
tree poetry-demo

poetry-demo
├── pyproject.toml
├── README.rst
├── poetry_demo
│   └── __init__.py
└── tests
    ├── __init__.py
    └── test_poetry_demo.py
```





Si l’on veut ajouter une librairie, on va alors se servir de la CLI :



```bash
poetry add django
```





Si l’on souhaite activer l’environnement virtuel du projet, on se place dedans et on appelle la commande shell.


```bash
cd poetry-demo
poetry shell
```





# Mot de la fin



Ce tutoriel a été réalisé sur une machine Ubuntu 22.04, mais devrait fonctionner de la même façon sur d’autres distributions. Il existe, bien sur, d’autres façons de gérer ces environnements Python, ceci n’est qu’un exemple qui permet de travailler plus proprement avec Python. Il fonctionne dans un contexte d’administration système avec la gestion des CLI via pipx ou dans un contexte de développement logiciel via l’usage de poetry.