Importando Módulos

PyObject* PyImport_ImportModule(const char *name)

Return value: New reference.

Esta é uma interface simplificada para PyImport_ImportModuleEx(), deixando os argumentos globals e locals definidos como NULL e level definido para 0. Quando o argumento name contém um ponto (especificando um submódulo de um pacote), o argumento fromlist é definido para a lista ‘['*']’ a fim que o retorno seja o módulo nomeado ao invés do pacote de nível superior que o contém, como seria neste caso. (Infelizmente, isso tem um efeito colateral quando o name especifica um subpacote ao invés de um submódulo: os submódulos especificados nos pacotes são carregados através da variável __all__). Retornando uma nova referência para o módulo importado, ou NULL com uma exceção definida durante a falha. Uma falha na importação do módulo não o deixa dentro de sys.modules.

Essas funções usam importações absolutas.

PyObject* PyImport_ImportModuleNoBlock(const char *name)

Esta função tem um alias obsoleto: c: func: PyImport_ImportModule.

Alterado na versão 3.3: Essa função falhava em alguns casos, quando o bloqueio de importação era mantido por outra thread. No Python 3.3, no entanto, o esquema de bloqueio mudou passando a ser por módulo na maior parte, dessa forma, o comportamento especial dessa função não é mais necessário.

PyObject* PyImport_ImportModuleEx(const char *name, PyObject *globals, PyObject *locals, PyObject *fromlist)

Return value: New reference.

Importar um módulo. Isso é melhor demonstrado através da função interna do Python __import__().

O valor retornado é uma nova referência ao módulo importado ou ao pacote localizado no nível acima, ou NULL através de uma exceção definida pela falha. Como na __import__(), o valor retornado quando um submódulo foi solicitado é o pacote de nível superior, a menos que uma fromlist tenha sido informada.

As importações com falhas removem objetos incompletos do módulo, como em PyImport_ImportModule().

PyObject* PyImport_ImportModuleLevelObject(PyObject *name, PyObject *globals, PyObject *locals, PyObject *fromlist, int level)

Return value: New reference.

Importar um módulo. Isso é melhor descrito referindo-se à função interna do Python __import__(), já que a função padrão: func:__import__ chama essa função diretamente.

O valor retornado é uma nova referência ao módulo importado ou ao pacote localizado no nível acima, ou NULL através de uma exceção definida pela falha. Como na __import__(), o valor retornado quando um submódulo foi solicitado é o pacote de nível superior, a menos que uma fromlist tenha sido informada.

Novo na versão 3.3.

PyObject* PyImport_ImportModuleLevel(const char *name, PyObject *globals, PyObject *locals, PyObject *fromlist, int level)

Return value: New reference.

Semelhante para PyImport_ImportModuleLevelObject(), mas o nome é uma string codificada em UTF-8 de um objeto Unicode.

Alterado na versão 3.3: Valores negativos para level não são mais aceitos.

PyObject* PyImport_Import(PyObject *name)

Return value: New reference.

Essa é uma interface de alto nível que chama a atual “função auxiliar de importação” (com um level explícito de 0, significando importação absoluta). Invoca a função __import__() a partir de __builtins__ da global atual. Isso significa que a importação é feita usando quaisquer extras de importação instalados no ambiente atual.

Essas funções usam importações absolutas.

PyObject* PyImport_ReloadModule(PyObject *m)

Return value: New reference.

Recarregar um módulo. Retorna uma nova referência ao módulo recarregado, ou NULL com uma exceção definida pela falha (o módulo ainda existe nesse caso).

PyObject* PyImport_AddModuleObject(PyObject *name)

Return value: Borrowed reference.

Retornar o objeto módulo correspondente ao nome do módulo. O argumento name pode estar no formato package.module. Primeiro confira no dicionário dos módulos se há um lá, e se não houver, crie um novo e insira este dentro do dicionários dos módulos. Retorna NULL com uma exceção definida pela falha.

