更新 transhandler.py

- 改为惰性初始化，启动时不再执行 `auth` ，调用方法时，再进行 `auth` （保留 auth_token 过期检查重新 `auth` 的功能）；
- 使用 双重检查锁定 的方式，保证线程安全；
- 统一通过一个 `timeout` 值进行设置，默认值从30秒降为15秒，保持与tmdb相同。

.github/workflows/build.yml

@@ -46,7 +46,7 @@ jobs:
         uses: docker/build-push-action@v5
         with:
           context: .
-          file: Dockerfile
+          file: docker/Dockerfile
           platforms: |
             linux/amd64
             linux/arm64/v8
@@ -56,10 +56,22 @@ jobs:
           cache-from: type=gha, scope=${{ github.workflow }}-docker
           cache-to: type=gha, scope=${{ github.workflow }}-docker
 
+      - name: Get existing release body
+        id: get_release_body
+        continue-on-error: true
+        run: |
+          release_body=$(curl -s -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" \
+            "https://api.github.com/repos/${{ github.repository }}/releases/tags/v${{ env.app_version }}" | \
+            jq -r '.body // ""')
+          echo "RELEASE_BODY<<EOF" >> $GITHUB_ENV
+          echo "$release_body" >> $GITHUB_ENV
+          echo "EOF" >> $GITHUB_ENV
+
       - name: Delete Release
         uses: dev-drprasad/delete-tag-and-release@v1.1
+        continue-on-error: true
         with:
-          tag_name: ${{ env.app_version }}
+          tag_name: v${{ env.app_version }}
           delete_release: true
           github_token: ${{ secrets.GITHUB_TOKEN }}
 
@@ -68,6 +80,7 @@ jobs:
         with:
           tag_name: v${{ env.app_version }}
           name: v${{ env.app_version }}
+          body: ${{ env.RELEASE_BODY }}
           draft: false
           prerelease: false
           make_latest: false

.github/workflows/bulit-lite.yml

@@ -1,55 +0,0 @@
-name: MoviePilot Builder v2 Lite
-on:
-  workflow_dispatch:
-  push:
-    branches:
-      - v2
-    paths:
-      - 'version.py'
-
-jobs:
-  Docker-build:
-    runs-on: ubuntu-latest
-    name: Build Docker Image
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Release version
-        id: release_version
-        run: |
-          app_version=$(cat version.py |sed -ne "s/APP_VERSION\s=\s'v\(.*\)'/\1/gp")
-          echo "app_version=$app_version" >> $GITHUB_ENV
-
-      - name: Docker Meta
-        id: meta
-        uses: docker/metadata-action@v5
-        with:
-          images: ${{ secrets.DOCKER_USERNAME }}/moviepilot-v2
-          tags: |
-            type=raw,value=lite-latest
-
-      - name: Set Up QEMU
-        uses: docker/setup-qemu-action@v3
-
-      - name: Set Up Buildx
-        uses: docker/setup-buildx-action@v3
-
-      - name: Login DockerHub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ secrets.DOCKER_USERNAME }}
-          password: ${{ secrets.DOCKER_PASSWORD }}
-
-      - name: Build Image
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          file: Dockerfile.lite
-          platforms: |
-            linux/amd64
-          push: true
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
-          cache-from: type=gha, scope=${{ github.workflow }}-docker
-          cache-to: type=gha, scope=${{ github.workflow }}-docker

Dockerfile.lite

@@ -1,93 +0,0 @@
-FROM python:3.11.4-slim-bookworm
-ENV LANG="C.UTF-8" \
-    TZ="Asia/Shanghai" \
-    HOME="/moviepilot" \
-    CONFIG_DIR="/config" \
-    TERM="xterm" \
-    DISPLAY=:987 \
-    PUID=0 \
-    PGID=0 \
-    UMASK=000 \
-    PORT=3001 \
-    NGINX_PORT=3000 \
-    MOVIEPILOT_AUTO_UPDATE=release
-WORKDIR "/app"
-RUN apt-get update -y \
-    && apt-get upgrade -y \
-    && apt-get -y install \
-        musl-dev \
-        nginx \
-        gettext-base \
-        locales \
-        procps \
-        gosu \
-        bash \
-        wget \
-        curl \
-        busybox \
-        dumb-init \
-        jq \
-        fuse3 \
-        rsync \
-        ffmpeg \
-        nano \
-    && \
-    if [ "$(uname -m)" = "x86_64" ]; \
-        then ln -s /usr/lib/x86_64-linux-musl/libc.so /lib/libc.musl-x86_64.so.1; \
-    elif [ "$(uname -m)" = "aarch64" ]; \
-        then ln -s /usr/lib/aarch64-linux-musl/libc.so /lib/libc.musl-aarch64.so.1; \
-    fi \
-    && curl https://rclone.org/install.sh | bash \
-    && curl --insecure -fsSL https://raw.githubusercontent.com/DDS-Derek/Aria2-Pro-Core/master/aria2-install.sh | bash \
-    && apt-get autoremove -y \
-    && apt-get clean -y \
-    && rm -rf \
-        /tmp/* \
-        /moviepilot/.cache \
-        /var/lib/apt/lists/* \
-        /var/tmp/*
-COPY requirements.in requirements.in
-RUN apt-get update -y \
-    && apt-get install -y build-essential \
-    && pip install --upgrade pip \
-    && pip install Cython pip-tools \
-    && pip-compile requirements.in \
-    && pip install -r requirements.txt \
-    && playwright install-deps chromium \
-    && apt-get remove -y build-essential \
-    && apt-get autoremove -y \
-    && apt-get clean -y \
-    && rm -rf \
-        /tmp/* \
-        /moviepilot/.cache \
-        /var/lib/apt/lists/* \
-        /var/tmp/*
-COPY . .
-RUN cp -f /app/nginx.conf /etc/nginx/nginx.template.conf \
-    && cp -f /app/update /usr/local/bin/mp_update \
-    && cp -f /app/entrypoint /entrypoint \
-    && cp -f /app/docker_http_proxy.conf /etc/nginx/docker_http_proxy.conf \
-    && chmod +x /entrypoint /usr/local/bin/mp_update \
-    && mkdir -p ${HOME} \
-    && groupadd -r moviepilot -g 918 \
-    && useradd -r moviepilot -g moviepilot -d ${HOME} -s /bin/bash -u 918 \
-    && python_ver=$(python3 -V | awk '{print $2}') \
-    && echo "/app/" > /usr/local/lib/python${python_ver%.*}/site-packages/app.pth \
-    && echo 'fs.inotify.max_user_watches=5242880' >> /etc/sysctl.conf \
-    && echo 'fs.inotify.max_user_instances=5242880' >> /etc/sysctl.conf \
-    && locale-gen zh_CN.UTF-8 \
-    && python3 /app/setup.py \
-    && find /app/app -type f -name "*.py" ! -path "/app/app/main.py" -exec rm -f {} \; \
-    && FRONTEND_VERSION=$(sed -n "s/^FRONTEND_VERSION\s*=\s*'\([^']*\)'/\1/p" /app/version.py) \
-    && curl -sL "https://github.com/jxxghp/MoviePilot-Frontend/releases/download/${FRONTEND_VERSION}/dist.zip" | busybox unzip -d / - \
-    && mv /dist /public \
-    && curl -sL "https://github.com/jxxghp/MoviePilot-Plugins/archive/refs/heads/main.zip" | busybox unzip -d /tmp - \
-    && mv -f /tmp/MoviePilot-Plugins-main/plugins.v2/* /app/app/plugins/ \
-    && cat /tmp/MoviePilot-Plugins-main/package.json | jq -r 'to_entries[] | select(.value.v2 == true) | .key' | awk '{print tolower($0)}' | \
-        while read -r i; do if [ ! -d "/app/app/plugins/$i" ]; then mv "/tmp/MoviePilot-Plugins-main/plugins/$i" "/app/app/plugins/"; else echo "跳过 $i"; fi; done \
-    && curl -sL "https://github.com/jxxghp/MoviePilot-Resources/archive/refs/heads/main.zip" | busybox unzip -d /tmp - \
-    && mv -f /tmp/MoviePilot-Resources-main/resources/* /app/app/helper/ \
-    && rm -rf /tmp/* /app/build
-EXPOSE 3000
-VOLUME [ "/config" ]
-ENTRYPOINT [ "/entrypoint" ]

README.md

@@ -28,7 +28,7 @@
 
 ## 参与开发
 
-需要 `Python 3.11`、`Node JS v20.12.1`
+需要 `Python 3.12`、`Node JS v20.12.1`
 
 - 克隆主项目 [MoviePilot](https://github.com/jxxghp/MoviePilot) 
 ```shell

app/actions/fetch_medias.py

@@ -40,54 +40,67 @@ class FetchMediasAction(BaseAction):
             {
                 "func": RecommendChain().tmdb_trending,
                 "name": '流行趋势',
+                "api_path": "recommend/tmdb_trending"
             },
             {
                 "func": RecommendChain().douban_movie_showing,
                 "name": '正在热映',
+                "api_path": "recommend/douban_showing"
             },
             {
                 "func": RecommendChain().bangumi_calendar,
                 "name": 'Bangumi每日放送',
+                "api_path": "recommend/bangumi_calendar"
             },
             {
                 "func": RecommendChain().tmdb_movies,
                 "name": 'TMDB热门电影',
+                "api_path": "recommend/tmdb_movies"
             },
             {
                 "func": RecommendChain().tmdb_tvs,
                 "name": 'TMDB热门电视剧',
+                "api_path": "recommend/tmdb_tvs?with_original_language=zh|en|ja|ko"
             },
             {
                 "func": RecommendChain().douban_movie_hot,
                 "name": '豆瓣热门电影',
+                "api_path": "recommend/douban_movie_hot"
             },
             {
                 "func": RecommendChain().douban_tv_hot,
                 "name": '豆瓣热门电视剧',
+                "api_path": "recommend/douban_tv_hot"
             },
             {
                 "func": RecommendChain().douban_tv_animation,
                 "name": '豆瓣热门动漫',
+                "api_path": "recommend/douban_tv_animation"
             },
             {
                 "func": RecommendChain().douban_movies,
                 "name": '豆瓣最新电影',
+                "api_path": "recommend/douban_movies"
             },
             {
                 "func": RecommendChain().douban_tvs,
                 "name": '豆瓣最新电视剧',
+                "api_path": "recommend/douban_tvs"
             },
             {
                 "func": RecommendChain().douban_movie_top250,
                 "name": '豆瓣电影TOP250',
+                "api_path": "recommend/douban_movie_top250"
             },
             {
                 "func": RecommendChain().douban_tv_weekly_chinese,
                 "name": '豆瓣国产剧集榜',
+                "api_path": "recommend/douban_tv_weekly_chinese"
             },
             {
                 "func": RecommendChain().douban_tv_weekly_global,
                 "name": '豆瓣全球剧集榜',
+                "api_path": "recommend/douban_tv_weekly_global"
             }
         ]
 
@@ -124,7 +137,7 @@ class FetchMediasAction(BaseAction):
         获取数据源
         """
         for s in self.__inner_sources:
-            if s['name'] == source:
+            if s['api_path'] == source:
                 return s
         return None
 
@@ -135,13 +148,14 @@ class FetchMediasAction(BaseAction):
         params = FetchMediasParams(**params)
         try:
             if params.source_type == "ranking":
-                for name in params.sources:
+                for api_path in params.sources:
                     if global_vars.is_workflow_stopped(workflow_id):
                         break
-                    source = self.__get_source(name)
+                    source = self.__get_source(api_path)
                     if not source:
                         continue
                     logger.info(f"获取媒体数据 {source} ...")
+                    name = source.get("name")
                     results = []
                     if source.get("func"):
                         results = source['func']()

app/actions/fetch_torrents.py

@@ -62,7 +62,7 @@ class FetchTorrentsAction(BaseAction):
         params = FetchTorrentsParams(**params)
         if params.search_type == "keyword":
             # 按关键字搜索
-            torrents = self.searchchain.search_by_title(title=params.name, sites=params.sites, cache_local=False)
+            torrents = self.searchchain.search_by_title(title=params.name, sites=params.sites)
             for torrent in torrents:
                 if global_vars.is_workflow_stopped(workflow_id):
                     break

app/actions/invoke_plugin.py

@@ -0,0 +1,72 @@
+from pydantic import Field
+
+from app.actions import BaseAction
+from app.core.plugin import PluginManager
+from app.log import logger
+from app.schemas import ActionParams, ActionContext
+
+
+class InvokePluginParams(ActionParams):
+    """
+    调用插件动作参数
+    """
+    plugin_id: str = Field(default=None, description="插件ID")
+    action_id: str = Field(default=None, description="动作ID")
+    action_params: dict = Field(default={}, description="动作参数")
+
+
+class InvokePluginAction(BaseAction):
+    """
+    调用插件
+    """
+
+    _success = False
+
+    def __init__(self, action_id: str):
+        super().__init__(action_id)
+        self._success = False
+
+    @classmethod
+    @property
+    def name(cls) -> str: # noqa
+        return "调用插件"
+
+    @classmethod
+    @property
+    def description(cls) -> str: # noqa
+        return "调用插件提供的动作"
+
+    @classmethod
+    @property
+    def data(cls) -> dict: # noqa
+        return InvokePluginParams().dict()
+
+    @property
+    def success(self) -> bool:
+        return self._success
+
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
+        """
+        执行插件定义的动作
+        """
+        params = InvokePluginParams(**params)
+        if not params.plugin_id or not params.action_id:
+            return context
+        try:
+            plugin_actions = PluginManager().get_plugin_actions(params.plugin_id)
+            if not plugin_actions:
+                logger.error(f"插件不存在: {params.plugin_id}")
+                return context
+            actions = plugin_actions[0].get("actions", [])
+            action = next((action for action in actions if action.action_id == params.action_id), None)
+            if not action or not action.get("func"):
+                logger.error(f"插件动作不存在: {params.plugin_id} - {params.action_id}")
+                return context
+            # 执行插件动作
+            self._success, context = action["func"](context, **params.action_params)
+        except Exception as e:
+            self._success = False
+            logger.error(f"调用插件动作失败: {e}")
+            return context
+        self.job_done()
+        return context

app/api/apiv1.py

@@ -2,7 +2,7 @@ from fastapi import APIRouter
 
 from app.api.endpoints import login, user, site, message, webhook, subscribe, \
     media, douban, search, plugin, tmdb, history, system, download, dashboard, \
-    transfer, mediaserver, bangumi, storage, discover, recommend, workflow
+    transfer, mediaserver, bangumi, storage, discover, recommend, workflow, torrent
 
 api_router = APIRouter()
 api_router.include_router(login.router, prefix="/login", tags=["login"])
@@ -27,3 +27,4 @@ api_router.include_router(bangumi.router, prefix="/bangumi", tags=["bangumi"])
 api_router.include_router(discover.router, prefix="/discover", tags=["discover"])
 api_router.include_router(recommend.router, prefix="/recommend", tags=["recommend"])
 api_router.include_router(workflow.router, prefix="/workflow", tags=["workflow"])
+api_router.include_router(torrent.router, prefix="/torrent", tags=["torrent"])

app/api/endpoints/login.py

@@ -11,7 +11,7 @@ from app.chain.mediaserver import MediaServerChain
 from app.core import security
 from app.core.config import settings
 from app.helper.sites import SitesHelper
-from app.utils.web import WebUtils
+from app.helper.wallpaper import WallpaperHelper
 
 router = APIRouter()
 
@@ -55,9 +55,11 @@ def wallpaper() -> Any:
     获取登录页面电影海报
     """
     if settings.WALLPAPER == "bing":
-        url = WebUtils.get_bing_wallpaper()
+        url = WallpaperHelper().get_bing_wallpaper()
     elif settings.WALLPAPER == "mediaserver":
         url = MediaServerChain().get_latest_wallpaper()
+    elif settings.WALLPAPER == "customize":
+        url = WallpaperHelper().get_customize_wallpaper()
     else:
         url = TmdbChain().get_random_wallpager()
     if url:
@@ -74,8 +76,12 @@ def wallpapers() -> Any:
     获取登录页面电影海报
     """
     if settings.WALLPAPER == "bing":
-        return WebUtils.get_bing_wallpapers()
+        return WallpaperHelper().get_bing_wallpapers()
     elif settings.WALLPAPER == "mediaserver":
         return MediaServerChain().get_latest_wallpapers()
-    else:
+    elif settings.WALLPAPER == "tmdb":
         return TmdbChain().get_trending_wallpapers()
+    elif settings.WALLPAPER == "customize":
+        return WallpaperHelper().get_customize_wallpapers()
+    else:
+        return []

app/api/endpoints/media.py

@@ -149,11 +149,12 @@ def seasons(tmdbid: int, _: schemas.TokenPayload = Depends(verify_token)) -> Any
     """
     查询媒体剧集组列表（themoviedb）
     """
-    mediainfo  = MediaChain().recognize_media(tmdbid=tmdbid, mtype=MediaType.TV)
+    mediainfo = MediaChain().recognize_media(tmdbid=tmdbid, mtype=MediaType.TV)
     if not mediainfo:
         return []
     return mediainfo.episode_groups
 
+
 @router.get("/seasons", summary="查询媒体季信息", response_model=List[schemas.MediaSeason])
 def seasons(mediaid: Optional[str] = None,
             title: Optional[str] = None,
@@ -198,7 +199,7 @@ def seasons(mediaid: Optional[str] = None,
 
 
 @router.get("/{mediaid}", summary="查询媒体详情", response_model=schemas.MediaInfo)
-def detail(mediaid: str, type_name: str, title: Optional[str] = None, year: int = None,
+def detail(mediaid: str, type_name: str, title: Optional[str] = None, year: str = None,
            _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据媒体ID查询themoviedb或豆瓣媒体信息，type_name: 电影/电视剧
@@ -219,14 +220,13 @@ def detail(mediaid: str, type_name: str, title: Optional[str] = None, year: int
         )
         event = eventmanager.send_event(ChainEventType.MediaRecognizeConvert, event_data)
         # 使用事件返回的上下文数据
-        if event and event.event_data:
+        if event and event.event_data and event.event_data.media_dict:
             event_data: MediaRecognizeConvertEventData = event.event_data
-            if event_data.media_dict:
-                new_id = event_data.media_dict.get("id")
-                if event_data.convert_type == "themoviedb":
-                    mediainfo = MediaChain().recognize_media(tmdbid=new_id, mtype=mtype)
-                elif event_data.convert_type == "douban":
-                    mediainfo = MediaChain().recognize_media(doubanid=new_id, mtype=mtype)
+            new_id = event_data.media_dict.get("id")
+            if event_data.convert_type == "themoviedb":
+                mediainfo = MediaChain().recognize_media(tmdbid=new_id, mtype=mtype)
+            elif event_data.convert_type == "douban":
+                mediainfo = MediaChain().recognize_media(doubanid=new_id, mtype=mtype)
         elif title:
             # 使用名称识别兜底
             meta = MetaInfo(title)

app/api/endpoints/mediaserver.py

@@ -121,7 +121,7 @@ def not_exists(media_in: schemas.MediaInfo,
 
 
 @router.get("/latest", summary="最新入库条目", response_model=List[schemas.MediaServerPlayItem])
-def latest(server: str, count: Optional[int] = 18,
+def latest(server: str, count: Optional[int] = 20,
            userinfo: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     获取媒体服务器最新入库条目

app/api/endpoints/plugin.py

@@ -1,6 +1,10 @@
+import mimetypes
+import shutil
 from typing import Annotated, Any, List, Optional
 
-from fastapi import APIRouter, Depends, Header
+from fastapi import APIRouter, Depends, Header, HTTPException
+from starlette import status
+from starlette.responses import FileResponse
 
 from app import schemas
 from app.command import Command
@@ -16,7 +20,6 @@ from app.scheduler import Scheduler
 from app.schemas.types import SystemConfigKey
 
 PROTECTED_ROUTES = {"/api/v1/openapi.json", "/docs", "/docs/oauth2-redirect", "/redoc"}
-
 PLUGIN_PREFIX = f"{settings.API_V1_STR}/plugin"
 
 router = APIRouter()
@@ -66,9 +69,13 @@ def _update_plugin_api_routes(plugin_id: Optional[str], action: str):
             try:
                 api["path"] = api_path
                 allow_anonymous = api.pop("allow_anonymous", False)
+                auth_mode = api.pop("auth", "apikey")
                 dependencies = api.setdefault("dependencies", [])
-                if not allow_anonymous and Depends(verify_apikey) not in dependencies:
-                    dependencies.append(Depends(verify_apikey))
+                if not allow_anonymous:
+                    if auth_mode == "bear" and Depends(verify_token) not in dependencies:
+                        dependencies.append(Depends(verify_token))
+                    elif Depends(verify_apikey) not in dependencies:
+                        dependencies.append(Depends(verify_apikey))
                 app.add_api_route(**api, tags=["plugin"])
                 is_modified = True
                 logger.debug(f"Added plugin route: {api_path}")
@@ -116,6 +123,18 @@ def _clean_protected_routes(existing_paths: dict):
             logger.error(f"Error removing protected route {protected_route}: {str(e)}")
 
 
+def register_plugin(plugin_id: str):
+    """
+    注册一个插件相关的服务
+    """
+    # 注册插件服务
+    Scheduler().update_plugin_job(plugin_id)
+    # 注册菜单命令
+    Command().init_commands(plugin_id)
+    # 注册插件API
+    register_plugin_api(plugin_id)
+
+
 @router.get("/", summary="所有插件", response_model=List[schemas.Plugin])
 def all_plugins(_: schemas.TokenPayload = Depends(get_current_active_superuser),
                 state: Optional[str] = "all") -> List[schemas.Plugin]:
@@ -126,11 +145,11 @@ def all_plugins(_: schemas.TokenPayload = Depends(get_current_active_superuser),
     local_plugins = PluginManager().get_local_plugins()
     # 已安装插件
     installed_plugins = [plugin for plugin in local_plugins if plugin.installed]
-    # 未安装的本地插件
-    not_installed_plugins = [plugin for plugin in local_plugins if not plugin.installed]
     if state == "installed":
         return installed_plugins
-
+        
+    # 未安装的本地插件
+    not_installed_plugins = [plugin for plugin in local_plugins if not plugin.installed]
     # 在线插件
     online_plugins = PluginManager().get_online_plugins()
     if not online_plugins:
@@ -159,6 +178,7 @@ def all_plugins(_: schemas.TokenPayload = Depends(get_current_active_superuser),
     if state == "market":
         # 返回未安装的插件
         return market_plugins
+        
     # 返回所有插件
     return installed_plugins + market_plugins
 
@@ -179,6 +199,18 @@ def statistic(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
     return PluginHelper().get_statistic()
 
 
+@router.get("/reload/{plugin_id}", summary="重新加载插件", response_model=schemas.Response)
+def reload_plugin(plugin_id: str, _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
+    """
+    重新加载插件
+    """
+    # 重新加载插件
+    PluginManager().reload_plugin(plugin_id)
+    # 注册插件服务
+    register_plugin(plugin_id)
+    return schemas.Response(success=True)
+
+
 @router.get("/install/{plugin_id}", summary="安装插件", response_model=schemas.Response)
 def install(plugin_id: str,
             repo_url: Optional[str] = "",
@@ -207,36 +239,65 @@ def install(plugin_id: str,
         install_plugins.append(plugin_id)
         # 保存设置
         SystemConfigOper().set(SystemConfigKey.UserInstalledPlugins, install_plugins)
-    # 加载插件到内存
-    PluginManager().reload_plugin(plugin_id)
-    # 注册插件服务
-    Scheduler().update_plugin_job(plugin_id)
-    # 注册菜单命令
-    Command().init_commands(plugin_id)
-    # 注册插件API
-    register_plugin_api(plugin_id)
+    # 重新加载插件
+    reload_plugin(plugin_id)
     return schemas.Response(success=True)
 
 
+@router.get("/remotes", summary="获取插件联邦组件列表", response_model=List[dict])
+def remotes(token: str) -> Any:
+    """
+    获取插件联邦组件列表
+    """
+    if token != "moviepilot":
+        raise HTTPException(status_code=403, detail="Forbidden")
+    return PluginManager().get_plugin_remotes()
+
+
 @router.get("/form/{plugin_id}", summary="获取插件表单页面")
 def plugin_form(plugin_id: str,
                 _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> dict:
     """
-    根据插件ID获取插件配置表单
+    根据插件ID获取插件配置表单或Vue组件URL
     """
-    conf, model = PluginManager().get_plugin_form(plugin_id)
-    return {
-        "conf": conf,
-        "model": model
-    }
+    plugin_instance = PluginManager().running_plugins.get(plugin_id)
+    if not plugin_instance:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"插件 {plugin_id} 不存在或未加载")
+
+    # 渲染模式
+    render_mode, _ = plugin_instance.get_render_mode()
+    try:
+        conf, model = plugin_instance.get_form()
+        return {
+            "render_mode": render_mode,
+            "conf": conf,
+            "model": PluginManager().get_plugin_config(plugin_id) or model
+        }
+    except Exception as e:
+        logger.error(f"插件 {plugin_id} 调用方法 get_form 出错: {str(e)}")
+    return {}
 
 
 @router.get("/page/{plugin_id}", summary="获取插件数据页面")
-def plugin_page(plugin_id: str, _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> List[dict]:
+def plugin_page(plugin_id: str, _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> dict:
     """
     根据插件ID获取插件数据页面
     """
-    return PluginManager().get_plugin_page(plugin_id)
+    plugin_instance = PluginManager().running_plugins.get(plugin_id)
+    if not plugin_instance:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"插件 {plugin_id} 不存在或未加载")
+
+    # 渲染模式
+    render_mode, _ = plugin_instance.get_render_mode()
+    try:
+        page = plugin_instance.get_page()
+        return {
+            "render_mode": render_mode,
+            "page": page or []
+        }
+    except Exception as e:
+        logger.error(f"插件 {plugin_id} 调用方法 get_page 出错: {str(e)}")
+    return {}
 
 
 @router.get("/dashboard/meta", summary="获取所有插件仪表板元信息")
@@ -247,22 +308,22 @@ def plugin_dashboard_meta(_: schemas.TokenPayload = Depends(verify_token)) -> Li
     return PluginManager().get_plugin_dashboard_meta()
 
 
+@router.get("/dashboard/{plugin_id}/{key}", summary="获取插件仪表板配置")
+def plugin_dashboard_by_key(plugin_id: str, key: str, user_agent: Annotated[str | None, Header()] = None,
+                            _: schemas.TokenPayload = Depends(verify_token)) -> Optional[schemas.PluginDashboard]:
+    """
+    根据插件ID获取插件仪表板
+    """
+    return PluginManager().get_plugin_dashboard(plugin_id, key, user_agent)
+
+
 @router.get("/dashboard/{plugin_id}", summary="获取插件仪表板配置")
 def plugin_dashboard(plugin_id: str, user_agent: Annotated[str | None, Header()] = None,
                      _: schemas.TokenPayload = Depends(verify_token)) -> schemas.PluginDashboard:
     """
     根据插件ID获取插件仪表板
     """
-    return PluginManager().get_plugin_dashboard(plugin_id, user_agent=user_agent)
-
-
-@router.get("/dashboard/{plugin_id}/{key}", summary="获取插件仪表板配置")
-def plugin_dashboard(plugin_id: str, key: str, user_agent: Annotated[str | None, Header()] = None,
-                     _: schemas.TokenPayload = Depends(verify_token)) -> schemas.PluginDashboard:
-    """
-    根据插件ID获取插件仪表板
-    """
-    return PluginManager().get_plugin_dashboard(plugin_id, key=key, user_agent=user_agent)
+    return plugin_dashboard_by_key(plugin_id, "", user_agent)
 
 
 @router.get("/reset/{plugin_id}", summary="重置插件配置及数据", response_model=schemas.Response)
@@ -271,21 +332,116 @@ def reset_plugin(plugin_id: str,
     """
     根据插件ID重置插件配置及数据
     """
+    plugin_manager = PluginManager()
     # 删除配置
-    PluginManager().delete_plugin_config(plugin_id)
+    plugin_manager.delete_plugin_config(plugin_id)
     # 删除插件所有数据
-    PluginManager().delete_plugin_data(plugin_id)
-    # 重新生效插件
-    PluginManager().reload_plugin(plugin_id)
-    # 注册插件服务
-    Scheduler().update_plugin_job(plugin_id)
-    # 注册菜单命令
-    Command().init_commands(plugin_id)
-    # 注册插件API
-    register_plugin_api(plugin_id)
+    plugin_manager.delete_plugin_data(plugin_id)
+    # 重新加载插件
+    reload_plugin(plugin_id)
     return schemas.Response(success=True)
 
 
+@router.get("/file/{plugin_id}/{filepath:path}", summary="获取插件静态文件")
+def plugin_static_file(plugin_id: str, filepath: str):
+    """
+    获取插件静态文件
+    """
+    # 基础安全检查
+    if ".." in filepath or ".." in filepath:
+        logger.warning(f"Static File API: Path traversal attempt detected: {plugin_id}/{filepath}")
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Forbidden")
+
+    plugin_base_dir = settings.ROOT_PATH / "app" / "plugins" / plugin_id.lower()
+    plugin_file_path = plugin_base_dir / filepath
+    if not plugin_file_path.exists():
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"{plugin_file_path} 不存在")
+    if not plugin_file_path.is_file():
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=f"{plugin_file_path} 不是文件")
+
+    # 判断 MIME 类型
+    response_type, _ = mimetypes.guess_type(str(plugin_file_path))
+    suffix = plugin_file_path.suffix.lower()
+    # 强制修正 .mjs 和 .js 的 MIME 类型
+    if suffix in ['.js', '.mjs']:
+        response_type = 'application/javascript'
+    elif suffix == '.css' and not response_type:  # 如果 guess_type 没猜对 css，也修正
+        response_type = 'text/css'
+    elif not response_type:  # 对于其他猜不出的类型
+        response_type = 'application/octet-stream'
+
+    try:
+        return FileResponse(plugin_file_path, media_type=response_type)
+    except Exception as e:
+        logger.error(f"Error creating/sending FileResponse for {plugin_file_path}: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail="Internal Server Error")
+
+
+@router.get("/folders", summary="获取插件文件夹配置", response_model=dict)
+def get_plugin_folders(_: schemas.TokenPayload = Depends(get_current_active_superuser)) -> dict:
+    """
+    获取插件文件夹分组配置
+    """
+    try:
+        result = SystemConfigOper().get(SystemConfigKey.PluginFolders) or {}
+        return result
+    except Exception as e:
+        logger.error(f"[文件夹API] 获取文件夹配置失败: {str(e)}")
+        return {}
+
+
+@router.post("/folders", summary="保存插件文件夹配置", response_model=schemas.Response)
+def save_plugin_folders(folders: dict, _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
+    """
+    保存插件文件夹分组配置
+    """
+    try:
+        SystemConfigOper().set(SystemConfigKey.PluginFolders, folders)
+        return schemas.Response(success=True)
+    except Exception as e:
+        logger.error(f"[文件夹API] 保存文件夹配置失败: {str(e)}")
+        return schemas.Response(success=False, message=str(e))
+
+
+@router.post("/folders/{folder_name}", summary="创建插件文件夹", response_model=schemas.Response)
+def create_plugin_folder(folder_name: str, _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
+    """
+    创建新的插件文件夹
+    """
+    folders = SystemConfigOper().get(SystemConfigKey.PluginFolders) or {}
+    if folder_name not in folders:
+        folders[folder_name] = []
+        SystemConfigOper().set(SystemConfigKey.PluginFolders, folders)
+        return schemas.Response(success=True, message=f"文件夹 '{folder_name}' 创建成功")
+    else:
+        return schemas.Response(success=False, message=f"文件夹 '{folder_name}' 已存在")
+
+
+@router.delete("/folders/{folder_name}", summary="删除插件文件夹", response_model=schemas.Response)
+def delete_plugin_folder(folder_name: str, _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
+    """
+    删除插件文件夹
+    """
+    folders = SystemConfigOper().get(SystemConfigKey.PluginFolders) or {}
+    if folder_name in folders:
+        del folders[folder_name]
+        SystemConfigOper().set(SystemConfigKey.PluginFolders, folders)
+        return schemas.Response(success=True, message=f"文件夹 '{folder_name}' 删除成功")
+    else:
+        return schemas.Response(success=False, message=f"文件夹 '{folder_name}' 不存在")
+
+
+@router.put("/folders/{folder_name}/plugins", summary="更新文件夹中的插件", response_model=schemas.Response)
+def update_folder_plugins(folder_name: str, plugin_ids: List[str], _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
+    """
+    更新指定文件夹中的插件列表
+    """
+    folders = SystemConfigOper().get(SystemConfigKey.PluginFolders) or {}
+    folders[folder_name] = plugin_ids
+    SystemConfigOper().set(SystemConfigKey.PluginFolders, folders)
+    return schemas.Response(success=True, message=f"文件夹 '{folder_name}' 中的插件已更新")
+
+
 @router.get("/{plugin_id}", summary="获取插件配置")
 def plugin_config(plugin_id: str,
                   _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> dict:
@@ -301,16 +457,13 @@ def set_plugin_config(plugin_id: str, conf: dict,
     """
     更新插件配置
     """
+    plugin_manager = PluginManager()
     # 保存配置
-    PluginManager().save_plugin_config(plugin_id, conf)
+    plugin_manager.save_plugin_config(plugin_id, conf)
     # 重新生效插件
-    PluginManager().init_plugin(plugin_id, conf)
+    plugin_manager.init_plugin(plugin_id, conf)
     # 注册插件服务
-    Scheduler().update_plugin_job(plugin_id)
-    # 注册菜单命令
-    Command().init_commands(plugin_id)
-    # 注册插件API
-    register_plugin_api(plugin_id)
+    register_plugin(plugin_id)
     return schemas.Response(success=True)
 
 
@@ -320,22 +473,153 @@ def uninstall_plugin(plugin_id: str,
     """
     卸载插件
     """
+    config_oper = SystemConfigOper()
     # 删除已安装信息
-    install_plugins = SystemConfigOper().get(SystemConfigKey.UserInstalledPlugins) or []
+    install_plugins = config_oper.get(SystemConfigKey.UserInstalledPlugins) or []
     for plugin in install_plugins:
         if plugin == plugin_id:
             install_plugins.remove(plugin)
             break
-    # 保存
-    SystemConfigOper().set(SystemConfigKey.UserInstalledPlugins, install_plugins)
+    config_oper.set(SystemConfigKey.UserInstalledPlugins, install_plugins)
     # 移除插件API
     remove_plugin_api(plugin_id)
     # 移除插件服务
     Scheduler().remove_plugin_job(plugin_id)
+    # 判断是否为分身
+    plugin_manager = PluginManager()
+    plugin_class = plugin_manager.plugins.get(plugin_id)
+    if getattr(plugin_class, "is_clone", False):
+        # 如果是分身插件，则删除分身数据和配置
+        plugin_manager.delete_plugin_config(plugin_id)
+        plugin_manager.delete_plugin_data(plugin_id)
+        # 删除分身文件
+        plugin_base_dir = settings.ROOT_PATH / "app" / "plugins" / plugin_id.lower()
+        if plugin_base_dir.exists():
+            try:
+                shutil.rmtree(plugin_base_dir)
+                plugin_manager.plugins.pop(plugin_id, None)
+            except Exception as e:
+                logger.error(f"删除插件分身目录 {plugin_base_dir} 失败: {str(e)}")
+    # 从插件文件夹中移除该插件
+    _remove_plugin_from_folders(plugin_id)
     # 移除插件
-    PluginManager().remove_plugin(plugin_id)
+    plugin_manager.remove_plugin(plugin_id)
     return schemas.Response(success=True)
 
 
-# 注册全部插件API
-register_plugin_api()
+@router.post("/clone/{plugin_id}", summary="创建插件分身", response_model=schemas.Response)
+def clone_plugin(plugin_id: str,
+                 clone_data: dict,
+                 _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
+    """
+    创建插件分身
+    """
+    try:
+        success, message = PluginManager().clone_plugin(
+            plugin_id=plugin_id,
+            suffix=clone_data.get("suffix", ""),
+            name=clone_data.get("name", ""),
+            description=clone_data.get("description", ""),
+            version=clone_data.get("version", ""),
+            icon=clone_data.get("icon", "")
+        )
+        
+        if success:
+            # 注册插件服务
+            reload_plugin(message)
+            # 将分身插件添加到原插件所在的文件夹中
+            _add_clone_to_plugin_folder(plugin_id, message)
+            return schemas.Response(success=True, message="插件分身创建成功")
+        else:
+            return schemas.Response(success=False, message=message)
+    except Exception as e:
+        logger.error(f"创建插件分身失败：{str(e)}")
+        return schemas.Response(success=False, message=f"创建插件分身失败：{str(e)}")
+
+
+def _add_clone_to_plugin_folder(original_plugin_id: str, clone_plugin_id: str):
+    """
+    将分身插件添加到原插件所在的文件夹中
+    :param original_plugin_id: 原插件ID
+    :param clone_plugin_id: 分身插件ID
+    """
+    try:
+        config_oper = SystemConfigOper()
+        # 获取插件文件夹配置
+        folders = config_oper.get(SystemConfigKey.PluginFolders) or {}
+        
+        # 查找原插件所在的文件夹
+        target_folder = None
+        for folder_name, folder_data in folders.items():
+            if isinstance(folder_data, dict) and 'plugins' in folder_data:
+                # 新格式：{"plugins": [...], "order": ..., "icon": ...}
+                if original_plugin_id in folder_data['plugins']:
+                    target_folder = folder_name
+                    break
+            elif isinstance(folder_data, list):
+                # 旧格式：直接是插件列表
+                if original_plugin_id in folder_data:
+                    target_folder = folder_name
+                    break
+        
+        # 如果找到了原插件所在的文件夹，则将分身插件也添加到该文件夹中
+        if target_folder:
+            folder_data = folders[target_folder]
+            if isinstance(folder_data, dict) and 'plugins' in folder_data:
+                # 新格式
+                if clone_plugin_id not in folder_data['plugins']:
+                    folder_data['plugins'].append(clone_plugin_id)
+                    logger.info(f"已将分身插件 {clone_plugin_id} 添加到文件夹 '{target_folder}' 中")
+            elif isinstance(folder_data, list):
+                # 旧格式
+                if clone_plugin_id not in folder_data:
+                    folder_data.append(clone_plugin_id)
+                    logger.info(f"已将分身插件 {clone_plugin_id} 添加到文件夹 '{target_folder}' 中")
+            
+            # 保存更新后的文件夹配置
+            config_oper.set(SystemConfigKey.PluginFolders, folders)
+        else:
+            logger.info(f"原插件 {original_plugin_id} 不在任何文件夹中，分身插件 {clone_plugin_id} 将保持独立")
+            
+    except Exception as e:
+        logger.error(f"处理插件文件夹时出错：{str(e)}")
+        # 文件夹处理失败不影响插件分身创建的整体流程
+
+
+def _remove_plugin_from_folders(plugin_id: str):
+    """
+    从所有文件夹中移除指定的插件
+    :param plugin_id: 要移除的插件ID
+    """
+    try:
+        config_oper = SystemConfigOper()
+        # 获取插件文件夹配置
+        folders = config_oper.get(SystemConfigKey.PluginFolders) or {}
+        
+        # 标记是否有修改
+        modified = False
+        
+        # 遍历所有文件夹，移除指定插件
+        for folder_name, folder_data in folders.items():
+            if isinstance(folder_data, dict) and 'plugins' in folder_data:
+                # 新格式：{"plugins": [...], "order": ..., "icon": ...}
+                if plugin_id in folder_data['plugins']:
+                    folder_data['plugins'].remove(plugin_id)
+                    logger.info(f"已从文件夹 '{folder_name}' 中移除插件 {plugin_id}")
+                    modified = True
+            elif isinstance(folder_data, list):
+                # 旧格式：直接是插件列表
+                if plugin_id in folder_data:
+                    folder_data.remove(plugin_id)
+                    logger.info(f"已从文件夹 '{folder_name}' 中移除插件 {plugin_id}")
+                    modified = True
+        
+        # 如果有修改，保存更新后的文件夹配置
+        if modified:
+            config_oper.set(SystemConfigKey.PluginFolders, folders)
+        else:
+            logger.debug(f"插件 {plugin_id} 不在任何文件夹中，无需移除")
+            
+    except Exception as e:
+        logger.error(f"从文件夹中移除插件时出错：{str(e)}")
+        # 文件夹处理失败不影响插件卸载的整体流程

app/api/endpoints/recommend.py

@@ -6,8 +6,8 @@ from app import schemas
 from app.core.event import eventmanager
 from app.core.security import verify_token
 from app.schemas.types import ChainEventType
-from chain.recommend import RecommendChain
-from schemas import RecommendSourceEventData
+from app.chain.recommend import RecommendChain
+from app.schemas import RecommendSourceEventData
 
 router = APIRouter()
 

app/api/endpoints/search.py

@@ -58,12 +58,12 @@ def search_by_id(mediaid: str,
             if doubaninfo:
                 torrents = SearchChain().search_by_id(doubanid=doubaninfo.get("id"),
                                                       mtype=media_type, area=area, season=media_season,
-                                                      sites=site_list)
+                                                      sites=site_list, cache_local=True)
             else:
                 return schemas.Response(success=False, message="未识别到豆瓣媒体信息")
         else:
             torrents = SearchChain().search_by_id(tmdbid=tmdbid, mtype=media_type, area=area, season=media_season,
-                                                  sites=site_list)
+                                                  sites=site_list, cache_local=True)
     elif mediaid.startswith("douban:"):
         doubanid = mediaid.replace("douban:", "")
         if settings.RECOGNIZE_SOURCE == "themoviedb":
@@ -74,12 +74,12 @@ def search_by_id(mediaid: str,
                     media_season = tmdbinfo.get('season')
                 torrents = SearchChain().search_by_id(tmdbid=tmdbinfo.get("id"),
                                                       mtype=media_type, area=area, season=media_season,
-                                                      sites=site_list)
+                                                      sites=site_list, cache_local=True)
             else:
                 return schemas.Response(success=False, message="未识别到TMDB媒体信息")
         else:
             torrents = SearchChain().search_by_id(doubanid=doubanid, mtype=media_type, area=area, season=media_season,
-                                                  sites=site_list)
+                                                  sites=site_list, cache_local=True)
     elif mediaid.startswith("bangumi:"):
         bangumiid = int(mediaid.replace("bangumi:", ""))
         if settings.RECOGNIZE_SOURCE == "themoviedb":
@@ -88,7 +88,7 @@ def search_by_id(mediaid: str,
             if tmdbinfo:
                 torrents = SearchChain().search_by_id(tmdbid=tmdbinfo.get("id"),
                                                       mtype=media_type, area=area, season=media_season,
-                                                      sites=site_list)
+                                                      sites=site_list, cache_local=True)
             else:
                 return schemas.Response(success=False, message="未识别到TMDB媒体信息")
         else:
@@ -97,7 +97,7 @@ def search_by_id(mediaid: str,
             if doubaninfo:
                 torrents = SearchChain().search_by_id(doubanid=doubaninfo.get("id"),
                                                       mtype=media_type, area=area, season=media_season,
-                                                      sites=site_list)
+                                                      sites=site_list, cache_local=True)
             else:
                 return schemas.Response(success=False, message="未识别到豆瓣媒体信息")
     else:
@@ -113,11 +113,11 @@ def search_by_id(mediaid: str,
             if event_data.media_dict:
                 search_id = event_data.media_dict.get("id")
                 if event_data.convert_type == "themoviedb":
-                    torrents = SearchChain().search_by_id(tmdbid=search_id,
-                                                          mtype=media_type, area=area, season=media_season)
+                    torrents = SearchChain().search_by_id(tmdbid=search_id, mtype=media_type, area=area,
+                                                          season=media_season, cache_local=True)
                 elif event_data.convert_type == "douban":
-                    torrents = SearchChain().search_by_id(doubanid=search_id,
-                                                          mtype=media_type, area=area, season=media_season)
+                    torrents = SearchChain().search_by_id(doubanid=search_id, mtype=media_type, area=area,
+                                                          season=media_season, cache_local=True)
         else:
             if not title:
                 return schemas.Response(success=False, message="未知的媒体ID")
@@ -133,11 +133,11 @@ def search_by_id(mediaid: str,
             mediainfo = MediaChain().recognize_media(meta=meta)
             if mediainfo:
                 if settings.RECOGNIZE_SOURCE == "themoviedb":
-                    torrents = SearchChain().search_by_id(tmdbid=mediainfo.tmdb_id,
-                                                          mtype=media_type, area=area, season=media_season)
+                    torrents = SearchChain().search_by_id(tmdbid=mediainfo.tmdb_id, mtype=media_type, area=area,
+                                                          season=media_season, cache_local=True)
                 else:
-                    torrents = SearchChain().search_by_id(doubanid=mediainfo.douban_id,
-                                                          mtype=media_type, area=area, season=media_season)
+                    torrents = SearchChain().search_by_id(doubanid=mediainfo.douban_id, mtype=media_type, area=area,
+                                                          season=media_season, cache_local=True)
     # 返回搜索结果
     if not torrents:
         return schemas.Response(success=False, message="未搜索到任何资源")
@@ -154,7 +154,8 @@ def search_by_title(keyword: Optional[str] = None,
     根据名称模糊搜索站点资源，支持分页，关键词为空是返回首页资源
     """
     torrents = SearchChain().search_by_title(title=keyword, page=page,
-                                             sites=[int(site) for site in sites.split(",") if site] if sites else None)
+                                             sites=[int(site) for site in sites.split(",") if site] if sites else None,
+                                             cache_local=True)
     if not torrents:
         return schemas.Response(success=False, message="未搜索到任何资源")
     return schemas.Response(success=True, data=[torrent.to_dict() for torrent in torrents])

app/api/endpoints/site.py

@@ -5,8 +5,10 @@ from sqlalchemy.orm import Session
 from starlette.background import BackgroundTasks
 
 from app import schemas
+from app.api.endpoints.plugin import register_plugin_api
 from app.chain.site import SiteChain
 from app.chain.torrents import TorrentsChain
+from app.command import Command
 from app.core.event import EventManager
 from app.core.plugin import PluginManager
 from app.core.security import verify_token
@@ -16,6 +18,7 @@ from app.db.models.site import Site
 from app.db.models.siteicon import SiteIcon
 from app.db.models.sitestatistic import SiteStatistic
 from app.db.models.siteuserdata import SiteUserData
+from app.db.site_oper import SiteOper
 from app.db.systemconfig_oper import SystemConfigOper
 from app.db.user_oper import get_current_active_superuser
 from app.helper.sites import SitesHelper
@@ -385,11 +388,29 @@ def auth_site(
         return schemas.Response(success=False, message="请输入认证站点和认证参数")
     status, msg = SitesHelper().check_user(auth_info.site, auth_info.params)
     SystemConfigOper().set(SystemConfigKey.UserSiteAuthParams, auth_info.dict())
+    # 认证成功后，重新初始化插件
     PluginManager().init_config()
     Scheduler().init_plugin_jobs()
+    Command().init_commands()
+    register_plugin_api()
     return schemas.Response(success=status, message=msg)
 
 
+@router.get("/mapping", summary="获取站点域名到名称的映射", response_model=schemas.Response)
+def site_mapping(_: User = Depends(get_current_active_superuser)):
+    """
+    获取站点域名到名称的映射关系
+    """
+    try:
+        sites = SiteOper().list()
+        mapping = {}
+        for site in sites:
+            mapping[site.domain] = site.name
+        return schemas.Response(success=True, data=mapping)
+    except Exception as e:
+        return schemas.Response(success=False, message=f"获取映射失败：{str(e)}")
+
+
 @router.get("/{site_id}", summary="站点详情", response_model=schemas.Site)
 def read_site(
         site_id: int,

app/api/endpoints/storage.py

@@ -31,7 +31,7 @@ def qrcode(name: str, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
 
 
 @router.get("/check/{name}", summary="二维码登录确认", response_model=schemas.Response)
-def check(name: str, ck: Optional[str] = None, t: Optional[str] = None, 
+def check(name: str, ck: Optional[str] = None, t: Optional[str] = None,
           _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     二维码登录确认
@@ -56,6 +56,16 @@ def save(name: str,
     return schemas.Response(success=True)
 
 
+@router.get("/reset/{name}", summary="重置存储配置", response_model=schemas.Response)
+def reset(name: str,
+          _: User = Depends(get_current_active_superuser)) -> Any:
+    """
+    重置存储配置
+    """
+    StorageChain().reset_config(name)
+    return schemas.Response(success=True)
+
+
 @router.post("/list", summary="所有目录和文件", response_model=List[schemas.FileItem])
 def list_files(fileitem: schemas.FileItem,
                sort: Optional[str] = 'updated_at',
@@ -152,47 +162,50 @@ def rename(fileitem: schemas.FileItem,
     """
     if not new_name:
         return schemas.Response(success=False, message="新名称为空")
+
+    # 重命名目录内文件
+    if recursive:
+        transferchain = TransferChain()
+        media_exts = settings.RMT_MEDIAEXT + settings.RMT_SUBEXT + settings.RMT_AUDIO_TRACK_EXT
+        # 递归修改目录内文件（智能识别命名）
+        sub_files: List[schemas.FileItem] = StorageChain().list_files(fileitem)
+        if sub_files:
+            # 开始进度
+            progress = ProgressHelper()
+            progress.start(ProgressKey.BatchRename)
+            total = len(sub_files)
+            handled = 0
+            for sub_file in sub_files:
+                handled += 1
+                progress.update(value=handled / total * 100,
+                                text=f"正在处理 {sub_file.name} ...",
+                                key=ProgressKey.BatchRename)
+                if sub_file.type == "dir":
+                    continue
+                if not sub_file.extension:
+                    continue
+                if f".{sub_file.extension.lower()}" not in media_exts:
+                    continue
+                sub_path = Path(f"{fileitem.path}{sub_file.name}")
+                meta = MetaInfoPath(sub_path)
+                mediainfo = transferchain.recognize_media(meta)
+                if not mediainfo:
+                    progress.end(ProgressKey.BatchRename)
+                    return schemas.Response(success=False, message=f"{sub_path.name} 未识别到媒体信息")
+                new_path = transferchain.recommend_name(meta=meta, mediainfo=mediainfo)
+                if not new_path:
+                    progress.end(ProgressKey.BatchRename)
+                    return schemas.Response(success=False, message=f"{sub_path.name} 未识别到新名称")
+                ret: schemas.Response = rename(fileitem=sub_file,
+                                               new_name=Path(new_path).name,
+                                               recursive=False)
+                if not ret.success:
+                    progress.end(ProgressKey.BatchRename)
+                    return schemas.Response(success=False, message=f"{sub_path.name} 重命名失败！")
+            progress.end(ProgressKey.BatchRename)
+    # 重命名自己
     result = StorageChain().rename_file(fileitem, new_name)
     if result:
-        if recursive:
-            transferchain = TransferChain()
-            media_exts = settings.RMT_MEDIAEXT + settings.RMT_SUBEXT + settings.RMT_AUDIO_TRACK_EXT
-            # 递归修改目录内文件（智能识别命名）
-            sub_files: List[schemas.FileItem] = StorageChain().list_files(fileitem)
-            if sub_files:
-                # 开始进度
-                progress = ProgressHelper()
-                progress.start(ProgressKey.BatchRename)
-                total = len(sub_files)
-                handled = 0
-                for sub_file in sub_files:
-                    handled += 1
-                    progress.update(value=handled / total * 100,
-                                    text=f"正在处理 {sub_file.name} ...",
-                                    key=ProgressKey.BatchRename)
-                    if sub_file.type == "dir":
-                        continue
-                    if not sub_file.extension:
-                        continue
-                    if f".{sub_file.extension.lower()}" not in media_exts:
-                        continue
-                    sub_path = Path(f"{fileitem.path}{sub_file.name}")
-                    meta = MetaInfoPath(sub_path)
-                    mediainfo = transferchain.recognize_media(meta)
-                    if not mediainfo:
-                        progress.end(ProgressKey.BatchRename)
-                        return schemas.Response(success=False, message=f"{sub_path.name} 未识别到媒体信息")
-                    new_path = transferchain.recommend_name(meta=meta, mediainfo=mediainfo)
-                    if not new_path:
-                        progress.end(ProgressKey.BatchRename)
-                        return schemas.Response(success=False, message=f"{sub_path.name} 未识别到新名称")
-                    ret: schemas.Response = rename(fileitem=sub_file,
-                                                   new_name=Path(new_path).name,
-                                                   recursive=False)
-                    if not ret.success:
-                        progress.end(ProgressKey.BatchRename)
-                        return schemas.Response(success=False, message=f"{sub_path.name} 重命名失败！")
-                progress.end(ProgressKey.BatchRename)
         return schemas.Response(success=True)
     return schemas.Response(success=False)
 

app/api/endpoints/subscribe.py

@@ -75,23 +75,12 @@ def create_subscribe(
         title = subscribe_in.name
     else:
         title = None
+    # 订阅用户
+    subscribe_in.username = current_user.name
     sid, message = SubscribeChain().add(mtype=mtype,
                                         title=title,
-                                        year=subscribe_in.year,
-                                        tmdbid=subscribe_in.tmdbid,
-                                        season=subscribe_in.season,
-                                        doubanid=subscribe_in.doubanid,
-                                        bangumiid=subscribe_in.bangumiid,
-                                        mediaid=subscribe_in.mediaid,
-                                        episode_group=subscribe_in.episode_group,
-                                        username=current_user.name,
-                                        best_version=subscribe_in.best_version,
-                                        save_path=subscribe_in.save_path,
-                                        search_imdbid=subscribe_in.search_imdbid,
-                                        custom_words=subscribe_in.custom_words,
-                                        media_category=subscribe_in.media_category,
-                                        filter_groups=subscribe_in.filter_groups,
-                                        exist_ok=True)
+                                        exist_ok=True,
+                                        **subscribe_in.dict())
     return schemas.Response(
         success=bool(sid), message=message, data={"id": sid}
     )

app/api/endpoints/system.py

@@ -28,6 +28,8 @@ from app.helper.message import MessageHelper, MessageQueueManager
 from app.helper.progress import ProgressHelper
 from app.helper.rule import RuleHelper
 from app.helper.sites import SitesHelper
+from app.helper.subscribe import SubscribeHelper
+from app.helper.system import SystemHelper
 from app.log import logger
 from app.monitor import Monitor
 from app.scheduler import Scheduler
@@ -35,7 +37,6 @@ from app.schemas.types import SystemConfigKey
 from app.utils.crypto import HashUtils
 from app.utils.http import RequestUtils
 from app.utils.security import SecurityUtils
-from app.utils.system import SystemUtils
 from app.utils.url import UrlUtils
 from version import APP_VERSION
 
@@ -170,18 +171,22 @@ def cache_img(
 
 
 @router.get("/global", summary="查询非敏感系统设置", response_model=schemas.Response)
-def get_global_setting():
+def get_global_setting(token: str):
     """
-    查询非敏感系统设置（无需鉴权）
+    查询非敏感系统设置（默认鉴权）
     """
+    if token != "moviepilot":
+        raise HTTPException(status_code=403, detail="Forbidden")
+
     # FIXME: 新增敏感配置项时要在此处添加排除项
     info = settings.dict(
         exclude={"SECRET_KEY", "RESOURCE_SECRET_KEY", "API_TOKEN", "TMDB_API_KEY", "TVDB_API_KEY", "FANART_API_KEY",
                  "COOKIECLOUD_KEY", "COOKIECLOUD_PASSWORD", "GITHUB_TOKEN", "REPO_GITHUB_TOKEN"}
     )
-    # 追加用户唯一ID
+    # 追加用户唯一ID和订阅分享管理权限
     info.update({
-        "USER_UNIQUE_ID": SystemUtils.generate_user_unique_id()
+        "USER_UNIQUE_ID": SubscribeHelper().get_user_uuid(),
+        "SUBSCRIBE_SHARE_MANAGE": SubscribeHelper().is_admin_user(),
     })
     return schemas.Response(success=True,
                             data=info)
@@ -281,6 +286,9 @@ def set_setting(key: str, value: Union[list, dict, bool, int, str] = None,
         success, message = settings.update_setting(key=key, value=value)
         return schemas.Response(success=success, message=message)
     elif key in {item.value for item in SystemConfigKey}:
+        if isinstance(value, list):
+            value = list(filter(None, value))
+            value = value if value else None
         SystemConfigOper().set(key, value)
         return schemas.Response(success=True)
     else:
@@ -466,12 +474,12 @@ def restart_system(_: User = Depends(get_current_active_superuser)):
     """
     重启系统（仅管理员）
     """
-    if not SystemUtils.can_restart():
+    if not SystemHelper.can_restart():
         return schemas.Response(success=False, message="当前运行环境不支持重启操作！")
     # 标识停止事件
     global_vars.stop_system()
     # 执行重启
-    ret, msg = SystemUtils.restart()
+    ret, msg = SystemHelper.restart()
     return schemas.Response(success=ret, message=msg)
 
 

app/api/endpoints/torrent.py

@@ -0,0 +1,199 @@
+from typing import Optional
+
+from fastapi import APIRouter, Depends
+
+from app import schemas
+from app.chain.media import MediaChain
+from app.chain.torrents import TorrentsChain
+from app.core.config import settings
+from app.core.context import MediaInfo
+from app.core.metainfo import MetaInfo
+from app.db.models import User
+from app.db.user_oper import get_current_active_superuser
+from app.utils.crypto import HashUtils
+
+router = APIRouter()
+
+
+@router.get("/cache", summary="获取种子缓存", response_model=schemas.Response)
+def torrents_cache(_: User = Depends(get_current_active_superuser)):
+    """
+    获取当前种子缓存数据
+    """
+    torrents_chain = TorrentsChain()
+
+    # 获取spider和rss两种缓存
+    if settings.SUBSCRIBE_MODE == "rss":
+        cache_info = torrents_chain.get_torrents("rss")
+    else:
+        cache_info = torrents_chain.get_torrents("spider")
+
+    # 统计信息
+    torrent_count = sum(len(torrents) for torrents in cache_info.values())
+
+    # 转换为前端需要的格式
+    torrent_data = []
+    for domain, contexts in cache_info.items():
+        for context in contexts:
+            torrent_hash = HashUtils.md5(f"{context.torrent_info.title}{context.torrent_info.description}")
+            torrent_data.append({
+                "hash": torrent_hash,
+                "domain": domain,
+                "title": context.torrent_info.title,
+                "description": context.torrent_info.description,
+                "size": context.torrent_info.size,
+                "pubdate": context.torrent_info.pubdate,
+                "site_name": context.torrent_info.site_name,
+                "media_name": context.media_info.title if context.media_info else "",
+                "media_year": context.media_info.year if context.media_info else "",
+                "media_type": context.media_info.type if context.media_info else "",
+                "season_episode": context.meta_info.season_episode if context.meta_info else "",
+                "resource_term": context.meta_info.resource_term if context.meta_info else "",
+                "enclosure": context.torrent_info.enclosure,
+                "page_url": context.torrent_info.page_url,
+                "poster_path": context.media_info.get_poster_image() if context.media_info else "",
+                "backdrop_path": context.media_info.get_backdrop_image() if context.media_info else ""
+            })
+
+    return schemas.Response(success=True, data={
+        "count": torrent_count,
+        "sites": len(cache_info),
+        "data": torrent_data
+    })
+
+
+@router.delete("/cache/{domain}/{torrent_hash}", summary="删除指定种子缓存",
+               response_model=schemas.Response)
+def delete_cache(domain: str, torrent_hash: str, _: User = Depends(get_current_active_superuser)):
+    """
+    删除指定的种子缓存
+    :param domain: 站点域名
+    :param torrent_hash: 种子hash（使用title+description的md5）
+    :param _: 当前用户，必须是超级用户
+    """
+
+    torrents_chain = TorrentsChain()
+
+    try:
+        # 获取当前缓存
+        cache_data = torrents_chain.get_torrents()
+
+        if domain not in cache_data:
+            return schemas.Response(success=False, message=f"站点 {domain} 缓存不存在")
+
+        # 查找并删除指定种子
+        original_count = len(cache_data[domain])
+        cache_data[domain] = [
+            context for context in cache_data[domain]
+            if HashUtils.md5(f"{context.torrent_info.title}{context.torrent_info.description}") != torrent_hash
+        ]
+
+        if len(cache_data[domain]) == original_count:
+            return schemas.Response(success=False, message="未找到指定的种子")
+
+        # 保存更新后的缓存
+        torrents_chain.save_cache(cache_data, torrents_chain.cache_file)
+
+        return schemas.Response(success=True, message="种子删除成功")
+    except Exception as e:
+        return schemas.Response(success=False, message=f"删除失败：{str(e)}")
+
+
+@router.delete("/cache", summary="清理种子缓存", response_model=schemas.Response)
+def clear_cache(_: User = Depends(get_current_active_superuser)):
+    """
+    清理所有种子缓存
+    """
+    torrents_chain = TorrentsChain()
+
+    try:
+        torrents_chain.clear_torrents()
+        return schemas.Response(success=True, message="种子缓存清理完成")
+    except Exception as e:
+        return schemas.Response(success=False, message=f"清理失败：{str(e)}")
+
+
+@router.post("/cache/refresh", summary="刷新种子缓存", response_model=schemas.Response)
+def refresh_cache(_: User = Depends(get_current_active_superuser)):
+    """
+    刷新种子缓存
+    """
+    from app.chain.torrents import TorrentsChain
+
+    torrents_chain = TorrentsChain()
+
+    try:
+        result = torrents_chain.refresh()
+
+        # 统计刷新结果
+        total_count = sum(len(torrents) for torrents in result.values())
+        sites_count = len(result)
+
+        return schemas.Response(success=True, message=f"缓存刷新完成，共刷新 {sites_count} 个站点，{total_count} 个种子")
+    except Exception as e:
+        return schemas.Response(success=False, message=f"刷新失败：{str(e)}")
+
+
+@router.post("/cache/reidentify/{domain}/{torrent_hash}", summary="重新识别种子", response_model=schemas.Response)
+def reidentify_cache(domain: str, torrent_hash: str,
+                     tmdbid: Optional[int] = None, doubanid: Optional[str] = None,
+                     _: User = Depends(get_current_active_superuser)):
+    """
+    重新识别指定的种子
+    :param domain: 站点域名
+    :param torrent_hash: 种子hash（使用title+description的md5）
+    :param tmdbid: 手动指定的TMDB ID
+    :param doubanid: 手动指定的豆瓣ID
+    :param _: 当前用户，必须是超级用户
+    """
+
+    torrents_chain = TorrentsChain()
+    media_chain = MediaChain()
+
+    try:
+        # 获取当前缓存
+        cache_data = torrents_chain.get_torrents()
+
+        if domain not in cache_data:
+            return schemas.Response(success=False, message=f"站点 {domain} 缓存不存在")
+
+        # 查找指定种子
+        target_context = None
+        for context in cache_data[domain]:
+            if HashUtils.md5(f"{context.torrent_info.title}{context.torrent_info.description}") == torrent_hash:
+                target_context = context
+                break
+
+        if not target_context:
+            return schemas.Response(success=False, message="未找到指定的种子")
+
+        # 重新识别
+        meta = MetaInfo(title=target_context.torrent_info.title,
+                        subtitle=target_context.torrent_info.description)
+        if tmdbid or doubanid:
+            # 手动指定媒体信息
+            mediainfo = MediaChain().recognize_media(meta=meta, tmdbid=tmdbid, doubanid=doubanid)
+        else:
+            # 自动重新识别
+            mediainfo = media_chain.recognize_by_meta(meta)
+
+        if not mediainfo:
+            # 创建空的媒体信息
+            mediainfo = MediaInfo()
+        else:
+            # 清理多余数据
+            mediainfo.clear()
+
+        # 更新上下文中的媒体信息
+        target_context.media_info = mediainfo
+
+        # 保存更新后的缓存
+        torrents_chain.save_cache(cache_data, TorrentsChain().cache_file)
+
+        return schemas.Response(success=True, message="重新识别完成", data={
+            "media_name": mediainfo.title if mediainfo else "",
+            "media_year": mediainfo.year if mediainfo else "",
+            "media_type": mediainfo.type.value if mediainfo and mediainfo.type else ""
+        })
+    except Exception as e:
+        return schemas.Response(success=False, message=f"重新识别失败：{str(e)}")

app/api/endpoints/workflow.py

@@ -6,6 +6,7 @@ from sqlalchemy.orm import Session
 
 from app import schemas
 from app.core.config import global_vars
+from app.core.plugin import PluginManager
 from app.core.workflow import WorkFlowManager
 from app.db import get_db
 from app.db.models.workflow import Workflow
@@ -43,6 +44,14 @@ def create_workflow(workflow: schemas.Workflow,
     return schemas.Response(success=True, message="创建工作流成功")
 
 
+@router.get("/plugin/actions", summary="查询插件动作", response_model=List[dict])
+def list_plugin_actions(plugin_id: str = None, _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    获取所有动作
+    """
+    return PluginManager().get_plugin_actions(plugin_id)
+
+
 @router.get("/actions", summary="所有动作", response_model=List[dict])
 def list_actions(_: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
     """

app/api/servarr.py

@@ -5,6 +5,7 @@ from sqlalchemy.orm import Session
 
 from app import schemas
 from app.chain.media import MediaChain
+from app.chain.tvdb import TvdbChain
 from app.chain.subscribe import SubscribeChain
 from app.core.metainfo import MetaInfo
 from app.core.security import verify_apikey
@@ -518,88 +519,89 @@ def arr_series_lookup(term: str, _: Annotated[str, Depends(verify_apikey)], db:
     """
     查询Sonarr剧集 term: `tvdb:${id}` title
     """
-    # 获取TVDBID
-    if not term.startswith("tvdb:"):
-        mediainfo = MediaChain().recognize_media(meta=MetaInfo(term),
-                                                 mtype=MediaType.TV)
-        if not mediainfo:
-            return [SonarrSeries()]
-        tvdbid = mediainfo.tvdb_id
-        if not tvdbid:
-            return [SonarrSeries()]
-    else:
-        mediainfo = None
-        tvdbid = int(term.replace("tvdb:", ""))
-
-    # 查询TVDB信息
-    tvdbinfo = MediaChain().tvdb_info(tvdbid=tvdbid)
-    if not tvdbinfo:
-        return [SonarrSeries()]
-
     # 季信息
     seas: List[int] = []
-    sea_num = tvdbinfo.get('season')
-    if sea_num:
-        seas = list(range(1, int(sea_num) + 1))
-
-    # 根据TVDB查询媒体信息
-    if not mediainfo:
-        mediainfo = MediaChain().recognize_media(meta=MetaInfo(tvdbinfo.get('seriesName')),
-                                                 mtype=MediaType.TV)
-
-    # 查询是否存在
-    exists = MediaChain().media_exists(mediainfo)
-    if exists:
-        hasfile = True
+    # tvdbid 列表
+    tvdbids: List[int] = []
+    # 获取TVDBID
+    if not term.startswith("tvdb:"):
+        title = term.replace("+", " ")
+        tvdbids = TvdbChain().get_tvdbid_by_name(title=title)
     else:
-        hasfile = False
+        tvdbid = int(term.replace("tvdb:", ""))
+        tvdbids.append(tvdbid)
 
-    # 查询订阅信息
-    seasons: List[dict] = []
-    subscribes = Subscribe.get_by_tmdbid(db, mediainfo.tmdb_id)
-    if subscribes:
-        # 已监控
-        monitored = True
-        # 已监控季
-        sub_seas = [sub.season for sub in subscribes]
-        for sea in seas:
-            if sea in sub_seas:
-                seasons.append({
-                    "seasonNumber": sea,
-                    "monitored": True,
-                })
-            else:
+    sonarr_series_list = []
+    for tvdbid in tvdbids:
+        # 查询TVDB信息
+        tvdbinfo = MediaChain().tvdb_info(tvdbid=tvdbid)
+        if not tvdbinfo:
+            continue
+
+        # 季信息(只取默认季类型，排除特别季)
+        sea_num = len([season for season in tvdbinfo.get('seasons') if
+                       season['type']['id'] == tvdbinfo.get('defaultSeasonType') and season['number'] > 0])
+        if sea_num:
+            seas = list(range(1, int(sea_num) + 1))
+
+        # 根据TVDB查询媒体信息
+        mediainfo = MediaChain().recognize_media(meta=MetaInfo(tvdbinfo.get('name')),
+                                                 mtype=MediaType.TV)
+        if not mediainfo:
+            continue
+        # 查询是否存在
+        exists = MediaChain().media_exists(mediainfo)
+        if exists:
+            hasfile = True
+        else:
+            hasfile = False
+
+        # 查询订阅信息
+        seasons: List[dict] = []
+        subscribes = Subscribe.get_by_tmdbid(db, mediainfo.tmdb_id)
+        if subscribes:
+            # 已监控
+            monitored = True
+            # 已监控季
+            sub_seas = [sub.season for sub in subscribes]
+            for sea in seas:
+                if sea in sub_seas:
+                    seasons.append({
+                        "seasonNumber": sea,
+                        "monitored": True,
+                    })
+                else:
+                    seasons.append({
+                        "seasonNumber": sea,
+                        "monitored": False,
+                    })
+            subid = subscribes[-1].id
+        else:
+            subid = None
+            monitored = False
+            for sea in seas:
                 seasons.append({
                     "seasonNumber": sea,
                     "monitored": False,
                 })
-        subid = subscribes[-1].id
-    else:
-        subid = None
-        monitored = False
-        for sea in seas:
-            seasons.append({
-                "seasonNumber": sea,
-                "monitored": False,
-            })
+        sonarr_series = SonarrSeries(
+            id=subid,
+            title=mediainfo.title,
+            seasonCount=len(seasons),
+            seasons=seasons,
+            remotePoster=mediainfo.get_poster_image(),
+            year=mediainfo.year,
+            tmdbId=mediainfo.tmdb_id,
+            tvdbId=tvdbid,
+            imdbId=mediainfo.imdb_id,
+            profileId=1,
+            languageProfileId=1,
+            monitored=monitored,
+            hasFile=hasfile,
+        )
+        sonarr_series_list.append(sonarr_series)
 
-    return [SonarrSeries(
-        id=subid,
-        title=mediainfo.title,
-        seasonCount=len(seasons),
-        seasons=seasons,
-        remotePoster=mediainfo.get_poster_image(),
-        year=mediainfo.year,
-        tmdbId=mediainfo.tmdb_id,
-        tvdbId=mediainfo.tvdb_id,
-        imdbId=mediainfo.imdb_id,
-        profileId=1,
-        languageProfileId=1,
-        qualityProfileId=1,
-        isAvailable=True,
-        monitored=monitored,
-        hasFile=hasfile
-    )]
+    return sonarr_series_list if sonarr_series_list else [SonarrSeries()]
 
 
 @arr_router.get("/series/{tid}", summary="剧集详情")

app/chain/__init__.py

@@ -3,6 +3,7 @@ import gc
 import pickle
 import traceback
 from abc import ABCMeta
+from collections.abc import Callable
 from pathlib import Path
 from typing import Optional, Any, Tuple, List, Set, Union, Dict
 
@@ -14,9 +15,10 @@ from app.core.context import Context, MediaInfo, TorrentInfo
 from app.core.event import EventManager
 from app.core.meta import MetaBase
 from app.core.module import ModuleManager
+from app.core.plugin import PluginManager
 from app.db.message_oper import MessageOper
 from app.db.user_oper import UserOper
-from app.helper.message import MessageHelper, MessageQueueManager
+from app.helper.message import MessageHelper, MessageQueueManager, MessageTemplateHelper
 from app.helper.service import ServiceConfigHelper
 from app.log import logger
 from app.schemas import TransferInfo, TransferTorrent, ExistMediaInfo, DownloadingTorrent, CommingMessage, Notification, \
@@ -42,6 +44,7 @@ class ChainBase(metaclass=ABCMeta):
             send_callback=self.run_module
         )
         self.useroper = UserOper()
+        self.pluginmanager = PluginManager()
 
     @staticmethod
     def load_cache(filename: str) -> Any:
@@ -64,7 +67,7 @@ class ChainBase(metaclass=ABCMeta):
         """
         try:
             with open(settings.TEMP_PATH / filename, 'wb') as f:
-                pickle.dump(cache, f) # noqa
+                pickle.dump(cache, f)  # noqa
         except Exception as err:
             logger.error(f"保存缓存 {filename} 出错：{str(err)}")
         finally:
@@ -97,7 +100,50 @@ class ChainBase(metaclass=ABCMeta):
                 return ret is None
 
         result = None
-        logger.debug(f"请求模块执行：{method} ...")
+        plugin_modules = self.pluginmanager.get_plugin_modules()
+        # 插件模块
+        for plugin, module_dict in plugin_modules.items():
+            plugin_id, plugin_name = plugin
+            if method in module_dict:
+                func = module_dict[method]
+                if func:
+                    try:
+                        logger.info(f"请求插件 {plugin_name} 执行：{method} ...")
+                        if is_result_empty(result):
+                            # 返回None，第一次执行或者需继续执行下一模块
+                            result = func(*args, **kwargs)
+                        elif isinstance(result, list):
+                            # 返回为列表，有多个模块运行结果时进行合并
+                            temp = func(*args, **kwargs)
+                            if isinstance(temp, list):
+                                result.extend(temp)
+                        else:
+                            break
+                    except Exception as err:
+                        if kwargs.get("raise_exception"):
+                            raise
+                        logger.error(
+                            f"运行插件 {plugin_id} 模块 {method} 出错：{str(err)}\n{traceback.format_exc()}")
+                        self.messagehelper.put(title=f"{plugin_name} 发生了错误",
+                                               message=str(err),
+                                               role="plugin")
+                        self.eventmanager.send_event(
+                            EventType.SystemError,
+                            {
+                                "type": "plugin",
+                                "plugin_id": plugin_id,
+                                "plugin_name": plugin_name,
+                                "plugin_method": method,
+                                "error": str(err),
+                                "traceback": traceback.format_exc()
+                            }
+                        )
+        if not is_result_empty(result) and not isinstance(result, list):
+            # 插件模块返回结果不为空且不是列表，直接返回
+            return result
+
+        # 系统模块
+        logger.debug(f"请求系统模块执行：{method} ...")
         modules = self.modulemanager.get_running_modules(method)
         # 按优先级排序
         modules = sorted(modules, key=lambda x: x.get_priority())
@@ -114,10 +160,10 @@ class ChainBase(metaclass=ABCMeta):
                     # 返回None，第一次执行或者需继续执行下一模块
                     result = func(*args, **kwargs)
                 elif ObjectUtils.check_signature(func, result):
-                    # 返回结果与方法签名一致，将结果传入（不能多个模块同时运行的需要通过开关控制）
+                    # 返回结果与方法签名一致，将结果传入
                     result = func(result)
                 elif isinstance(result, list):
-                    # 返回为列表，有多个模块运行结果时进行合并（不能多个模块同时运行的需要通过开关控制）
+                    # 返回为列表，有多个模块运行结果时进行合并
                     temp = func(*args, **kwargs)
                     if isinstance(temp, list):
                         result.extend(temp)
@@ -328,7 +374,7 @@ class ChainBase(metaclass=ABCMeta):
         return self.run_module("search_torrents", site=site, keywords=keywords,
                                mtype=mtype, page=page)
 
-    def refresh_torrents(self, site: dict, keyword: Optional[str] = None, 
+    def refresh_torrents(self, site: dict, keyword: Optional[str] = None,
                          cat: Optional[str] = None, page: Optional[int] = 0) -> List[TorrentInfo]:
         """
         获取站点最新一页的种子，多个站点需要多线程处理
@@ -401,7 +447,8 @@ class ChainBase(metaclass=ABCMeta):
                  target_storage: Optional[str] = None, target_path: Path = None,
                  transfer_type: Optional[str] = None, scrape: bool = None,
                  library_type_folder: bool = None, library_category_folder: bool = None,
-                 episodes_info: List[TmdbEpisode] = None) -> Optional[TransferInfo]:
+                 episodes_info: List[TmdbEpisode] = None,
+                 source_oper: Callable = None, target_oper: Callable = None) -> Optional[TransferInfo]:
         """
         文件转移
         :param fileitem:  文件信息
@@ -415,6 +462,8 @@ class ChainBase(metaclass=ABCMeta):
         :param library_type_folder: 是否按类型创建目录
         :param library_category_folder: 是否按类别创建目录
         :param episodes_info: 当前季的全部集信息
+        :param source_oper:  源存储操作类
+        :param target_oper:  目标存储操作类
         :return: {path, target_path, message}
         """
         return self.run_module("transfer",
@@ -424,7 +473,8 @@ class ChainBase(metaclass=ABCMeta):
                                transfer_type=transfer_type, scrape=scrape,
                                library_type_folder=library_type_folder,
                                library_category_folder=library_category_folder,
-                               episodes_info=episodes_info)
+                               episodes_info=episodes_info,
+                               source_oper=source_oper, target_oper=target_oper)
 
     def transfer_completed(self, hashs: str, downloader: Optional[str] = None) -> None:
         """
@@ -492,13 +542,27 @@ class ChainBase(metaclass=ABCMeta):
         """
         return self.run_module("media_files", mediainfo=mediainfo)
 
-    def post_message(self, message: Notification) -> None:
+    def post_message(self,
+                     message: Optional[Notification] = None,
+                     meta: Optional[MetaBase] = None,
+                     mediainfo: Optional[MediaInfo] = None,
+                     torrentinfo: Optional[TorrentInfo] = None,
+                     transferinfo: Optional[TransferInfo] = None,
+                     **kwargs) -> None:
         """
         发送消息
-        :param message:  消息体
+        :param message:  Notification实例
+        :param meta:  元数据
+        :param mediainfo:  媒体信息
+        :param torrentinfo:  种子信息
+        :param transferinfo:  文件整理信息
+        :param kwargs:  其他参数(覆盖业务对象属性值)
         :return: 成功或失败
         """
-        # 保存原消息
+        # 渲染消息
+        message = MessageTemplateHelper.render(message=message, meta=meta, mediainfo=mediainfo,
+                                               torrentinfo=torrentinfo, transferinfo=transferinfo, **kwargs)
+        # 保存消息
         self.messagehelper.put(message, role="user", title=message.title)
         self.messageoper.add(**message.dict())
         # 发送消息按设置隔离
@@ -579,7 +643,7 @@ class ChainBase(metaclass=ABCMeta):
         self.messageoper.add(**message.dict(), note=note_list)
         return self.messagequeue.send_message("post_torrents_message", message=message, torrents=torrents)
 
-    def metadata_img(self, mediainfo: MediaInfo, 
+    def metadata_img(self, mediainfo: MediaInfo,
                      season: Optional[int] = None, episode: Optional[int] = None) -> Optional[dict]:
         """
         获取图片名称和url

app/chain/download.py

@@ -20,7 +20,7 @@ from app.helper.message import MessageHelper
 from app.helper.torrent import TorrentHelper
 from app.log import logger
 from app.schemas import ExistMediaInfo, NotExistMediaInfo, DownloadingTorrent, Notification, ResourceSelectionEventData, ResourceDownloadEventData
-from app.schemas.types import MediaType, TorrentStatus, EventType, MessageChannel, NotificationType, ChainEventType
+from app.schemas.types import MediaType, TorrentStatus, EventType, MessageChannel, NotificationType, ContentType, ChainEventType
 from app.utils.http import RequestUtils
 from app.utils.string import StringUtils
 
@@ -38,63 +38,6 @@ class DownloadChain(ChainBase):
         self.directoryhelper = DirectoryHelper()
         self.messagehelper = MessageHelper()
 
-    def post_download_message(self, meta: MetaBase, mediainfo: MediaInfo, torrent: TorrentInfo,
-                              channel: MessageChannel = None, username: Optional[str] = None,
-                              download_episodes: Optional[str] = None):
-        """
-        发送添加下载的消息，根据消息场景开关决定发给谁
-        :param meta: 元数据
-        :param mediainfo: 媒体信息
-        :param torrent: 种子信息
-        :param channel: 通知渠道
-        :param username: 通知显示的下载用户信息
-        :param download_episodes: 下载的集数
-        """
-        # 拼装消息内容
-        msg_text = ""
-        if username:
-            msg_text = f"用户：{username}"
-        if torrent.site_name:
-            msg_text = f"{msg_text}\n站点：{torrent.site_name}"
-        if meta.resource_term:
-            msg_text = f"{msg_text}\n质量：{meta.resource_term}"
-        if torrent.size:
-            if str(torrent.size).replace(".", "").isdigit():
-                size = StringUtils.str_filesize(torrent.size)
-            else:
-                size = torrent.size
-            msg_text = f"{msg_text}\n大小：{size}"
-        if torrent.title:
-            msg_text = f"{msg_text}\n种子：{torrent.title}"
-        if torrent.pubdate:
-            msg_text = f"{msg_text}\n发布时间：{torrent.pubdate}"
-        if torrent.freedate:
-            msg_text = f"{msg_text}\n免费时间：{StringUtils.diff_time_str(torrent.freedate)}"
-        if torrent.seeders:
-            msg_text = f"{msg_text}\n做种数：{torrent.seeders}"
-        if torrent.uploadvolumefactor and torrent.downloadvolumefactor:
-            msg_text = f"{msg_text}\n促销：{torrent.volume_factor}"
-        if torrent.hit_and_run:
-            msg_text = f"{msg_text}\nHit&Run：是"
-        if torrent.labels:
-            msg_text = f"{msg_text}\n标签：{' '.join(torrent.labels)}"
-        if torrent.description:
-            html_re = re.compile(r'<[^>]+>', re.S)
-            description = html_re.sub('', torrent.description)
-            torrent.description = re.sub(r'<[^>]+>', '', description)
-            msg_text = f"{msg_text}\n描述：{torrent.description}"
-
-        # 下载成功按规则发送消息
-        self.post_message(Notification(
-            channel=channel,
-            mtype=NotificationType.Download,
-            title=f"{mediainfo.title_year} "
-                  f"{'%s %s' % (meta.season, download_episodes) if download_episodes else meta.season_episode} 开始下载",
-            text=msg_text,
-            image=mediainfo.get_message_image(),
-            link=settings.MP_DOMAIN('/#/downloading'),
-            username=username))
-
     def download_torrent(self, torrent: TorrentInfo,
                          channel: MessageChannel = None,
                          source: Optional[str] = None,
@@ -384,8 +327,21 @@ class DownloadChain(ChainBase):
                 self.downloadhis.add_files(files_to_add)
 
             # 下载成功发送消息
-            self.post_download_message(meta=_meta, mediainfo=_media, torrent=_torrent,
-                                       username=username, download_episodes=download_episodes)
+            self.post_message(
+                Notification(
+                    channel=channel,
+                    mtype=NotificationType.Download,
+                    ctype=ContentType.DownloadAdded,
+                    image=_media.get_message_image(),
+                    link=settings.MP_DOMAIN('/#/downloading'),
+                    username=username
+                ),
+                meta=_meta,
+                mediainfo=_media,
+                torrentinfo=_torrent,
+                download_episodes=download_episodes,
+                username=username,
+            )
             # 下载成功后处理
             self.download_added(context=context, download_dir=download_dir, torrent_path=torrent_file)
             # 广播事件

app/chain/media.py

@@ -449,23 +449,19 @@ class MediaChain(ChainBase, metaclass=Singleton):
                 # 生成目录内图片文件
                 if init_folder:
                     # 图片
-                    for attr_name, attr_value in vars(mediainfo).items():
-                        if attr_value \
-                                and attr_name.endswith("_path") \
-                                and attr_value \
-                                and isinstance(attr_value, str) \
-                                and attr_value.startswith("http"):
-                            image_name = attr_name.replace("_path", "") + Path(attr_value).suffix
-                            image_path = filepath / image_name
+                    image_dict = self.metadata_img(mediainfo=mediainfo)
+                    if image_dict:
+                        for image_name, image_url in image_dict.items():
+                            image_path = filepath.with_name(image_name)
                             if overwrite or not self.storagechain.get_file_item(storage=fileitem.storage,
                                                                                 path=image_path):
                                 # 下载图片
-                                content = __download_image(_url=attr_value)
+                                content = __download_image(image_url)
                                 # 写入图片到当前目录
                                 if content:
                                     __save_file(_fileitem=fileitem, _path=image_path, _content=content)
-                            else:
-                                logger.info(f"已存在图片文件：{image_path}")
+                                else:
+                                    logger.info(f"已存在图片文件：{image_path}")
         else:
             # 电视剧
             if fileitem.type == "file":

app/chain/message.py

@@ -119,7 +119,7 @@ class MessageChain(ChainBase):
         userid = info.userid
         # 用户名
         username = info.username or userid
-        if not userid:
+        if userid is None or userid == '':
             logger.debug(f'未识别到用户ID：{body}{form}{args}')
             return
         # 消息内容
@@ -422,13 +422,17 @@ class MessageChain(ChainBase):
                     or text.find("继续") != -1:
                 # 聊天
                 content = text
-                action = "chat"
+                action = "Chat"
+            elif StringUtils.is_link(text):
+                # 链接
+                content = text
+                action = "Link"
             else:
                 # 搜索
                 content = text
                 action = "Search"
 
-            if action != "chat":
+            if action in ["Search", "ReSearch", "Subscribe", "ReSubscribe"]:
                 # 搜索
                 meta, medias = self.mediachain.search(content)
                 # 识别

app/chain/search.py

@@ -36,7 +36,7 @@ class SearchChain(ChainBase):
 
     def search_by_id(self, tmdbid: Optional[int] = None, doubanid: Optional[str] = None,
                      mtype: MediaType = None, area: Optional[str] = "title", season: Optional[int] = None,
-                     sites: List[int] = None) -> List[Context]:
+                     sites: List[int] = None, cache_local: bool = False) -> List[Context]:
         """
         根据TMDBID/豆瓣ID搜索资源，精确匹配，不过滤本地存在的资源
         :param tmdbid: TMDB ID
@@ -45,6 +45,7 @@ class SearchChain(ChainBase):
         :param area: 搜索范围，title or imdbid
         :param season: 季数
         :param sites: 站点ID列表
+        :param cache_local: 是否缓存到本地
         """
         mediainfo = self.recognize_media(tmdbid=tmdbid, doubanid=doubanid, mtype=mtype)
         if not mediainfo:
@@ -59,12 +60,12 @@ class SearchChain(ChainBase):
             }
         results = self.process(mediainfo=mediainfo, sites=sites, area=area, no_exists=no_exists)
         # 保存到本地文件
-        bytes_results = pickle.dumps(results)
-        self.save_cache(bytes_results, self.__result_temp_file)
+        if cache_local:
+            self.save_cache(pickle.dumps(results), self.__result_temp_file)
         return results
 
     def search_by_title(self, title: str, page: Optional[int] = 0,
-                        sites: List[int] = None, cache_local: Optional[bool] = True) -> List[Context]:
+                        sites: List[int] = None, cache_local: Optional[bool] = False) -> List[Context]:
         """
         根据标题搜索资源，不识别不过滤，直接返回站点内容
         :param title: 标题，为空时返回所有站点首页内容
@@ -86,8 +87,7 @@ class SearchChain(ChainBase):
                             torrent_info=torrent) for torrent in torrents]
         # 保存到本地文件
         if cache_local:
-            bytes_results = pickle.dumps(contexts)
-            self.save_cache(bytes_results, self.__result_temp_file)
+            self.save_cache(pickle.dumps(contexts), self.__result_temp_file)
         return contexts
 
     def last_search_results(self) -> List[Context]:
@@ -329,36 +329,36 @@ class SearchChain(ChainBase):
         self.progress.update(value=0,
                              text=f"开始搜索，共 {total_num} 个站点 ...",
                              key=ProgressKey.Search)
-        # 多线程
-        executor = ThreadPoolExecutor(max_workers=len(indexer_sites))
-        all_task = []
-        for site in indexer_sites:
-            if area == "imdbid":
-                # 搜索IMDBID
-                task = executor.submit(self.search_torrents, site=site,
-                                       keywords=[mediainfo.imdb_id] if mediainfo else None,
-                                       mtype=mediainfo.type if mediainfo else None,
-                                       page=page)
-            else:
-                # 搜索标题
-                task = executor.submit(self.search_torrents, site=site,
-                                       keywords=keywords,
-                                       mtype=mediainfo.type if mediainfo else None,
-                                       page=page)
-            all_task.append(task)
         # 结果集
         results = []
-        for future in as_completed(all_task):
-            if global_vars.is_system_stopped:
-                break
-            finish_count += 1
-            result = future.result()
-            if result:
-                results.extend(result)
-            logger.info(f"站点搜索进度：{finish_count} / {total_num}")
-            self.progress.update(value=finish_count / total_num * 100,
-                                 text=f"正在搜索{keywords or ''}，已完成 {finish_count} / {total_num} 个站点 ...",
-                                 key=ProgressKey.Search)
+        # 多线程
+        with ThreadPoolExecutor(max_workers=len(indexer_sites)) as executor:
+            all_task = []
+            for site in indexer_sites:
+                if area == "imdbid":
+                    # 搜索IMDBID
+                    task = executor.submit(self.search_torrents, site=site,
+                                           keywords=[mediainfo.imdb_id] if mediainfo else None,
+                                           mtype=mediainfo.type if mediainfo else None,
+                                           page=page)
+                else:
+                    # 搜索标题
+                    task = executor.submit(self.search_torrents, site=site,
+                                           keywords=keywords,
+                                           mtype=mediainfo.type if mediainfo else None,
+                                           page=page)
+                all_task.append(task)
+            for future in as_completed(all_task):
+                if global_vars.is_system_stopped:
+                    break
+                finish_count += 1
+                result = future.result()
+                if result:
+                    results.extend(result)
+                logger.info(f"站点搜索进度：{finish_count} / {total_num}")
+                self.progress.update(value=finish_count / total_num * 100,
+                                     text=f"正在搜索{keywords or ''}，已完成 {finish_count} / {total_num} 个站点 ...",
+                                     key=ProgressKey.Search)
         # 计算耗时
         end_time = datetime.now()
         # 更新进度

app/chain/site.py

@@ -1,7 +1,6 @@
 import base64
 import re
 from datetime import datetime
-from time import time
 from typing import Optional, Tuple, Union, Dict
 from urllib.parse import urljoin
 
@@ -178,12 +177,9 @@ class SiteChain(ChainBase):
         domain = StringUtils.get_url_domain(site.url)
         url = f"https://api.{domain}/api/member/profile"
         headers = {
-            "Content-Type": "application/json",
             "User-Agent": user_agent,
             "Accept": "application/json, text/plain, */*",
-            "Authorization": site.token,
             "x-api-key": site.apikey,
-            "ts": str(int(time()))
         }
         res = RequestUtils(
             headers=headers,
@@ -193,27 +189,10 @@ class SiteChain(ChainBase):
         if res is None:
             return False, "无法打开网站！"
         if res.status_code == 200:
-            state = False
-            message = "鉴权已过期或无效"
             user_info = res.json() or {}
             if user_info.get("data"):
-                # 更新最后访问时间
-                del headers["x-api-key"]
-                res = RequestUtils(headers=headers,
-                                   timeout=site.timeout or 15,
-                                   proxies=settings.PROXY if site.proxy else None,
-                                   referer=f"{site.url}index"
-                                   ).post_res(url=f"https://api.{domain}/api/member/updateLastBrowse")
-                state = True
-                message = "连接成功，但更新状态失败"
-                if res and res.status_code == 200:
-                    update_info = res.json() or {}
-                    if "code" in update_info and int(update_info["code"]) == 0:
-                        message = "连接成功"
-            elif user_info.get("message"):
-                # 使用馒头的错误提示
-                message = user_info.get("message")
-            return state, message
+                return True, "连接成功"
+            return False, user_info.get("message", "鉴权已过期或无效")
         else:
             return False, f"错误：{res.status_code} {res.reason}"
 
@@ -318,7 +297,7 @@ class SiteChain(ChainBase):
             """
             if StringUtils.get_url_domain(inx.get("domain")) == sub_domain:
                 return inx.get("domain")
-            for ext_d in inx.get("ext_domains"):
+            for ext_d in inx.get("ext_domains", []):
                 if StringUtils.get_url_domain(ext_d) == sub_domain:
                     return ext_d
             return sub_domain

app/chain/storage.py

@@ -24,6 +24,12 @@ class StorageChain(ChainBase):
         """
         self.run_module("save_config", storage=storage, conf=conf)
 
+    def reset_config(self, storage: str) -> None:
+        """
+        重置存储配置
+        """
+        self.run_module("reset_config", storage=storage)
+
     def generate_qrcode(self, storage: str) -> Optional[Tuple[dict, str]]:
         """
         生成二维码
@@ -131,28 +137,43 @@ class StorageChain(ChainBase):
         """
         删除媒体文件，以及不含媒体文件的目录
         """
+
+        def __is_bluray_dir(_fileitem: schemas.FileItem) -> bool:
+            """
+            检查是否蓝光目录
+            """
+            _dir_files = self.list_files(fileitem=_fileitem, recursion=False)
+            if _dir_files:
+                for _f in _dir_files:
+                    if _f.type == "dir" and _f.name in ["BDMV", "CERTIFICATE"]:
+                        return True
+            return False
+
         media_exts = settings.RMT_MEDIAEXT + settings.DOWNLOAD_TMPEXT
         if fileitem.path == "/" or len(Path(fileitem.path).parts) <= 2:
             logger.warn(f"【{fileitem.storage}】{fileitem.path} 根目录或一级目录不允许删除")
             return False
         if fileitem.type == "dir":
             # 本身是目录
-            if _blue_dir := self.list_files(fileitem=fileitem, recursion=False):
-                # 删除蓝光目录
-                for _f in _blue_dir:
-                    if _f.type == "dir" and _f.name in ["BDMV", "CERTIFICATE"]:
-                        logger.warn(f"【{fileitem.storage}】{_f.path} 删除蓝光目录")
-                        self.delete_file(_f)
-            if self.any_files(fileitem, extensions=media_exts) is False:
-                logger.warn(f"【{fileitem.storage}】{fileitem.path} 不存在其它媒体文件，删除空目录")
-                return self.delete_file(fileitem)
-            return False
+            if __is_bluray_dir(fileitem):
+                logger.warn(f"正在删除蓝光原盘目录：【{fileitem.storage}】{fileitem.path}")
+                if not self.delete_file(fileitem):
+                    logger.warn(f"【{fileitem.storage}】{fileitem.path} 删除失败")
+                    return False
+            elif self.any_files(fileitem, extensions=media_exts) is False:
+                logger.warn(f"【{fileitem.storage}】{fileitem.path} 不存在其它媒体文件，正在删除空目录")
+                if not self.delete_file(fileitem):
+                    logger.warn(f"【{fileitem.storage}】{fileitem.path} 删除失败")
+                    return False
+            # 不处理父目录
+            return True
         elif delete_self:
-            # 本身是文件
-            logger.warn(f"正在删除【{fileitem.storage}】{fileitem.path}")
+            # 本身是文件，需要删除文件
+            logger.warn(f"正在删除文件【{fileitem.storage}】{fileitem.path}")
             if not self.delete_file(fileitem):
                 logger.warn(f"【{fileitem.storage}】{fileitem.path} 删除失败")
                 return False
+
         if mtype:
             # 重命名格式
             rename_format = settings.TV_RENAME_FORMAT \
@@ -161,11 +182,14 @@ class StorageChain(ChainBase):
             rename_format_level = len(rename_format.split("/")) - 1
             if rename_format_level < 1:
                 return True
-            # 处理上级目录
+            # 处理媒体文件根目录
             dir_item = self.get_file_item(storage=fileitem.storage,
                                           path=Path(fileitem.path).parents[rename_format_level - 1])
         else:
+            # 处理上级目录
             dir_item = self.get_parent_item(fileitem)
+
+        # 检查和删除上级目录
         if dir_item and len(Path(dir_item.path).parts) > 2:
             # 如何目录是所有下载目录、媒体库目录的上级，则不处理
             for d in self.directoryhelper.get_dirs():
@@ -177,7 +201,9 @@ class StorageChain(ChainBase):
                     return True
             # 不存在其他媒体文件，删除空目录
             if self.any_files(dir_item, extensions=media_exts) is False:
-                logger.warn(f"【{dir_item.storage}】{dir_item.path} 不存在其它媒体文件，删除空目录")
-                return self.delete_file(dir_item)
+                logger.warn(f"【{dir_item.storage}】{dir_item.path} 不存在其它媒体文件，正在删除空目录")
+                if not self.delete_file(dir_item):
+                    logger.warn(f"【{dir_item.storage}】{dir_item.path} 删除失败")
+                    return False
 
         return True

app/chain/subscribe.py

@@ -29,7 +29,7 @@ from app.helper.subscribe import SubscribeHelper
 from app.helper.torrent import TorrentHelper
 from app.log import logger
 from app.schemas import MediaRecognizeConvertEventData
-from app.schemas.types import MediaType, SystemConfigKey, MessageChannel, NotificationType, EventType, ChainEventType
+from app.schemas.types import MediaType, SystemConfigKey, MessageChannel, NotificationType, EventType, ChainEventType, ContentType
 from app.utils.singleton import Singleton
 
 
@@ -212,6 +212,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
             'filter_groups': self.__get_default_subscribe_config(mediainfo.type, "filter_groups") if not kwargs.get(
                 "filter_groups") else kwargs.get("filter_groups")
         })
+        # 操作数据库
         sid, err_msg = self.subscribeoper.add(mediainfo=mediainfo, season=season, username=username, **kwargs)
         if not sid:
             logger.error(f'{mediainfo.title_year} {err_msg}')
@@ -227,22 +228,23 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                                                        userid=userid))
             return None, err_msg
         elif message:
-            logger.info(f'{mediainfo.title_year} {metainfo.season} 添加订阅成功')
-            if username:
-                text = f"评分：{mediainfo.vote_average}，来自用户：{username}"
-            else:
-                text = f"评分：{mediainfo.vote_average}"
             if mediainfo.type == MediaType.TV:
                 link = settings.MP_DOMAIN('#/subscribe/tv?tab=mysub')
             else:
                 link = settings.MP_DOMAIN('#/subscribe/movie?tab=mysub')
             # 订阅成功按规则发送消息
-            self.post_message(schemas.Notification(mtype=NotificationType.Subscribe,
-                                                   title=f"{mediainfo.title_year} {metainfo.season} 已添加订阅",
-                                                   text=text,
-                                                   image=mediainfo.get_message_image(),
-                                                   link=link,
-                                                   username=username))
+            self.post_message(
+                schemas.Notification(
+                    mtype=NotificationType.Subscribe,
+                    ctype=ContentType.SubscribeAdded,
+                    image=mediainfo.get_message_image(),
+                    link=link,
+                    username=username
+                ),
+                meta=metainfo,
+                mediainfo=mediainfo,
+                username=username
+            )
         # 发送事件
         EventManager().send_event(EventType.SubscribeAdded, {
             "subscribe_id": sid,
@@ -559,6 +561,26 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
             logger.debug(f"match lock acquired at {datetime.now()}")
             # 所有订阅
             subscribes = self.subscribeoper.list(self.get_states_for_search('R'))
+
+            # 预识别所有未识别的种子
+            processed_torrents = {}
+            for domain, contexts in torrents.items():
+                processed_torrents[domain] = []
+                for context in contexts:
+                    # 复制上下文避免修改原始数据
+                    _context = copy.deepcopy(context)
+                    torrent_meta = _context.meta_info
+                    torrent_mediainfo = _context.media_info
+
+                    # 如果种子未识别，尝试识别
+                    if not torrent_mediainfo or (not torrent_mediainfo.tmdb_id and not torrent_mediainfo.douban_id):
+                        torrent_mediainfo = self.recognize_media(meta=torrent_meta)
+                        if torrent_mediainfo:
+                            # 更新种子缓存
+                            context.media_info = torrent_mediainfo
+                    # 添加已预处理
+                    processed_torrents[domain].append(_context)
+
             # 遍历订阅
             for subscribe in subscribes:
                 if global_vars.is_system_stopped:
@@ -602,9 +624,9 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                 else:
                     custom_words_list = None
 
-                # 遍历缓存种子
+                # 遍历预识别后的种子
                 _match_context = []
-                for domain, contexts in torrents.items():
+                for domain, contexts in processed_torrents.items():
                     if global_vars.is_system_stopped:
                         break
                     if domains and domain not in domains:
@@ -636,32 +658,28 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                                                         custom_words=custom_words_list)
                                 # 更新元数据缓存
                                 context.meta_info = torrent_meta
-                                # 媒体信息需要重新识别
-                                torrent_mediainfo = None
-
-                        # 先判断是否有没识别的种子，否则重新识别
-                        if not torrent_mediainfo \
-                                or (not torrent_mediainfo.tmdb_id and not torrent_mediainfo.douban_id):
-                            # 重新识别媒体信息
-                            torrent_mediainfo = self.recognize_media(meta=torrent_meta,
-                                                                     episode_group=subscribe.episode_group)
-                            if torrent_mediainfo:
-                                # 更新种子缓存
-                                context.media_info = torrent_mediainfo
-                            else:
-                                # 通过标题匹配兜底
-                                logger.warn(
-                                    f'{torrent_info.site_name} - {torrent_info.title} 重新识别失败，尝试通过标题匹配...')
-                                if self.torrenthelper.match_torrent(mediainfo=mediainfo,
-                                                                    torrent_meta=torrent_meta,
-                                                                    torrent=torrent_info):
-                                    # 匹配成功
-                                    logger.info(
-                                        f'{mediainfo.title_year} 通过标题匹配到可选资源：{torrent_info.site_name} - {torrent_info.title}')
-                                    torrent_mediainfo = mediainfo
+                                # 重新识别媒体信息
+                                torrent_mediainfo = self.recognize_media(meta=torrent_meta,
+                                                                         episode_group=subscribe.episode_group)
+                                if torrent_mediainfo:
+                                    # 更新种子缓存
                                     context.media_info = torrent_mediainfo
-                                else:
-                                    continue
+
+                        # 如果仍然没有识别到媒体信息，尝试标题匹配
+                        if not torrent_mediainfo or (not torrent_mediainfo.tmdb_id and not torrent_mediainfo.douban_id):
+                            logger.warn(
+                                f'{torrent_info.site_name} - {torrent_info.title} 重新识别失败，尝试通过标题匹配...')
+                            if self.torrenthelper.match_torrent(mediainfo=mediainfo,
+                                                                torrent_meta=torrent_meta,
+                                                                torrent=torrent_info):
+                                # 匹配成功
+                                logger.info(
+                                    f'{mediainfo.title_year} 通过标题匹配到可选资源：{torrent_info.site_name} - {torrent_info.title}')
+                                torrent_mediainfo = mediainfo
+                                # 更新种子缓存
+                                context.media_info = mediainfo
+                            else:
+                                continue
 
                         # 直接比对媒体信息
                         if torrent_mediainfo and (torrent_mediainfo.tmdb_id or torrent_mediainfo.douban_id):
@@ -1012,11 +1030,19 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
         else:
             link = settings.MP_DOMAIN('#/subscribe/movie?tab=mysub')
         # 完成订阅按规则发送消息
-        self.post_message(schemas.Notification(mtype=NotificationType.Subscribe,
-                                               title=f'{mediainfo.title_year} {meta.season} 已完成{msgstr}',
-                                               image=mediainfo.get_message_image(),
-                                               link=link,
-                                               username=subscribe.username))
+        self.post_message(
+            schemas.Notification(
+                mtype=NotificationType.Subscribe,
+                ctype=ContentType.SubscribeComplete,
+                image=mediainfo.get_message_image(),
+                link=link,
+                username=subscribe.username
+            ),
+            meta=meta,
+            mediainfo=mediainfo,
+            msgstr=msgstr,
+            username=subscribe.username
+        )
         # 发送事件
         EventManager().send_event(EventType.SubscribeComplete, {
             "subscribe_id": subscribe.id,

app/chain/system.py

@@ -10,6 +10,7 @@ from app.schemas import Notification, MessageChannel
 from app.utils.http import RequestUtils
 from app.utils.singleton import Singleton
 from app.utils.system import SystemUtils
+from helper.system import SystemHelper
 from version import FRONTEND_VERSION, APP_VERSION
 
 
@@ -45,7 +46,8 @@ class SystemChain(ChainBase, metaclass=Singleton):
                 "channel": channel.value,
                 "userid": userid
             }, self._restart_file)
-        SystemUtils.restart()
+        # 重启
+        SystemHelper.restart()
 
     def __get_version_message(self) -> str:
         """

app/chain/torrents.py

@@ -38,6 +38,15 @@ class TorrentsChain(ChainBase, metaclass=Singleton):
         self.mediachain = MediaChain()
         self.torrenthelper = TorrentHelper()
 
+    @property
+    def cache_file(self) -> str:
+        """
+        返回缓存文件列表
+        """
+        if settings.SUBSCRIBE_MODE == 'spider':
+            return self._spider_file
+        return self._rss_file
+
     def remote_refresh(self, channel: MessageChannel, userid: Union[str, int] = None):
         """
         远程刷新订阅，发送消息

app/chain/transfer.py

@@ -17,6 +17,7 @@ from app.core.config import settings, global_vars
 from app.core.context import MediaInfo
 from app.core.meta import MetaBase
 from app.core.metainfo import MetaInfoPath
+from app.core.event import eventmanager
 from app.db.downloadhistory_oper import DownloadHistoryOper
 from app.db.models.downloadhistory import DownloadHistory
 from app.db.models.transferhistory import TransferHistory
@@ -29,7 +30,8 @@ from app.log import logger
 from app.schemas import TransferInfo, TransferTorrent, Notification, EpisodeFormat, FileItem, TransferDirectoryConf, \
     TransferTask, TransferQueue, TransferJob, TransferJobTask
 from app.schemas.types import TorrentStatus, EventType, MediaType, ProgressKey, NotificationType, MessageChannel, \
-    SystemConfigKey
+    SystemConfigKey, ChainEventType, ContentType
+from app.schemas import StorageOperSelectionEventData
 from app.utils.singleton import Singleton
 from app.utils.string import StringUtils
 
@@ -699,10 +701,36 @@ class TransferChain(ChainBase, metaclass=Singleton):
                                                                          storage=task.fileitem.storage,
                                                                          src_path=Path(task.fileitem.path),
                                                                          target_storage=task.target_storage)
+            if not task.target_storage and task.target_directory:
+                task.target_storage = task.target_directory.library_storage
 
             # 正在处理
             self.jobview.running_task(task)
 
+            # 广播事件，请示额外的源存储支持
+            source_oper = None
+            source_event_data = StorageOperSelectionEventData(
+                storage=task.fileitem.storage,
+            )
+            source_event = eventmanager.send_event(ChainEventType.StorageOperSelection, source_event_data)
+            # 使用事件返回的上下文数据
+            if source_event and source_event.event_data:
+                source_event_data: StorageOperSelectionEventData = source_event.event_data
+                if source_event_data.storage_oper:
+                    source_oper = source_event_data.storage_oper
+
+            # 广播事件，请示额外的目标存储支持
+            target_oper = None
+            target_event_data = StorageOperSelectionEventData(
+                storage=task.target_storage,
+            )
+            target_event = eventmanager.send_event(ChainEventType.StorageOperSelection, target_event_data)
+            # 使用事件返回的上下文数据
+            if target_event and target_event.event_data:
+                target_event_data: StorageOperSelectionEventData = target_event.event_data
+                if target_event_data.storage_oper:
+                    target_oper = target_event_data.storage_oper
+
             # 执行整理
             transferinfo: TransferInfo = self.transfer(fileitem=task.fileitem,
                                                        meta=task.meta,
@@ -714,7 +742,9 @@ class TransferChain(ChainBase, metaclass=Singleton):
                                                        episodes_info=task.episodes_info,
                                                        scrape=task.scrape,
                                                        library_type_folder=task.library_type_folder,
-                                                       library_category_folder=task.library_category_folder)
+                                                       library_category_folder=task.library_category_folder,
+                                                       source_oper=source_oper,
+                                                       target_oper=target_oper)
             if not transferinfo:
                 logger.error("文件整理模块运行失败")
                 return False, "文件整理模块运行失败"
@@ -830,7 +860,7 @@ class TransferChain(ChainBase, metaclass=Singleton):
 
                 # 设置下载任务状态
                 if state:
-                    self.transfer_completed(hashs=torrent.hash)
+                    self.transfer_completed(hashs=torrent.hash, downloader=torrent.downloader)
 
             # 结束
             logger.info("所有下载器中下载完成的文件已整理完成")
@@ -1344,22 +1374,17 @@ class TransferChain(ChainBase, metaclass=Singleton):
         """
         发送入库成功的消息
         """
-        msg_title = f"{mediainfo.title_year} {meta.season_episode if not season_episode else season_episode} 已入库"
-        if mediainfo.vote_average:
-            msg_str = f"评分：{mediainfo.vote_average}，类型：{mediainfo.type.value}"
-        else:
-            msg_str = f"类型：{mediainfo.type.value}"
-        if mediainfo.category:
-            msg_str = f"{msg_str}，类别：{mediainfo.category}"
-        if meta.resource_term:
-            msg_str = f"{msg_str}，质量：{meta.resource_term}"
-        msg_str = f"{msg_str}，共{transferinfo.file_count}个文件，" \
-                  f"大小：{StringUtils.str_filesize(transferinfo.total_size)}"
-        if transferinfo.message:
-            msg_str = f"{msg_str}，以下文件处理失败：\n{transferinfo.message}"
-        # 发送
-        self.post_message(Notification(
-            mtype=NotificationType.Organize,
-            title=msg_title, text=msg_str, image=mediainfo.get_message_image(),
-            username=username,
-            link=settings.MP_DOMAIN('#/history')))
+        self.post_message(
+            Notification(
+                mtype=NotificationType.Organize,
+                ctype=ContentType.OrganizeSuccess,
+                image=mediainfo.get_message_image(),
+                username=username,
+                link=settings.MP_DOMAIN('#/history')
+            ),
+            meta=meta,
+            mediainfo=mediainfo,
+            transferinfo=transferinfo,
+            season_episode=season_episode,
+            username=username
+        )

app/chain/tvdb.py

@@ -0,0 +1,13 @@
+from typing import List
+from app.chain import ChainBase
+from app.utils.singleton import Singleton
+
+
+class TvdbChain(ChainBase, metaclass=Singleton):
+    """
+    Tvdb处理链，单例运行
+    """
+
+    def get_tvdbid_by_name(self, title: str) -> List[int]:
+        tvdb_info_list = self.run_module("search_tvdb", title=title)
+        return [int(item["tvdb_id"]) for item in tvdb_info_list]

app/core/config.py

@@ -1,11 +1,12 @@
 import copy
+import json
 import os
 import re
 import secrets
 import sys
 import threading
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Type
+from typing import Any, Dict, List, Optional, Tuple, Type, Union
 
 from dotenv import set_key
 from pydantic import BaseModel, BaseSettings, validator, Field
@@ -85,10 +86,12 @@ class ConfigModel(BaseModel):
     AUXILIARY_AUTH_ENABLE: bool = False
     # API密钥，需要更换
     API_TOKEN: Optional[str] = None
-    # 网络代理 IP:PORT
+    # 网络代理服务器地址
     PROXY_HOST: Optional[str] = None
     # 登录页面电影海报,tmdb/bing/mediaserver
     WALLPAPER: str = "tmdb"
+    # 自定义壁纸api地址
+    CUSTOMIZE_WALLPAPER_API_URL: Optional[str] = None
     # 媒体搜索来源 themoviedb/douban/bangumi，多个用,分隔
     SEARCH_SOURCE: str = "themoviedb,douban,bangumi"
     # 媒体识别来源 themoviedb/douban
@@ -101,10 +104,15 @@ class ConfigModel(BaseModel):
     TMDB_IMAGE_DOMAIN: str = "image.tmdb.org"
     # TMDB API地址
     TMDB_API_DOMAIN: str = "api.themoviedb.org"
+    # TMDB元数据语言
+    TMDB_LOCALE: str = "zh"
+    # 刮削使用TMDB原始语种图片
+    TMDB_SCRAP_ORIGINAL_IMAGE: bool = False
     # TMDB API Key
     TMDB_API_KEY: str = "db55323b8d3e4154498498a75642b381"
     # TVDB API Key
-    TVDB_API_KEY: str = "6b481081-10aa-440c-99f2-21d17717ee02"
+    TVDB_V4_API_KEY: str = "ed2aa66b-7899-4677-92a7-67bc9ce3d93a"
+    TVDB_V4_API_PIN: str = ""
     # Fanart开关
     FANART_ENABLE: bool = True
     # Fanart API Key
@@ -119,6 +127,8 @@ class ConfigModel(BaseModel):
     ANIME_GENREIDS = [16]
     # 用户认证站点
     AUTH_SITE: str = ""
+    # 重启自动升级
+    MOVIEPILOT_AUTO_UPDATE: str = 'release'
     # 自动检查和更新站点资源包（站点索引、认证等）
     AUTO_UPDATE_RESOURCE: bool = True
     # 是否启用DOH解析域名
@@ -212,7 +222,18 @@ class ConfigModel(BaseModel):
     PLUGIN_MARKET: str = ("https://github.com/jxxghp/MoviePilot-Plugins,"
                           "https://github.com/thsrite/MoviePilot-Plugins,"
                           "https://github.com/honue/MoviePilot-Plugins,"
-                          "https://github.com/InfinityPacer/MoviePilot-Plugins")
+                          "https://github.com/InfinityPacer/MoviePilot-Plugins,"
+                          "https://github.com/DDS-Derek/MoviePilot-Plugins,"
+                          "https://github.com/madrays/MoviePilot-Plugins,"
+                          "https://github.com/justzerock/MoviePilot-Plugins,"
+                          "https://github.com/KoWming/MoviePilot-Plugins,"
+                          "https://github.com/wikrin/MoviePilot-Plugins,"
+                          "https://github.com/HankunYu/MoviePilot-Plugins,"
+                          "https://github.com/baozaodetudou/MoviePilot-Plugins,"
+                          "https://github.com/Aqr-K/MoviePilot-Plugins,"
+                          "https://github.com/hotlcc/MoviePilot-Plugins-Third,"
+                          "https://github.com/gxterry/MoviePilot-Plugins,"
+                          "https://github.com/DzAvril/MoviePilot-Plugins")
     # 插件安装数据共享
     PLUGIN_STATISTIC_SHARE: bool = True
     # 是否开启插件热加载
@@ -237,6 +258,7 @@ class ConfigModel(BaseModel):
     SECURITY_IMAGE_DOMAINS: List[str] = Field(
         default_factory=lambda: ["image.tmdb.org",
                                  "static-mdb.v.geilijiasu.com",
+                                 "bing.com",
                                  "doubanio.com",
                                  "lain.bgm.tv",
                                  "raw.githubusercontent.com",
@@ -261,6 +283,8 @@ class ConfigModel(BaseModel):
     TOKENIZED_SEARCH: bool = False
     # 为指定默认字幕添加.default后缀
     DEFAULT_SUB: Optional[str] = "zh-cn"
+    # Docker Client API地址
+    DOCKER_CLIENT_API: Optional[str] = "tcp://127.0.0.1:38379"
 
 
 class Settings(BaseSettings, ConfigModel, LogConfigModel):
@@ -352,13 +376,16 @@ class Settings(BaseSettings, ConfigModel, LogConfigModel):
                 if field_name in fields_not_keep_spaces:
                     value = re.sub(r"\s+", "", value)
                 return value, str(value) != str(original_value)
-            # # 后续考虑支持 list 类型的处理
-            # elif expected_type is list:
-            #     if isinstance(value, list):
-            #         return value, False
-            #     if isinstance(value, str):
-            #         items = [item.strip() for item in value.split(",") if item.strip()]
-            #         return items, items != original_value.split(",")
+            # 支持 list 类型的处理
+            elif expected_type is list:
+                if isinstance(value, list):
+                    return value, str(value) != str(original_value)
+                if isinstance(value, str):
+                    items = json.loads(value)
+                    if isinstance(original_value, list):
+                        return items, items != original_value
+                    else:
+                        return items, str(items) != str(original_value)
             # 可根据需要添加更多类型处理
             else:
                 return value, str(value) != str(original_value)
@@ -399,7 +426,14 @@ class Settings(BaseSettings, ConfigModel, LogConfigModel):
             logger.warning(message)
             return False, message
         else:
-            set_key(SystemUtils.get_env_path(), field.name, str(converted_value) if converted_value is not None else "")
+            # 如果是列表、字典或集合类型，将其转换为JSON字符串
+            if isinstance(converted_value, (list, dict, set)):
+                value_to_write = json.dumps(converted_value)
+            else:
+                value_to_write = str(converted_value) if converted_value is not None else ""
+
+            set_key(dotenv_path=SystemUtils.get_env_path(), key_to_set=field.name, value_to_set=value_to_write,
+                    quote_mode="always")
             if is_converted:
                 logger.info(f"配置项 '{field.name}' 已自动修正并写入到 'app.env' 文件")
         return True, message
@@ -546,6 +580,7 @@ class Settings(BaseSettings, ConfigModel, LogConfigModel):
             return {
                 "server": self.PROXY_HOST
             }
+        return None
 
     @property
     def GITHUB_HEADERS(self):

app/core/meta/metabase.py

@@ -582,6 +582,12 @@ class MetaBase(object):
         # Part
         if not self.part:
             self.part = meta.part
+        # tmdbid
+        if not self.tmdbid and meta.tmdbid:
+            self.tmdbid = meta.tmdbid
+        # doubanid
+        if not self.doubanid and meta.doubanid:
+            self.doubanid = meta.doubanid
 
     def to_dict(self):
         """

app/core/meta/metavideo.py

@@ -31,7 +31,7 @@ class MetaVideo(MetaBase):
     _part_re = r"(^PART[0-9ABI]{0,2}$|^CD[0-9]{0,2}$|^DVD[0-9]{0,2}$|^DISK[0-9]{0,2}$|^DISC[0-9]{0,2}$)"
     _roman_numerals = r"^(?=[MDCLXVI])M*(C[MD]|D?C{0,3})(X[CL]|L?X{0,3})(I[XV]|V?I{0,3})$"
     _source_re = r"^BLURAY$|^HDTV$|^UHDTV$|^HDDVD$|^WEBRIP$|^DVDRIP$|^BDRIP$|^BLU$|^WEB$|^BD$|^HDRip$|^REMUX$|^UHD$"
-    _effect_re = r"^SDR$|^HDR\d*$|^DOLBY$|^DOVI$|^DV$|^3D$|^REPACK$"
+    _effect_re = r"^SDR$|^HDR\d*$|^DOLBY$|^DOVI$|^DV$|^3D$|^REPACK$|^HLG$|^HDR10(\+|Plus)$"
     _resources_type_re = r"%s|%s" % (_source_re, _effect_re)
     _name_no_begin_re = r"^[\[【].+?[\]】]"
     _name_no_chinese_re = r".*版|.*字幕"
@@ -50,8 +50,8 @@ class MetaVideo(MetaBase):
                         r"|CD[\s.]*[1-9]|DVD[\s.]*[1-9]|DISK[\s.]*[1-9]|DISC[\s.]*[1-9]|\s+GB"
     _resources_pix_re = r"^[SBUHD]*(\d{3,4}[PI]+)|\d{3,4}X(\d{3,4})"
     _resources_pix_re2 = r"(^[248]+K)"
-    _video_encode_re = r"^[HX]26[45]$|^AVC$|^HEVC$|^VC\d?$|^MPEG\d?$|^Xvid$|^DivX$|^HDR\d*$"
-    _audio_encode_re = r"^DTS\d?$|^DTSHD$|^DTSHDMA$|^Atmos$|^TrueHD\d?$|^AC3$|^\dAudios?$|^DDP\d?$|^DD\d?$|^LPCM\d?$|^AAC\d?$|^FLAC\d?$|^HD\d?$|^MA\d?$"
+    _video_encode_re = r"^(H26[45])$|^(x26[45])$|^AVC$|^HEVC$|^VC\d?$|^MPEG\d?$|^Xvid$|^DivX$|^AV1$|^HDR\d*$|^AVS(\+|[23])$"
+    _audio_encode_re = r"^DTS\d?$|^DTSHD$|^DTSHDMA$|^Atmos$|^TrueHD\d?$|^AC3$|^\dAudios?$|^DDP\d?$|^DD\+\d?$|^DD\d?$|^LPCM\d?$|^AAC\d?$|^FLAC\d?$|^HD\d?$|^MA\d?$|^HR\d?$|^Opus\d?$|^Vorbis\d?$"
 
     def __init__(self, title: str, subtitle: str = None, isfile: bool = False):
         """
@@ -592,7 +592,12 @@ class MetaVideo(MetaBase):
             self._stop_name_flag = True
             self._last_token_type = "videoencode"
             if not self.video_encode:
-                self.video_encode = re_res.group(1).upper()
+                if re_res.group(2):
+                    self.video_encode = re_res.group(2).upper()
+                elif re_res.group(3):
+                    self.video_encode = re_res.group(3).lower()
+                else:
+                    self.video_encode = re_res.group(1).upper()
                 self._last_token = self.video_encode
             elif self.video_encode == "10bit":
                 self.video_encode = f"{re_res.group(1).upper()} 10bit"

app/core/meta/releasegroup.py

@@ -15,32 +15,32 @@ class ReleaseGroupsMatcher(metaclass=Singleton):
         "0ff": ['FF(?:(?:A|WE)B|CD|E(?:DU|B)|TV)'],
         "1pt": [],
         "52pt": [],
-        "audiences": ['Audies', 'AD(?:Audio|E(?:|book)|Music|Web)'],
+        "audiences": ['Audies', 'AD(?:Audio|E(?:book|)|Music|Web)'],
         "azusa": [],
         "beitai": ['BeiTai'],
         "btschool": ['Bts(?:CHOOL|HD|PAD|TV)', 'Zone'],
         "carpt": ['CarPT'],
-        "chdbits": ['CHD(?:|Bits|PAD|(?:|HK)TV|WEB)', 'StBOX', 'OneHD', 'Lee', 'xiaopie'],
+        "chdbits": ['CHD(?:Bits|PAD|(?:|HK)TV|WEB|)', 'StBOX', 'OneHD', 'Lee', 'xiaopie'],
         "discfan": [],
         "dragonhd": [],
         "eastgame": ['(?:(?:iNT|(?:HALFC|Mini(?:S|H|FH)D))-|)TLF'],
         "filelist": [],
         "gainbound": ['(?:DG|GBWE)B'],
-        "hares": ['Hares(?:|(?:M|T)V|Web)'],
+        "hares": ['Hares(?:(?:M|T)V|Web|)'],
         "hd4fans": [],
         "hdarea": ['HDA(?:pad|rea|TV)', 'EPiC'],
         "hdatmos": [],
         "hdbd": [],
-        "hdchina": ['HDC(?:|hina|TV)', 'k9611', 'tudou', 'iHD'],
+        "hdchina": ['HDC(?:hina|TV|)', 'k9611', 'tudou', 'iHD'],
         "hddolby": ['D(?:ream|BTV)', '(?:HD|QHstudI)o'],
-        "hdfans": ['beAst(?:|TV)'],
-        "hdhome": ['HDH(?:|ome|Pad|TV|WEB)'],
-        "hdpt": ['HDPT(?:|Web)'],
-        "hdsky": ['HDS(?:|ky|TV|Pad|WEB)', 'AQLJ'],
+        "hdfans": ['beAst(?:TV|)'],
+        "hdhome": ['HDH(?:ome|Pad|TV|WEB|)'],
+        "hdpt": ['HDPT(?:Web|)'],
+        "hdsky": ['HDS(?:ky|TV|Pad|WEB|)', 'AQLJ'],
         "hdtime": [],
         "HDU": [],
         "hdvideo": [],
-        "hdzone": ['HDZ(?:|one)'],
+        "hdzone": ['HDZ(?:one|)'],
         "hhanclub": ['HHWEB'],
         "hitpt": [],
         "htpt": ['HTPT'],
@@ -48,34 +48,36 @@ class ReleaseGroupsMatcher(metaclass=Singleton):
         "joyhd": [],
         "keepfrds": ['FRDS', 'Yumi', 'cXcY'],
         "lemonhd": ['L(?:eague(?:(?:C|H)D|(?:M|T)V|NF|WEB)|HD)', 'i18n', 'CiNT'],
-        "mteam": ['MTeam(?:|TV)', 'MPAD'],
+        "mteam": ['MTeam(?:TV|)', 'MPAD'],
         "nanyangpt": [],
         "nicept": [],
         "oshen": [],
         "ourbits": ['Our(?:Bits|TV)', 'FLTTH', 'Ao', 'PbK', 'MGs', 'iLove(?:HD|TV)'],
         "piggo": ['PiGo(?:NF|(?:H|WE)B)'],
         "ptchina": [],
-        "pterclub": ['PTer(?:|DIY|Game|(?:M|T)V|WEB)'],
-        "pthome": ['PTH(?:|Audio|eBook|music|ome|tv|WEB)'],
+        "pterclub": ['PTer(?:DIY|Game|(?:M|T)V|WEB|)'],
+        "pthome": ['PTH(?:Audio|eBook|music|ome|tv|WEB|)'],
         "ptmsg": [],
         "ptsbao": ['PTsbao', 'OPS', 'F(?:Fans(?:AIeNcE|BD|D(?:VD|IY)|TV|WEB)|HDMv)', 'SGXT'],
         "pttime": [],
         "putao": ['PuTao'],
         "soulvoice": [],
-        "springsunday": ['CMCT(?:|V)'],
-        "sharkpt": ['Shark(?:|WEB|DIY|TV|MV)'],
+        "springsunday": ['CMCT(?:V|)'],
+        "sharkpt": ['Shark(?:WEB|DIY|TV|MV|)'],
         "tccf": [],
         "tjupt": ['TJUPT'],
         "totheglory": ['TTG', 'WiKi', 'NGB', 'DoA', '(?:ARi|ExRE)N'],
         "U2": [],
         "ultrahd": [],
-        "others": ['B(?:MDru|eyondHD|TN)', 'C(?:fandora|trlhd|MRG)', 'DON', 'EVO', 'FLUX', 'HONE(?:|yG)',
-                   'N(?:oGroup|T(?:b|G))', 'PandaMoon', 'SMURF', 'T(?:EPES|aengoo|rollHD )', 'UBWEB'],
+        "others": ['B(?:MDru|eyondHD|TN)', 'C(?:fandora|trlhd|MRG)', 'DON', 'EVO', 'FLUX', 'HONE(?:yG|)',
+                   'N(?:oGroup|T(?:b|G))', 'PandaMoon', 'SMURF', 'T(?:EPES|aengoo|rollHD )',],
         "anime": ['ANi', 'HYSUB', 'KTXP', 'LoliHouse', 'MCE', 'Nekomoe kissaten', 'SweetSub', 'MingY',
                   '(?:Lilith|NC)-Raws', '织梦字幕组', '枫叶字幕组', '猎户手抄部', '喵萌奶茶屋', '漫猫字幕社',
                   '霜庭云花Sub', '北宇治字幕组', '氢气烤肉架', '云歌字幕组', '萌樱字幕组', '极影字幕社',
                   '悠哈璃羽字幕社',
-                  '❀拨雪寻春❀', '沸羊羊(?:制作|字幕组)', '(?:桜|樱)都字幕组']
+                  '❀拨雪寻春❀', '沸羊羊(?:制作|字幕组)', '(?:桜|樱)都字幕组'],
+        "forge": ['FROG(?:E|Web|)'],
+        "ubits": ['UB(?:its|WEB|TV)'],
     }
 
     def __init__(self):
@@ -97,13 +99,15 @@ class ReleaseGroupsMatcher(metaclass=Singleton):
         if not groups:
             # 自定义组
             custom_release_groups = self.systemconfig.get(SystemConfigKey.CustomReleaseGroups)
+            if isinstance(custom_release_groups, list):
+                custom_release_groups = list(filter(None, custom_release_groups))
             if custom_release_groups:
                 custom_release_groups_str = '|'.join(custom_release_groups)
                 groups = f"{self.__release_groups}|{custom_release_groups_str}"
             else:
                 groups = self.__release_groups
         title = f"{title} "
-        groups_re = re.compile(r"(?<=[-@\[￡【&])(?:%s)(?=[@.\s\]\[】&])" % groups, re.I)
+        groups_re = re.compile(r"(?<=[-@\[￡【&])(?:%s)(?=[@.\s\S\]\[】&])" % groups, re.I)
         # 处理一个制作组识别多次的情况，保留顺序
         unique_groups = []
         for item in re.findall(groups_re, title):

app/core/metainfo.py

@@ -120,41 +120,69 @@ def find_metainfo(title: str) -> Tuple[str, dict]:
         return title, metainfo
     # 从标题中提取媒体信息 格式为{[tmdbid=xxx;type=xxx;s=xxx;e=xxx]}
     results = re.findall(r'(?<={\[)[\W\w]+(?=]})', title)
-    if not results:
-        return title, metainfo
-    for result in results:
-        # 查找tmdbid信息
-        tmdbid = re.findall(r'(?<=tmdbid=)\d+', result)
-        if tmdbid and tmdbid[0].isdigit():
-            metainfo['tmdbid'] = tmdbid[0]
-        # 查找豆瓣id信息
-        doubanid = re.findall(r'(?<=doubanid=)\d+', result)
-        if doubanid and doubanid[0].isdigit():
-            metainfo['doubanid'] = doubanid[0]
-        # 查找媒体类型
-        mtype = re.findall(r'(?<=type=)\w+', result)
-        if mtype:
-            if mtype[0] == "movies":
-                metainfo['type'] = MediaType.MOVIE
-            elif mtype[0] == "tv":
-                metainfo['type'] = MediaType.TV
-        # 查找季信息
-        begin_season = re.findall(r'(?<=s=)\d+', result)
-        if begin_season and begin_season[0].isdigit():
-            metainfo['begin_season'] = int(begin_season[0])
-        end_season = re.findall(r'(?<=s=\d+-)\d+', result)
-        if end_season and end_season[0].isdigit():
-            metainfo['end_season'] = int(end_season[0])
-        # 查找集信息
-        begin_episode = re.findall(r'(?<=e=)\d+', result)
-        if begin_episode and begin_episode[0].isdigit():
-            metainfo['begin_episode'] = int(begin_episode[0])
-        end_episode = re.findall(r'(?<=e=\d+-)\d+', result)
-        if end_episode and end_episode[0].isdigit():
-            metainfo['end_episode'] = int(end_episode[0])
-        # 去除title中该部分
-        if tmdbid or mtype or begin_season or end_season or begin_episode or end_episode:
-            title = title.replace(f"{{[{result}]}}", '')
+    if results:
+        for result in results:
+            # 查找tmdbid信息
+            tmdbid = re.findall(r'(?<=tmdbid=)\d+', result)
+            if tmdbid and tmdbid[0].isdigit():
+                metainfo['tmdbid'] = tmdbid[0]
+            # 查找豆瓣id信息
+            doubanid = re.findall(r'(?<=doubanid=)\d+', result)
+            if doubanid and doubanid[0].isdigit():
+                metainfo['doubanid'] = doubanid[0]
+            # 查找媒体类型
+            mtype = re.findall(r'(?<=type=)\w+', result)
+            if mtype:
+                if mtype[0] == "movies":
+                    metainfo['type'] = MediaType.MOVIE
+                elif mtype[0] == "tv":
+                    metainfo['type'] = MediaType.TV
+            # 查找季信息
+            begin_season = re.findall(r'(?<=s=)\d+', result)
+            if begin_season and begin_season[0].isdigit():
+                metainfo['begin_season'] = int(begin_season[0])
+            end_season = re.findall(r'(?<=s=\d+-)\d+', result)
+            if end_season and end_season[0].isdigit():
+                metainfo['end_season'] = int(end_season[0])
+            # 查找集信息
+            begin_episode = re.findall(r'(?<=e=)\d+', result)
+            if begin_episode and begin_episode[0].isdigit():
+                metainfo['begin_episode'] = int(begin_episode[0])
+            end_episode = re.findall(r'(?<=e=\d+-)\d+', result)
+            if end_episode and end_episode[0].isdigit():
+                metainfo['end_episode'] = int(end_episode[0])
+            # 去除title中该部分
+            if tmdbid or mtype or begin_season or end_season or begin_episode or end_episode:
+                title = title.replace(f"{{[{result}]}}", '')
+    
+    # 支持Emby格式的ID标签
+    # 1. [tmdbid=xxxx] 或 [tmdbid-xxxx] 格式
+    tmdb_match = re.search(r'\[tmdbid[=\-](\d+)\]', title)
+    if tmdb_match:
+        metainfo['tmdbid'] = tmdb_match.group(1)
+        title = re.sub(r'\[tmdbid[=\-](\d+)\]', '', title).strip()
+    
+    # 2. [tmdb=xxxx] 或 [tmdb-xxxx] 格式
+    if not metainfo['tmdbid']:
+        tmdb_match = re.search(r'\[tmdb[=\-](\d+)\]', title)
+        if tmdb_match:
+            metainfo['tmdbid'] = tmdb_match.group(1)
+            title = re.sub(r'\[tmdb[=\-](\d+)\]', '', title).strip()
+    
+    # 3. {tmdbid=xxxx} 或 {tmdbid-xxxx} 格式
+    if not metainfo['tmdbid']:
+        tmdb_match = re.search(r'\{tmdbid[=\-](\d+)\}', title)
+        if tmdb_match:
+            metainfo['tmdbid'] = tmdb_match.group(1)
+            title = re.sub(r'\{tmdbid[=\-](\d+)\}', '', title).strip()
+    
+    # 4. {tmdb=xxxx} 或 {tmdb-xxxx} 格式
+    if not metainfo['tmdbid']:
+        tmdb_match = re.search(r'\{tmdb[=\-](\d+)\}', title)
+        if tmdb_match:
+            metainfo['tmdbid'] = tmdb_match.group(1)
+            title = re.sub(r'\{tmdb[=\-](\d+)\}', '', title).strip()
+    
     # 计算季集总数
     if metainfo.get('begin_season') and metainfo.get('end_season'):
         if metainfo['begin_season'] > metainfo['end_season']:
@@ -169,3 +197,67 @@ def find_metainfo(title: str) -> Tuple[str, dict]:
     elif metainfo.get('begin_episode') and not metainfo.get('end_episode'):
         metainfo['total_episode'] = 1
     return title, metainfo
+
+
+def test_find_metainfo():
+    """
+    测试find_metainfo函数的各种ID识别格式
+    """
+    test_cases = [
+        # 测试 [tmdbid=xxxx] 格式
+        ("The Vampire Diaries (2009) [tmdbid=18165]", "18165"),
+        # 测试 [tmdbid-xxxx] 格式
+        ("Inception (2010) [tmdbid-27205]", "27205"),
+        # 测试 [tmdb=xxxx] 格式
+        ("Breaking Bad (2008) [tmdb=1396]", "1396"),
+        # 测试 [tmdb-xxxx] 格式
+        ("Interstellar (2014) [tmdb-157336]", "157336"),
+        # 测试 {tmdbid=xxxx} 格式
+        ("Stranger Things (2016) {tmdbid=66732}", "66732"),
+        # 测试 {tmdbid-xxxx} 格式
+        ("The Matrix (1999) {tmdbid-603}", "603"),
+        # 测试 {tmdb=xxxx} 格式
+        ("Game of Thrones (2011) {tmdb=1399}", "1399"),
+        # 测试 {tmdb-xxxx} 格式
+        ("Avatar (2009) {tmdb-19995}", "19995"),
+    ]
+    
+    for title, expected_tmdbid in test_cases:
+        cleaned_title, metainfo = find_metainfo(title)
+        found_tmdbid = metainfo.get('tmdbid')
+        
+        print(f"原标题: {title}")
+        print(f"清理后标题: {cleaned_title}")
+        print(f"期望的tmdbid: {expected_tmdbid}")
+        print(f"识别的tmdbid: {found_tmdbid}")
+        print(f"结果: {'通过' if found_tmdbid == expected_tmdbid else '失败'}")
+        print("-" * 50)
+
+
+def test_meta_info_path():
+    """
+    测试MetaInfoPath函数
+    """
+    # 测试文件路径
+    path_tests = [
+        # 文件名中包含tmdbid
+        Path("/movies/The Vampire Diaries (2009) [tmdbid=18165]/The.Vampire.Diaries.S01E01.1080p.mkv"),
+        # 目录名中包含tmdbid
+        Path("/movies/Inception (2010) [tmdbid-27205]/Inception.2010.1080p.mkv"),
+        # 父目录名中包含tmdbid
+        Path("/movies/Breaking Bad (2008) [tmdb=1396]/Season 1/Breaking.Bad.S01E01.1080p.mkv"),
+        # 祖父目录名中包含tmdbid
+        Path("/tv/Game of Thrones (2011) {tmdb=1399}/Season 1/Game.of.Thrones.S01E01.1080p.mkv"),
+    ]
+    
+    for path in path_tests:
+        meta = MetaInfoPath(path)
+        print(f"测试路径: {path}")
+        print(f"识别结果: tmdbid={meta.tmdbid}")
+        print("-" * 50)
+
+
+if __name__ == "__main__":
+    # 运行测试函数
+    # test_find_metainfo()
+    test_meta_info_path()

app/core/plugin.py

@@ -7,8 +7,10 @@ import time
 import traceback
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union
+from typing import Any, Dict, List, Optional, Type, Union, Callable, Tuple
 
+from fastapi import HTTPException
+from starlette import status
 from watchdog.events import FileSystemEventHandler
 from watchdog.observers import Observer
 
@@ -202,24 +204,43 @@ class PluginManager(metaclass=Singleton):
         # 停止插件
         if pid:
             logger.info(f"正在停止插件 {pid}...")
+            plugin_obj = self._running_plugins.get(pid)
+            if not plugin_obj:
+                logger.warning(f"插件 {pid} 不存在或未加载")
+                return
+            plugins = {pid: plugin_obj}
         else:
             logger.info("正在停止所有插件...")
-        for plugin_id, plugin in self._running_plugins.items():
-            if pid and plugin_id != pid:
-                continue
+            plugins = self._running_plugins
+        for plugin_id, plugin in plugins.items():
             eventmanager.disable_event_handler(type(plugin))
             self.__stop_plugin(plugin)
         # 清空对像
         if pid:
             # 清空指定插件
-            if pid in self._running_plugins:
-                self._running_plugins.pop(pid)
+            self._running_plugins.pop(pid, None)
         else:
             # 清空
             self._plugins = {}
             self._running_plugins = {}
         logger.info("插件停止完成")
 
+    @property
+    def running_plugins(self) -> Dict[str, Any]:
+        """
+        获取运行态插件列表
+        :return: 运行态插件列表
+        """
+        return self._running_plugins
+
+    @property
+    def plugins(self) -> Dict[str, Any]:
+        """
+        获取插件列表
+        :return: 插件列表
+        """
+        return self._plugins
+
     def reload_monitor(self):
         """
         重新加载插件文件修改监测
@@ -386,7 +407,8 @@ class PluginManager(metaclass=Singleton):
         """
         if not self._plugins.get(pid):
             return False
-        return self.systemconfig.set(self._config_key % pid, conf)
+        self.systemconfig.set(self._config_key % pid, conf)
+        return True
 
     def delete_plugin_config(self, pid: str) -> bool:
         """
@@ -407,68 +429,6 @@ class PluginManager(metaclass=Singleton):
         self.plugindata.del_data(pid)
         return True
 
-    def get_plugin_form(self, pid: str) -> Tuple[List[dict], Dict[str, Any]]:
-        """
-        获取插件表单
-        :param pid: 插件ID
-        """
-        plugin = self._running_plugins.get(pid)
-        if not plugin:
-            return [], {}
-        if hasattr(plugin, "get_form"):
-            return plugin.get_form() or ([], {})
-        return [], {}
-
-    def get_plugin_page(self, pid: str) -> List[dict]:
-        """
-        获取插件页面
-        :param pid: 插件ID
-        """
-        plugin = self._running_plugins.get(pid)
-        if not plugin:
-            return []
-        if hasattr(plugin, "get_page"):
-            return plugin.get_page() or []
-        return []
-
-    def get_plugin_dashboard(self, pid: str, key: Optional[str] = None, **kwargs) -> Optional[schemas.PluginDashboard]:
-        """
-        获取插件仪表盘
-        :param pid: 插件ID
-        :param key: 仪表盘key
-        """
-
-        def __get_params_count(func: Callable):
-            """
-            获取函数的参数信息
-            """
-            signature = inspect.signature(func)
-            return len(signature.parameters)
-
-        plugin = self._running_plugins.get(pid)
-        if not plugin:
-            return None
-        if hasattr(plugin, "get_dashboard"):
-            # 检查方法的参数个数
-            params_count = __get_params_count(plugin.get_dashboard)
-            if params_count > 1:
-                dashboard: Tuple = plugin.get_dashboard(key=key, **kwargs)
-            elif params_count > 0:
-                dashboard: Tuple = plugin.get_dashboard(**kwargs)
-            else:
-                dashboard: Tuple = plugin.get_dashboard()
-            if dashboard:
-                cols, attrs, elements = dashboard
-                return schemas.PluginDashboard(
-                    id=pid,
-                    name=plugin.plugin_name,
-                    key=key or "",
-                    cols=cols or {},
-                    elements=elements,
-                    attrs=attrs or {}
-                )
-        return None
-
     def get_plugin_state(self, pid: str) -> bool:
         """
         获取插件状态
@@ -517,16 +477,20 @@ class PluginManager(metaclass=Singleton):
         }]
         """
         ret_apis = []
-        for plugin_id, plugin in self._running_plugins.items():
+        if pid:
+            plugins = {pid: self._running_plugins.get(pid)}
+        else:
+            plugins = self._running_plugins
+        for plugin_id, plugin in plugins.items():
             if pid and pid != plugin_id:
                 continue
             if hasattr(plugin, "get_api") and ObjectUtils.check_method(plugin.get_api):
                 try:
-                    if not plugin.get_state():
-                        continue
                     apis = plugin.get_api() or []
                     for api in apis:
                         api["path"] = f"/{plugin_id}{api['path']}"
+                        if not api.get("auth"):
+                            api["auth"] = "apikey"
                     ret_apis.extend(apis)
                 except Exception as e:
                     logger.error(f"获取插件 {plugin_id} API出错：{str(e)}")
@@ -558,7 +522,92 @@ class PluginManager(metaclass=Singleton):
                     logger.error(f"获取插件 {plugin_id} 服务出错：{str(e)}")
         return ret_services
 
-    def get_plugin_dashboard_meta(self):
+    def get_plugin_modules(self, pid: Optional[str] = None) -> Dict[tuple, Dict[str, Any]]:
+        """
+        获取插件模块
+        {
+            plugin_id: {
+                method: function
+            }
+        }
+        """
+        ret_modules = {}
+        for plugin_id, plugin in self._running_plugins.items():
+            if pid and pid != plugin_id:
+                continue
+            if hasattr(plugin, "get_module") and ObjectUtils.check_method(plugin.get_module):
+                try:
+                    if not plugin.get_state():
+                        continue
+                    plugin_module = plugin.get_module() or []
+                    ret_modules[(plugin_id, plugin.get_name())] = plugin_module
+                except Exception as e:
+                    logger.error(f"获取插件 {plugin_id} 模块出错：{str(e)}")
+        return ret_modules
+
+    def get_plugin_actions(self, pid: Optional[str] = None) -> List[Dict[str, Any]]:
+        """
+        获取插件动作
+        [{
+            "id": "动作ID",
+            "name": "动作名称",
+            "func": self.xxx,
+            "kwargs": {} # 需要附加传递的参数
+        }]
+        """
+        ret_actions = []
+        for plugin_id, plugin in self._running_plugins.items():
+            if pid and pid != plugin_id:
+                continue
+            if hasattr(plugin, "get_actions") and ObjectUtils.check_method(plugin.get_actions):
+                try:
+                    if not plugin.get_state():
+                        continue
+                    actions = plugin.get_actions()
+                    if actions:
+                        ret_actions.append({
+                            "plugin_id": plugin_id,
+                            "plugin_name": plugin.plugin_name,
+                            "actions": actions
+                        })
+                except Exception as e:
+                    logger.error(f"获取插件 {plugin_id} 动作出错：{str(e)}")
+        return ret_actions
+
+    @staticmethod
+    def get_plugin_remote_entry(plugin_id: str, dist_path: str) -> str:
+        """
+        获取插件的远程入口地址
+        :param plugin_id: 插件 ID
+        :param dist_path: 插件的分发路径
+        :return: 远程入口地址
+        """
+        if dist_path.startswith("/"):
+            dist_path = dist_path[1:]
+        if dist_path.endswith("/"):
+            dist_path = dist_path[:-1]
+        return f"/plugin/file/{plugin_id.lower()}/{dist_path}/remoteEntry.js"
+
+    def get_plugin_remotes(self, pid: Optional[str] = None) -> List[Dict[str, Any]]:
+        """
+        获取插件联邦组件列表
+        """
+        remotes = []
+        for plugin_id, plugin in self._running_plugins.items():
+            if pid and pid != plugin_id:
+                continue
+            if hasattr(plugin, "get_render_mode"):
+                render_mode, dist_path = plugin.get_render_mode()
+                if render_mode != "vue":
+                    continue
+                remotes.append({
+                    "id": plugin_id,
+                    "url": self.get_plugin_remote_entry(plugin_id, dist_path),
+                    "name": plugin.plugin_name,
+                })
+        return remotes
+
+    def get_plugin_dashboard_meta(self) -> List[Dict[str, str]]:
         """
         获取所有插件仪表盘元信息
         """
@@ -588,6 +637,50 @@ class PluginManager(metaclass=Singleton):
                 logger.error(f"获取插件[{plugin_id}]仪表盘元数据出错：{str(e)}")
         return dashboard_meta
 
+    def get_plugin_dashboard(self, pid: str, key: str, user_agent: str = None) -> schemas.PluginDashboard:
+        """
+        获取插件仪表盘
+        """
+
+        def __get_params_count(func: Callable):
+            """
+            获取函数的参数信息
+            """
+            signature = inspect.signature(func)
+            return len(signature.parameters)
+
+        # 获取插件实例
+        plugin_instance = self.running_plugins.get(pid)
+        if not plugin_instance:
+            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"插件 {pid} 不存在或未加载")
+
+        # 渲染模式
+        render_mode, _ = plugin_instance.get_render_mode()
+        # 获取插件仪表板
+        try:
+            # 检查方法的参数个数
+            params_count = __get_params_count(plugin_instance.get_dashboard)
+            if params_count > 1:
+                dashboard: Tuple = plugin_instance.get_dashboard(key=key, user_agent=user_agent)
+            elif params_count > 0:
+                dashboard: Tuple = plugin_instance.get_dashboard(user_agent=user_agent)
+            else:
+                dashboard: Tuple = plugin_instance.get_dashboard()
+        except Exception as e:
+            logger.error(f"插件 {pid} 调用方法 get_dashboard 出错: {str(e)}")
+            raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                                detail=f"插件 {pid} 调用方法 get_dashboard 出错: {str(e)}")
+        cols, attrs, elements = dashboard
+        return schemas.PluginDashboard(
+            id=pid,
+            name=plugin_instance.plugin_name,
+            key=key,
+            render_mode=render_mode,
+            cols=cols or {},
+            attrs=attrs or {},
+            elements=elements
+        )
+
     def get_plugin_attr(self, pid: str, attr: str) -> Any:
         """
         获取插件属性
@@ -781,7 +874,8 @@ class PluginManager(metaclass=Singleton):
             logger.debug(f"获取插件是否在本地包中存在失败，{e}")
             return False
 
-    def get_plugins_from_market(self, market: str, package_version: Optional[str] = None) -> Optional[List[schemas.Plugin]]:
+    def get_plugins_from_market(self, market: str,
+                                package_version: Optional[str] = None) -> Optional[List[schemas.Plugin]]:
         """
         从指定的市场获取插件信息
         :param market: 市场的 URL 或标识
@@ -795,7 +889,8 @@ class PluginManager(metaclass=Singleton):
         # 获取在线插件
         online_plugins = self.pluginhelper.get_plugins(market, package_version)
         if online_plugins is None:
-            logger.warning(f"获取{package_version if package_version else ''}插件库失败：{market}，请检查 GitHub 网络连接")
+            logger.warning(
+                f"获取{package_version if package_version else ''}插件库失败：{market}，请检查 GitHub 网络连接")
             return []
         ret_plugins = []
         add_time = len(online_plugins)
@@ -930,3 +1025,333 @@ class PluginManager(metaclass=Singleton):
         except Exception as e:
             logger.debug(f"获取插件 {plugin_id} 的私钥时发生错误：{e}")
             return None
+
+    def clone_plugin(self, plugin_id: str, suffix: str, name: str, description: str,
+                     version: str = None, icon: str = None) -> Tuple[bool, str]:
+        """
+        创建插件分身
+        :param plugin_id: 原插件ID
+        :param suffix: 分身后缀
+        :param name: 分身名称
+        :param description: 分身描述
+        :param version: 自定义版本号
+        :param icon: 自定义图标URL
+        :return: (是否成功, 错误信息)
+        """
+        try:
+            # 验证参数
+            if not plugin_id or not suffix:
+                return False, "插件ID和分身后缀不能为空"
+
+            # 检查原插件是否存在
+            if plugin_id not in self._plugins:
+                return False, f"原插件 {plugin_id} 不存在"
+
+            # 生成分身插件ID
+            clone_id = f"{plugin_id}{suffix.lower()}"
+
+            # 检查分身插件是否已存在
+            if self.is_plugin_exists(clone_id):
+                return False, f"分身插件 {clone_id} 已存在"
+
+            # 获取原插件目录
+            original_plugin_dir = Path(settings.ROOT_PATH) / "app" / "plugins" / plugin_id.lower()
+            if not original_plugin_dir.exists():
+                return False, f"原插件目录 {original_plugin_dir} 不存在"
+
+            # 创建分身插件目录
+            clone_plugin_dir = Path(settings.ROOT_PATH) / "app" / "plugins" / clone_id.lower()
+
+            # 复制插件目录
+            import shutil
+            shutil.copytree(original_plugin_dir, clone_plugin_dir)
+            logger.info(f"已复制插件目录：{original_plugin_dir} -> {clone_plugin_dir}")
+
+            # 修改插件文件内容
+            success, msg = self._modify_plugin_files(
+                plugin_dir=clone_plugin_dir,
+                original_id=plugin_id,
+                suffix=suffix,
+                name=name,
+                description=description,
+                version=version,
+                icon=icon
+            )
+
+            if not success:
+                # 如果修改失败，清理已创建的目录
+                if clone_plugin_dir.exists():
+                    shutil.rmtree(clone_plugin_dir)
+                return False, msg
+
+            # 将分身插件添加到已安装列表
+            installed_plugins = self.systemconfig.get(SystemConfigKey.UserInstalledPlugins) or []
+            if clone_id not in installed_plugins:
+                installed_plugins.append(clone_id)
+                self.systemconfig.set(SystemConfigKey.UserInstalledPlugins, installed_plugins)
+
+            # 为分身插件创建初始配置（从原插件复制配置）
+            logger.info(f"正在为分身插件 {clone_id} 创建初始配置...")
+            original_config = self.get_plugin_config(plugin_id)
+            if original_config:
+                # 复制原插件配置作为分身插件的初始配置
+                clone_config = original_config.copy()
+                # 可以在这里修改一些默认值，比如禁用分身插件
+                # 默认禁用分身插件，让用户手动配置
+                clone_config['enable'] = False
+                clone_config['enabled'] = False
+                self.save_plugin_config(clone_id, clone_config)
+                logger.info(f"已为分身插件 {clone_id} 设置初始配置")
+            else:
+                logger.info(f"原插件 {plugin_id} 没有配置，分身插件 {clone_id} 将使用默认配置")
+
+            # 注册分身插件的API和服务
+            logger.info(f"正在注册分身插件 {clone_id} ...")
+            PluginManager().reload_plugin(clone_id)
+            # 确保分身插件正确初始化配置
+            if clone_id in self._running_plugins:
+                clone_instance = self._running_plugins[clone_id]
+                clone_config = self.get_plugin_config(clone_id)
+                if clone_config:
+                    logger.info(f"正在为分身插件 {clone_id} 重新初始化配置...")
+                    clone_instance.init_plugin(clone_config)
+                    logger.info(f"分身插件 {clone_id} 配置重新初始化完成")
+
+            logger.info(f"插件分身 {clone_id} 创建成功")
+            return True, clone_id
+
+        except Exception as e:
+            logger.error(f"创建插件分身失败：{str(e)}")
+            return False, f"创建插件分身失败：{str(e)}"
+
+    def _modify_plugin_files(self, plugin_dir: Path, original_id: str, suffix: str,
+                             name: str, description: str, version: str = None,
+                             icon: str = None) -> Tuple[bool, str]:
+        """
+        修改插件文件中的类名和相关信息
+        :param plugin_dir: 插件目录
+        :param original_id: 原插件ID
+        :param suffix: 分身后缀
+        :param name: 分身名称
+        :param description: 分身描述
+        :param version: 自定义版本号
+        :param icon: 自定义图标URL
+        :return: (是否成功, 错误信息)
+        """
+        try:
+            # 获取原插件类
+            original_plugin_class = self._plugins.get(original_id)
+            if not original_plugin_class:
+                return False, f"无法获取原插件类 {original_id}"
+
+            # 获取原类名
+            original_class_name = original_plugin_class.__name__
+            clone_class_name = f"{original_class_name}{suffix}"
+
+            # 修改 __init__.py 文件
+            init_file = plugin_dir / "__init__.py"
+            if init_file.exists():
+                success, msg = self._modify_python_file(
+                    file_path=init_file,
+                    original_class_name=original_class_name,
+                    clone_class_name=clone_class_name,
+                    name=name,
+                    description=description,
+                    version=version,
+                    icon=icon
+                )
+                if not success:
+                    return False, msg
+
+            # 检查是否为联邦插件（存在dist目录）
+            dist_dir = plugin_dir / "dist"
+            if dist_dir.exists():
+                success, msg = self._modify_federation_files(
+                    dist_dir=dist_dir,
+                    original_class_name=original_class_name,
+                    clone_class_name=clone_class_name
+                )
+                if not success:
+                    return False, msg
+
+            return True, "文件修改成功"
+
+        except Exception as e:
+            logger.error(f"修改插件文件失败：{str(e)}")
+            return False, f"修改插件文件失败：{str(e)}"
+
+    @staticmethod
+    def _modify_python_file(file_path: Path, original_class_name: str,
+                            clone_class_name: str, name: str, description: str,
+                            version: str = None, icon: str = None) -> Tuple[bool, str]:
+        """
+        修改Python文件中的类名和插件信息
+        """
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+
+            # 替换类名
+            content = content.replace(f"class {original_class_name}", f"class {clone_class_name}")
+
+            # 替换插件名称和描述
+            import re
+
+            # 替换 plugin_name
+            if name:
+                content = re.sub(
+                    r'plugin_name\s*=\s*["\'][^"\']*["\']',
+                    f'plugin_name = "{name}"',
+                    content
+                )
+
+            # 替换 plugin_desc
+            if description:
+                content = re.sub(
+                    r'plugin_desc\s*=\s*["\'][^"\']*["\']',
+                    f'plugin_desc = "{description}"',
+                    content
+                )
+
+            # 替换 plugin_config_prefix（如果存在）
+            content = re.sub(
+                r'plugin_config_prefix\s*=\s*["\'][^"\']*["\']',
+                f'plugin_config_prefix = "{clone_class_name.lower()}_"',
+                content
+            )
+
+            # 替换 plugin_version（如果提供了自定义版本）
+            if version:
+                content = re.sub(
+                    r'plugin_version\s*=\s*["\'][^"\']*["\']',
+                    f'plugin_version = "{version}"',
+                    content
+                )
+
+            # 替换 plugin_icon（如果提供了自定义图标）
+            if icon and icon.strip():
+                old_content = content
+                content = re.sub(
+                    r'plugin_icon\s*=\s*["\'][^"\']*["\']',
+                    f'plugin_icon = "{icon}"',
+                    content
+                )
+                if old_content != content:
+                    logger.info(f"已替换插件图标为: {icon}")
+                else:
+                    logger.warning(f"插件图标替换失败，未找到匹配的图标设置")
+            else:
+                logger.info("未提供自定义图标，保持原插件图标")
+
+            # 添加分身标志
+            if "def init_plugin(self" in content:
+                init_index = content.index("def init_plugin(self")
+                # 在 def init_plugin(self 前添加 is_clone = True
+                content = content[:init_index] + "is_clone = True\n\n    " + content[init_index:]
+
+            with open(file_path, 'w', encoding='utf-8') as f:
+                f.write(content)
+
+            logger.debug(f"已修改Python文件：{file_path}")
+            return True, "Python文件修改成功"
+
+        except Exception as e:
+            logger.error(f"修改Python文件失败：{str(e)}")
+            return False, f"修改Python文件失败：{str(e)}"
+
+    def _modify_federation_files(self, dist_dir: Path, original_class_name: str,
+                                 clone_class_name: str) -> Tuple[bool, str]:
+        """
+        修改联邦插件的前端文件
+        """
+        try:
+            # 获取原始插件名（从类名推导）
+            original_plugin_name = original_class_name
+            clone_plugin_name = clone_class_name
+
+            # 遍历dist目录下的所有文件
+            for file_path in dist_dir.rglob("*"):
+                if not file_path.is_file():
+                    continue
+
+                # 处理JS文件
+                if file_path.suffix == '.js':
+                    try:
+                        with open(file_path, 'r', encoding='utf-8') as f:
+                            content = f.read()
+
+                        # 替换类名引用（精确匹配）
+                        content = content.replace(original_class_name, clone_class_name)
+                        # 替换插件名引用（如果存在）
+                        content = content.replace(f'"{original_plugin_name}"', f'"{clone_plugin_name}"')
+                        content = content.replace(f"'{original_plugin_name}'", f"'{clone_plugin_name}'")
+                        # 替换CSS key中的类名（联邦插件特有）
+                        content = content.replace(f'css__{original_class_name}__', f'css__{clone_class_name}__')
+                        # 替换可能的小写类名引用
+                        content = content.replace(original_class_name.lower(), clone_class_name.lower())
+
+                        with open(file_path, 'w', encoding='utf-8') as f:
+                            f.write(content)
+
+                        logger.debug(f"已修改联邦插件JS文件：{file_path}")
+
+                    except Exception as e:
+                        logger.warning(f"修改联邦插件文件 {file_path} 失败：{str(e)}")
+                        continue
+
+                # 处理CSS文件
+                elif file_path.suffix == '.css':
+                    try:
+                        with open(file_path, 'r', encoding='utf-8') as f:
+                            content = f.read()
+
+                        # 替换CSS中可能的类名引用
+                        content = content.replace(original_class_name.lower(), clone_class_name.lower())
+                        content = content.replace(original_class_name, clone_class_name)
+
+                        with open(file_path, 'w', encoding='utf-8') as f:
+                            f.write(content)
+
+                        logger.debug(f"已修改联邦插件CSS文件：{file_path}")
+
+                    except Exception as e:
+                        logger.warning(f"修改联邦插件CSS文件 {file_path} 失败：{str(e)}")
+                        continue
+
+            # 重命名构建文件（如果需要）
+            self._rename_federation_assets(dist_dir, original_class_name, clone_class_name)
+
+            return True, "联邦插件文件修改完成"
+
+        except Exception as e:
+            logger.error(f"修改联邦插件文件失败：{str(e)}")
+            return False, f"修改联邦插件文件失败：{str(e)}"
+
+    @staticmethod
+    def _rename_federation_assets(dist_dir: Path, original_class_name: str, clone_class_name: str):
+        """
+        重命名联邦插件的资源文件，避免文件名冲突
+        """
+        try:
+            # 查找包含原类名的文件并重命名
+            for file_path in dist_dir.glob("*"):
+                if not file_path.is_file():
+                    continue
+
+                file_name = file_path.name
+                # 如果文件名包含原类名，则重命名
+                if original_class_name.lower() in file_name.lower():
+                    new_name = file_name.replace(
+                        original_class_name.lower(),
+                        clone_class_name.lower()
+                    )
+                    new_path = file_path.parent / new_name
+
+                    # 避免重命名冲突
+                    if not new_path.exists():
+                        file_path.rename(new_path)
+                        logger.debug(f"重命名联邦插件文件：{file_name} -> {new_name}")
+
+        except Exception as e:
+            # 重命名失败不影响整体流程
+            logger.warning(f"重命名联邦插件资源文件失败：{str(e)}")

app/db/downloadhistory_oper.py

@@ -113,6 +113,7 @@ class DownloadHistoryOper(DbOper):
                     season: Optional[str] = None, episode: Optional[str] = None, tmdbid=None) -> List[DownloadHistory]:
         """
         按类型、标题、年份、季集查询下载记录
+        tmdbid + mtype 或 title + year
         """
         return DownloadHistory.get_last_by(db=self._db,
                                            mtype=mtype,

app/db/models/downloadhistory.py

@@ -1,7 +1,7 @@
 import time
 from typing import Optional
 
-from sqlalchemy import Column, Integer, String, Sequence, JSON
+from sqlalchemy import Column, Integer, String, Sequence, JSON, or_
 from sqlalchemy.orm import Session
 
 from app.db import db_query, db_update, Base
@@ -65,8 +65,11 @@ class DownloadHistory(Base):
     @staticmethod
     @db_query
     def get_by_mediaid(db: Session, tmdbid: int, doubanid: str):
-        return db.query(DownloadHistory).filter(DownloadHistory.tmdbid == tmdbid,
-                                                DownloadHistory.doubanid == doubanid).all()
+        if tmdbid:
+            return db.query(DownloadHistory).filter(DownloadHistory.tmdbid == tmdbid).all()
+        elif doubanid:
+            return db.query(DownloadHistory).filter(DownloadHistory.doubanid == doubanid).all()
+        return []
 
     @staticmethod
     @db_query
@@ -81,49 +84,58 @@ class DownloadHistory(Base):
 
     @staticmethod
     @db_query
-    def get_last_by(db: Session, mtype: Optional[str] = None, title: Optional[str] = None, 
+    def get_last_by(db: Session, mtype: Optional[str] = None, title: Optional[str] = None,
                     year: Optional[str] = None, season: Optional[str] = None,
                     episode: Optional[str] = None, tmdbid: Optional[int] = None):
         """
-        据tmdbid、season、season_episode查询转移记录
+        据tmdbid、season、season_episode查询下载记录
+        tmdbid + mtype 或 title + year
         """
         result = None
-        if tmdbid and not season and not episode:
-            result = db.query(DownloadHistory).filter(DownloadHistory.tmdbid == tmdbid).order_by(
-                DownloadHistory.id.desc()).all()
-        if tmdbid and season and not episode:
-            result = db.query(DownloadHistory).filter(DownloadHistory.tmdbid == tmdbid,
-                                                      DownloadHistory.seasons == season).order_by(
-                DownloadHistory.id.desc()).all()
-        if tmdbid and season and episode:
-            result = db.query(DownloadHistory).filter(DownloadHistory.tmdbid == tmdbid,
-                                                      DownloadHistory.seasons == season,
-                                                      DownloadHistory.episodes == episode).order_by(
-                DownloadHistory.id.desc()).all()
-        # 电视剧所有季集｜电影
-        if not season and not episode:
-            result = db.query(DownloadHistory).filter(DownloadHistory.type == mtype,
-                                                      DownloadHistory.title == title,
-                                                      DownloadHistory.year == year).order_by(
-                DownloadHistory.id.desc()).all()
-        # 电视剧某季
-        if season and not episode:
-            result = db.query(DownloadHistory).filter(DownloadHistory.type == mtype,
-                                                      DownloadHistory.title == title,
-                                                      DownloadHistory.year == year,
-                                                      DownloadHistory.seasons == season).order_by(
-                DownloadHistory.id.desc()).all()
-        # 电视剧某季某集
-        if season and episode:
-            result = db.query(DownloadHistory).filter(DownloadHistory.type == mtype,
-                                                      DownloadHistory.title == title,
-                                                      DownloadHistory.year == year,
-                                                      DownloadHistory.seasons == season,
-                                                      DownloadHistory.episodes == episode).order_by(
-                DownloadHistory.id.desc()).all()
+        # TMDBID + 类型
+        if tmdbid and mtype:
+            # 电视剧某季某集
+            if season and episode:
+                result = db.query(DownloadHistory).filter(DownloadHistory.tmdbid == tmdbid,
+                                                          DownloadHistory.type == mtype,
+                                                          DownloadHistory.seasons == season,
+                                                          DownloadHistory.episodes == episode).order_by(
+                    DownloadHistory.id.desc()).all()
+            # 电视剧某季
+            elif season:
+                result = db.query(DownloadHistory).filter(DownloadHistory.tmdbid == tmdbid,
+                                                          DownloadHistory.type == mtype,
+                                                          DownloadHistory.seasons == season).order_by(
+                    DownloadHistory.id.desc()).all()
+            else:
+                # 电视剧所有季集/电影
+                result = db.query(DownloadHistory).filter(DownloadHistory.tmdbid == tmdbid,
+                                                          DownloadHistory.type == mtype).order_by(
+                    DownloadHistory.id.desc()).all()
+        # 标题 + 年份
+        elif title and year:
+            # 电视剧某季某集
+            if season and episode:
+                result = db.query(DownloadHistory).filter(DownloadHistory.title == title,
+                                                          DownloadHistory.year == year,
+                                                          DownloadHistory.seasons == season,
+                                                          DownloadHistory.episodes == episode).order_by(
+                    DownloadHistory.id.desc()).all()
+            # 电视剧某季
+            elif season:
+                result = db.query(DownloadHistory).filter(DownloadHistory.title == title,
+                                                          DownloadHistory.year == year,
+                                                          DownloadHistory.seasons == season).order_by(
+                    DownloadHistory.id.desc()).all()
+            else:
+                # 电视剧所有季集/电影
+                result = db.query(DownloadHistory).filter(DownloadHistory.title == title,
+                                                          DownloadHistory.year == year).order_by(
+                    DownloadHistory.id.desc()).all()
 
         if result:
             return list(result)
+        return []
 
     @staticmethod
     @db_query

app/db/subscribe_oper.py

@@ -20,22 +20,24 @@ class SubscribeOper(DbOper):
                                      tmdbid=mediainfo.tmdb_id,
                                      doubanid=mediainfo.douban_id,
                                      season=kwargs.get('season'))
+        kwargs.update({
+            "name": mediainfo.title,
+            "year": mediainfo.year,
+            "type": mediainfo.type.value,
+            "tmdbid": mediainfo.tmdb_id,
+            "imdbid": mediainfo.imdb_id,
+            "tvdbid": mediainfo.tvdb_id,
+            "doubanid": mediainfo.douban_id,
+            "bangumiid": mediainfo.bangumi_id,
+            "episode_group": mediainfo.episode_group,
+            "poster": mediainfo.get_poster_image(),
+            "backdrop": mediainfo.get_backdrop_image(),
+            "vote": mediainfo.vote_average,
+            "description": mediainfo.overview,
+            "date": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
+        })
         if not subscribe:
-            subscribe = Subscribe(name=mediainfo.title,
-                                  year=mediainfo.year,
-                                  type=mediainfo.type.value,
-                                  tmdbid=mediainfo.tmdb_id,
-                                  imdbid=mediainfo.imdb_id,
-                                  tvdbid=mediainfo.tvdb_id,
-                                  doubanid=mediainfo.douban_id,
-                                  bangumiid=mediainfo.bangumi_id,
-                                  episode_group=mediainfo.episode_group,
-                                  poster=mediainfo.get_poster_image(),
-                                  backdrop=mediainfo.get_backdrop_image(),
-                                  vote=mediainfo.vote_average,
-                                  description=mediainfo.overview,
-                                  date=time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()),
-                                  **kwargs)
+            subscribe = Subscribe(**kwargs)
             subscribe.create(self._db)
             # 查询订阅
             subscribe = Subscribe.exists(self._db,

app/db/transferhistory_oper.py

@@ -194,7 +194,6 @@ class TransferHistoryOper(DbOper):
                 episodes=meta.episode,
                 downloader=downloader,
                 download_hash=download_hash,
-                episode_group=mediainfo.episode_group,
                 status=0,
                 errmsg="未识别到媒体信息"
             )

app/helper/message.py

@@ -1,18 +1,534 @@
 from __future__ import annotations
 
+import ast
 import json
 import queue
+import re
 import threading
 import time
 from datetime import datetime
-from typing import Any, Union
-from typing import List, Optional, Callable
+from typing import Any, Literal, Optional, List, Dict, Union
+from typing import Callable
+
+from cachetools import TTLCache
+from jinja2 import Template
 
 from app.core.config import global_vars
+from app.core.context import MediaInfo, TorrentInfo
+from app.core.meta import MetaBase
 from app.db.systemconfig_oper import SystemConfigOper
+from app.log import logger
+from app.schemas.message import Notification
+from app.schemas.tmdb import TmdbEpisode
+from app.schemas.transfer import TransferInfo
 from app.schemas.types import SystemConfigKey
 from app.utils.singleton import Singleton, SingletonClass
-from app.log import logger
+from app.utils.string import StringUtils
+
+
+class TemplateContextBuilder:
+    """
+    模板上下文构建器
+    """
+
+    def __init__(self):
+        self._context = {}
+
+    def build(
+            self,
+            meta: Optional[MetaBase] = None,
+            mediainfo: Optional[MediaInfo] = None,
+            torrentinfo: Optional[TorrentInfo] = None,
+            transferinfo: Optional[TransferInfo] = None,
+            file_extension: Optional[str] = None,
+            episodes_info: Optional[List[TmdbEpisode]] = None,
+            include_raw_objects: bool = True,
+            **kwargs
+    ) -> Dict[str, Any]:
+        """
+        :param meta: 媒体信息
+        :param mediainfo: 媒体信息
+        :param torrentinfo: 种子信息
+        :param transferinfo: 传输信息
+        :param file_extension: 文件扩展名
+        :param episodes_info: 剧集信息
+        :param include_raw_objects: 是否包含原始对象
+        :return: 渲染上下文字典
+        """
+        self._context.clear()
+        self._add_episode_details(meta, episodes_info)
+        self._add_media_info(mediainfo)
+        self._add_transfer_info(transferinfo)
+        self._add_torrent_info(torrentinfo)
+        self._add_file_info(file_extension)
+        if kwargs: self._context.update(kwargs)
+
+        if include_raw_objects:
+            self._add_raw_objects(meta, mediainfo, torrentinfo, transferinfo, episodes_info)
+
+        # 移除空值
+        return {k: v for k, v in self._context.items() if v is not None}
+
+    def _add_media_info(self, mediainfo: MediaInfo):
+        """
+        增加媒体信息
+        """
+        if not mediainfo: return
+        season_fmt = f"S{mediainfo.season:02d}" if mediainfo.season is not None else None
+        base_info = {
+            # 标题
+            "title": self.__convert_invalid_characters(mediainfo.title),
+            # 英文标题
+            "en_title": self.__convert_invalid_characters(mediainfo.en_title),
+            # 原语种标题
+            "original_title": self.__convert_invalid_characters(mediainfo.original_title),
+            # 季号
+            "season": self._context.get("season") or mediainfo.season,
+            # Sxx
+            "season_fmt": self._context.get("season_fmt") or season_fmt,
+            # 年份
+            "year": mediainfo.year or self._context.get("year"),
+            # 媒体标题 + 年份
+            "title_year": mediainfo.title_year or self._context.get("title_year"),
+        }
+
+        _meta_season = self._context.get("season")
+        media_info = {
+            # 类型
+            "type": mediainfo.type.value,
+            # 类别
+            "category": mediainfo.category,
+            # 评分
+            "vote_average": mediainfo.vote_average,
+            # 海报
+            "poster": mediainfo.get_poster_image(),
+            # 背景图
+            "backdrop": mediainfo.get_backdrop_image(),
+            # 季年份根据season值获取
+            "season_year": mediainfo.season_years.get(
+                int(_meta_season),
+                None) if (mediainfo.season_years and _meta_season) else None,
+            # 演员
+            "actors": '、 '.join([actor['name'] for actor in mediainfo.actors[:5]]),
+            # 简介
+            "overview": mediainfo.overview,
+            # TMDBID
+            "tmdbid": mediainfo.tmdb_id,
+            # IMDBID
+            "imdbid": mediainfo.imdb_id,
+            # 豆瓣ID
+            "doubanid": mediainfo.douban_id,
+        }
+        self._context.update({**base_info, **media_info})
+
+    def _add_episode_details(self, meta: Optional[MetaBase], episodes: Optional[List[TmdbEpisode]]):
+        """
+        添加剧集详细信息
+        """
+        if not meta:
+            return
+
+        episode_data = {"episode_title": None, "episode_date": None}
+        if meta.begin_episode and episodes:
+            for episode in episodes:
+                if episode.episode_number == meta.begin_episode:
+                    episode_data.update({
+                        "episode_title": self.__convert_invalid_characters(episode.name),
+                        "episode_date": episode.air_date if episode.air_date else None
+                    })
+                    break
+
+        meta_info = {
+            # 原文件名
+            "original_name": meta.title,
+            # 识别名称（优先使用中文）
+            "name": meta.name,
+            # 识别的英文名称（可能为空）
+            "en_name": meta.en_name,
+            # 年份
+            "year": meta.year,
+            # 名字 + 年份
+            "title_year": self._context.get("title_year") or "%s (%s)" % (
+                meta.name, meta.year) if meta.year else meta.name,
+            # 季号
+            "season": meta.season_seq,
+            # Sxx
+            "season_fmt": meta.season,
+            # 集号
+            "episode": meta.episode_seqs,
+            # 季集 SxxExx
+            "season_episode": "%s%s" % (meta.season, meta.episode),
+            # 段/节
+            "part": meta.part,
+            # 自定义占位符
+            "customization": meta.customization,
+        }
+
+        tech_metadata = {
+            # 资源类型
+            "resourceType": meta.resource_type,
+            # 特效
+            "effect": meta.resource_effect,
+            # 版本
+            "edition": meta.edition,
+            # 分辨率
+            "videoFormat": meta.resource_pix,
+            # 质量
+            "resource_term": meta.resource_term,
+            # 制作组/字幕组
+            "releaseGroup": meta.resource_team,
+            # 视频编码
+            "videoCodec": meta.video_encode,
+            # 音频编码
+            "audioCodec": meta.audio_encode,
+        }
+        self._context.update({**meta_info, **tech_metadata, **episode_data})
+
+    def _add_torrent_info(self, torrentinfo: Optional[TorrentInfo]):
+        """
+        添加种子信息
+        """
+        if not torrentinfo:
+            return
+        if torrentinfo.size:
+            if str(torrentinfo.size).replace(".", "").isdigit():
+                size = StringUtils.str_filesize(torrentinfo.size)
+            else:
+                size = torrentinfo.size
+        else:
+            size = 0
+
+        if torrentinfo.description:
+            html_re = re.compile(r'<[^>]+>', re.S)
+            description = html_re.sub('', torrentinfo.description)
+            torrentinfo.description = re.sub(r'<[^>]+>', '', description)
+
+        torrent_info = {
+            # 种子标题
+            "torrent_title": torrentinfo.title,
+            # 发布时间
+            "pubdate": torrentinfo.pubdate,
+            # 免费剩余时间
+            "freedate": torrentinfo.freedate_diff,
+            # 做种数
+            "seeders": torrentinfo.seeders,
+            # 促销信息
+            "volume_factor": torrentinfo.volume_factor,
+            # Hit&Run
+            "hit_and_run": "是" if torrentinfo.hit_and_run else "否",
+            # 种子标签
+            "labels": ' '.join(torrentinfo.labels),
+            # 描述
+            "description": torrentinfo.description,
+            # 站点名称
+            "site_name": torrentinfo.site_name,
+            # 种子大小
+            "size": size,
+        }
+        self._context.update(torrent_info)
+
+    def _add_transfer_info(self, transferinfo: Optional[TransferInfo]) -> Optional[Dict]:
+        """
+        添加文件转移上下文
+        """
+        if not transferinfo:
+            return None
+        ctx = {
+            "transfer_type": transferinfo.transfer_type,
+            "file_count": transferinfo.file_count,
+            "total_size": StringUtils.str_filesize(transferinfo.total_size),
+            "err_msg": transferinfo.message,
+        }
+        self._context.update(ctx)
+
+    def _add_file_info(self, file_extension: Optional[str]):
+        """
+        添加文件信息
+        """
+        if not file_extension: return
+        file_info = {
+            # 文件后缀
+            "fileExt": file_extension,
+        }
+        self._context.update(file_info)
+
+    def _add_raw_objects(
+            self,
+            meta: Optional[MetaBase],
+            mediainfo: Optional[MediaInfo],
+            torrentinfo: Optional[TorrentInfo],
+            transferinfo: Optional[TransferInfo],
+            episodes_info: Optional[List[TmdbEpisode]],
+    ):
+        """
+        添加原始对象引用
+        """
+        raw_objects = {
+            # 文件元数据
+            "__meta__": meta,
+            # 识别的媒体信息
+            "__mediainfo__": mediainfo,
+            # 种子信息
+            "__torrentinfo__": torrentinfo,
+            # 文件转移信息
+            "__transferinfo__": transferinfo,
+            # 当前季的全部集信息
+            "__episodes_info__": episodes_info,
+        }
+        self._context.update(raw_objects)
+
+    @staticmethod
+    def __convert_invalid_characters(filename: str):
+        """
+        将不支持的字符转换为全角字符
+        """
+        if not filename:
+            return filename
+        invalid_characters = r'\/:*?"<>|'
+        # 创建半角到全角字符的转换表
+        halfwidth_chars = "".join([chr(i) for i in range(33, 127)])
+        fullwidth_chars = "".join([chr(i + 0xFEE0) for i in range(33, 127)])
+        translation_table = str.maketrans(halfwidth_chars, fullwidth_chars)
+        # 将不支持的字符替换为对应的全角字符
+        for char in invalid_characters:
+            filename = filename.replace(char, char.translate(translation_table))
+        return filename
+
+
+class TemplateHelper(metaclass=SingletonClass):
+    """
+    模板格式渲染帮助类
+    """
+
+    def __init__(self):
+        self.builder = TemplateContextBuilder()
+        self.cache = TTLCache(maxsize=100, ttl=600)
+
+    @staticmethod
+    def _generate_cache_key(cuntent: Union[str, dict]) -> str:
+        """
+        生成缓存键
+        """
+        if isinstance(cuntent, dict):
+            base_str = cuntent.get("title", '') + cuntent.get("text", '')
+            return StringUtils.md5_hash(json.dumps(base_str, sort_keys=True, ensure_ascii=False))
+
+        return StringUtils.md5_hash(cuntent)
+
+    def get_cache_context(self, cuntent: Union[str, dict]) -> Optional[dict]:
+        """
+        获取缓存上下文
+        """
+        cache_key = self._generate_cache_key(cuntent)
+        return self.cache.get(cache_key)
+
+    def set_cache_context(self, cuntent: Union[str, dict], context: dict) -> None:
+        """
+        设置缓存上下文
+        """
+        cache_key = self._generate_cache_key(cuntent)
+        self.cache[cache_key] = context
+
+    def render(self,
+               template_content: str,
+               template_type: Literal['string', 'dict', 'literal'] = "literal",
+               **kwargs) -> Optional[Union[str, dict]]:
+        """
+        根据模板格式渲染内容
+        :param template_content: 模板字符串
+        :param template_type: 模板字符串类型(消息通知`literal`, 路径`string`)
+        :param kwargs: 补传业务对象
+        :raises ValueError: 当模板处理过程中出现错误
+        :return: 渲染后的结果
+        """
+        try:
+            # 解析模板字符
+            parsed = self.parse_template_content(template_content, template_type)
+            if not parsed:
+                raise ValueError("模板解析失败")
+
+            context = self.builder.build(**kwargs)
+            if not context:
+                raise ValueError("上下文构建失败")
+
+            rendered = self.render_with_context(parsed, context)
+            if not rendered:
+                raise ValueError("模板渲染失败")
+
+            if rendered := rendered if template_type == 'string' else self.__process_formatted_string(rendered):
+                # 缓存上下文
+                self.set_cache_context(rendered, context)
+                # 返回渲染结果
+                return rendered
+
+        except Exception as e:
+            logger.error(f"模板处理失败: {str(e)}")
+            raise ValueError(f"模板处理失败: {str(e)}") from e
+
+    @staticmethod
+    def render_with_context(template_content: str, context: dict) -> str:
+        """
+        使用指定上下文渲染 Jinja2 模板字符串
+        template_content: Jinja2 模板字符串
+        context: 渲染用的上下文数据
+        """
+        # 渲染模板
+        template = Template(template_content)
+        return template.render(context)
+
+    @staticmethod
+    def parse_template_content(template_content: Union[str, dict],
+                               template_type: Literal['string', 'dict', 'literal'] = None) -> Optional[str]:
+        """
+        解析模板字符
+        :param template_content 模板格式字符
+        :param template_type 模板字符类型
+        """
+
+        def parse_literal(_template_content: str) -> str:
+            """
+            解析Python字面量
+            """
+            try:
+                template_dict = ast.literal_eval(_template_content) if isinstance(_template_content,
+                                                                                  str) else _template_content
+                if not isinstance(template_dict, dict):
+                    raise ValueError("解析结果必须是一个字典")
+                return json.dumps(template_dict, ensure_ascii=False)
+            except (ValueError, SyntaxError) as err:
+                raise ValueError(f"无效的Python字面量格式: {str(err)}")
+
+        try:
+            if template_type:
+                parse_map = {
+                    'string': lambda x: str(x),
+                    'dict': lambda x: json.dumps(x, ensure_ascii=False),
+                    'literal': parse_literal
+                }
+                return parse_map[template_type](template_content)
+
+            # 自动判断模板类型
+            if isinstance(template_content, dict):
+                return json.dumps(template_content, ensure_ascii=False)
+            elif isinstance(template_content, str):
+                try:
+                    json.loads(template_content)
+                    return template_content
+                except json.JSONDecodeError:
+                    try:
+                        return parse_literal(template_content)
+                    except (ValueError, SyntaxError):
+                        return template_content
+            else:
+                raise ValueError(f"不支持的模板类型: {type(template_content)}")
+
+        except Exception as e:
+            logger.error(f"模板解析失败: {str(e)}")
+            return None
+
+    @staticmethod
+    def __process_formatted_string(rendered: str) -> Optional[Union[dict, str]]:
+        """
+        处理格式化字符串
+        保留转义字符
+        """
+
+        def restore_chars(obj: Any) -> Any:
+            """恢复特殊字符"""
+            if isinstance(obj, str):
+                return obj.replace('\\n', '\n').replace('\\r', '\r').replace('\\t', '\t').replace('\\b', '\b').replace(
+                    '\\f', '\f')
+            elif isinstance(obj, dict):
+                return {k: restore_chars(v) for k, v in obj.items()}
+            elif isinstance(obj, list):
+                return [restore_chars(item) for item in obj]
+            return obj
+
+            # 定义特殊字符映射
+
+        special_chars = {
+            '\n': '\\n',  # 换行符
+            '\r': '\\r',  # 回车符
+            '\t': '\\t',  # 制表符
+            '\b': '\\b',  # 退格符
+            '\f': '\\f',  # 换页符
+        }
+
+        # 处理特殊字符
+        processed = rendered
+        for char, escape in special_chars.items():
+            processed = processed.replace(char, escape)
+
+        # 尝试解析为JSON
+        try:
+            rendered_dict = json.loads(processed)
+            return restore_chars(rendered_dict)
+        except json.JSONDecodeError:
+            return rendered
+
+
+class MessageTemplateHelper:
+    """
+    消息模板渲染器
+    """
+
+    @staticmethod
+    def render(message: Notification, *args, **kwargs) -> Optional[Notification]:
+        """
+        渲染消息模板
+        """
+        if not MessageTemplateHelper.is_instance_valid(message):
+            if MessageTemplateHelper.meets_update_conditions(message, *args, **kwargs):
+                logger.info("将使用模板渲染消息内容")
+                return MessageTemplateHelper._apply_template_data(message, *args, **kwargs)
+        return message
+
+    @staticmethod
+    def is_instance_valid(message: Notification) -> bool:
+        """
+        检查消息是否有效
+        """
+        if isinstance(message, Notification):
+            return bool(message.title or message.text)
+        return False
+
+    @staticmethod
+    def meets_update_conditions(message: Notification, *args, **kwargs) -> bool:
+        """
+        判断是否满足消息实例更新条件
+
+        满足条件需同时具备：
+        1. 消息为有效Notification实例
+        2. 消息指定了模板类型(ctype)
+        3. 存在待渲染的模板变量数据
+        """
+        if isinstance(message, Notification):
+            return True if message.ctype and (args or kwargs) else False
+        return False
+
+    @staticmethod
+    def _apply_template_data(message: Notification, *args, **kwargs) -> Optional[Notification]:
+        """
+        更新消息实例
+        """
+        try:
+            if template := MessageTemplateHelper._get_template(message):
+                rendered = TemplateHelper().render(template_content=template, *args, **kwargs)
+                for key, value in rendered.items():
+                    if hasattr(message, key):
+                        setattr(message, key, value)
+            return message
+        except Exception as e:
+            logger.error(f"更新Notification时出现错误：{str(e)}")
+            return message
+
+    @staticmethod
+    def _get_template(message: Notification) -> Optional[str]:
+        """
+        获取消息模板
+        """
+        template_dict: dict[str, str] = SystemConfigOper().get(SystemConfigKey.NotificationTemplates)
+        return template_dict.get(f"{message.ctype.value}")
 
 
 class MessageQueueManager(metaclass=SingletonClass):
@@ -55,6 +571,7 @@ class MessageQueueManager(metaclass=SingletonClass):
     def _parse_schedule(periods: Union[list, dict]) -> List[tuple[int, int, int, int]]:
         """
         将字符串时间格式转换为分钟数元组
+        支持格式为 'HH:MM' 或 'HH:MM:SS' 的时间字符串
         """
         parsed = []
         if not periods:
@@ -66,9 +583,31 @@ class MessageQueueManager(metaclass=SingletonClass):
                 continue
             if not period.get('start') or not period.get('end'):
                 continue
-            start_h, start_m = map(int, period['start'].split(':'))
-            end_h, end_m = map(int, period['end'].split(':'))
-            parsed.append((start_h, start_m, end_h, end_m))
+            try:
+                # 处理 start 时间
+                start_parts = period['start'].split(':')
+                if len(start_parts) == 2:
+                    start_h, start_m = map(int, start_parts)
+                elif len(start_parts) >= 3:
+                    start_h, start_m = map(int, start_parts[:2])  # 只取前两个部分 (HH:MM)
+                else:
+                    continue
+                # 处理 end 时间
+                end_parts = period['end'].split(':')
+                if len(end_parts) == 2:
+                    end_h, end_m = map(int, end_parts)
+                elif len(end_parts) >= 3:
+                    end_h, end_m = map(int, end_parts[:2])  # 只取前两个部分 (HH:MM)
+                else:
+                    continue
+
+                parsed.append((start_h, start_m, end_h, end_m))
+            except ValueError as e:
+                logger.error(f"解析时间周期时出现错误：{period}. 错误：{str(e)}. 跳过此周期。")
+                continue
+            except Exception as e:
+                logger.error(f"解析时间周期时出现意外错误：{period}. 错误：{str(e)}. 跳过此周期。")
+                continue
         return parsed
 
     @staticmethod

app/helper/module.py

@@ -7,14 +7,15 @@ from typing import List, Any, Callable
 
 from app.log import logger
 
-
 FilterFuncType = Callable[[str, Any], bool]
 
+
 def _default_filter(name: str, obj: Any) -> bool:
     """
     默认过滤器
     """
-    return True
+    return True if name and obj else False
+
 
 class ModuleHelper:
     """
@@ -76,7 +77,8 @@ class ModuleHelper:
 
         def reload_sub_modules(parent_module, parent_module_name):
             """重新加载一级子模块"""
-            for sub_importer, sub_module_name, sub_is_pkg in pkgutil.walk_packages(parent_module.__path__, parent_module_name+'.'):
+            for sub_importer, sub_module_name, sub_is_pkg in pkgutil.walk_packages(parent_module.__path__,
+                                                                                   parent_module_name + '.'):
                 try:
                     full_sub_module = importlib.import_module(sub_module_name)
                     importlib.reload(full_sub_module)

app/helper/plugin.py

@@ -1,6 +1,9 @@
+import sys
 import json
 import shutil
 import traceback
+import site
+import importlib
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Set
 
@@ -451,19 +454,22 @@ class PluginHelper(metaclass=Singleton):
     @staticmethod
     def __pip_install_with_fallback(requirements_file: Path) -> Tuple[bool, str]:
         """
-        使用自动降级策略，PIP 安装依赖，优先级依次为镜像站、代理、直连
+        使用自动降级策略安装依赖，并确保新安装的包可被动态导入
         :param requirements_file: 依赖的 requirements.txt 文件路径
         :return: (是否成功, 错误信息)
         """
+        base_cmd = [sys.executable, "-m", "pip", "install", "-r", str(requirements_file)]
         strategies = []
 
         # 添加策略到列表中
         if settings.PIP_PROXY:
-            strategies.append(("镜像站", ["pip", "install", "-r", str(requirements_file), "-i", settings.PIP_PROXY]))
+            strategies.append(("镜像站", base_cmd + ["-i", settings.PIP_PROXY]))
         if settings.PROXY_HOST:
-            strategies.append(
-                ("代理", ["pip", "install", "-r", str(requirements_file), "--proxy", settings.PROXY_HOST]))
-        strategies.append(("直连", ["pip", "install", "-r", str(requirements_file)]))
+            strategies.append(("代理", base_cmd + ["--proxy", settings.PROXY_HOST]))
+        strategies.append(("直连", base_cmd))
+
+        # 记录当前已安装的包，以便后续刷新
+        before_installation = set(sys.modules.keys())
 
         # 遍历策略进行安装
         for strategy_name, pip_command in strategies:
@@ -471,6 +477,16 @@ class PluginHelper(metaclass=Singleton):
             success, message = SystemUtils.execute_with_subprocess(pip_command)
             if success:
                 logger.debug(f"[PIP] 策略：{strategy_name} 安装依赖成功，输出：{message}")
+                # 安装成功后刷新Python的模块系统
+                importlib.reload(site)
+                # 获取新安装的模块
+                current_modules = set(sys.modules.keys())
+                new_modules = current_modules - before_installation
+                # 重新加载新安装的模块
+                for module in new_modules:
+                    if module in sys.modules:
+                        del sys.modules[module]
+                logger.debug(f"[PIP] 已刷新导入系统，新加载的模块: {new_modules}")
                 return True, message
             else:
                 logger.error(f"[PIP] 策略：{strategy_name} 安装依赖失败，错误信息：{message}")

app/helper/resource.py

@@ -8,6 +8,7 @@ from app.utils.http import RequestUtils
 from app.utils.singleton import Singleton
 from app.utils.string import StringUtils
 from app.utils.system import SystemUtils
+from helper.system import SystemHelper
 
 
 class ResourceHelper(metaclass=Singleton):
@@ -32,80 +33,80 @@ class ResourceHelper(metaclass=Singleton):
         检测是否有更新，如有则下载安装
         """
         if not settings.AUTO_UPDATE_RESOURCE:
-            return
+            return None
         if SystemUtils.is_frozen():
-            return
+            return None
         logger.info("开始检测资源包版本...")
         res = RequestUtils(proxies=self.proxies, headers=settings.GITHUB_HEADERS, timeout=10).get_res(self._repo)
         if res:
             try:
                 resource_info = json.loads(res.text)
+                online_version = resource_info.get("version")
+                if online_version:
+                    logger.info(f"最新资源包版本：v{online_version}")
+                    # 需要更新的资源包
+                    need_updates = {}
+                    # 资源明细
+                    resources: dict = resource_info.get("resources") or {}
+                    for rname, resource in resources.items():
+                        rtype = resource.get("type")
+                        platform = resource.get("platform")
+                        target = resource.get("target")
+                        version = resource.get("version")
+                        # 判断平台
+                        if platform and platform != SystemUtils.platform():
+                            continue
+                        # 判断版本号
+                        if rtype == "auth":
+                            # 站点认证资源
+                            local_version = self.siteshelper.auth_version
+                        elif rtype == "sites":
+                            # 站点索引资源
+                            local_version = self.siteshelper.indexer_version
+                        else:
+                            continue
+                        if StringUtils.compare_version(version, ">", local_version):
+                            logger.info(f"{rname} 资源包有更新，最新版本：v{version}")
+                        else:
+                            continue
+                        # 需要安装
+                        need_updates[rname] = target
+                    if need_updates:
+                        # 下载文件信息列表
+                        r = RequestUtils(proxies=settings.PROXY, headers=settings.GITHUB_HEADERS,
+                                         timeout=30).get_res(self._files_api)
+                        if r and not r.ok:
+                            return None, f"连接仓库失败：{r.status_code} - {r.reason}"
+                        elif not r:
+                            return None, "连接仓库失败"
+                        files_info = r.json()
+                        for item in files_info:
+                            save_path = need_updates.get(item.get("name"))
+                            if not save_path:
+                                continue
+                            if item.get("download_url"):
+                                logger.info(f"开始更新资源文件：{item.get('name')} ...")
+                                download_url = f"{settings.GITHUB_PROXY}{item.get('download_url')}"
+                                # 下载资源文件
+                                res = RequestUtils(proxies=self.proxies, headers=settings.GITHUB_HEADERS,
+                                                   timeout=180).get_res(download_url)
+                                if not res:
+                                    logger.error(f"文件 {item.get('name')} 下载失败！")
+                                elif res.status_code != 200:
+                                    logger.error(f"下载文件 {item.get('name')} 失败：{res.status_code} - {res.reason}")
+                                # 创建插件文件夹
+                                file_path = self._base_dir / save_path / item.get("name")
+                                if not file_path.parent.exists():
+                                    file_path.parent.mkdir(parents=True, exist_ok=True)
+                                # 写入文件
+                                file_path.write_bytes(res.content)
+                        logger.info("资源包更新完成，开始重启服务...")
+                        SystemHelper.restart()
+                    else:
+                        logger.info("所有资源已最新，无需更新")
             except json.JSONDecodeError:
                 logger.error("资源包仓库数据解析失败！")
-                return
+                return None
         else:
             logger.warn("无法连接资源包仓库！")
-            return
-        online_version = resource_info.get("version")
-        if online_version:
-            logger.info(f"最新资源包版本：v{online_version}")
-        # 需要更新的资源包
-        need_updates = {}
-        # 资源明细
-        resources: dict = resource_info.get("resources") or {}
-        for rname, resource in resources.items():
-            rtype = resource.get("type")
-            platform = resource.get("platform")
-            target = resource.get("target")
-            version = resource.get("version")
-            # 判断平台
-            if platform and platform != SystemUtils.platform():
-                continue
-            # 判断版本号
-            if rtype == "auth":
-                # 站点认证资源
-                local_version = self.siteshelper.auth_version
-            elif rtype == "sites":
-                # 站点索引资源
-                local_version = self.siteshelper.indexer_version
-            else:
-                continue
-            if StringUtils.compare_version(version, ">", local_version):
-                logger.info(f"{rname} 资源包有更新，最新版本：v{version}")
-            else:
-                continue
-            # 需要安装
-            need_updates[rname] = target
-        if need_updates:
-            # 下载文件信息列表
-            r = RequestUtils(proxies=settings.PROXY, headers=settings.GITHUB_HEADERS,
-                             timeout=30).get_res(self._files_api)
-            if r and not r.ok:
-                return None, f"连接仓库失败：{r.status_code} - {r.reason}"
-            elif not r:
-                return None, "连接仓库失败"
-            files_info = r.json()
-            for item in files_info:
-                save_path = need_updates.get(item.get("name"))
-                if not save_path:
-                    continue
-                if item.get("download_url"):
-                    logger.info(f"开始更新资源文件：{item.get('name')} ...")
-                    download_url = f"{settings.GITHUB_PROXY}{item.get('download_url')}"
-                    # 下载资源文件
-                    res = RequestUtils(proxies=self.proxies, headers=settings.GITHUB_HEADERS,
-                                       timeout=180).get_res(download_url)
-                    if not res:
-                        logger.error(f"文件 {item.get('name')} 下载失败！")
-                    elif res.status_code != 200:
-                        logger.error(f"下载文件 {item.get('name')} 失败：{res.status_code} - {res.reason}")
-                    # 创建插件文件夹
-                    file_path = self._base_dir / save_path / item.get("name")
-                    if not file_path.parent.exists():
-                        file_path.parent.mkdir(parents=True, exist_ok=True)
-                    # 写入文件
-                    file_path.write_bytes(res.content)
-            logger.info("资源包更新完成，开始重启服务...")
-            SystemUtils.restart()
-        else:
-            logger.info("所有资源已最新，无需更新")
+            return None

app/helper/storage.py

@@ -50,3 +50,35 @@ class StorageHelper:
                     s.config = conf
                     break
         self.systemconfig.set(SystemConfigKey.Storages, [s.dict() for s in storagies])
+
+    def add_storage(self, storage: str, name: str, conf: dict):
+        """
+        添加存储配置
+        """
+        storagies = self.get_storagies()
+        if not storagies:
+            storagies = [
+                schemas.StorageConf(
+                    type=storage,
+                    name=name,
+                    config=conf
+                )
+            ]
+        else:
+            storagies.append(schemas.StorageConf(
+                type=storage,
+                name=name,
+                config=conf
+            ))
+        self.systemconfig.set(SystemConfigKey.Storages, [s.dict() for s in storagies])
+
+    def reset_storage(self, storage: str):
+        """
+        重置存储配置
+        """
+        storagies = self.get_storagies()
+        for s in storagies:
+            if s.type == storage:
+                s.config = {}
+                break
+        self.systemconfig.set(SystemConfigKey.Storages, [s.dict() for s in storagies])

app/helper/subscribe.py

@@ -5,6 +5,7 @@ from app.core.cache import cached, cache_backend
 from app.core.config import settings
 from app.db.subscribe_oper import SubscribeOper
 from app.db.systemconfig_oper import SystemConfigOper
+from app.log import logger
 from app.schemas.types import SystemConfigKey
 from app.utils.http import RequestUtils
 from app.utils.singleton import Singleton
@@ -32,13 +33,30 @@ class SubscribeHelper(metaclass=Singleton):
 
     _shares_cache_region = "subscribe_share"
 
+    _github_user = None
+
+    _share_user_id = None
+
+    _admin_users = [
+        "jxxghp",
+        "thsrite",
+        "InfinityPacer",
+        "DDSRem",
+        "Aqr-K",
+        "Putarku",
+        "4Nest",
+        "xyswordzoro",
+        "wikrin"
+    ]
+
     def __init__(self):
         self.systemconfig = SystemConfigOper()
-        self.share_user_id = SystemUtils.generate_user_unique_id()
         if settings.SUBSCRIBE_STATISTIC_SHARE:
             if not self.systemconfig.get(SystemConfigKey.SubscribeReport):
                 if self.sub_report():
                     self.systemconfig.set(SystemConfigKey.SubscribeReport, "1")
+        self.get_user_uuid()
+        self.get_github_user()
 
     @cached(maxsize=20, ttl=1800)
     def get_statistic(self, stype: str, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
@@ -135,7 +153,7 @@ class SubscribeHelper(metaclass=Singleton):
                                                 "share_title": share_title,
                                                 "share_comment": share_comment,
                                                 "share_user": share_user,
-                                                "share_uid": self.share_user_id,
+                                                "share_uid": self._share_user_id,
                                                 **subscribe_dict
                                             })
         if res is None:
@@ -155,7 +173,7 @@ class SubscribeHelper(metaclass=Singleton):
             return False, "当前没有开启订阅数据共享功能"
         res = RequestUtils(proxies=settings.PROXY,
                            timeout=5).delete_res(f"{self._sub_share}/{share_id}",
-                                                 params={"share_uid": self.share_user_id})
+                                                 params={"share_uid": self._share_user_id})
         if res is None:
             return False, "连接MoviePilot服务器失败"
         if res.ok:
@@ -196,3 +214,35 @@ class SubscribeHelper(metaclass=Singleton):
         if res and res.status_code == 200:
             return res.json()
         return []
+
+    def get_user_uuid(self) -> str:
+        """
+        获取用户uuid
+        """
+        if not self._share_user_id:
+            self._share_user_id = SystemUtils.generate_user_unique_id()
+            logger.info(f"当前用户UUID: {self._share_user_id}")
+        return self._share_user_id
+
+    def get_github_user(self) -> str:
+        """
+        获取github用户
+        """
+        if self._github_user is None and settings.GITHUB_HEADERS:
+            res = RequestUtils(headers=settings.GITHUB_HEADERS,
+                               proxies=settings.PROXY,
+                               timeout=15).get_res(f"https://api.github.com/user")
+            if res:
+                self._github_user = res.json().get("login")
+                logger.info(f"当前Github用户: {self._github_user}")
+        return self._github_user
+
+    def is_admin_user(self) -> bool:
+        """
+        判断是否是管理员
+        """
+        if not self._github_user:
+            return False
+        if self._github_user in self._admin_users:
+            return True
+        return False

app/helper/system.py

@@ -0,0 +1,55 @@
+from pathlib import Path
+from typing import Tuple
+
+import docker
+
+from app.core.config import settings
+from app.utils.system import SystemUtils
+
+
+class SystemHelper:
+    @staticmethod
+    def can_restart() -> bool:
+        """
+        判断是否可以内部重启
+        """
+        return (
+            Path("/var/run/docker.sock").exists()
+            or settings.DOCKER_CLIENT_API != "tcp://127.0.0.1:38379"
+        )
+
+    @staticmethod
+    def restart() -> Tuple[bool, str]:
+        """
+        执行Docker重启操作
+        """
+        if not SystemUtils.is_docker():
+            return False, "非Docker环境，无法重启！"
+        try:
+            # 创建 Docker 客户端
+            client = docker.DockerClient(base_url=settings.DOCKER_CLIENT_API)
+            # 获取当前容器的 ID
+            container_id = None
+            with open("/proc/self/mountinfo", "r") as f:
+                data = f.read()
+                index_resolv_conf = data.find("resolv.conf")
+                if index_resolv_conf != -1:
+                    index_second_slash = data.rfind("/", 0, index_resolv_conf)
+                    index_first_slash = data.rfind("/", 0, index_second_slash) + 1
+                    container_id = data[index_first_slash:index_second_slash]
+                    if len(container_id) < 20:
+                        index_resolv_conf = data.find("/sys/fs/cgroup/devices")
+                        if index_resolv_conf != -1:
+                            index_second_slash = data.rfind(" ", 0, index_resolv_conf)
+                            index_first_slash = (
+                                data.rfind("/", 0, index_second_slash) + 1
+                            )
+                            container_id = data[index_first_slash:index_second_slash]
+            if not container_id:
+                return False, "获取容器ID失败！"
+            # 重启当前容器
+            client.containers.get(container_id.strip()).restart()
+            return True, ""
+        except Exception as err:
+            print(str(err))
+            return False, f"重启时发生错误：{str(err)}"

app/helper/wallpaper.py

@@ -0,0 +1,105 @@
+from typing import Optional, List
+
+from app.core.cache import cached
+from app.core.config import settings
+from app.utils.http import RequestUtils
+from app.utils.singleton import Singleton
+
+
+class WallpaperHelper(metaclass=Singleton):
+
+    def __init__(self):
+        self.req = RequestUtils(timeout=5)
+
+    @cached(maxsize=1, ttl=3600)
+    def get_bing_wallpaper(self) -> Optional[str]:
+        """
+        获取Bing每日壁纸
+        """
+        url = "https://cn.bing.com/HPImageArchive.aspx?format=js&idx=0&n=1"
+        resp = self.req.get_res(url)
+        if resp and resp.status_code == 200:
+            try:
+                result = resp.json()
+                if isinstance(result, dict):
+                    for image in result.get('images') or []:
+                        return f"https://cn.bing.com{image.get('url')}" if 'url' in image else ''
+            except Exception as err:
+                print(str(err))
+        return None
+
+    @cached(maxsize=1, ttl=3600)
+    def get_bing_wallpapers(self, num: int = 7) -> List[str]:
+        """
+        获取7天的Bing每日壁纸
+        """
+        url = f"https://cn.bing.com/HPImageArchive.aspx?format=js&idx=0&n={num}"
+        resp = self.req.get_res(url)
+        if resp and resp.status_code == 200:
+            try:
+                result = resp.json()
+                if isinstance(result, dict):
+                    return [f"https://cn.bing.com{image.get('url')}" for image in result.get('images') or []]
+            except Exception as err:
+                print(str(err))
+        return []
+
+    @cached(maxsize=1, ttl=3600)
+    def get_customize_wallpaper(self) -> Optional[str]:
+        """
+        获取自定义壁纸api壁纸
+        """
+        wallpaper_list = self.get_customize_wallpapers()
+        if wallpaper_list:
+            return wallpaper_list[0]
+        return None
+
+    @cached(maxsize=1, ttl=3600)
+    def get_customize_wallpapers(self) -> List[str]:
+        """
+        获取自定义壁纸api壁纸
+        """
+
+        def find_files_with_suffixes(obj, suffixes: List[str]) -> List[str]:
+            """
+            递归查找对象中所有包含特定后缀的文件，返回匹配的字符串列表
+            支持输入：字典、列表、字符串
+            """
+            _result = []
+
+            # 处理字符串
+            if isinstance(obj, str):
+                if obj.endswith(tuple(suffixes)):
+                    _result.append(obj)
+
+            # 处理字典
+            elif isinstance(obj, dict):
+                for value in obj.values():
+                    _result.extend(find_files_with_suffixes(value, suffixes))
+
+            # 处理列表
+            elif isinstance(obj, list):
+                for item in obj:
+                    _result.extend(find_files_with_suffixes(item, suffixes))
+
+            return _result
+
+        # 判断是否存在自定义壁纸api
+        if settings.CUSTOMIZE_WALLPAPER_API_URL:
+            wallpaper_list = []
+            resp = self.req.get_res(settings.CUSTOMIZE_WALLPAPER_API_URL)
+            if resp and resp.status_code == 200:
+                # 如果返回的是图片格式
+                content_type = resp.headers.get('Content-Type')
+                if content_type and content_type.lower().startswith('image/'):
+                    wallpaper_list.append(settings.CUSTOMIZE_WALLPAPER_API_URL)
+                else:
+                    try:
+                        result = resp.json()
+                        if isinstance(result, list) or isinstance(result, dict) or isinstance(result, str):
+                            wallpaper_list = find_files_with_suffixes(result, settings.SECURITY_IMAGE_SUFFIXES)
+                    except Exception as err:
+                        print(str(err))
+            return wallpaper_list
+        else:
+            return []

app/log.py

@@ -30,7 +30,7 @@ class LogConfigModel(BaseModel):
     # 备份的日志文件数量
     LOG_BACKUP_COUNT: int = 3
     # 控制台日志格式
-    LOG_CONSOLE_FORMAT: str = "%(leveltext)s%(message)s"
+    LOG_CONSOLE_FORMAT: str = "%(leveltext)s[%(name)s] %(asctime)s %(message)s"
     # 文件日志格式
     LOG_FILE_FORMAT: str = "【%(levelname)s】%(asctime)s - %(message)s"
 
@@ -189,6 +189,9 @@ class LoggerManager:
         file_handler.setFormatter(file_formatter)
         _logger.addHandler(file_handler)
 
+        # 禁止向父级log传递
+        _logger.propagate = False
+
         return _logger
 
     def update_loggers(self):

app/modules/douban/__init__.py

@@ -39,11 +39,9 @@ class DoubanModule(_ModuleBase):
         测试模块连接性
         """
         ret = RequestUtils().get_res("https://movie.douban.com/")
-        if ret and ret.status_code == 200:
-            return True, ""
-        elif ret:
-            return False, f"无法连接豆瓣，错误码：{ret.status_code}"
-        return False, "豆瓣网络连接失败"
+        if ret is None:
+            return False, "豆瓣网络连接失败"
+        return True, ""
 
     def init_setting(self) -> Tuple[str, Union[str, bool]]:
         pass

app/modules/emby/emby.py

@@ -1031,6 +1031,8 @@ class Emby:
             eventItem.image_url = self.get_remote_image_by_id(item_id=eventItem.item_id,
                                                               image_type="Backdrop")
 
+        eventItem.json_object = message
+
         return eventItem
 
     def get_data(self, url: str) -> Optional[Response]:

app/modules/filemanager/storages/__init__.py

@@ -61,6 +61,13 @@ class StorageBase(metaclass=ABCMeta):
         """
         return transtype in self.transtype
 
+    def reset_config(self):
+        """
+        重置置配置
+        """
+        self.storagehelper.reset_storage(self.schema.value)
+        self.init_storage()
+
     @abstractmethod
     def check(self) -> bool:
         """

app/modules/filemanager/storages/alipan.py

@@ -1,5 +1,6 @@
 import base64
 import hashlib
+import io
 import secrets
 import threading
 import time
@@ -24,6 +25,10 @@ class NoCheckInException(Exception):
     pass
 
 
+class SessionInvalidException(Exception):
+    pass
+
+
 class AliPan(StorageBase, metaclass=Singleton):
     """
     阿里云盘相关操作
@@ -177,7 +182,7 @@ class AliPan(StorageBase, metaclass=Singleton):
         确认登录后，获取相关token
         """
         if not self._auth_state:
-            raise Exception("【阿里云盘】请先生成二维码")
+            raise SessionInvalidException("【阿里云盘】请先生成二维码")
         resp = self.session.post(
             f"{self.base_url}/oauth/access_token",
             json={
@@ -188,7 +193,7 @@ class AliPan(StorageBase, metaclass=Singleton):
             }
         )
         if resp is None:
-            raise Exception("【阿里云盘】获取 access_token 失败")
+            raise SessionInvalidException("【阿里云盘】获取 access_token 失败")
         result = resp.json()
         if result.get("code"):
             raise Exception(f"【阿里云盘】{result.get('code')} - {result.get('message')}！")
@@ -199,7 +204,7 @@ class AliPan(StorageBase, metaclass=Singleton):
         刷新access_token
         """
         if not refresh_token:
-            raise Exception("【阿里云盘】会话失效，请重新扫码登录！")
+            raise SessionInvalidException("【阿里云盘】会话失效，请重新扫码登录！")
         resp = self.session.post(
             f"{self.base_url}/oauth/access_token",
             json={
@@ -335,6 +340,8 @@ class AliPan(StorageBase, metaclass=Singleton):
         """
         if not fileinfo:
             return schemas.FileItem()
+        if not parent.endswith("/"):
+            parent += "/"
         if fileinfo.get("type") == "folder":
             return schemas.FileItem(
                 storage=self.schema.value,
@@ -428,6 +435,17 @@ class AliPan(StorageBase, metaclass=Singleton):
                 break
         return items
 
+    def _delay_get_item(self, path: Path) -> Optional[schemas.FileItem]:
+        """
+        自动延迟重试 get_item 模块
+        """
+        for _ in range(2):
+            time.sleep(2)
+            fileitem = self.get_item(path)
+            if fileitem:
+                return fileitem
+        return None
+
     def create_folder(self, parent_item: schemas.FileItem, name: str) -> Optional[schemas.FileItem]:
         """
         创建目录
@@ -437,7 +455,7 @@ class AliPan(StorageBase, metaclass=Singleton):
             "/adrive/v1.0/openFile/create",
             json={
                 "drive_id": parent_item.drive_id,
-                "parent_file_id": parent_item.fileid,
+                "parent_file_id": parent_item.fileid or "root",
                 "name": name,
                 "type": "folder"
             }
@@ -450,7 +468,7 @@ class AliPan(StorageBase, metaclass=Singleton):
         # 缓存新目录
         new_path = Path(parent_item.path) / name
         self._id_cache[str(new_path)] = (resp.get("drive_id"), resp.get("file_id"))
-        return self.get_item(new_path)
+        return self._delay_get_item(new_path)
 
     @staticmethod
     def _calculate_pre_hash(file_path: Path):
@@ -628,6 +646,29 @@ class AliPan(StorageBase, metaclass=Singleton):
             raise Exception(resp.get("message"))
         return resp
 
+    @staticmethod
+    def _log_progress(desc: str, total: int) -> tqdm:
+        """
+        创建一个可以输出到日志的进度条
+        """
+
+        class TqdmToLogger(io.StringIO):
+            def write(s, buf):  # noqa
+                buf = buf.strip('\r\n\t ')
+                if buf:
+                    logger.info(buf)
+
+        return tqdm(
+            total=total,
+            unit='B',
+            unit_scale=True,
+            desc=desc,
+            file=TqdmToLogger(),
+            mininterval=1.0,
+            maxinterval=5.0,
+            miniters=1
+        )
+
     def upload(self, target_dir: schemas.FileItem, local_path: Path,
                new_name: Optional[str] = None) -> Optional[schemas.FileItem]:
         """
@@ -646,7 +687,7 @@ class AliPan(StorageBase, metaclass=Singleton):
                                        chunk_size=chunk_size)
         if create_res.get('rapid_upload', False):
             logger.info(f"【阿里云盘】{target_name} 秒传完成！")
-            return self.get_item(target_path)
+            return self._delay_get_item(target_path)
 
         if create_res.get("exist", False):
             logger.info(f"【阿里云盘】{target_name} 已存在")
@@ -668,13 +709,7 @@ class AliPan(StorageBase, metaclass=Singleton):
 
         # 4. 初始化进度条
         logger.info(f"【阿里云盘】开始上传: {local_path} -> {target_path}，分片数：{len(part_info_list)}")
-        progress_bar = tqdm(
-            total=file_size,
-            unit='B',
-            unit_scale=True,
-            desc="上传进度",
-            ascii=True
-        )
+        progress_bar = self._log_progress(f"【阿里云盘】{target_name} 上传进度", file_size)
 
         # 5. 分片上传循环
         with open(local_path, 'rb') as f:
@@ -828,7 +863,7 @@ class AliPan(StorageBase, metaclass=Singleton):
             if resp.get("code"):
                 logger.debug(f"【阿里云盘】获取文件信息失败: {resp.get('message')}")
                 return None
-            return self.__get_fileitem(resp, parent=f"{str(path.parent)}/")
+            return self.__get_fileitem(resp, parent=str(path.parent))
         except Exception as e:
             logger.debug(f"【阿里云盘】获取文件信息失败: {str(e)}")
             return None
@@ -854,7 +889,7 @@ class AliPan(StorageBase, metaclass=Singleton):
         if folder:
             return folder
         # 逐级查找和创建目录
-        fileitem = schemas.FileItem(storage=self.schema.value, path="/")
+        fileitem = schemas.FileItem(storage=self.schema.value, path="/", drive_id=self._default_drive_id)
         for part in path.parts[1:]:
             dir_file = __find_dir(fileitem, part)
             if dir_file:
@@ -895,7 +930,7 @@ class AliPan(StorageBase, metaclass=Singleton):
             return False
         # 重命名
         new_path = Path(path) / fileitem.name
-        new_file = self.get_item(new_path)
+        new_file = self._delay_get_item(new_path)
         self.rename(new_file, new_name)
         # 更新缓存
         del self._id_cache[fileitem.path]
@@ -957,3 +992,5 @@ class AliPan(StorageBase, metaclass=Singleton):
             )
         except NoCheckInException:
             return None
+        except SessionInvalidException:
+            return None

app/modules/filemanager/storages/u115.py

@@ -1,6 +1,6 @@
 import base64
 import hashlib
-import json
+import io
 import secrets
 import threading
 import time
@@ -306,6 +306,17 @@ class U115Pan(StorageBase, metaclass=Singleton):
                     sha1.update(chunk)
         return sha1.hexdigest()
 
+    def _delay_get_item(self, path: Path) -> Optional[schemas.FileItem]:
+        """
+        自动延迟重试 get_item 模块
+        """
+        for _ in range(2):
+            time.sleep(2)
+            fileitem = self.get_item(path)
+            if fileitem:
+                return fileitem
+        return None
+
     def init_storage(self):
         pass
 
@@ -323,6 +334,8 @@ class U115Pan(StorageBase, metaclass=Singleton):
             cid = '0'
         else:
             cid = fileitem.fileid
+            if not cid:
+                cid = self._path_to_id(fileitem.path)
 
         items = []
         offset = 0
@@ -373,7 +386,7 @@ class U115Pan(StorageBase, metaclass=Singleton):
             "POST",
             "/open/folder/add",
             data={
-                "pid": int(parent_item.fileid),
+                "pid": int(parent_item.fileid or "0"),
                 "file_name": name
             }
         )
@@ -397,17 +410,37 @@ class U115Pan(StorageBase, metaclass=Singleton):
             modify_time=int(time.time())
         )
 
+    @staticmethod
+    def _log_progress(desc: str, total: int) -> tqdm:
+        """
+        创建一个可以输出到日志的进度条
+        """
+
+        class TqdmToLogger(io.StringIO):
+            def write(s, buf):  # noqa
+                buf = buf.strip('\r\n\t ')
+                if buf:
+                    logger.info(buf)
+
+        return tqdm(
+            total=total,
+            unit='B',
+            unit_scale=True,
+            desc=desc,
+            file=TqdmToLogger(),
+            mininterval=1.0,
+            maxinterval=5.0,
+            miniters=1
+        )
+
     def upload(self, target_dir: schemas.FileItem, local_path: Path,
                new_name: Optional[str] = None) -> Optional[schemas.FileItem]:
         """
         实现带秒传、断点续传和二次认证的文件上传
         """
 
-        def encode_callback(cb: dict):
-            """
-            回调参数Base64编码函数
-            """
-            return oss2.utils.b64encode_as_string(json.dumps(cb).strip())
+        def encode_callback(cb: str) -> str:
+            return oss2.utils.b64encode_as_string(cb)
 
         target_name = new_name or local_path.name
         target_path = Path(target_dir.path) / target_name
@@ -491,7 +524,32 @@ class U115Pan(StorageBase, metaclass=Singleton):
         # Step 3: 秒传
         if init_result.get("status") == 2:
             logger.info(f"【115】{target_name} 秒传成功")
-            return self.get_item(target_path)
+            file_id = init_result.get("file_id", None)
+            if file_id:
+                logger.debug(f"【115】{target_name} 使用秒传返回ID获取文件信息")
+                time.sleep(2)
+                info_resp = self._request_api(
+                    "GET",
+                    "/open/folder/get_info",
+                    "data",
+                    params={
+                        "file_id": int(file_id)
+                    }
+                )
+                if info_resp:
+                    return schemas.FileItem(
+                        storage=self.schema.value,
+                        fileid=str(info_resp["file_id"]),
+                        path=str(target_path) + ("/" if info_resp["file_category"] == "0" else ""),
+                        type="file" if info_resp["file_category"] == "1" else "dir",
+                        name=info_resp["file_name"],
+                        basename=Path(info_resp["file_name"]).stem,
+                        extension=Path(info_resp["file_name"]).suffix[1:] if info_resp["file_category"] == "1" else None,
+                        pickcode=info_resp["pick_code"],
+                        size=StringUtils.num_filesize(info_resp['size']) if info_resp["file_category"] == "1" else None,
+                        modify_time=info_resp["utime"]
+                    )
+            return self._delay_get_item(target_path)
 
         # Step 4: 获取上传凭证
         token_resp = self._request_api(
@@ -533,12 +591,6 @@ class U115Pan(StorageBase, metaclass=Singleton):
             security_token=SecurityToken
         )
         bucket = oss2.Bucket(auth, endpoint, bucket_name)  # noqa
-        # 处理oss请求回调
-        callback_dict = json.loads(callback.get("callback"))
-        callback_var_dict = json.loads(callback.get("callback_var"))
-        # 补充参数
-        logger.debug(f"【115】上传 Step 6 回调参数：{callback_dict} {callback_var_dict}")
-        # 填写不能包含Bucket名称在内的Object完整路径，例如exampledir/exampleobject.txt。
         # determine_part_size方法用于确定分片大小，设置分片大小为 100M
         part_size = determine_part_size(file_size, preferred_size=100 * 1024 * 1024)
 
@@ -582,8 +634,8 @@ class U115Pan(StorageBase, metaclass=Singleton):
 
         # 请求头
         headers = {
-            'X-oss-callback': encode_callback(callback_dict),
-            'x-oss-callback-var': encode_callback(callback_var_dict),
+            'X-oss-callback': encode_callback(callback["callback"]),
+            'x-oss-callback-var': encode_callback(callback["callback_var"]),
             'x-oss-forbid-overwrite': 'false'
         }
         try:
@@ -602,7 +654,7 @@ class U115Pan(StorageBase, metaclass=Singleton):
                 logger.error(f"【115】{target_name} 上传失败: {e.status}, 错误码: {e.code}, 详情: {e.message}")
                 return None
         # 返回结果
-        return self.get_item(target_path)
+        return self._delay_get_item(target_path)
 
     def download(self, fileitem: schemas.FileItem, path: Path = None) -> Optional[Path]:
         """
@@ -695,7 +747,7 @@ class U115Pan(StorageBase, metaclass=Singleton):
             return schemas.FileItem(
                 storage=self.schema.value,
                 fileid=str(resp["file_id"]),
-                path=str(path) + ("/" if resp["file_category"] == "1" else ""),
+                path=str(path) + ("/" if resp["file_category"] == "0" else ""),
                 type="file" if resp["file_category"] == "1" else "dir",
                 name=resp["file_name"],
                 basename=Path(resp["file_name"]).stem,
@@ -767,7 +819,7 @@ class U115Pan(StorageBase, metaclass=Singleton):
             return False
         if resp["state"]:
             new_path = Path(path) / fileitem.name
-            new_item = self.get_item(new_path)
+            new_item = self._delay_get_item(new_path)
             self.rename(new_item, new_name)
             # 更新缓存
             del self._id_cache[fileitem.path]
@@ -795,7 +847,7 @@ class U115Pan(StorageBase, metaclass=Singleton):
             return False
         if resp["state"]:
             new_path = Path(path) / fileitem.name
-            new_file = self.get_item(new_path)
+            new_file = self._delay_get_item(new_path)
             self.rename(new_file, new_name)
             # 更新缓存
             del self._id_cache[fileitem.path]

app/modules/filemanager/transhandler.py

@@ -0,0 +1,921 @@
+import re
+from pathlib import Path
+from threading import Lock
+from typing import Optional, List, Tuple
+
+from jinja2 import Template
+
+from app.core.config import settings
+from app.core.context import MediaInfo
+from app.core.event import eventmanager
+from app.core.meta import MetaBase
+from app.core.metainfo import MetaInfoPath
+from app.helper.message import TemplateHelper
+from app.log import logger
+from app.modules.filemanager.storages import StorageBase
+from app.schemas import TransferInfo, TmdbEpisode, TransferDirectoryConf, FileItem, TransferInterceptEventData
+from app.schemas.types import MediaType, ChainEventType
+from app.utils.system import SystemUtils
+from app.schemas import TransferRenameEventData
+
+lock = Lock()
+
+
+class TransHandler:
+    """
+    文件转移整理类
+    """
+
+    result: Optional[TransferInfo] = None
+    inner_lock: Lock = Lock()
+
+    def __init__(self):
+        self.__reset_result()
+
+    def __reset_result(self):
+        """
+        重置结果
+        """
+        self.result = TransferInfo()
+
+    def __set_result(self, **kwargs):
+        """
+        设置结果
+        """
+        with self.inner_lock:
+            # 设置值
+            for key, value in kwargs.items():
+                if hasattr(self.result, key):
+                    current_value = getattr(self.result, key)
+                    if current_value is None:
+                        current_value = value
+                    elif isinstance(current_value, list):
+                        if isinstance(value, list):
+                            current_value.extend(value)
+                        else:
+                            current_value.append(value)
+                    elif isinstance(current_value, dict):
+                        if isinstance(value, dict):
+                            current_value.update(value)
+                        else:
+                            current_value[key] = value
+                    elif isinstance(current_value, bool):
+                        current_value = value
+                    elif isinstance(current_value, int):
+                        current_value += (value or 0)
+                    else:
+                        current_value = value
+                    setattr(self.result, key, current_value)
+
+    def transfer_media(self,
+                       fileitem: FileItem,
+                       in_meta: MetaBase,
+                       mediainfo: MediaInfo,
+                       target_storage: str,
+                       target_path: Path,
+                       transfer_type: str,
+                       source_oper: StorageBase,
+                       target_oper: StorageBase,
+                       need_scrape: Optional[bool] = False,
+                       need_rename: Optional[bool] = True,
+                       need_notify: Optional[bool] = True,
+                       overwrite_mode: Optional[str] = None,
+                       episodes_info: List[TmdbEpisode] = None
+                       ) -> TransferInfo:
+        """
+        识别并整理一个文件或者一个目录下的所有文件
+        :param fileitem: 整理的文件对象，可能是一个文件也可以是一个目录
+        :param in_meta：预识别元数据
+        :param mediainfo: 媒体信息
+        :param target_storage: 目标存储
+        :param target_path: 目标路径
+        :param transfer_type: 文件整理方式
+        :param source_oper: 源存储操作对象
+        :param target_oper: 目标存储操作对象
+        :param need_scrape: 是否需要刮削
+        :param need_rename: 是否需要重命名
+        :param need_notify: 是否需要通知
+        :param overwrite_mode: 覆盖模式
+        :param episodes_info: 当前季的全部集信息
+        :return: TransferInfo、错误信息
+        """
+
+        # 重置结果
+        self.__reset_result()
+
+        # 重命名格式
+        rename_format = settings.TV_RENAME_FORMAT \
+            if mediainfo.type == MediaType.TV else settings.MOVIE_RENAME_FORMAT
+
+        # 判断是否为文件夹
+        if fileitem.type == "dir":
+            # 整理整个目录，一般为蓝光原盘
+            if need_rename:
+                new_path = self.get_rename_path(
+                    path=target_path,
+                    template_string=rename_format,
+                    rename_dict=self.get_naming_dict(meta=in_meta,
+                                                     mediainfo=mediainfo)
+                ).parent
+            else:
+                new_path = target_path / fileitem.name
+            # 整理目录
+            new_diritem, errmsg = self.__transfer_dir(fileitem=fileitem,
+                                                      mediainfo=mediainfo,
+                                                      source_oper=source_oper,
+                                                      target_oper=target_oper,
+                                                      target_storage=target_storage,
+                                                      target_path=new_path,
+                                                      transfer_type=transfer_type)
+            if not new_diritem:
+                logger.error(f"文件夹 {fileitem.path} 整理失败：{errmsg}")
+                self.__set_result(success=False,
+                                  message=errmsg,
+                                  fileitem=fileitem,
+                                  transfer_type=transfer_type,
+                                  need_notify=need_notify)
+                return self.result
+
+            logger.info(f"文件夹 {fileitem.path} 整理成功")
+            # 计算目录下所有文件大小
+            total_size = sum(file.stat().st_size for file in Path(fileitem.path).rglob('*') if file.is_file())
+            # 返回整理后的路径
+            self.__set_result(success=True,
+                              fileitem=fileitem,
+                              target_item=new_diritem,
+                              target_diritem=new_diritem,
+                              total_size=total_size,
+                              need_scrape=need_scrape,
+                              need_notify=need_notify,
+                              transfer_type=transfer_type)
+            return self.result
+        else:
+            # 整理单个文件
+            if mediainfo.type == MediaType.TV:
+                # 电视剧
+                if in_meta.begin_episode is None:
+                    logger.warn(f"文件 {fileitem.path} 整理失败：未识别到文件集数")
+                    self.__set_result(success=False,
+                                      message=f"未识别到文件集数",
+                                      fileitem=fileitem,
+                                      fail_list=[fileitem.path],
+                                      transfer_type=transfer_type,
+                                      need_notify=need_notify)
+                    return self.result
+
+                # 文件结束季为空
+                in_meta.end_season = None
+                # 文件总季数为1
+                if in_meta.total_season:
+                    in_meta.total_season = 1
+                # 文件不可能超过2集
+                if in_meta.total_episode > 2:
+                    in_meta.total_episode = 1
+                    in_meta.end_episode = None
+
+            # 目的文件名
+            if need_rename:
+                new_file = self.get_rename_path(
+                    path=target_path,
+                    template_string=rename_format,
+                    rename_dict=self.get_naming_dict(
+                        meta=in_meta,
+                        mediainfo=mediainfo,
+                        episodes_info=episodes_info,
+                        file_ext=f".{fileitem.extension}"
+                    )
+                )
+            else:
+                new_file = target_path / fileitem.name
+
+            # 判断是否要覆盖
+            overflag = False
+            # 计算重命名中的文件夹层级
+            rename_format_level = len(rename_format.split("/")) - 1
+            folder_path = new_file.parents[rename_format_level - 1]
+            # 目标目录
+            target_diritem = target_oper.get_folder(folder_path)
+            if not target_diritem:
+                logger.error(f"目标目录 {folder_path} 获取失败")
+                self.__set_result(success=False,
+                                  message=f"目标目录 {folder_path} 获取失败",
+                                  fileitem=fileitem,
+                                  fail_list=[fileitem.path],
+                                  transfer_type=transfer_type,
+                                  need_notify=need_notify)
+                return self.result
+            # 目标文件
+            target_item = target_oper.get_item(new_file)
+            if target_item:
+                # 目标文件已存在
+                target_file = new_file
+                if target_storage == "local" and new_file.is_symlink():
+                    target_file = new_file.readlink()
+                    if not target_file.exists():
+                        overflag = True
+                if not overflag:
+                    # 目标文件已存在
+                    logger.info(f"目的文件系统中已经存在同名文件 {target_file}，当前整理覆盖模式设置为 {overwrite_mode}")
+                    if overwrite_mode == 'always':
+                        # 总是覆盖同名文件
+                        overflag = True
+                    elif overwrite_mode == 'size':
+                        # 存在时大覆盖小
+                        if target_item.size < fileitem.size:
+                            logger.info(f"目标文件文件大小更小，将覆盖：{new_file}")
+                            overflag = True
+                        else:
+                            self.__set_result(success=False,
+                                              message=f"媒体库存在同名文件，且质量更好",
+                                              fileitem=fileitem,
+                                              target_item=target_item,
+                                              target_diritem=target_diritem,
+                                              fail_list=[fileitem.path],
+                                              transfer_type=transfer_type,
+                                              need_notify=need_notify)
+                            return self.result
+                    elif overwrite_mode == 'never':
+                        # 存在不覆盖
+                        self.__set_result(success=False,
+                                          message=f"媒体库存在同名文件，当前覆盖模式为不覆盖",
+                                          fileitem=fileitem,
+                                          target_item=target_item,
+                                          target_diritem=target_diritem,
+                                          fail_list=[fileitem.path],
+                                          transfer_type=transfer_type,
+                                          need_notify=need_notify)
+                        return self.result
+                    elif overwrite_mode == 'latest':
+                        # 仅保留最新版本
+                        logger.info(f"当前整理覆盖模式设置为仅保留最新版本，将覆盖：{new_file}")
+                        overflag = True
+            else:
+                if overwrite_mode == 'latest':
+                    # 文件不存在，但仅保留最新版本
+                    logger.info(f"当前整理覆盖模式设置为 {overwrite_mode}，仅保留最新版本，正在删除已有版本文件 ...")
+                    self.__delete_version_files(target_oper, new_file)
+            # 整理文件
+            new_item, err_msg = self.__transfer_file(fileitem=fileitem,
+                                                     mediainfo=mediainfo,
+                                                     target_storage=target_storage,
+                                                     target_file=new_file,
+                                                     transfer_type=transfer_type,
+                                                     over_flag=overflag,
+                                                     source_oper=source_oper,
+                                                     target_oper=target_oper)
+            if not new_item:
+                logger.error(f"文件 {fileitem.path} 整理失败：{err_msg}")
+                self.__set_result(success=False,
+                                  message=err_msg,
+                                  fileitem=fileitem,
+                                  fail_list=[fileitem.path],
+                                  transfer_type=transfer_type,
+                                  need_notify=need_notify)
+                return self.result
+
+            logger.info(f"文件 {fileitem.path} 整理成功")
+            self.__set_result(success=True,
+                              fileitem=fileitem,
+                              target_item=new_item,
+                              target_diritem=target_diritem,
+                              need_scrape=need_scrape,
+                              transfer_type=transfer_type,
+                              need_notify=need_notify)
+            return self.result
+
+    @staticmethod
+    def __transfer_command(fileitem: FileItem, target_storage: str,
+                           source_oper: StorageBase, target_oper: StorageBase,
+                           target_file: Path, transfer_type: str,
+                           ) -> Tuple[Optional[FileItem], str]:
+        """
+        处理单个文件
+        :param fileitem: 源文件
+        :param target_storage: 目标存储
+        :param source_oper: 源存储操作对象
+        :param target_oper: 目标存储操作对象
+        :param target_file: 目标文件路径
+        :param transfer_type: 整理方式
+        """
+
+        def __get_targetitem(_path: Path) -> FileItem:
+            """
+            获取文件信息
+            """
+            return FileItem(
+                storage=target_storage,
+                path=str(_path).replace("\\", "/"),
+                name=_path.name,
+                basename=_path.stem,
+                type="file",
+                size=_path.stat().st_size,
+                extension=_path.suffix.lstrip('.'),
+                modify_time=_path.stat().st_mtime
+            )
+
+        if (fileitem.storage != target_storage
+                and fileitem.storage != "local" and target_storage != "local"):
+            return None, f"不支持 {fileitem.storage} 到 {target_storage} 的文件整理"
+
+        # 加锁
+        with lock:
+            if fileitem.storage == "local" and target_storage == "local":
+                # 创建目录
+                if not target_file.parent.exists():
+                    target_file.parent.mkdir(parents=True)
+                # 本地到本地
+                if transfer_type == "copy":
+                    state = source_oper.copy(fileitem, target_file.parent, target_file.name)
+                elif transfer_type == "move":
+                    state = source_oper.move(fileitem, target_file.parent, target_file.name)
+                elif transfer_type == "link":
+                    state = source_oper.link(fileitem, target_file)
+                elif transfer_type == "softlink":
+                    state = source_oper.softlink(fileitem, target_file)
+                else:
+                    return None, f"不支持的整理方式：{transfer_type}"
+                if state:
+                    return __get_targetitem(target_file), ""
+                else:
+                    return None, f"{fileitem.path} {transfer_type} 失败"
+            elif fileitem.storage == "local" and target_storage != "local":
+                # 本地到网盘
+                filepath = Path(fileitem.path)
+                if not filepath.exists():
+                    return None, f"文件 {filepath} 不存在"
+                if transfer_type == "copy":
+                    # 复制
+                    # 根据目的路径创建文件夹
+                    target_fileitem = target_oper.get_folder(target_file.parent)
+                    if target_fileitem:
+                        # 上传文件
+                        new_item = target_oper.upload(target_fileitem, filepath, target_file.name)
+                        if new_item:
+                            return new_item, ""
+                        else:
+                            return None, f"{fileitem.path} 上传 {target_storage} 失败"
+                    else:
+                        return None, f"【{target_storage}】{target_file.parent} 目录获取失败"
+                elif transfer_type == "move":
+                    # 移动
+                    # 根据目的路径获取文件夹
+                    target_fileitem = target_oper.get_folder(target_file.parent)
+                    if target_fileitem:
+                        # 上传文件
+                        new_item = target_oper.upload(target_fileitem, filepath, target_file.name)
+                        if new_item:
+                            # 删除源文件
+                            source_oper.delete(fileitem)
+                            return new_item, ""
+                        else:
+                            return None, f"{fileitem.path} 上传 {target_storage} 失败"
+                    else:
+                        return None, f"【{target_storage}】{target_file.parent} 目录获取失败"
+            elif fileitem.storage != "local" and target_storage == "local":
+                # 网盘到本地
+                if target_file.exists():
+                    logger.warn(f"文件已存在：{target_file}")
+                    return __get_targetitem(target_file), ""
+                # 网盘到本地
+                if transfer_type in ["copy", "move"]:
+                    # 下载
+                    tmp_file = source_oper.download(fileitem=fileitem, path=target_file.parent)
+                    if tmp_file:
+                        # 创建目录
+                        if not target_file.parent.exists():
+                            target_file.parent.mkdir(parents=True)
+                        # 将tmp_file移动后target_file
+                        SystemUtils.move(tmp_file, target_file)
+                        if transfer_type == "move":
+                            # 删除源文件
+                            source_oper.delete(fileitem)
+                        return __get_targetitem(target_file), ""
+                    else:
+                        return None, f"{fileitem.path} {fileitem.storage} 下载失败"
+            elif fileitem.storage == target_storage:
+                # 同一网盘
+                if transfer_type == "copy":
+                    # 复制文件到新目录
+                    target_fileitem = target_oper.get_folder(target_file.parent)
+                    if target_fileitem:
+                        if source_oper.move(fileitem, Path(target_fileitem.path), target_file.name):
+                            return target_oper.get_item(target_file), ""
+                        else:
+                            return None, f"【{target_storage}】{fileitem.path} 复制文件失败"
+                    else:
+                        return None, f"【{target_storage}】{target_file.parent} 目录获取失败"
+                elif transfer_type == "move":
+                    # 移动文件到新目录
+                    target_fileitem = target_oper.get_folder(target_file.parent)
+                    if target_fileitem:
+                        if source_oper.move(fileitem, Path(target_fileitem.path), target_file.name):
+                            return target_oper.get_item(target_file), ""
+                        else:
+                            return None, f"【{target_storage}】{fileitem.path} 移动文件失败"
+                    else:
+                        return None, f"【{target_storage}】{target_file.parent} 目录获取失败"
+                else:
+                    return None, f"不支持的整理方式：{transfer_type}"
+
+        return None, "未知错误"
+
+    def __transfer_other_files(self, fileitem: FileItem, target_storage: str,
+                               source_oper: StorageBase, target_oper: StorageBase,
+                               target_file: Path, transfer_type: str) -> Tuple[bool, str]:
+        """
+        根据文件名整理其他相关文件
+        :param fileitem: 源文件
+        :param target_storage: 目标存储
+        :param source_oper: 源存储操作对象
+        :param target_oper: 目标存储操作对象
+        :param target_file: 目标路径
+        :param transfer_type: 整理方式
+        """
+        # 整理字幕
+        state, errmsg = self.__transfer_subtitles(fileitem=fileitem,
+                                                  target_storage=target_storage,
+                                                  source_oper=source_oper,
+                                                  target_oper=target_oper,
+                                                  target_file=target_file,
+                                                  transfer_type=transfer_type)
+        if not state:
+            return False, errmsg
+        # 整理音轨文件
+        state, errmsg = self.__transfer_audio_track_files(fileitem=fileitem,
+                                                          target_storage=target_storage,
+                                                          source_oper=source_oper,
+                                                          target_oper=target_oper,
+                                                          target_file=target_file,
+                                                          transfer_type=transfer_type)
+
+        return state, errmsg
+
+    def __transfer_subtitles(self, fileitem: FileItem, target_storage: str,
+                             source_oper: StorageBase, target_oper: StorageBase,
+                             target_file: Path, transfer_type: str) -> Tuple[bool, str]:
+        """
+        根据文件名整理对应字幕文件
+        :param fileitem: 源文件
+        :param target_storage: 目标存储
+        :param source_oper: 源存储操作对象
+        :param target_oper: 目标存储操作对象
+        :param target_file: 目标路径
+        :param transfer_type: 整理方式
+        """
+        # 字幕正则式
+        _zhcn_sub_re = r"([.\[(](((zh[-_])?(cn|ch[si]|sg|sc))|zho?" \
+                       r"|chinese|(cn|ch[si]|sg|zho?|eng)[-_&]?(cn|ch[si]|sg|zho?|eng)" \
+                       r"|简[体中]?)[.\])])" \
+                       r"|([\u4e00-\u9fa5]{0,3}[中双][\u4e00-\u9fa5]{0,2}[字文语][\u4e00-\u9fa5]{0,3})" \
+                       r"|简体|简中|JPSC|sc_jp" \
+                       r"|(?<![a-z0-9])gb(?![a-z0-9])"
+        _zhtw_sub_re = r"([.\[(](((zh[-_])?(hk|tw|cht|tc))" \
+                       r"|(cht|eng)[-_&]?(cht|eng)" \
+                       r"|繁[体中]?)[.\])])" \
+                       r"|繁体中[文字]|中[文字]繁体|繁体|JPTC|tc_jp" \
+                       r"|(?<![a-z0-9])big5(?![a-z0-9])"
+        _eng_sub_re = r"[.\[(]eng[.\])]"
+
+        # 比对文件名并整理字幕
+        org_path = Path(fileitem.path)
+        # 查找上级文件项
+        parent_item: FileItem = source_oper.get_parent(fileitem)
+        if not parent_item:
+            return False, f"{org_path} 上级目录获取失败"
+        # 字幕文件列表
+        file_list: List[FileItem] = source_oper.list(parent_item) or []
+        file_list = [f for f in file_list if f.type == "file" and f.extension
+                     and f".{f.extension.lower()}" in settings.RMT_SUBEXT]
+        if len(file_list) == 0:
+            logger.info(f"{parent_item.path} 目录下没有找到字幕文件...")
+        else:
+            logger.info(f"字幕文件清单：{[f.name for f in file_list]}")
+            # 识别文件名
+            metainfo = MetaInfoPath(org_path)
+            for sub_item in file_list:
+                # 识别字幕文件名
+                sub_file_name = re.sub(_zhtw_sub_re,
+                                       ".",
+                                       re.sub(_zhcn_sub_re,
+                                              ".",
+                                              sub_item.name,
+                                              flags=re.I),
+                                       flags=re.I)
+                sub_file_name = re.sub(_eng_sub_re, ".", sub_file_name, flags=re.I)
+                sub_metainfo = MetaInfoPath(Path(sub_item.path))
+                # 匹配字幕文件名
+                if (org_path.stem == Path(sub_file_name).stem) or \
+                        (sub_metainfo.cn_name and sub_metainfo.cn_name == metainfo.cn_name) \
+                        or (sub_metainfo.en_name and sub_metainfo.en_name == metainfo.en_name):
+                    if metainfo.part and metainfo.part != sub_metainfo.part:
+                        continue
+                    if metainfo.season \
+                            and metainfo.season != sub_metainfo.season:
+                        continue
+                    if metainfo.episode \
+                            and metainfo.episode != sub_metainfo.episode:
+                        continue
+                    new_file_type = ""
+                    # 兼容jellyfin字幕识别(多重识别), emby则会识别最后一个后缀
+                    if re.search(_zhcn_sub_re, sub_item.name, re.I):
+                        new_file_type = ".chi.zh-cn"
+                    elif re.search(_zhtw_sub_re, sub_item.name,
+                                   re.I):
+                        new_file_type = ".zh-tw"
+                    elif re.search(_eng_sub_re, sub_item.name, re.I):
+                        new_file_type = ".eng"
+                    # 通过对比字幕文件大小  尽量整理所有存在的字幕
+                    file_ext = f".{sub_item.extension}"
+                    new_sub_tag_dict = {
+                        ".eng": ".英文",
+                        ".chi.zh-cn": ".简体中文",
+                        ".zh-tw": ".繁体中文"
+                    }
+                    new_sub_tag_list = [
+                        (".default" + new_file_type if (
+                                (settings.DEFAULT_SUB == "zh-cn" and new_file_type == ".chi.zh-cn") or
+                                (settings.DEFAULT_SUB == "zh-tw" and new_file_type == ".zh-tw") or
+                                (settings.DEFAULT_SUB == "eng" and new_file_type == ".eng")
+                        ) else new_file_type) if t == 0 else "%s%s(%s)" % (new_file_type,
+                                                                           new_sub_tag_dict.get(
+                                                                               new_file_type, ""
+                                                                           ),
+                                                                           t) for t in range(6)
+                    ]
+                    for new_sub_tag in new_sub_tag_list:
+                        new_file: Path = target_file.with_name(target_file.stem + new_sub_tag + file_ext)
+                        # 如果字幕文件不存在, 直接整理字幕, 并跳出循环
+                        try:
+                            logger.debug(f"正在处理字幕：{sub_item.name}")
+                            new_item, errmsg = self.__transfer_command(fileitem=sub_item,
+                                                                       target_storage=target_storage,
+                                                                       source_oper=source_oper,
+                                                                       target_oper=target_oper,
+                                                                       target_file=new_file,
+                                                                       transfer_type=transfer_type)
+                            if new_item:
+                                logger.info(f"字幕 {sub_item.name} 整理完成")
+                                self.__set_result(
+                                    subtitle_list=[sub_item.path],
+                                    subtitle_list_new=[new_item.path],
+                                )
+                                break
+                            else:
+                                logger.error(f"字幕 {sub_item.name} 整理失败：{errmsg}")
+                                return False, errmsg
+                        except Exception as error:
+                            logger.info(f"字幕 {new_file} 出错了,原因: {str(error)}")
+        return True, ""
+
+    def __transfer_audio_track_files(self, fileitem: FileItem, target_storage: str,
+                                     source_oper: StorageBase, target_oper: StorageBase,
+                                     target_file: Path, transfer_type: str) -> Tuple[bool, str]:
+        """
+        根据文件名整理对应音轨文件
+        :param fileitem: 源文件
+        :param target_storage: 目标存储
+        :param source_oper: 源存储操作对象
+        :param target_oper: 目标存储操作对象
+        :param target_file: 目标路径
+        :param transfer_type: 整理方式
+        """
+        org_path = Path(fileitem.path)
+        # 查找上级文件项
+        parent_item: FileItem = source_oper.get_parent(fileitem)
+        if not parent_item:
+            return False, f"{org_path} 上级目录获取失败"
+        file_list: List[FileItem] = source_oper.list(parent_item)
+        # 匹配音轨文件
+        pending_file_list: List[FileItem] = [file for file in file_list
+                                             if Path(file.name).stem == org_path.stem
+                                             and file.type == "file" and file.extension
+                                             and f".{file.extension.lower()}" in settings.RMT_AUDIOEXT]
+        if len(pending_file_list) == 0:
+            return True, f"{parent_item.path} 目录下没有找到匹配的音轨文件"
+        logger.debug("音轨文件清单：" + str(pending_file_list))
+        for track_file in pending_file_list:
+            track_ext = f".{track_file.extension}"
+            new_track_file = target_file.with_name(target_file.stem + track_ext)
+            try:
+                logger.info(f"正在整理音轨文件：{track_file} 到 {new_track_file}")
+                new_item, errmsg = self.__transfer_command(fileitem=track_file,
+                                                           target_storage=target_storage,
+                                                           source_oper=source_oper,
+                                                           target_oper=target_oper,
+                                                           target_file=new_track_file,
+                                                           transfer_type=transfer_type)
+                if new_item:
+                    logger.info(f"音轨文件 {org_path.name} 整理完成")
+                    self.__set_result(
+                        audio_list=[track_file.path],
+                        audio_list_new=[new_item.path],
+                    )
+                else:
+                    logger.error(f"音轨文件 {org_path.name} 整理失败：{errmsg}")
+            except Exception as error:
+                logger.error(f"音轨文件 {org_path.name} 整理失败：{str(error)}")
+        return True, ""
+
+    def __transfer_dir(self, fileitem: FileItem, mediainfo: MediaInfo,
+                       source_oper: StorageBase, target_oper: StorageBase,
+                       transfer_type: str, target_storage: str, target_path: Path) -> Tuple[Optional[FileItem], str]:
+        """
+        整理整个文件夹
+        :param fileitem: 源文件
+        :param mediainfo: 媒体信息
+        :param source_oper: 源存储操作对象
+        :param target_oper: 目标存储操作对象
+        :param transfer_type: 整理方式
+        :param target_storage: 目标存储
+        :param target_path: 目标路径
+        """
+        logger.info(f"正在整理目录：{fileitem.path} 到 {target_path}")
+        target_item = target_oper.get_folder(target_path)
+        if not target_item:
+            return None, f"获取目标目录失败：{target_path}"
+        event_data = TransferInterceptEventData(
+            fileitem=fileitem,
+            mediainfo=mediainfo,
+            target_storage=target_storage,
+            target_path=target_path,
+            transfer_type=transfer_type
+        )
+        event = eventmanager.send_event(ChainEventType.TransferIntercept, event_data)
+        if event and event.event_data:
+            event_data = event.event_data
+            # 如果事件被取消，跳过文件整理
+            if event_data.cancel:
+                logger.debug(
+                    f"Transfer dir canceled by event: {event_data.source},"
+                    f"Reason: {event_data.reason}")
+                return None, event_data.reason
+        # 处理所有文件
+        state, errmsg = self.__transfer_dir_files(fileitem=fileitem,
+                                                  target_storage=target_storage,
+                                                  source_oper=source_oper,
+                                                  target_oper=target_oper,
+                                                  target_path=target_path,
+                                                  transfer_type=transfer_type)
+        if state:
+            return target_item, errmsg
+        else:
+            return None, errmsg
+
+    def __transfer_dir_files(self, fileitem: FileItem, target_storage: str,
+                             source_oper: StorageBase, target_oper: StorageBase,
+                             transfer_type: str, target_path: Path) -> Tuple[bool, str]:
+        """
+        按目录结构整理目录下所有文件
+        :param fileitem: 源文件
+        :param target_storage: 目标存储
+        :param source_oper: 源存储操作对象
+        :param target_oper: 目标存储操作对象
+        :param target_path: 目标路径
+        :param transfer_type: 整理方式
+        """
+        file_list: List[FileItem] = source_oper.list(fileitem)
+        # 整理文件
+        for item in file_list:
+            if item.type == "dir":
+                # 递归整理目录
+                new_path = target_path / item.name
+                state, errmsg = self.__transfer_dir_files(fileitem=item,
+                                                          target_storage=target_storage,
+                                                          source_oper=source_oper,
+                                                          target_oper=target_oper,
+                                                          transfer_type=transfer_type,
+                                                          target_path=new_path)
+                if not state:
+                    return False, errmsg
+            else:
+                # 整理文件
+                new_file = target_path / item.name
+                new_item, errmsg = self.__transfer_command(fileitem=item,
+                                                           target_storage=target_storage,
+                                                           source_oper=source_oper,
+                                                           target_oper=target_oper,
+                                                           target_file=new_file,
+                                                           transfer_type=transfer_type)
+                if not new_item:
+                    return False, errmsg
+                self.__set_result(
+                    file_list=[item.path],
+                    file_list_new=[new_item.path],
+                )
+        # 返回成功
+        return True, ""
+
+    def __transfer_file(self, fileitem: FileItem, mediainfo: MediaInfo,
+                        source_oper: StorageBase, target_oper: StorageBase,
+                        target_storage: str, target_file: Path,
+                        transfer_type: str, over_flag: Optional[bool] = False) -> Tuple[Optional[FileItem], str]:
+        """
+        整理一个文件，同时处理其他相关文件
+        :param fileitem: 原文件
+        :param mediainfo: 媒体信息
+        :param source_oper: 源存储操作对象
+        :param target_oper: 目标存储操作对象
+        :param target_storage: 目标存储
+        :param target_file: 新文件
+        :param transfer_type: 整理方式
+        :param over_flag: 是否覆盖，为True时会先删除再整理
+        :param source_oper: 源存储操作对象
+        :param target_oper: 目标存储操作对象
+        """
+        logger.info(f"正在整理文件：【{fileitem.storage}】{fileitem.path} 到 【{target_storage}】{target_file}，"
+                    f"操作类型：{transfer_type}")
+        event_data = TransferInterceptEventData(
+            fileitem=fileitem,
+            mediainfo=mediainfo,
+            target_storage=target_storage,
+            target_path=target_file,
+            transfer_type=transfer_type,
+            options={
+                "over_flag": over_flag
+            }
+        )
+        event = eventmanager.send_event(ChainEventType.TransferIntercept, event_data)
+        if event and event.event_data:
+            event_data = event.event_data
+            # 如果事件被取消，跳过文件整理
+            if event_data.cancel:
+                logger.debug(
+                    f"Transfer file canceled by event: {event_data.source},"
+                    f"Reason: {event_data.reason}")
+                return None, event_data.reason
+        if target_storage == "local" and (target_file.exists() or target_file.is_symlink()):
+            if not over_flag:
+                logger.warn(f"文件已存在：{target_file}")
+                return None, f"{target_file} 已存在"
+            else:
+                logger.info(f"正在删除已存在的文件：{target_file}")
+                target_file.unlink()
+        else:
+            exists_item = target_oper.get_item(target_file)
+            if exists_item:
+                if not over_flag:
+                    logger.warn(f"文件已存在：【{target_storage}】{target_file}")
+                    return None, f"【{target_storage}】{target_file} 已存在"
+                else:
+                    logger.info(f"正在删除已存在的文件：【{target_storage}】{target_file}")
+                    target_oper.delete(exists_item)
+        # 执行文件整理命令
+        new_item, errmsg = self.__transfer_command(fileitem=fileitem,
+                                                   target_storage=target_storage,
+                                                   source_oper=source_oper,
+                                                   target_oper=target_oper,
+                                                   target_file=target_file,
+                                                   transfer_type=transfer_type)
+        if new_item:
+            self.__set_result(
+                file_list=[fileitem.path],
+                file_list_new=[new_item.path],
+                file_count=1,
+                total_size=fileitem.size,
+            )
+            # 处理其他相关文件
+            self.__transfer_other_files(fileitem=fileitem,
+                                        target_storage=target_storage,
+                                        source_oper=source_oper,
+                                        target_oper=target_oper,
+                                        target_file=target_file,
+                                        transfer_type=transfer_type)
+            return new_item, errmsg
+
+        return None, errmsg
+
+    @staticmethod
+    def get_dest_path(mediainfo: MediaInfo, target_path: Path,
+                      need_type_folder: Optional[bool] = False, need_category_folder: Optional[bool] = False):
+        """
+        获取目标路径
+        """
+        if need_type_folder:
+            target_path = target_path / mediainfo.type.value
+        if need_category_folder and mediainfo.category:
+            target_path = target_path / mediainfo.category
+        return target_path
+
+    @staticmethod
+    def get_dest_dir(mediainfo: MediaInfo, target_dir: TransferDirectoryConf,
+                     need_type_folder: Optional[bool] = None, need_category_folder: Optional[bool] = None) -> Path:
+        """
+        根据设置并装媒体库目录
+        :param mediainfo: 媒体信息
+        :param target_dir: 媒体库根目录
+        :param need_type_folder: 是否需要按媒体类型创建目录
+        :param need_category_folder: 是否需要按媒体类别创建目录
+        """
+        if need_type_folder is None:
+            need_type_folder = target_dir.library_type_folder
+        if need_category_folder is None:
+            need_category_folder = target_dir.library_category_folder
+        if not target_dir.media_type and need_type_folder:
+            # 一级自动分类
+            library_dir = Path(target_dir.library_path) / mediainfo.type.value
+        elif target_dir.media_type and need_type_folder:
+            # 一级手动分类
+            library_dir = Path(target_dir.library_path) / target_dir.media_type
+        else:
+            library_dir = Path(target_dir.library_path)
+        if not target_dir.media_category and need_category_folder and mediainfo.category:
+            # 二级自动分类
+            library_dir = library_dir / mediainfo.category
+        elif target_dir.media_category and need_category_folder:
+            # 二级手动分类
+            library_dir = library_dir / target_dir.media_category
+
+        return library_dir
+
+    @staticmethod
+    def get_naming_dict(meta: MetaBase, mediainfo: MediaInfo, file_ext: Optional[str] = None,
+                        episodes_info: List[TmdbEpisode] = None) -> dict:
+        """
+        根据媒体信息，返回Format字典
+        :param meta: 文件元数据
+        :param mediainfo: 识别的媒体信息
+        :param file_ext: 文件扩展名
+        :param episodes_info: 当前季的全部集信息
+        """
+        return TemplateHelper().builder.build(meta=meta, mediainfo=mediainfo,
+                                              file_extension=file_ext, episodes_info=episodes_info)
+
+    @staticmethod
+    def __delete_version_files(storage_oper: StorageBase, path: Path) -> bool:
+        """
+        删除目录下的所有版本文件
+        :param storage_oper: 存储操作对象
+        :param path: 目录路径
+        """
+        # 存储
+        if not storage_oper:
+            return False
+        # 识别文件中的季集信息
+        meta = MetaInfoPath(path)
+        season = meta.season
+        episode = meta.episode
+        logger.warn(f"正在删除目标目录中其它版本的文件：{path.parent}")
+        # 获取父目录
+        parent_item = storage_oper.get_item(path.parent)
+        if not parent_item:
+            logger.warn(f"目录 {path.parent} 不存在")
+            return False
+        # 检索媒体文件
+        media_files = storage_oper.list(parent_item)
+        if not media_files:
+            logger.info(f"目录 {path.parent} 中没有文件")
+            return False
+        # 删除文件
+        for media_file in media_files:
+            media_path = Path(media_file.path)
+            if media_path == path:
+                continue
+            if media_file.type != "file":
+                continue
+            if f".{media_file.extension.lower()}" not in settings.RMT_MEDIAEXT:
+                continue
+            # 识别文件中的季集信息
+            filemeta = MetaInfoPath(media_path)
+            # 相同季集的文件才删除
+            if filemeta.season != season or filemeta.episode != episode:
+                continue
+            logger.info(f"正在删除文件：{media_file.name}")
+            storage_oper.delete(media_file)
+        return True
+
+    @staticmethod
+    def get_rename_path(template_string: str, rename_dict: dict, path: Path = None) -> Path:
+        """
+        生成重命名后的完整路径，支持智能重命名事件
+        :param template_string: Jinja2 模板字符串
+        :param rename_dict: 渲染上下文，用于替换模板中的变量
+        :param path: 可选的基础路径，如果提供，将在其基础上拼接生成的路径
+        :return: 生成的完整路径
+        """
+        # 创建jinja2模板对象
+        template = Template(template_string)
+        # 渲染生成的字符串
+        render_str = template.render(rename_dict)
+
+        logger.debug(f"Initial render string: {render_str}")
+        # 发送智能重命名事件
+        event_data = TransferRenameEventData(
+            template_string=template_string,
+            rename_dict=rename_dict,
+            render_str=render_str,
+            path=path
+        )
+        event = eventmanager.send_event(ChainEventType.TransferRename, event_data)
+        # 检查事件返回的结果
+        if event and event.event_data:
+            event_data: TransferRenameEventData = event.event_data
+            if event_data.updated and event_data.updated_str:
+                logger.debug(f"Render string updated by event: "
+                             f"{render_str} -> {event_data.updated_str} (source: {event_data.source})")
+                render_str = event_data.updated_str
+
+        # 目的路径
+        if path:
+            return path / render_str
+        else:
+            return Path(render_str)

app/modules/filter/__init__.py

@@ -21,8 +21,8 @@ class FilterModule(_ModuleBase):
     rule_set: Dict[str, dict] = {
         # 蓝光原盘
         "BLU": {
-            "include": [r'Blu-?Ray.+VC-?1|Blu-?Ray.+AVC|UHD.+blu-?ray.+HEVC|MiniBD'],
-            "exclude": [r'[Hx].?264|[Hx].?265|WEB-?DL|WEB-?RIP|REMUX']
+            "include": [r'(?i)(\bBlu-?Ray\b.*\b(?:VC-?1|AVC|MPEG-?2)\b|\b(?:UHD|4K|2160p)\b(?:.*Blu-?Ray)?.*\b(?:HEVC|H\.?265)\b|\bBlu-?Ray\b.*\b(?:UHD|4K|2160p)\b.*\b(?:HEVC|H\.?265)\b|\b(?:COMPLETE|FULL)\b.*\b(?:(?:UHD|4K|2160p)\b.*)?Blu-?Ray\b|\b(BD25|BD50|BD66|BD100|BDMV|MiniBD)\b)'],
+            "exclude": [r'(?i)(\b[XH]\.?264\b|\b[XH]\.?265\b|\bWEB-?DL\b|\bWEB-?RIP\b|\bHDTV(?:RIP)?\b|\bREMUX\b|\bBDRip\b|\bBRRip\b|\bHDRip\b|\bENCODE\b|\b(?<!WEB-|HDTV)RIP\b)']
         },
         # 4K
         "4K": {

app/modules/indexer/parser/yema.py

@@ -56,7 +56,11 @@ class TYemaSiteUserInfo(SiteParserBase):
         self.join_at = StringUtils.unify_datetime_str(user_info.get("registerTime"))
 
         self.upload = user_info.get('uploadSize')
-        self.download = user_info.get('downloadSize')
+        # 使用 promotionDownloadSize 获取真实下载量（考虑促销因素）
+        if "promotionDownloadSize" in user_info:
+            self.download = user_info.get('promotionDownloadSize')
+        else:
+            self.download = user_info.get('downloadSize')
         self.ratio = round(self.upload / (self.download or 1), 2)
         self.bonus = user_info.get("bonus")
         self.message_unread = 0

app/modules/indexer/spider/mtorrent.py

@@ -108,11 +108,17 @@ class MTorrentSpider:
                     category = MediaType.MOVIE.value
                 else:
                     category = MediaType.UNKNOWN.value
-                labels_value = self._labels.get(result.get('labels') or "0") or ""
-                if labels_value:
-                    labels = labels_value.split()
+                # 处理馒头新版标签
+                labels = []
+                labels_new = result.get( 'labelsNew' )
+                if labels_new:
+                    # 新版标签本身就是list
+                    labels = labels_new
                 else:
-                    labels = []
+                    # 旧版标签
+                    labels_value = self._labels.get(result.get('labels') or "0") or ""
+                    if labels_value:
+                        labels = labels_value.split()
                 torrent = {
                     'title': result.get('name'),
                     'description': result.get('smallDescr'),
@@ -191,7 +197,6 @@ class MTorrentSpider:
                 'id': torrent_id
             },
             'header': {
-                'Content-Type': 'application/json',
                 'User-Agent': f'{self._ua}',
                 'Accept': 'application/json, text/plain, */*',
                 'x-api-key': self._apikey

app/modules/jellyfin/jellyfin.py

@@ -696,6 +696,8 @@ class Jellyfin:
             # jellyfin 的 webhook 不含 item_path，需要单独获取
             eventItem.item_path = self.get_item_path_by_id(eventItem.item_id)
 
+        eventItem.json_object = message
+
         return eventItem
 
     @staticmethod

app/modules/plex/plex.py

@@ -703,6 +703,8 @@ class Plex:
             eventItem.image_url = self.get_remote_image_by_id(item_id=eventItem.item_id,
                                                               image_type="Backdrop")
 
+        eventItem.json_object = message
+
         return eventItem
 
     def get_plex(self):

app/modules/themoviedb/__init__.py

@@ -37,7 +37,7 @@ class TheMovieDbModule(_ModuleBase):
         self.cache = TmdbCache()
         self.tmdb = TmdbApi()
         self.category = CategoryHelper()
-        self.scraper = TmdbScraper(self.tmdb)
+        self.scraper = TmdbScraper()
 
     @staticmethod
     def get_name() -> str:
@@ -268,7 +268,7 @@ class TheMovieDbModule(_ModuleBase):
                             # 当前季第一季时间
                             first_date = episodes[0].get("air_date")
                             # 判断是不是日期格式
-                            if re.match(r"^\d{4}-\d{2}-\d{2}$", first_date):
+                            if first_date and re.match(r"^\d{4}-\d{2}-\d{2}$", first_date):
                                 season_years[season] = str(first_date).split("-")[0]
                     if season_years:
                         mediainfo.season_years = season_years

app/modules/themoviedb/category.py

@@ -115,11 +115,18 @@ class CategoryHelper(metaclass=Singleton):
             for attr, value in item.items():
                 if not value:
                     continue
-                info_value = tmdb_info.get(attr)
+                if attr == "release_year":
+                    # 发行年份
+                    info_value = tmdb_info.get("release_date") or tmdb_info.get("first_air_date")
+                    if info_value:
+                        info_value = str(info_value)[:4]
+                else:
+                    info_value = tmdb_info.get(attr)
                 if not info_value:
                     match_flag = False
                     continue
                 elif attr == "production_countries":
+                    # 制片国家
                     info_values = [str(val.get("iso_3166_1")).upper() for val in info_value]
                 else:
                     if isinstance(info_value, list):
@@ -128,7 +135,18 @@ class CategoryHelper(metaclass=Singleton):
                         info_values = [str(info_value).upper()]
 
                 if value.find(",") != -1:
+                    # , 分隔多个值
                     values = [str(val).upper() for val in value.split(",") if val]
+                elif value.find("-") != -1:
+                    # - 表示范围，仅限于数字
+                    value_begin = value.split("-")[0]
+                    value_end = value.split("-")[1]
+                    if value_begin.isdigit() and value_end.isdigit():
+                        # 数字范围
+                        values = [str(val) for val in range(int(value_begin), int(value_end) + 1)]
+                    else:
+                        # 字符串范围
+                        values = [str(value_begin), str(value_end)]
                 else:
                     values = [str(value).upper()]
 

app/modules/themoviedb/scraper.py

@@ -7,15 +7,29 @@ from app.core.context import MediaInfo
 from app.core.meta import MetaBase
 from app.schemas.types import MediaType
 from app.utils.dom import DomUtils
+from app.modules.themoviedb.tmdbapi import TmdbApi
 
 
 class TmdbScraper:
-    tmdb = None
-    _force_nfo = False
-    _force_img = False
+    _meta_tmdb = None
+    _img_tmdb = None
 
-    def __init__(self, tmdb):
-        self.tmdb = tmdb
+    @property
+    def default_tmdb(self):
+        """
+        获取元数据TMDB Api
+        """
+        if not self._meta_tmdb:
+            self._meta_tmdb = TmdbApi(language=settings.TMDB_LOCALE)
+        return self._meta_tmdb
+
+    def original_tmdb(self, mediainfo: Optional[MediaInfo] = None):
+        """
+        获取图片TMDB Api
+        """
+        if settings.TMDB_SCRAP_ORIGINAL_IMAGE and mediainfo:
+            return TmdbApi(language=mediainfo.original_language)
+        return self.default_tmdb
 
     def get_metadata_nfo(self, meta: MetaBase, mediainfo: MediaInfo,
                          season: Optional[int] = None, episode: Optional[int] = None) -> Optional[str]:
@@ -33,9 +47,9 @@ class TmdbScraper:
             if season is not None:
                 # 查询季信息
                 if mediainfo.episode_group:
-                    seasoninfo = self.tmdb.get_tv_group_detail(mediainfo.episode_group, season=season)
+                    seasoninfo = self.default_tmdb.get_tv_group_detail(mediainfo.episode_group, season=season)
                 else:
-                    seasoninfo = self.tmdb.get_tv_season_detail(mediainfo.tmdb_id, season=season)
+                    seasoninfo = self.default_tmdb.get_tv_season_detail(mediainfo.tmdb_id, season=season)
                 if episode:
                     # 集元数据文件
                     episodeinfo = self.__get_episode_detail(seasoninfo, meta.begin_episode)
@@ -48,11 +62,12 @@ class TmdbScraper:
                 # 电视剧元数据文件
                 doc = self.__gen_tv_nfo_file(mediainfo=mediainfo)
         if doc:
-            return doc.toprettyxml(indent="  ", encoding="utf-8") # noqa
+            return doc.toprettyxml(indent="  ", encoding="utf-8")  # noqa
 
         return None
 
-    def get_metadata_img(self, mediainfo: MediaInfo, season: Optional[int] = None, episode: Optional[int] = None) -> dict:
+    def get_metadata_img(self, mediainfo: MediaInfo, season: Optional[int] = None,
+                         episode: Optional[int] = None) -> dict:
         """
         获取图片名称和url
         :param mediainfo: 媒体信息
@@ -61,13 +76,13 @@ class TmdbScraper:
         """
         images = {}
         if season is not None:
-            # 只需要集的图片
+            # 只需要季集的图片
             if episode:
                 # 集的图片
                 if mediainfo.episode_group:
-                    seasoninfo = self.tmdb.get_tv_group_detail(mediainfo.episode_group, season)
+                    seasoninfo = self.original_tmdb(mediainfo).get_tv_group_detail(mediainfo.episode_group, season)
                 else:
-                    seasoninfo = self.tmdb.get_tv_season_detail(mediainfo.tmdb_id, season)
+                    seasoninfo = self.original_tmdb(mediainfo).get_tv_season_detail(mediainfo.tmdb_id, season)
                 if seasoninfo:
                     episodeinfo = self.__get_episode_detail(seasoninfo, episode)
                     if episodeinfo and episodeinfo.get("still_path"):
@@ -77,7 +92,7 @@ class TmdbScraper:
                         images[still_name] = still_url
             else:
                 # 季的图片
-                seasoninfo = self.tmdb.get_tv_season_detail(mediainfo.tmdb_id, season)
+                seasoninfo = self.original_tmdb(mediainfo).get_tv_season_detail(mediainfo.tmdb_id, season)
                 if seasoninfo:
                     # TMDB季poster图片
                     poster_name, poster_url = self.get_season_poster(seasoninfo, season)
@@ -85,7 +100,7 @@ class TmdbScraper:
                         images[poster_name] = poster_url
             return images
         else:
-            # 主媒体图片
+            # 获取媒体信息中原有图片（TheMovieDb或Fanart）
             for attr_name, attr_value in vars(mediainfo).items():
                 if attr_value \
                         and attr_name.endswith("_path") \
@@ -94,6 +109,15 @@ class TmdbScraper:
                         and attr_value.startswith("http"):
                     image_name = attr_name.replace("_path", "") + Path(attr_value).suffix
                     images[image_name] = attr_value
+            # 替换原语言Poster
+            if settings.TMDB_SCRAP_ORIGINAL_IMAGE:
+                _mediainfo = self.original_tmdb(mediainfo).get_info(mediainfo.type, mediainfo.tmdb_id)
+                if _mediainfo:
+                    for attr_name, attr_value in _mediainfo.items():
+                        if attr_name.endswith("_path") and attr_value is not None:
+                            image_url = f"https://{settings.TMDB_IMAGE_DOMAIN}/t/p/original{attr_value}"
+                            image_name = attr_name.replace("_path", "") + Path(image_url).suffix
+                            images[image_name] = image_url
             return images
 
     @staticmethod

app/modules/themoviedb/tmdbapi.py

@@ -23,31 +23,19 @@ class TmdbApi:
     TMDB识别匹配
     """
 
-    def __init__(self):
+    def __init__(self, language: Optional[str] = None):
         # TMDB主体
-        self.tmdb = TMDb()
-        # 域名
-        self.tmdb.domain = settings.TMDB_API_DOMAIN
-        # 开启缓存
-        self.tmdb.cache = True
-        # APIKEY
-        self.tmdb.api_key = settings.TMDB_API_KEY
-        # 语种
-        self.tmdb.language = 'zh'
-        # 代理
-        self.tmdb.proxies = settings.PROXY
-        # 调试模式
-        self.tmdb.debug = False
+        self.tmdb = TMDb(language=language)
         # TMDB查询对象
-        self.search = Search()
-        self.movie = Movie()
-        self.tv = TV()
-        self.season_obj = Season()
-        self.episode_obj = Episode()
-        self.discover = Discover()
-        self.trending = Trending()
-        self.person = Person()
-        self.collection = Collection()
+        self.search = Search(language=language)
+        self.movie = Movie(language=language)
+        self.tv = TV(language=language)
+        self.season_obj = Season(language=language)
+        self.episode_obj = Episode(language=language)
+        self.discover = Discover(language=language)
+        self.trending = Trending(language=language)
+        self.person = Person(language=language)
+        self.collection = Collection(language=language)
 
     def search_multiis(self, title: str) -> List[dict]:
         """
@@ -632,7 +620,8 @@ class TmdbApi:
             # 转换多语种标题
             self.__update_tmdbinfo_extra_title(tmdb_info)
             # 转换中文标题
-            self.__update_tmdbinfo_cn_title(tmdb_info)
+            if settings.TMDB_LOCALE == "zh":
+                self.__update_tmdbinfo_cn_title(tmdb_info)
 
         return tmdb_info
 
@@ -647,6 +636,7 @@ class TmdbApi:
             return None
         # dict[地区:分级]
         ratings = {}
+        results = []
         if results := (tmdb_info.get("release_dates") or {}).get("results"):
             """
             [
@@ -1344,7 +1334,18 @@ class TmdbApi:
             return []
         try:
             logger.debug(f"正在获取剧集组：{group_id}...")
-            return self.tv.group_episodes(group_id) or []
+            group_seasons = self.tv.group_episodes(group_id) or []
+            return [
+                {
+                    **group_season,
+                    "episodes": [
+                        {**ep, "episode_number": idx}
+                        # 剧集组中每个季的episode_number从1开始
+                        for idx, ep in enumerate(group_season.get("episodes", []), start=1)
+                    ]
+                }
+                for group_season in group_seasons
+            ]
         except Exception as e:
             logger.error(str(e))
             return []

app/modules/themoviedb/tmdbv3api/tmdb.py

@@ -1,7 +1,6 @@
 # -*- coding: utf-8 -*-
 
 import logging
-import os
 import time
 from datetime import datetime
 
@@ -17,19 +16,22 @@ logger = logging.getLogger(__name__)
 
 
 class TMDb(object):
-    TMDB_API_KEY = "TMDB_API_KEY"
-    TMDB_LANGUAGE = "TMDB_LANGUAGE"
-    TMDB_SESSION_ID = "TMDB_SESSION_ID"
-    TMDB_WAIT_ON_RATE_LIMIT = "TMDB_WAIT_ON_RATE_LIMIT"
-    TMDB_DEBUG_ENABLED = "TMDB_DEBUG_ENABLED"
-    TMDB_CACHE_ENABLED = "TMDB_CACHE_ENABLED"
-    TMDB_PROXIES = "TMDB_PROXIES"
-    TMDB_DOMAIN = "TMDB_DOMAIN"
-
     _req = None
     _session = None
 
-    def __init__(self, obj_cached=True, session=None):
+    def __init__(self, obj_cached=True, session=None, language=None):
+        self._api_key = settings.TMDB_API_KEY
+        self._language = language or settings.TMDB_LOCALE or "en-US"
+        self._session_id = None
+        self._wait_on_rate_limit = True
+        self._debug_enabled = False
+        self._cache_enabled = obj_cached
+        self._proxies = settings.PROXY
+        self._domain = settings.TMDB_API_DOMAIN
+        self._page = None
+        self._total_results = None
+        self._total_pages = None
+
         if session is not None:
             self._req = RequestUtils(session=session, proxies=self.proxies)
         else:
@@ -39,103 +41,88 @@ class TMDb(object):
         self._reset = None
         self._timeout = 15
         self.obj_cached = obj_cached
-        if os.environ.get(self.TMDB_LANGUAGE) is None:
-            os.environ[self.TMDB_LANGUAGE] = "en-US"
 
     @property
     def page(self):
-        return os.environ["page"]
+        return self._page
 
     @property
     def total_results(self):
-        return os.environ["total_results"]
+        return self._total_results
 
     @property
     def total_pages(self):
-        return os.environ["total_pages"]
+        return self._total_pages
 
     @property
     def api_key(self):
-        return os.environ.get(self.TMDB_API_KEY)
+        return self._api_key
 
     @property
     def domain(self):
-        return os.environ.get(self.TMDB_DOMAIN)
+        return self._domain
 
     @property
     def proxies(self):
-        proxy = os.environ.get(self.TMDB_PROXIES)
-        if proxy is not None:
-            proxy = eval(proxy)
-        return proxy
+        return self._proxies
 
     @proxies.setter
     def proxies(self, proxies):
-        if proxies is not None:
-            os.environ[self.TMDB_PROXIES] = str(proxies)
+        self._proxies = proxies
 
     @api_key.setter
     def api_key(self, api_key):
-        os.environ[self.TMDB_API_KEY] = str(api_key)
+        self._api_key = str(api_key)
 
     @domain.setter
     def domain(self, domain):
-        os.environ[self.TMDB_DOMAIN] = str(domain)
+        self._domain = str(domain)
 
     @property
     def language(self):
-        return os.environ.get(self.TMDB_LANGUAGE)
+        return self._language
 
     @language.setter
     def language(self, language):
-        os.environ[self.TMDB_LANGUAGE] = language
+        self._language = language
 
     @property
     def has_session(self):
-        return True if os.environ.get(self.TMDB_SESSION_ID) else False
+        return True if self._session_id else False
 
     @property
     def session_id(self):
-        if not os.environ.get(self.TMDB_SESSION_ID):
+        if not self._session_id:
             raise TMDbException("Must Authenticate to create a session run Authentication(username, password)")
-        return os.environ.get(self.TMDB_SESSION_ID)
+        return self._session_id
 
     @session_id.setter
     def session_id(self, session_id):
-        os.environ[self.TMDB_SESSION_ID] = session_id
+        self._session_id = session_id
 
     @property
     def wait_on_rate_limit(self):
-        if os.environ.get(self.TMDB_WAIT_ON_RATE_LIMIT) == "False":
-            return False
-        else:
-            return True
+        return self._wait_on_rate_limit
 
     @wait_on_rate_limit.setter
     def wait_on_rate_limit(self, wait_on_rate_limit):
-        os.environ[self.TMDB_WAIT_ON_RATE_LIMIT] = str(wait_on_rate_limit)
+        self._wait_on_rate_limit = bool(wait_on_rate_limit)
 
     @property
     def debug(self):
-        if os.environ.get(self.TMDB_DEBUG_ENABLED) == "True":
-            return True
-        else:
-            return False
+        return self._debug_enabled
 
     @debug.setter
     def debug(self, debug):
-        os.environ[self.TMDB_DEBUG_ENABLED] = str(debug)
+        self._debug_enabled = bool(debug)
 
     @property
     def cache(self):
-        if os.environ.get(self.TMDB_CACHE_ENABLED) == "False":
-            return False
-        else:
-            return True
+        return self._cache_enabled
 
     @cache.setter
     def cache(self, cache):
-        os.environ[self.TMDB_CACHE_ENABLED] = str(cache)
+        self._cache_enabled = bool(cache)
 
     @cached(maxsize=settings.CACHE_CONF["tmdb"], ttl=settings.CACHE_CONF["meta"])
     def cached_request(self, method, url, data, json,
@@ -197,30 +184,30 @@ class TMDb(object):
             else:
                 raise TMDbException("达到请求频率限制，将在 %d 秒后重试..." % sleep_time)
 
-        json = req.json()
+        json_data = req.json()
 
-        if "page" in json:
-            os.environ["page"] = str(json["page"])
+        if "page" in json_data:
+            self._page = json_data["page"]
 
-        if "total_results" in json:
-            os.environ["total_results"] = str(json["total_results"])
+        if "total_results" in json_data:
+            self._total_results = json_data["total_results"]
 
-        if "total_pages" in json:
-            os.environ["total_pages"] = str(json["total_pages"])
+        if "total_pages" in json_data:
+            self._total_pages = json_data["total_pages"]
 
         if self.debug:
-            logger.info(json)
+            logger.info(json_data)
             logger.info(self.cached_request.cache_info())
 
-        if "errors" in json:
-            raise TMDbException(json["errors"])
+        if "errors" in json_data:
+            raise TMDbException(json_data["errors"])
 
-        if "success" in json and json["success"] is False:
-            raise TMDbException(json["status_message"])
+        if "success" in json_data and json_data["success"] is False:
+            raise TMDbException(json_data["status_message"])
 
         if key:
-            return json.get(key)
-        return json
+            return json_data.get(key)
+        return json_data
 
     def close(self):
         if self._session:

app/modules/thetvdb/__init__.py

@@ -1,21 +1,92 @@
+from threading import Lock
 from typing import Optional, Tuple, Union
 
 from app.core.config import settings
 from app.log import logger
 from app.modules import _ModuleBase
-from app.modules.thetvdb import tvdbapi
+from app.modules.thetvdb import tvdb_v4_official
 from app.schemas.types import ModuleType, MediaRecognizeType
-from app.utils.http import RequestUtils
 
 
 class TheTvDbModule(_ModuleBase):
-    tvdb: tvdbapi.Tvdb = None
+    """
+    TVDB媒体信息匹配
+    """
+    __timeout: int = 15
+    tvdb: Optional[tvdb_v4_official.TVDB] = None
+    __auth_lock = Lock()
 
     def init_module(self) -> None:
-        self.tvdb = tvdbapi.Tvdb(apikey=settings.TVDB_API_KEY,
-                                 cache=False,
-                                 select_first=True,
-                                 proxies=settings.PROXY)
+        pass
+
+    def _initialize_tvdb_session(self, is_retry: bool = False) -> None:
+        """
+        创建或刷新 TVDB 登录会话。
+        :param is_retry: 是否是由于token失效后的重试登录
+        """
+        action = "刷新" if is_retry else "创建"
+        logger.info(f"开始{action}TVDB登录会话...")
+        try:
+            if not settings.TVDB_V4_API_KEY:
+                raise ConnectionError("TVDB API Key 未配置，无法初始化会话。")
+            self.tvdb = tvdb_v4_official.TVDB(apikey=settings.TVDB_V4_API_KEY,
+                                              pin=settings.TVDB_V4_API_PIN,
+                                              proxy=settings.PROXY,
+                                              timeout=self.__timeout)
+            if self.tvdb:
+                logger.info(f"TVDB登录会话{action}成功。")
+            else:
+                raise ValueError(f"TVDB登录会话{action}后实例仍为None。")
+        except Exception as e:
+            self.tvdb = None
+            raise ConnectionError(f"TVDB登录会话{action}失败: {str(e)}") from e
+
+    def _ensure_tvdb_session(self, is_retry: bool = False) -> None:
+        """
+        确保TVDB会话存在。如果不存在或需要强制重新初始化，则进行初始化。
+        :param is_retry: 是否重新初始化（例如token失效时）
+        """
+        # 第一次检查 (无锁)，提高性能，避免不必要锁竞争
+        if not self.tvdb or is_retry:
+            with self.__auth_lock:
+                # 第二次检查 (有锁)，防止多个线程都通过第一次检查后重复初始化
+                if not self.tvdb or is_retry:
+                    self._initialize_tvdb_session(is_retry=is_retry)
+
+    def _handle_tvdb_call(self, method_name: str, *args, **kwargs):
+        """
+        包裹 TVDB 调用，处理 token 失效情况并尝试重新初始化
+        :param method_name: 要在 self.tvdb 实例上调用的方法的名称 (字符串)
+        """
+        try:
+            self._ensure_tvdb_session()
+            actual_method = getattr(self.tvdb, method_name)
+            return actual_method(*args, **kwargs)
+        except ValueError as e:
+            if "Unauthorized" in str(e):
+                logger.warning("TVDB Token 可能已失效，正在尝试重新登录...")
+                try:
+                    self._ensure_tvdb_session(is_retry=True)
+                    actual_method = getattr(self.tvdb, method_name)
+                    return actual_method(*args, **kwargs)
+                except ConnectionError as conn_err:
+                    logger.error(f"TVDB Token失效后重新登录失败: {conn_err}")
+                    raise
+            elif "NotFoundException" in str(e) or "ID not found" in str(e):
+                logger.warning(f"TVDB 资源未找到 (调用 {method_name}): {e}")
+                return None
+            else:
+                logger.error(f"TVDB 调用 ({method_name}) 时发生未处理的 ValueError: {str(e)}")
+                raise
+        except ConnectionError as e:
+            logger.error(f"TVDB 连接会话错误: {str(e)}")
+            raise
+        except AttributeError as e:
+            logger.error(f"TVDB 实例上没有方法 '{method_name}': {e}")
+            raise
+        except Exception as e:
+            logger.error(f"TVDB 调用时发生未知错误: {str(e)}", exc_info=True)
+            raise
 
     @staticmethod
     def get_name() -> str:
@@ -43,18 +114,19 @@ class TheTvDbModule(_ModuleBase):
         return 4
 
     def stop(self):
-        self.tvdb.close()
+        logger.info("TheTvDbModule 停止。正在清除 TVDB 会话。")
+        with self.__auth_lock:
+            self.tvdb = None
 
     def test(self) -> Tuple[bool, str]:
         """
         测试模块连接性
         """
-        ret = RequestUtils(proxies=settings.PROXY).get_res("https://api.thetvdb.com/series/81189")
-        if ret and ret.status_code == 200:
+        try:
+            self._handle_tvdb_call("get_series", 81189)
             return True, ""
-        elif ret:
-            return False, f"无法连接 api.thetvdb.com，错误码：{ret.status_code}"
-        return False, "api.thetvdb.com 网络连接失败"
+        except Exception as e:
+            return False, str(e)
 
     def init_setting(self) -> Tuple[str, Union[str, bool]]:
         pass
@@ -67,6 +139,26 @@ class TheTvDbModule(_ModuleBase):
         """
         try:
             logger.info(f"开始获取TVDB信息: {tvdbid} ...")
-            return self.tvdb[tvdbid].data
+            return self._handle_tvdb_call("get_series_extended", tvdbid)
         except Exception as err:
             logger.error(f"获取TVDB信息失败: {str(err)}")
+            return None
+
+    def search_tvdb(self, title: str) -> list:
+        """
+        用标题搜索TVDB剧集
+        :param title: 标题
+        :return: TVDB信息
+        """
+        try:
+            logger.info(f"开始用标题搜索TVDB剧集: {title} ...")
+            res = self._handle_tvdb_call("search", title)
+            if res is None:
+                return []
+            if not isinstance(res, list):
+                logger.warning(f"TVDB 搜索 '{title}' 未返回列表：{type(res)}")
+                return []
+            return [item for item in res if isinstance(item, dict) and item.get("type") == "series"]
+        except Exception as err:
+            logger.error(f"用标题搜索TVDB剧集失败 ({title}): {str(err)}")
+            return []

app/modules/thetvdb/tvdb_v4_official.py

@@ -0,0 +1,615 @@
+"""Official python package for using the tvdb v4 api"""
+
+__author__ = "Weylin Wagnon"
+__version__ = "1.0.12"
+
+import json
+import urllib.parse
+from http import HTTPStatus
+
+from app.utils.http import RequestUtils
+
+
+class Auth:
+    """
+    TVDB认证类
+    """
+
+    def __init__(self, url, apikey, pin="", proxy=None, timeout: int = 15):
+        login_info = {"apikey": apikey}
+        if pin != "":
+            login_info["pin"] = pin
+
+        login_info_bytes = json.dumps(login_info, indent=2)
+
+        try:
+            # 使用项目统一的RequestUtils类
+            req_utils = RequestUtils(proxies=proxy, timeout=timeout)
+            response = req_utils.post_res(
+                url=url,
+                data=login_info_bytes,
+                headers={"Content-Type": "application/json"}
+            )
+
+            if response and response.status_code == 200:
+                result = response.json()
+                self.token = result["data"]["token"]
+            else:
+                error_msg = f"登录失败，状态码: {response.status_code if response else 'None'}"
+                if response:
+                    try:
+                        error_data = response.json()
+                        error_msg = f"Code: {response.status_code}, {error_data.get('message', '未知错误')}"
+                    except Exception as err:
+                        error_msg = f"Code: {response.status_code}, 响应解析失败：{err}"
+                raise Exception(error_msg)
+        except Exception as e:
+            raise Exception(f"TVDB认证失败: {str(e)}")
+
+    def get_token(self):
+        """
+        获取认证token
+        """
+        return self.token
+
+
+class Request:
+    """
+    请求处理类
+    """
+
+    def __init__(self, auth_token, proxy=None, timeout=15):
+        self.auth_token = auth_token
+        self.links = None
+        self.proxy = proxy
+        self.timeout = timeout
+
+    def make_request(self, url, if_modified_since=None):
+        """
+        向指定的 URL 发起请求并返回数据
+        """
+        headers = {"Authorization": f"Bearer {self.auth_token}"}
+        if if_modified_since:
+            headers["If-Modified-Since"] = str(if_modified_since)
+
+        try:
+            # 使用项目统一的RequestUtils类
+            req_utils = RequestUtils(proxies=self.proxy, timeout=self.timeout)
+            response = req_utils.get_res(url=url, headers=headers)
+
+            if response is None:
+                raise ValueError(f"获取 {url} 失败\n  网络连接失败")
+
+            if response.status_code == HTTPStatus.NOT_MODIFIED:
+                return {
+                    "code": HTTPStatus.NOT_MODIFIED.real,
+                    "message": "Not-Modified",
+                }
+
+            if response.status_code == 200:
+                result = response.json()
+                data = result.get("data", None)
+                if data is not None and result.get("status", "failure") != "failure":
+                    self.links = result.get("links", None)
+                    return data
+
+                msg = result.get("message", "未知错误")
+                raise ValueError(f"获取 {url} 失败\n  {str(msg)}")
+            else:
+                # 处理其他HTTP错误状态码
+                try:
+                    error_data = response.json()
+                    msg = error_data.get("message", f"HTTP {response.status_code}")
+                except Exception as err:
+                    msg = f"HTTP {response.status_code} {err}"
+                raise ValueError(f"获取 {url} 失败\n  {str(msg)}")
+
+        except Exception as e:
+            if isinstance(e, ValueError):
+                raise
+            raise ValueError(f"获取 {url} 失败\n  {str(e)}")
+
+
+class Url:
+    """
+    URL构建类
+    """
+
+    def __init__(self):
+        self.base_url = "https://api4.thetvdb.com/v4/"
+
+    def construct(self, url_sect, url_id=None, url_subsect=None, url_lang=None, **kwargs):
+        """
+        构建API URL
+        """
+        url = self.base_url + url_sect
+        if url_id:
+            url += "/" + str(url_id)
+        if url_subsect:
+            url += "/" + url_subsect
+        if url_lang:
+            url += "/" + url_lang
+        if kwargs:
+            params = {var: val for var, val in kwargs.items() if val is not None}
+            if params:
+                url += "?" + urllib.parse.urlencode(params)
+        return url
+
+
+class TVDB:
+    """
+    TVDB API主类
+    """
+
+    def __init__(self, apikey: str, pin="", proxy=None, timeout: int = 15):
+        self.url = Url()
+        login_url = self.url.construct("login")
+        self.auth = Auth(login_url, apikey, pin, proxy, timeout)
+        auth_token = self.auth.get_token()
+        self.request = Request(auth_token, proxy, timeout)
+
+    def get_req_links(self) -> dict:
+        """
+        获取上一次请求返回的链接信息（例如分页链接）
+        """
+        return self.request.links
+
+    def get_artwork_statuses(self, meta=None, if_modified_since=None) -> list:
+        """
+        返回艺术图状态列表
+        """
+        url = self.url.construct("artwork/statuses", meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_artwork_types(self, meta=None, if_modified_since=None) -> list:
+        """
+        返回艺术图类型列表
+        """
+        url = self.url.construct("artwork/types", meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_artwork(self, id: int, meta=None, if_modified_since=None) -> dict:
+        """
+        返回单个艺术图信息的字典
+        """
+        url = self.url.construct("artwork", id, meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_artwork_extended(self, id: int, meta=None, if_modified_since=None) -> dict:
+        """
+        返回单个艺术图的扩展信息字典
+        """
+        url = self.url.construct("artwork", id, "extended", meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_all_awards(self, meta=None, if_modified_since=None) -> list:
+        """
+        返回奖项列表
+        """
+        url = self.url.construct("awards", meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_award(self, id: int, meta=None, if_modified_since=None) -> dict:
+        """
+        返回单个奖项信息的字典
+        """
+        url = self.url.construct("awards", id, meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_award_extended(self, id: int, meta=None, if_modified_since=None) -> dict:
+        """
+        返回单个奖项的扩展信息字典
+        """
+        url = self.url.construct("awards", id, "extended", meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_all_award_categories(self, meta=None, if_modified_since=None) -> list:
+        """
+        返回奖项类别列表
+        """
+        url = self.url.construct("awards/categories", meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_award_category(self, id: int, meta=None, if_modified_since=None) -> dict:
+        """
+        返回单个奖项类别信息的字典
+        """
+        url = self.url.construct("awards/categories", id, meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_award_category_extended(self, id: int, meta=None, if_modified_since=None) -> dict:
+        """
+        返回单个奖项类别的扩展信息字典
+        """
+        url = self.url.construct("awards/categories", id, "extended", meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_content_ratings(self, meta=None, if_modified_since=None) -> list:
+        """
+        返回内容分级列表
+        """
+        url = self.url.construct("content/ratings", meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_countries(self, meta=None, if_modified_since=None) -> list:
+        """
+        返回国家列表
+        """
+        url = self.url.construct("countries", meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_all_companies(self, page=None, meta=None, if_modified_since=None) -> list:
+        """
+        返回公司列表 (可分页)
+        """
+        url = self.url.construct("companies", page=page, meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_company_types(self, meta=None, if_modified_since=None) -> list:
+        """
+        返回公司类型列表
+        """
+        url = self.url.construct("companies/types", meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_company(self, id: int, meta=None, if_modified_since=None) -> dict:
+        """
+        返回单个公司信息的字典
+        """
+        url = self.url.construct("companies", id, meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_all_series(self, page=None, meta=None, if_modified_since=None) -> list:
+        """
+        返回剧集列表 (可分页)
+        """
+        url = self.url.construct("series", page=page, meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_series(self, id: int, meta=None, if_modified_since=None) -> dict:
+        """
+        返回单个剧集信息的字典
+        """
+        url = self.url.construct("series", id, meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_series_by_slug(self, slug: str, meta=None, if_modified_since=None) -> dict:
+        """
+        通过 slug (别名) 返回单个剧集信息的字典
+        """
+        url = self.url.construct("series/slug", slug, meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_series_extended(self, id: int, meta=None, short=False, if_modified_since=None) -> dict:
+        """
+        返回单个剧集的扩展信息字典
+        """
+        url = self.url.construct("series", id, "extended", meta=meta, short=short)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_series_episodes(self, id: int, season_type: str = "default", page: int = 0,
+                            lang: str = None, meta=None, if_modified_since=None, **kwargs) -> dict:
+        """
+        返回指定剧集和季类型的各集信息字典 (可分页，可指定语言)
+        """
+        url = self.url.construct(
+            "series", id, "episodes/" + season_type, lang, page=page, meta=meta, **kwargs
+        )
+        return self.request.make_request(url, if_modified_since)
+
+    def get_series_translation(self, id: int, lang: str, meta=None, if_modified_since=None) -> dict:
+        """
+        返回剧集的指定语言翻译信息字典
+        """
+        url = self.url.construct("series", id, "translations", lang, meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_series_artworks(self, id: int, lang: str, type=None, if_modified_since=None) -> dict:
+        """
+        返回包含艺术图数组的剧集记录 (可指定语言和类型)
+        """
+        url = self.url.construct("series", id, "artworks", lang=lang, type=type)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_series_next_aired(self, id: int, if_modified_since=None) -> dict:
+        """
+        返回剧集的下一播出信息字典
+        """
+        url = self.url.construct("series", id, "nextAired")
+        return self.request.make_request(url, if_modified_since)
+
+    def get_all_movies(self, page=None, meta=None, if_modified_since=None) -> list:
+        """
+        返回电影列表 (可分页)
+        """
+        url = self.url.construct("movies", page=page, meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_movie(self, id: int, meta=None, if_modified_since=None) -> dict:
+        """
+        返回单个电影信息的字典
+        """
+        url = self.url.construct("movies", id, meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_movie_by_slug(self, slug: str, meta=None, if_modified_since=None) -> dict:
+        """
+        通过 slug (别名) 返回单个电影信息的字典
+        """
+        url = self.url.construct("movies/slug", slug, meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_movie_extended(self, id: int, meta=None, short=False, if_modified_since=None) -> dict:
+        """
+        返回电影的扩展信息字典
+        """
+        url = self.url.construct("movies", id, "extended", meta=meta, short=short)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_movie_translation(self, id: int, lang: str, meta=None, if_modified_since=None) -> dict:
+        """
+        返回电影的指定语言翻译信息字典
+        """
+        url = self.url.construct("movies", id, "translations", lang, meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_all_seasons(self, page=None, meta=None, if_modified_since=None) -> list:
+        """
+        返回季列表 (可分页)
+        """
+        url = self.url.construct("seasons", page=page, meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_season(self, id: int, meta=None, if_modified_since=None) -> dict:
+        """
+        返回单季信息的字典
+        """
+        url = self.url.construct("seasons", id, meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_season_extended(self, id: int, meta=None, if_modified_since=None) -> dict:
+        """
+        返回单季的扩展信息字典
+        """
+        url = self.url.construct("seasons", id, "extended", meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_season_types(self, meta=None, if_modified_since=None) -> list:
+        """
+        返回季类型列表
+        """
+        url = self.url.construct("seasons/types", meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_season_translation(self, id: int, lang: str, meta=None, if_modified_since=None) -> dict:
+        """
+        返回季的指定语言翻译信息字典
+        """
+        url = self.url.construct("seasons", id, "translations", lang, meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_all_episodes(self, page=None, meta=None, if_modified_since=None) -> list:
+        """
+        返回集列表 (可分页)
+        """
+        url = self.url.construct("episodes", page=page, meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_episode(self, id: int, meta=None, if_modified_since=None) -> dict:
+        """
+        返回单集信息的字典
+        """
+        url = self.url.construct("episodes", id, meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_episode_extended(self, id: int, meta=None, if_modified_since=None) -> dict:
+        """
+        返回单集的扩展信息字典
+        """
+        url = self.url.construct("episodes", id, "extended", meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_episode_translation(self, id: int, lang: str, meta=None, if_modified_since=None) -> dict:
+        """
+        返回单集的指定语言翻译信息字典
+        """
+        url = self.url.construct("episodes", id, "translations", lang, meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    # 兼容旧函数名。
+    get_episodes_translation = get_episode_translation
+
+    def get_all_genders(self, meta=None, if_modified_since=None) -> list:
+        """
+        返回性别列表
+        """
+        url = self.url.construct("genders", meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_all_genres(self, meta=None, if_modified_since=None) -> list:
+        """
+        返回类型（流派）列表
+        """
+        url = self.url.construct("genres", meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_genre(self, id: int, meta=None, if_modified_since=None) -> dict:
+        """
+        返回单个类型（流派）信息的字典
+        """
+        url = self.url.construct("genres", id, meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_all_languages(self, meta=None, if_modified_since=None) -> list:
+        """
+        返回语言列表
+        """
+        url = self.url.construct("languages", meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_all_people(self, page=None, meta=None, if_modified_since=None) -> list:
+        """
+        返回人物列表 (可分页)
+        """
+        url = self.url.construct("people", page=page, meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_person(self, id: int, meta=None, if_modified_since=None) -> dict:
+        """
+        返回单个人物信息的字典
+        """
+        url = self.url.construct("people", id, meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_person_extended(self, id: int, meta=None, if_modified_since=None) -> dict:
+        """
+        返回单个人物的扩展信息字典
+        """
+        url = self.url.construct("people", id, "extended", meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_person_translation(self, id: int, lang: str, meta=None, if_modified_since=None) -> dict:
+        """
+        返回人物的指定语言翻译信息字典
+        """
+        url = self.url.construct("people", id, "translations", lang, meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_character(self, id: int, meta=None, if_modified_since=None) -> dict:
+        """
+        返回角色信息的字典
+        """
+        url = self.url.construct("characters", id, meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_people_types(self, meta=None, if_modified_since=None) -> list:
+        """
+        返回人物类型列表
+        """
+        url = self.url.construct("people/types", meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    # 兼容旧函数名
+    get_all_people_types = get_people_types
+
+    def get_source_types(self, meta=None, if_modified_since=None) -> list:
+        """
+        返回来源类型列表
+        """
+        url = self.url.construct("sources/types", meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    # 兼容旧函数名
+    get_all_sourcetypes = get_source_types
+
+    def get_updates(self, since: int, **kwargs) -> list:
+        """
+        返回更新列表
+        """
+        url = self.url.construct("updates", since=since, **kwargs)
+        return self.request.make_request(url)
+
+    def get_all_tag_options(self, page=None, meta=None, if_modified_since=None) -> list:
+        """
+        返回标签选项列表 (可分页)
+        """
+        url = self.url.construct("tags/options", page=page, meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_tag_option(self, id: int, meta=None, if_modified_since=None) -> dict:
+        """
+        返回单个标签选项信息的字典
+        """
+        url = self.url.construct("tags/options", id, meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_all_lists(self, page=None, meta=None) -> dict:
+        """
+        返回所有公开的列表信息 (可分页)
+        """
+        url = self.url.construct("lists", page=page, meta=meta)
+        return self.request.make_request(url)
+
+    def get_list(self, id: int, meta=None, if_modified_since=None) -> dict:
+        """
+        返回单个列表信息的字典
+        """
+        url = self.url.construct("lists", id, meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_list_by_slug(self, slug: str, meta=None, if_modified_since=None) -> dict:
+        """
+        通过 slug (别名) 返回单个列表信息的字典
+        """
+        url = self.url.construct("lists/slug", slug, meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_list_extended(self, id: int, meta=None, if_modified_since=None) -> dict:
+        """
+        返回单个列表的扩展信息字典
+        """
+        url = self.url.construct("lists", id, "extended", meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_list_translation(self, id: int, lang: str, meta=None, if_modified_since=None) -> dict:
+        """
+        返回列表的指定语言翻译信息字典
+        """
+        url = self.url.construct("lists", id, "translations", lang, meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_inspiration_types(self, meta=None, if_modified_since=None) -> dict:
+        """
+        返回灵感类型列表
+        """
+        url = self.url.construct("inspiration/types", meta=meta)
+        return self.request.make_request(url, if_modified_since)
+
+    def search(self, query: str, **kwargs) -> list:
+        """
+        根据查询字符串进行搜索，并返回结果列表
+        """
+        url = self.url.construct("search", query=query, **kwargs)
+        return self.request.make_request(url)
+
+    def search_by_remote_id(self, remoteid: str) -> list:
+        """
+        通过外部 ID 精确匹配搜索，并返回结果列表
+        """
+        url = self.url.construct("search/remoteid", remoteid)
+        return self.request.make_request(url)
+
+    def get_tags(self, slug: str, if_modified_since=None) -> dict:
+        """
+        返回具有指定 slug 的标签实体信息字典 (此方法基于的 /entities/{slug} 端点非标准，请谨慎使用)
+        """
+        url = self.url.construct("entities", url_subsect=slug)
+        return self.request.make_request(url, if_modified_since)
+
+    def get_entities_types(self, if_modified_since=None) -> dict:
+        """
+        返回可用的实体类型列表
+        """
+        url = self.url.construct("entities")
+        return self.request.make_request(url, if_modified_since)
+
+    def get_user_by_id(self, id: int) -> dict:
+        """
+        通过用户 ID 返回用户信息字典
+        """
+        url = self.url.construct("user", id)
+        return self.request.make_request(url)
+
+    def get_user(self) -> dict:
+        """
+        返回当前认证的用户信息字典
+        """
+        url = self.url.construct("user")
+        return self.request.make_request(url)
+
+    def get_user_favorites(self) -> dict:
+        """
+        返回当前认证用户的收藏夹信息字典
+        """
+        url = self.url.construct('user/favorites')
+        return self.request.make_request(url)

app/modules/transmission/transmission.py

@@ -163,8 +163,9 @@ class Transmission:
         if not self.trc:
             return []
         try:
-            torrent = self.trc.get_torrents(ids=ids, arguments=self._trarg)
-            if torrent:
+            torrents = self.trc.get_torrents(ids=ids, arguments=self._trarg)
+            if len(torrents):
+                torrent = torrents[0]
                 labels = [str(tag).strip()
                           for tag in torrent.labels] if hasattr(torrent, "labels") else []
                 return labels

app/modules/trimemedia/__init__.py

@@ -62,7 +62,9 @@ class TrimeMediaModule(_ModuleBase, _MediaServerBase[TrimeMedia]):
                 server.reconnect()
 
     def stop(self):
-        pass
+        for server in self.get_instances().values():
+            if server.is_authenticated():
+                server.disconnect()
 
     def test(self) -> Optional[Tuple[bool, str]]:
         """
@@ -73,7 +75,7 @@ class TrimeMediaModule(_ModuleBase, _MediaServerBase[TrimeMedia]):
         for name, server in self.get_instances().items():
             if not server.is_configured():
                 return False, f"飞牛影视配置不完整：{name}"
-            if server.is_inactive() and server.reconnect() != True:
+            if server.is_inactive() and not server.reconnect():
                 return False, f"无法连接飞牛影视：{name}"
         return True, ""
 

app/modules/trimemedia/api.py

@@ -4,7 +4,7 @@ import random
 import time
 from dataclasses import dataclass
 from enum import Enum
-from typing import Optional, Union, List
+from typing import List, Optional, Union
 
 from app.core.config import settings
 from app.log import logger
@@ -19,27 +19,27 @@ class User:
 
 
 class Category(Enum):
-    Movie = "Movie"
+    MOVIE = "Movie"
     TV = "TV"
-    Mix = "Mix"
-    Others = "Others"
+    MIX = "Mix"
+    OTHERS = "Others"
 
     @classmethod
     def _missing_(cls, value):
-        return cls.Others
+        return cls.OTHERS
 
 
 class Type(Enum):
-    Movie = "Movie"
+    MOVIE = "Movie"
     TV = "TV"
-    Season = "Season"
-    Episode = "Episode"
-    Video = "Video"
-    Directory = "Directory"
+    SEASON = "Season"
+    EPISODE = "Episode"
+    VIDEO = "Video"
+    DIRECTORY = "Directory"
 
     @classmethod
     def _missing_(cls, value):
-        return cls.Video
+        return cls.VIDEO
 
 
 @dataclass
@@ -60,6 +60,13 @@ class MediaDbSummary:
     total: int = 0
 
 
+@dataclass
+class Version:
+    # 飞牛影视版本
+    frontend: Optional[str] = None
+    backend: Optional[str] = None
+
+
 @dataclass
 class Item:
     guid: str
@@ -103,6 +110,7 @@ class Api:
         "_apikey",
         "_api_path",
         "_request_utils",
+        "_version",
     )
 
     @property
@@ -117,13 +125,34 @@ class Api:
     def apikey(self) -> str:
         return self._apikey
 
+    @property
+    def version(self) -> Optional[Version]:
+        return self._version
+
     def __init__(self, host: str, apikey: str):
-        self._api_path = "/v/api/v1"
+        """
+        :param host: 飞牛服务端地址，如http://127.0.0.1:5666/v
+        """
+        self._api_path = "/api/v1"
         self._host = host.rstrip("/")
         self._apikey = apikey
-        self._token = None
+        self._token: Optional[str] = None
+        self._version: Optional[Version] = None
         self._request_utils = RequestUtils(session=requests.Session())
 
+    def sys_version(self) -> Optional[Version]:
+        """
+        飞牛影视版本号
+        """
+        if (res := self.__request_api("/sys/version")) and res.success:
+            if res.data:
+                self._version = Version(
+                    frontend=res.data.get("version"),
+                    backend=res.data.get("mediasrvVersion"),
+                )
+                return self._version
+        return None
+
     def login(self, username, password) -> Optional[str]:
         """
         登录飞牛影视
@@ -131,14 +160,14 @@ class Api:
         :return: 成功返回token 否则返回None
         """
         if (
-                res := self.__request_api(
-                    "/login",
-                    data={
-                        "username": username,
-                        "password": password,
-                        "app_name": "trimemedia-web",
-                    },
-                )
+            res := self.__request_api(
+                "/login",
+                data={
+                    "username": username,
+                    "password": password,
+                    "app_name": "trimemedia-web",
+                },
+            )
         ) and res.success:
             self._token = res.data.get("token")
         return self._token
@@ -250,7 +279,7 @@ class Api:
         扫描指定媒体库
         """
         if (
-                res := self.__request_api(f"/mdb/scan/{mdb.guid}", data={})
+            res := self.__request_api(f"/mdb/scan/{mdb.guid}", data={})
         ) and res.success:
             if res.data:
                 return True
@@ -272,22 +301,22 @@ class Api:
         return item
 
     def item_list(
-            self,
-            guid: Optional[str] = None,
-            type=None,
-            exclude_grouped_video=True,
-            page=1,
-            page_size=22,
-            sort_by="create_time",
-            sort="DESC",
+        self,
+        guid: Optional[str] = None,
+        types=None,
+        exclude_grouped_video=True,
+        page=1,
+        page_size=22,
+        sort_by="create_time",
+        sort="DESC",
     ) -> Optional[list[Item]]:
         """
         媒体列表
         """
-        if type is None:
-            type = [Type.Movie, Type.TV, Type.Directory, Type.Video]
+        if types is None:
+            types = [Type.MOVIE, Type.TV, Type.DIRECTORY, Type.VIDEO]
         post = {
-            "tags": {"type": type} if type else {},
+            "tags": {"type": types} if types else {},
             "sort_type": sort,
             "sort_column": sort_by,
             "page": page,
@@ -307,25 +336,48 @@ class Api:
         搜索影片、演员
         """
         if (
-                res := self.__request_api("/search/list", params={"q": keywords})
+            res := self.__request_api("/search/list", params={"q": keywords})
         ) and res.success:
             return [self.__build_item(info) for info in res.data]
         return None
 
     def item(self, guid: str) -> Optional[Item]:
-        """ """
+        """
+        查询媒体详情
+        """
         if (res := self.__request_api(f"/item/{guid}")) and res.success:
             return self.__build_item(res.data)
         return None
 
+    def del_item(self, guid: str, delete_file: bool) -> bool:
+        """
+        删除媒体
+
+        :param delete_file: True删除媒体文件，False仅从媒体库移除
+        """
+        if (
+            res := self.__request_api(
+                f"/item/{guid}",
+                method="delete",
+                data={"delete_file": 1 if delete_file else 0, "media_guids": []},
+            )
+        ) and res.success:
+            if res.data:
+                return True
+        return False
+
     def season_list(self, tv_guid: str) -> Optional[list[Item]]:
-        """ """
+        """
+        查询季列表
+        """
         if (res := self.__request_api(f"/season/list/{tv_guid}")) and res.success:
             return [self.__build_item(info) for info in res.data]
         return None
 
     def episode_list(self, season_guid: str) -> Optional[list[Item]]:
-        """ """
+        """
+        查询剧集列表
+        """
         if (res := self.__request_api(f"/episode/list/{season_guid}")) and res.success:
             return [self.__build_item(info) for info in res.data]
         return None
@@ -338,12 +390,12 @@ class Api:
             return [self.__build_item(info) for info in res.data]
         return None
 
-    def __get_authx(self, api_path, body: Optional[str]):
+    def __get_authx(self, api_path: str, body: Optional[str]):
         """
         计算消息签名
         """
-        if api_path[0] != "/":
-            api_path = "/" + api_path
+        if not api_path.startswith("/v"):
+            api_path = "/v" + api_path
         nonce = str(random.randint(100000, 999999))
         ts = str(int(time.time() * 1000))
         md5 = hashlib.md5()
@@ -366,10 +418,17 @@ class Api:
         return f"nonce={nonce}&timestamp={ts}&sign={sign}"
 
     def __request_api(
-            self, api: str, method: str = None, params: dict = None, data: dict = None
+        self,
+        api: str,
+        method: Optional[str] = None,
+        params: Optional[dict] = None,
+        data: Optional[dict] = None,
+        suppress_log=False,
     ):
         """
         请求飞牛影视API
+
+        :param suppress_log: 是否禁止日志
         """
 
         @dataclass
@@ -397,7 +456,7 @@ class Api:
         url = self._host + api_path
         if method is None:
             method = "get" if data is None else "post"
-        if method == "post":
+        if method != "get":
             json_body = (
                 json.dumps(data, allow_nan=False, cls=JsonEncoder) if data else ""
             )
@@ -422,11 +481,13 @@ class Api:
                 resp = res.json()
                 msg = resp.get("msg")
                 if code := int(resp.get("code", -1)):
-                    logger.error(f"请求接口 {api_path} 失败，错误码：{code} {msg}")
+                    if not suppress_log:
+                        logger.error(f"请求接口 {url} 失败，错误码：{code} {msg}")
                     return Result(code, msg)
                 return Result(0, msg, resp.get("data"))
-            else:
-                logger.error(f"请求接口 {api_path} 失败")
+            elif not suppress_log:
+                logger.error(f"请求接口 {url} 失败")
         except Exception as e:
-            logger.error(f"请求接口 {api_path} 异常：" + str(e))
+            if not suppress_log:
+                logger.error(f"请求接口 {url} 异常：" + str(e))
         return None

app/modules/trimemedia/trimemedia.py

@@ -26,21 +26,59 @@ class TrimeMedia:
         username: Optional[str] = None,
         password: Optional[str] = None,
         play_host: Optional[str] = None,
-        sync_libraries: list = None,
+        sync_libraries: Optional[list] = None,
         **kwargs,
     ):
         if not host or not username or not password:
             logger.error("飞牛影视配置不完整！！")
             return
-        host = UrlUtils.standardize_base_url(host).rstrip("/")
-        if play_host:
-            self._playhost = UrlUtils.standardize_base_url(play_host).rstrip("/")
         self._username = username
         self._password = password
         self._sync_libraries = sync_libraries or []
-        self._api = fnapi.Api(host, apikey="16CCEB3D-AB42-077D-36A1-F355324E4237")
+
+        if (api := self.__create_api(host)) is None:
+            logger.error(f"请检查服务端地址 {host}")
+            return
+        self._api = api
+        if play_api := self.__create_api(play_host):
+            self._playhost = play_api.host
+        elif play_host:
+            logger.warning(f"请检查外网播放地址 {play_host}")
+            self._playhost = UrlUtils.standardize_base_url(play_host).rstrip("/")
+
         self.reconnect()
 
+    @property
+    def api(self) -> Optional[fnapi.Api]:
+        """
+        获得飞牛API
+        """
+        return self._api
+
+    def __create_api(self, host: Optional[str]) -> Optional[fnapi.Api]:
+        """
+        创建一个飞牛API
+
+        :param host:  服务端地址
+        :return: 如果地址无效、不可访问则返回None
+        """
+        if not host:
+            return None
+        api_key = "16CCEB3D-AB42-077D-36A1-F355324E4237"
+        host = UrlUtils.standardize_base_url(host).rstrip("/")
+
+        if not host.endswith("/v"):
+            # 尝试补上结尾的/v 测试能否正常访问
+            api = fnapi.Api(host + "/v", api_key)
+            if api.sys_version():
+                return api
+        # 测试用户配置的地址
+        api = fnapi.Api(host, api_key)
+        return api if api.sys_version() else None
+
+    def __del__(self):
+        self.disconnect()
+
     def is_configured(self) -> bool:
         return self._api is not None
 
@@ -62,14 +100,27 @@ class TrimeMedia:
         """
         if not self.is_configured():
             return False
+        if (fnver := self._api.sys_version()) is None:
+            return False
+        # 版本号:0.8.36, 服务版本:0.8.19
+        logger.debug(f"版本号:{fnver.frontend}, 服务版本:{fnver.backend}")
         if self._api.login(self._username, self._password) is None:
             return False
         self._userinfo = self._api.user_info()
         if self._userinfo is None:
             return False
-        logger.debug(f"{self._userinfo.username} 成功登录飞牛影视")
+        logger.debug(f"{self._username} 成功登录飞牛影视")
         return True
 
+    def disconnect(self):
+        """
+        断开与飞牛的连接
+        """
+        if self.is_authenticated():
+            self._api.logout()
+            self._userinfo = None
+            logger.debug(f"{self._username} 已断开飞牛影视")
+
     def get_librarys(
         self, hidden: Optional[bool] = False
     ) -> List[schemas.MediaServerLibrary]:
@@ -87,11 +138,11 @@ class TrimeMedia:
         for library in self._libraries.values():
             if hidden and self.__is_library_blocked(library.guid):
                 continue
-            if library.category == fnapi.Category.Movie:
+            if library.category == fnapi.Category.MOVIE:
                 library_type = MediaType.MOVIE.value
             elif library.category == fnapi.Category.TV:
                 library_type = MediaType.TV.value
-            elif library.category == fnapi.Category.Others:
+            elif library.category == fnapi.Category.OTHERS:
                 # 忽略这个库
                 continue
             else:
@@ -107,7 +158,7 @@ class TrimeMedia:
                         f"{self._api.host}{img_path}?w=256"
                         for img_path in library.posters or []
                     ],
-                    link=f"{self._playhost or self._api.host}/v/library/{library.guid}",
+                    link=f"{self._playhost or self._api.host}/library/{library.guid}",
                 )
             )
         return libraries
@@ -170,7 +221,7 @@ class TrimeMedia:
         movies = []
         items = self._api.search_list(keywords=title) or []
         for item in items:
-            if item.type != fnapi.Type.Movie:
+            if item.type != fnapi.Type.MOVIE:
                 continue
             if (
                 (not tmdb_id or tmdb_id == item.tmdb_id)
@@ -280,7 +331,7 @@ class TrimeMedia:
             lib = self.__match_library_by_path(item.target_path)
             if lib is None:
                 # 如果有匹配失败的,刷新整个库
-                return self._api.mdb_scanall()
+                return self.refresh_root_library()
             # 媒体库去重
             libraries.add(lib.guid)
 
@@ -290,7 +341,7 @@ class TrimeMedia:
             logger.info(f"刷新媒体库：{lib.name}")
             if not self._api.mdb_scan(lib):
                 # 如果失败，刷新整个库
-                return self._api.mdb_scanall()
+                return self.refresh_root_library()
         return True
 
     def __match_library_by_path(self, path: Path) -> Optional[fnapi.MediaDb]:
@@ -336,7 +387,7 @@ class TrimeMedia:
         if item.watched:
             user_state.played = True
         if item.duration and item.ts is not None:
-            user_state.percentage = item.ts / item.duration
+            user_state.percentage = item.ts / item.duration * 100
             user_state.resume = True
         if item.type is None:
             item_type = None
@@ -361,40 +412,37 @@ class TrimeMedia:
         """
         拼装播放链接
         """
-        if item.type == fnapi.Type.Episode:
-            return f"{host}/v/tv/episode/{item.guid}"
-        elif item.type == fnapi.Type.Season:
-            return f"{host}/v/tv/season/{item.guid}"
-        elif item.type == fnapi.Type.Movie:
-            return f"{host}/v/movie/{item.guid}"
+        if item.type == fnapi.Type.EPISODE:
+            return f"{host}/tv/episode/{item.guid}"
+        elif item.type == fnapi.Type.SEASON:
+            return f"{host}/tv/season/{item.guid}"
+        elif item.type == fnapi.Type.MOVIE:
+            return f"{host}/movie/{item.guid}"
         elif item.type == fnapi.Type.TV:
-            return f"{host}/v/tv/{item.guid}"
+            return f"{host}/tv/{item.guid}"
         else:
             # 其它类型走通用页面，由飞牛来判断
-            return f"{host}/v/other/{item.guid}"
+            return f"{host}/other/{item.guid}"
 
     def __build_media_server_play_item(
         self, item: fnapi.Item
     ) -> schemas.MediaServerPlayItem:
-        """
-        :params use_backdrop: 是否优先使用Backdrop类型的图片
-        """
-        if item.type == fnapi.Type.Episode:
+        if item.type == fnapi.Type.EPISODE:
             title = item.tv_title
             subtitle = f"S{item.season_number}:{item.episode_number} - {item.title}"
         else:
             title = item.title
-            subtitle = "电影" if item.type == fnapi.Type.Movie else "视频"
-        type = (
+            subtitle = "电影" if item.type == fnapi.Type.MOVIE else "视频"
+        types = (
             MediaType.MOVIE.value
-            if item.type in [fnapi.Type.Movie, fnapi.Type.Video]
+            if item.type in [fnapi.Type.MOVIE, fnapi.Type.VIDEO]
             else MediaType.TV.value
         )
         return schemas.MediaServerPlayItem(
             id=item.guid,
             title=title,
             subtitle=subtitle,
-            type=type,
+            type=types,
             image=f"{self._api.host}{item.poster}",
             link=self.__build_play_url(self._playhost or self._api.host, item),
             percent=(
@@ -421,22 +469,22 @@ class TrimeMedia:
         """
         if not self.is_authenticated():
             return None
-        if (SIZE := limit) is None:
-            SIZE = -1
+        if (page_size := limit) is None:
+            page_size = -1
         items = (
             self._api.item_list(
                 guid=parent,
                 page=start_index + 1,
-                page_size=SIZE,
-                type=[fnapi.Type.Movie, fnapi.Type.TV, fnapi.Type.Directory],
+                page_size=page_size,
+                types=[fnapi.Type.MOVIE, fnapi.Type.TV, fnapi.Type.DIRECTORY],
             )
             or []
         )
         for item in items:
-            if item.type == fnapi.Type.Directory:
+            if item.type == fnapi.Type.DIRECTORY:
                 for items in self.get_items(parent=item.guid):
                     yield items
-            elif item.type in [fnapi.Type.Movie, fnapi.Type.TV]:
+            elif item.type in [fnapi.Type.MOVIE, fnapi.Type.TV]:
                 yield self.__build_media_server_item(item)
         return None
 
@@ -482,7 +530,7 @@ class TrimeMedia:
             self._api.item_list(
                 page=1,
                 page_size=max(100, num * 5),
-                type=[fnapi.Type.Movie, fnapi.Type.TV],
+                types=[fnapi.Type.MOVIE, fnapi.Type.TV],
             )
             or []
         )
@@ -505,7 +553,7 @@ class TrimeMedia:
             self._api.item_list(
                 page=1,
                 page_size=max(100, num * 5),
-                type=[fnapi.Type.Movie, fnapi.Type.TV],
+                types=[fnapi.Type.MOVIE, fnapi.Type.TV],
             )
             or []
         )
@@ -534,7 +582,7 @@ class TrimeMedia:
 
     def __is_library_blocked(self, library_guid: str):
         if library := self._libraries.get(library_guid):
-            if library.category == fnapi.Category.Others:
+            if library.category == fnapi.Category.OTHERS:
                 # 忽略这个库
                 return True
         return (

app/plugins/__init__.py

@@ -34,6 +34,8 @@ class _PluginBase(metaclass=ABCMeta):
     plugin_desc: Optional[str] = ""
     # 插件顺序
     plugin_order: Optional[int] = 9999
+    # 是否为插件分身
+    is_clone: bool = False
 
     def __init__(self):
         # 插件数据
@@ -55,6 +57,13 @@ class _PluginBase(metaclass=ABCMeta):
         """
         pass
 
+    def get_name(self) -> str:
+        """
+        获取插件名称
+        :return: 插件名称
+        """
+        return self.plugin_name
+
     @abstractmethod
     def get_state(self) -> bool:
         """
@@ -76,6 +85,14 @@ class _PluginBase(metaclass=ABCMeta):
         """
         pass
 
+    @staticmethod
+    def get_render_mode() -> Tuple[str, Optional[str]]:
+        """
+        获取插件渲染模式
+        :return: 1、渲染模式，支持：vue/vuetify，默认vuetify；2、vue模式下编译后文件的相对路径，默认为`dist/asserts`，vuetify模式下为None
+        """
+        return "vuetify", None
+
     @abstractmethod
     def get_api(self) -> List[Dict[str, Any]]:
         """
@@ -84,6 +101,7 @@ class _PluginBase(metaclass=ABCMeta):
             "path": "/xx",
             "endpoint": self.xxx,
             "methods": ["GET", "POST"],
+            "auth: "apikey",  # 鉴权类型：apikey/bear
             "summary": "API名称",
             "description": "API说明"
         }]
@@ -91,18 +109,19 @@ class _PluginBase(metaclass=ABCMeta):
         pass
 
     @abstractmethod
-    def get_form(self) -> Tuple[List[dict], Dict[str, Any]]:
+    def get_form(self) -> Tuple[Optional[List[dict]], Dict[str, Any]]:
         """
-        拼装插件配置页面，需要返回两块数据：1、页面配置；2、数据结构
-        插件配置页面使用Vuetify组件拼装，参考：https://vuetifyjs.com/
+        拼装插件配置页面，插件配置页面使用Vuetify组件拼装，参考：https://vuetifyjs.com/
+        :return: 1、页面配置（vuetify模式）或 None（vue模式）；2、默认数据结构
         """
         pass
 
     @abstractmethod
-    def get_page(self) -> List[dict]:
+    def get_page(self) -> Optional[List[dict]]:
         """
         拼装插件详情页面，需要返回页面配置，同时附带数据
         插件详情页面使用Vuetify组件拼装，参考：https://vuetifyjs.com/
+        :return: 页面配置（vuetify模式）或 None（vue模式）
         """
         pass
 
@@ -119,9 +138,9 @@ class _PluginBase(metaclass=ABCMeta):
         """
         pass
 
-    def get_dashboard(self, key: str, **kwargs) -> Optional[Tuple[Dict[str, Any], Dict[str, Any], List[dict]]]:
+    def get_dashboard(self, key: str, **kwargs) -> Optional[Tuple[Dict[str, Any], Dict[str, Any], Optional[List[dict]]]]:
         """
-        获取插件仪表盘页面，需要返回：1、仪表板col配置字典；2、全局配置（自动刷新等）；3、仪表板页面元素配置json（含数据）
+        获取插件仪表盘页面，需要返回：1、仪表板col配置字典；2、全局配置（布局、自动刷新等）；3、仪表板页面元素配置含数据json（vuetify）或 None（vue模式）
         1、col配置参考：
         {
             "cols": 12, "md": 6
@@ -133,7 +152,7 @@ class _PluginBase(metaclass=ABCMeta):
             "title": "组件标题", // 组件标题，如有将显示该标题，否则显示插件名称
             "subtitle": "组件子标题", // 组件子标题，缺省时不展示子标题
         }
-        3、页面配置使用Vuetify组件拼装，参考：https://vuetifyjs.com/
+        3、vuetify模式页面配置使用Vuetify组件拼装，参考：https://vuetifyjs.com/；vue模式为None
 
         kwargs参数可获取的值：1、user_agent：浏览器UA
 
@@ -155,6 +174,32 @@ class _PluginBase(metaclass=ABCMeta):
         """
         pass
 
+    def get_module(self) -> Dict[str, Any]:
+        """
+        获取插件模块声明，用于胁持系统模块实现（方法名：方法实现）
+        {
+            "id1": self.xxx1,
+            "id2": self.xxx2,
+        }
+        """
+        pass
+
+    def get_actions(self) -> List[Dict[str, Any]]:
+        """
+        获取插件工作流动作
+        [{
+            "id": "动作ID",
+            "name": "动作名称",
+            "func": self.xxx,
+            "kwargs": {} # 需要附加传递的参数
+        }]
+
+        对实现函数的要求：
+        1、函数的第一个参数固定为 ActionContent 实例，如需要传递额外参数，在kwargs中定义
+        2、函数的返回：执行状态 True / False，更新后的 ActionContent 实例
+        """
+        pass
+
     @abstractmethod
     def stop_service(self):
         """

app/scheduler.py

@@ -51,6 +51,8 @@ class Scheduler(metaclass=Singleton):
     _jobs = {}
     # 用户认证失败次数
     _auth_count = 0
+    # 用户认证失败消息发送
+    _auth_message = False
 
     def __init__(self):
         self.init()
@@ -538,17 +540,18 @@ class Scheduler(metaclass=Singleton):
         self.remove_plugin_job(pid)
         # 获取插件服务列表
         with self._lock:
+            plugin_manager = PluginManager()
             try:
-                plugin_services = PluginManager().get_plugin_services(pid=pid)
+                plugin_services = plugin_manager.get_plugin_services(pid=pid)
             except Exception as e:
                 logger.error(f"运行插件 {pid} 服务失败：{str(e)} - {traceback.format_exc()}")
                 return
             # 获取插件名称
-            plugin_name = PluginManager().get_plugin_attr(pid, "plugin_name")
+            plugin_name = plugin_manager.get_plugin_attr(pid, "plugin_name")
             # 开始注册插件服务
             for service in plugin_services:
                 try:
-                    sid = f"{service['id']}"
+                    sid = f"{pid}_{service['id']}"
                     job_id = sid.split("|")[0]
                     self.remove_plugin_job(pid, job_id)
                     self._jobs[job_id] = {
@@ -586,6 +589,9 @@ class Scheduler(metaclass=Singleton):
             schedulers = []
             # 去重
             added = []
+            # 避免_scheduler.shutdown()处于阻塞状态导致的死锁
+            if not self._scheduler or not self._scheduler.running:
+                return []
             jobs = self._scheduler.get_jobs()
             # 按照下次运行时间排序
             jobs.sort(key=lambda x: x.next_run_time)
@@ -594,8 +600,8 @@ class Scheduler(metaclass=Singleton):
                 name = service.get("name")
                 provider_name = service.get("provider_name")
                 if service.get("running") and name and provider_name:
-                    if name not in added:
-                        added.append(name)
+                    if job_id not in added:
+                        added.append(job_id)
                     schedulers.append(schemas.ScheduleInfo(
                         id=job_id,
                         name=name,
@@ -604,11 +610,11 @@ class Scheduler(metaclass=Singleton):
                     ))
             # 获取其他待执行任务
             for job in jobs:
-                if job.name not in added:
-                    added.append(job.name)
+                job_id = job.id.split("|")[0]
+                if job_id not in added:
+                    added.append(job_id)
                 else:
                     continue
-                job_id = job.id.split("|")[0]
                 service = self._jobs.get(job_id)
                 if not service:
                     continue
@@ -658,9 +664,11 @@ class Scheduler(metaclass=Singleton):
         # 最大重试次数
         __max_try__ = 30
         if self._auth_count > __max_try__:
-            SchedulerChain().messagehelper.put(title=f"用户认证失败",
-                                               message="用户认证失败次数过多，将不再尝试认证！",
-                                               role="system")
+            if not self._auth_message:
+                SchedulerChain().messagehelper.put(title=f"用户认证失败",
+                                                   message="用户认证失败次数过多，将不再尝试认证！",
+                                                   role="system")
+                self._auth_message = True
             return
         logger.info("用户未认证，正在尝试认证...")
         auth_conf = SystemConfigOper().get(SystemConfigKey.UserSiteAuthParams)
@@ -675,10 +683,11 @@ class Scheduler(metaclass=Singleton):
                 Notification(
                     mtype=NotificationType.Manual,
                     title="MoviePilot用户认证成功",
-                    text=f"使用站点：{msg}",
+                    text=f"使用站点：{msg}，如有插件使用异常，请重启MoviePilot。",
                     link=settings.MP_DOMAIN('#/site')
                 )
             )
+            # 认证通过后重新初始化插件
             PluginManager().init_config()
             self.init_plugin_jobs()
 

app/schemas/event.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import Optional, Dict, Any, List, Set
+from typing import Optional, Dict, Any, List, Set, Callable
 
 from pydantic import BaseModel, Field, root_validator
 
@@ -274,6 +274,7 @@ class RecommendMediaSource(BaseModel):
     """
     name: str = Field(..., description="数据源名称")
     api_path: str = Field(..., description="媒体数据源API地址")
+    type: str = Field(..., description="类型")
 
 
 class RecommendSourceEventData(ChainEventData):
@@ -305,4 +306,22 @@ class MediaRecognizeConvertEventData(ChainEventData):
     convert_type: str = Field(..., description="转换类型（themoviedb/douban）")
 
     # 输出参数
-    media_dict: dict = Field(default=dict, description="转换后的媒体信息（TheMovieDb/豆瓣）")
+    media_dict: dict = Field(default_factory=dict, description="转换后的媒体信息（TheMovieDb/豆瓣）")
+
+
+class StorageOperSelectionEventData(ChainEventData):
+    """
+    StorageOperSelect 事件的数据模型
+
+    Attributes:
+        # 输入参数
+        storage (str): 存储类型
+
+        # 输出参数
+        storage_oper (Callable): 存储操作对象
+    """
+    # 输入参数
+    storage: Optional[str] = Field(default=None, description="存储类型")
+
+    # 输出参数
+    storage_oper: Optional[Callable] = Field(default=None, description="存储操作对象")

app/schemas/file.py

@@ -1,11 +1,11 @@
-from typing import Optional, Union
+from typing import Optional
 
 from pydantic import BaseModel, Field
 
 
 class FileItem(BaseModel):
     # 存储类型
-    storage: Optional[str] = "local"
+    storage: Optional[str] = Field(default="local")
     # 类型 dir/file
     type: Optional[str] = None
     # 文件路径

app/schemas/mediaserver.py

@@ -160,6 +160,7 @@ class WebhookEventInfo(BaseModel):
     save_reason: Optional[str] = None
     item_isvirtual: Optional[bool] = None
     media_type: Optional[str] = None
+    json_object: Optional[dict] = {}
 
 
 class MediaServerPlayItem(BaseModel):

app/schemas/message.py

@@ -2,7 +2,7 @@ from typing import Optional, Union
 
 from pydantic import BaseModel, Field
 
-from app.schemas.types import NotificationType, MessageChannel
+from app.schemas.types import ContentType, NotificationType, MessageChannel
 
 
 class CommingMessage(BaseModel):
@@ -45,6 +45,8 @@ class Notification(BaseModel):
     source: Optional[str] = None
     # 消息类型
     mtype: Optional[NotificationType] = None
+    # 内容类型
+    ctype: Optional[ContentType] = None
     # 标题
     title: Optional[str] = None
     # 文本内容

app/schemas/plugin.py

@@ -59,6 +59,8 @@ class PluginDashboard(Plugin):
     name: Optional[str] = None
     # 仪表板key
     key: Optional[str] = None
+    # 演染模式
+    render_mode: Optional[str] = Field(default="vuetify")
     # 全局配置
     attrs: Optional[dict] = Field(default_factory=dict)
     # col列数

app/schemas/subscribe.py

@@ -74,7 +74,7 @@ class Subscribe(BaseModel):
     # 过滤规则组
     filter_groups: Optional[List[str]] = Field(default_factory=list)
     # 剧集组
-    episode_group: str = None
+    episode_group: Optional[str] = None
 
     class Config:
         orm_mode = True

app/schemas/transfer.py

@@ -115,15 +115,23 @@ class TransferInfo(BaseModel):
     # 整理方式
     transfer_type: Optional[str] = None
     # 处理文件数
-    file_count: Optional[int] = 0
+    file_count: Optional[int] = Field(default=0)
     # 处理文件清单
     file_list: Optional[list] = Field(default_factory=list)
     # 目标文件清单
     file_list_new: Optional[list] = Field(default_factory=list)
     # 总文件大小
-    total_size: Optional[float] = 0.0
+    total_size: Optional[int] = Field(default=0)
     # 失败清单
     fail_list: Optional[list] = Field(default_factory=list)
+    # 处理字幕文件清单
+    subtitle_list: Optional[list] = Field(default_factory=list)
+    # 目标字幕文件清单
+    subtitle_list_new: Optional[list] = Field(default_factory=list)
+    # 处理音频文件清单
+    audio_list: Optional[list] = Field(default_factory=list)
+    # 目标音频文件清单
+    audio_list_new: Optional[list] = Field(default_factory=list)
     # 错误信息
     message: Optional[str] = None
     # 是否需要刮削

app/schemas/types.py

@@ -89,6 +89,8 @@ class ChainEventType(Enum):
     RecommendSource = "recommend.source"
     # 工作流执行
     WorkflowExecution = "workflow.execution"
+    # 存储操作选择
+    StorageOperSelection = "storage.operation"
 
 
 # 系统配置Key字典
@@ -139,6 +141,8 @@ class SystemConfigKey(Enum):
     UserInstalledPlugins = "UserInstalledPlugins"
     # 插件安装统计
     PluginInstallReport = "PluginInstallReport"
+    # 插件文件夹分组配置
+    PluginFolders = "PluginFolders"
     # 默认电影订阅规则
     DefaultMovieSubscribeConfig = "DefaultMovieSubscribeConfig"
     # 默认电视剧订阅规则
@@ -149,6 +153,8 @@ class SystemConfigKey(Enum):
     FollowSubscribers = "FollowSubscribers"
     # 通知发送时间
     NotificationSendTime = "NotificationSendTime"
+    # 通知消息格式模板
+    NotificationTemplates = "NotificationTemplates"
 
 
 # 处理进度Key字典
@@ -187,6 +193,21 @@ class NotificationType(Enum):
     Other = "其它"
 
 
+class ContentType(str, Enum):
+    """
+    消息内容类型
+    操作状态的通知消息类型标识
+    """
+    # 订阅添加成功
+    SubscribeAdded = "subscribeAdded"
+    # 订阅完成
+    SubscribeComplete = "subscribeComplete"
+    # 入库成功
+    OrganizeSuccess = "organizeSuccess"
+    # 下载开始(添加下载任务成功)
+    DownloadAdded = "downloadAdded"
+
+
 # 消息渠道
 class MessageChannel(Enum):
     """

app/startup/command_initializer.py

@@ -0,0 +1,22 @@
+from app.command import Command
+
+
+def init_command():
+    """
+    初始化命令
+    """
+    Command()
+
+
+def stop_command():
+    """
+    停止命令
+    """
+    pass
+
+
+def restart_command():
+    """
+    重启命令
+    """
+    Command().init_commands()

app/startup/lifecycle.py

@@ -3,10 +3,25 @@ from contextlib import asynccontextmanager
 
 from fastapi import FastAPI
 
-from app.startup.workflow_initializer import init_workflow, stop_workflow
-from app.startup.modules_initializer import shutdown_modules, start_modules
-from app.startup.plugins_initializer import init_plugins_async
+from app.core.config import global_vars
+from app.startup.command_initializer import init_command, stop_command, restart_command
+from app.startup.modules_initializer import init_modules, stop_modules
+from app.startup.monitor_initializer import stop_monitor, init_monitor
+from app.startup.plugins_initializer import init_plugins, stop_plugins, sync_plugins
 from app.startup.routers_initializer import init_routers
+from app.startup.scheduler_initializer import stop_scheduler, init_scheduler, init_plugin_scheduler
+from app.startup.workflow_initializer import init_workflow, stop_workflow
+
+
+async def init_plugin_system():
+    """
+    同步插件及重启相关依赖服务
+    """
+    if await sync_plugins():
+        # 重新注册插件定时服务
+        init_plugin_scheduler()
+        # 重新注册命令
+        restart_command()
 
 
 @asynccontextmanager
@@ -15,29 +30,45 @@ async def lifespan(app: FastAPI):
     定义应用的生命周期事件
     """
     print("Starting up...")
-    # 启动模块
-    start_modules(app)
-    # 初始化工作流动作
-    init_workflow(app)
+    # 初始化模块
+    init_modules()
     # 初始化路由
     init_routers(app)
     # 初始化插件
-    plugin_init_task = asyncio.create_task(init_plugins_async())
+    init_plugins()
+    # 初始化定时器
+    init_scheduler()
+    # 初始化监控器
+    init_monitor()
+    # 初始化命令
+    init_command()
+    # 初始化工作流
+    init_workflow()
+    # 插件同步到本地
+    sync_plugins_task = asyncio.create_task(init_plugin_system())
     try:
         # 在此处 yield，表示应用已经启动，控制权交回 FastAPI 主事件循环
         yield
     finally:
         print("Shutting down...")
+        # 停止信号
+        global_vars.stop_system()
         try:
-            # 取消插件初始化
-            plugin_init_task.cancel()
-            await plugin_init_task
+            sync_plugins_task.cancel()
+            await sync_plugins_task
         except asyncio.CancelledError:
-            print("Plugin installation task cancelled.")
+            pass
         except Exception as e:
-            print(f"Error during plugin installation shutdown: {e}")
-        # 清理模块
-        shutdown_modules(app)
-        # 关闭工作流
-        stop_workflow(app)
-
+            print(str(e))
+        # 停止工作流
+        stop_workflow()
+        # 停止命令
+        stop_command()
+        # 停止监控器
+        stop_monitor()
+        # 停止定时器
+        stop_scheduler()
+        # 停止插件
+        stop_plugins()
+        # 停止模块
+        stop_modules()

app/startup/modules_initializer.py

@@ -1,12 +1,11 @@
 import sys
 
-from fastapi import FastAPI
-
 from app.core.cache import close_cache
-from app.core.config import global_vars, settings
+from app.core.config import settings
 from app.core.module import ModuleManager
 from app.log import logger
 from app.utils.system import SystemUtils
+from app.command import CommandChain
 
 # SitesHelper涉及资源包拉取，提前引入并容错提示
 try:
@@ -18,18 +17,14 @@ except ImportError as e:
     sys.exit(1)
 
 from app.core.event import EventManager
-from app.core.plugin import PluginManager
 from app.helper.thread import ThreadHelper
 from app.helper.display import DisplayHelper
 from app.helper.resource import ResourceHelper
 from app.helper.message import MessageHelper
-from app.scheduler import Scheduler
-from app.monitor import Monitor
 from app.schemas import Notification, NotificationType
 from app.schemas.types import SystemConfigKey
 from app.db import close_database
 from app.db.systemconfig_oper import SystemConfigOper
-from app.command import Command, CommandChain
 
 
 def start_frontend():
@@ -109,25 +104,16 @@ def check_auth():
         )
 
 
-def shutdown_modules(_: FastAPI):
+def stop_modules():
     """
     服务关闭
     """
-    # 停止信号
-    global_vars.stop_system()
     # 停止模块
     ModuleManager().stop()
-    # 停止插件
-    PluginManager().stop()
-    PluginManager().stop_monitor()
     # 停止事件消费
     EventManager().stop()
     # 停止虚拟显示
     DisplayHelper().stop()
-    # 停止定时服务
-    Scheduler().stop()
-    # 停止监控
-    Monitor().stop()
     # 停止线程池
     ThreadHelper().shutdown()
     # 停止缓存连接
@@ -140,7 +126,7 @@ def shutdown_modules(_: FastAPI):
     clear_temp()
 
 
-def start_modules(_: FastAPI):
+def init_modules():
     """
     启动模块
     """
@@ -156,14 +142,6 @@ def start_modules(_: FastAPI):
     ModuleManager()
     # 启动事件消费
     EventManager().start()
-    # 加载插件
-    PluginManager().start()
-    # 启动监控任务
-    Monitor()
-    # 启动定时服务
-    Scheduler()
-    # 加载命令
-    Command()
     # 启动前端服务
     start_frontend()
     # 检查认证状态

app/startup/monitor_initializer.py

@@ -0,0 +1,15 @@
+from app.monitor import Monitor
+
+
+def init_monitor():
+    """
+    初始化监控器
+    """
+    Monitor()
+
+
+def stop_monitor():
+    """
+    停止监控器
+    """
+    Monitor().stop()

app/startup/plugins_initializer.py

@@ -1,43 +1,36 @@
 import asyncio
 
-from app.command import Command
 from app.core.plugin import PluginManager
 from app.log import logger
-from app.scheduler import Scheduler
 
 
-async def init_plugins_async():
+async def sync_plugins() -> bool:
     """
     初始化安装插件，并动态注册后台任务及API
     """
     try:
         loop = asyncio.get_event_loop()
         plugin_manager = PluginManager()
-        scheduler = Scheduler()
-        command = Command()
 
         sync_result = await execute_task(loop, plugin_manager.sync, "插件同步到本地")
         resolved_dependencies = await execute_task(loop, plugin_manager.install_plugin_missing_dependencies,
                                                    "缺失依赖项安装")
         # 判断是否需要进行插件初始化
         if not sync_result and not resolved_dependencies:
-            logger.debug("没有新的插件同步到本地或缺失依赖项需要安装，跳过插件初始化")
-            return
+            logger.debug("没有新的插件同步到本地或缺失依赖项需要安装")
+            return False
 
         # 继续执行后续的插件初始化步骤
-        logger.info("正在初始化所有插件")
-        # 为避免初始化插件异常，这里所有插件都进行初始化
-        # 安装完成后重新初始化插件
+        logger.info("正在重新初始化插件")
+        # 重新初始化插件
         plugin_manager.init_config()
-        # 插件启动后注册后台任务
-        scheduler.init_plugin_jobs()
-        # 插件启动后注册菜单命令
-        command.init_commands()
-        # 插件启动后注册插件API
+        # 重新注册插件API
         register_plugin_api()
         logger.info("所有插件初始化完成")
+        return True
     except Exception as e:
         logger.error(f"插件初始化过程中出现异常: {e}")
+        return False
 
 
 async def execute_task(loop, task_func, task_name):
@@ -62,3 +55,23 @@ def register_plugin_api():
     """
     from app.api.endpoints import plugin
     plugin.register_plugin_api()
+
+
+def init_plugins():
+    """
+    初始化插件
+    """
+    PluginManager().start()
+    register_plugin_api()
+
+
+def stop_plugins():
+    """
+    停止插件
+    """
+    try:
+        plugin_manager = PluginManager()
+        plugin_manager.stop()
+        plugin_manager.stop_monitor()
+    except Exception as e:
+        logger.error(f"停止插件时发生错误：{e}", exc_info=True)

app/startup/scheduler_initializer.py

@@ -0,0 +1,29 @@
+from app.scheduler import Scheduler
+
+
+def init_scheduler():
+    """
+    初始化定时器
+    """
+    Scheduler()
+
+
+def stop_scheduler():
+    """
+    停止定时器
+    """
+    Scheduler().stop()
+
+
+def restart_scheduler():
+    """
+    重启定时器
+    """
+    Scheduler().init()
+
+
+def init_plugin_scheduler():
+    """
+    初始化插件定时器
+    """
+    Scheduler().init_plugin_jobs()

app/startup/workflow_initializer.py

@@ -1,16 +1,14 @@
-from fastapi import FastAPI
-
 from app.core.workflow import WorkFlowManager
 
 
-def init_workflow(_: FastAPI):
+def init_workflow():
     """
     初始化动作
     """
     WorkFlowManager()
 
 
-def stop_workflow(_: FastAPI):
+def stop_workflow():
     """
     停止动作
     """

app/utils/object.py

@@ -52,21 +52,30 @@ class ObjectUtils:
                 # 跳过空行
                 if not line:
                     continue
-                # 处理多行注释
+                # 处理"""单行注释
+                if (line.startswith(('"""', "'''"))
+                        and line.endswith(('"""', "'''"))
+                        and len(line) > 3):
+                    continue
+                # 处理"""多行注释
                 if line.startswith(('"""', "'''")):
                     in_comment = not in_comment
                     continue
                 # 在注释中则跳过
                 if in_comment:
                     continue
-                # 跳过注释、pass语句、装饰器、函数定义行
-                if line.startswith('#') or line == "pass" or line.startswith('@') or line.startswith('def '):
+                # 跳过#注释、pass语句、装饰器、函数定义行
+                if (line.startswith('#')
+                        or line == "pass"
+                        or line.startswith('@')
+                        or line.startswith('def ')):
                     continue
                 # 发现有效代码行
                 return True
             # 没有有效代码行
             return False
-        except Exception:
+        except Exception as err:
+            print(err)
             # 源代码分析失败时，进行字节码分析
             code_obj = func.__code__
             instructions = list(dis.get_instructions(code_obj))

app/utils/string.py

@@ -15,7 +15,8 @@ from app.schemas.types import MediaType
 _special_domains = [
     'u2.dmhy.org',
     'pt.ecust.pp.ua',
-    'pt.gtkpw.xyz'
+    'pt.gtkpw.xyz',
+    'pt.gtk.pw'
 ]
 
 # 内置版本号转换字典
@@ -642,13 +643,14 @@ class StringUtils:
         if len(parts) > 3:
             # 处理不希望包含多个冒号的情况（除了协议后的冒号）
             return None, None
-        # 不含端口地址
-        domain = ":".join(parts[:-1]).rstrip('/')
-        # 端口号
-        try:
+        elif len(parts) == 3:
             port = int(parts[-1])
-        except ValueError:
-            # 端口号不是整数，返回 None 表示无效
+            # 不含端口地址
+            domain = ":".join(parts[:-1]).rstrip('/')
+        elif len(parts) == 2:
+            port = 443 if address.startswith("https") else 80
+            domain = address
+        else:
             return None, None
         return domain, port
 
@@ -906,3 +908,20 @@ class StringUtils:
         :return: 如果elem有效（非None且长度大于0），返回True；否则返回False
         """
         return elem is not None and len(elem) > 0
+
+    @staticmethod
+    def is_link(text: str) -> bool:
+        """
+        检查文件是否为链接地址，支持各类协议
+        :param text: 要检查的文本
+        :return: 如果URL有效，返回True；否则返回False
+        """
+        if not text:
+            return False
+        # 检查是否以http、https、ftp等协议开头
+        if re.match(r'^(http|https|ftp|ftps|sftp|ws|wss)://', text):
+            return True
+        # 检查是否为IP地址或域名
+        if re.match(r'^[a-zA-Z0-9.-]+(\.[a-zA-Z]{2,})?$', text):
+            return True
+        return False

app/utils/system.py

@@ -11,7 +11,6 @@ from glob import glob
 from pathlib import Path
 from typing import List, Optional, Tuple, Union
 
-import docker
 import psutil
 
 from app import schemas
@@ -439,47 +438,6 @@ class SystemUtils:
         """
         return [psutil.virtual_memory().used, int(psutil.virtual_memory().percent)]
 
-    @staticmethod
-    def can_restart() -> bool:
-        """
-        判断是否可以内部重启
-        """
-        return Path("/var/run/docker.sock").exists()
-
-    @staticmethod
-    def restart() -> Tuple[bool, str]:
-        """
-        执行Docker重启操作
-        """
-        if not SystemUtils.is_docker():
-            return False, "非Docker环境，无法重启！"
-        try:
-            # 创建 Docker 客户端
-            client = docker.DockerClient(base_url='tcp://127.0.0.1:38379')
-            # 获取当前容器的 ID
-            container_id = None
-            with open('/proc/self/mountinfo', 'r') as f:
-                data = f.read()
-                index_resolv_conf = data.find("resolv.conf")
-                if index_resolv_conf != -1:
-                    index_second_slash = data.rfind("/", 0, index_resolv_conf)
-                    index_first_slash = data.rfind("/", 0, index_second_slash) + 1
-                    container_id = data[index_first_slash:index_second_slash]
-                    if len(container_id) < 20:
-                        index_resolv_conf = data.find("/sys/fs/cgroup/devices")
-                        if index_resolv_conf != -1:
-                            index_second_slash = data.rfind(" ", 0, index_resolv_conf)
-                            index_first_slash = data.rfind("/", 0, index_second_slash) + 1
-                            container_id = data[index_first_slash:index_second_slash]
-            if not container_id:
-                return False, "获取容器ID失败！"
-            # 重启当前容器
-            client.containers.get(container_id.strip()).restart()
-            return True, ""
-        except Exception as err:
-            print(str(err))
-            return False, f"重启时发生错误：{str(err)}"
-
     @staticmethod
     def is_hardlink(src: Path, dest: Path) -> bool:
         """

app/utils/tokens.py

@@ -12,7 +12,7 @@ class Tokens:
         self.load_text(text)
 
     def load_text(self, text):
-        splitted_text = re.split(r"\.|\s+|\(|\)|\[|]|-|\+|【|】|/|～|;|&|\||#|_|「|」|~", text)
+        splitted_text = re.split(r"\.|\s+|\(|\)|\[|]|-|【|】|/|～|;|&|\||#|_|「|」|~", text)
         for sub_text in splitted_text:
             if sub_text:
                 self._tokens.append(sub_text)

app/utils/web.py

@@ -1,7 +1,3 @@
-from typing import Optional, List
-
-from app.core.cache import cached
-
 from app.utils.http import RequestUtils
 
 
@@ -73,38 +69,3 @@ class WebUtils:
         except Exception as err:
             print(str(err))
             return ""
-
-    @staticmethod
-    @cached(maxsize=1, ttl=3600)
-    def get_bing_wallpaper() -> Optional[str]:
-        """
-        获取Bing每日壁纸
-        """
-        url = "https://cn.bing.com/HPImageArchive.aspx?format=js&idx=0&n=1"
-        resp = RequestUtils(timeout=5).get_res(url)
-        if resp and resp.status_code == 200:
-            try:
-                result = resp.json()
-                if isinstance(result, dict):
-                    for image in result.get('images') or []:
-                        return f"https://cn.bing.com{image.get('url')}" if 'url' in image else ''
-            except Exception as err:
-                print(str(err))
-        return None
-
-    @staticmethod
-    @cached(maxsize=1, ttl=3600)
-    def get_bing_wallpapers(num: int = 7) -> List[str]:
-        """
-        获取7天的Bing每日壁纸
-        """
-        url = f"https://cn.bing.com/HPImageArchive.aspx?format=js&idx=0&n={num}"
-        resp = RequestUtils(timeout=5).get_res(url)
-        if resp and resp.status_code == 200:
-            try:
-                result = resp.json()
-                if isinstance(result, dict):
-                    return [f"https://cn.bing.com{image.get('url')}" for image in result.get('images') or []]
-            except Exception as err:
-                print(str(err))
-        return []

config/app.env

@@ -1,67 +1,29 @@
-#######################################################################
-# 【*】为必配项，其余为选配项，选配项可以删除整项配置项或者保留配置默认值       #
-#######################################################################
+#######################################################################################################
+# V2版本中大部分设置可通过后台设置界面进行配置，本文件仅展示界面无法配置的项， 这些项同样可以通过环境变量进行设置      #
+#######################################################################################################
 # 【*】API监听地址（注意不是前端访问地址）
 HOST=0.0.0.0
-# 是否调试模式，打开后将输出更多日志
-DEBUG=false
-# 是否开发模式，打开后后台服务将不会启动
-DEV=false
-# 日志级别（DEBUG、INFO、WARNING、ERROR等），当DEBUG=true时，此配置项将被忽略，日志级别始终为DEBUG
-LOG_LEVEL=INFO
+# 【*】超级管理员，设置后一但重启将固化到数据库中，修改将无效（初始化超级管理员密码仅会生成一次，请在日志中查看并自行登录系统修改）
+SUPERUSER=admin
+# 重启自动升级 release/dev/true/false
+MOVIEPILOT_AUTO_UPDATE=release
+# 自动检查和更新站点资源包（索引、认证等）
+AUTO_UPDATE_RESOURCE=true
+# 网络代理服务器地址 http(s)://ip:port、socks5://user:pass@host:port、socks5h://user:pass@host:port
+PROXY_HOST=
+# 媒体识别来源 themoviedb/douban，使用themoviedb时需要确保能正常连接api.themoviedb.org，使用douban时不支持二级分类
+RECOGNIZE_SOURCE=themoviedb
+# OCR服务器地址
+OCR_HOST=https://movie-pilot.org
+# 搜索多个名称，true/false，为true时搜索时会同时搜索中英文及原始名称，搜索结果会更全面，但会增加搜索时间；为false时其中一个名称搜索到结果或全部名称搜索完毕即停止
+SEARCH_MULTIPLE_NAME=false
+# 为指定字幕添加.default后缀设置为默认字幕，支持为'zh-cn'，'zh-tw'，'eng'添加默认字幕，未定义或设置为None则不添加
+DEFAULT_SUB=zh-cn
 # 数据库连接池的大小，可适当降低如20-50以减少I/O压力
 DB_POOL_SIZE=100
 # 数据库连接池最大溢出连接数，可适当降低如0以减少I/O压力
 DB_MAX_OVERFLOW=500
 # SQLite 的 busy_timeout 参数，可适当增加如180以减少锁定错误
 DB_TIMEOUT=60
-# SQLite 是否启用 WAL 模式，启用可提升读写并发性能，但可能在异常情况下增加数据丢失的风险
-DB_WAL_ENABLE=false
-# 【*】超级管理员，设置后一但重启将固化到数据库中，修改将无效（初始化超级管理员密码仅会生成一次，请在日志中查看并自行登录系统修改）
-SUPERUSER=admin
-# 辅助认证，允许通过外部服务进行认证、单点登录以及自动创建用户
-AUXILIARY_AUTH_ENABLE=false
-# 大内存模式，开启后会增加缓存数量，但会占用更多内存
-BIG_MEMORY_MODE=false
-# 是否启用DOH域名解析，启用后对于api.themovie.org等域名通过DOH解析，避免域名DNS被污染
-DOH_ENABLE=true
-# 使用 DOH 解析的域名列表，多个域名使用`,`分隔
-DOH_DOMAINS=api.themoviedb.org,api.tmdb.org,webservice.fanart.tv,api.github.com,github.com,raw.githubusercontent.com,api.telegram.org
-# DOH 解析服务器列表，多个服务器使用`,`分隔
-DOH_RESOLVERS=1.0.0.1,1.1.1.1,9.9.9.9,149.112.112.112
-# 元数据识别缓存过期时间，数字型，单位小时，0为系统默认（大内存模式为7天，滞则为3天），调大该值可减少themoviedb的访问次数
-META_CACHE_EXPIRE=0
-# 自动检查和更新站点资源包（索引、认证等）
-AUTO_UPDATE_RESOURCE=true
-# 【*】API密钥，未设置时系统将随机生成，建议使用复杂字符串，用于Jellyseerr/Overseerr、媒体服务器Webhook等配置以及部分支持API_TOKEN的API请求
-API_TOKEN=''
-# 登录页面电影海报，tmdb/bing/mediaserver，tmdb要求能正常连接api.themoviedb.org
-WALLPAPER=tmdb
-# TMDB图片地址，无需修改需保留默认值，如果默认地址连通性不好可以尝试修改为：`static-mdb.v.geilijiasu.com`
-TMDB_IMAGE_DOMAIN=image.tmdb.org
-# TMDB API地址，无需修改需保留默认值，也可配置为`api.tmdb.org`或其它中转代理服务地址，能连通即可
-TMDB_API_DOMAIN=api.themoviedb.org
-# 媒体识别来源 themoviedb/douban，使用themoviedb时需要确保能正常连接api.themoviedb.org，使用douban时不支持二级分类
-RECOGNIZE_SOURCE=themoviedb
-# Fanart开关
-FANART_ENABLE=true
-# 新增已入库媒体是否跟随TMDB信息变化，true/false，为false时即使TMDB信息变化时也会仍然按历史记录中已入库的信息进行刮削
-SCRAP_FOLLOW_TMDB=true
-# 刮削来源 themoviedb/douban，使用themoviedb时需要确保能正常连接api.themoviedb.org，使用douban时会缺失部分信息
-SCRAP_SOURCE=themoviedb
-# 电影重命名格式，Jinja2语法，参考：https://jinja.palletsprojects.com/en/3.0.x/templates/
-MOVIE_RENAME_FORMAT={{title}}{% if year %} ({{year}}){% endif %}/{{title}}{% if year %} ({{year}}){% endif %}{% if part %}-{{part}}{% endif %}{% if videoFormat %} - {{videoFormat}}{% endif %}{{fileExt}}
-# 电视剧重命名格式，Jinja2语法，参考：https://jinja.palletsprojects.com/en/3.0.x/templates/
-TV_RENAME_FORMAT={{title}}{% if year %} ({{year}}){% endif %}/Season {{season}}/{{title}} - {{season_episode}}{% if part %}-{{part}}{% endif %}{% if episode %} - 第 {{episode}} 集{% endif %}{{fileExt}}
-# 交互搜索自动下载用户ID（消息通知渠道的用户ID），使用,分割，设置为 all 代表所有用户自动择优下载，未设置需要用户手动选择资源或者回复`0`才自动择优下载
-AUTO_DOWNLOAD_USER=
-# 自动下载站点字幕（如有）
-DOWNLOAD_SUBTITLE=true
-# OCR服务器地址
-OCR_HOST=https://movie-pilot.org
-# 插件市场仓库地址，多个地址使用`,`分隔，保留最后的/
-PLUGIN_MARKET=https://github.com/jxxghp/MoviePilot-Plugins,https://github.com/thsrite/MoviePilot-Plugins,https://github.com/InfinityPacer/MoviePilot-Plugins,https://github.com/honue/MoviePilot-Plugins
-# 搜索多个名称，true/false，为true时搜索时会同时搜索中英文及原始名称，搜索结果会更全面，但会增加搜索时间；为false时其中一个名称搜索到结果或全部名称搜索完毕即停止
-SEARCH_MULTIPLE_NAME=true
-# 为指定字幕添加.default后缀设置为默认字幕，支持为'zh-cn'，'zh-tw'，'eng'添加默认字幕，未定义或设置为None则不添加
-DEFAULT_SUB=None
+# 是否开发调试模式，仅开发人员使用，打开后将停止后台服务
+DEV=false

config/category.yaml

@@ -5,6 +5,7 @@
 #   `original_language` 语种，具体含义参考下方字典
 #   `production_countries` 国家或地区（电影）、`origin_country` 国家或地区（电视剧），具体含义参考下方字典
 #   `genre_ids` 内容类型，具体含义参考下方字典
+#   `release_year` 发行年份，格式：YYYY，电影实际对应`release_date`字段，电视剧实际对应`first_air_date`字段，支持范围设定，如：`YYYY-YYYY`
 #   themoviedb 详情API返回的其它一级字段
 # 4. 配置多项条件时需要同时满足，一个条件需要匹配多个值是使用`,`分隔