Динамический импорт модулей Python по полному пути: техники и примеры

import importlib.util
import sys

def import_module_from_path(module_name, module_path):
"""
Динамически импортирует модуль Python по полному пути к файлу.

Args:
module_name (str): Имя, которое будет присвоено модулю
module_path (str): Полный путь к файлу модуля (.py)

Returns:
module: Загруженный модуль или None в случае ошибки
"""
try:
# Шаг 1: Создаем спецификацию модуля
spec = importlib.util.spec_from_file_location(module_name, module_path)
if spec is None:
return None

# Шаг 2: Создаем модуль на основе спецификации
module = importlib.util.module_from_spec(spec)

# Шаг 3: Регистрируем модуль в sys.modules
sys.modules[module_name] = module

# Шаг 4: Выполняем код модуля
spec.loader.exec_module(module)

return module
except Exception as e:
print(f"Ошибка при импорте модуля {module_name}: {e}")
return None

# Пример использования
calculator_module = import_module_from_path(
"calculator", 
"/path/to/your/modules/calculator.py"
)

if calculator_module:
result = calculator_module.add(5, 3)
print(f"Результат: {result}")

import sys
import os

# Добавляем путь к каталогу с модулем в sys.path
module_dir = '/path/to/your/modules'
sys.path.insert(0, module_dir)

# Теперь можно импортировать модуль как обычно
import calculator

# Используем модуль
result = calculator.add(5, 3)
print(f"Результат: {result}")

# По завершении можно удалить добавленный путь
sys.path.remove(module_dir)

# Добавляем каталог в sys.path
import sys
sys.path.insert(0, '/path/to/your/modules')

# Динамически импортируем модуль
module_name = 'calculator'
calculator_module = __import__(module_name)

# Используем импортированный модуль
result = calculator_module.add(5, 3)
print(f"Результат: {result}")

# Создаем пустой словарь для хранения глобальных переменных модуля
module_globals = {}

# Открываем и выполняем файл модуля
with open('/path/to/your/modules/calculator.py', 'r') as file:
exec(file.read(), module_globals)

# Теперь можем использовать функции из модуля
result = module_globals['add'](5, 3)
print(f"Результат: {result}")

import os
import importlib.util

class PluginManager:
def __init__(self, plugins_dir):
self.plugins_dir = plugins_dir
self.plugins = {}

def discover_plugins(self):
"""Обнаруживает все плагины в указанном каталоге."""
if not os.path.isdir(self.plugins_dir):
print(f"Каталог плагинов не существует: {self.plugins_dir}")
return

for filename in os.listdir(self.plugins_dir):
if filename.endswith('.py') and not filename.startswith('__'):
plugin_path = os.path.join(self.plugins_dir, filename)
plugin_name = os.path.splitext(filename)[0]
self.load_plugin(plugin_name, plugin_path)

def load_plugin(self, plugin_name, plugin_path):
"""Загружает отдельный плагин по пути."""
try:
spec = importlib.util.spec_from_file_location(plugin_name, plugin_path)
plugin = importlib.util.module_from_spec(spec)
spec.loader.exec_module(plugin)

# Проверяем, что плагин имеет необходимый интерфейс
if hasattr(plugin, 'register') and hasattr(plugin, 'execute'):
self.plugins[plugin_name] = plugin
plugin.register()
print(f"Плагин загружен: {plugin_name}")
else:
print(f"Недопустимый плагин: {plugin_name} (отсутствуют обязательные методы)")
except Exception as e:
print(f"Ошибка при загрузке плагина {plugin_name}: {e}")

def execute_plugin(self, plugin_name, *args, **kwargs):
"""Выполняет указанный плагин с заданными аргументами."""
if plugin_name in self.plugins:
return self.plugins[plugin_name].execute(*args, **kwargs)
else:
print(f"Плагин не найден: {plugin_name}")
return None

# Пример использования
manager = PluginManager("/path/to/plugins")
manager.discover_plugins()
result = manager.execute_plugin("image_processor", image_path="photo.jpg")

import importlib.util
import os
import time

