Python

Description

Python est un langage de programmation interprété dont la philosophie de design repose principalement sur la lisibilité du code. Sa syntaxe est simple et expressive et sa bibliothèque de modules standards est très étendue.

Les capacités du langage Python peuvent être étendues à l'aide de paquets développés par des tiers. En général, nous n'installons pas les paquets de tiers dans le répertoire de logiciels disponibles afin de simplifier le plus possible les opérations; il vous revient donc de les installer. En revanche, nous mettons à votre disposition plusieurs versions de l'interpréteur Python et les outils nécessaires pour que vous puissiez facilement installer les paquets dont vous avez besoin.

Les sections suivantes présentent l'interpréteur Python et expliquent comment installer et utiliser les paquets.

Charger l'interpréteur

Version par défaut

Une version est disponible quand vous vous connectez à nos grappes, mais vous aurez souvent besoin d'une version différente, surtout si vous voulez installer des paquets. Trouvez la version de Python dont vous avez besoin et chargez le module approprié. En cas de doute, vous pouvez utiliser la plus récente version disponible.

Charger un module Python

Pour connaître les versions disponibles, utilisez

[name@server ~]$ module avail python

Vous pouvez ensuite charger la version de votre choix avec la commande module load, par exemple, pour charger Python 3.10 avec

[name@server ~]$ module load python/3.10

Version supportée

En règle générale dans l'écosystème Python, la transition vers des versions plus modernes s'accélère et plusieurs paquets ne supportent que les quelques dernières versions de Python 3.x. Dans notre cas, nous offrons uniquement des paquets pré-construits (wheels Python) pour les trois versions les plus récentes disponibles sur nos systèmes. Des problèmes de dépendance se présenteront quand vous tentez d'installer ces paquets avec les plus anciennes versions de Python. Voir la section Dépannage.

Le tableau suivant montre les dates auxquelles nous avons cessé de construire des wheels pour les versions de Python.

Version	Date
3.10
3.9
3.8
3.7	2022-02
3.6	2021-02
3.5	2020-02
2.7	2020-01

Pile logicielle SciPy

En plus du module Python de base, le paquet SciPy est aussi disponible comme module d'environnement. Le module scipy-stack comprend

• NumPy
• SciPy
• Matplotlib
  • dateutil
  • pytz
• IPython
  • pyzmq
  • tornado
• pandas
• Sympy
• nose

Pour utiliser un de ces paquets, chargez une version de Python, puis module load scipy-stack.

Pour la liste et les numéros de version des paquets contenus dans scipy-stack, lancez module spider scipy-stack/2020a (en remplaçant 2020a par la version que vous voulez).

Créer et utiliser un environnement virtuel

Avec chaque version de Python vient l'outil virtualenv qui permet de créer des environnements virtuels à l'intérieur desquels vous pourrez installer facilement vos paquets Python. Ces environnements permettent par exemple d'installer plusieurs versions d'un même paquet, ou encore de compartimenter les installations en fonction des besoins ou des expériences à réaliser. Vous créeriez habituellement vos environnements virtuels Python dans votre répertoire /home ou dans un de vos répertoires /project. Pour une troisième option, voyez ci-dessous la section Créer un environnement virtuel dans vos tâches.

Où créer un environnement virtuel

Ne créez pas votre environnement virtuel dans $SCRATCH à cause du risque qu'il soit en partie détruit. Voyez plutôt Créer un environnement virtuel dans vos tâches ci-dessous.

Pour créer un environnement virtuel, sélectionnez d'abord une version de Python avec module load python/X.Y.Z, comme indiqué ci-dessus dans Charger un module Python. Si vous voulez utiliser les paquets listés dans Pile logicielle SciPy, lancez aussi module load scipy-stack/X.Y.Z. Entrez ensuite la prochaine commande, où ENV est le nom du répertoire pour votre nouvel environnement.

[name@server ~]$ virtualenv --no-download ~/ENV

Une fois l'environnement virtuel créé, il ne vous reste plus qu'à l'activer avec

[name@server ~]$ source ~/ENV/bin/activate

