Importe dinamicamente o módulo da memória no Python 3 usando ganchos
O que desejo alcançar é exatamente o que esta resposta propõe, porém em Python 3.
O código abaixo funciona bem no Python 2:
import sys
import imp
modules = {
"my_module":
"""class Test:
def __init__(self):
self.x = 5
def print_number(self):
print self.x"""}
class StringImporter(object):
def __init__(self, modules):
self._modules = dict(modules)
def find_module(self, fullname, path):
if fullname in self._modules.keys():
return self
return None
def load_module(self, fullname):
if not fullname in self._modules.keys():
raise ImportError(fullname)
new_module = imp.new_module(fullname)
exec self._modules[fullname] in new_module.__dict__
return new_module
if __name__ == '__main__':
sys.meta_path.append(StringImporter(modules))
from my_module import Test
my_test = Test()
my_test.print_number() # prints 5
No entanto, ao fazer as alterações óbvias no Python 3 (incluindo exec e print entre parênteses), recebo o seguinte código:
import sys
import imp
modules = {
"my_module":
"""class Test:
def __init__(self):
self.x = 5
def print_number(self):
print(self.x)"""}
class StringImporter(object):
def __init__(self, modules):
self._modules = dict(modules)
def find_module(self, fullname, path):
if fullname in self._modules.keys():
return self
return None
def load_module(self, fullname):
if not fullname in self._modules.keys():
raise ImportError(fullname)
new_module = imp.new_module(fullname)
exec(self._modules[fullname])
return new_module
if __name__ == '__main__':
sys.meta_path.append(StringImporter(modules))
from my_module import Test
my_test = Test()
my_test.print_number() # Should print 5
Não que a exec()
mudança fosse muito significativa. Não entendi o que aquela linha fazia no Python 2, "traduzi" da maneira que acho que está correta. No entanto, o código do Python 3 me dá o seguinte erro:
Traceback (most recent call last):
File "main.py", line 35, in <module>
from my_module import Test
File "<frozen importlib._bootstrap>", line 991, in _find_and_load
File "<frozen importlib._bootstrap>", line 975, in _find_and_load_unlocked
File "<frozen importlib._bootstrap>", line 655, in _load_unlocked
File "<frozen importlib._bootstrap>", line 626, in _load_backward_compatible
KeyError: 'my_module'
O que devo mudar no código para funcionar no Python 3 exatamente da mesma forma que funciona no Python 2?
Observação: Isso não responde à minha pergunta, pois não estou interessado em importar um módulo do .pyc
.
Respostas
A resposta curta é que você se esqueceu de traduzir a última metade da exec
instrução do exemplo de código. Isso faz com que o exec
seja aplicado in
no contexto do load_module
método - não o new_module
; então especifique o contexto:
exec(self._modules[fullname], new_module.__dict__)
No entanto, usando um Python com versão 3.4 ou superior, você fica sujeito ao PEP 451 (a introdução das especificações do módulo ), bem como à depreciação do impmódulo, em favor de importlib. Particularmente:
- A imp.new_module(name)função é substituída por
importlib.util.module_from_spec(spec)
. - Uma classe base abstrata para objetos localizador meta caminho é fornecido:
importlib.abc.MetaPathFinder
. - E esses objetos localizadores agora usam em
find_spec
vez defind_module
.
Aqui está uma reimplementação bem próxima do exemplo de código.
import importlib
import sys
import types
class StringLoader(importlib.abc.Loader):
def __init__(self, modules):
self._modules = modules
def has_module(self, fullname):
return (fullname in self._modules)
def create_module(self, spec):
if self.has_module(spec.name):
module = types.ModuleType(spec.name)
exec(self._modules[spec.name], module.__dict__)
return module
def exec_module(self, module):
pass
class StringFinder(importlib.abc.MetaPathFinder):
def __init__(self, loader):
self._loader = loader
def find_spec(self, fullname, path, target=None):
if self._loader.has_module(fullname):
return importlib.machinery.ModuleSpec(fullname, self._loader)
if __name__ == '__main__':
modules = {
'my_module': """
BAZ = 42
class Foo:
def __init__(self, *args: str):
self.args = args
def bar(self):
return ', '.join(self.args)
"""}
finder = StringFinder(StringLoader(modules))
sys.meta_path.append(finder)
import my_module
foo = my_module.Foo('Hello', 'World!')
print(foo.bar())
print(my_module.BAZ)