concurrent.interpreters — Múltiplos interpretadores no mesmo processo

Adicionado na versão 3.14.

Código-fonte: Lib/concurrent/interpreters.py

---

Introdução

O módulo concurrent.interpreters constrói interfaces de nível mais alto sobre o módulo de mais baixo nível _interpreters.

Ver também

Isolando módulos de extensão

como atualizar um módulo de extensão para oferecer suporte a vários interpretadores

PEP 554

PEP 734

PEP 684

Disponibilidade: not WASI.

Este módulo não funciona ou não está disponível em WebAssembly. Veja Plataformas WebAssembly para mais informações.

Detalhes-chave

Antes de mergulharmos nos exemplos, há alguns detalhes a serem lembrados sobre o uso de múltiplos interpretadores:

• isolados, por padrão

• nenhuma thread implícita

• nem todos os pacotes PyPI oferecem suporte ao uso em múltiplos interpretadores ainda

No contexto de múltiplos interpretadores, “isolados” significa que diferentes interpretadores não compartilham nenhum estado. Na prática, há alguns dados globais do processo que todos eles compartilham, mas isso é gerenciado pelo tempo de execução.

Referência

Este módulo define as seguintes funções:

concurrent.interpreters.list_all()

Retorna list de objetos Interpreter, um para cada interpretador existente.

concurrent.interpreters.get_current()

Retorna um objeto Interpreter para o interpretador em execução no momento.

concurrent.interpreters.get_main()

Retorna um objeto Interpreter para o interpretador principal.

concurrent.interpreters.create()

Inicializa um novo interpretador Python (ocioso) e retorna um objeto Interpreter para ele.

Objetos interpretador

class concurrent.interpreters.Interpreter(id)

Um único interpretador no processo atual.

Geralmente, Interpreter não deve ser chamado diretamente. Em vez disso, use create() ou uma das outras funções do módulo.

id

(somente leitura)

O ID do interpretador.

whence

(somente leitura)

Uma string descrevendo de onde o interpretador veio.

is_running()

Retorna True se o interpretador estiver executando código em seu módulo __main__ e False caso contrário.

close()

Finaliza e destrói o interpretador.

prepare_main(ns=None, **kwargs)

Liga objetos “compartilháveis” no módulo __main__ do interpretador.

exec(code, /, dedent=True)

Executa o código-fonte fornecido no interpretador (na thread atual).

call(callable, /, *args, **kwargs)

Retorna o resultado da chamada da execução da função fornecida no interpretador (na thread atual).

call_in_thread(callable, /, *args, **kwargs)

Executa a função fornecida no interpretador (em uma nova thread).

Exceções

exception concurrent.interpreters.InterpreterError

Esta exceção, uma subclasse de Exception, é levantada quando ocorre um erro relacionado ao interpretador.

exception concurrent.interpreters.InterpreterNotFoundError

Esta exceção, uma subclasse de InterpreterError, é levantada quando o interpretador de destino não existe mais.

exception concurrent.interpreters.ExecutionFailed

Esta exceção, uma subclasse de InterpreterError, é levantada quando o código em execução levanta uma exceção não capturada.

excinfo

Um snapshot básico da exceção levantada no outro interpretador.

exception concurrent.interpreters.NotShareableError

Esta exceção, uma subclasse de TypeError, é levantada quando um objeto não pode ser enviado para outro interpretador.

Uso básico

Criando um interpretador e executando código nele:

from concurrent import interpreters

interp = interpreters.create()

# Executa na thread atual do sistema operacional.

interp.exec('print("spam!")')

interp.exec("""if True:
    print('spam!')
    """)

from textwrap import dedent
interp.exec(dedent("""
    print('spam!')
    """))

def run():
    print('spam!')

interp.call(run)

# Executa uma nova thread do sistema operacional.

t = interp.call_in_thread(run)
t.join()