Vous devriez aussi faire la mise à jour de pip dans l'environnement.

[name@server ~]$ pip install --no-index --upgrade pip

Pour quitter l'environnement virtuel, entrez simplement la commande

(ENV) [name@server ~] deactivate

Pour réutiliser l'environnement virtuel :

1. Chargez les mêmes modules d'environnement que vous avez chargés quand l'environnement virtuel a été créé, soit module load python scipy-stack.
2. Activez l'environnement avec source ENV/bin/activate.

Installer des paquets

Une fois que vous avez chargé un environnement virtuel, vous pouvez lancer la commande pip. Cette commande prend en charge la compilation et l'installation de la plupart des paquets Python et de leurs dépendances. Consultez l'index complet des paquets Python.

Les commandes disponibles sont expliquées dans le manuel d'utilisation pip. Nous mentionnons ici les commandes les plus importantes en présentant un exemple d'installation du paquet NumPy.

Chargeons d'abord l'interpréteur Python avec

[name@server ~]$ module load python/3.10

Ensuite, activons l'environnement virtuel créé précédemment avec la commande virtualenv.

[name@server ~]$ source ~/ENV/bin/activate

Enfin, nous pouvons installer la dernière version stable de NumPy avec

(ENV) [name@server ~] pip install numpy --no-index

La commande pip peut installer des paquets à partir de plusieurs sources, dont PyPI et les paquets de distribution préconstruits appelés Python wheels. Nous fournissons des wheels Python pour plusieurs paquets. Dans l'exemple ci-dessus, l'option --no-index demande à pip de ne pas installer à partir de PyPI, mais plutôt de n'installer qu'à partir de paquets de source locale, soit de nos wheels.

Si un de nos wheels est disponible pour un paquet que vous voulez, nous vous recommandons fortement de l'utiliser avec l'option --no-index. Contrairement aux paquets de PyPI, les wheels compilés par notre personnel évitent les problèmes de dépendances manquantes ou conflictuelles et sont de plus optimisés pour nos grappes et nos bibliothèques. Voyez Wheels disponibles.

Si vous omettez l'option --no-index, pip cherchera les paquets PyPI et les paquets locaux et utilisera la version la plus récente. Si celle-ci est de PyPI, elle sera installée plutôt la nôtre et vous aurez possiblement des problèmes. Si vous préférez télécharger un paquet PyPI plutôt que d'utiliser un wheel, utilisez l'option --no-binary qui demande à pip de ne considérer aucun paquet préconstruit; ainsi, les wheels distribués via PyPI ne seront pas considérés et le paquet sera toujours compilé de la source.

Pour savoir d'où provient le paquet Python installé par pip, ajoutez l'option -vvv. Lorsque vous installez plusieurs paquets Python, il est préférable de les installer en une seule étape, puisque pip peut alors résoudre les dépendances croisées.

Créer un environnement virtuel dans vos tâches

Les systèmes de fichiers parallèles comme ceux qui sont installés sur nos grappes sont très efficaces lorsqu'il s'agit de lire ou d'écrire de grandes portions de données, mais pas pour une utilisation intensive de petits fichiers. Pour cette raison, le lancement d'un logiciel et le chargement de bibliothèques peuvent être lents, ce qui se produit quand on lance Python et qu'on charge un environnement virtuel.

Pour contrer ce genre de ralentissement, particulièrement pour les tâches Python sur un nœud unique, vous pouvez créer votre environnement virtuel à l'intérieur de votre tâche en utilisant le disque local du nœud de calcul. Il peut sembler déraisonnable de recréer votre environnement pour chacune de vos tâches, mais c'est souvent plus rapide et plus efficace que d'utiliser le système de fichiers parallèles. Il faut créer un virtualenv localement sur chacun des nœuds utilisés par la tâche puisque l'accès à virtualenv se fait par nœud. Le script suivant en est un exemple

File : submit_venv.sh

#!/bin/bash
#SBATCH --account=def-someuser
#SBATCH --mem-per-cpu=1.5G      # increase as needed
#SBATCH --time=1:00:00

