# `code` — Classes bases do interpretador

Código-fonte: Lib/code.py

O módulo `code` fornece facilidades para implementar laços de leitura-execução-escrita no código Python. São incluídas duas classes e funções de conveniência que podem ser usadas para criar aplicações que fornecem um prompt de interpretador interativo.

class code.InteractiveInterpreter(locals=None)

  Esta classe trata de analisar e interpretar o estado (espaço de nome do usuário); o mesmo não lida com buffer de entrada ou solicitação ou nomeação de arquivo de entrada (o nome do arquivo é sempre passado explicitamente). O argumento opcional local especifica o dicionário no qual o código será executado; ele é padrão para um dicionário recém-criado com a chave `'__name__'` set to `'__console__'` and key `'__doc__'` definido com `None`.

class code.InteractiveConsole(locals=None, filename='<console>')

  Emula de forma bem similiar o comportamento do interpretador Python interativo. Esta classe se baseia em `InteractiveInterpreter` e adiciona prompting usando os familiares `sys.ps1` e `sys.ps2`, e buffering de entrada.

code.interact(banner=None, readfunc=None, local=None, exitmsg=None)

  Função de conveniência para executar um laço leitura-avaliação-exibição. Isso cria uma nova instância de `InteractiveConsole` e define readfunc para ser usado como o método `InteractiveConsole.raw_input()`, se fornecido. Se local for fornecido, ele é passado para o construtor `InteractiveConsole` para uso como o espaço de nomes padrão para o laço do interpretador. O método `interact()` da instância é então executado com banner e exitmsg passados como o banner e a mensagem de saída a serem usados, se fornecidos. O objeto console é descartado após o uso.

  Alterado na versão 3.6: Parâmetro adicionado exitmsg.

code.compile_command(source, filename='<input>', symbol='single')

  Esta função é útil para programas que desejam emular o laço principal do interpretador Python (também conhecido como laço de leitura-execução-impressão). A parte complicada é determinar quando o usuário digitou um comando incompleto que pode ser concluído inserindo mais texto (em vez de um comando completo ou um erro de sintaxe). Esta função quase sempre toma a mesma decisão que o laço principal do interpretador real.

  source é a string fonte; filename é o nome do arquivo opcional do qual a fonte foi lida, sendo o padrão `'<input>'`; e symbol é o símbolo opcional de início da gramática, que deve ser `'single'` (o padrão), `'eval'` ou `'exec'`.

  Retorna um objeto código (o mesmo que `compile(source, filename, symbol)`) se o comando for completo e válido; `None` se o comando estiver incompleto; levanta `SyntaxError` se o comando estiver completo e contém um erro de sintaxe, ou levanta `OverflowError` ou `ValueError` se o comando contiver um literal inválido.

## Objetos de interpretador interativo

InteractiveInterpreter.runsource(source, filename='<input>', symbol='single')

  Compila e executa alguma fonte no interpretador. Os argumentos são os mesmos de `compile_command()`; o padrão para filename é `'<input>'`, e para symbol é `'single'`. Uma de várias coisas pode acontecer:

  - A entrada está incorreta; `compile_command()` levantou uma exceção (`SyntaxError` ou `OverflowError`). Um traceback da sintaxe será impresso chamando o método `showsyntaxerror()`. `runsource()` retorna `False`.

  - A entrada está incompleta e são necessárias mais entradas; `compile_command()` retornou `None`. `runsource()` retorna `True`.

  - A entrada está completa; `compile_command()` retornou um objeto código. O código é executado chamando `runcode()` (que também lida com exceções de tempo de execução, exceto `SystemExit`). `runsource()` retorna `False`.

  O valor de retorno pode ser usado para decidir se usar `sys.ps1` ou `sys.ps2` para solicitar a próxima linha.

InteractiveInterpreter.runcode(code)

  Executa um objeto código. Quando ocorre uma exceção, `showtraceback()` é chamado para exibir um traceback. Todas as exceções são capturadas, exceto `SystemExit`, que pode ser propagada.

  Uma observação sobre `KeyboardInterrupt`: esta exceção pode ocorrer em outro lugar neste código e nem sempre pode ser detectada. O chamador deve estar preparado para lidar com isso.

InteractiveInterpreter.showsyntaxerror(filename=None)

  Exibe o erro de sintaxe que acabou de ocorrer. Isso não exibe um stack trace (situação da pilha de execução) porque não há um para erros de sintaxe. Se filename for fornecido, ele será inserido na exceção em vez do nome de arquivo padrão fornecido pelo analisador sintático do Python, porque ele sempre usa `'<string>'` ao ler uma string. A saída é escrita pelo método `write()`.

InteractiveInterpreter.showtraceback()

  Exibe a exceção que acabou de ocorrer. Removemos o primeiro item da pilha porque ele está dentro da implementação do objeto interpretador. A saída é escrita pelo método `write()`.

  Alterado na versão 3.5: O traceback encadeado completo é exibido em vez de apenas o traceback primário.

InteractiveInterpreter.write(data)

  Escreve uma string no fluxo de erro padrão (`sys.stderr`). As classes derivadas devem substituir isso para fornecer o tratamento de saída apropriado conforme necessário.

## Objetos de console Interativo

A classe `InteractiveConsole` é uma subclasse de `InteractiveInterpreter` e, portanto, oferece todos os métodos dos objetos interpretadores, bem como as seguintes adições.

InteractiveConsole.interact(banner=None, exitmsg=None)

  Emula de forma muito semelhante o console interativo do Python. O argumento opcional banner especifica o banner a ser impresso antes da primeira interação; por padrão ele imprime um banner semelhante ao impresso pelo interpretador Python padrão, seguido pelo nome da classe do objeto console entre parênteses (para não confundir isso com o interpretador real – já que está tão próximo!).

  O argumento opcional exitmsg especifica uma mensagem de saída impressa ao sair. Passe a string vazia para suprimir a mensagem de saída. Se exitmsg não for fornecido ou `None`, uma mensagem padrão será impressa.

  Alterado na versão 3.4: Para suprimir a impressão de qualquer banner, passe uma string vazia.

  Alterado na versão 3.6: Imprime uma mensagem de saída ao sair.

InteractiveConsole.push(line)

  Envia uma linha do texto fonte para o interpretador. A linha não deve ter uma nova linha à direita; pode ter novas linhas internas. A linha é anexada a um buffer e o método `runsource()` do interpretador é chamado com o conteúdo concatenado do buffer como fonte. Se isso indicar que o comando foi executado ou é inválido, o buffer será redefinido; caso contrário, o comando estará incompleto e o buffer permanecerá como estava após a linha ser anexada. O valor de retorno é `True` se mais entrada for necessária, `False` se a linha foi tratada de alguma forma (isto é o mesmo que `runsource()`).

InteractiveConsole.resetbuffer()

  Remove qualquer texto fonte não tratado do buffer de entrada.

InteractiveConsole.raw_input(prompt='')

  Escreve um prompt e leia uma linha. A linha retornada não inclui a nova linha final. Quando o usuário insere a sequência de teclas de fim de linha, uma exceção `EOFError` é levantada. A implementação base lê `sys.stdin`; uma subclasse pode substituir isso por uma implementação diferente.