Outils de vérification de type statique en Python

Question

Je travaille avec une large base de code Python et voudrais commencer à ajouter dans les annotations de type afin que je puisse obtenir un certain niveau de vérification statique. J'imagine quelque chose comme Erlang, Strongtalk, ou Tapé Régime/Raquette.

J'ai vu quick-and-dirty décorateurs d'insertion dynamique de contrôles basés sur les paramètres de la fonction et le type de retour des annotations, mais je suis à la recherche de quelque chose qui est plus robuste et qui effectue des contrôles au moment de la compilation.

Quels sont les outils disponibles en ce moment pour ce genre de chose? Je suis familier avec les compilateurs et la vérification de type et je suis certainement prêt à améliorer incomplète outil si il a une bonne fondation.

(Note: je ne suis pas intéressé par une discussion sur les avantages/inconvénients de typage statique.)

EDIT: Un exemple:

def put(d, k, v):
   d[k] = v

J'aimerais être capable d'annoter l' put fonction de type put<K,V>(dict<K,V>, K, V) -> None.

Answer 1

Vous pourriez vouloir vérifier certains des projets mentionnés dans le présent liés StackOverflow post sur l'analyse statique pour Python.

En résumé:

• pylint
• PyFlakes
• PyChecker

Depuis Python utilise le duck-typing largement, les choses que l'on pourrait appeler "les erreurs de type" dans d'autres langues pourrait être "l'objet X ne prend pas en charge la méthode de Y" en Python.

Edit:

Je suis d'accord avec delnan que le typage statique n'est pas possible pour Python. Mais depuis notre scepticisme ne semble pas dissuader vous, je ne peux que vous donner plus d'informations sur le sujet. Je vous présente:

• Une discussion de l'inférence de type pour Python. (D'autres liens sont à partir d'ici.)
• Guido van van Rossum, des articles sur l'ajout facultatif typage statique: partie 1 et partie 2.
• RPython, un sous-ensemble de Python qui pourrait être une chance d'être analysé de manière statique assez pour faire une certaine forme de vérification de type.

Answer 2

Vous pouvez trouver mypy intéressant. Il a été proposé pour inclusion dans Python 3.5 par Guido .

Answer 3

Découvrez ce post: PySonar: un Analyseur Statique pour Python. PySonar est un outil qui déduit types à l'aide de l'interprétation abstraite (partiellement l'exécution du code. Il trouve tous les chemins d'exécution possibles de votre programme et trouve tous les types possibles de toutes les variables.

En gros, il existe trois versions de PySonar:

• Open-source Java (Jython indexeur)
• Closed-source Java (Caché dans Google)
• Open-source Python (mini-pysonar)

Aucun d'entre eux (à l'exception de "closed source") est pleinement mis en œuvre. Mais l'idée de base est que vous pouvez l'utiliser comme une base pour votre travail.

Answer 4

Je ne sais pas si cela aide, mais pour ce que ça vaut, Jeremy Siek à l'université du Colorado a travaillé sur le graduelle de frappe, et j'ai trouvé ce faire une recherche rapide. http://www.wiki.jvmlangsummit.com/pdf/28_Siek_gradual.pdf

Je pense (je peux me tromper) est il n'y a pas prometteur outils open source que vous pouvez trouver à l'instant, car sa recherche relativement nouveau.

Votre meilleur pari serait de contacter les auteurs et leur demander s'ils peuvent libérer leur code pour vous.

Answer 5

Il y a le "graduel" de package pour Python 3; voir PIP ou la Bitbucket Repo

Apparemment, c'est une mise en œuvre par le groupe autour de Jeremy Siek qui semble être tout à fait une autorité dans le domaine de l'augmentation progressive de la frappe.

Quelques annotations sont apparemment nécessaire, voici un exemple:

from gradual import *

@typed
def calculate_total(a:int, b:int) -> int:
    return a + b//100

Aussi loin que les annotations go, ce n'est pas si mal. Je n'ai pas utilisé le package donc je ne peux pas parler à sa qualité, mais la syntaxe (et les gens qui sont derrière) certainement le faire paraître prometteur.