module load python/3.10
virtualenv --no-download $SLURM_TMPDIR/env
source $SLURM_TMPDIR/env/bin/activate
pip install --no-index --upgrade pip

pip install --no-index -r requirements.txt
python ...

où le fichier requirements.txt aura été créé dans un environnement de test. Par exemple, pour créer un environnement pour TensorFlow, utilisez les commandes suivantes dans un nœud de connexion :

[name@server ~]$ module load python/3.10
[name@server ~]$ ENVDIR=/tmp/$RANDOM
[name@server ~]$ virtualenv --no-download $ENVDIR
[name@server ~]$ source $ENVDIR/bin/activate
[name@server ~]$ pip install --no-index --upgrade pip
[name@server ~]$ pip install --no-index tensorflow
[name@server ~]$ pip freeze --local > requirements.txt
[name@server ~]$ deactivate
[name@server ~]$ rm -rf $ENVDIR

Ceci produit le fichier requirements.txt dont le contenu ressemble à ceci :

File : requirements.txt

absl_py==1.2.0+computecanada
astunparse==1.6.3+computecanada
cachetools==5.2.0+computecanada
certifi==2022.6.15+computecanada
charset_normalizer==2.1.0+computecanada
flatbuffers==1.12+computecanada
gast==0.4.0+computecanada
google-pasta==0.2.0+computecanada
google_auth==2.9.1+computecanada
google_auth_oauthlib==0.4.6+computecanada
grpcio==1.47.0+computecanada
h5py==3.6.0+computecanada
idna==3.3+computecanada
keras==2.9.0+computecanada
Keras-Preprocessing==1.1.2+computecanada
libclang==14.0.1+computecanada
Markdown==3.4.1+computecanada
numpy==1.23.0+computecanada
oauthlib==3.2.0+computecanada
opt-einsum==3.3.0+computecanada
packaging==21.3+computecanada
protobuf==3.19.4+computecanada
pyasn1==0.4.8+computecanada
pyasn1-modules==0.2.8+computecanada
pyparsing==3.0.9+computecanada
requests==2.28.1+computecanada
requests_oauthlib==1.3.1+computecanada
rsa==4.8+computecanada
six==1.16.0+computecanada
tensorboard==2.9.1+computecanada
tensorboard-data-server==0.6.1+computecanada
tensorboard_plugin_wit==1.8.1+computecanada
tensorflow==2.9.0+computecanada
tensorflow_estimator==2.9.0+computecanada
tensorflow_io_gcs_filesystem==0.23.1+computecanada
termcolor==1.1.0+computecanada
typing_extensions==4.3.0+computecanada
urllib3==1.26.11+computecanada
Werkzeug==2.1.2+computecanada
wrapt==1.13.3+computecanada

Ce fichier fait en sorte que votre environnement puisse être reproduit pour les autres tâches.

Remarquez que les directives ci-dessus exigent que tous les paquets dont vous avez besoin soient disponibles dans les wheels Python que nous fournissons. Si ce n'est pas le cas, vous pouvez le prétélécharger (voir Prétélécharger des paquets ci-dessous). Si vous croyez que les wheels devraient être fournis, faites-en la demande au soutien technique

Créer un environnement virtuel dans vos tâches (plusieurs nœuds)

Pour que vos scripts utilisent plusieurs nœuds, chacun doit avoir son propre environnement activé.

1. Dans votre script de soumission de la tâche, créez l'environnement virtuel pour chacun des nœuds alloués.

srun --ntasks $SLURM_NNODES --tasks-per-node=1 bash << EOF

virtualenv --no-download $SLURM_TMPDIR/env
source $SLURM_TMPDIR/env/bin/activate

pip install --no-index --upgrade pip
pip install --no-index -r requirements.txt

EOF

2. Activez l'environnement virtuel du nœud principal.

source $SLURM_TMPDIR/env/bin/activate;

3. Exécutez le script avec

srun python myscript.py;

Exemple (plusieurs nœuds)

File : submit-nnodes-venv.sh

