pyanalyze Download - pyanalyze Source Code Download

pyanalyze

Andere Kategorien

0.13.1

Herunterladen

Pyanalyz

Pyanalyze ist ein semi-statischer Typ-Checker für Python-Code. Wie ein statischer Typ Checker (z. B. MyPy oder Pyright) erkennt es Typfehler in Ihrem Code, sodass Fehler gefunden werden können, bevor sie die Produktion erreichen. Im Gegensatz zu solchen Tools importiert es jedoch die Module IT -Typ -Überprüfungen, sodass Pyanalyze viele dynamische Konstrukte verstehen kann, die andere Typen Checkers ablehnen. Diese Eigenschaft ermöglicht es auch, Pyanalyze mit Plugins zu erweitern, die direkt mit Ihrem Code interagieren.

Verwendung

Sie können Pyanalyze mit:

$ pip install pyanalyze

Sobald es installiert ist, können Sie Pyanalyze auf einer Python -Datei oder einem Paket wie folgt ausführen:

$ python -m pyanalyze file.py
$ python -m pyanalyze package/

Beachten Sie jedoch, dass dies versucht, alle Python -Dateien zu importieren, die übergeben werden. Wenn Sie Skripte haben, die Operationen ohne if __name__ == "__main__": Blöcke, kann Pyanalyze sie möglicherweise ausführen.

Um erfolgreich zu rennen, muss Pyanalyze in der Lage sein, den von ihm überprüfenden Code importieren zu können. Um diese Arbeit zu erstellen, müssen Sie möglicherweise den Importweg von Python manuell mithilfe der Variablen $PYTHONPATH -Umgebung manuell anpassen.

Für schnelle Experimente können Sie auch die Option -c verwenden, um einen Code direkt zu überprüfen:

 $ python -m pyanalyze -c 'import typing; typing.reveal_type(1)'
Runtime type is 'int'

Revealed type is 'Literal[1]' (code: reveal_type)
In <code> at line 1
   1: import typing; typing.reveal_type(1)
                                        ^

Konfiguration

Pyanalyze verfügt über eine Reihe von Befehlszeilenoptionen, die Sie sehen können, indem Sie python -m pyanalyze --help ausführen. Wichtige sind -f , das eine interaktive Eingabeaufforderung ausführt, mit der Sie jeden von Pyanalyzing gefundenen Fehler untersuchen und beheben können, und --enable / --disable , die bestimmte Fehlercodes aktivieren und deaktivieren.

Die Konfiguration über eine pyproject.toml -Datei wird ebenfalls unterstützt. Einzelheiten finden Sie in der Dokumentation.

Pyanalyze erweitern

Eine der Hauptmethoden zur Erweiterung von Pyanalyze ist die Bereitstellung einer Spezifikation für eine bestimmte Funktion. Auf diese Weise können Sie beliebiger Code ausführen, der die Argumente auf die Funktion untersucht und Fehler aufwirft, wenn etwas nicht stimmt.

Angenommen, Ihre Codebasis enthält eine Funktionsdatenbank.run_query database.run_query() , die als Argument eine SQL -Zeichenfolge wie folgt nimmt:

 database . run_query ( "SELECT answer, question FROM content" )

Sie möchten erkennen, wann ein Aufruf an run_query() syntaktisch ungültig ist, SQL oder auf eine nicht existierende Tabelle oder Spalte bezieht. Sie könnten das mit einem solchen Code einrichten:

 from pyanalyze . error_code import ErrorCode
from pyanalyze . signature import CallContext , Signature , SigParameter
from pyanalyze . value import KnownValue , TypedValue , AnyValue , AnySource , Value

from database import run_query , parse_sql


def run_query_impl ( ctx : CallContext ) -> Value :
    sql = ctx . vars [ "sql" ]
    if not isinstance ( sql , KnownValue ) or not isinstance ( sql . val , str ):
        ctx . show_error (
            "Argument to run_query() must be a string literal" ,
            ErrorCode . incompatible_call ,
        )
        return AnyValue ( AnySource . error )

    try :
        parsed = parse_sql ( sql )
    except ValueError as e :
        ctx . show_error (
            f"Invalid sql passed to run_query(): { e } " ,
            ErrorCode . incompatible_call ,
        )
        return AnyValue ( AnySource . error )

    # check that the parsed SQL is valid...

    # pyanalyze will use this as the inferred return type for the function
    return TypedValue ( list )


# in pyproject.toml, set:
# known_signatures = ["<module>.get_known_argspecs"]
def get_known_argspecs ( arg_spec_cache ):
    return {
        # This infers the parameter types and names from the function signature
        run_query : arg_spec_cache . get_argspec (
            run_query , impl = run_query_impl
        ),
        # You can also write the signature manually
        run_query : Signature . make (
            [ SigParameter ( "sql" , annotation = TypedValue ( str ))],
            callable = run_query ,
            impl = run_query_impl ,
        ),
    }

Unterstützte Funktionen

Pyanalyze zielt im Allgemeinen darauf ab, die Python -Typing -Spezifikation zu implementieren, aber die Unterstützung für einige Funktionen ist unvollständig. Einzelheiten finden Sie in der Dokumentation.

Fehler ignorieren

Manchmal versteht Pyanalyze die Dinge falsch und Sie müssen einen Fehler ignorieren, den er emittiert. Dies kann wie folgt erfolgen:

# static analysis: ignore eine Zeile selbst vor der Zeile, die den Fehler erzeugt.
# static analysis: ignore am Ende der Zeile, die den Fehler erzeugt.
# static analysis: ignore oben in der Datei; Dadurch wird Fehler in der gesamten Datei ignoriert.

Sie können einen Fehlercode wie # static analysis: ignore[undefined_name] , um nur einen bestimmten Fehlercode zu ignorieren. Dies funktioniert nicht für Ignores für die gesamte Datei. Wenn der Fehlercode bare_ignore eingeschaltet wird, wird Pyanalyze einen Fehler ausstrahlen, wenn Sie keinen Fehlercode für einen Kommentar ignorieren.

Pyanalyze unterstützt derzeit nicht den Standard # type: ignore die Kommentarsyntax.

Support für Python -Version

Pyanalyze unterstützt alle Versionen von Python, die nicht am Ende des Lebens erreicht sind. Da es den Code importiert, den es überprüft, müssen Sie ihn mit derselben Version von Python ausführen, mit der Sie Ihren Code ausführen.