static typing

statische Typing

Augument Python 3 abstrakte Syntaxbäume (ASTS) mit statischen Informationen.

Python ist eine dynamisch getippte Programmiersprache. Ein Großteil der typisch gesehenen Python -Code würde jedoch funktionieren, auch wenn er statisch getippt würde!

Mit diesem Paket kann man statische Informationen in Python abstrakte Syntaxbäume (ASTS) einfügen. Die Annahme, dass der angegebene Code funktionieren würde, wenn Python statisch getippt würde, kann man vor der Ausführung statisch über die Typen im Code einfügen.

Ein solcher Augmented AST ist hauptsächlich für Analyse/Verbrauch unter Verwendung anderer Tools vorgesehen.

Funktioniert am besten mit ASTS vom typed_ast Modul, aber es funktioniert auch mit integriertem ast Modul.

Beachten Sie, dass dies eine laufende Arbeit ist, und die aktuelle Implementierung unterliegt plötzliche Änderungen.

Die Unterstützung von typed_ast wird nach Veröffentlichung von Python 3.8 fallen gelassen, da seine Funktionalität in den eingebauten AST-Parser zusammengeführt wird.

Inhalt

• Wie man benutzt
  • Ast Manipulation
• Wie es implementiert ist
  • Geben Sie eine Hinweisauflösung an
  • Geben Sie Informationen kombiniert
  • Ast umschreiben
• Anforderungen

Wie man benutzt

Sie können das static_typing -Modul verwenden, um den Code direkt mithilfe von parse() zu analysieren:

 import static_typing as st
class MyClass :
    pass
module = st . parse ( 'def my_fun(obj: MyClass) -> MyClass: return obj' )
# TODO: currently there is no public API yet
functions = module . _functions
my_fun = module . _functions [ 'my_fun' ]
assert MyClass in my_fun . _params [ 'obj' ]

Oder Sie können die vorhandene AST mithilfe der augment() -Funktion erweitern:

 import static_typing as st
import typed_ast . ast3
module = typed_ast . ast3 . parse ( '''def spam(): x, y, z = 'ham', 42, 3.1415  # type: str, int, float''' )
module = st . augment ( module )
# TODO: currently there is no public API yet
function = module . _functions [ 'spam' ]
assert len ( function . _local_vars ) == 3
assert float in function . _local_vars [ 'z' ]

Weitere Beispiele finden Sie unter Beispielen.IPynb Notebook.

Ast Manipulation

Zusätzlich zu den Hauptmerkmalen enthält die Bibliothek static_typing.ast_manipulation , das Tools und Bausteine ​​auf niedriger Ebene enthält, die es ermöglichen:

• rekursiver Ast -Traversal,
• AST -Validierung,
• rekursive AST -Transformationen,
• AST transkribieren (von typed_ast bis eingebautes ast und umgekehrt) und umgekehrt) und
• Tipps des Typs auflösen (im Detail unten beschrieben).

Wie es implementiert ist

Der Prozess oder die statische Typisierung, die die Funktion augment() implementiert, hat 3 Hauptschritte:

• Tippen Sie auf Hinweise zur Auflösung,
• Geben Sie Informationen ein und kombinieren und
• Ast umschreiben.

Geben Sie eine Hinweisauflösung an

In allen zutreffenden Knoten werden Typ -Hinweise in Feldern type_comment , annotation und returns gespeichert. Der Typ Tipps Resolver liest diese Felder - die entweder rohe Saiten oder ATS sind.

Es wird vorhandene Python -Symbol -Tabellen verwendet, um Typen Hinweise in tatsächliche Typobjekte mithilfe von Selbstbeobachtung aufzulösen.

Standardmäßig verwendet der Resolver nur integrierte Symbole, wenn sie direkt oder über augment() aufgerufen werden. Bei der Aufforderung durch parse() verwendet es jedoch standardmäßig globals() und locals() des Anrufers.

Der aufgelöste Typ -Hinweis wird direkt im AST gespeichert. Insbesondere wird jedes aufgelöste Feld in einem entsprechend benannten Feld gespeichert, das entweder resolved_type_comment , resolved_annotation oder resolved_returns ist.

Somit werden statische Informationen im AST verfügbar.

Geben Sie Informationen kombiniert

Für jeden AST -Knoten, der möglicherweise Namenserklärungen enthält, wird eine ausgeschaltete Version eines Knotens bereitgestellt. Jeder erweiterte AST -Knoten verfügt über neue Felder, die die deklarierten Namen und die mit jedem Namen zugeordneten Informationen eingeben.

Diese neuen Felder speichern alle Typinformationen aller aufgelösten Typ -Hinweise in jedem lokalen Bereich, sodass ein Typkonflikt oder ein Mangel an Typinformationen erkannt werden können. Basierend auf diesen kombinierten Informationen kann auch Typinferenz durchgeführt werden.

Insbesondere werden neue Versionen der folgenden AST -Knoten mit neuen Feldern bereitgestellt: Module , FunctionDef , ClassDef , Assign , AnnAssign , For und With . Diese neuen Versionen haben ihre Namen StaticallyTyped...

Eine Liste von Unternehmen, für die Informationen in diesen neuen Bereichen gesammelt werden, folgt.

Für Module :

• Definierte Variablen
• definierte Funktionen
• definierte Klassen

Für FunctionDef :

• Parameter und ihre Typen
• Rückgabetypen
• Art (IE -Funktion, Instanzmethode, Klassenmethode, statische Methode usw.)
• Lokale Variablen und ihre Typen

Für ClassDef :

• definierte Methoden (alle zusammen und nach Art gruppiert)
• Klassenfelder und ihre Typen
• Instanzfelder und ihre Typen

Für Assign und AnnAssign :

• Zuweisungsziele und ihre Typen

Für: For :

• Indexvariablen und ihre Typen

Für With :

• Kontextvariablen und ihre Typen

Ast umschreiben

Das AST -Umschreiben bedeutet, gewöhnliche AST -Knoten zu ersetzen, die oben durch ihre erweiterten Versionen aufgeführt sind.

Anforderungen

Python Version 3.5 oder höher.

Python -Bibliotheken gemäß den Anforderungen.txt.

Erstellen und Ausführen von Tests erfordert zusätzlich Pakete, die in test_requirements.txt aufgeführt sind.

Unter Linux und Windows getestet.