Utilisation de mypy pour vérifier les types

mypy : un vérificateur de types statique pour Python

`mypy` est un outil de vérification statique de types pour Python. Il analyse votre code (sans l'exécuter) et vérifie que les types que vous avez annotés sont respectés. Si `mypy` détecte une incohérence de type, il affiche un message d'erreur.

Contrairement à l'interpréteur Python, qui ignore les annotations de type, `mypy` les utilise pour effectuer une vérification statique, similaire à ce que font les compilateurs dans les langages à typage statique (comme Java ou C++).

L'utilisation de `mypy` permet de :

• Détecter les erreurs de type *avant* l'exécution du programme.
• Améliorer la fiabilité et la maintenabilité du code.
• Faciliter le débogage.
• Améliorer la lisibilité du code (en rendant les types explicites).

`mypy` est un outil externe. Il n'est pas inclus dans la bibliothèque standard Python. Vous devez l'installer séparément.

Installation de mypy

Vous pouvez installer `mypy` en utilisant `pip` :

pip install mypy

Il est recommandé d'installer `mypy` dans un environnement virtuel, comme tous les outils de développement.

Exécuter mypy : analyser votre code

Pour vérifier les types dans un fichier Python avec `mypy`, utilisez la commande suivante dans votre terminal :

mypy mon_fichier.py

Remplacez `mon_fichier.py` par le nom de votre fichier.

Si `mypy` ne détecte aucune erreur de type, il ne produira aucune sortie (sauf si vous utilisez des options spécifiques).

Si `mypy` détecte des erreurs de type, il affichera des messages d'erreur indiquant la ligne où l'erreur a été détectée, le type d'erreur, et une explication.

Exemple :

Soit le fichier `mon_fichier.py` suivant :

# mon_fichier.py
def additionner(a: int, b: int) -> int:
    return a + b

print(additionner(1, 2))
print(additionner("a", "b"))  # Erreur de type ici

Exécution de `mypy mon_fichier.py` :

mon_fichier.py:6: error: Argument 1 to "additionner" has incompatible type "str"; expected "int"  [arg-type]
Found 1 error in 1 file (checked 1 source file)

`mypy` a détecté une erreur de type à la ligne 6 : la fonction `additionner` attend des entiers, mais elle est appelée avec des chaînes de caractères.

Vous pouvez exécuter `mypy` sur plusieurs fichiers, ou sur un répertoire entier :

mypy mon_fichier1.py mon_fichier2.py
mypy mon_repertoire/

Interpréter les messages d'erreur de mypy

Les messages d'erreur de `mypy` ont généralement la forme suivante :

nom_du_fichier.py:numero_de_ligne: categorie: Message d'erreur  [code_erreur]

• `nom_du_fichier.py` : Le nom du fichier où l'erreur a été détectée.
• `numero_de_ligne` : Le numéro de la ligne où l'erreur a été détectée.
• `categorie` : erreur (`error`), note (`note`) ou avertissement (`warning`)
• `Message d'erreur` : Une description de l'erreur.
• `[code_erreur]` : (Optionnel) Un code d'erreur qui peut être utilisé pour configurer `mypy` (par exemple, pour ignorer certaines erreurs).

Exemple :

mon_fichier.py:6: error: Argument 1 to "additionner" has incompatible type "str"; expected "int"  [arg-type]

Ce message d'erreur indique :

• Fichier : `mon_fichier.py`
• Ligne : 6
• Catégorie : erreur (`error`)
• Message : L'argument 1 de la fonction `additionner` a un type incompatible (`str` au lieu de `int`).
• Code d'erreur : `arg-type`

En lisant attentivement les messages d'erreur de `mypy`, vous pouvez comprendre la nature de l'erreur de type et la corriger.

Configuration de mypy : options et fichier de configuration

`mypy` a de nombreuses options pour contrôler la manière dont il vérifie les types. Vous pouvez spécifier ces options :

• Sur la ligne de commande.
• Dans un fichier de configuration (`mypy.ini`, `setup.cfg`, ou `pyproject.toml`).
• En utilisant des commentaires spéciaux dans le code source (`# type: ignore`, etc.).

Voici quelques options courantes :

• `--strict` : Active un ensemble d'options strictes (recommandé pour une vérification plus rigoureuse).
• `--ignore-missing-imports` : Ignore les erreurs liées aux modules importés qui n'ont pas d'annotations de type.
• `--disallow-untyped-defs` : Signale une erreur pour chaque fonction sans annotation de type.
• `--check-untyped-defs` : Vérifie les types dans les fonctions même sans annotation de type (inférence de type limitée).
• `--no-implicit-optional` : N'autorise pas `Optional[Type]` implicite quand un argument à une valeur par défaut `None`
• `--warn-return-any` : Avertit si une fonction avec une annotation de type pour la valeur de retour retourne une valeur de type `Any`.
• `--warn-unreachable` : Avertit si du code est inaccessible.

Exemple (ligne de commande) :

mypy --strict mon_fichier.py

Exemple (fichier de configuration `mypy.ini`) :

[mypy]
strict = True
ignore_missing_imports = True

Exemple (commentaire dans le code) :

def ma_fonction(x):
    return x + 1  # type: ignore  # Ignore l'erreur de type (par exemple, si x n'est pas annoté)

La configuration de `mypy` vous permet d'adapter la vérification des types à vos besoins et à votre style de codage. Il est recommandé d'utiliser une configuration stricte pour maximiser les bénéfices de la vérification statique des types.

Intégration avec les IDE

La plupart des IDE modernes pour Python (VS Code, PyCharm, etc.) s'intègrent avec `mypy` (ou d'autres outils de vérification de type statique, comme `pyright`). Cela permet d'obtenir des informations sur les erreurs de type directement dans l'éditeur, au fur et à mesure que vous écrivez le code.

Cette intégration facilite grandement l'utilisation de `mypy` et rend le processus de vérification des types plus interactif.