class HotReloader:
def __init__(self, module_path):
self.module_path = module_path
self.module_name = os.path.splitext(os.path.basename(module_path))[0]
self.module = None
self.last_modified = 0
self.load_module()

def load_module(self):
"""Загружает модуль из указанного пути."""
try:
spec = importlib.util.spec_from_file_location(self.module_name, self.module_path)
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
self.module = module
self.last_modified = os.path.getmtime(self.module_path)
print(f"Модуль {self.module_name} загружен/обновлен")
return True
except Exception as e:
print(f"Ошибка при загрузке модуля {self.module_name}: {e}")
return False

def check_for_changes(self):
"""Проверяет, был ли модуль изменен, и перезагружает его при необходимости."""
current_mtime = os.path.getmtime(self.module_path)
if current_mtime > self.last_modified:
print(f"Обнаружены изменения в модуле {self.module_name}")
return self.load_module()
return False

def get_module(self):
"""Возвращает текущий экземпляр модуля."""
return self.module

# Пример использования в бесконечном цикле
reloader = HotReloader("/path/to/business_logic.py")
while True:
if reloader.check_for_changes():
print("Модуль был обновлен, применяем новую логику")

module = reloader.get_module()
result = module.process_data(some_input_data)
print(f"Результат обработки: {result}")

time.sleep(1) # Проверка изменений каждую секунду

import importlib.util
import os

def load_config(environment):
"""
Загружает конфигурацию для указанного окружения.

Args:
environment (str): Имя окружения (dev, staging, prod)

Returns:
module: Загруженный конфигурационный модуль
"""
config_dir = os.path.join(os.path.dirname(__file__), 'configs')
config_file = f"config_{environment}.py"
config_path = os.path.join(config_dir, config_file)

if not os.path.exists(config_path):
raise ValueError(f"Конфигурация для окружения '{environment}' не найдена")

module_name = f"config_{environment}"
spec = importlib.util.spec_from_file_location(module_name, config_path)
config = importlib.util.module_from_spec(spec)
spec.loader.exec_module(config)

print(f"Загружена конфигурация для окружения: {environment}")
return config

# Использование в приложении
env = os.environ.get('ENVIRONMENT', 'dev')
config = load_config(env)

# Теперь мы можем использовать настройки из конфигурации
database = config.DATABASE_URI
api_keys = config.API_KEYS
debug_mode = config.DEBUG

import importlib.util
import sys
import time

class ModuleCache:
def __init__(self):
self.cache = {} # Кэш загруженных модулей

def import_module(self, module_name, module_path):
"""
Импортирует модуль с кэшированием для повышения производительности.

Args:
module_name (str): Имя модуля
module_path (str): Полный путь к файлу модуля

Returns:
module: Загруженный модуль
"""
cache_key = f"{module_name}:{module_path}"

# Проверяем кэш
if cache_key in self.cache:
return self.cache[cache_key]

# Загружаем модуль, если его нет в кэше
start_time = time.time()
try:
spec = importlib.util.spec_from_file_location(module_name, module_path)
module = importlib.util.module_from_spec(spec)
sys.modules[module_name] = module
spec.loader.exec_module(module)

# Сохраняем в кэш
self.cache[cache_key] = module

load_time = (time.time() – start_time) * 1000
print(f"Модуль {module_name} загружен за {load_time:.2f} мс")
return module
except Exception as e:
print(f"Ошибка при импорте модуля {module_name}: {e}")
return None

def clear_cache(self, module_name=None, module_path=None):
"""
Очищает кэш модулей, полностью или для конкретного модуля.

Args:
module_name (str, optional): Имя модуля для удаления из кэша
module_path (str, optional): Путь к модулю для удаления из кэша
"""
if module_name and module_path:
cache_key = f"{module_name}:{module_path}"
if cache_key in self.cache:
del self.cache[cache_key]
print(f"Модуль {module_name} удален из кэша")
else:
self.cache.clear()
print("Кэш модулей очищен")

# Пример использования
module_cache = ModuleCache()