Nota

Esta função não carrega ou importa o módulo; se o módulo não foi carregado, você receberá um objeto de módulo vazio. Utilize PyImport_ImportModule() ou uma de suas variações para importar um módulo. Estruturas de pacotes implícitos através de um ponto no nome para a name não são criados se não estiverem presentes.

Novo na versão 3.3.

PyObject* PyImport_AddModule(const char *name)

Return value: Borrowed reference.

Semelhante para PyImport_AddModuleObject(), mas o nome é uma string codifica em UTF-8 em vez de um objeto Unicode.

PyObject* PyImport_ExecCodeModule(const char *name, PyObject *co)

Return value: New reference.

Para um nome de módulo (possivelmente na forma de package.module) e um objeto de código lido a partir de um arquivo bytecode do Python ou obtido a partir da função interna compile(), carrega o módulo. Retorna uma nova referência ao objeto do módulo, ou NULL com uma exceção definida pela falha. name é removido do sys.modules em casos de erro, mesmo se o name já esteja dentro de sys.modules na entrada para PyImport_ExecCodeModule(). Deixar módulos inicializados de forma incompleta em sys.modules é perigoso, como na importação de tais módulos não há como saber que o objeto do módulo tem estado indefinido (e provavelmente com problemas com relação às intenções do autor do módulo).

O módulo __spec__ e __loader__ será definido, se não estiver, com os valores apropriados. O carregador de especificações definirá o módulo __loader__ (se definido) e uma instância da classe SourceFileLoader em caso contrário.

O atributo do módulo __file__ poderá ser definido ao objeto do código co_filename. Se aplicável, __cached__ também será definido.

Esta função poderá recarregar o módulo se este já foi importado. Veja PyImport_ReloadModule() para forma desejada de recarregar um módulo.

Se name apontar para um nome com ponto no formato de package.module, qualquer estruturas de pacotes que não tenha sido criada não será mais criada.

Veja também PyImport_ExecCodeModuleEx() e PyImport_ExecCodeModuleWithPathnames().

PyObject* PyImport_ExecCodeModuleEx(const char *name, PyObject *co, const char *pathname)

Return value: New reference.

Como PyImport_ExecCodeModule(), mas o atributo __file__ do objeto módulo é definido como pathname se não for NULL.

Veja também PyImport_ExecCodeModuleWithPathnames().

PyObject* PyImport_ExecCodeModuleObject(PyObject *name, PyObject *co, PyObject *pathname, PyObject *cpathname)

Return value: New reference.

Como PyImport_ExecCodeModuleEx(), mas o atributo __cached__ do objeto módulo é definido como cpathname se não for NULL. Das três funções, esta é a preferida para usar.

Novo na versão 3.3.

PyObject* PyImport_ExecCodeModuleWithPathnames(const char *name, PyObject *co, const char *pathname, const char *cpathname)

Return value: New reference.

Como PyImport_ExecCodeModuleObject(), mas name, pathname e cpathname são strings codificadas em UTF-8. Também são feitas tentativas para descobrir qual valor para pathname deve ser de cpathname se o primeiro estiver definido como NULL.

Novo na versão 3.2.

Alterado na versão 3.3: Usa imp.source_from_cache() no cálculo do caminho de origem se apenas o caminho do bytecode for fornecido.

long PyImport_GetMagicNumber()

Retorna o número mágico para arquivos de bytecode Python (também conhecido como arquivo .pyc). O número mágico deve estar presente nos primeiros quatro bytes do arquivo bytecode, na ordem de bytes little-endian. Retorna -1 em caso de erro.

Alterado na versão 3.3: Retorna o valor de -1 no caso de falha.

const char * PyImport_GetMagicTag()

Retorna a string de tag mágica para nomes de arquivo de bytecode Python no formato de PEP 3147. Tenha em mente que o valor em sys.implementation.cache_tag é autoritativo e deve ser usado no lugar desta função.

Novo na versão 3.2.

