static typing

static-typing

Auxunto Python 3 Sintaxe abstrata árvores (ASTS) com informações do tipo estático.

O Python é uma linguagem de programação tipada dinamicamente. No entanto, grande parte do código Python tipicamente visto funcionaria, mesmo que fosse estaticamente digitado!

Com este pacote, pode -se inserir informações do tipo estático nas árvores de sintaxe abstrata do Python (ASTS); portanto, assumindo que o código dado funcionaria se o python fosse estaticamente digitado, pode -se raciocinar sobre os tipos no código estaticamente, antes da execução.

Esse AST aumentado é destinado principalmente à análise/consumo usando outras ferramentas.

Funciona melhor com o módulo ASTS do typed_ast , no entanto, também funciona com o módulo ast embutido.

Esteja ciente de que este é um trabalho em andamento, e a implementação atual está sujeita a mudanças repentinas.

O suporte ao typed_ast será descartado após o lançamento do Python 3.8, pois sua funcionalidade será mesclada no analisador AST embutido.

Conteúdo

• Como usar
  • Manipulação ast
• Como é implementado
  • Tipo Resolução de dica
  • Digite informações combinadas
  • Reescrita AST
• Requisitos

Como usar

Você pode usar o módulo static_typing para analisar o código diretamente usando a função parse() :

 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' ]

Ou, você pode aumentar a função AST existente usando augment() :

 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' ]

Para mais exemplos, consulte Exemplos.ipynb Notebook.

Manipulação ast

Além dos principais recursos, a biblioteca contém static_typing.ast_manipulation módulo que contém ferramentas de baixo nível e blocos de construção, permitindo:

• Traversal Ast recursivo,
• Validação AST,
• Transformações AST recursivas,
• Transcrição AST (de typed_ast para ast embutido e vice-versa) e
• Resolução do tipo dicas (descrito em detalhes abaixo).

Como é implementado

O processo ou a digitação estática, que a função augment() implementa, possui três etapas principais:

• Tipo de resolução de dica,
• tipo de informação combinando e
• Reescrita AST.

Tipo Resolução de dica

Em todos os nós aplicáveis, as dicas de tipo são armazenadas em campos type_comment , annotation e returns . O resolvedor de dica de tipo lê esses campos - que as vejam são strings brutas ou ASTs.

Ele usa tabelas de símbolo Python fornecidas para resolver o tipo de dicas em objetos de tipo real usando a introspecção.

Por padrão, o resolvedor usa apenas símbolos internos quando chamados diretamente ou através augment() . No entanto, quando chamado através do parse() ele usa globals() e locals() do chamador por padrão.

As dicas do tipo resolvido são armazenadas diretamente no AST. Especificamente, cada campo resolvido é armazenado em um campo nomeado correspondentemente, que é resolved_type_comment , resolved_annotation ou resolved_returns .

Assim, as informações do tipo estático ficam disponíveis no AST.

Digite informações combinadas

Para cada nó AST que pode conter qualquer declaração de nome, é fornecida uma versão expusente de um nó. Cada nó AST estendido possui novos campos que armazenam os nomes declarados e as informações de tipo associadas a cada nome.

Esses novos campos armazenam todas as informações de tipo de todas as dicas de tipo resolvido em qualquer escopo local, para que um conflito de tipo ou falta de informações do tipo possa ser detectado. Além disso, com base nessas informações combinadas, a inferência de tipo pode ser executada.

Especificamente, são fornecidas novas versões dos seguintes nós AST com novos campos: Module , FunctionDef , ClassDef , Assign , AnnAssign , For e With . Essas novas versões têm seus nomes prefixados StaticallyTyped...

Segue uma lista de entidades para as quais as informações são coletadas nesses novos campos.

Para Module :

• variáveis ​​definidas
• funções definidas
• classes definidas

Para FunctionDef :

• parâmetros e seus tipos
• Tipos de retorno
• gentil (ou seja, função, método de instância, método de classe, método estático, etc.)
• variáveis ​​locais e seus tipos

Para ClassDef :

• Métodos definidos (todos juntos e agrupados por tipo)
• campos de classe e seus tipos
• campos de instância e seus tipos

Para Assign e AnnAssign :

• metas de atribuição e seus tipos

Para For :

• variáveis ​​de índice e seus tipos

Para With :

• variáveis ​​de contexto e seus tipos

Reescrita AST

A reescrita AST significa substituir os nós AST comuns listados acima por suas versões estendidas.

Requisitos

Python versão 3.5 ou posterior.

Bibliotecas Python, conforme especificado em requisitos.txt.

A criação e a execução de testes requer pacotes listados também em test_requirements.txt.

Testado no Linux e Windows.