# Первая загрузка (займет время)
calc = module_cache.import_module("calculator", "/path/to/calculator.py")
result1 = calc.add(5, 3)

# Вторая загрузка (мгновенная, из кэша)
calc_again = module_cache.import_module("calculator", "/path/to/calculator.py")
result2 = calc_again.add(10, 5)

# Очистка кэша при необходимости (например, если модуль обновился)
module_cache.clear_cache("calculator", "/path/to/calculator.py")

import importlib.util
import sys
import types

def create_namespace_package(namespace):
"""
Создает пространство имен для изоляции модулей.

Args:
namespace (str): Имя пространства имен

Returns:
module: Созданный модуль пространства имен
"""
if namespace in sys.modules:
return sys.modules[namespace]

namespace_module = types.ModuleType(namespace)
namespace_module.__path__ = []
sys.modules[namespace] = namespace_module
return namespace_module

def import_isolated_module(module_path, namespace="dynamic_modules"):
"""
Импортирует модуль в изолированное пространство имен.

Args:
module_path (str): Полный путь к файлу модуля
namespace (str): Имя пространства имен для изоляции

Returns:
module: Изолированный модуль
"""
# Создаем пространство имен, если его еще нет
namespace_pkg = create_namespace_package(namespace)

# Определяем имя модуля внутри пространства имен
module_name = f"{namespace}.{module_path.split('/')[-1].replace('.py', '')}"

# Импортируем модуль в пространство имен
spec = importlib.util.spec_from_file_location(module_name, module_path)
module = importlib.util.module_from_spec(spec)
sys.modules[module_name] = module
spec.loader.exec_module(module)

# Добавляем модуль в пространство имен для доступа через точечную нотацию
setattr(namespace_pkg, module_name.split('.')[-1], module)

return module

# Пример использования
module1 = import_isolated_module("/path/to/module1.py")
module2 = import_isolated_module("/path/to/module2.py")

# Даже если в обоих модулях есть функция с одинаковым именем, они не конфликтуют
result1 = module1.process_data(data)
result2 = module2.process_data(data)

import importlib.util
import sys
import traceback
import logging

# Настройка логирования
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s – %(name)s – %(levelname)s – %(message)s',
filename='module_loader.log'
)
logger = logging.getLogger('ModuleLoader')

def safe_import_module(module_name, module_path, fallback_module=None):
"""
Безопасно импортирует модуль с обработкой всех возможных исключений.

Args:
module_name (str): Имя модуля
module_path (str): Полный путь к файлу модуля
fallback_module (module, optional): Резервный модуль, используемый в случае ошибки

Returns:
module: Загруженный модуль или fallback_module в случае ошибки
"""
try:
# Основной импорт
spec = importlib.util.spec_from_file_location(module_name, module_path)
if spec is None:
raise ImportError(f"Не удалось создать спецификацию для {module_path}")

module = importlib.util.module_from_spec(spec)
sys.modules[module_name] = module
spec.loader.exec_module(module)

logger.info(f"Модуль {module_name} успешно загружен")
return module

except FileNotFoundError:
logger.error(f"Файл модуля не найден: {module_path}")
except SyntaxError:
logger.error(f"Синтаксическая ошибка в модуле {module_name}")
logger.debug(traceback.format_exc())
except ImportError as e:
logger.error(f"Ошибка импорта модуля {module_name}: {e}")
except Exception as e:
logger.error(f"Непредвиденная ошибка при импорте {module_name}: {e}")
logger.debug(traceback.format_exc())

# В случае любой ошибки возвращаем резервный модуль
if fallback_module:
logger.info(f"Используем резервный модуль для {module_name}")
return fallback_module

return None

# Пример использования с резервным модулем
class FallbackCalculator:
@staticmethod
def add(a, b):
return a + b

@staticmethod
def subtract(a, b):
return a – b

# Попытка загрузки модуля с резервным вариантом
calculator = safe_import_module(
"calculator", 
"/path/to/calculator.py", 
fallback_module=FallbackCalculator()
)

# Использование модуля (основного или резервного)
result = calculator.add(5, 3)
print(f"Результат: {result}")