#!/bin/bash
#SBATCH --account=<your account>
#SBATCH --time=00:30:00
#SBATCH --nodes=2
#SBATCH --ntasks=2
#SBATCH --mem-per-cpu=2000M

module load StdEnv/2023 python/3.11 mpi4py

# créer l'environnement virtuel pour chacun des nœuds.
srun --ntasks $SLURM_NNODES --tasks-per-node=1 bash << EOF
virtualenv --no-download $SLURM_TMPDIR/env
source $SLURM_TMPDIR/env/bin/activate

pip install --no-index --upgrade pip
pip install --no-index -r requirements.txt
EOF

# activer uniquement sur le nœud principal                                                               
source $SLURM_TMPDIR/env/bin/activate;
# srun exporte l'environnement actuel qui contient
 $VIRTUAL_ENV and $PATH variables
srun python myscript-mpi.py;

Wheels disponibles

Les wheels présentement disponibles sont listés sur la page Wheels Python. Vous pouvez aussi utiliser la commande avail_wheels sur la grappe. Par défaut, cette commande montre seulement

• la plus récente version d'un paquet en particulier, à moins qu'une version particulière n'ait été spécifiée;
• les versions compatibles avec le module Python chargé ou l'environnement virtuel activé; autrement, toutes les versions sont affichées;
• les versions compatibles avec l'architecture CPU et l'environnement logiciel (StdEnv) que vous utilisez à ce moment.

Noms

Pour la liste des wheels qui contiennent cdf (insensible à la casse) dans leur nom, lancez

[name@server ~]$ avail_wheels "*cdf*"
name      version    python    arch
--------  ---------  --------  -------
h5netcdf  0.7.4      py2,py3   generic
netCDF4   1.5.8      cp39      avx2
netCDF4   1.5.8      cp38      avx2
netCDF4   1.5.8      cp310     avx2

ou utilisez le nom exact, par exemple

[name@server ~]$ avail_wheels numpy
name    version    python    arch
------  ---------  --------  -------
numpy   1.23.0     cp39      generic
numpy   1.23.0     cp38      generic
numpy   1.23.0     cp310     generic

Version

Pour la liste d'une version particulière, vous pouvez utiliser le même format qu'avec `pip`:

[name@server ~]$ avail_wheels numpy==1.23
name    version    python    arch
------  ---------  --------  -------
numpy   1.23.0     cp39      generic
numpy   1.23.0     cp38      generic
numpy   1.23.0     cp310     generic

ou employer la version plus longue, comme

[name@server ~]$ avail_wheels numpy --version 1.23
name    version    python    arch
------  ---------  --------  -------
numpy   1.23.0     cp39      generic
numpy   1.23.0     cp38      generic
numpy   1.23.0     cp310     generic

Avec le format pip, vous pouvez utiliser différents opérateurs%nbsp: ==, <, >, ~=, <=,>=, !=. Par exemple, pour lister les versions antérieures,

[name@server ~]$ avail_wheels 'numpy<1.23'
name    version    python    arch
------  ---------  --------  -------
numpy   1.22.2     cp39      generic
numpy   1.22.2     cp38      generic
numpy   1.22.2     cp310     generic

et pour lister toutes les versions disponibles,

[name@server ~]$ avail_wheels "*cdf*" --all-version
name      version    python    arch
--------  ---------  --------  -------
h5netcdf  0.7.4      py2,py3   generic
netCDF4   1.5.8      cp39      avx2
netCDF4   1.5.8      cp38      avx2
netCDF4   1.5.8      cp310     avx2
netCDF4   1.5.6      cp38      avx2
netCDF4   1.5.6      cp37      avx2
netCDF4   1.5.4      cp38      avx2
netCDF4   1.5.4      cp37      avx2
netCDF4   1.5.4      cp36      avx2

Python

Pour lister une version particulière de Python, lancez

[name@server ~]$ avail_wheels 'numpy<1.23' --python 3.9
name    version    python    arch
------  ---------  --------  -------
numpy   1.22.2     cp39      generic

La colonne python montre la version de Python pour laquelle le wheel est disponible, où cp39 est utilisé pour cpython 3.9.

