Как импортировать модуль с указанием полного пути?
Как я могу загрузить модуль Python, учитывая его полный путь? Обратите внимание, что файл может находиться где угодно в файловой системе, так как это опция конфигурации.
36 ответов
Для Python 3.5+ используйте:
import importlib.util
spec = importlib.util.spec_from_file_location("module.name", "/path/to/file.py")
foo = importlib.util.module_from_spec(spec)
spec.loader.exec_module(foo)
foo.MyClass()
Для Python 3.3 и 3.4 используйте:
from importlib.machinery import SourceFileLoader
foo = SourceFileLoader("module.name", "/path/to/file.py").load_module()
foo.MyClass()
(Хотя это не рекомендуется в Python 3.4.)
Python 2 использовать:
import imp
foo = imp.load_source('module.name', '/path/to/file.py')
foo.MyClass()
Есть эквивалентные вспомогательные функции для скомпилированных файлов Python и DLL.
Смотрите также. http://bugs.python.org/issue21436.
Преимущество добавления пути к sys.path (по сравнению с использованием imp) заключается в том, что он упрощает процесс импорта нескольких модулей из одного пакета. Например:
import sys
# the mock-0.3.1 dir contains testcase.py, testutils.py & mock.py
sys.path.append('/foo/bar/mock-0.3.1')
from testcase import TestCase
from testutils import RunTests
from mock import Mock, sentinel, patch
Чтобы импортировать ваш модуль, вам нужно добавить его каталог в переменную окружения, временно или постоянно.
Временно
import sys
sys.path.append("/path/to/my/modules/")
import my_module
Постоянно
Добавив следующую строку в ваш .bashrc файл (в linux) и исключительный source ~/.bashrc в терминале:
export PYTHONPATH="${PYTHONPATH}:/path/to/my/modules/"
Кредит / Источник: saarrrr, другой вопрос обмена стека
Если ваш модуль верхнего уровня не является файлом, но упакован как каталог с помощью __init__.py, то принятое решение почти работает, но не совсем. В Python 3.5+ необходим следующий код (обратите внимание на добавленную строку, которая начинается с 'sys.modules'):
MODULE_PATH = "/path/to/your/module/__init__.py"
MODULE_NAME = "mymodule"
spec = importlib.util.spec_from_file_location(MODULE_NAME, MODULE_PATH)
module = importlib.util.module_from_spec(spec)
sys.modules[spec.name] = module
spec.loader.exec_module(module)
Без этой строки при выполнении exec_module он пытается привязать относительный импорт в вашем верхнем уровне __init__.py к имени модуля верхнего уровня - в данном случае "mymodule". Но "mymodule" еще не загружен, поэтому вы получите ошибку "SystemError: Родительский модуль" mymodule "не загружен, не может выполнить относительный импорт". Поэтому вам нужно связать имя, прежде чем загружать его. Причиной этого является фундаментальный инвариант относительной системы импорта: "Инвариантное удержание состоит в том, что если у вас есть sys.modules['spam'] и sys.modules['spam.foo'] (как вы сделали бы после вышеупомянутого импорта), последний должен появляться как атрибут foo первого ", как обсуждалось здесь.
Похоже, вы не хотите специально импортировать файл конфигурации (в котором есть множество побочных эффектов и дополнительных сложностей), вы просто хотите запустить его и иметь доступ к результирующему пространству имен. Стандартная библиотека предоставляет API специально для этого в виде runpy.run_path:
from runpy import run_path
settings = run_path("/path/to/file.py")
Этот интерфейс доступен в Python 2.7 и Python 3.2+
Вы также можете сделать что-то вроде этого и добавить каталог, в котором находится файл конфигурации, к пути загрузки Python, а затем просто выполнить обычный импорт, предполагая, что вы заранее знаете имя файла, в данном случае "config".
Грязно, но это работает.
configfile = '~/config.py'
import os
import sys
sys.path.append(os.path.dirname(os.path.expanduser(configfile)))
import config
Я придумал слегка измененную версию замечательного ответа @SebastianRittau (для Python > 3.4, я думаю), который позволит вам загрузить файл с любым расширением в качестве модуля, используя spec_from_loader вместо spec_from_file_location:
from importlib.util import spec_from_loader, module_from_spec
from importlib.machinery import SourceFileLoader
spec = spec_from_loader("module.name", SourceFileLoader("module.name", "/path/to/file.py"))
mod = module_from_spec(spec)
spec.loader.exec_module(mod)
Преимущество кодирования пути в явном SourceFileLoader является то, что механизм не будет пытаться выяснить тип файла по расширению. Это означает, что вы можете загрузить что-то вроде .txt файл, используя этот метод, но вы не могли сделать это с spec_from_file_location без указания загрузчика, потому что .txt не в importlib.machinery.SOURCE_SUFFIXES,
To add to Sebastian Rittau's answer :At least for CPython, there's pydoc, and, while not officially declared, importing files is what does :
from pydoc import importfile
module = importfile('/path/to/module.py')
PS. For the sake of completeness, there's a reference to the current implementation at the moment of writing: pydoc.py, and I'm pleased to say that in the vein of xkcd 1987 it uses neither of the implemenations mentioned in issue 21436 -- at least, not verbatim.
Вы имеете в виду загрузку или импорт?
Вы можете манипулировать списком sys.path, указывать путь к вашему модулю, а затем импортировать ваш модуль. Например, данный модуль находится по адресу:
/foo/bar.py
Вы могли бы сделать:
import sys
sys.path[0:0] = ['/foo'] # puts the /foo directory at the start of your path
import bar
Вот код, который работает во всех версиях Python, начиная с 2.7-3.5 и, возможно, даже в других.
config_file = "/tmp/config.py"
with open(config_file) as f:
code = compile(f.read(), config_file, 'exec')
exec(code, globals(), locals())
Я проверял это. Это может быть некрасиво, но пока единственный, который работает во всех версиях.
def import_file(full_path_to_module):
try:
import os
module_dir, module_file = os.path.split(full_path_to_module)
module_name, module_ext = os.path.splitext(module_file)
save_cwd = os.getcwd()
os.chdir(module_dir)
module_obj = __import__(module_name)
module_obj.__file__ = full_path_to_module
globals()[module_name] = module_obj
os.chdir(save_cwd)
except:
raise ImportError
import_file('/home/somebody/somemodule.py')
Если у нас есть скрипты в одном проекте, но в разных каталогах, мы можем решить эту проблему следующим способом.
В этой ситуации utils.py в src/main/util/
import sys
sys.path.append('./')
import src.main.util.utils
#or
from src.main.util.utils import json_converter # json_converter is example method
Я верю, что вы можете использовать imp.find_module() а также imp.load_module() загрузить указанный модуль. Вам нужно будет разделить имя модуля по пути, т.е. если вы хотите загрузить /home/mypath/mymodule.py вам нужно сделать:
imp.find_module('mymodule', '/home/mypath/')
... но это должно сделать работу.
Вы можете использовать pkgutil модуль (в частности, walk_packages метод), чтобы получить список пакетов в текущем каталоге. Оттуда тривиально использовать importlib машины для импорта модулей, которые вы хотите:
import pkgutil
import importlib
packages = pkgutil.walk_packages(path='.')
for importer, name, is_package in packages:
mod = importlib.import_module(name)
# do whatever you want with module now, it's been imported!
Специально для этого есть пакет:
from thesmuggler import smuggle
# À la `import weapons`
weapons = smuggle('weapons.py')
# À la `from contraband import drugs, alcohol`
drugs, alcohol = smuggle('drugs', 'alcohol', source='contraband.py')
# À la `from contraband import drugs as dope, alcohol as booze`
dope, booze = smuggle('drugs', 'alcohol', source='contraband.py')
Он протестирован во всех версиях Python (в том числе Jython и PyPy), но может оказаться излишним в зависимости от размера вашего проекта.
Создать модуль python test.py
import sys
sys.path.append("<project-path>/lib/")
from tes1 import Client1
from tes2 import Client2
import tes3
Создать модуль python test_check.py
from test import Client1
from test import Client2
from test import test3
Мы можем импортировать импортированный модуль из модуля.
Эта область Python 3.4 кажется чрезвычайно сложной для понимания! Однако с небольшим количеством взлома, используя код от Криса Кэллоуэя как начало, мне удалось заставить кое-что работать. Вот основная функция.
def import_module_from_file(full_path_to_module):
"""
Import a module given the full path/filename of the .py file
Python 3.4
"""
module = None
try:
# Get module name and path from full path
module_dir, module_file = os.path.split(full_path_to_module)
module_name, module_ext = os.path.splitext(module_file)
# Get module "spec" from filename
spec = importlib.util.spec_from_file_location(module_name,full_path_to_module)
module = spec.loader.load_module()
except Exception as ec:
# Simple error printing
# Insert "sophisticated" stuff here
print(ec)
finally:
return module
Похоже, что для этого используются устаревшие модули из Python 3.4. Я не притворяюсь, что понимаю почему, но, похоже, это работает изнутри программы. Я обнаружил, что решение Криса работает в командной строке, но не внутри программы.
Я написал свою собственную глобальную и переносимую функцию импорта, основанную на importlib модуль, для:
- Уметь импортировать как модуль как подмодуль, так и импортировать содержимое модуля в родительский модуль (или в глобальные объекты, если родительский модуль отсутствует).
- Уметь импортировать модули с точками в имени файла.
- Уметь импортировать модули с любым расширением.
- Уметь использовать отдельное имя для подмодуля вместо имени файла без расширения, которое используется по умолчанию.
- Уметь определять порядок импорта на основе ранее импортированного модуля, а не в зависимости от
sys.pathили в каком-либо хранилище путей поиска.
Структура каталогов примеров:
<root>
|
+- test.py
|
+- testlib.py
|
+- /std1
| |
| +- testlib.std1.py
|
+- /std2
| |
| +- testlib.std2.py
|
+- /std3
|
+- testlib.std3.py
Зависимость и порядок включения:
test.py
-> testlib.py
-> testlib.std1.py
-> testlib.std2.py
-> testlib.std3.py
Реализация:
Магазин последних изменений: https://sourceforge.net/p/tacklelib/tacklelib/HEAD/tree/trunk/python/tacklelib/tacklelib.py
test.py:
import os, sys, inspect, copy
SOURCE_FILE = os.path.abspath(inspect.getsourcefile(lambda:0)).replace('\\','/')
SOURCE_DIR = os.path.dirname(SOURCE_FILE)
print("test::SOURCE_FILE: ", SOURCE_FILE)
# portable import to the global space
sys.path.append(TACKLELIB_ROOT) # TACKLELIB_ROOT - path to the library directory
import tacklelib as tkl
tkl.tkl_init(tkl)
# cleanup
del tkl # must be instead of `tkl = None`, otherwise the variable would be still persist
sys.path.pop()
tkl_import_module(SOURCE_DIR, 'testlib.py')
print(globals().keys())
testlib.base_test()
testlib.testlib_std1.std1_test()
testlib.testlib_std1.testlib_std2.std2_test()
#testlib.testlib.std3.std3_test() # does not reachable directly ...
getattr(globals()['testlib'], 'testlib.std3').std3_test() # ... but reachable through the `globals` + `getattr`
tkl_import_module(SOURCE_DIR, 'testlib.py', '.')
print(globals().keys())
base_test()
testlib_std1.std1_test()
testlib_std1.testlib_std2.std2_test()
#testlib.std3.std3_test() # does not reachable directly ...
globals()['testlib.std3'].std3_test() # ... but reachable through the `globals` + `getattr`
testlib.py:
# optional for 3.4.x and higher
#import os, inspect
#
#SOURCE_FILE = os.path.abspath(inspect.getsourcefile(lambda:0)).replace('\\','/')
#SOURCE_DIR = os.path.dirname(SOURCE_FILE)
print("1 testlib::SOURCE_FILE: ", SOURCE_FILE)
tkl_import_module(SOURCE_DIR + '/std1', 'testlib.std1.py', 'testlib_std1')
# SOURCE_DIR is restored here
print("2 testlib::SOURCE_FILE: ", SOURCE_FILE)
tkl_import_module(SOURCE_DIR + '/std3', 'testlib.std3.py')
print("3 testlib::SOURCE_FILE: ", SOURCE_FILE)
def base_test():
print('base_test')
testlib.std1.py:
# optional for 3.4.x and higher
#import os, inspect
#
#SOURCE_FILE = os.path.abspath(inspect.getsourcefile(lambda:0)).replace('\\','/')
#SOURCE_DIR = os.path.dirname(SOURCE_FILE)
print("testlib.std1::SOURCE_FILE: ", SOURCE_FILE)
tkl_import_module(SOURCE_DIR + '/../std2', 'testlib.std2.py', 'testlib_std2')
def std1_test():
print('std1_test')
testlib.std2.py:
# optional for 3.4.x and higher
#import os, inspect
#
#SOURCE_FILE = os.path.abspath(inspect.getsourcefile(lambda:0)).replace('\\','/')
#SOURCE_DIR = os.path.dirname(SOURCE_FILE)
print("testlib.std2::SOURCE_FILE: ", SOURCE_FILE)
def std2_test():
print('std2_test')
testlib.std3.py:
# optional for 3.4.x and higher
#import os, inspect
#
#SOURCE_FILE = os.path.abspath(inspect.getsourcefile(lambda:0)).replace('\\','/')
#SOURCE_DIR = os.path.dirname(SOURCE_FILE)
print("testlib.std3::SOURCE_FILE: ", SOURCE_FILE)
def std3_test():
print('std3_test')
Выход (3.7.4):
test::SOURCE_FILE: <root>/test01/test.py
import : <root>/test01/testlib.py as testlib -> []
1 testlib::SOURCE_FILE: <root>/test01/testlib.py
import : <root>/test01/std1/testlib.std1.py as testlib_std1 -> ['testlib']
import : <root>/test01/std1/../std2/testlib.std2.py as testlib_std2 -> ['testlib', 'testlib_std1']
testlib.std2::SOURCE_FILE: <root>/test01/std1/../std2/testlib.std2.py
2 testlib::SOURCE_FILE: <root>/test01/testlib.py
import : <root>/test01/std3/testlib.std3.py as testlib.std3 -> ['testlib']
testlib.std3::SOURCE_FILE: <root>/test01/std3/testlib.std3.py
3 testlib::SOURCE_FILE: <root>/test01/testlib.py
dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', '__file__', '__cached__', 'os', 'sys', 'inspect', 'copy', 'SOURCE_FILE', 'SOURCE_DIR', 'TackleGlobalImportModuleState', 'tkl_membercopy', 'tkl_merge_module', 'tkl_get_parent_imported_module_state', 'tkl_declare_global', 'tkl_import_module', 'TackleSourceModuleState', 'tkl_source_module', 'TackleLocalImportModuleState', 'testlib'])
base_test
std1_test
std2_test
std3_test
import : <root>/test01/testlib.py as . -> []
1 testlib::SOURCE_FILE: <root>/test01/testlib.py
import : <root>/test01/std1/testlib.std1.py as testlib_std1 -> ['testlib']
import : <root>/test01/std1/../std2/testlib.std2.py as testlib_std2 -> ['testlib', 'testlib_std1']
testlib.std2::SOURCE_FILE: <root>/test01/std1/../std2/testlib.std2.py
2 testlib::SOURCE_FILE: <root>/test01/testlib.py
import : <root>/test01/std3/testlib.std3.py as testlib.std3 -> ['testlib']
testlib.std3::SOURCE_FILE: <root>/test01/std3/testlib.std3.py
3 testlib::SOURCE_FILE: <root>/test01/testlib.py
dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', '__file__', '__cached__', 'os', 'sys', 'inspect', 'copy', 'SOURCE_FILE', 'SOURCE_DIR', 'TackleGlobalImportModuleState', 'tkl_membercopy', 'tkl_merge_module', 'tkl_get_parent_imported_module_state', 'tkl_declare_global', 'tkl_import_module', 'TackleSourceModuleState', 'tkl_source_module', 'TackleLocalImportModuleState', 'testlib', 'testlib_std1', 'testlib.std3', 'base_test'])
base_test
std1_test
std2_test
std3_test
Протестировано на Python 3.7.4, 3.2.5, 2.7.16
Плюсы:
- Может импортировать оба модуля как подмодуль и может импортировать содержимое модуля в родительский модуль (или в глобальные объекты, если родительский модуль отсутствует).
- Можно импортировать модули с точками в имени файла.
- Может импортировать любой модуль расширения из любого модуля расширения.
- Может использовать отдельное имя для подмодуля вместо имени файла без расширения, которое используется по умолчанию (например,
testlib.std.pyв качествеtestlib,testlib.blabla.pyв качествеtestlib_blablaи так далее). - Не зависит от
sys.pathили в каком-либо хранилище путей поиска. - Не требует сохранения / восстановления глобальных переменных типа
SOURCE_FILEа такжеSOURCE_DIRмежду звонками вtkl_import_module. - [за
3.4.xи выше] Может смешивать пространства имен модулей во вложенныхtkl_import_moduleзвонки (например:named->local->namedилиlocal->named->localи так далее). - [за
3.4.xи выше] Может автоматически экспортировать глобальные переменные / функции / классы, откуда они объявлены, во все дочерние модули, импортированные черезtkl_import_module(сквозьtkl_declare_globalфункция).
Минусы:
- [за
3.3.xи ниже] Требовать декларироватьtkl_import_moduleво всех модулях, которые обращаются кtkl_import_module(дублирование кода)
Обновление 1,2 (для3.4.x только и выше):
В Python 3.4 и выше вы можете обойти требование объявления tkl_import_module в каждом модуле объявить tkl_import_module в модуле верхнего уровня, и функция будет внедряться во все дочерние модули за один вызов (это своего рода импорт самостоятельного развертывания).
Обновление 3:
Добавлена функция tkl_source_module как аналог bash source с поддержкой защиты выполнения при импорте (реализовано через слияние модулей вместо импорта).
Обновление 4:
Добавлена функция tkl_declare_global для автоматического экспорта глобальной переменной модуля во все дочерние модули, где глобальная переменная модуля не отображается, поскольку не является частью дочернего модуля.
Обновление 5:
Все функции перенесены в библиотеку tacklelib, см. Ссылку выше.
Чтобы импортировать модуль из заданного имени файла, вы можете временно расширить путь и восстановить системный путь в ссылке на блок finally :
filename = "directory/module.py"
directory, module_name = os.path.split(filename)
module_name = os.path.splitext(module_name)[0]
path = list(sys.path)
sys.path.insert(0, directory)
try:
module = __import__(module_name)
finally:
sys.path[:] = path # restore
Я сделал пакет, который использует imp для тебя. Я называю это import_file и вот как это используется:
>>>from import_file import import_file
>>>mylib = import_file('c:\\mylib.py')
>>>another = import_file('relative_subdir/another.py')
Вы можете получить его по адресу:
http://pypi.python.org/pypi/import_file
или в
Простое решение с использованием importlib вместо imp пакет (протестирован для Python 2.7, хотя он должен работать и для Python 3):
import importlib
dirname, basename = os.path.split(pyfilepath) # pyfilepath: '/my/path/mymodule.py'
sys.path.append(dirname) # only directories should be added to PYTHONPATH
module_name = os.path.splitext(basename)[0] # '/my/path/mymodule.py' --> 'mymodule'
module = importlib.import_module(module_name) # name space of defined module (otherwise we would literally look for "module_name")
Теперь вы можете напрямую использовать пространство имен импортируемого модуля, например так:
a = module.myvar
b = module.myfunc(a)
Преимущество этого решения в том, что нам даже не нужно знать фактическое имя модуля, который мы хотели бы импортировать, чтобы использовать его в нашем коде. Это полезно, например, в случае, если путь модуля является настраиваемым аргументом.
Я не говорю, что это лучше, но ради полноты я хотел предложить exec функция, доступная как в Python 2, так и в 3. exec позволяет выполнять произвольный код либо в глобальной области, либо во внутренней области, представленной в виде словаря.
Например, если у вас есть модуль, хранящийся в "/path/to/module "с функцией foo() Вы можете запустить его, выполнив следующее:
module = dict()
with open("/path/to/module") as f:
exec(f.read(), module)
module['foo']()
Это делает более явным то, что вы загружаете код динамически, и дает вам некоторую дополнительную мощность, такую как возможность предоставления пользовательских встроенных функций.
И если для вас важен доступ через атрибуты, а не ключи, вы можете разработать собственный класс dict для глобалов, который обеспечивает такой доступ, например:
class MyModuleClass(dict):
def __getattr__(self, name):
return self.__getitem__(name)
Импорт пакетов модулей во время выполнения (рецепт Python)
http://code.activestate.com/recipes/223972/
###################
## #
## classloader.py #
## #
###################
import sys, types
def _get_mod(modulePath):
try:
aMod = sys.modules[modulePath]
if not isinstance(aMod, types.ModuleType):
raise KeyError
except KeyError:
# The last [''] is very important!
aMod = __import__(modulePath, globals(), locals(), [''])
sys.modules[modulePath] = aMod
return aMod
def _get_func(fullFuncName):
"""Retrieve a function object from a full dotted-package name."""
# Parse out the path, module, and function
lastDot = fullFuncName.rfind(u".")
funcName = fullFuncName[lastDot + 1:]
modPath = fullFuncName[:lastDot]
aMod = _get_mod(modPath)
aFunc = getattr(aMod, funcName)
# Assert that the function is a *callable* attribute.
assert callable(aFunc), u"%s is not callable." % fullFuncName
# Return a reference to the function itself,
# not the results of the function.
return aFunc
def _get_class(fullClassName, parentClass=None):
"""Load a module and retrieve a class (NOT an instance).
If the parentClass is supplied, className must be of parentClass
or a subclass of parentClass (or None is returned).
"""
aClass = _get_func(fullClassName)
# Assert that the class is a subclass of parentClass.
if parentClass is not None:
if not issubclass(aClass, parentClass):
raise TypeError(u"%s is not a subclass of %s" %
(fullClassName, parentClass))
# Return a reference to the class itself, not an instantiated object.
return aClass
######################
## Usage ##
######################
class StorageManager: pass
class StorageManagerMySQL(StorageManager): pass
def storage_object(aFullClassName, allOptions={}):
aStoreClass = _get_class(aFullClassName, StorageManager)
return aStoreClass(allOptions)
Это должно работать
path = os.path.join('./path/to/folder/with/py/files', '*.py')
for infile in glob.glob(path):
basename = os.path.basename(infile)
basename_without_extension = basename[:-3]
# http://docs.python.org/library/imp.html?highlight=imp#module-imp
imp.load_source(basename_without_extension, infile)
В Linux добавление символической ссылки в каталог, в котором находится ваш скрипт на python, работает.
то есть:
ln -s /absolute/path/to/module/module.py /absolute/path/to/script/module.py
питон создаст /absolute/path/to/script/module.pyc и обновит его, если вы измените содержимое /absolute/path/to/module/module.py
затем включите следующее в mypythonscript.py
from module import *
Вот способ загрузки файлов вроде C и т. Д.
from importlib.machinery import SourceFileLoader
import os
def LOAD (MODULE_PATH):
if (MODULE_PATH [ 0 ] == "/"):
FULL_PATH = MODULE_PATH;
else:
DIR_PATH = os.path.dirname (os.path.realpath (__file__))
FULL_PATH = os.path.normpath (DIR_PATH + "/" + MODULE_PATH)
return SourceFileLoader (FULL_PATH, FULL_PATH).load_module ()
Реализации Где:
Y = LOAD ("../Z.py")
A = LOAD ("./A.py")
D = LOAD ("./C/D.py")
A_ = LOAD ("/IMPORTS/A.py")
Y.DEF ();
A.DEF ();
D.DEF ();
A_.DEF ();
Где каждый из файлов выглядит так:
def DEF ():
print ("A");
Довольно простой способ: предположим, что вы хотите импортировать файл с относительным путем../../MyLibs/pyfunc.py
libPath = '../../MyLibs'
import sys
if not libPath in sys.path: sys.path.append(libPath)
import pyfunc as pf
Но если вы сделаете это без охраны, вы, наконец, сможете пройти очень длинный путь
Добавив это в список ответов, я не смог найти ничего, что сработало. Это позволит импортировать скомпилированные (pyd) модули Python в 3.4:
import sys
import importlib.machinery
def load_module(name, filename):
# If the Loader finds the module name in this list it will use
# module_name.__file__ instead so we need to delete it here
if name in sys.modules:
del sys.modules[name]
loader = importlib.machinery.ExtensionFileLoader(name, filename)
module = loader.load_module()
locals()[name] = module
globals()[name] = module
load_module('something', r'C:\Path\To\something.pyd')
something.do_something()
Я считаю, что это простой ответ: module = dict()
code = """
import json
def testhi() :
return json.dumps({"key" : "value"}, indent = 4 )
"""
exec(code, module)
x = module['testhi']()
print(x)