PyObject* PyImport_GetModuleDict()

Return value: Borrowed reference.

Retorna o dicionário usado para a administração do módulo (também conhecido como sys.modules). Observe que esta é uma variável por interpretador.

PyObject* PyImport_GetImporter(PyObject *path)

Return value: New reference.

Retorna um objeto localizador para o item path de sys.path/pkg.__path__, possivelmente obtendo-o do dicionário sys.path_importer_cache. Se ainda não foi armazenado em cache, atravessa sys.path_hooks até que um gancho seja encontrado que possa lidar com o item de caminho. Retorna None se nenhum gancho puder; isso diz ao nosso chamador que o localizador baseado no caminho não conseguiu encontrar um localizador para este item de caminho. Armazena o resultado em sys.path_importer_cache. Retorna uma nova referência ao objeto localizador.

void _PyImport_Init()

Inicia o mecanismo de importação. Apenas para uso interno.

void PyImport_Cleanup()

Esvazia a tabela do módulo. Apenas para uso interno.

void _PyImport_Fini()

Finaliza o mecanismo de importação. Apenas para uso interno.

PyObject* _PyImport_FindExtension(char *, char *)

Apenas para uso interno.

int PyImport_ImportFrozenModuleObject(PyObject *name)

Return value: New reference.

Carrega um módulo congelado chamado name. Retorna 1 para sucesso, 0 se o módulo não for encontrado e -1 com uma exceção definida se a inicialização falhar. Para acessar o módulo importado em um carregamento bem-sucedido, use PyImport_ImportModule(). (Observe o nome incorreto — esta função recarregaria o módulo se ele já tivesse sido importado.)

Novo na versão 3.3.

Alterado na versão 3.4: O atributo __file__ não está mais definido no módulo.

int PyImport_ImportFrozenModule(const char *name)

Semelhante a PyImport_ImportFrozenModuleObject(), mas o nome é uma string codificada em UTF-8 em vez de um objeto Unicode.

struct _frozen

Esta é a definição do tipo de estrutura para descritores de módulo congelados, conforme gerado pelo utilitário freeze (veja Tools/freeze/ na distribuição fonte do Python). Sua definição, encontrada em Include/import.h, é:

struct _frozen {
    char *name;
    unsigned char *code;
    int size;
};

const struct _frozen* PyImport_FrozenModules

This pointer is initialized to point to an array of struct _frozen records, terminated by one whose members are all NULL or zero. When a frozen module is imported, it is searched in this table. Third-party code could play tricks with this to provide a dynamically created collection of frozen modules.

int PyImport_AppendInittab(const char *name, PyObject* (*initfunc)(void))

Adiciona um único módulo à tabela existente de módulos embutidos. Este é um invólucro prático em torno de PyImport_ExtendInittab(), retornando -1 se a tabela não puder ser estendida. O novo módulo pode ser importado pelo nome name e usa a função initfunc como a função de inicialização chamada na primeira tentativa de importação. Deve ser chamado antes de Py_Initialize().

struct _inittab

Estrutura que descreve uma única entrada na lista de módulos embutidos. Cada uma dessas estruturas fornece o nome e a função de inicialização para um módulo embutido ao interpretador. O nome é uma string codificada em ASCII. Os programas que embutem Python podem usar um vetor dessas estruturas em conjunto com PyImport_ExtendInittab() para fornecer módulos embutidos adicionais. A estrutura é definida em Include/import.h como:

struct _inittab {
    char *name;                 /* ASCII encoded string */
    PyObject* (*initfunc)(void);
};

int PyImport_ExtendInittab(struct _inittab *newtab)

Add a collection of modules to the table of built-in modules. The newtab array must end with a sentinel entry which contains NULL for the name field; failure to provide the sentinel value can result in a memory fault. Returns 0 on success or -1 if insufficient memory could be allocated to extend the internal table. In the event of failure, no modules are added to the internal table. This should be called before Py_Initialize().