Requirements file

Pour savoir si les wheels disponibles incluent ceux qui sont indiqués dans le fichier requirements.txt, lancez

[name@server ~]$ avail_wheels -r requirements.txt 
name       version    python    arch
---------  ---------  --------  -------
packaging  21.3       py3       generic
tabulate   0.8.10     py3       generic

Pour la liste de ceux qui ne sont pas disponibles, la commande est

[name@server ~]$ avail_wheels -r requirements.txt --not-available
name       version    python    arch
---------  ---------  --------  -------
packaging  21.3       py3       generic
pip
tabulate   0.8.10     py3       generic

Prétélécharger des paquets

La procédure suivante prétélécharge le paquet tensorboardX sur un nœud de connexion et l'installe sur un nœud de calcul :

1. Lancez pip download --no-deps tensorboardX pour télécharger le paquet tensorboardX-1.9-py2.py3-none-any.whl (ou semblable) dans le répertoire de travail. La syntaxe pour pip download est la même que celle pour pip install.
2. Si le nom du fichier ne se termine pas pas none-any, mais par linux_x86_64 ou manylinux*_x86_64, il est possible que le wheel ne fonctionnera pas correctement. Cpontactez le soutien technique pour que nous compilions le wheel et le rendre disponible sur nos superordinateurs.
3. À l'installation, utilisez le chemin du fichier pip install tensorboardX-1.9-py2.py3-none-any.whl.

Programmation parallèle avec le module multiprocessing

La programmation parallèle avec Python est un moyen facile d'obtenir des résultats plus rapidement, ce qui est habituellement accompli avec l'utilisation du module multiprocessing. La classe Pool de ce module est particulièrement intéressante car elle permet de contrôler le nombre de processus lancés en parallèle pour exécuter le même calcul avec des données multiples. Supposons que nous voulons calculer le <codet>cube d'une liste de nombres; le code série serait semblable à :

Avec une bouclePar mappage

File : cubes_sequential.py

def cube(x):
    return x**3

data = [1, 2, 3, 4, 5, 6]
cubes = [cube(x) for x in data]
print(cubes)

File : cubes_sequential.py

def cube(x):
    return x**3

data = [1, 2, 3, 4, 5, 6]
cubes = list(map(cube,data))
print(cubes)

Avec la classe Pool le code parallèle devient :

Avec une bouclePar mappage

File : cubes_parallel.py

import multiprocessing as mp

def cube(x):
    return x**3

pool = mp.Pool(processes=4)
data = [1, 2, 3, 4, 5, 6]
results = [pool.apply_async(cube, args=(x,)) for x in data]
cubes = [p.get() for p in results]
print(cubes)

File : cubes_parallel.py

import multiprocessing as mp

def cube(x):
    return x**3

pool = mp.Pool(processes=4)
data = [1, 2, 3, 4, 5, 6]
cubes = pool.map(cube, data)
print(cubes)

Dans les exemples précédents, nous sommes toutefois limités à quatre processus. Avec une grappe, il est très important d'utiliser les cœurs qui sont alloués à la tâche. Si le nombre de processus exécutés dépasse le nombre de cœurs demandés pour la tâche, les calculs s'effectueront plus lentement et le nœud de calcul sera possiblement surchargé. Si le nombre de processus exécutés est inférieur au nombre de cœurs demandés, certains cœurs resteront inactifs et les ressources ne seront pas utilisées de façon optimale. Votre code devrait faire appel à autant de cœurs que la quantité de ressources demandées à l'ordonnanceur. Par exemple, pour exécuter le même calcul sur des dizaines de données ou plus, il serait sensé d'utiliser tous les cœurs d'un nœud. Dans ce cas, le script de soumission de la tâche aurait l'en-tête suivant :

File : submit.sh

#SBATCH --ntasks-per-node=1
#SBATCH --cpus-per-task=32

python cubes_parallel.py

Le code serait alors :

Avec une bouclePar mappage

File : cubes_parallel.py

import multiprocessing as mp
import os

def cube(x):
    return x**3

