Facebook lance Pyre, un vérificateur de type statique pour Python,
Cet outil va-t-il révolutionner le développement avec Python ?

Le , par Bill Fassinou, Chroniqueur Actualités
Placé sous une licence libre proche de la licence BSD, Python est un langage de programmation objet, multiparadigme et multiplateforme. Il favorise la programmation impérative structurée, fonctionnelle et orientée objet. Il est doté d'un typage dynamique fort, d'une gestion automatique de la mémoire par ramasse-miettes et d'un système de gestion d'exceptions ; il est ainsi similaire à Perl, Ruby, Scheme, Smalltalk et Tcl. Il fonctionne sur la plupart des plateformes informatiques et est conçu pour optimiser la productivité des programmeurs en offrant des outils de haut niveau et une syntaxe simple à utiliser.

Selon un classement de la popularité des langages de programmation, Python est le deuxième langage le plus utilisé des développeurs après JavaScript et le langage de programmation le plus populaire de mai 2018. Plusieurs outils d'aide au développement en Python ont été développés. Parmi eux, Pyre qui est un vérificateur de type statique. Son but est de vous permettre d'écrire un Python idiomatique et lisible sans vous encombrer. Il est conçu pour aider à améliorer la qualité et la vitesse de développement dans les grandes bases de code Python en signalant interactivement les erreurs de type dans votre éditeur favori. Il vérifie les annotations de type progressif qui font déjà partie du langage de programmation Python.

Pyre est conçu pour être hautement parallèle, optimisant les réponses quasi instantanées afin que vous obteniez une rétroaction immédiate, même dans une grande base de code. De par leur conception, les annotations de type ne sont pas obligatoires partout. Si vous n'êtes pas totalement attaché au typage statique, ou si vous avez une base de code existante que vous avez l'intention de convertir progressivement au fil du temps, vous pouvez toujours obtenir des résultats utiles.


Python est beaucoup utilisé dans le monde et aussi par les plus grandes start-up comme Facebook et Instagram. Il est apprécié pour son expressivité, sa flexibilité et sa productivité. Cependant, certains de ces avantages se sont estompés au fil du temps. Car, l'absence de garanties statiques peut rendre plus difficile la modification en toute sécurité d'une base de code existante. Cela rend le code plus sujet aux erreurs et ralentit le développement par rapport au code typé statiquement. Il est difficile de créer des outils de haute qualité comme la recherche de code, la saisie semi-automatique, la navigation et le réusinage du code (le refactoring). Les développeurs Python devront donc faire face à un défi majeur à cause du manque d'outils comme ceux-ci et cela est particulièrement préjudiciable lorsque vous travaillez dans une grande base de code.

C'est pour résoudre ces problèmes que Facebook a développé Pyre pour être à la fois un vérificateur de type conforme à la norme PEP 484 (support d'annotation de type pour Python) et une plateforme idéale pour la création d'outils d'analyse statique plus approfondis. Le vérificateur de type Pyre est conçu avec une performance interactive. Le but est de fournir toutes les erreurs de type pertinentes dès que possible. Pour ce faire, il fonctionne comme un serveur qui met continuellement à jour sa compréhension de votre code en mémoire. Il utilise Watchman (un service de surveillance de fichiers) pour repérer les modifications apportées à votre code.

Pyre maintient une représentation graphique de dépendance de votre code. Lorsque votre code change, Pyre ne réanalysera que le code qui a changé et ses dépendances directes, mettant à jour le graphe de dépendance en cours de route. Les résultats sont disponibles depuis la ligne de commande, sous forme de JSON structuré, ou via l'intégration avec VSCode et Nuclide. Au-delà de la vérification de type, Pyre prend en charge un certain nombre de fonctionnalités, telles que le recontrôle automatique des fichiers édités via le Language Server Protocol (LSP).

En interne, l'architecture de haut niveau de Pyre est similaire à celle de Hack, le vérificateur de type Facebook pour PHP. Comme le vérificateur de type Hack, Pyre est implémenté dans OCaml et utilise une architecture de données à mémoire partagée sans verrou pour réaliser le parallélisme. Pyre est compatible avec Python 3 et supporte actuellement la majorité des fonctionnalités définies dans PEP 484. Pyre est envisagé pour être compatible avec mypy qui est l'implémentation de référence de facto pour la vérification de type Python, même si des différences mineures de mise en œuvre sont possibles. Il prendra en charge la vérification de type Python à mesure que le langage évolue.

Source Facebook

Et vous ?

