MoviePilot/app/adapters/system/plugin/dependency.py

"""插件 requirements 聚合和 Python 依赖安装适配器。"""

from __future__ import annotations

import asyncio
from collections.abc import Callable
from importlib.metadata import distributions
from pathlib import Path
from typing import Any, Optional

from packaging.requirements import Requirement
from packaging.specifiers import InvalidSpecifier, SpecifierSet
from packaging.version import InvalidVersion, Version

from app.runtime.config import settings
from app.runtime.log import logger


class PluginDependencyInstaller:
    """独立负责插件依赖扫描、约束合并和 pip 安装。"""

    def __init__(
        self,
        helper: Any = None,
        *,
        installed_plugins_provider: Optional[Callable[[], list[str]]] = None,
        plugin_dir: Optional[Path] = None,
    ) -> None:
        """保存 pip 端口和启动层提供的已安装插件读取器。"""
        if helper is None:
            from app.adapters.external.market import PluginHelper

            helper = PluginHelper()
        self._helper = helper
        self._installed_plugins_provider = installed_plugins_provider or (lambda: [])
        self._plugin_dir = plugin_dir or (
            Path(settings.ROOT_PATH) / "app" / "plugins"
        )

    @staticmethod
    def _standardize(name: str) -> str:
        """按 PEP 503 兼容规则标准化依赖包名。"""
        return (name or "").lower().replace("-", "_").replace(".", "_")

    @classmethod
    def _installed_packages(cls) -> dict[str, Version]:
        """读取当前 Python 环境中可解析版本的已安装包。"""
        installed: dict[str, Version] = {}
        try:
            for distribution in distributions():
                name = distribution.metadata.get("Name")
                version = distribution.metadata.get("Version") or getattr(
                    distribution,
                    "version",
                    None,
                )
                if not name or not version:
                    continue
                package_name = cls._standardize(name)
                try:
                    parsed = Version(version)
                except InvalidVersion:
                    logger.debug(
                        f"无法解析已安装包 '{package_name}' 的版本：{version}"
                    )
                    continue
                if package_name not in installed or parsed > installed[package_name]:
                    installed[package_name] = parsed
        except Exception as err:
            logger.error(f"获取已安装的包时发生错误：{err}")
        return installed

    @classmethod
    def _parse_requirements(cls, requirements_file: Path) -> dict[str, list[str]]:
        """解析一个 requirements 文件中的包名和版本约束。"""
        dependencies: dict[str, list[str]] = {}
        try:
            for line in requirements_file.read_text(
                encoding="utf-8",
                errors="replace",
            ).splitlines():
                line = line.strip()
                if not line or line.startswith("#"):
                    continue
                try:
                    requirement = Requirement(line)
                except Exception as err:
                    logger.debug(f"无法解析依赖项 '{line}'：{err}")
                    continue
                package_name = cls._standardize(requirement.name)
                dependencies.setdefault(package_name, []).append(
                    str(requirement.specifier)
                )
        except Exception as err:
            logger.error(f"解析 requirements.txt 时发生错误：{err}")
        return dependencies

    @classmethod
    def _merge(cls, dependencies: dict[str, set[str]]) -> dict[str, str]:
        """求同一包多来源约束的交集，保留冲突约束供 pip 处理。"""
        merged: dict[str, str] = {}
        for package_name, specifiers in dependencies.items():
            spec_set = SpecifierSet()
            for specifier in specifiers:
                if not specifier:
                    continue
                try:
                    spec_set &= SpecifierSet(specifier)
                except InvalidSpecifier as err:
                    logger.error(f"发生版本约束冲突：{err}")
            merged[package_name] = str(spec_set) if spec_set else ""
        return merged

    def _plugin_dependencies(self) -> dict[str, str]:
        """扫描已安装插件的 requirements 并合并版本约束。"""
        dependencies: dict[str, set[str]] = {}
        installed_plugins = {
            plugin_id.lower()
            for plugin_id in self._installed_plugins_provider() or []
        }
        try:
            plugin_dirs = list(self._plugin_dir.iterdir())
        except (FileNotFoundError, OSError):
            return {}
        for plugin_dir in plugin_dirs:
            if not plugin_dir.is_dir():
                continue
            requirements_file = plugin_dir / "requirements.txt"
            if not requirements_file.is_file():
                continue
            if plugin_dir.name not in installed_plugins:
                logger.debug(f"忽略插件 {plugin_dir.name} 的依赖")
                continue
            for package_name, specifiers in self._parse_requirements(
                requirements_file
            ).items():
                dependencies.setdefault(package_name, set()).update(specifiers)
        return self._merge(dependencies)

    def find_missing(self) -> list[str]:
        """返回当前插件集合缺失或不满足约束的依赖项。"""
        try:
            required = self._plugin_dependencies()
            installed = self._installed_packages()
            missing = []
            for package_name, specifier in required.items():
                installed_version = installed.get(package_name)
                try:
                    satisfied = installed_version is not None and SpecifierSet(
                        specifier
                    ).contains(installed_version, prereleases=True)
                except InvalidSpecifier as err:
                    logger.error(f"依赖 {package_name} 约束无效：{err}")
                    satisfied = False
                if not satisfied:
                    missing.append(f"{package_name}{specifier}")
            return missing
        except Exception as err:
            logger.error(f"收集所有需要安装或更新的依赖项时发生错误：{err}")
            return []

    def _wheels_dirs(self) -> list[Path]:
        """收集已安装插件附带的本地 wheels 目录。"""
        result = []
        installed_plugins = {
            plugin_id.lower()
            for plugin_id in self._installed_plugins_provider() or []
        }
        for plugin_id in installed_plugins:
            wheels_dir = self._plugin_dir / plugin_id / "wheels"
            if wheels_dir.is_dir():
                result.append(wheels_dir)
        return list(dict.fromkeys(result))

    def install(self, dependencies: list[str]) -> tuple[bool, str]:
        """把依赖写入临时 requirements 并调用现有 pip 健康检查策略。"""
        if not dependencies:
            return False, "没有传入需要安装的依赖项"
        requirements_file = (
            Path(settings.TEMP_PATH)
            / "plugin_dependencies"
            / "requirements.txt"
        )
        try:
            requirements_file.parent.mkdir(parents=True, exist_ok=True)
            requirements_file.write_text(
                "".join(f"{dependency}\n" for dependency in dependencies),
                encoding="utf-8",
            )
            return self._helper.pip_install_with_fallback(
                requirements_file,
                self._wheels_dirs(),
            )
        except Exception as err:
            logger.error(f"安装依赖项时发生错误：{err}")
            return False, f"安装依赖项时发生错误：{err}"
        finally:
            requirements_file.unlink(missing_ok=True)

    async def async_find_missing(self) -> list[str]:
        """在线程池中扫描缺失依赖，避免阻塞事件循环。"""
        return await asyncio.to_thread(self.find_missing)

    async def async_install(self, dependencies: list[str]) -> tuple[bool, str]:
        """在线程池中安装依赖，复用同步 pip 健康检查策略。"""
        return await asyncio.to_thread(self.install, dependencies)