404 lines
16 KiB
Python
404 lines
16 KiB
Python
import importlib
|
||
import importlib.util
|
||
import os
|
||
import shutil
|
||
import subprocess
|
||
import sys
|
||
from pathlib import Path
|
||
from typing import Any
|
||
|
||
from packaging import version
|
||
from packaging.requirements import Requirement
|
||
|
||
from src.common.logger import get_logger
|
||
from src.plugin_system.base.component_types import PythonDependency
|
||
from src.plugin_system.utils.dependency_alias import INSTALL_NAME_TO_IMPORT_NAME
|
||
|
||
logger = get_logger("dependency_manager")
|
||
|
||
|
||
class VenvDetector:
|
||
"""虚拟环境检测器"""
|
||
|
||
@staticmethod
|
||
def detect_venv_type() -> str | None:
|
||
"""
|
||
检测虚拟环境类型
|
||
返回: 'uv' | 'venv' | 'conda' | None
|
||
"""
|
||
# 检查是否在虚拟环境中
|
||
in_venv = hasattr(sys, "real_prefix") or (
|
||
hasattr(sys, "base_prefix") and sys.base_prefix != sys.prefix
|
||
)
|
||
|
||
if not in_venv:
|
||
logger.warning("当前不在虚拟环境中")
|
||
return None
|
||
|
||
venv_path = Path(sys.prefix)
|
||
|
||
# 1. 检测 uv (优先检查 pyvenv.cfg 文件)
|
||
pyvenv_cfg = venv_path / "pyvenv.cfg"
|
||
if pyvenv_cfg.exists():
|
||
try:
|
||
with open(pyvenv_cfg, encoding="utf-8") as f:
|
||
content = f.read()
|
||
if "uv = " in content:
|
||
logger.info("检测到 uv 虚拟环境")
|
||
return "uv"
|
||
except Exception as e:
|
||
logger.warning(f"读取 pyvenv.cfg 失败: {e}")
|
||
|
||
# 2. 检测 conda (检查环境变量和路径)
|
||
if "CONDA_DEFAULT_ENV" in os.environ or "CONDA_PREFIX" in os.environ:
|
||
logger.info("检测到 conda 虚拟环境")
|
||
return "conda"
|
||
|
||
# 通过路径特征检测 conda
|
||
if "conda" in str(venv_path).lower() or "anaconda" in str(venv_path).lower():
|
||
logger.info(f"检测到 conda 虚拟环境 (路径: {venv_path})")
|
||
return "conda"
|
||
|
||
# 3. 默认为 venv (标准 Python 虚拟环境)
|
||
logger.info(f"检测到标准 venv 虚拟环境 (路径: {venv_path})")
|
||
return "venv"
|
||
|
||
@staticmethod
|
||
def get_install_command(venv_type: str | None) -> list[str]:
|
||
"""
|
||
根据虚拟环境类型获取安装命令
|
||
|
||
Args:
|
||
venv_type: 虚拟环境类型 ('uv' | 'venv' | 'conda' | None)
|
||
|
||
Returns:
|
||
安装命令列表 (不包括包名)
|
||
"""
|
||
if venv_type == "uv":
|
||
# 检查 uv 是否可用
|
||
uv_path = shutil.which("uv")
|
||
if uv_path:
|
||
logger.debug("使用 uv pip 安装")
|
||
return [uv_path, "pip", "install"]
|
||
else:
|
||
logger.warning("未找到 uv 命令，回退到标准 pip")
|
||
return [sys.executable, "-m", "pip", "install"]
|
||
|
||
elif venv_type == "conda":
|
||
# 获取当前 conda 环境名
|
||
conda_env = os.environ.get("CONDA_DEFAULT_ENV")
|
||
if conda_env:
|
||
logger.debug(f"使用 conda 在环境 {conda_env} 中安装")
|
||
return ["conda", "install", "-n", conda_env, "-y"]
|
||
else:
|
||
logger.warning("未找到 conda 环境名，回退到 pip")
|
||
return [sys.executable, "-m", "pip", "install"]
|
||
|
||
else:
|
||
# 默认使用 pip
|
||
logger.debug("使用标准 pip 安装")
|
||
return [sys.executable, "-m", "pip", "install"]
|
||
class DependencyManager:
|
||
"""Python包依赖管理器 (整合配置和虚拟环境检测)
|
||
|
||
负责检查和自动安装插件的Python包依赖
|
||
"""
|
||
|
||
def __init__(self, auto_install: bool = True, use_mirror: bool = False, mirror_url: str | None = None):
|
||
"""初始化依赖管理器
|
||
|
||
Args:
|
||
auto_install: 是否自动安装缺失的依赖
|
||
use_mirror: 是否使用PyPI镜像源
|
||
mirror_url: PyPI镜像源URL
|
||
"""
|
||
# 延迟导入配置以避免循环依赖
|
||
try:
|
||
from src.config.config import global_config
|
||
|
||
dep_config = global_config.dependency_management
|
||
# 优先使用配置文件中的设置，参数作为覆盖
|
||
self.auto_install = dep_config.auto_install if auto_install is True else auto_install
|
||
self.use_mirror = dep_config.use_mirror if use_mirror is False else use_mirror
|
||
self.mirror_url = dep_config.mirror_url if mirror_url is None else mirror_url
|
||
self.install_timeout = dep_config.auto_install_timeout
|
||
self.prompt_before_install = dep_config.prompt_before_install
|
||
|
||
except Exception as e:
|
||
logger.warning(f"无法加载依赖配置，使用默认设置: {e}")
|
||
self.auto_install = auto_install
|
||
self.use_mirror = use_mirror or False
|
||
self.mirror_url = mirror_url or ""
|
||
self.install_timeout = 300
|
||
self.prompt_before_install = False
|
||
|
||
# 检测虚拟环境类型
|
||
self.venv_type = VenvDetector.detect_venv_type()
|
||
if self.venv_type:
|
||
logger.info(f"依赖管理器初始化完成，虚拟环境类型: {self.venv_type}")
|
||
else:
|
||
logger.warning("依赖管理器初始化完成，但未检测到虚拟环境")
|
||
# ========== 依赖检查和安装核心方法 ==========
|
||
|
||
def check_dependencies(self, dependencies: Any, plugin_name: str = "") -> tuple[bool, list[str], list[str]]:
|
||
"""检查依赖包是否满足要求
|
||
|
||
Args:
|
||
dependencies: 依赖列表，支持字符串或PythonDependency对象
|
||
plugin_name: 插件名称，用于日志记录
|
||
|
||
Returns:
|
||
Tuple[bool, List[str], List[str]]: (是否全部满足, 缺失的包, 错误信息)
|
||
"""
|
||
missing_packages = []
|
||
error_messages = []
|
||
log_prefix = f"[Plugin:{plugin_name}] " if plugin_name else ""
|
||
|
||
# 标准化依赖格式
|
||
normalized_deps = self._normalize_dependencies(dependencies)
|
||
|
||
for dep in normalized_deps:
|
||
try:
|
||
if not self._check_single_dependency(dep):
|
||
logger.info(f"{log_prefix}缺少依赖包: {dep.get_pip_requirement()}")
|
||
missing_packages.append(dep.get_pip_requirement())
|
||
except Exception as e:
|
||
error_msg = f"检查依赖 {dep.package_name} 时发生错误: {e!s}"
|
||
error_messages.append(error_msg)
|
||
logger.error(f"{log_prefix}{error_msg}")
|
||
|
||
all_satisfied = len(missing_packages) == 0 and len(error_messages) == 0
|
||
|
||
if all_satisfied:
|
||
logger.debug(f"{log_prefix}所有Python依赖检查通过")
|
||
else:
|
||
logger.warning(
|
||
f"{log_prefix}Python依赖检查失败: 缺失{len(missing_packages)}个包, {len(error_messages)}个错误"
|
||
)
|
||
|
||
return all_satisfied, missing_packages, error_messages
|
||
|
||
def install_dependencies(self, packages: list[str], plugin_name: str = "") -> tuple[bool, list[str]]:
|
||
"""自动安装缺失的依赖包
|
||
|
||
Args:
|
||
packages: 要安装的包列表
|
||
plugin_name: 插件名称，用于日志记录
|
||
|
||
Returns:
|
||
Tuple[bool, List[str]]: (是否全部安装成功, 失败的包列表)
|
||
"""
|
||
if not packages:
|
||
return True, []
|
||
|
||
if not self.auto_install:
|
||
logger.info(f"[Plugin:{plugin_name}] 自动安装已禁用，跳过安装: {packages}")
|
||
return False, packages
|
||
|
||
log_prefix = f"[Plugin:{plugin_name}] " if plugin_name else ""
|
||
logger.info(f"{log_prefix}开始自动安装Python依赖: {packages}")
|
||
|
||
failed_packages = []
|
||
|
||
for package in packages:
|
||
try:
|
||
if self._install_single_package(package, plugin_name):
|
||
logger.info(f"{log_prefix} 成功安装: {package}")
|
||
else:
|
||
failed_packages.append(package)
|
||
logger.error(f"{log_prefix} 安装失败: {package}")
|
||
except Exception as e:
|
||
failed_packages.append(package)
|
||
logger.error(f"{log_prefix} 安装 {package} 时发生异常: {e!s}")
|
||
|
||
success = len(failed_packages) == 0
|
||
if success:
|
||
logger.info(f"{log_prefix} 所有依赖安装完成")
|
||
else:
|
||
logger.error(f"{log_prefix} 部分依赖安装失败: {failed_packages}")
|
||
|
||
return success, failed_packages
|
||
|
||
def check_and_install_dependencies(self, dependencies: Any, plugin_name: str = "") -> tuple[bool, list[str]]:
|
||
"""检查并自动安装依赖（组合操作）
|
||
|
||
Args:
|
||
dependencies: 依赖列表
|
||
plugin_name: 插件名称
|
||
|
||
Returns:
|
||
Tuple[bool, List[str]]: (是否全部满足, 错误信息列表)
|
||
"""
|
||
# 第一步：检查依赖
|
||
all_satisfied, missing_packages, check_errors = self.check_dependencies(dependencies, plugin_name)
|
||
|
||
if all_satisfied:
|
||
return True, []
|
||
|
||
all_errors = check_errors.copy()
|
||
|
||
# 第二步：尝试安装缺失的包
|
||
if missing_packages and self.auto_install:
|
||
install_success, failed_packages = self.install_dependencies(missing_packages, plugin_name)
|
||
|
||
if not install_success:
|
||
all_errors.extend([f"安装失败: {pkg}" for pkg in failed_packages])
|
||
else:
|
||
# 安装成功后重新检查
|
||
recheck_satisfied, recheck_missing, recheck_errors = self.check_dependencies(dependencies, plugin_name)
|
||
if not recheck_satisfied:
|
||
all_errors.extend(recheck_errors)
|
||
all_errors.extend([f"安装后仍缺失: {pkg}" for pkg in recheck_missing])
|
||
else:
|
||
return True, []
|
||
else:
|
||
all_errors.extend([f"缺失依赖: {pkg}" for pkg in missing_packages])
|
||
|
||
return False, all_errors
|
||
|
||
@staticmethod
|
||
def _normalize_dependencies(dependencies: Any) -> list[PythonDependency]:
|
||
"""将依赖列表标准化为PythonDependency对象"""
|
||
normalized = []
|
||
|
||
for dep in dependencies:
|
||
if isinstance(dep, str):
|
||
# 解析字符串格式的依赖
|
||
try:
|
||
# 尝试解析为requirement格式 (如 "package>=1.0.0")
|
||
req = Requirement(dep)
|
||
version_spec = str(req.specifier) if req.specifier else ""
|
||
|
||
normalized.append(
|
||
PythonDependency(
|
||
package_name=req.name,
|
||
version=version_spec,
|
||
install_name=dep, # 保持原始的安装名称
|
||
)
|
||
)
|
||
except Exception:
|
||
# 如果解析失败，作为简单包名处理
|
||
normalized.append(PythonDependency(package_name=dep, install_name=dep))
|
||
elif isinstance(dep, PythonDependency):
|
||
normalized.append(dep)
|
||
else:
|
||
logger.warning(f"未知的依赖格式: {dep}")
|
||
|
||
return normalized
|
||
|
||
@staticmethod
|
||
def _check_single_dependency(dep: PythonDependency) -> bool:
|
||
"""检查单个依赖是否满足要求"""
|
||
|
||
def _try_check(import_name: str) -> bool:
|
||
"""尝试使用给定的导入名进行检查"""
|
||
try:
|
||
spec = importlib.util.find_spec(import_name)
|
||
if spec is None:
|
||
return False
|
||
|
||
# 如果没有版本要求，导入成功就够了
|
||
if not dep.version:
|
||
return True
|
||
|
||
# 检查版本要求
|
||
try:
|
||
module = importlib.import_module(import_name)
|
||
installed_version = getattr(module, "__version__", None)
|
||
|
||
if installed_version is None:
|
||
# 尝试其他常见的版本属性
|
||
installed_version = getattr(module, "VERSION", None)
|
||
if installed_version is None:
|
||
logger.debug(f"无法获取包 {import_name} 的版本信息，假设满足要求")
|
||
return True
|
||
|
||
# 解析版本要求
|
||
req = Requirement(f"{dep.package_name}{dep.version}")
|
||
return version.parse(str(installed_version)) in req.specifier
|
||
|
||
except Exception as e:
|
||
logger.debug(f"检查包 {import_name} 版本时出错: {e}")
|
||
return True # 如果无法检查版本，假设满足要求
|
||
|
||
except ImportError:
|
||
return False
|
||
except Exception as e:
|
||
logger.error(f"检查依赖 {import_name} 时发生未知错误: {e}")
|
||
return False
|
||
|
||
# 1. 首先尝试使用原始的 package_name 进行检查
|
||
if _try_check(dep.package_name):
|
||
return True
|
||
|
||
# 2. 如果失败，查询别名映射表
|
||
# 注意：此时 dep.package_name 可能是 simple "requests" 或 "beautifulsoup4"
|
||
import_alias = INSTALL_NAME_TO_IMPORT_NAME.get(dep.package_name)
|
||
if import_alias:
|
||
logger.debug(f"依赖 '{dep.package_name}' 导入失败, 尝试使用别名 '{import_alias}'")
|
||
if _try_check(import_alias):
|
||
return True
|
||
|
||
# 3. 如果别名也失败了，或者没有别名，最终确认失败
|
||
return False
|
||
|
||
def _install_single_package(self, package: str, plugin_name: str = "") -> bool:
|
||
"""安装单个包 (支持虚拟环境自动检测)"""
|
||
try:
|
||
log_prefix = f"[Plugin:{plugin_name}] " if plugin_name else ""
|
||
|
||
# 根据虚拟环境类型构建安装命令
|
||
cmd = VenvDetector.get_install_command(self.venv_type)
|
||
cmd.append(package)
|
||
|
||
# 添加镜像源设置 (仅对 pip/uv 有效)
|
||
if self.use_mirror and self.mirror_url and "pip" in cmd:
|
||
cmd.extend(["-i", self.mirror_url])
|
||
logger.debug(f"{log_prefix}使用PyPI镜像源: {self.mirror_url}")
|
||
|
||
logger.info(f"{log_prefix}执行安装命令: {' '.join(cmd)}")
|
||
|
||
result = subprocess.run(
|
||
cmd,
|
||
capture_output=True,
|
||
text=True,
|
||
encoding="utf-8",
|
||
errors="ignore",
|
||
timeout=self.install_timeout,
|
||
check=False,
|
||
)
|
||
|
||
if result.returncode == 0:
|
||
logger.info(f"{log_prefix}安装成功: {package}")
|
||
return True
|
||
else:
|
||
logger.error(f"{log_prefix}安装失败: {result.stderr}")
|
||
return False
|
||
|
||
except subprocess.TimeoutExpired:
|
||
logger.error(f"[Plugin:{plugin_name}] 安装 {package} 超时")
|
||
return False
|
||
except Exception as e:
|
||
logger.error(f"[Plugin:{plugin_name}] 安装 {package} 时发生异常: {e}")
|
||
return False
|
||
|
||
|
||
# 全局依赖管理器实例
|
||
_global_dependency_manager: DependencyManager | None = None
|
||
|
||
|
||
def get_dependency_manager() -> DependencyManager:
|
||
"""获取全局依赖管理器实例"""
|
||
global _global_dependency_manager
|
||
if _global_dependency_manager is None:
|
||
_global_dependency_manager = DependencyManager()
|
||
return _global_dependency_manager
|
||
|
||
|
||
def configure_dependency_manager(auto_install: bool = True, use_mirror: bool = False, mirror_url: str | None = None):
|
||
"""配置全局依赖管理器"""
|
||
global _global_dependency_manager
|
||
_global_dependency_manager = DependencyManager(
|
||
auto_install=auto_install, use_mirror=use_mirror, mirror_url=mirror_url
|
||
)
|