ncpus = int(os.environ.get('SLURM_CPUS_PER_TASK',default=1))
pool = mp.Pool(processes=ncpus)
data = [1, 2, 3, 4, 5, 6]
results = [pool.apply_async(cube, args=(x,)) for x in data]
cubes = [p.get() for p in results]
print(cubes)

File : cubes_parallel.py

import multiprocessing as mp
import os

def cube(x):
    return x**3

ncpus = int(os.environ.get('SLURM_CPUS_PER_TASK',default=1))
pool = mp.Pool(processes=ncpus)
data = [1, 2, 3, 4, 5, 6]
cubes = pool.map(cube, data)
print(cubes)

Remarquez que dans cet exemple, la fonction cube est en elle-même séquentielle. Il est possible qu'une fonction appelée d'une bibliothèque externe comme numpy soit en elle-même parallèle. Pour distribuer des processus avec la technique précédente, vérifiez d'abord si les fonctions appelées sont en elles-mêmes parallèles et si c'est le cas, vous devrez contrôler le nombre de fils qu'elles utiliseront. Si comme dans l'exemple les fonctions utilisent la totalité des cœurs disponibles (ici 32) et que vous lancez 32 processus, votre code sera plus lent et le nœud sera possiblement surchargé.

Comme le module multiprocessing ne peut utiliser qu'un seul nœud de calcul, le gain en performance est habituellement limité au nombre de cœurs CPU du nœud. Si vous voulez dépasser cette limite et utiliser plusieurs nœuds, considérez mpi4py ou PySpark. Il existe d'autres méthodes de parallélisation, mais elles ne peuvent pas toutes être utilisées avec nos grappes. Souvenez-vous toutefois qu'un code de qualité fournira toujours la meilleure performance; avant de le paralléliser, assurez-vous donc que votre code est optimal. Si vous doutez de l'efficacité de votre code, contactez le soutien technique.

Anaconda

Voir la page sur Anaconda.

Jupyter

Voir la page sur Jupyter Notebook.

Dépannage

Script gelé

Avec le module faulthandler, vous pouvez modifier votre script pour qu'une trace de l'origine du problème soit fournie après une certaine durée; voir l'information sur la commande faulthandler.dump_traceback_later(timeout, repeat=False, file=sys.stderr, exit=False).

Vous pouvez aussi inspecter un processus Python pendant l'exécution d'une tâche sans avoir à le modifier au préalable avec py-spy :

1. Installez py-spy dans un environnement virtuel de votre répertoire /home.
2. Connectez-vous à une tâche en cours avec srun --pty --jobid JOBID bash.
3. Trouvez l'ID du processus du script Python avec htop -u $USER.
4. Activez l'environnement virtuel où py-spy est installé.
5. Lancez py-spy top --pid PID pour visionner en direct les endroits où le code utilise beaucoup de temps.
6. Lancez py-spy dump --pid PID pour obtenir une trace de l'état de votre code.

Message Package 'X' requires a different Python: X.Y.Z not in '>=X.Y'

En installant un paquet, vous pourriez avoir une erreur comme ERROR: Package 'X' requires a different Python: 3.6.10 not in '>=3.7'.

Dans ce cas, le module Python 3.6.10 qui est chargé n'est pas supporté par le paquet. Vous pouvez utiliser une version de Python plus récente, comme le dernier module disponible, ou encore installer une version moins récente du paquet X.

Message Package has requirement X, but you'll have Y which is incompatible

En installant un paquet, vous pourriez avoir une erreur comme ERROR: Package has requirement X, but you'll have Y which is incompatible..

Pour utiliser le nouveau résolveur de dépendances, installez la plus récente version de pip ou une version supérieure à [21.3].

(ENV) [name@server ~] pip install --no-index --upgrade pip

Lancez ensuite de nouveau la commande d'installation.

Message No matching distribution found for X

À l'installation d'un paquet, vous pouvez obtenir un message semblable à

(ENV) [name@server ~] pip install X
ERROR: Could not find a version that satisfies the requirement X (from versions: none)
ERROR: No matching distribution found for X