Que pensez-vous de ce vérificateur de type statique pour Python ?
Pensez-vous que cela va révolutionner l'évolution du langage ?

Voir aussi

Python : Flask passe à la version 1.0, le micro-framework de développement web se dote de nouvelles fonctionnalités
RHEL : Red Hat compte remplacer Python 2 par Python 3 dans la prochaine version majeure de sa distribution Linux
Microsoft envisagerait d'ajouter Python comme langage de script officiel à Excel, les utilisateurs sont appelés à donner leur opinion sur la question


Vous avez aimé cette actualité ? Alors partagez-la avec vos amis en cliquant sur les boutons ci-dessous :


 Poster une réponse Signaler un problème

Avatar de stef-13013 stef-13013 - Membre habitué https://www.developpez.com
le 12/05/2018 à 12:27
Est-ce que je me trompe ou Pycharm fait déjà cela depuis pas mal de temps ?

(Bon ok, faut avoir Pycharm, mais bon...)

Pyre est-il meilleur ?
Avatar de abriotde abriotde - Membre éprouvé https://www.developpez.com
le 12/05/2018 à 13:12
Mais pycharm n'est pas open-source. Pyre peut donc révolutionner la programmation en étant largement diffusé, utilisé ammendé... L'avenir le dira.
Avatar de wiztricks wiztricks - Modérateur https://www.developpez.com
le 12/05/2018 à 14:16
Citation Envoyé par Bill Fassinou Voir le message
Que pensez-vous de ce vérificateur de type statique pour Python ?
C'est un outil qui s'appuie sur les annotations introduites dans les dernières versions.

Citation Envoyé par Bill Fassinou Voir le message
Pensez-vous que cela va révolutionner l'évolution du langage ?
Un vérificateur de type statique est un outil indispensable pour gérer le développement de gros projet (beaucoup de monde qui code). Cà permet d'élargir la classe d'applications que l'on pourra se permettre d'écrire avec Python.

- W
Avatar de Pyramidev Pyramidev - Membre expert https://www.developpez.com
le 14/05/2018 à 11:12
Pour l'analyse statique de code en Python, j'utilise mypy qui, actuellement, est mieux documenté que Pyre.

Je viens d'essayer d'installer Pyre mais, chez moi, la commande « pip install pyre-check » a échoué à cause d'un problème de certificat. Je lis dans la documentation que, pour compiler Pyre depuis le code source, il faut un compilateur OCaml, que je n'ai pas le temps d'installer maintenant.

Est-ce que quelqu'un ici a installé Pyre ?

Si oui, est-ce que Pyre supporte la programmation générique, comme mypy ? Je n'ai rien vu dans la documentation à ce sujet.
Exemple de code pour tester :
Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
"""
Ce script lit un fichier et affiche les lignes qui y apparaissent plusieurs
fois, en indiquant combien de fois elles apparaissent.
Ce code a été testé avec Python 3.6.4.
L'analyse statique du code a été validée par mypy 0.570.
"""

#####################
# Imports and types #
#####################

import os
from typing import Iterable, Mapping, MutableMapping, TypeVar

T = TypeVar('T')

#########
# Paths #
#########

filePath : str = 'test.txt'

#############
# Main code #
#############

def _mainImpl() -> None:
	with open(filePath) as file:
		mapFromLineToNumberOfOccurrences : Mapping[str, int] = countOccurrencesOfEachElement(file)
	printMapFromLineToNumberOfOccurrences(mapFromLineToNumberOfOccurrences)

def countOccurrencesOfEachElement(iterable : Iterable[T]) -> MutableMapping[T, int]:
	result : MutableMapping[T, int] = {}
	for element in iterable:
		if element not in result:
			result[element] = 1
		else:
			result[element] += 1
	return result

def printMapFromLineToNumberOfOccurrences(mapFromLineToNumberOfOccurrences : Mapping[str, int]) -> None:
	for line in mapFromLineToNumberOfOccurrences:
		count : int = mapFromLineToNumberOfOccurrences[line]
		if count > 1:
			print(line[0:-1] + ' : ' + str(count) + ' occurrences')

if __name__ == '__main__':
	try:
		_mainImpl()
	except Exception as e:
		print('Error: ' + str(e))
	os.system('pause')
Avatar de oudjira oudjira - Membre du Club https://www.developpez.com
le 18/05/2018 à 12:31
Avec la limite de Pycharm, c'est vraiment intéressant d'avoir Pyre open source. Comme ça je dirai bye bye Pychrm
Contacter le responsable de la rubrique Accueil