Download de pyanalyze - download de código fonte pyanalyze

pyanalyze

Outras categorias

0.13.1

Baixar

Pyanalyze

O Pyanalyze é um verificador do tipo semi-estático para código Python. Como um verificador do tipo estático (por exemplo, MyPy ou Pyright), ele detecta erros de tipo em seu código para que os bugs possam ser encontrados antes de atingirem a produção. Ao contrário de essas ferramentas, no entanto, importa os módulos que digitam, permitindo que o pyanalyze compreenda muitas construções dinâmicas que outros tipos de damas rejeitarão. Essa propriedade também possibilita estender o pyanalis com plug -ins que interagem diretamente com seu código.

Uso

Você pode instalar o pyanalyze com:

$ pip install pyanalyze

Depois de instalado, você pode executar o pyanalyze em um arquivo ou pacote python da seguinte maneira:

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

Mas observe que isso tentará importar todos os arquivos Python que ele é passado. Se você tiver scripts que executam operações sem if __name__ == "__main__": blocos, o pyanalyze pode acabar executando -os.

Para executar com sucesso, o pyanalyze precisa ser capaz de importar o código que ele verifica. Para fazer esse trabalho, talvez seja necessário ajustar manualmente o caminho de importação do Python usando a variável de ambiente $PYTHONPATH .

Para experimentação rápida, você também pode usar a opção -c para digitar diretamente uma peça de código:

 $ 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)
                                        ^

Configuração

O Pyanalyze possui várias opções de linha de comando, que você pode ver executando python -m pyanalyze --help . Os importantes incluem -f , que executa um prompt interativo que permite examinar e corrigir cada erro encontrado por pyanalyze e --enable / --disable , que habilita e desabilita códigos de erro específicos.

A configuração através de um arquivo pyproject.toml também é suportada. Veja a documentação para obter detalhes.

Estendendo o pyanalis

Uma das principais maneiras de estender o pyanalis é fornecer uma especificação para uma função específica. Isso permite executar um código arbitrário que inspeciona os argumentos da função e levanta erros se algo estiver errado.

Como exemplo, suponha que sua base de código contenha um database.run_query() que toma como argumento uma string sql, assim:

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

Você deseja detectar quando uma chamada para run_query() contém SQL sintaticamente inválida ou se refere a uma tabela ou coluna inexistente. Você pode configurar isso com código como este:

 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 ,
        ),
    }

Recursos suportados

O pyanalyze geralmente visa implementar as especificações de digitação do Python, mas o suporte para alguns recursos é incompleto. Veja a documentação para obter detalhes.

Ignorando erros

Às vezes, o pyanalyze errou e você precisa ignorar um erro que ele emite. Isso pode ser feito da seguinte forma:

Adicione # static analysis: ignore em uma linha por si só antes da linha que gera o erro.
Adicione # static analysis: ignore no final da linha que gera o erro.
Adicione # static analysis: ignore na parte superior do arquivo; Isso ignorará erros em todo o arquivo.

Você pode adicionar um código de erro, como # static analysis: ignore[undefined_name] , para ignorar apenas um código de erro específico. Isso não funciona para o arquivo inteiro ignora. Se o código de erro bare_ignore estiver ativado, o Pyanalyze emitirá um erro se você não especificar um código de erro em um comentário de ignorar.

Atualmente, o pyanalyze não suporta o # type: ignore a sintaxe do comentário.

Suporte à versão do Python

O pyanalyze suporta todas as versões do Python que não atingiram o fim da vida. Como importa o código que ele verifica, você deve executá -lo usando a mesma versão do Python que você usa para executar seu código.