pip n'a trouvé aucun paquet à installer qui rencontre les exigences (nom, version ou tags). Assurez-vous que le nom et la version sont corrects. Sachez aussi que les wheels manylinux_x_y sont ignorés.

Vous pouvez aussi vérifier si le paquet est disponible avec la commande avail_wheels ou en consultant la page Wheels disponibles.

Installation de plusieurs paquets

Lorsque possible, il est préférable d'installer plusieurs paquets avec une seule commande.

(ENV) [name@server ~] pip install --upgrade pip
(ENV) [name@server ~] pip install package1 package2 package3 package4

Ainsi, pip peut résoudre plus facilement les problèmes de dépendance.

Mon environnement virtuel fonctionnait hier, mais pas aujourd'hui

Les fréquentes mises à jour des paquets font en sorte qu'un environnement virtuel ne peut souvent pas être reproduit.

Il est possible aussi qu'un environnement virtuel créé dans $SCRATCH soit partiellement détruit lors de la purge automatique de ce système de fichiers, ce qui empêcherait l'environnement virtuel de bien fonctionner.

Pour contrer ceci, gelez les paquets et leurs versions avec

(ENV) [name@server ~] pip install --upgrade pip
(ENV) [name@server ~] pip install --no-index 'package1==X.Y' 'package2==X.Y.Z' 'package3<X.Y' 'package4>X.Y'

et créez ensuite un fichier de requis qui sera utilisé pour installer ces paquets dans votre tâche.

Le wheel X n'est pas pris en charge sur cette plateforme

À l'installation d'un paquet, vous pourriez obtenir une erreur comme ERROR: package-3.8.1-cp311-cp311-manylinux_2_28_x86_64.whl is not a supported wheel on this platform.

Certains paquets peuvent être incompatibles ou non pris en charge par nos systèmes. Deux cas fréquents sont :

• installation d'un paquet manylinux
• ou un paquet Python construit pour une autre version de Python (par exemple, installer un paquet construit pour Python 3.11 quand vous avez Python 3.9).

Certains paquets manylinux peuvent se trouver parmi nos wheels Python.

Message AttributeError: module ‘numpy’ has no attribute ‘X’

À l'installation d'un whell, la plus récente version de Numpy est installée si aucune version spécifique n'est demanée. Plusieurs attributs ont été déclarés obsolètes dans Numpy v1.20 et ne sont plus offerts dans v1.24.

Dépendant de l'attribut, une erreur comme AttributeError: module ‘numpy’ has no attribute ‘bool’ pourrait survenir.

Ceci est résolu avec l'installation d'une version précédente de Numpy avec pip install --no-index 'numpy<1.24'.

Message ModuleNotFoundError: No module named 'X'

Il est possible qu'un module Python que vous voulez importer ne soit pas trouvé. Il y a plusieurs explications pour ceci, mais les plus fréquentes sont que

• le paquet n'est pas installé ou encore il n'est pas visible pour l'interpréteur Python;
• le nom du module ne correspond pas au nom réel;
• l'environnement virtuel est défectueux.

Pour contrer ceci, évitez de

• modifier la variable d'environnement PYTHONPATH;
• modifier la variable d'environnement PATH;
• charger un module alors qu'un environnement virtuel est activé; chargez d'abord tous les modules avant d'activer l'environnement virtuel.

Si vous avez ce problème,

• avec pip list, vérifiez si le paquet est installé;
• vérifiez encore si le nom que vous entrez correspond exactement au nom du module (majuscules, minuscules, traits de soulignement, etc.);
• vérifiez si le module est importé au bon niveau quand il provient de son répertoire source.

Dans le doute, recommencez avec un nouvel environnement.

Message ImportError: numpy.core.multiarray failed to import

When trying to import a Python module that depends on Numpy, one may encounter ImportError: numpy.core.multiarray failed to import.

This is caused by an incompatible version of numpy installed or used and you must install a compatible version.

This is especially true with the release of Numpy 2.0 which breaks the ABI. In the case of a wheel that was built with version 1.x but installed version 2.x, one must installed a lower version with: pip install --no-index 'numpy<2.0'