增加搜索次数统计和强制休眠机制以优化搜索性能

- 添加检查临时目录中是否存在种子文件
- 修改 match_torrent 方法参数类型
- 优化种子文件下载和处理逻辑

.github/ISSUE_TEMPLATE/rfc.yml

@@ -10,7 +10,7 @@ body:
         目的是让协作的开发者间清晰的知道「要做什么」和「具体会怎么做」，以及所有的开发者都能公开透明的参与讨论；
         以便评估和讨论产生的影响 (遗漏的考虑、向后兼容性、与现有功能的冲突)，
         因此提案侧重在对解决问题的 **方案、设计、步骤** 的描述上。
-          
+
         如果仅希望讨论是否添加或改进某功能本身，请使用 -> [Issue: 功能改进](https://github.com/jxxghp/MoviePilot/issues/new?assignees=&labels=feature+request&projects=&template=feature_request.yml&title=%5BFeature+Request%5D%3A+)
   - type: textarea
     id: background

.github/workflows/build.yml

@@ -25,7 +25,9 @@ jobs:
         id: meta
         uses: docker/metadata-action@v5
         with:
-          images: ${{ secrets.DOCKER_USERNAME }}/moviepilot-v2
+          images: |
+            ${{ secrets.DOCKER_USERNAME }}/moviepilot-v2
+            ghcr.io/${{ github.repository }}
           tags: |
             type=raw,value=${{ env.app_version }}
             type=raw,value=latest
@@ -42,6 +44,13 @@ jobs:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
 
+      - name: Login GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
       - name: Build Image
         uses: docker/build-push-action@v5
         with:

.github/workflows/issues.yml

@@ -0,0 +1,32 @@
+name: Close inactive issues
+on:
+ workflow_dispatch:
+
+ schedule:
+   # Github Action 只支持 UTC 时间。
+   # '0 18 * * *' 对应 UTC 时间的 18:00，也就是中国时区 (UTC+8) 的第二天凌晨 02:00。
+   - cron: "0 18 * * *"
+
+jobs:
+ close-issues:
+   runs-on: ubuntu-latest
+   permissions:
+     issues: write
+     pull-requests: write
+   steps:
+     - uses: actions/stale@v5
+       with:
+         # 标记 stale 标签时间
+         days-before-issue-stale: 30
+         # 关闭 issues 标签时间
+         days-before-issue-close: 14
+         # 自定义标签名
+         stale-issue-label: "stale"
+         stale-issue-message: "此问题已过时，因为它已打开 30 天且没有任何活动。"
+         close-issue-message: "此问题已关闭，因为它在标记为 stale 后，已处于无更新状态 14 天。"
+         # 忽略所有的 Pull Request，只处理 Issue
+         days-before-pr-stale: -1
+         days-before-pr-close: -1
+         # 排除带有RFC标签的issue
+         exempt-issue-labels: "RFC"
+         repo-token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/pylint.yml

@@ -1,16 +1,6 @@
 name: Pylint Code Quality Check
 
 on:
-  # 在推送到任何分支时运行
-  push:
-    branches: [ "main", "v2", "develop" ]
-    paths:
-      - '**.py'
-  # 在PR时运行
-  pull_request:
-    branches: [ "main", "v2", "develop" ]
-    paths:
-      - '**.py'
   # 允许手动触发
   workflow_dispatch:
 
@@ -18,35 +8,40 @@ jobs:
   pylint:
     runs-on: ubuntu-latest
     name: Pylint Code Quality Check
-    
+
     steps:
     - name: Checkout code
       uses: actions/checkout@v4
-      
+
     - name: Set up Python
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v5
       with:
-        python-version: '3.11'
-        
+        python-version: '3.12'
+        cache: 'pip'
+
     - name: Cache pip dependencies
-      uses: actions/cache@v3
+      uses: actions/cache@v4
       with:
         path: ~/.cache/pip
         key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt', '**/requirements.in') }}
         restore-keys: |
           ${{ runner.os }}-pip-
-          
+
     - name: Install dependencies
       run: |
-        python -m pip install --upgrade pip
+        python -m pip install --upgrade pip setuptools wheel
         pip install pylint
         # 安装项目依赖
         if [ -f requirements.txt ]; then
+          echo "📦 安装 requirements.txt 中的依赖..."
           pip install -r requirements.txt
         elif [ -f requirements.in ]; then
+          echo "📦 安装 requirements.in 中的依赖..."
           pip install -r requirements.in
+        else
+          echo "⚠️ 未找到依赖文件，仅安装 pylint"
         fi
-        
+
     - name: Verify pylint config
       run: |
         # 检查项目中的pylint配置文件是否存在
@@ -62,35 +57,35 @@ jobs:
       run: |
         # 运行pylint，检查主要的Python文件
         echo "🚀 运行 Pylint 错误检查..."
-        
+
         # 检查主要目录 - 只关注错误，如果有错误则退出
         echo "📂 检查 app/ 目录..."
         pylint app/ --output-format=colorized --reports=yes --score=yes
-        
+
         # 检查根目录的Python文件
         echo "📂 检查根目录 Python 文件..."
         for file in $(find . -name "*.py" -not -path "./.*" -not -path "./.venv/*" -not -path "./build/*" -not -path "./dist/*" -not -path "./tests/*" -not -path "./docs/*" -not -path "./__pycache__/*" -maxdepth 1); do
           echo "检查文件: $file"
           pylint "$file" --output-format=colorized || exit 1
         done
-        
+
         # 生成详细报告
         echo "📊 生成 Pylint 详细报告..."
         pylint app/ --output-format=json > pylint-report.json || true
-        
+
         # 显示评分（仅供参考）
         echo "📈 Pylint 评分（仅供参考）:"
         pylint app/ --score=yes --reports=no | tail -2 || true
-        
+
     - name: Upload pylint report
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       if: always()
       with:
         name: pylint-report
         path: pylint-report.json
-        
+
     - name: Summary
       run: |
         echo "🎉 Pylint 检查完成！"
         echo "✅ 没有发现语法错误或严重问题"
-        echo "📊 详细报告已保存为构建工件" 
+        echo "📊 详细报告已保存为构建工件"

.pylintrc

@@ -12,7 +12,7 @@ jobs=0
 # 只关注错误级别的问题，禁用警告、约定和重构建议
 # E = Error (错误) - 会导致构建失败
 # W = Warning (警告) - 仅显示，不会失败
-# R = Refactor (重构建议) - 仅显示，不会失败  
+# R = Refactor (重构建议) - 仅显示，不会失败
 # C = Convention (约定) - 仅显示，不会失败
 # I = Information (信息) - 仅显示，不会失败
 
@@ -80,4 +80,4 @@ ignore-imports=yes
 
 [TYPECHECK]
 # 生成缺失成员提示的类列表
-generated-members=requests.packages.urllib3 
+generated-members=requests.packages.urllib3

app/actions/add_download.py

@@ -26,37 +26,31 @@ class AddDownloadAction(BaseAction):
     添加下载资源
     """
 
-    # 已添加的下载
-    _added_downloads = []
-    _has_error = False
-
     def __init__(self, action_id: str):
         super().__init__(action_id)
-        self.downloadchain = DownloadChain()
-        self.mediachain = MediaChain()
         self._added_downloads = []
         self._has_error = False
 
     @classmethod
     @property
-    def name(cls) -> str: # noqa
+    def name(cls) -> str:  # noqa
         return "添加下载"
 
     @classmethod
     @property
-    def description(cls) -> str: # noqa
+    def description(cls) -> str:  # noqa
         return "根据资源列表添加下载任务"
 
     @classmethod
     @property
-    def data(cls) -> dict: # noqa
+    def data(cls) -> dict:  # noqa
         return AddDownloadParams().dict()
 
     @property
     def success(self) -> bool:
         return not self._has_error
 
-    def execute(self, workflow_id: int,  params: dict, context: ActionContext) -> ActionContext:
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
         """
         将上下文中的torrents添加到下载任务中
         """
@@ -73,13 +67,13 @@ class AddDownloadAction(BaseAction):
             if not t.meta_info:
                 t.meta_info = MetaInfo(title=t.torrent_info.title, subtitle=t.torrent_info.description)
             if not t.media_info:
-                t.media_info = self.mediachain.recognize_media(meta=t.meta_info)
+                t.media_info = MediaChain().recognize_media(meta=t.meta_info)
             if not t.media_info:
                 self._has_error = True
                 logger.warning(f"{t.torrent_info.title} 未识别到媒体信息，无法下载")
                 continue
             if params.only_lack:
-                exists_info = self.downloadchain.media_exists(t.media_info)
+                exists_info = DownloadChain().media_exists(t.media_info)
                 if exists_info:
                     if t.media_info.type == MediaType.MOVIE:
                         # 电影
@@ -96,14 +90,15 @@ class AddDownloadAction(BaseAction):
                             exists_episodes = exists_seasons.get(t.meta_info.begin_season)
                             if exists_episodes:
                                 if set(t.meta_info.episode_list).issubset(exists_episodes):
-                                    logger.warning(f"{t.meta_info.title} 第 {t.meta_info.begin_season} 季第 {t.meta_info.episode_list} 集已存在，跳过")
+                                    logger.warning(
+                                        f"{t.meta_info.title} 第 {t.meta_info.begin_season} 季第 {t.meta_info.episode_list} 集已存在，跳过")
                                     continue
 
             _started = True
-            did = self.downloadchain.download_single(context=t,
-                                                     downloader=params.downloader,
-                                                     save_path=params.save_path,
-                                                     label=params.labels)
+            did = DownloadChain().download_single(context=t,
+                                                  downloader=params.downloader,
+                                                  save_path=params.save_path,
+                                                  label=params.labels)
             if did:
                 self._added_downloads.append(did)
                 # 保存缓存

app/actions/add_subscribe.py

@@ -19,29 +19,24 @@ class AddSubscribeAction(BaseAction):
     添加订阅
     """
 
-    _added_subscribes = []
-    _has_error = False
-
     def __init__(self, action_id: str):
         super().__init__(action_id)
-        self.subscribechain = SubscribeChain()
-        self.subscribeoper = SubscribeOper()
         self._added_subscribes = []
         self._has_error = False
 
     @classmethod
     @property
-    def name(cls) -> str: # noqa
+    def name(cls) -> str:  # noqa
         return "添加订阅"
 
     @classmethod
     @property
-    def description(cls) -> str: # noqa
+    def description(cls) -> str:  # noqa
         return "根据媒体列表添加订阅"
 
     @classmethod
     @property
-    def data(cls) -> dict: # noqa
+    def data(cls) -> dict:  # noqa
         return AddSubscribeParams().dict()
 
     @property
@@ -63,19 +58,20 @@ class AddSubscribeAction(BaseAction):
                 continue
             mediainfo = MediaInfo()
             mediainfo.from_dict(media.dict())
-            if self.subscribechain.exists(mediainfo):
+            subscribechain = SubscribeChain()
+            if subscribechain.exists(mediainfo):
                 logger.info(f"{media.title} 已存在订阅")
                 continue
             # 添加订阅
             _started = True
-            sid, message = self.subscribechain.add(mtype=mediainfo.type,
-                                                   title=mediainfo.title,
-                                                   year=mediainfo.year,
-                                                   tmdbid=mediainfo.tmdb_id,
-                                                   season=mediainfo.season,
-                                                   doubanid=mediainfo.douban_id,
-                                                   bangumiid=mediainfo.bangumi_id,
-                                                   username=settings.SUPERUSER)
+            sid, message = subscribechain.add(mtype=mediainfo.type,
+                                              title=mediainfo.title,
+                                              year=mediainfo.year,
+                                              tmdbid=mediainfo.tmdb_id,
+                                              season=mediainfo.season,
+                                              doubanid=mediainfo.douban_id,
+                                              bangumiid=mediainfo.bangumi_id,
+                                              username=settings.SUPERUSER)
             if sid:
                 self._added_subscribes.append(sid)
                 # 保存缓存
@@ -84,7 +80,7 @@ class AddSubscribeAction(BaseAction):
         if self._added_subscribes:
             logger.info(f"已添加 {len(self._added_subscribes)} 个订阅")
             for sid in self._added_subscribes:
-                context.subscribes.append(self.subscribeoper.get(sid))
+                context.subscribes.append(SubscribeOper().get(sid))
         elif _started:
             self._has_error = True
 

app/actions/fetch_downloads.py

@@ -16,11 +16,8 @@ class FetchDownloadsAction(BaseAction):
     获取下载任务
     """
 
-    _downloads = []
-
     def __init__(self, action_id: str):
         super().__init__(action_id)
-        self.chain = ActionChain()
         self._downloads = []
 
     @classmethod
@@ -51,7 +48,7 @@ class FetchDownloadsAction(BaseAction):
             if global_vars.is_workflow_stopped(workflow_id):
                 break
             logger.info(f"获取下载任务 {download.download_id} 状态 ...")
-            torrents = self.chain.list_torrents(hashs=[download.download_id])
+            torrents = ActionChain().list_torrents(hashs=[download.download_id])
             if not torrents:
                 download.completed = True
                 continue

app/actions/fetch_medias.py

@@ -27,10 +27,6 @@ class FetchMediasAction(BaseAction):
     获取媒体数据
     """
 
-    _inner_sources = []
-    _medias = []
-    _has_error = False
-
     def __init__(self, action_id: str):
         super().__init__(action_id)
 

app/actions/fetch_rss.py

@@ -29,29 +29,24 @@ class FetchRssAction(BaseAction):
     获取RSS资源列表
     """
 
-    _rss_torrents = []
-    _has_error = False
-
     def __init__(self, action_id: str):
         super().__init__(action_id)
-        self.rsshelper = RssHelper()
-        self.chain = ActionChain()
         self._rss_torrents = []
         self._has_error = False
 
     @classmethod
     @property
-    def name(cls) -> str: # noqa
+    def name(cls) -> str:  # noqa
         return "获取RSS资源"
 
     @classmethod
     @property
-    def description(cls) -> str: # noqa
+    def description(cls) -> str:  # noqa
         return "订阅RSS地址获取资源"
 
     @classmethod
     @property
-    def data(cls) -> dict: # noqa
+    def data(cls) -> dict:  # noqa
         return FetchRssParams().dict()
 
     @property
@@ -74,10 +69,10 @@ class FetchRssAction(BaseAction):
         if params.ua:
             headers["User-Agent"] = params.ua
 
-        rss_items = self.rsshelper.parse(url=params.url,
-                                         proxy=settings.PROXY if params.proxy else None,
-                                         timeout=params.timeout,
-                                         headers=headers)
+        rss_items = RssHelper().parse(url=params.url,
+                                      proxy=settings.PROXY if params.proxy else None,
+                                      timeout=params.timeout,
+                                      headers=headers)
         if rss_items is None or rss_items is False:
             logger.error(f'RSS地址 {params.url} 请求失败！')
             self._has_error = True
@@ -103,7 +98,7 @@ class FetchRssAction(BaseAction):
             meta = MetaInfo(title=torrentinfo.title, subtitle=torrentinfo.description)
             mediainfo = None
             if params.match_media:
-                mediainfo = self.chain.recognize_media(meta)
+                mediainfo = ActionChain().recognize_media(meta)
                 if not mediainfo:
                     logger.warning(f"{torrentinfo.title} 未识别到媒体信息")
                     continue

app/actions/fetch_torrents.py

@@ -29,26 +29,23 @@ class FetchTorrentsAction(BaseAction):
     搜索站点资源
     """
 
-    _torrents = []
-
     def __init__(self, action_id: str):
         super().__init__(action_id)
-        self.searchchain = SearchChain()
         self._torrents = []
 
     @classmethod
     @property
-    def name(cls) -> str: # noqa
+    def name(cls) -> str:  # noqa
         return "搜索站点资源"
 
     @classmethod
     @property
-    def description(cls) -> str: # noqa
+    def description(cls) -> str:  # noqa
         return "搜索站点种子资源列表"
 
     @classmethod
     @property
-    def data(cls) -> dict: # noqa
+    def data(cls) -> dict:  # noqa
         return FetchTorrentsParams().dict()
 
     @property
@@ -60,9 +57,10 @@ class FetchTorrentsAction(BaseAction):
         搜索站点，获取资源列表
         """
         params = FetchTorrentsParams(**params)
+        searchchain = SearchChain()
         if params.search_type == "keyword":
             # 按关键字搜索
-            torrents = self.searchchain.search_by_title(title=params.name, sites=params.sites)
+            torrents = searchchain.search_by_title(title=params.name, sites=params.sites)
             for torrent in torrents:
                 if global_vars.is_workflow_stopped(workflow_id):
                     break
@@ -74,7 +72,7 @@ class FetchTorrentsAction(BaseAction):
                     continue
                 # 识别媒体信息
                 if params.match_media:
-                    torrent.media_info = self.searchchain.recognize_media(torrent.meta_info)
+                    torrent.media_info = searchchain.recognize_media(torrent.meta_info)
                     if not torrent.media_info:
                         logger.warning(f"{torrent.torrent_info.title} 未识别到媒体信息")
                         continue
@@ -84,10 +82,10 @@ class FetchTorrentsAction(BaseAction):
             for media in context.medias:
                 if global_vars.is_workflow_stopped(workflow_id):
                     break
-                torrents = self.searchchain.search_by_id(tmdbid=media.tmdb_id,
-                                                         doubanid=media.douban_id,
-                                                         mtype=MediaType(media.type),
-                                                         sites=params.sites)
+                torrents = searchchain.search_by_id(tmdbid=media.tmdb_id,
+                                                    doubanid=media.douban_id,
+                                                    mtype=MediaType(media.type),
+                                                    sites=params.sites)
                 for torrent in torrents:
                     self._torrents.append(torrent)
 

app/actions/filter_medias.py

@@ -22,8 +22,6 @@ class FilterMediasAction(BaseAction):
     过滤媒体数据
     """
 
-    _medias = []
-
     def __init__(self, action_id: str):
         super().__init__(action_id)
         self._medias = []

app/actions/filter_torrents.py

@@ -27,12 +27,8 @@ class FilterTorrentsAction(BaseAction):
     过滤资源数据
     """
 
-    _torrents = []
-
     def __init__(self, action_id: str):
         super().__init__(action_id)
-        self.torrenthelper = TorrentHelper()
-        self.chain = ActionChain()
         self._torrents = []
 
     @classmethod
@@ -62,7 +58,7 @@ class FilterTorrentsAction(BaseAction):
         for torrent in context.torrents:
             if global_vars.is_workflow_stopped(workflow_id):
                 break
-            if self.torrenthelper.filter_torrent(
+            if TorrentHelper().filter_torrent(
                     torrent_info=torrent.torrent_info,
                     filter_params={
                         "quality": params.quality,
@@ -73,7 +69,7 @@ class FilterTorrentsAction(BaseAction):
                         "size": params.size
                     }
             ):
-                if self.chain.filter_torrents(
+                if ActionChain().filter_torrents(
                         rule_groups=params.rule_groups,
                         torrent_list=[torrent.torrent_info],
                         mediainfo=torrent.media_info

app/actions/invoke_plugin.py

@@ -20,8 +20,6 @@ class InvokePluginAction(BaseAction):
     调用插件
     """
 
-    _success = False
-
     def __init__(self, action_id: str):
         super().__init__(action_id)
         self._success = False

app/actions/note.py

@@ -0,0 +1,30 @@
+from app.actions import BaseAction
+from app.schemas import ActionContext
+
+
+class NoteAction(BaseAction):
+    """
+    备注
+    """
+
+    @classmethod
+    @property
+    def name(cls) -> str: # noqa
+        return "备注"
+
+    @classmethod
+    @property
+    def description(cls) -> str: # noqa
+        return "给工作流添加备注"
+
+    @classmethod
+    @property
+    def data(cls) -> dict: # noqa
+        return {}
+
+    @property
+    def success(self) -> bool:
+        return True
+
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
+        return context

app/actions/scan_file.py

@@ -24,12 +24,8 @@ class ScanFileAction(BaseAction):
     整理文件
     """
 
-    _fileitems = []
-    _has_error = False
-
     def __init__(self, action_id: str):
         super().__init__(action_id)
-        self.storagechain = StorageChain()
         self._fileitems = []
         self._has_error = False
 
@@ -59,12 +55,13 @@ class ScanFileAction(BaseAction):
         params = ScanFileParams(**params)
         if not params.storage or not params.directory:
             return context
-        fileitem = self.storagechain.get_file_item(params.storage, Path(params.directory))
+        storagechain = StorageChain()
+        fileitem = storagechain.get_file_item(params.storage, Path(params.directory))
         if not fileitem:
             logger.error(f"目录不存在: 【{params.storage}】{params.directory}")
             self._has_error = True
             return context
-        files = self.storagechain.list_files(fileitem, recursion=True)
+        files = storagechain.list_files(fileitem, recursion=True)
         for file in files:
             if global_vars.is_workflow_stopped(workflow_id):
                 break

app/actions/scrape_file.py

@@ -21,13 +21,8 @@ class ScrapeFileAction(BaseAction):
     刮削文件
     """
 
-    _scraped_files = []
-    _has_error = False
-
     def __init__(self, action_id: str):
         super().__init__(action_id)
-        self.storagechain = StorageChain()
-        self.mediachain = MediaChain()
         self._scraped_files = []
         self._has_error = False
 
@@ -61,7 +56,7 @@ class ScrapeFileAction(BaseAction):
                 break
             if fileitem in self._scraped_files:
                 continue
-            if not self.storagechain.exists(fileitem):
+            if not StorageChain().exists(fileitem):
                 continue
             # 检查缓存
             cache_key = f"{fileitem.path}"
@@ -69,12 +64,13 @@ class ScrapeFileAction(BaseAction):
                 logger.info(f"{fileitem.path} 已刮削过，跳过")
                 continue
             meta = MetaInfoPath(Path(fileitem.path))
-            mediainfo = self.mediachain.recognize_media(meta)
+            mediachain = MediaChain()
+            mediainfo = mediachain.recognize_media(meta)
             if not mediainfo:
                 _failed_count += 1
                 logger.info(f"{fileitem.path} 未识别到媒体信息，无法刮削")
                 continue
-            self.mediachain.scrape_metadata(fileitem=fileitem, meta=meta, mediainfo=mediainfo)
+            mediachain.scrape_metadata(fileitem=fileitem, meta=meta, mediainfo=mediainfo)
             self._scraped_files.append(fileitem)
             # 保存缓存
             self.save_cache(workflow_id, cache_key)

app/actions/send_message.py

@@ -4,7 +4,7 @@ from pydantic import Field
 
 from app.actions import BaseAction, ActionChain
 from app.schemas import ActionParams, ActionContext, Notification
-from core.config import settings
+from app.core.config import settings
 
 
 class SendMessageParams(ActionParams):
@@ -22,7 +22,6 @@ class SendMessageAction(BaseAction):
 
     def __init__(self, action_id: str):
         super().__init__(action_id)
-        self.chain = ActionChain()
 
     @classmethod
     @property
@@ -60,7 +59,7 @@ class SendMessageAction(BaseAction):
             if not params.client:
                 params.client = [""]
             for client in params.client:
-                self.chain.post_message(
+                ActionChain().post_message(
                     Notification(
                         source=client,
                         userid=params.userid,

app/actions/transfer_file.py

@@ -26,30 +26,24 @@ class TransferFileAction(BaseAction):
     整理文件
     """
 
-    _fileitems = []
-    _has_error = False
-
     def __init__(self, action_id: str):
         super().__init__(action_id)
-        self.transferchain = TransferChain()
-        self.storagechain = StorageChain()
-        self.transferhis = TransferHistoryOper()
         self._fileitems = []
         self._has_error = False
 
     @classmethod
     @property
-    def name(cls) -> str: # noqa
+    def name(cls) -> str:  # noqa
         return "整理文件"
 
     @classmethod
     @property
-    def description(cls) -> str: # noqa
+    def description(cls) -> str:  # noqa
         return "整理队列中的文件"
 
     @classmethod
     @property
-    def data(cls) -> dict: # noqa
+    def data(cls) -> dict:  # noqa
         return TransferFileParams().dict()
 
     @property
@@ -72,6 +66,9 @@ class TransferFileAction(BaseAction):
         params = TransferFileParams(**params)
         # 失败次数
         _failed_count = 0
+        storagechain = StorageChain()
+        transferchain = TransferChain()
+        transferhis = TransferHistoryOper()
         if params.source == "downloads":
             # 从下载任务中整理文件
             for download in context.downloads:
@@ -85,16 +82,16 @@ class TransferFileAction(BaseAction):
                 if self.check_cache(workflow_id, cache_key):
                     logger.info(f"{download.path} 已整理过，跳过")
                     continue
-                fileitem = self.storagechain.get_file_item(storage="local", path=Path(download.path))
+                fileitem = storagechain.get_file_item(storage="local", path=Path(download.path))
                 if not fileitem:
                     logger.info(f"文件 {download.path} 不存在")
                     continue
-                transferd = self.transferhis.get_by_src(fileitem.path, storage=fileitem.storage)
+                transferd = transferhis.get_by_src(fileitem.path, storage=fileitem.storage)
                 if transferd:
                     # 已经整理过的文件不再整理
                     continue
                 logger.info(f"开始整理文件 {download.path} ...")
-                state, errmsg = self.transferchain.do_transfer(fileitem, background=False)
+                state, errmsg = transferchain.do_transfer(fileitem, background=False)
                 if not state:
                     _failed_count += 1
                     logger.error(f"整理文件 {download.path} 失败: {errmsg}")
@@ -112,13 +109,13 @@ class TransferFileAction(BaseAction):
                 if self.check_cache(workflow_id, cache_key):
                     logger.info(f"{fileitem.path} 已整理过，跳过")
                     continue
-                transferd = self.transferhis.get_by_src(fileitem.path, storage=fileitem.storage)
+                transferd = transferhis.get_by_src(fileitem.path, storage=fileitem.storage)
                 if transferd:
                     # 已经整理过的文件不再整理
                     continue
                 logger.info(f"开始整理文件 {fileitem.path} ...")
-                state, errmsg = self.transferchain.do_transfer(fileitem, background=False,
-                                                               continue_callback=check_continue)
+                state, errmsg = transferchain.do_transfer(fileitem, background=False,
+                                                          continue_callback=check_continue)
                 if not state:
                     _failed_count += 1
                     logger.error(f"整理文件 {fileitem.path} 失败: {errmsg}")

app/api/endpoints/dashboard.py

@@ -166,3 +166,19 @@ def memory2(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
     获取当前内存使用率 API_TOKEN认证（?token=xxx）
     """
     return memory()
+
+
+@router.get("/network", summary="获取当前网络流量", response_model=List[int])
+def network(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    获取当前网络流量（上行和下行流量，单位：bytes/s）
+    """
+    return SystemUtils.network_usage()
+
+
+@router.get("/network2", summary="获取当前网络流量（API_TOKEN）", response_model=List[int])
+def network2(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
+    """
+    获取当前网络流量 API_TOKEN认证（?token=xxx）
+    """
+    return network()

app/api/endpoints/discover.py

@@ -7,9 +7,9 @@ from app.core.event import eventmanager
 from app.core.security import verify_token
 from app.schemas import DiscoverSourceEventData
 from app.schemas.types import ChainEventType, MediaType
-from chain.bangumi import BangumiChain
-from chain.douban import DoubanChain
-from chain.tmdb import TmdbChain
+from app.chain.bangumi import BangumiChain
+from app.chain.douban import DoubanChain
+from app.chain.tmdb import TmdbChain
 
 router = APIRouter()
 

app/api/endpoints/download.py

@@ -44,6 +44,8 @@ def download(
     # 种子信息
     torrentinfo = TorrentInfo()
     torrentinfo.from_dict(torrent_in.dict())
+    # 手动下载始终使用选择的下载器
+    torrentinfo.site_downloader = downloader
     # 上下文
     context = Context(
         meta_info=metainfo,
@@ -51,7 +53,7 @@ def download(
         torrent_info=torrentinfo
     )
     did = DownloadChain().download_single(context=context, username=current_user.name,
-                                          downloader=downloader, save_path=save_path, source="Manual")
+                                          save_path=save_path, source="Manual")
     if not did:
         return schemas.Response(success=False, message="任务添加失败")
     return schemas.Response(success=True, data={
@@ -94,22 +96,22 @@ def add(
 
 @router.get("/start/{hashString}", summary="开始任务", response_model=schemas.Response)
 def start(
-        hashString: str,
+        hashString: str, name: Optional[str] = None,
         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     开如下载任务
     """
-    ret = DownloadChain().set_downloading(hashString, "start")
+    ret = DownloadChain().set_downloading(hashString, "start", name=name)
     return schemas.Response(success=True if ret else False)
 
 
 @router.get("/stop/{hashString}", summary="暂停任务", response_model=schemas.Response)
-def stop(hashString: str,
+def stop(hashString: str, name: Optional[str] = None,
          _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     暂停下载任务
     """
-    ret = DownloadChain().set_downloading(hashString, "stop")
+    ret = DownloadChain().set_downloading(hashString, "stop", name=name)
     return schemas.Response(success=True if ret else False)
 
 
@@ -125,10 +127,10 @@ def clients(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
 
 
 @router.delete("/{hashString}", summary="删除下载任务", response_model=schemas.Response)
-def delete(hashString: str,
+def delete(hashString: str, name: Optional[str] = None,
            _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     删除下载任务
     """
-    ret = DownloadChain().remove_downloading(hashString)
+    ret = DownloadChain().remove_downloading(hashString, name=name)
     return schemas.Response(success=True if ret else False)

app/api/endpoints/history.py

@@ -6,7 +6,6 @@ from sqlalchemy.orm import Session
 
 from app import schemas
 from app.chain.storage import StorageChain
-from app.core.config import settings
 from app.core.event import eventmanager
 from app.core.security import verify_token
 from app.db import get_db
@@ -59,9 +58,8 @@ def transfer_history(title: Optional[str] = None,
         status = True
 
     if title:
-        if settings.TOKENIZED_SEARCH:
-            words = jieba.cut(title, HMM=False)
-            title = "%".join(words)
+        words = jieba.cut(title, HMM=False)
+        title = "%".join(words)
         total = TransferHistory.count_by_title(db, title=title, status=status)
         result = TransferHistory.list_by_title(db, title=title, page=page,
                                                count=count, status=status)

app/api/endpoints/login.py

@@ -43,7 +43,8 @@ def login_access_token(
         user_id=user_or_message.id,
         user_name=user_or_message.name,
         avatar=user_or_message.avatar,
-        level=level
+        level=level,
+        permissions= user_or_message.permissions or {},
     )
 
 

app/api/endpoints/plugin.py

@@ -137,7 +137,7 @@ def register_plugin(plugin_id: str):
 
 @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]:
+                state: Optional[str] = "all", force: bool = False) -> List[schemas.Plugin]:
     """
     查询所有插件清单，包括本地插件和在线插件，插件状态：installed, market, all
     """
@@ -147,11 +147,11 @@ def all_plugins(_: schemas.TokenPayload = Depends(get_current_active_superuser),
     installed_plugins = [plugin for plugin in local_plugins if 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()
+    online_plugins = PluginManager().get_online_plugins(force)
     if not online_plugins:
         # 没有获取在线插件
         if state == "market":
@@ -178,7 +178,7 @@ def all_plugins(_: schemas.TokenPayload = Depends(get_current_active_superuser),
     if state == "market":
         # 返回未安装的插件
         return market_plugins
-        
+
     # 返回所有插件
     return installed_plugins + market_plugins
 
@@ -348,7 +348,7 @@ def plugin_static_file(plugin_id: str, filepath: str):
     获取插件静态文件
     """
     # 基础安全检查
-    if ".." in filepath or ".." in filepath:
+    if ".." in filepath or ".." in plugin_id:
         logger.warning(f"Static File API: Path traversal attempt detected: {plugin_id}/{filepath}")
         raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Forbidden")
 
@@ -523,7 +523,7 @@ def clone_plugin(plugin_id: str,
             version=clone_data.get("version", ""),
             icon=clone_data.get("icon", "")
         )
-        
+
         if success:
             # 注册插件服务
             reload_plugin(message)
@@ -547,7 +547,7 @@ def _add_clone_to_plugin_folder(original_plugin_id: str, clone_plugin_id: str):
         config_oper = SystemConfigOper()
         # 获取插件文件夹配置
         folders = config_oper.get(SystemConfigKey.PluginFolders) or {}
-        
+
         # 查找原插件所在的文件夹
         target_folder = None
         for folder_name, folder_data in folders.items():
@@ -561,7 +561,7 @@ def _add_clone_to_plugin_folder(original_plugin_id: str, clone_plugin_id: str):
                 if original_plugin_id in folder_data:
                     target_folder = folder_name
                     break
-        
+
         # 如果找到了原插件所在的文件夹，则将分身插件也添加到该文件夹中
         if target_folder:
             folder_data = folders[target_folder]
@@ -575,12 +575,12 @@ def _add_clone_to_plugin_folder(original_plugin_id: str, clone_plugin_id: str):
                 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)}")
         # 文件夹处理失败不影响插件分身创建的整体流程
@@ -595,10 +595,10 @@ def _remove_plugin_from_folders(plugin_id: str):
         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:
@@ -613,13 +613,13 @@ def _remove_plugin_from_folders(plugin_id: str):
                     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/site.py

@@ -333,8 +333,8 @@ def read_site_by_domain(
     return site
 
 
-@router.get("/statistic/{site_url}", summary="站点统计信息", response_model=schemas.SiteStatistic)
-def read_site_by_domain(
+@router.get("/statistic/{site_url}", summary="特定站点统计信息", response_model=schemas.SiteStatistic)
+def read_statistic_by_domain(
         site_url: str,
         db: Session = Depends(get_db),
         _: schemas.TokenPayload = Depends(verify_token)
@@ -349,6 +349,17 @@ def read_site_by_domain(
     return schemas.SiteStatistic(domain=domain)
 
 
+@router.get("/statistic", summary="所有站点统计信息", response_model=List[schemas.SiteStatistic])
+def read_statistics(
+        db: Session = Depends(get_db),
+        _: schemas.TokenPayload = Depends(verify_token)
+) -> Any:
+    """
+    获取所有站点统计信息
+    """
+    return SiteStatistic.list(db)
+
+
 @router.get("/rss", summary="所有订阅站点", response_model=List[schemas.Site])
 def read_rss_sites(db: Session = Depends(get_db),
                    _: schemas.TokenPayload = Depends(verify_token)) -> List[dict]:
@@ -411,6 +422,14 @@ def site_mapping(_: User = Depends(get_current_active_superuser)):
         return schemas.Response(success=False, message=f"获取映射失败：{str(e)}")
 
 
+@router.get("/supporting", summary="获取支持的站点列表", response_model=dict)
+def support_sites(_: User = Depends(get_current_active_superuser)):
+    """
+    获取支持的站点列表
+    """
+    return SitesHelper().get_indexsites()
+
+
 @router.get("/{site_id}", summary="站点详情", response_model=schemas.Site)
 def read_site(
         site_id: int,

app/api/endpoints/subscribe.py

@@ -560,6 +560,15 @@ def popular_subscribes(
     return SubscribeHelper().get_shares(name=name, page=page, count=count)
 
 
+@router.get("/share/statistics", summary="查询订阅分享统计", response_model=List[schemas.SubscribeShareStatistics])
+def subscribe_share_statistics(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询订阅分享统计
+    返回每个分享人分享的媒体数量以及总的复用人次
+    """
+    return SubscribeHelper().get_share_statistics()
+
+
 @router.get("/{subscribe_id}", summary="订阅详情", response_model=schemas.Subscribe)
 def read_subscribe(
         subscribe_id: int,

app/api/endpoints/system.py

@@ -1,6 +1,7 @@
 import asyncio
 import io
 import json
+import re
 import tempfile
 from collections import deque
 from datetime import datetime
@@ -10,17 +11,18 @@ from typing import Optional, Union, Annotated
 import aiofiles
 import pillow_avif  # noqa 用于自动注册AVIF支持
 from PIL import Image
-from fastapi import APIRouter, Depends, HTTPException, Header, Request, Response
+from app.helper.sites import SitesHelper
+from fastapi import APIRouter, Body, Depends, HTTPException, Header, Request, Response
 from fastapi.responses import StreamingResponse
 
 from app import schemas
 from app.chain.search import SearchChain
 from app.chain.system import SystemChain
 from app.core.config import global_vars, settings
+from app.core.event import eventmanager
 from app.core.metainfo import MetaInfo
 from app.core.module import ModuleManager
 from app.core.security import verify_apitoken, verify_resource_token, verify_token
-from app.core.event import eventmanager
 from app.db.models import User
 from app.db.systemconfig_oper import SystemConfigOper
 from app.db.user_oper import get_current_active_superuser
@@ -28,7 +30,6 @@ from app.helper.mediaserver import MediaServerHelper
 from app.helper.message import MessageHelper
 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
@@ -94,7 +95,7 @@ def fetch_image(
     # 请求远程图片
     referer = "https://movie.douban.com/" if "doubanio.com" in url else None
     proxies = settings.PROXY if proxy else None
-    response = RequestUtils(ua=settings.USER_AGENT, proxies=proxies, referer=referer,
+    response = RequestUtils(ua=settings.NORMAL_USER_AGENT, proxies=proxies, referer=referer,
                             accept_type="image/avif,image/webp,image/apng,*/*").get_res(url=url)
     if not response:
         raise HTTPException(status_code=502, detail="Failed to fetch the image from the remote server")
@@ -143,6 +144,7 @@ def fetch_image(
 def proxy_img(
         imgurl: str,
         proxy: bool = False,
+        cache: bool = False,
         if_none_match: Annotated[str | None, Header()] = None,
         _: schemas.TokenPayload = Depends(verify_resource_token)
 ) -> Response:
@@ -153,7 +155,7 @@ def proxy_img(
     hosts = [config.config.get("host") for config in MediaServerHelper().get_configs().values() if
              config and config.config and config.config.get("host")]
     allowed_domains = set(settings.SECURITY_IMAGE_DOMAINS) | set(hosts)
-    return fetch_image(url=imgurl, proxy=proxy, use_disk_cache=False,
+    return fetch_image(url=imgurl, proxy=proxy, use_disk_cache=cache,
                        if_none_match=if_none_match, allowed_domains=allowed_domains)
 
 
@@ -185,9 +187,11 @@ def get_global_setting(token: str):
                  "COOKIECLOUD_KEY", "COOKIECLOUD_PASSWORD", "GITHUB_TOKEN", "REPO_GITHUB_TOKEN"}
     )
     # 追加用户唯一ID和订阅分享管理权限
+    share_admin = SubscribeHelper().is_admin_user()
     info.update({
         "USER_UNIQUE_ID": SubscribeHelper().get_user_uuid(),
-        "SUBSCRIBE_SHARE_MANAGE": SubscribeHelper().is_admin_user(),
+        "SUBSCRIBE_SHARE_MANAGE": share_admin,
+        "WORKFLOW_SHARE_MANAGE": share_admin
     })
     return schemas.Response(success=True,
                             data=info)
@@ -225,7 +229,7 @@ def set_env_setting(env: dict,
     if failed_updates:
         return schemas.Response(
             success=False,
-            message=f"{', '.join(failed_updates.keys())} 配置项更新失败",
+            message=f"{', '.join([v[1] for v in failed_updates.values()])}",
             data={
                 "success_updates": success_updates,
                 "failed_updates": failed_updates
@@ -287,8 +291,11 @@ def get_setting(key: str,
 
 
 @router.post("/setting/{key}", summary="更新系统设置", response_model=schemas.Response)
-def set_setting(key: str, value: Union[list, dict, bool, int, str] = None,
-                _: User = Depends(get_current_active_superuser)):
+def set_setting(
+        key: str,
+        value: Annotated[Union[list, dict, bool, int, str] | None, Body()] = None,
+        _: User = Depends(get_current_active_superuser),
+):
     """
     更新系统设置（仅管理员）
     """
@@ -446,30 +453,80 @@ def ruletest(title: str,
 
 
 @router.get("/nettest", summary="测试网络连通性")
-def nettest(url: str,
-            proxy: bool,
-            _: schemas.TokenPayload = Depends(verify_token)):
+def nettest(
+        url: str,
+        proxy: bool,
+        include: Optional[str] = None,
+        _: schemas.TokenPayload = Depends(verify_token),
+):
     """
     测试网络连通性
     """
     # 记录开始的毫秒数
     start_time = datetime.now()
+    headers = None
+    # 当前使用的加速代理
+    proxy_name = ""
+    if "github" in url:
+        # 这是github的连通性测试
+        headers = settings.GITHUB_HEADERS
+    if "{GITHUB_PROXY}" in url:
+        url = url.replace(
+            "{GITHUB_PROXY}", UrlUtils.standardize_base_url(settings.GITHUB_PROXY or "")
+        )
+        if settings.GITHUB_PROXY:
+            proxy_name = "Github加速代理"
+    if "{PIP_PROXY}" in url:
+        url = url.replace(
+            "{PIP_PROXY}",
+            UrlUtils.standardize_base_url(
+                settings.PIP_PROXY or "https://pypi.org/simple/"
+            ),
+        )
+        if settings.PIP_PROXY:
+            proxy_name = "PIP加速代理"
     url = url.replace("{TMDBAPIKEY}", settings.TMDB_API_KEY)
-    result = RequestUtils(proxies=settings.PROXY if proxy else None,
-                          ua=settings.USER_AGENT).get_res(url)
+    result = RequestUtils(
+        proxies=settings.PROXY if proxy else None,
+        headers=headers,
+        timeout=10,
+        ua=settings.NORMAL_USER_AGENT,
+    ).get_res(url)
     # 计时结束的毫秒数
     end_time = datetime.now()
+    time = round((end_time - start_time).total_seconds() * 1000)
     # 计算相关秒数
-    if result and result.status_code == 200:
-        return schemas.Response(success=True, data={
-            "time": round((end_time - start_time).microseconds / 1000)
-        })
-    elif result:
-        return schemas.Response(success=False, message=f"错误码：{result.status_code}", data={
-            "time": round((end_time - start_time).microseconds / 1000)
-        })
+    if result is None:
+        return schemas.Response(
+            success=False, message=f"{proxy_name}无法连接", data={"time": time}
+        )
+    elif result.status_code == 200:
+        if include and not re.search(r"%s" % include, result.text, re.IGNORECASE):
+            # 通常是被加速代理跳转到其它页面了
+            logger.error(f"{url} 的响应内容不匹配包含规则 {include}")
+            if proxy_name:
+                message = f"{proxy_name}已失效，请检查配置"
+            else:
+                message = f"无效响应，不匹配 {include}"
+            return schemas.Response(
+                success=False,
+                message=message,
+                data={"time": time},
+            )
+        return schemas.Response(success=True, data={"time": time})
     else:
-        return schemas.Response(success=False, message="网络连接失败！")
+        if proxy_name:
+            # 加速代理失败
+            message = f"{proxy_name}已失效，错误码：{result.status_code}"
+        else:
+            message = f"错误码：{result.status_code}"
+            if "github" in url:
+                # 非加速代理访问github
+                if result.status_code == 401:
+                    message = "Github Token已失效，请检查配置"
+                elif result.status_code in {403, 429}:
+                    message = "触发限流，请配置Github Token"
+        return schemas.Response(success=False, message=message, data={"time": time})
 
 
 @router.get("/modulelist", summary="查询已加载的模块ID列表", response_model=schemas.Response)

app/api/endpoints/transfer.py

@@ -8,11 +8,13 @@ from app import schemas
 from app.chain.media import MediaChain
 from app.chain.storage import StorageChain
 from app.chain.transfer import TransferChain
+from app.core.config import settings
 from app.core.metainfo import MetaInfoPath
 from app.core.security import verify_token, verify_apitoken
 from app.db import get_db
 from app.db.models.transferhistory import TransferHistory
 from app.db.user_oper import get_current_active_superuser
+from app.helper.directory import DirectoryHelper
 from app.schemas import MediaType, FileItem, ManualTransferItem
 
 router = APIRouter()
@@ -35,11 +37,19 @@ def query_name(path: str, filetype: str,
     if not new_path:
         return schemas.Response(success=False, message="未识别到新名称")
     if filetype == "dir":
-        parents = Path(new_path).parents
-        if len(parents) > 2:
-            new_name = parents[1].name
+        media_path = DirectoryHelper.get_media_root_path(
+            rename_format=settings.RENAME_FORMAT(mediainfo.type),
+            rename_path=Path(new_path),
+        )
+        if media_path:
+            new_name = media_path.name
         else:
-            new_name = parents[0].name
+            # fallback
+            parents = Path(new_path).parents
+            if len(parents) > 2:
+                new_name = parents[1].name
+            else:
+                new_name = parents[0].name
     else:
         new_name = Path(new_path).name
     return schemas.Response(success=True, data={

app/api/endpoints/user.py

@@ -1,8 +1,8 @@
 import base64
 import re
-from typing import Any, List, Union
+from typing import Annotated, Any, List, Union
 
-from fastapi import APIRouter, Depends, HTTPException, UploadFile, File
+from fastapi import APIRouter, Body, Depends, HTTPException, UploadFile, File
 from sqlalchemy.orm import Session
 
 from app import schemas
@@ -164,8 +164,11 @@ def get_config(key: str,
 
 
 @router.post("/config/{key}", summary="更新用户配置", response_model=schemas.Response)
-def set_config(key: str, value: Union[list, dict, bool, int, str] = None,
-               current_user: User = Depends(get_current_active_user)):
+def set_config(
+    key: str,
+    value: Annotated[Union[list, dict, bool, int, str] | None, Body()] = None,
+    current_user: User = Depends(get_current_active_user),
+):
     """
     更新用户配置
     """

app/api/endpoints/workflow.py

@@ -1,3 +1,4 @@
+import json
 from datetime import datetime
 from typing import List, Any, Optional
 
@@ -5,14 +6,15 @@ from fastapi import APIRouter, Depends
 from sqlalchemy.orm import Session
 
 from app import schemas
+from app.chain.workflow import WorkflowChain
 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
+from app.db.models import Workflow
 from app.db.systemconfig_oper import SystemConfigOper
 from app.db.user_oper import get_current_active_user
-from app.chain.workflow import WorkflowChain
+from app.helper.workflow import WorkflowHelper
 from app.scheduler import Scheduler
 
 router = APIRouter()
@@ -24,7 +26,8 @@ def list_workflows(db: Session = Depends(get_db),
     """
     获取工作流列表
     """
-    return Workflow.list(db)
+    from app.db.workflow_oper import WorkflowOper
+    return WorkflowOper(db).list()
 
 
 @router.post("/", summary="创建工作流", response_model=schemas.Response)
@@ -34,13 +37,15 @@ def create_workflow(workflow: schemas.Workflow,
     """
     创建工作流
     """
-    if Workflow.get_by_name(db, workflow.name):
+    from app.db.workflow_oper import WorkflowOper
+    if workflow.name and WorkflowOper(db).get_by_name(workflow.name):
         return schemas.Response(success=False, message="已存在相同名称的工作流")
     if not workflow.add_time:
         workflow.add_time = datetime.strftime(datetime.now(), "%Y-%m-%d %H:%M:%S")
     if not workflow.state:
         workflow.state = "P"
-    Workflow(**workflow.dict()).create(db)
+    from app.db.models.workflow import Workflow as WorkflowModel
+    WorkflowModel(**workflow.dict()).create(db)
     return schemas.Response(success=True, message="创建工作流成功")
 
 
@@ -60,47 +65,97 @@ def list_actions(_: schemas.TokenPayload = Depends(get_current_active_user)) ->
     return WorkFlowManager().list_actions()
 
 
-@router.get("/{workflow_id}", summary="工作流详情", response_model=schemas.Workflow)
-def get_workflow(workflow_id: int,
-                 db: Session = Depends(get_db),
-                 _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+@router.post("/share", summary="分享工作流", response_model=schemas.Response)
+def workflow_share(
+        workflow: schemas.WorkflowShare,
+        _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
     """
-    获取工作流详情
+    分享工作流
     """
-    return Workflow.get(db, workflow_id)
+    if not workflow.id or not workflow.share_title or not workflow.share_user:
+        return schemas.Response(success=False, message="请填写工作流ID、分享标题和分享人")
+
+    state, errmsg = WorkflowHelper().workflow_share(workflow_id=workflow.id,
+                                                    share_title=workflow.share_title or "",
+                                                    share_comment=workflow.share_comment or "",
+                                                    share_user=workflow.share_user or "")
+    return schemas.Response(success=state, message=errmsg)
 
 
-@router.put("/{workflow_id}", summary="更新工作流", response_model=schemas.Response)
-def update_workflow(workflow: schemas.Workflow,
-                    db: Session = Depends(get_db),
-                    _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+@router.delete("/share/{share_id}", summary="删除分享", response_model=schemas.Response)
+def workflow_share_delete(
+        share_id: int,
+        _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
     """
-    更新工作流
+    删除分享
     """
-    wf = Workflow.get(db, workflow.id)
-    if not wf:
-        return schemas.Response(success=False, message="工作流不存在")
-    wf.update(db, workflow.dict())
-    return schemas.Response(success=True, message="更新成功")
+    state, errmsg = WorkflowHelper().share_delete(share_id=share_id)
+    return schemas.Response(success=state, message=errmsg)
 
 
-@router.delete("/{workflow_id}", summary="删除工作流", response_model=schemas.Response)
-def delete_workflow(workflow_id: int,
-                    db: Session = Depends(get_db),
-                    _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+@router.post("/fork", summary="复用工作流", response_model=schemas.Response)
+def workflow_fork(
+        workflow: schemas.WorkflowShare,
+        db: Session = Depends(get_db),
+        _: schemas.User = Depends(get_current_active_user)) -> Any:
     """
-    删除工作流
+    复用工作流
     """
-    workflow = Workflow.get(db, workflow_id)
-    if not workflow:
-        return schemas.Response(success=False, message="工作流不存在")
-    # 删除定时任务
-    Scheduler().remove_workflow_job(workflow)
-    # 删除工作流
-    Workflow.delete(db, workflow_id)
-    # 删除缓存
-    SystemConfigOper().delete(f"WorkflowCache-{workflow_id}")
-    return schemas.Response(success=True, message="删除成功")
+    if not workflow.name:
+        return schemas.Response(success=False, message="工作流名称不能为空")
+
+    # 解析JSON数据，添加错误处理
+    try:
+        actions = json.loads(workflow.actions or "[]")
+    except json.JSONDecodeError:
+        return schemas.Response(success=False, message="actions字段JSON格式错误")
+
+    try:
+        flows = json.loads(workflow.flows or "[]")
+    except json.JSONDecodeError:
+        return schemas.Response(success=False, message="flows字段JSON格式错误")
+
+    try:
+        context = json.loads(workflow.context or "{}")
+    except json.JSONDecodeError:
+        return schemas.Response(success=False, message="context字段JSON格式错误")
+
+    # 创建工作流
+    workflow_dict = {
+        "name": workflow.name,
+        "description": workflow.description,
+        "timer": workflow.timer,
+        "actions": actions,
+        "flows": flows,
+        "context": context,
+        "state": "P"  # 默认暂停状态
+    }
+
+    # 检查名称是否重复
+    if Workflow.get_by_name(db, workflow_dict["name"]):
+        return schemas.Response(success=False, message="已存在相同名称的工作流")
+
+    # 创建新工作流
+    workflow = Workflow(**workflow_dict)
+    workflow.create(db)
+
+    # 更新复用次数
+    if workflow.id:
+        WorkflowHelper().workflow_fork(share_id=workflow.id)
+
+    return schemas.Response(success=True, message="复用成功")
+
+
+@router.get("/shares", summary="查询分享的工作流", response_model=List[schemas.WorkflowShare])
+def workflow_shares(
+        name: Optional[str] = None,
+        page: Optional[int] = 1,
+        count: Optional[int] = 30,
+        _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    查询分享的工作流
+    """
+    return WorkflowHelper().get_shares(name=name, page=page, count=count)
 
 
 @router.post("/{workflow_id}/run", summary="执行工作流", response_model=schemas.Response)
@@ -123,7 +178,8 @@ def start_workflow(workflow_id: int,
     """
     启用工作流
     """
-    workflow = Workflow.get(db, workflow_id)
+    from app.db.workflow_oper import WorkflowOper
+    workflow = WorkflowOper(db).get(workflow_id)
     if not workflow:
         return schemas.Response(success=False, message="工作流不存在")
     # 添加定时任务
@@ -140,7 +196,8 @@ def pause_workflow(workflow_id: int,
     """
     停用工作流
     """
-    workflow = Workflow.get(db, workflow_id)
+    from app.db.workflow_oper import WorkflowOper
+    workflow = WorkflowOper(db).get(workflow_id)
     if not workflow:
         return schemas.Response(success=False, message="工作流不存在")
     # 删除定时任务
@@ -159,7 +216,8 @@ def reset_workflow(workflow_id: int,
     """
     重置工作流
     """
-    workflow = Workflow.get(db, workflow_id)
+    from app.db.workflow_oper import WorkflowOper
+    workflow = WorkflowOper(db).get(workflow_id)
     if not workflow:
         return schemas.Response(success=False, message="工作流不存在")
     # 停止工作流
@@ -169,3 +227,52 @@ def reset_workflow(workflow_id: int,
     # 删除缓存
     SystemConfigOper().delete(f"WorkflowCache-{workflow_id}")
     return schemas.Response(success=True)
+
+
+@router.get("/{workflow_id}", summary="工作流详情", response_model=schemas.Workflow)
+def get_workflow(workflow_id: int,
+                 db: Session = Depends(get_db),
+                 _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    获取工作流详情
+    """
+    from app.db.workflow_oper import WorkflowOper
+    return WorkflowOper(db).get(workflow_id)
+
+
+@router.put("/{workflow_id}", summary="更新工作流", response_model=schemas.Response)
+def update_workflow(workflow: schemas.Workflow,
+                    db: Session = Depends(get_db),
+                    _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    更新工作流
+    """
+    from app.db.workflow_oper import WorkflowOper
+    if not workflow.id:
+        return schemas.Response(success=False, message="工作流ID不能为空")
+    wf = WorkflowOper(db).get(workflow.id)
+    if not wf:
+        return schemas.Response(success=False, message="工作流不存在")
+    wf.update(db, workflow.dict())
+    return schemas.Response(success=True, message="更新成功")
+
+
+@router.delete("/{workflow_id}", summary="删除工作流", response_model=schemas.Response)
+def delete_workflow(workflow_id: int,
+                    db: Session = Depends(get_db),
+                    _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    删除工作流
+    """
+    from app.db.workflow_oper import WorkflowOper
+    workflow = WorkflowOper(db).get(workflow_id)
+    if not workflow:
+        return schemas.Response(success=False, message="工作流不存在")
+    # 删除定时任务
+    Scheduler().remove_workflow_job(workflow)
+    # 删除工作流
+    from app.db.models.workflow import Workflow as WorkflowModel
+    WorkflowModel.delete(db, workflow_id)
+    # 删除缓存
+    SystemConfigOper().delete(f"WorkflowCache-{workflow_id}")
+    return schemas.Response(success=True, message="删除成功")

app/chain/__init__.py

@@ -1,5 +1,4 @@
 import copy
-import gc
 import pickle
 import traceback
 from abc import ABCMeta
@@ -23,7 +22,7 @@ from app.helper.service import ServiceConfigHelper
 from app.log import logger
 from app.schemas import TransferInfo, TransferTorrent, ExistMediaInfo, DownloadingTorrent, CommingMessage, Notification, \
     WebhookEventInfo, TmdbEpisode, MediaPerson, FileItem, TransferDirectoryConf
-from app.schemas.types import TorrentStatus, MediaType, MediaImageType, EventType
+from app.schemas.types import TorrentStatus, MediaType, MediaImageType, EventType, MessageChannel
 from app.utils.object import ObjectUtils
 
 
@@ -69,10 +68,6 @@ class ChainBase(metaclass=ABCMeta):
                 pickle.dump(cache, f)  # noqa
         except Exception as err:
             logger.error(f"保存缓存 {filename} 出错：{str(err)}")
-        finally:
-            # 主动资源回收
-            del cache
-            gc.collect()
 
     @staticmethod
     def remove_cache(filename: str) -> None:
@@ -99,9 +94,8 @@ class ChainBase(metaclass=ABCMeta):
                 return ret is None
 
         result = None
-        plugin_modules = self.pluginmanager.get_plugin_modules()
         # 插件模块
-        for plugin, module_dict in plugin_modules.items():
+        for plugin, module_dict in self.pluginmanager.get_plugin_modules().items():
             plugin_id, plugin_name = plugin
             if method in module_dict:
                 func = module_dict[method]
@@ -143,10 +137,7 @@ class ChainBase(metaclass=ABCMeta):
 
         # 系统模块
         logger.debug(f"请求系统模块执行：{method} ...")
-        modules = self.modulemanager.get_running_modules(method)
-        # 按优先级排序
-        modules = sorted(modules, key=lambda x: x.get_priority())
-        for module in modules:
+        for module in sorted(self.modulemanager.get_running_modules(method), key=lambda x: x.get_priority()):
             module_id = module.__class__.__name__
             try:
                 module_name = module.get_name()
@@ -617,7 +608,8 @@ class ChainBase(metaclass=ABCMeta):
         # 发送消息事件
         self.eventmanager.send_event(etype=EventType.NoticeMessage, data={**message.dict(), "type": message.mtype})
         # 按原消息发送
-        self.messagequeue.send_message("post_message", message=message)
+        self.messagequeue.send_message("post_message", message=message,
+                                       immediately=True if message.userid else False)
 
     def post_medias_message(self, message: Notification, medias: List[MediaInfo]) -> None:
         """
@@ -629,7 +621,8 @@ class ChainBase(metaclass=ABCMeta):
         note_list = [media.to_dict() for media in medias]
         self.messagehelper.put(message, role="user", note=note_list, title=message.title)
         self.messageoper.add(**message.dict(), note=note_list)
-        return self.messagequeue.send_message("post_medias_message", message=message, medias=medias)
+        return self.messagequeue.send_message("post_medias_message", message=message, medias=medias,
+                                              immediately=True if message.userid else False)
 
     def post_torrents_message(self, message: Notification, torrents: List[Context]) -> None:
         """
@@ -641,7 +634,21 @@ class ChainBase(metaclass=ABCMeta):
         note_list = [torrent.torrent_info.to_dict() for torrent in torrents]
         self.messagehelper.put(message, role="user", note=note_list, title=message.title)
         self.messageoper.add(**message.dict(), note=note_list)
-        return self.messagequeue.send_message("post_torrents_message", message=message, torrents=torrents)
+        return self.messagequeue.send_message("post_torrents_message", message=message, torrents=torrents,
+                                              immediately=True if message.userid else False)
+
+    def delete_message(self, channel: MessageChannel, source: str,
+                       message_id: Union[str, int], chat_id: Optional[Union[str, int]] = None) -> bool:
+        """
+        删除消息
+        :param channel: 消息渠道
+        :param source: 消息源（指定特定的消息模块）
+        :param message_id: 消息ID
+        :param chat_id: 聊天ID（如群组ID）
+        :return: 删除是否成功
+        """
+        return self.run_module("delete_message", channel=channel, source=source,
+                               message_id=message_id, chat_id=chat_id)
 
     def metadata_img(self, mediainfo: MediaInfo,
                      season: Optional[int] = None, episode: Optional[int] = None) -> Optional[dict]:

app/chain/download.py

@@ -188,6 +188,9 @@ class DownloadChain(ChainBase):
                     f"Resource download canceled by event: {event_data.source},"
                     f"Reason: {event_data.reason}")
                 return None
+            # 如果事件修改了下载路径，使用新路径
+            if event_data.options and event_data.options.get("save_path"):
+                save_path = event_data.options.get("save_path")
 
         # 补充完整的media数据
         if not _media.genre_ids:
@@ -324,10 +327,12 @@ class DownloadChain(ChainBase):
             self.post_message(
                 Notification(
                     channel=channel,
+                    source=source if channel else None,
                     mtype=NotificationType.Download,
                     ctype=ContentType.DownloadAdded,
                     image=_media.get_message_image(),
                     link=settings.MP_DOMAIN('/#/downloading'),
+                    userid=userid,
                     username=username
                 ),
                 meta=_meta,
@@ -445,19 +450,6 @@ class DownloadChain(ChainBase):
                 return 9999
             return no_exist[season].total_episode
 
-        def _calculate_intersection_ratio(episodes_set: set, target_set: set) -> Tuple[float, set]:
-            """
-            计算种子与目标缺失集之间的交集比例。
-            :param episodes_set (Set[int]): 当前种子的集数集合。
-            :param target_set (Set[int]): 当前季缺失的集数集合。
-            :return: Tuple[float, Set[int]]: - 交集比例（0~1）- 交集集合（Set[int]）
-            """
-            cal_intersection = episodes_set & target_set
-            if not cal_intersection:
-                return 0.0, set()
-            cal_ratio = len(cal_intersection) / len(episodes_set)
-            return cal_ratio, cal_intersection
-
         # 发送资源选择事件，允许外部修改上下文数据
         logger.debug(f"Initial contexts: {len(contexts)} items, Downloader: {downloader}")
         event_data = ResourceSelectionEventData(
@@ -616,8 +608,6 @@ class DownloadChain(ChainBase):
                     # 缺失整季的转化为缺失集进行比较
                     if not need_episodes:
                         need_episodes = list(range(start_episode, total_episode + 1))
-                    # 计算每个种子的集数与缺失集数的交集比例 shaw
-                    torrent_ratios = []
                     # 循环种子
                     for context in contexts:
                         if global_vars.is_system_stopped:
@@ -644,54 +634,24 @@ class DownloadChain(ChainBase):
                             # 整季的不处理
                             if not torrent_episodes:
                                 continue
-                            # 计算交集
-                            # 若种子[5-10],[7-10],[9-10]  need_episodes=[9,10,11,12,13,14]
-                            # 计算后的交集比例( len(torrent_episodes ∩ need_episodes) / len(torrent_episodes)  )分别  0.33 0.66  1.0
-                            ratio, intersection = _calculate_intersection_ratio(torrent_episodes, set(need_episodes))
-                            if ratio <= (settings.EPISODE_INTERSECTION_MIN_CONFIDENCE or 0.05):
-                                # 可以设定阈值
-                                logger.info(
-                                    f"{context.meta_info.title} 与当前缺失集数交集比例过低：{ratio:.2%}，跳过")
-                                continue
-
-                            # 收集候选种子
-                            torrent_ratios.append((context, ratio, len(intersection)))
-                    if not torrent_ratios:
-                        continue
-                    # 按交集比例排序
-                    torrent_ratios.sort(key=lambda x: (x[1], x[2]), reverse=True)
-                    # 按排序后的顺序下载
-                    for context, _, _ in torrent_ratios:
-                        if global_vars.is_system_stopped:
-                            break
-                        # 重新计算与当前need_episodes的交集比例
-                        current_episodes = set(context.meta_info.episode_list)
-                        current_ratio, current_intersection = _calculate_intersection_ratio(current_episodes,
-                                                                                            set(need_episodes))
-                        if current_ratio <= (settings.EPISODE_INTERSECTION_MIN_CONFIDENCE or 0.05):
-                            # 可以设定阈值
-                            logger.info(
-                                f"{context.meta_info.title} 与当前缺失集数交集比例过低：{current_ratio:.2%}，跳过")
-                            continue
-                        # 下载
-                        logger.info(f"开始下载 {context.meta_info.title} ...")
-                        download_id = self.download_single(context, save_path=save_path,
-                                                           channel=channel, source=source,
-                                                           userid=userid, username=username,
-                                                           downloader=downloader)
-                        if download_id:
-                            # 下载成功
-                            logger.info(f"{context.meta_info.title} 添加下载成功")
-                            downloaded_list.append(context)
-                            # 更新仍需集数
-                            need_episodes = __update_episodes(_mid=need_mid,
-                                                              _need=need_episodes,
-                                                              _sea=need_season,
-                                                              _current=current_intersection)
-                            logger.info(f"季 {need_season} 剩余需要集：{need_episodes}")
-                            # 如果已经没有需要下载的集数，跳出当前循环
-                            if not need_episodes:
-                                break
+                            # 为需要集的子集则下载
+                            if torrent_episodes.issubset(set(need_episodes)):
+                                # 下载
+                                logger.info(f"开始下载 {meta.title} ...")
+                                download_id = self.download_single(context, save_path=save_path,
+                                                                   channel=channel, source=source,
+                                                                   userid=userid, username=username,
+                                                                   downloader=downloader)
+                                if download_id:
+                                    # 下载成功
+                                    logger.info(f"{meta.title} 添加下载成功")
+                                    downloaded_list.append(context)
+                                    # 更新仍需集数
+                                    need_episodes = __update_episodes(_mid=need_mid,
+                                                                      _need=need_episodes,
+                                                                      _sea=need_season,
+                                                                      _current=torrent_episodes)
+                                    logger.info(f"季 {need_season} 剩余需要集：{need_episodes}")
 
         # 仍然缺失的剧集，从整季中选择需要的集数文件下载，仅支持QB和TR
         if no_exists:
@@ -841,7 +801,6 @@ class DownloadChain(ChainBase):
             totals = {}
 
         mediaserver = MediaServerOper()
-
         if mediainfo.type == MediaType.MOVIE:
             # 电影
             itemid = mediaserver.get_item_id(mtype=mediainfo.type.value,
@@ -985,21 +944,21 @@ class DownloadChain(ChainBase):
             ret_torrents.append(torrent)
         return ret_torrents
 
-    def set_downloading(self, hash_str, oper: str) -> bool:
+    def set_downloading(self, hash_str, oper: str, name: Optional[str] = None) -> bool:
         """
         控制下载任务 start/stop
         """
         if oper == "start":
-            return self.start_torrents(hashs=[hash_str])
+            return self.start_torrents(hashs=[hash_str], downloader=name)
         elif oper == "stop":
-            return self.stop_torrents(hashs=[hash_str])
+            return self.stop_torrents(hashs=[hash_str], downloader=name)
         return False
 
-    def remove_downloading(self, hash_str: str) -> bool:
+    def remove_downloading(self, hash_str: str, name: Optional[str] = None) -> bool:
         """
         删除下载任务
         """
-        return self.remove_torrents(hashs=[hash_str])
+        return self.remove_torrents(hashs=[hash_str], downloader=name)
 
     @eventmanager.register(EventType.DownloadFileDeleted)
     def download_file_deleted(self, event: Event):

app/chain/media.py

@@ -10,15 +10,15 @@ from app.core.context import Context, MediaInfo
 from app.core.event import eventmanager, Event
 from app.core.meta import MetaBase
 from app.core.metainfo import MetaInfo, MetaInfoPath
+from app.db.systemconfig_oper import SystemConfigOper
 from app.log import logger
 from app.schemas import FileItem
-from app.schemas.types import EventType, MediaType, ChainEventType
+from app.schemas.types import EventType, MediaType, ChainEventType, SystemConfigKey
 from app.utils.http import RequestUtils
 from app.utils.string import StringUtils
 
 recognize_lock = Lock()
 scraping_lock = Lock()
-scraping_files = []
 
 
 class MediaChain(ChainBase):
@@ -26,6 +26,49 @@ class MediaChain(ChainBase):
     媒体信息处理链，单例运行
     """
 
+    @staticmethod
+    def _get_scraping_switchs() -> dict:
+        """
+        获取刮削开关配置
+        """
+        switchs = SystemConfigOper().get(SystemConfigKey.ScrapingSwitchs) or {}
+        # 默认配置
+        default_switchs = {
+            'movie_nfo': True,  # 电影NFO
+            'movie_poster': True,  # 电影海报
+            'movie_backdrop': True,  # 电影背景图
+            'movie_logo': True,  # 电影Logo
+            'movie_disc': True,  # 电影光盘图
+            'movie_banner': True,  # 电影横幅图
+            'movie_thumb': True,  # 电影缩略图
+            'tv_nfo': True,  # 电视剧NFO
+            'tv_poster': True,  # 电视剧海报
+            'tv_backdrop': True,  # 电视剧背景图
+            'tv_banner': True,  # 电视剧横幅图
+            'tv_logo': True,  # 电视剧Logo
+            'tv_thumb': True,  # 电视剧缩略图
+            'season_nfo': True,  # 季NFO
+            'season_poster': True,  # 季海报
+            'season_banner': True,  # 季横幅图
+            'season_thumb': True,  # 季缩略图
+            'episode_nfo': True,  # 集NFO
+            'episode_thumb': True  # 集缩略图
+        }
+        # 合并用户配置和默认配置
+        for key, default_value in default_switchs.items():
+            if key not in switchs:
+                switchs[key] = default_value
+        return switchs
+
+    @staticmethod
+    def set_scraping_switchs(switchs: dict) -> bool:
+        """
+        设置刮削开关配置
+        :param switchs: 开关配置字典
+        :return: 是否设置成功
+        """
+        return SystemConfigOper().set(SystemConfigKey.ScrapingSwitchs, switchs)
+
     def metadata_nfo(self, meta: MetaBase, mediainfo: MediaInfo,
                      season: Optional[int] = None, episode: Optional[int] = None) -> Optional[str]:
         """
@@ -300,23 +343,49 @@ class MediaChain(ChainBase):
             return
         event_data = event.event_data or {}
         fileitem: FileItem = event_data.get("fileitem")
+        file_list: List[str] = event_data.get("file_list", [])
         meta: MetaBase = event_data.get("meta")
         mediainfo: MediaInfo = event_data.get("mediainfo")
         overwrite = event_data.get("overwrite", False)
         if not fileitem:
             return
+
         # 刮削锁
         with scraping_lock:
-            if fileitem.path in scraping_files:
+            # 检查文件项是否存在
+            storagechain = StorageChain()
+            if not storagechain.get_item(fileitem):
+                logger.warn(f"文件项不存在：{fileitem.path}")
                 return
-            scraping_files.append(fileitem.path)
-        try:
-            # 执行刮削
-            self.scrape_metadata(fileitem=fileitem, meta=meta, mediainfo=mediainfo, overwrite=overwrite)
-        finally:
-            # 释放锁
-            with scraping_lock:
-                scraping_files.remove(fileitem.path)
+            # 检查是否为目录
+            if fileitem.type == "file":
+                # 单个文件刮削
+                self.scrape_metadata(fileitem=fileitem,
+                                     mediainfo=mediainfo,
+                                     init_folder=False,
+                                     parent=storagechain.get_parent_item(fileitem),
+                                     overwrite=overwrite)
+            else:
+                # 检查目的目录下是否已经有nfo刮削文件
+                has_nfo_file = storagechain.any_files(fileitem, extensions=['.nfo'])
+                if has_nfo_file and file_list:
+                    logger.info(f"目录 {fileitem.path} 已有NFO文件，开始增量刮削...")
+                    for file_path in file_list:
+                        file_item = storagechain.get_file_item(storage=fileitem.storage,
+                                                               path=Path(file_path))
+                        if file_item:
+                            # 对于电视剧文件，应该保存到与视频文件相同的目录
+                            # 而不是电视剧根目录
+                            self.scrape_metadata(fileitem=file_item,
+                                                 mediainfo=mediainfo,
+                                                 init_folder=False,
+                                                 parent=None,  # 让函数内部自动获取正确的父目录
+                                                 overwrite=overwrite)
+                else:
+                    # 执行全量刮削
+                    logger.info(f"开始全量刮削目录 {fileitem.path} ...")
+                    self.scrape_metadata(fileitem=fileitem, meta=meta, init_folder=True,
+                                         mediainfo=mediainfo, overwrite=overwrite)
 
     def scrape_metadata(self, fileitem: schemas.FileItem,
                         meta: MetaBase = None, mediainfo: MediaInfo = None,
@@ -363,8 +432,10 @@ class MediaChain(ChainBase):
             """
             if not _fileitem or not _content or not _path:
                 return
-            # 保存文件到临时目录，文件名随机
-            tmp_file = settings.TEMP_PATH / f"{_path.name}.{StringUtils.generate_random_str(10)}"
+            # 保存文件到临时目录
+            tmp_dir = settings.TEMP_PATH / StringUtils.generate_random_str(10)
+            tmp_dir.mkdir(parents=True, exist_ok=True)
+            tmp_file = tmp_dir / _path.name
             tmp_file.write_bytes(_content)
             # 获取文件的父目录
             try:
@@ -383,7 +454,7 @@ class MediaChain(ChainBase):
             """
             try:
                 logger.info(f"正在下载图片：{_url} ...")
-                r = RequestUtils(proxies=settings.PROXY).get_res(url=_url)
+                r = RequestUtils(proxies=settings.PROXY, ua=settings.NORMAL_USER_AGENT).get_res(url=_url)
                 if r:
                     return r.content
                 else:
@@ -392,6 +463,9 @@ class MediaChain(ChainBase):
                 logger.error(f"{_url} 图片下载失败：{str(err)}！")
             return None
 
+        if not fileitem:
+            return
+
         # 当前文件路径
         filepath = Path(fileitem.path)
         if fileitem.type == "file" \
@@ -404,44 +478,57 @@ class MediaChain(ChainBase):
         if not mediainfo:
             logger.warn(f"{filepath} 无法识别文件媒体信息！")
             return
+
+        # 获取刮削开关配置
+        scraping_switchs = self._get_scraping_switchs()
         logger.info(f"开始刮削：{filepath} ...")
         if mediainfo.type == MediaType.MOVIE:
             # 电影
             if fileitem.type == "file":
-                # 是否已存在
-                nfo_path = filepath.with_suffix(".nfo")
-                if overwrite or not storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
-                    # 电影文件
-                    movie_nfo = self.metadata_nfo(meta=meta, mediainfo=mediainfo)
-                    if movie_nfo:
-                        # 保存或上传nfo文件到上级目录
-                        __save_file(_fileitem=parent, _path=nfo_path, _content=movie_nfo)
-                    else:
-                        logger.warn(f"{filepath.name} nfo文件生成失败！")
-                else:
-                    logger.info(f"已存在nfo文件：{nfo_path}")
-            else:
-                # 电影目录
-                if is_bluray_folder(fileitem):
-                    # 原盘目录
-                    nfo_path = filepath / (filepath.name + ".nfo")
+                # 检查电影NFO开关
+                if scraping_switchs.get('movie_nfo', True):
+                    # 是否已存在
+                    nfo_path = filepath.with_suffix(".nfo")
                     if overwrite or not storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
-                        # 生成原盘nfo
+                        # 电影文件
                         movie_nfo = self.metadata_nfo(meta=meta, mediainfo=mediainfo)
                         if movie_nfo:
-                            # 保存或上传nfo文件到当前目录
-                            __save_file(_fileitem=fileitem, _path=nfo_path, _content=movie_nfo)
+                            # 保存或上传nfo文件到上级目录
+                            if not parent:
+                                parent = storagechain.get_parent_item(fileitem)
+                            __save_file(_fileitem=parent, _path=nfo_path, _content=movie_nfo)
                         else:
                             logger.warn(f"{filepath.name} nfo文件生成失败！")
                     else:
                         logger.info(f"已存在nfo文件：{nfo_path}")
+                else:
+                    logger.info("电影NFO刮削已关闭，跳过")
+            else:
+                # 电影目录
+                if is_bluray_folder(fileitem):
+                    # 原盘目录
+                    if scraping_switchs.get('movie_nfo', True):
+                        nfo_path = filepath / (filepath.name + ".nfo")
+                        if overwrite or not storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
+                            # 生成原盘nfo
+                            movie_nfo = self.metadata_nfo(meta=meta, mediainfo=mediainfo)
+                            if movie_nfo:
+                                # 保存或上传nfo文件到当前目录
+                                __save_file(_fileitem=fileitem, _path=nfo_path, _content=movie_nfo)
+                            else:
+                                logger.warn(f"{filepath.name} nfo文件生成失败！")
+                        else:
+                            logger.info(f"已存在nfo文件：{nfo_path}")
+                    else:
+                        logger.info("电影NFO刮削已关闭，跳过")
                 else:
                     # 处理目录内的文件
                     files = __list_files(_fileitem=fileitem)
                     for file in files:
                         self.scrape_metadata(fileitem=file,
-                                             meta=meta, mediainfo=mediainfo,
-                                             init_folder=False, parent=fileitem,
+                                             mediainfo=mediainfo,
+                                             init_folder=False,
+                                             parent=fileitem,
                                              overwrite=overwrite)
                 # 生成目录内图片文件
                 if init_folder:
@@ -449,16 +536,37 @@ class MediaChain(ChainBase):
                     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 storagechain.get_file_item(storage=fileitem.storage,
-                                                                           path=image_path):
-                                # 下载图片
-                                content = __download_image(image_url)
-                                # 写入图片到当前目录
-                                if content:
-                                    __save_file(_fileitem=fileitem, _path=image_path, _content=content)
+                            # 根据图片类型检查开关
+                            if 'poster' in image_name.lower():
+                                should_scrape = scraping_switchs.get('movie_poster', True)
+                            elif ('backdrop' in image_name.lower()
+                                  or 'fanart' in image_name.lower()
+                                  or 'background' in image_name.lower()):
+                                should_scrape = scraping_switchs.get('movie_backdrop', True)
+                            elif 'logo' in image_name.lower():
+                                should_scrape = scraping_switchs.get('movie_logo', True)
+                            elif 'disc' in image_name.lower() or 'cdart' in image_name.lower():
+                                should_scrape = scraping_switchs.get('movie_disc', True)
+                            elif 'banner' in image_name.lower():
+                                should_scrape = scraping_switchs.get('movie_banner', True)
+                            elif 'thumb' in image_name.lower():
+                                should_scrape = scraping_switchs.get('movie_thumb', True)
+                            else:
+                                should_scrape = True  # 未知类型默认刮削
+
+                            if should_scrape:
+                                image_path = filepath.with_name(image_name)
+                                if overwrite or not storagechain.get_file_item(storage=fileitem.storage,
+                                                                               path=image_path):
+                                    # 下载图片
+                                    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_name}")
         else:
             # 电视剧
             if fileitem.type == "file":
@@ -472,44 +580,51 @@ class MediaChain(ChainBase):
                 if not file_mediainfo:
                     logger.warn(f"{filepath.name} 无法识别文件媒体信息！")
                     return
-                # 是否已存在
-                nfo_path = filepath.with_suffix(".nfo")
-                if overwrite or not storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
-                    # 获取集的nfo文件
-                    episode_nfo = self.metadata_nfo(meta=file_meta, mediainfo=file_mediainfo,
-                                                    season=file_meta.begin_season,
-                                                    episode=file_meta.begin_episode)
-                    if episode_nfo:
-                        # 保存或上传nfo文件到上级目录
-                        if not parent:
-                            parent = storagechain.get_parent_item(fileitem)
-                        __save_file(_fileitem=parent, _path=nfo_path, _content=episode_nfo)
-                    else:
-                        logger.warn(f"{filepath.name} nfo文件生成失败！")
-                else:
-                    logger.info(f"已存在nfo文件：{nfo_path}")
-                # 获取集的图片
-                image_dict = self.metadata_img(mediainfo=file_mediainfo,
-                                               season=file_meta.begin_season, episode=file_meta.begin_episode)
-                if image_dict:
-                    for episode, image_url in image_dict.items():
-                        image_path = filepath.with_suffix(Path(image_url).suffix)
-                        if overwrite or not storagechain.get_file_item(storage=fileitem.storage, path=image_path):
-                            # 下载图片
-                            content = __download_image(image_url)
-                            # 保存图片文件到当前目录
-                            if content:
-                                if not parent:
-                                    parent = storagechain.get_parent_item(fileitem)
-                                __save_file(_fileitem=parent, _path=image_path, _content=content)
+                # 检查集NFO开关
+                if scraping_switchs.get('episode_nfo', True):
+                    # 是否已存在
+                    nfo_path = filepath.with_suffix(".nfo")
+                    if overwrite or not storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
+                        # 获取集的nfo文件
+                        episode_nfo = self.metadata_nfo(meta=file_meta, mediainfo=file_mediainfo,
+                                                        season=file_meta.begin_season,
+                                                        episode=file_meta.begin_episode)
+                        if episode_nfo:
+                            # 保存或上传nfo文件到上级目录
+                            if not parent:
+                                parent = storagechain.get_parent_item(fileitem)
+                            __save_file(_fileitem=parent, _path=nfo_path, _content=episode_nfo)
                         else:
-                            logger.info(f"已存在图片文件：{image_path}")
+                            logger.warn(f"{filepath.name} nfo文件生成失败！")
+                    else:
+                        logger.info(f"已存在nfo文件：{nfo_path}")
+                else:
+                    logger.info("集NFO刮削已关闭，跳过")
+                # 获取集的图片
+                if scraping_switchs.get('episode_thumb', True):
+                    image_dict = self.metadata_img(mediainfo=file_mediainfo,
+                                                   season=file_meta.begin_season, episode=file_meta.begin_episode)
+                    if image_dict:
+                        for episode, image_url in image_dict.items():
+                            image_path = filepath.with_suffix(Path(image_url).suffix)
+                            if overwrite or not storagechain.get_file_item(storage=fileitem.storage, path=image_path):
+                                # 下载图片
+                                content = __download_image(image_url)
+                                # 保存图片文件到当前目录
+                                if content:
+                                    if not parent:
+                                        parent = storagechain.get_parent_item(fileitem)
+                                    __save_file(_fileitem=parent, _path=image_path, _content=content)
+                            else:
+                                logger.info(f"已存在图片文件：{image_path}")
+                else:
+                    logger.info("集缩略图刮削已关闭，跳过")
             else:
-                # 当前为目录，处理目录内的文件
+                # 当前为电视剧目录，处理目录内的文件
                 files = __list_files(_fileitem=fileitem)
                 for file in files:
                     self.scrape_metadata(fileitem=file,
-                                         meta=meta, mediainfo=mediainfo,
+                                         mediainfo=mediainfo,
                                          parent=fileitem if file.type == "file" else None,
                                          init_folder=True if file.type == "dir" else False,
                                          overwrite=overwrite)
@@ -521,71 +636,96 @@ class MediaChain(ChainBase):
                     if filepath.name in settings.RENAME_FORMAT_S0_NAMES:
                         season_meta.begin_season = 0
                     if season_meta.begin_season is not None:
-                        # 是否已存在
-                        nfo_path = filepath / "season.nfo"
-                        if overwrite or not storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
-                            # 当前目录有季号，生成季nfo
-                            season_nfo = self.metadata_nfo(meta=meta, mediainfo=mediainfo,
-                                                           season=season_meta.begin_season)
-                            if season_nfo:
-                                # 写入nfo到根目录
-                                __save_file(_fileitem=fileitem, _path=nfo_path, _content=season_nfo)
-                            else:
-                                logger.warn(f"无法生成电视剧季nfo文件：{meta.name}")
-                        else:
-                            logger.info(f"已存在nfo文件：{nfo_path}")
-                        # TMDB季poster图片
-                        image_dict = self.metadata_img(mediainfo=mediainfo, season=season_meta.begin_season)
-                        if image_dict:
-                            for image_name, image_url in image_dict.items():
-                                image_path = filepath.with_name(image_name)
-                                if overwrite or not storagechain.get_file_item(storage=fileitem.storage,
-                                                                               path=image_path):
-                                    # 下载图片
-                                    content = __download_image(image_url)
-                                    # 保存图片文件到剧集目录
-                                    if content:
-                                        if not parent:
-                                            parent = storagechain.get_parent_item(fileitem)
-                                        __save_file(_fileitem=parent, _path=image_path, _content=content)
+                        # 检查季NFO开关
+                        if scraping_switchs.get('season_nfo', True):
+                            # 是否已存在
+                            nfo_path = filepath / "season.nfo"
+                            if overwrite or not storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
+                                # 当前目录有季号，生成季nfo
+                                season_nfo = self.metadata_nfo(meta=meta, mediainfo=mediainfo,
+                                                               season=season_meta.begin_season)
+                                if season_nfo:
+                                    # 写入nfo到根目录
+                                    __save_file(_fileitem=fileitem, _path=nfo_path, _content=season_nfo)
                                 else:
-                                    logger.info(f"已存在图片文件：{image_path}")
-                        # 额外fanart季图片：poster thumb banner
-                        image_dict = self.metadata_img(mediainfo=mediainfo)
-                        if image_dict:
-                            for image_name, image_url in image_dict.items():
-                                if image_name.startswith("season"):
+                                    logger.warn(f"无法生成电视剧季nfo文件：{meta.name}")
+                            else:
+                                logger.info(f"已存在nfo文件：{nfo_path}")
+                        else:
+                            logger.info("季NFO刮削已关闭，跳过")
+                        # TMDB季poster图片
+                        if scraping_switchs.get('season_poster', True):
+                            image_dict = self.metadata_img(mediainfo=mediainfo, season=season_meta.begin_season)
+                            if image_dict:
+                                for image_name, image_url in image_dict.items():
                                     image_path = filepath.with_name(image_name)
-                                    # 只下载当前刮削季的图片
-                                    image_season = "00" if "specials" in image_name else image_name[6:8]
-                                    if image_season != str(season_meta.begin_season).rjust(2, '0'):
-                                        logger.info(f"当前刮削季为：{season_meta.begin_season}，跳过文件：{image_path}")
-                                        continue
                                     if overwrite or not storagechain.get_file_item(storage=fileitem.storage,
                                                                                    path=image_path):
                                         # 下载图片
                                         content = __download_image(image_url)
-                                        # 保存图片文件到当前目录
+                                        # 保存图片文件到剧集目录
                                         if content:
                                             if not parent:
                                                 parent = storagechain.get_parent_item(fileitem)
                                             __save_file(_fileitem=parent, _path=image_path, _content=content)
                                     else:
                                         logger.info(f"已存在图片文件：{image_path}")
+                        else:
+                            logger.info("季海报刮削已关闭，跳过")
+                        # 额外fanart季图片：poster thumb banner
+                        image_dict = self.metadata_img(mediainfo=mediainfo)
+                        if image_dict:
+                            for image_name, image_url in image_dict.items():
+                                if image_name.startswith("season"):
+                                    # 根据季图片类型检查开关
+                                    if 'poster' in image_name.lower():
+                                        should_scrape = scraping_switchs.get('season_poster', True)
+                                    elif 'banner' in image_name.lower():
+                                        should_scrape = scraping_switchs.get('season_banner', True)
+                                    elif 'thumb' in image_name.lower():
+                                        should_scrape = scraping_switchs.get('season_thumb', True)
+                                    else:
+                                        should_scrape = True  # 未知类型默认刮削
+
+                                    if should_scrape:
+                                        image_path = filepath.with_name(image_name)
+                                        # 只下载当前刮削季的图片
+                                        image_season = "00" if "specials" in image_name else image_name[6:8]
+                                        if image_season != str(season_meta.begin_season).rjust(2, '0'):
+                                            logger.info(
+                                                f"当前刮削季为：{season_meta.begin_season}，跳过文件：{image_path}")
+                                            continue
+                                        if overwrite or not storagechain.get_file_item(storage=fileitem.storage,
+                                                                                       path=image_path):
+                                            # 下载图片
+                                            content = __download_image(image_url)
+                                            # 保存图片文件到当前目录
+                                            if content:
+                                                if not parent:
+                                                    parent = storagechain.get_parent_item(fileitem)
+                                                __save_file(_fileitem=parent, _path=image_path, _content=content)
+                                        else:
+                                            logger.info(f"已存在图片文件：{image_path}")
+                                    else:
+                                        logger.info(f"季图片刮削已关闭，跳过：{image_name}")
                     # 判断当前目录是不是剧集根目录
                     if not season_meta.season:
-                        # 是否已存在
-                        nfo_path = filepath / "tvshow.nfo"
-                        if overwrite or not storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
-                            # 当前目录有名称，生成tvshow nfo 和 tv图片
-                            tv_nfo = self.metadata_nfo(meta=meta, mediainfo=mediainfo)
-                            if tv_nfo:
-                                # 写入tvshow nfo到根目录
-                                __save_file(_fileitem=fileitem, _path=nfo_path, _content=tv_nfo)
+                        # 检查电视剧NFO开关
+                        if scraping_switchs.get('tv_nfo', True):
+                            # 是否已存在
+                            nfo_path = filepath / "tvshow.nfo"
+                            if overwrite or not storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
+                                # 当前目录有名称，生成tvshow nfo 和 tv图片
+                                tv_nfo = self.metadata_nfo(meta=meta, mediainfo=mediainfo)
+                                if tv_nfo:
+                                    # 写入tvshow nfo到根目录
+                                    __save_file(_fileitem=fileitem, _path=nfo_path, _content=tv_nfo)
+                                else:
+                                    logger.warn(f"无法生成电视剧nfo文件：{meta.name}")
                             else:
-                                logger.warn(f"无法生成电视剧nfo文件：{meta.name}")
+                                logger.info(f"已存在nfo文件：{nfo_path}")
                         else:
-                            logger.info(f"已存在nfo文件：{nfo_path}")
+                            logger.info("电视剧NFO刮削已关闭，跳过")
                         # 生成目录图片
                         image_dict = self.metadata_img(mediainfo=mediainfo)
                         if image_dict:
@@ -593,14 +733,33 @@ class MediaChain(ChainBase):
                                 # 不下载季图片
                                 if image_name.startswith("season"):
                                     continue
-                                image_path = filepath / image_name
-                                if overwrite or not storagechain.get_file_item(storage=fileitem.storage,
-                                                                               path=image_path):
-                                    # 下载图片
-                                    content = __download_image(image_url)
-                                    # 保存图片文件到当前目录
-                                    if content:
-                                        __save_file(_fileitem=fileitem, _path=image_path, _content=content)
+                                # 根据电视剧图片类型检查开关
+                                if 'poster' in image_name.lower():
+                                    should_scrape = scraping_switchs.get('tv_poster', True)
+                                elif ('backdrop' in image_name.lower()
+                                      or 'fanart' in image_name.lower()
+                                      or 'background' in image_name.lower()):
+                                    should_scrape = scraping_switchs.get('tv_backdrop', True)
+                                elif 'banner' in image_name.lower():
+                                    should_scrape = scraping_switchs.get('tv_banner', True)
+                                elif 'logo' in image_name.lower():
+                                    should_scrape = scraping_switchs.get('tv_logo', True)
+                                elif 'thumb' in image_name.lower():
+                                    should_scrape = scraping_switchs.get('tv_thumb', True)
                                 else:
-                                    logger.info(f"已存在图片文件：{image_path}")
+                                    should_scrape = True  # 未知类型默认刮削
+
+                                if should_scrape:
+                                    image_path = filepath / image_name
+                                    if overwrite or not storagechain.get_file_item(storage=fileitem.storage,
+                                                                                   path=image_path):
+                                        # 下载图片
+                                        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_name}")
         logger.info(f"{filepath.name} 刮削完成")

app/chain/recommend.py

@@ -130,7 +130,7 @@ class RecommendChain(ChainBase, metaclass=Singleton):
         # 请求远程图片
         referer = "https://movie.douban.com/" if "doubanio.com" in url else None
         proxies = settings.PROXY if not referer else None
-        response = RequestUtils(ua=settings.USER_AGENT, proxies=proxies, referer=referer).get_res(url=url)
+        response = RequestUtils(ua=settings.NORMAL_USER_AGENT, proxies=proxies, referer=referer).get_res(url=url)
         if not response:
             logger.debug(f"Empty response for URL: {url}")
             return

app/chain/search.py

@@ -12,7 +12,6 @@ from app.core.context import MediaInfo, TorrentInfo
 from app.core.event import eventmanager, Event
 from app.core.metainfo import MetaInfo
 from app.db.systemconfig_oper import SystemConfigOper
-from app.helper.memory import memory_optimized
 from app.helper.progress import ProgressHelper
 from app.helper.sites import SitesHelper
 from app.helper.torrent import TorrentHelper
@@ -98,7 +97,6 @@ class SearchChain(ChainBase):
             logger.error(f'加载搜索结果失败：{str(e)} - {traceback.format_exc()}')
             return []
 
-    @memory_optimized(force_gc_after=True, log_memory=True)
     def process(self, mediainfo: MediaInfo,
                 keyword: Optional[str] = None,
                 no_exists: Dict[int, Dict[int, NotExistMediaInfo]] = None,
@@ -204,16 +202,15 @@ class SearchChain(ChainBase):
         # 过滤完成
         progress.update(value=50, text=f'过滤完成，剩余 {len(torrents)} 个资源', key=ProgressKey.Search)
 
-        # 开始匹配
-        _match_torrents = []
         # 总数
         _total = len(torrents)
         # 已处理数
         _count = 0
 
+        # 开始匹配
+        _match_torrents = []
         torrenthelper = TorrentHelper()
-
-        if mediainfo:
+        try:
             # 英文标题应该在别名/原标题中，不需要再匹配
             logger.info(f"开始匹配结果 标题：{mediainfo.title}，原标题：{mediainfo.original_title}，别名：{mediainfo.names}")
             progress.update(value=51, text=f'开始匹配，总 {_total} 个资源 ...', key=ProgressKey.Search)
@@ -258,16 +255,18 @@ class SearchChain(ChainBase):
             progress.update(value=97,
                             text=f'匹配完成，共匹配到 {len(_match_torrents)} 个资源',
                             key=ProgressKey.Search)
-        else:
-            _match_torrents = [(t, MetaInfo(title=t.title, subtitle=t.description)) for t in torrents]
 
-        # 去掉mediainfo中多余的数据
-        mediainfo.clear()
-
-        # 组装上下文
-        contexts = [Context(torrent_info=t[0],
-                            media_info=mediainfo,
-                            meta_info=t[1]) for t in _match_torrents]
+            # 去掉mediainfo中多余的数据
+            mediainfo.clear()
+            # 组装上下文
+            contexts = [Context(torrent_info=t[0],
+                                media_info=mediainfo,
+                                meta_info=t[1]) for t in _match_torrents]
+        finally:
+            torrents.clear()
+            del torrents
+            _match_torrents.clear()
+            del _match_torrents
 
         # 排序
         progress.update(value=99,
@@ -366,6 +365,7 @@ class SearchChain(ChainBase):
         logger.info(f"站点搜索完成，有效资源数：{len(results)}，总耗时 {(end_time - start_time).seconds} 秒")
         # 结束进度
         progress.end(ProgressKey.Search)
+
         # 返回
         return results
 

app/chain/site.py

@@ -1,4 +1,5 @@
 import base64
+import gc
 import re
 from datetime import datetime
 from typing import Optional, Tuple, Union, Dict
@@ -92,10 +93,9 @@ class SiteChain(ChainBase):
         """
         刷新所有站点的用户数据
         """
-        sites = SitesHelper().get_indexers()
         any_site_updated = False
         result = {}
-        for site in sites:
+        for site in SitesHelper().get_indexers():
             if global_vars.is_system_stopped:
                 return None
             if site.get("is_active"):
@@ -107,6 +107,11 @@ class SiteChain(ChainBase):
             EventManager().send_event(EventType.SiteRefreshed, {
                 "site_id": "*"
             })
+
+        # 如果不是大内存模式，进行垃圾回收
+        if not settings.BIG_MEMORY_MODE:
+            gc.collect()
+
         return result
 
     def is_special_site(self, domain: str) -> bool:
@@ -266,16 +271,20 @@ class SiteChain(ChainBase):
             logger.error(f"获取站点页面失败：{url}")
             return favicon_url, None
         html = etree.HTML(html_text)
-        if StringUtils.is_valid_html_element(html):
-            fav_link = html.xpath('//head/link[contains(@rel, "icon")]/@href')
-            if fav_link:
-                favicon_url = urljoin(url, fav_link[0])
+        try:
+            if StringUtils.is_valid_html_element(html):
+                fav_link = html.xpath('//head/link[contains(@rel, "icon")]/@href')
+                if fav_link:
+                    favicon_url = urljoin(url, fav_link[0])
 
-        res = RequestUtils(cookies=cookie, timeout=15, ua=ua).get_res(url=favicon_url)
-        if res:
-            return favicon_url, base64.b64encode(res.content).decode()
-        else:
-            logger.error(f"获取站点图标失败：{favicon_url}")
+            res = RequestUtils(cookies=cookie, timeout=15, ua=ua).get_res(url=favicon_url)
+            if res:
+                return favicon_url, base64.b64encode(res.content).decode()
+            else:
+                logger.error(f"获取站点图标失败：{favicon_url}")
+        finally:
+            if html is not None:
+                del html
         return favicon_url, None
 
     def sync_cookies(self, manual=False) -> Tuple[bool, str]:
@@ -351,9 +360,10 @@ class SiteChain(ChainBase):
                                    ua=settings.USER_AGENT
                                    ).get_res(url=domain_url)
                 if res and res.status_code in [200, 500, 403]:
-                    if not indexer.get("public") and not SiteUtils.is_logged_in(res.text):
+                    content = res.text
+                    if not indexer.get("public") and not SiteUtils.is_logged_in(content):
                         _fail_count += 1
-                        if under_challenge(res.text):
+                        if under_challenge(content):
                             logger.warn(f"站点 {indexer.get('name')} 被Cloudflare防护，无法登录，无法添加站点")
                             continue
                         logger.warn(
@@ -571,8 +581,9 @@ class SiteChain(ChainBase):
                                ).get_res(url=site_url)
             # 判断登录状态
             if res and res.status_code in [200, 500, 403]:
-                if not public and not SiteUtils.is_logged_in(res.text):
-                    if under_challenge(res.text):
+                content = res.text
+                if not public and not SiteUtils.is_logged_in(content):
+                    if under_challenge(content):
                         msg = "站点被Cloudflare防护，请打开站点浏览器仿真"
                     elif res.status_code == 200:
                         msg = "Cookie已失效"

app/chain/storage.py

@@ -110,11 +110,17 @@ class StorageChain(ChainBase):
         """
         return self.run_module("get_parent_item", fileitem=fileitem)
 
-    def snapshot_storage(self, storage: str, path: Path) -> Optional[Dict[str, float]]:
+    def snapshot_storage(self, storage: str, path: Path,
+                         last_snapshot_time: float = None, max_depth: int = 5) -> Optional[Dict[str, Dict]]:
         """
         快照存储
+        :param storage: 存储类型
+        :param path: 路径
+        :param last_snapshot_time: 上次快照时间，用于增量快照
+        :param max_depth: 最大递归深度，避免过深遍历
         """
-        return self.run_module("snapshot_storage", storage=storage, path=path)
+        return self.run_module("snapshot_storage", storage=storage, path=path,
+                               last_snapshot_time=last_snapshot_time, max_depth=max_depth)
 
     def storage_usage(self, storage: str) -> Optional[schemas.StorageUsage]:
         """
@@ -172,15 +178,14 @@ class StorageChain(ChainBase):
 
         if mtype:
             # 重命名格式
-            rename_format = settings.TV_RENAME_FORMAT \
-                if mtype == MediaType.TV else settings.MOVIE_RENAME_FORMAT
-            # 计算重命名中的文件夹层数
-            rename_format_level = len(rename_format.split("/")) - 1
-            if rename_format_level < 1:
+            rename_format = settings.RENAME_FORMAT(mtype)
+            media_path = DirectoryHelper.get_media_root_path(
+                rename_format, rename_path=Path(fileitem.path)
+            )
+            if not media_path:
                 return True
             # 处理媒体文件根目录
-            dir_item = self.get_file_item(storage=fileitem.storage,
-                                          path=Path(fileitem.path).parents[rename_format_level - 1])
+            dir_item = self.get_file_item(storage=fileitem.storage, path=media_path)
         else:
             # 处理上级目录
             dir_item = self.get_parent_item(fileitem)

app/chain/subscribe.py

@@ -1,4 +1,5 @@
 import copy
+import gc
 import json
 import random
 import threading
@@ -24,7 +25,6 @@ from app.db.models.subscribe import Subscribe
 from app.db.site_oper import SiteOper
 from app.db.subscribe_oper import SubscribeOper
 from app.db.systemconfig_oper import SystemConfigOper
-from app.helper.memory import memory_optimized
 from app.helper.subscribe import SubscribeHelper
 from app.helper.torrent import TorrentHelper
 from app.log import logger
@@ -39,6 +39,8 @@ class SubscribeChain(ChainBase):
     """
 
     _rlock = threading.RLock()
+    # 避免莫名原因导致长时间持有锁
+    _LOCK_TIMOUT = 3600 * 2
 
     def add(self, title: str, year: str,
             mtype: MediaType = None,
@@ -222,10 +224,13 @@ class SubscribeChain(ChainBase):
             # 订阅成功按规则发送消息
             self.post_message(
                 schemas.Notification(
+                    channel=channel,
+                    source=source,
                     mtype=NotificationType.Subscribe,
                     ctype=ContentType.SubscribeAdded,
                     image=mediainfo.get_message_image(),
                     link=link,
+                    userid=userid,
                     username=username
                 ),
                 meta=metainfo,
@@ -268,7 +273,6 @@ class SubscribeChain(ChainBase):
             return True
         return False
 
-    @memory_optimized(force_gc_after=True, log_memory=True)
     def search(self, sid: Optional[int] = None, state: Optional[str] = 'N', manual: Optional[bool] = False):
         """
         订阅搜索
@@ -277,154 +281,179 @@ class SubscribeChain(ChainBase):
         :param manual: 是否手动搜索
         :return: 更新订阅状态为R或删除订阅
         """
-        with self._rlock:
-            logger.debug(f"search lock acquired at {datetime.now()}")
+        lock_acquired = False
+        try:
+            if lock_acquired := self._rlock.acquire(
+                blocking=True, timeout=self._LOCK_TIMOUT
+            ):
+                logger.debug(f"search lock acquired at {datetime.now()}")
+            else:
+                logger.warn("search上锁超时")
+
             subscribeoper = SubscribeOper()
             if sid:
                 subscribe = subscribeoper.get(sid)
                 subscribes = [subscribe] if subscribe else []
             else:
                 subscribes = subscribeoper.list(self.get_states_for_search(state))
-            # 遍历订阅
-            for subscribe in subscribes:
-                if global_vars.is_system_stopped:
-                    break
-                mediakey = subscribe.tmdbid or subscribe.doubanid
-                custom_word_list = subscribe.custom_words.split("\n") if subscribe.custom_words else None
-                # 校验当前时间减订阅创建时间是否大于1分钟，否则跳过先，留出编辑订阅的时间
-                if subscribe.date:
-                    now = datetime.now()
-                    subscribe_time = datetime.strptime(subscribe.date, '%Y-%m-%d %H:%M:%S')
-                    if (now - subscribe_time).total_seconds() < 60:
-                        logger.debug(f"订阅标题：{subscribe.name} 新增小于1分钟，暂不搜索...")
-                        continue
-                # 随机休眠1-5分钟
-                if not sid and state in ['R', 'P']:
-                    sleep_time = random.randint(60, 300)
-                    logger.info(f'订阅搜索随机休眠 {sleep_time} 秒 ...')
-                    time.sleep(sleep_time)
-                try:
-                    logger.info(f'开始搜索订阅，标题：{subscribe.name} ...')
-                    # 生成元数据
-                    meta = MetaInfo(subscribe.name)
-                    meta.year = subscribe.year
-                    meta.begin_season = subscribe.season or None
+
+            try:
+                # 遍历订阅
+                for subscribe in subscribes:
+                    if global_vars.is_system_stopped:
+                        break
+                    mediakey = subscribe.tmdbid or subscribe.doubanid
+                    custom_word_list = subscribe.custom_words.split("\n") if subscribe.custom_words else None
+                    # 校验当前时间减订阅创建时间是否大于1分钟，否则跳过先，留出编辑订阅的时间
+                    if subscribe.date:
+                        now = datetime.now()
+                        subscribe_time = datetime.strptime(subscribe.date, '%Y-%m-%d %H:%M:%S')
+                        if (now - subscribe_time).total_seconds() < 60:
+                            logger.debug(f"订阅标题：{subscribe.name} 新增小于1分钟，暂不搜索...")
+                            continue
+                    # 随机休眠1-5分钟
+                    if not sid and state in ['R', 'P']:
+                        sleep_time = random.randint(60, 300)
+                        logger.info(f'订阅搜索随机休眠 {sleep_time} 秒 ...')
+                        time.sleep(sleep_time)
                     try:
-                        meta.type = MediaType(subscribe.type)
-                    except ValueError:
-                        logger.error(f'订阅 {subscribe.name} 类型错误：{subscribe.type}')
-                        continue
-                    # 识别媒体信息
-                    mediainfo: MediaInfo = self.recognize_media(meta=meta, mtype=meta.type,
-                                                                tmdbid=subscribe.tmdbid,
-                                                                doubanid=subscribe.doubanid,
-                                                                episode_group=subscribe.episode_group,
-                                                                cache=False)
-                    if not mediainfo:
-                        logger.warn(
-                            f'未识别到媒体信息，标题：{subscribe.name}，tmdbid：{subscribe.tmdbid}，doubanid：{subscribe.doubanid}')
-                        continue
+                        logger.info(f'开始搜索订阅，标题：{subscribe.name} ...')
+                        # 生成元数据
+                        meta = MetaInfo(subscribe.name)
+                        meta.year = subscribe.year
+                        meta.begin_season = subscribe.season or None
+                        try:
+                            meta.type = MediaType(subscribe.type)
+                        except ValueError:
+                            logger.error(f'订阅 {subscribe.name} 类型错误：{subscribe.type}')
+                            continue
+                        # 识别媒体信息
+                        mediainfo: MediaInfo = self.recognize_media(meta=meta, mtype=meta.type,
+                                                                    tmdbid=subscribe.tmdbid,
+                                                                    doubanid=subscribe.doubanid,
+                                                                    episode_group=subscribe.episode_group,
+                                                                    cache=False)
+                        if not mediainfo:
+                            logger.warn(
+                                f'未识别到媒体信息，标题：{subscribe.name}，tmdbid：{subscribe.tmdbid}，doubanid：{subscribe.doubanid}')
+                            continue
 
-                    # 如果媒体已存在或已下载完毕，跳过当前订阅处理
-                    exist_flag, no_exists = self.check_and_handle_existing_media(subscribe=subscribe,
-                                                                                 meta=meta,
-                                                                                 mediainfo=mediainfo,
-                                                                                 mediakey=mediakey)
-                    if exist_flag:
-                        continue
+                        # 如果媒体已存在或已下载完毕，跳过当前订阅处理
+                        exist_flag, no_exists = self.check_and_handle_existing_media(subscribe=subscribe,
+                                                                                     meta=meta,
+                                                                                     mediainfo=mediainfo,
+                                                                                     mediakey=mediakey)
+                        if exist_flag:
+                            continue
 
-                    # 站点范围
-                    sites = self.get_sub_sites(subscribe)
+                        # 站点范围
+                        sites = self.get_sub_sites(subscribe)
 
-                    # 优先级过滤规则
-                    if subscribe.best_version:
-                        rule_groups = subscribe.filter_groups \
-                                      or SystemConfigOper().get(SystemConfigKey.BestVersionFilterRuleGroups) or []
-                    else:
-                        rule_groups = subscribe.filter_groups \
-                                      or SystemConfigOper().get(SystemConfigKey.SubscribeFilterRuleGroups) or []
-
-                    # 搜索，同时电视剧会过滤掉不需要的剧集
-                    contexts = SearchChain().process(mediainfo=mediainfo,
-                                                     keyword=subscribe.keyword,
-                                                     no_exists=no_exists,
-                                                     sites=sites,
-                                                     rule_groups=rule_groups,
-                                                     area="imdbid" if subscribe.search_imdbid else "title",
-                                                     custom_words=custom_word_list,
-                                                     filter_params=self.get_params(subscribe))
-                    if not contexts:
-                        logger.warn(f'订阅 {subscribe.keyword or subscribe.name} 未搜索到资源')
-                        self.finish_subscribe_or_not(subscribe=subscribe, meta=meta,
-                                                     mediainfo=mediainfo, lefts=no_exists)
-                        continue
-
-                    # 过滤搜索结果
-                    matched_contexts = []
-                    for context in contexts:
-                        torrent_meta = context.meta_info
-                        torrent_info = context.torrent_info
-                        torrent_mediainfo = context.media_info
-
-                        # 洗版
+                        # 优先级过滤规则
                         if subscribe.best_version:
-                            # 洗版时，非整季不要
-                            if torrent_mediainfo.type == MediaType.TV:
-                                if torrent_meta.episode_list:
-                                    logger.info(f'{subscribe.name} 正在洗版，{torrent_info.title} 不是整季')
-                                    continue
-                            # 洗版时，优先级小于等于已下载优先级的不要
-                            if subscribe.current_priority \
-                                    and torrent_info.pri_order <= subscribe.current_priority:
-                                logger.info(
-                                    f'{subscribe.name} 正在洗版，{torrent_info.title} 优先级低于或等于已下载优先级')
-                                continue
-                        # 更新订阅自定义属性
-                        if subscribe.media_category:
-                            torrent_mediainfo.category = subscribe.media_category
-                        if subscribe.episode_group:
-                            torrent_mediainfo.episode_group = subscribe.episode_group
-                        matched_contexts.append(context)
+                            rule_groups = subscribe.filter_groups \
+                                          or SystemConfigOper().get(SystemConfigKey.BestVersionFilterRuleGroups) or []
+                        else:
+                            rule_groups = subscribe.filter_groups \
+                                          or SystemConfigOper().get(SystemConfigKey.SubscribeFilterRuleGroups) or []
 
-                    if not matched_contexts:
-                        logger.warn(f'订阅 {subscribe.name} 没有符合过滤条件的资源')
-                        self.finish_subscribe_or_not(subscribe=subscribe, meta=meta,
-                                                     mediainfo=mediainfo, lefts=no_exists)
-                        continue
+                        # 搜索，同时电视剧会过滤掉不需要的剧集
+                        contexts = SearchChain().process(mediainfo=mediainfo,
+                                                         keyword=subscribe.keyword,
+                                                         no_exists=no_exists,
+                                                         sites=sites,
+                                                         rule_groups=rule_groups,
+                                                         area="imdbid" if subscribe.search_imdbid else "title",
+                                                         custom_words=custom_word_list,
+                                                         filter_params=self.get_params(subscribe))
+                        if not contexts:
+                            logger.warn(f'订阅 {subscribe.keyword or subscribe.name} 未搜索到资源')
+                            self.finish_subscribe_or_not(subscribe=subscribe, meta=meta,
+                                                         mediainfo=mediainfo, lefts=no_exists)
+                            continue
 
-                    # 自动下载
-                    downloads, lefts = DownloadChain().batch_download(
-                        contexts=matched_contexts,
-                        no_exists=no_exists,
-                        userid=subscribe.username,
-                        username=subscribe.username,
-                        save_path=subscribe.save_path,
-                        downloader=subscribe.downloader,
-                        source=self.get_subscribe_source_keyword(subscribe)
-                    )
+                        # 过滤搜索结果
+                        matched_contexts = []
+                        try:
+                            for context in contexts:
+                                if global_vars.is_system_stopped:
+                                    break
+                                torrent_meta = context.meta_info
+                                torrent_info = context.torrent_info
+                                torrent_mediainfo = context.media_info
 
-                    # 同步外部修改，更新订阅信息
-                    subscribe = subscribeoper.get(subscribe.id)
+                                # 洗版
+                                if subscribe.best_version:
+                                    # 洗版时，非整季不要
+                                    if torrent_mediainfo.type == MediaType.TV:
+                                        if torrent_meta.episode_list:
+                                            logger.info(f'{subscribe.name} 正在洗版，{torrent_info.title} 不是整季')
+                                            continue
+                                    # 洗版时，优先级小于等于已下载优先级的不要
+                                    if subscribe.current_priority \
+                                            and torrent_info.pri_order <= subscribe.current_priority:
+                                        logger.info(
+                                            f'{subscribe.name} 正在洗版，{torrent_info.title} 优先级低于或等于已下载优先级')
+                                        continue
+                                # 更新订阅自定义属性
+                                if subscribe.media_category:
+                                    torrent_mediainfo.category = subscribe.media_category
+                                if subscribe.episode_group:
+                                    torrent_mediainfo.episode_group = subscribe.episode_group
+                                matched_contexts.append(context)
+                        finally:
+                            contexts.clear()
+                            del contexts
 
-                    # 判断是否应完成订阅
-                    if subscribe:
-                        self.finish_subscribe_or_not(subscribe=subscribe, meta=meta, mediainfo=mediainfo,
-                                                     downloads=downloads, lefts=lefts)
-                finally:
-                    # 如果状态为N则更新为R
-                    if subscribe and subscribe.state == 'N':
-                        subscribeoper.update(subscribe.id, {'state': 'R'})
+                        if not matched_contexts:
+                            logger.warn(f'订阅 {subscribe.name} 没有符合过滤条件的资源')
+                            self.finish_subscribe_or_not(subscribe=subscribe, meta=meta,
+                                                         mediainfo=mediainfo, lefts=no_exists)
+                            continue
 
-            # 手动触发时发送系统消息
-            if manual:
-                if subscribes:
-                    if sid:
-                        self.messagehelper.put(f'{subscribes[0].name} 搜索完成！', title="订阅搜索", role="system")
+                        # 自动下载
+                        downloads, lefts = DownloadChain().batch_download(
+                            contexts=matched_contexts,
+                            no_exists=no_exists,
+                            username=subscribe.username,
+                            save_path=subscribe.save_path,
+                            downloader=subscribe.downloader,
+                            source=self.get_subscribe_source_keyword(subscribe)
+                        )
+
+                        # 同步外部修改，更新订阅信息
+                        subscribe = subscribeoper.get(subscribe.id)
+
+                        # 判断是否应完成订阅
+                        if subscribe:
+                            self.finish_subscribe_or_not(subscribe=subscribe, meta=meta, mediainfo=mediainfo,
+                                                         downloads=downloads, lefts=lefts)
+                    finally:
+                        # 如果状态为N则更新为R
+                        if subscribe and subscribe.state == 'N':
+                            subscribeoper.update(subscribe.id, {'state': 'R'})
+
+                # 手动触发时发送系统消息
+                if manual:
+                    if subscribes:
+                        if sid:
+                            self.messagehelper.put(f'{subscribes[0].name} 搜索完成！', title="订阅搜索", role="system")
+                        else:
+                            self.messagehelper.put('所有订阅搜索完成！', title="订阅搜索", role="system")
                     else:
-                        self.messagehelper.put('所有订阅搜索完成！', title="订阅搜索", role="system")
-                else:
-                    self.messagehelper.put('没有找到订阅！', title="订阅搜索", role="system")
-            logger.debug(f"search Lock released at {datetime.now()}")
+                        self.messagehelper.put('没有找到订阅！', title="订阅搜索", role="system")
+
+            finally:
+                subscribes.clear()
+                del subscribes
+        finally:
+            if lock_acquired:
+                self._rlock.release()
+                logger.debug(f"search Lock released at {datetime.now()}")
+
+            # 如果不是大内存模式，进行垃圾回收
+            if not settings.BIG_MEMORY_MODE:
+                gc.collect()
 
     def update_subscribe_priority(self, subscribe: Subscribe, meta: MetaBase,
                                   mediainfo: MediaInfo, downloads: Optional[List[Context]]):
@@ -497,6 +526,9 @@ class SubscribeChain(ChainBase):
         self.match(
             TorrentsChain().refresh(sites=sites)
         )
+        # 如果不是大内存模式，进行垃圾回收
+        if not settings.BIG_MEMORY_MODE:
+            gc.collect()
 
     @staticmethod
     def get_sub_sites(subscribe: Subscribe) -> List[int]:
@@ -525,13 +557,9 @@ class SubscribeChain(ChainBase):
         获取订阅中涉及的所有站点清单（节约资源）
         :return: 返回[]代表所有站点命中，返回None代表没有订阅
         """
-        # 查询所有订阅
-        subscribes = SubscribeOper().list(self.get_states_for_search('R'))
-        if not subscribes:
-            return None
         ret_sites = []
         # 刷新订阅选中的Rss站点
-        for subscribe in subscribes:
+        for subscribe in SubscribeOper().list(self.get_states_for_search('R')):
             # 刷新选中的站点
             ret_sites.extend(self.get_sub_sites(subscribe))
         # 去重
@@ -540,7 +568,6 @@ class SubscribeChain(ChainBase):
 
         return ret_sites
 
-    @memory_optimized(force_gc_after=True, log_memory=True)
     def match(self, torrents: Dict[str, List[Context]]):
         """
         从缓存中匹配订阅，并自动下载
@@ -549,16 +576,24 @@ class SubscribeChain(ChainBase):
             logger.warn('没有缓存资源，无法匹配订阅')
             return
 
-        with self._rlock:
-            logger.debug(f"match lock acquired at {datetime.now()}")
-            # 所有订阅
-            subscribes = SubscribeOper().list(self.get_states_for_search('R'))
+        lock_acquired = False
+        try:
+            if lock_acquired := self._rlock.acquire(
+                blocking=True, timeout=self._LOCK_TIMOUT
+            ):
+                logger.debug(f"match lock acquired at {datetime.now()}")
+            else:
+                logger.warn("match上锁超时")
 
             # 预识别所有未识别的种子
             processed_torrents: Dict[str, List[Context]] = {}
             for domain, contexts in torrents.items():
+                if global_vars.is_system_stopped:
+                    break
                 processed_torrents[domain] = []
                 for context in contexts:
+                    if global_vars.is_system_stopped:
+                        break
                     # 如果种子未识别，尝试识别
                     if not context.media_info or (not context.media_info.tmdb_id
                                                   and not context.media_info.douban_id):
@@ -571,236 +606,243 @@ class SubscribeChain(ChainBase):
                     # 添加已预处理
                     processed_torrents[domain].append(context)
 
-            # 遍历订阅
-            for subscribe in subscribes:
-                if global_vars.is_system_stopped:
-                    break
-                logger.info(f'开始匹配订阅，标题：{subscribe.name} ...')
-                mediakey = subscribe.tmdbid or subscribe.doubanid
-                # 生成元数据
-                meta = MetaInfo(subscribe.name)
-                meta.year = subscribe.year
-                meta.begin_season = subscribe.season or None
-                try:
-                    meta.type = MediaType(subscribe.type)
-                except ValueError:
-                    logger.error(f'订阅 {subscribe.name} 类型错误：{subscribe.type}')
-                    continue
-                # 订阅的站点域名列表
-                domains = []
-                if subscribe.sites:
-                    domains = SiteOper().get_domains_by_ids(subscribe.sites)
-                # 识别媒体信息
-                mediainfo: MediaInfo = self.recognize_media(meta=meta, mtype=meta.type,
-                                                            tmdbid=subscribe.tmdbid,
-                                                            doubanid=subscribe.doubanid,
-                                                            episode_group=subscribe.episode_group,
-                                                            cache=False)
-                if not mediainfo:
-                    logger.warn(
-                        f'未识别到媒体信息，标题：{subscribe.name}，tmdbid：{subscribe.tmdbid}，doubanid：{subscribe.doubanid}')
-                    continue
-
-                # 如果媒体已存在或已下载完毕，跳过当前订阅处理
-                exist_flag, no_exists = self.check_and_handle_existing_media(subscribe=subscribe, meta=meta,
-                                                                             mediainfo=mediainfo,
-                                                                             mediakey=mediakey)
-                if exist_flag:
-                    continue
-
-                # 清理多余信息
-                mediainfo.clear()
-
-                # 订阅识别词
-                if subscribe.custom_words:
-                    custom_words_list = subscribe.custom_words.split("\n")
-                else:
-                    custom_words_list = None
-
-                # 遍历预识别后的种子
-                _match_context = []
-                torrenthelper = TorrentHelper()
-                systemconfig = SystemConfigOper()
-                wordsmatcher = WordsMatcher()
-                for domain, contexts in processed_torrents.items():
+            # 所有订阅
+            subscribes = SubscribeOper().list(self.get_states_for_search('R'))
+            try:
+                for subscribe in subscribes:
                     if global_vars.is_system_stopped:
                         break
-                    if domains and domain not in domains:
+                    logger.info(f'开始匹配订阅，标题：{subscribe.name} ...')
+                    mediakey = subscribe.tmdbid or subscribe.doubanid
+                    # 生成元数据
+                    meta = MetaInfo(subscribe.name)
+                    meta.year = subscribe.year
+                    meta.begin_season = subscribe.season or None
+                    try:
+                        meta.type = MediaType(subscribe.type)
+                    except ValueError:
+                        logger.error(f'订阅 {subscribe.name} 类型错误：{subscribe.type}')
+                        continue
+                    # 订阅的站点域名列表
+                    domains = []
+                    if subscribe.sites:
+                        domains = SiteOper().get_domains_by_ids(subscribe.sites)
+                    # 识别媒体信息
+                    mediainfo: MediaInfo = self.recognize_media(meta=meta, mtype=meta.type,
+                                                                tmdbid=subscribe.tmdbid,
+                                                                doubanid=subscribe.doubanid,
+                                                                episode_group=subscribe.episode_group,
+                                                                cache=False)
+                    if not mediainfo:
+                        logger.warn(
+                            f'未识别到媒体信息，标题：{subscribe.name}，tmdbid：{subscribe.tmdbid}，doubanid：{subscribe.doubanid}')
                         continue
-                    logger.debug(f'开始匹配站点：{domain}，共缓存了 {len(contexts)} 个种子...')
-                    for context in contexts:
-                        # 提取信息
-                        _context = copy.copy(context)
-                        torrent_meta = _context.meta_info
-                        torrent_mediainfo = _context.media_info
-                        torrent_info = _context.torrent_info
 
-                        # 不在订阅站点范围的不处理
-                        sub_sites = self.get_sub_sites(subscribe)
-                        if sub_sites and torrent_info.site not in sub_sites:
-                            logger.debug(f"{torrent_info.site_name} - {torrent_info.title} 不符合订阅站点要求")
+                    # 如果媒体已存在或已下载完毕，跳过当前订阅处理
+                    exist_flag, no_exists = self.check_and_handle_existing_media(subscribe=subscribe, meta=meta,
+                                                                                 mediainfo=mediainfo,
+                                                                                 mediakey=mediakey)
+                    if exist_flag:
+                        continue
+
+                    # 清理多余信息
+                    mediainfo.clear()
+
+                    # 订阅识别词
+                    if subscribe.custom_words:
+                        custom_words_list = subscribe.custom_words.split("\n")
+                    else:
+                        custom_words_list = None
+
+                    # 遍历预识别后的种子
+                    _match_context = []
+                    torrenthelper = TorrentHelper()
+                    systemconfig = SystemConfigOper()
+                    wordsmatcher = WordsMatcher()
+                    for domain, contexts in processed_torrents.items():
+                        if global_vars.is_system_stopped:
+                            break
+                        if domains and domain not in domains:
                             continue
+                        logger.debug(f'开始匹配站点：{domain}，共缓存了 {len(contexts)} 个种子...')
+                        for context in contexts:
+                            if global_vars.is_system_stopped:
+                                break
+                            # 提取信息
+                            _context = copy.copy(context)
+                            torrent_meta = _context.meta_info
+                            torrent_mediainfo = _context.media_info
+                            torrent_info = _context.torrent_info
 
-                        # 有自定义识别词时，需要判断是否需要重新识别
-                        if custom_words_list:
-                            # 使用org_string，应用一次后理论上不能再次应用
-                            _, apply_words = wordsmatcher.prepare(torrent_meta.org_string,
-                                                                  custom_words=custom_words_list)
-                            if apply_words:
+                            # 不在订阅站点范围的不处理
+                            sub_sites = self.get_sub_sites(subscribe)
+                            if sub_sites and torrent_info.site not in sub_sites:
+                                logger.debug(f"{torrent_info.site_name} - {torrent_info.title} 不符合订阅站点要求")
+                                continue
+
+                            # 有自定义识别词时，需要判断是否需要重新识别
+                            if custom_words_list:
+                                # 使用org_string，应用一次后理论上不能再次应用
+                                _, apply_words = wordsmatcher.prepare(torrent_meta.org_string,
+                                                                      custom_words=custom_words_list)
+                                if apply_words:
+                                    logger.info(
+                                        f'{torrent_info.site_name} - {torrent_info.title} 因订阅存在自定义识别词，重新识别元数据...')
+                                    # 重新识别元数据
+                                    torrent_meta = MetaInfo(title=torrent_info.title, subtitle=torrent_info.description,
+                                                            custom_words=custom_words_list)
+                                    # 更新元数据缓存
+                                    _context.meta_info = torrent_meta
+                                    # 重新识别媒体信息
+                                    torrent_mediainfo = self.recognize_media(meta=torrent_meta,
+                                                                             episode_group=subscribe.episode_group)
+                                    if torrent_mediainfo:
+                                        # 清理多余信息
+                                        torrent_mediainfo.clear()
+                                        # 更新种子缓存
+                                        _context.media_info = torrent_mediainfo
+
+                            # 如果仍然没有识别到媒体信息，尝试标题匹配
+                            if not torrent_mediainfo or (
+                                    not torrent_mediainfo.tmdb_id and not torrent_mediainfo.douban_id):
                                 logger.info(
-                                    f'{torrent_info.site_name} - {torrent_info.title} 因订阅存在自定义识别词，重新识别元数据...')
-                                # 重新识别元数据
-                                torrent_meta = MetaInfo(title=torrent_info.title, subtitle=torrent_info.description,
-                                                        custom_words=custom_words_list)
-                                # 更新元数据缓存
-                                _context.meta_info = torrent_meta
-                                # 重新识别媒体信息
-                                torrent_mediainfo = self.recognize_media(meta=torrent_meta,
-                                                                         episode_group=subscribe.episode_group)
-                                if torrent_mediainfo:
-                                    # 清理多余信息
-                                    torrent_mediainfo.clear()
+                                    f'{torrent_info.site_name} - {torrent_info.title} 重新识别失败，尝试通过标题匹配...')
+                                if 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 = torrent_mediainfo
+                                    _context.media_info = mediainfo
+                                else:
+                                    continue
 
-                        # 如果仍然没有识别到媒体信息，尝试标题匹配
-                        if not torrent_mediainfo or (not torrent_mediainfo.tmdb_id and not torrent_mediainfo.douban_id):
-                            logger.info(
-                                f'{torrent_info.site_name} - {torrent_info.title} 重新识别失败，尝试通过标题匹配...')
-                            if torrenthelper.match_torrent(mediainfo=mediainfo,
-                                                           torrent_meta=torrent_meta,
-                                                           torrent=torrent_info):
-                                # 匹配成功
+                            # 直接比对媒体信息
+                            if torrent_mediainfo and (torrent_mediainfo.tmdb_id or torrent_mediainfo.douban_id):
+                                if torrent_mediainfo.type != mediainfo.type:
+                                    continue
+                                if torrent_mediainfo.tmdb_id \
+                                        and torrent_mediainfo.tmdb_id != mediainfo.tmdb_id:
+                                    continue
+                                if torrent_mediainfo.douban_id \
+                                        and torrent_mediainfo.douban_id != mediainfo.douban_id:
+                                    continue
                                 logger.info(
-                                    f'{mediainfo.title_year} 通过标题匹配到可选资源：{torrent_info.site_name} - {torrent_info.title}')
-                                torrent_mediainfo = mediainfo
-                                # 更新种子缓存
-                                _context.media_info = mediainfo
+                                    f'{mediainfo.title_year} 通过媒体信ID匹配到可选资源：{torrent_info.site_name} - {torrent_info.title}')
                             else:
                                 continue
 
-                        # 直接比对媒体信息
-                        if torrent_mediainfo and (torrent_mediainfo.tmdb_id or torrent_mediainfo.douban_id):
-                            if torrent_mediainfo.type != mediainfo.type:
-                                continue
-                            if torrent_mediainfo.tmdb_id \
-                                    and torrent_mediainfo.tmdb_id != mediainfo.tmdb_id:
-                                continue
-                            if torrent_mediainfo.douban_id \
-                                    and torrent_mediainfo.douban_id != mediainfo.douban_id:
-                                continue
-                            logger.info(
-                                f'{mediainfo.title_year} 通过媒体信ID匹配到可选资源：{torrent_info.site_name} - {torrent_info.title}')
-                        else:
-                            continue
-
-                        # 如果是电视剧
-                        if torrent_mediainfo.type == MediaType.TV:
-                            # 有多季的不要
-                            if len(torrent_meta.season_list) > 1:
-                                logger.debug(f'{torrent_info.title} 有多季，不处理')
-                                continue
-                            # 比对季
-                            if torrent_meta.begin_season:
-                                if meta.begin_season != torrent_meta.begin_season:
+                            # 如果是电视剧
+                            if torrent_mediainfo.type == MediaType.TV:
+                                # 有多季的不要
+                                if len(torrent_meta.season_list) > 1:
+                                    logger.debug(f'{torrent_info.title} 有多季，不处理')
+                                    continue
+                                # 比对季
+                                if torrent_meta.begin_season:
+                                    if meta.begin_season != torrent_meta.begin_season:
+                                        logger.debug(f'{torrent_info.title} 季不匹配')
+                                        continue
+                                elif meta.begin_season != 1:
                                     logger.debug(f'{torrent_info.title} 季不匹配')
                                     continue
-                            elif meta.begin_season != 1:
-                                logger.debug(f'{torrent_info.title} 季不匹配')
-                                continue
-                            # 非洗版
-                            if not subscribe.best_version:
-                                # 不是缺失的剧集不要
-                                if no_exists and no_exists.get(mediakey):
-                                    # 缺失集
-                                    no_exists_info = no_exists.get(mediakey).get(subscribe.season)
-                                    if no_exists_info:
-                                        # 是否有交集
-                                        if no_exists_info.episodes and \
-                                                torrent_meta.episode_list and \
-                                                not set(no_exists_info.episodes).intersection(
-                                                    set(torrent_meta.episode_list)
-                                                ):
-                                            logger.debug(
-                                                f'{torrent_info.title} 对应剧集 {torrent_meta.episode_list} 未包含缺失的剧集'
-                                            )
+                                # 非洗版
+                                if not subscribe.best_version:
+                                    # 不是缺失的剧集不要
+                                    if no_exists and no_exists.get(mediakey):
+                                        # 缺失集
+                                        no_exists_info = no_exists.get(mediakey).get(subscribe.season)
+                                        if no_exists_info:
+                                            # 是否有交集
+                                            if no_exists_info.episodes and \
+                                                    torrent_meta.episode_list and \
+                                                    not set(no_exists_info.episodes).intersection(
+                                                        set(torrent_meta.episode_list)
+                                                    ):
+                                                logger.debug(
+                                                    f'{torrent_info.title} 对应剧集 {torrent_meta.episode_list} 未包含缺失的剧集'
+                                                )
+                                                continue
+                                else:
+                                    # 洗版时，非整季不要
+                                    if meta.type == MediaType.TV:
+                                        if torrent_meta.episode_list:
+                                            logger.debug(f'{subscribe.name} 正在洗版，{torrent_info.title} 不是整季')
                                             continue
-                            else:
-                                # 洗版时，非整季不要
-                                if meta.type == MediaType.TV:
-                                    if torrent_meta.episode_list:
-                                        logger.debug(f'{subscribe.name} 正在洗版，{torrent_info.title} 不是整季')
-                                        continue
 
-                        # 匹配订阅附加参数
-                        if not torrenthelper.filter_torrent(torrent_info=torrent_info,
-                                                            filter_params=self.get_params(subscribe)):
-                            continue
-
-                        # 优先级过滤规则
-                        if subscribe.best_version:
-                            rule_groups = subscribe.filter_groups \
-                                          or systemconfig.get(SystemConfigKey.BestVersionFilterRuleGroups)
-                        else:
-                            rule_groups = subscribe.filter_groups \
-                                          or systemconfig.get(SystemConfigKey.SubscribeFilterRuleGroups)
-                        result: List[TorrentInfo] = self.filter_torrents(
-                            rule_groups=rule_groups,
-                            torrent_list=[torrent_info],
-                            mediainfo=torrent_mediainfo)
-                        if result is not None and not result:
-                            # 不符合过滤规则
-                            logger.debug(f"{torrent_info.title} 不匹配过滤规则")
-                            continue
-
-                        # 洗版时，优先级小于已下载优先级的不要
-                        if subscribe.best_version:
-                            if subscribe.current_priority \
-                                    and torrent_info.pri_order <= subscribe.current_priority:
-                                logger.info(
-                                    f'{subscribe.name} 正在洗版，{torrent_info.title} 优先级低于或等于已下载优先级')
+                            # 匹配订阅附加参数
+                            if not torrenthelper.filter_torrent(torrent_info=torrent_info,
+                                                                filter_params=self.get_params(subscribe)):
                                 continue
 
-                        # 匹配成功
-                        logger.info(f'{mediainfo.title_year} 匹配成功：{torrent_info.title}')
-                        # 自定义属性
-                        if subscribe.media_category:
-                            torrent_mediainfo.category = subscribe.media_category
-                        if subscribe.episode_group:
-                            torrent_mediainfo.episode_group = subscribe.episode_group
-                        _match_context.append(_context)
+                            # 优先级过滤规则
+                            if subscribe.best_version:
+                                rule_groups = subscribe.filter_groups \
+                                              or systemconfig.get(SystemConfigKey.BestVersionFilterRuleGroups)
+                            else:
+                                rule_groups = subscribe.filter_groups \
+                                              or systemconfig.get(SystemConfigKey.SubscribeFilterRuleGroups)
+                            result: List[TorrentInfo] = self.filter_torrents(
+                                rule_groups=rule_groups,
+                                torrent_list=[torrent_info],
+                                mediainfo=torrent_mediainfo)
+                            if result is not None and not result:
+                                # 不符合过滤规则
+                                logger.debug(f"{torrent_info.title} 不匹配过滤规则")
+                                continue
 
-                    # 清理内存
-                    contexts.clear()
-                    del contexts
+                            # 洗版时，优先级小于已下载优先级的不要
+                            if subscribe.best_version:
+                                if subscribe.current_priority \
+                                        and torrent_info.pri_order <= subscribe.current_priority:
+                                    logger.info(
+                                        f'{subscribe.name} 正在洗版，{torrent_info.title} 优先级低于或等于已下载优先级')
+                                    continue
 
-                if not _match_context:
-                    # 未匹配到资源
-                    logger.info(f'{mediainfo.title_year} 未匹配到符合条件的资源')
-                    self.finish_subscribe_or_not(subscribe=subscribe, meta=meta,
-                                                 mediainfo=mediainfo, lefts=no_exists)
-                    continue
+                            # 匹配成功
+                            logger.info(f'{mediainfo.title_year} 匹配成功：{torrent_info.title}')
+                            # 自定义属性
+                            if subscribe.media_category:
+                                torrent_mediainfo.category = subscribe.media_category
+                            if subscribe.episode_group:
+                                torrent_mediainfo.episode_group = subscribe.episode_group
+                            _match_context.append(_context)
 
-                # 开始批量择优下载
-                logger.info(f'{mediainfo.title_year} 匹配完成，共匹配到{len(_match_context)}个资源')
-                downloads, lefts = DownloadChain().batch_download(contexts=_match_context,
-                                                                  no_exists=no_exists,
-                                                                  userid=subscribe.username,
-                                                                  username=subscribe.username,
-                                                                  save_path=subscribe.save_path,
-                                                                  downloader=subscribe.downloader,
-                                                                  source=self.get_subscribe_source_keyword(subscribe)
-                                                                  )
+                    if not _match_context:
+                        # 未匹配到资源
+                        logger.info(f'{mediainfo.title_year} 未匹配到符合条件的资源')
+                        self.finish_subscribe_or_not(subscribe=subscribe, meta=meta,
+                                                     mediainfo=mediainfo, lefts=no_exists)
+                        continue
 
-                # 同步外部修改，更新订阅信息
-                subscribe = SubscribeOper().get(subscribe.id)
+                    # 开始批量择优下载
+                    logger.info(f'{mediainfo.title_year} 匹配完成，共匹配到{len(_match_context)}个资源')
+                    downloads, lefts = DownloadChain().batch_download(contexts=_match_context,
+                                                                      no_exists=no_exists,
+                                                                      username=subscribe.username,
+                                                                      save_path=subscribe.save_path,
+                                                                      downloader=subscribe.downloader,
+                                                                      source=self.get_subscribe_source_keyword(subscribe)
+                                                                      )
 
-                # 判断是否要完成订阅
-                if subscribe:
-                    self.finish_subscribe_or_not(subscribe=subscribe, meta=meta, mediainfo=mediainfo,
-                                                 downloads=downloads, lefts=lefts)
+                    # 同步外部修改，更新订阅信息
+                    subscribe = SubscribeOper().get(subscribe.id)
 
-            logger.debug(f"match Lock released at {datetime.now()}")
+                    # 判断是否要完成订阅
+                    if subscribe:
+                        self.finish_subscribe_or_not(subscribe=subscribe, meta=meta, mediainfo=mediainfo,
+                                                     downloads=downloads, lefts=lefts)
+            finally:
+                processed_torrents.clear()
+                del processed_torrents
+                subscribes.clear()
+                del subscribes
+        finally:
+            if lock_acquired:
+                self._rlock.release()
+                logger.debug(f"match Lock released at {datetime.now()}")
 
     def check(self):
         """
@@ -808,12 +850,8 @@ class SubscribeChain(ChainBase):
         """
         # 查询所有订阅
         subscribeoper = SubscribeOper()
-        subscribes = subscribeoper.list()
-        if not subscribes:
-            # 没有订阅不运行
-            return
         # 遍历订阅
-        for subscribe in subscribes:
+        for subscribe in subscribeoper.list():
             if global_vars.is_system_stopped:
                 break
             logger.info(f'开始更新订阅元数据：{subscribe.name} ...')
@@ -869,11 +907,12 @@ class SubscribeChain(ChainBase):
         follow_users: List[str] = SystemConfigOper().get(SystemConfigKey.FollowSubscribers)
         if not follow_users:
             return
-        share_subs = SubscribeHelper().get_shares()
         logger.info(f'开始刷新follow用户分享订阅 ...')
         success_count = 0
         subscribeoper = SubscribeOper()
-        for share_sub in share_subs:
+        for share_sub in SubscribeHelper().get_shares():
+            if global_vars.is_system_stopped:
+                break
             uid = share_sub.get("share_uid")
             if uid and uid in follow_users:
                 # 订阅已存在则跳过
@@ -1182,6 +1221,9 @@ class SubscribeChain(ChainBase):
                     new_episodes = list(range(max(start_episode, start), total_episode + 1))
                     # 与原集列表取交集
                     episodes = list(set(episode_list).intersection(set(new_episodes)))
+                    # 交集为空时，说明订阅的剧集均已入库
+                    if not episodes:
+                        return True, {}
                 # 更新集合
                 no_exists[mediakey][begin_season] = schemas.NotExistMediaInfo(
                     season=begin_season,

app/chain/system.py

@@ -1,15 +1,18 @@
 import json
 import re
+import shutil
 from pathlib import Path
 from typing import Union, Optional
 
 from app.chain import ChainBase
 from app.core.config import settings
+from app.core.plugin import PluginManager
 from app.log import logger
 from app.schemas import Notification, MessageChannel
 from app.utils.http import RequestUtils
 from app.utils.system import SystemUtils
 from app.helper.system import SystemHelper
+from app.helper.plugin import PluginHelper
 from version import FRONTEND_VERSION, APP_VERSION
 
 
@@ -32,6 +35,8 @@ class SystemChain(ChainBase):
         """
         重启系统
         """
+        from app.core.config import global_vars
+
         if channel and userid:
             self.post_message(Notification(channel=channel, source=source,
                                            title="系统正在重启，请耐心等候！", userid=userid))
@@ -40,9 +45,120 @@ class SystemChain(ChainBase):
                 "channel": channel.value,
                 "userid": userid
             }, self._restart_file)
+        # 主动备份一次插件
+        self.backup_plugins()
+        # 设置停止标志，通知所有模块准备停止
+        global_vars.stop_system()
         # 重启
         SystemHelper.restart()
 
+    @staticmethod
+    def backup_plugins():
+        """
+        备份插件到用户配置目录（仅docker环境）
+        """
+
+        # 非docker环境不处理
+        if not SystemUtils.is_docker():
+            return
+
+        try:
+            # 使用绝对路径确保准确性
+            plugins_dir = settings.ROOT_PATH / "app" / "plugins"
+            backup_dir = settings.CONFIG_PATH / "plugins_backup"
+
+            if not plugins_dir.exists():
+                logger.info("插件目录不存在，跳过备份")
+                return
+
+            # 确保备份目录存在
+            backup_dir.mkdir(parents=True, exist_ok=True)
+
+            # 需要排除的文件和目录
+            exclude_items = {"__init__.py", "__pycache__", ".DS_Store"}
+
+            # 遍历插件目录，备份除排除项外的所有内容
+            for item in plugins_dir.iterdir():
+                if item.name in exclude_items:
+                    continue
+
+                target_path = backup_dir / item.name
+
+                # 如果是目录
+                if item.is_dir():
+                    if target_path.exists():
+                        continue
+                    shutil.copytree(item, target_path)
+                    logger.info(f"已备份插件目录: {item.name}")
+                # 如果是文件
+                elif item.is_file():
+                    if target_path.exists():
+                        continue
+                    shutil.copy2(item, target_path)
+                    logger.info(f"已备份插件文件: {item.name}")
+
+            logger.info(f"插件备份完成，备份位置: {backup_dir}")
+
+        except Exception as e:
+            logger.error(f"插件备份失败: {str(e)}")
+
+    @staticmethod
+    def restore_plugins():
+        """
+        从备份恢复插件到app/plugins目录，恢复完成后删除备份（仅docker环境）
+        """
+
+        # 非docker环境不处理
+        if not SystemUtils.is_docker():
+            return
+
+        # 使用绝对路径确保准确性
+        plugins_dir = settings.ROOT_PATH / "app" / "plugins"
+        backup_dir = settings.CONFIG_PATH / "plugins_backup"
+
+        if not backup_dir.exists():
+            logger.info("插件备份目录不存在，跳过恢复")
+            return
+
+        # 系统被重置才恢复插件
+        if SystemHelper().is_system_reset():
+
+            # 确保插件目录存在
+            plugins_dir.mkdir(parents=True, exist_ok=True)
+
+            # 遍历备份目录，恢复所有内容
+            restored_count = 0
+            for item in backup_dir.iterdir():
+                target_path = plugins_dir / item.name
+                try:
+                    # 如果是目录，且目录内有内容
+                    if item.is_dir() and any(item.iterdir()):
+                        if target_path.exists():
+                            shutil.rmtree(target_path)
+                        shutil.copytree(item, target_path)
+                        logger.info(f"已恢复插件目录: {item.name}")
+                        restored_count += 1
+                    # 如果是文件
+                    elif item.is_file():
+                        shutil.copy2(item, target_path)
+                        logger.info(f"已恢复插件文件: {item.name}")
+                        restored_count += 1
+                except Exception as e:
+                    logger.error(f"恢复插件 {item.name} 时发生错误: {str(e)}")
+                    continue
+
+            logger.info(f"插件恢复完成，共恢复 {restored_count} 个项目")
+
+            # 安装缺少的依赖
+            PluginManager.install_plugin_missing_dependencies()
+
+        # 删除备份目录
+        try:
+            shutil.rmtree(backup_dir)
+            logger.info(f"已删除插件备份目录: {backup_dir}")
+        except Exception as e:
+            logger.warning(f"删除备份目录失败: {str(e)}")
+
     def __get_version_message(self) -> str:
         """
         获取版本信息文本

app/chain/torrents.py

@@ -1,4 +1,3 @@
-import gc
 import re
 import traceback
 from typing import Dict, List, Union, Optional
@@ -10,7 +9,6 @@ from app.core.context import TorrentInfo, Context, MediaInfo
 from app.core.metainfo import MetaInfo
 from app.db.site_oper import SiteOper
 from app.db.systemconfig_oper import SystemConfigOper
-from app.helper.memory import memory_optimized, clear_large_objects
 from app.helper.rss import RssHelper
 from app.helper.sites import SitesHelper
 from app.helper.torrent import TorrentHelper
@@ -71,7 +69,6 @@ class TorrentsChain(ChainBase):
         self.remove_cache(self._rss_file)
         logger.info(f'种子缓存数据清理完成')
 
-    @memory_optimized(force_gc_after=True, log_memory=True)
     def browse(self, domain: str, keyword: Optional[str] = None, cat: Optional[str] = None,
                page: Optional[int] = 0) -> List[TorrentInfo]:
         """
@@ -88,7 +85,6 @@ class TorrentsChain(ChainBase):
             return []
         return self.refresh_torrents(site=site, keyword=keyword, cat=cat, page=page)
 
-    @memory_optimized(force_gc_after=True, log_memory=True)
     def rss(self, domain: str) -> List[TorrentInfo]:
         """
         获取站点RSS内容，返回种子清单，TTL缓存3分钟
@@ -102,6 +98,7 @@ class TorrentsChain(ChainBase):
         if not site.get("rss"):
             logger.error(f'站点 {domain} 未配置RSS地址！')
             return []
+        # 解析RSS
         rss_items = RssHelper().parse(site.get("rss"), True if site.get("proxy") else False,
                                       timeout=int(site.get("timeout") or 30))
         if rss_items is None:
@@ -113,34 +110,46 @@ class TorrentsChain(ChainBase):
             return []
         # 组装种子
         ret_torrents: List[TorrentInfo] = []
-        for item in rss_items:
-            if not item.get("title"):
-                continue
-            torrentinfo = TorrentInfo(
-                site=site.get("id"),
-                site_name=site.get("name"),
-                site_cookie=site.get("cookie"),
-                site_ua=site.get("ua") or settings.USER_AGENT,
-                site_proxy=site.get("proxy"),
-                site_order=site.get("pri"),
-                site_downloader=site.get("downloader"),
-                title=item.get("title"),
-                enclosure=item.get("enclosure"),
-                page_url=item.get("link"),
-                size=item.get("size"),
-                pubdate=item["pubdate"].strftime("%Y-%m-%d %H:%M:%S") if item.get("pubdate") else None,
-            )
-            ret_torrents.append(torrentinfo)
-
+        try:
+            for item in rss_items:
+                if not item.get("title"):
+                    continue
+                torrentinfo = TorrentInfo(
+                    site=site.get("id"),
+                    site_name=site.get("name"),
+                    site_cookie=site.get("cookie"),
+                    site_ua=site.get("ua") or settings.USER_AGENT,
+                    site_proxy=site.get("proxy"),
+                    site_order=site.get("pri"),
+                    site_downloader=site.get("downloader"),
+                    title=item.get("title"),
+                    enclosure=item.get("enclosure"),
+                    page_url=item.get("link"),
+                    size=item.get("size"),
+                    pubdate=item["pubdate"].strftime("%Y-%m-%d %H:%M:%S") if item.get("pubdate") else None,
+                )
+                ret_torrents.append(torrentinfo)
+        finally:
+            rss_items.clear()
+            del rss_items
         return ret_torrents
 
-    @memory_optimized(force_gc_after=True, log_memory=True)
     def refresh(self, stype: Optional[str] = None, sites: List[int] = None) -> Dict[str, List[Context]]:
         """
         刷新站点最新资源，识别并缓存起来
         :param stype: 强制指定缓存类型，spider:爬虫缓存，rss:rss缓存
         :param sites: 强制指定站点ID列表，为空则读取设置的订阅站点
         """
+
+        def __is_no_cache_site(_domain: str) -> bool:
+            """
+            判断站点是否不需要缓存
+            """
+            for url_key in settings.NO_CACHE_SITE_KEY.split(','):
+                if url_key in _domain:
+                    return True
+            return False
+
         # 刷新类型
         if not stype:
             stype = settings.SUBSCRIBE_MODE
@@ -157,13 +166,10 @@ class TorrentsChain(ChainBase):
             torrents_cache[_domain] = [_torrent for _torrent in _torrents
                                        if not TorrentHelper().is_invalid(_torrent.torrent_info.enclosure)]
 
-        # 所有站点索引
-        indexers = SitesHelper().get_indexers()
         # 需要刷新的站点domain
         domains = []
-
         # 遍历站点缓存资源
-        for indexer in indexers:
+        for indexer in SitesHelper().get_indexers():
             if global_vars.is_system_stopped:
                 break
             # 未开启的站点不刷新
@@ -173,65 +179,72 @@ class TorrentsChain(ChainBase):
             domains.append(domain)
             if stype == "spider":
                 # 刷新首页种子
-                torrents: List[TorrentInfo] = self.browse(domain=domain)
+                torrents: List[TorrentInfo] = []
+                # 读取第0页和第1页
+                for page in range(2):
+                    page_torrents = self.browse(domain=domain, page=page)
+                    if page_torrents:
+                        torrents.extend(page_torrents)
+                    else:
+                        # 如果某一页没有数据，说明已经到最后一页，停止获取
+                        break
             else:
                 # 刷新RSS种子
                 torrents: List[TorrentInfo] = self.rss(domain=domain)
             # 按pubdate降序排列
             torrents.sort(key=lambda x: x.pubdate or '', reverse=True)
             # 取前N条
-            torrents = torrents[:settings.CACHE_CONF["refresh"]]
+            torrents = torrents[:settings.CONF.refresh]
             if torrents:
-                # 过滤出没有处理过的种子 - 优化：使用集合查找，避免重复创建字符串列表
-                cached_signatures = {f'{t.torrent_info.title}{t.torrent_info.description}'
-                                     for t in torrents_cache.get(domain) or []}
-                torrents = [torrent for torrent in torrents
-                            if f'{torrent.title}{torrent.description}' not in cached_signatures]
+                if __is_no_cache_site(domain):
+                    # 不需要缓存的站点，直接处理
+                    logger.info(f'{indexer.get("name")} 有 {len(torrents)} 个种子 (不缓存)')
+                    torrents_cache[domain] = []
+                else:
+                    # 过滤出没有处理过的种子 - 优化：使用集合查找，避免重复创建字符串列表
+                    cached_signatures = {f'{t.torrent_info.title}{t.torrent_info.description}'
+                                         for t in torrents_cache.get(domain) or []}
+                    torrents = [torrent for torrent in torrents
+                                if f'{torrent.title}{torrent.description}' not in cached_signatures]
                 if torrents:
                     logger.info(f'{indexer.get("name")} 有 {len(torrents)} 个新种子')
                 else:
                     logger.info(f'{indexer.get("name")} 没有新种子')
                     continue
-                for torrent in torrents:
-                    if global_vars.is_system_stopped:
-                        break
-                    logger.info(f'处理资源：{torrent.title} ...')
-                    # 识别
-                    meta = MetaInfo(title=torrent.title, subtitle=torrent.description)
-                    if torrent.title != meta.org_string:
-                        logger.info(f'种子名称应用识别词后发生改变：{torrent.title} => {meta.org_string}')
-                    # 使用站点种子分类，校正类型识别
-                    if meta.type != MediaType.TV \
-                            and torrent.category == MediaType.TV.value:
-                        meta.type = MediaType.TV
-                    # 识别媒体信息
-                    mediainfo: MediaInfo = MediaChain().recognize_by_meta(meta)
-                    if not mediainfo:
-                        logger.warn(f'{torrent.title} 未识别到媒体信息')
-                        # 存储空的媒体信息
-                        mediainfo = MediaInfo()
-                    # 清理多余数据，减少内存占用
-                    mediainfo.clear()
-                    # 上下文
-                    context = Context(meta_info=meta, media_info=mediainfo, torrent_info=torrent)
-                    # 添加到缓存
-                    if not torrents_cache.get(domain):
-                        torrents_cache[domain] = [context]
-                    else:
-                        torrents_cache[domain].append(context)
-                    # 如果超过了限制条数则移除掉前面的
-                    if len(torrents_cache[domain]) > settings.CACHE_CONF["torrents"]:
-                        # 优化：直接删除旧数据，无需重复清理（数据进缓存前已经clear过）
-                        old_contexts = torrents_cache[domain][:-settings.CACHE_CONF["torrents"]]
-                        torrents_cache[domain] = torrents_cache[domain][-settings.CACHE_CONF["torrents"]:]
-                        # 清理旧对象
-                        clear_large_objects(*old_contexts)
-                    # 优化：清理不再需要的临时变量
-                    del meta, mediainfo, context
-                # 回收资源
-                torrents.clear()
-                del torrents
-                gc.collect()
+                try:
+                    for torrent in torrents:
+                        if global_vars.is_system_stopped:
+                            break
+                        logger.info(f'处理资源：{torrent.title} ...')
+                        # 识别
+                        meta = MetaInfo(title=torrent.title, subtitle=torrent.description)
+                        if torrent.title != meta.org_string:
+                            logger.info(f'种子名称应用识别词后发生改变：{torrent.title} => {meta.org_string}')
+                        # 使用站点种子分类，校正类型识别
+                        if meta.type != MediaType.TV \
+                                and torrent.category == MediaType.TV.value:
+                            meta.type = MediaType.TV
+                        # 识别媒体信息
+                        mediainfo: MediaInfo = MediaChain().recognize_by_meta(meta)
+                        if not mediainfo:
+                            logger.warn(f'{torrent.title} 未识别到媒体信息')
+                            # 存储空的媒体信息
+                            mediainfo = MediaInfo()
+                        # 清理多余数据，减少内存占用
+                        mediainfo.clear()
+                        # 上下文
+                        context = Context(meta_info=meta, media_info=mediainfo, torrent_info=torrent)
+                        # 添加到缓存
+                        if not torrents_cache.get(domain):
+                            torrents_cache[domain] = [context]
+                        else:
+                            torrents_cache[domain].append(context)
+                        # 如果超过了限制条数则移除掉前面的
+                        if len(torrents_cache[domain]) > settings.CONF.torrents:
+                            torrents_cache[domain] = torrents_cache[domain][-settings.CONF.torrents:]
+                finally:
+                    torrents.clear()
+                    del torrents
             else:
                 logger.info(f'{indexer.get("name")} 没有获取到种子')
 
@@ -243,17 +256,7 @@ class TorrentsChain(ChainBase):
 
         # 去除不在站点范围内的缓存种子
         if sites and torrents_cache:
-            old_cache = torrents_cache
             torrents_cache = {k: v for k, v in torrents_cache.items() if k in domains}
-            # 清理不再使用的缓存数据（数据进缓存前已经clear过，无需重复清理）
-            removed_contexts = []
-            for domain, contexts in old_cache.items():
-                if domain not in domains:
-                    removed_contexts.extend(contexts)
-            # 批量清理
-            if removed_contexts:
-                clear_large_objects(*removed_contexts)
-            del old_cache
 
         return torrents_cache
 

app/chain/transfer.py

@@ -1,10 +1,10 @@
+import gc
 import queue
 import re
 import threading
 import traceback
 from copy import deepcopy
 from pathlib import Path
-from queue import Queue
 from time import sleep
 from typing import List, Optional, Tuple, Union, Dict, Callable
 
@@ -15,9 +15,9 @@ from app.chain.storage import StorageChain
 from app.chain.tmdb import TmdbChain
 from app.core.config import settings, global_vars
 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.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
@@ -25,14 +25,13 @@ from app.db.systemconfig_oper import SystemConfigOper
 from app.db.transferhistory_oper import TransferHistoryOper
 from app.helper.directory import DirectoryHelper
 from app.helper.format import FormatParser
-from app.helper.memory import memory_optimized
 from app.helper.progress import ProgressHelper
 from app.log import logger
+from app.schemas import StorageOperSelectionEventData
 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, ChainEventType, ContentType
-from app.schemas import StorageOperSelectionEventData
 from app.utils.singleton import Singleton
 from app.utils.string import StringUtils
 
@@ -213,6 +212,7 @@ class JobManager:
                                 set(self._season_episodes[mediaid]) - set(task.meta.episode_list)
                             )
                         return task
+            return None
 
     def remove_job(self, task: TransferTask) -> Optional[TransferJob]:
         """
@@ -226,6 +226,7 @@ class JobManager:
                 if __mediaid__ in self._season_episodes:
                     self._season_episodes.pop(__mediaid__)
                 return self._job_view.pop(__mediaid__)
+            return None
 
     def is_done(self, task: TransferTask) -> bool:
         """
@@ -311,7 +312,7 @@ class JobManager:
 
     def count(self, media: MediaInfo, season: Optional[int] = None) -> int:
         """
-        获取某项任务总数
+        获取某项任务成功总数
         """
         __mediaid__ = self.__get_media_id(media=media, season=season)
         with job_lock:
@@ -322,7 +323,7 @@ class JobManager:
 
     def size(self, media: MediaInfo, season: Optional[int] = None) -> int:
         """
-        获取某项任务总大小
+        获取某项任务成功文件总大小
         """
         __mediaid__ = self.__get_media_id(media=media, season=season)
         with job_lock:
@@ -359,22 +360,20 @@ class TransferChain(ChainBase, metaclass=Singleton):
     文件整理处理链
     """
 
-    # 可处理的文件后缀
-    all_exts = settings.RMT_MEDIAEXT
-
-    # 待整理任务队列
-    _queue = Queue()
-
-    # 文件整理线程
-    _transfer_thread = None
-
-    # 队列间隔时间（秒）
-    _transfer_interval = 15
-
     def __init__(self):
         super().__init__()
+        # 可处理的文件后缀
+        self.all_exts = settings.RMT_MEDIAEXT
+        # 待整理任务队列
+        self._queue = queue.Queue()
+        # 文件整理线程
+        self._transfer_thread = None
+        # 队列间隔时间（秒）
+        self._transfer_interval = 15
+        # 事件管理器
         self.jobview = JobManager()
-
+        # 车移成功的文件清单
+        self._success_target_files: Dict[str, List[str]] = {}
         # 启动整理任务
         self.__init()
 
@@ -391,6 +390,44 @@ class TransferChain(ChainBase, metaclass=Singleton):
         """
         整理完成后处理
         """
+
+        def __do_finished():
+            """
+            完成时发送消息、刮削事件、移除任务等
+            """
+            # 更新文件数量
+            transferinfo.file_count = self.jobview.count(task.mediainfo, task.meta.begin_season) or 1
+            # 更新文件大小
+            transferinfo.total_size = self.jobview.size(task.mediainfo,
+                                                        task.meta.begin_season) or task.fileitem.size
+            # 更新文件清单
+            transferinfo.file_list_new = self._success_target_files.pop(transferinfo.target_diritem.path, [])
+            # 发送通知，实时手动整理时不发
+            if transferinfo.need_notify and (task.background or not task.manual):
+                se_str = None
+                if task.mediainfo.type == MediaType.TV:
+                    season_episodes = self.jobview.season_episodes(task.mediainfo, task.meta.begin_season)
+                    if season_episodes:
+                        se_str = f"{task.meta.season} {StringUtils.format_ep(season_episodes)}"
+                    else:
+                        se_str = f"{task.meta.season}"
+                self.send_transfer_message(meta=task.meta,
+                                           mediainfo=task.mediainfo,
+                                           transferinfo=transferinfo,
+                                           season_episode=se_str,
+                                           username=task.username)
+            # 刮削事件
+            if transferinfo.need_scrape:
+                self.eventmanager.send_event(EventType.MetadataScrape, {
+                    'meta': task.meta,
+                    'mediainfo': task.mediainfo,
+                    'fileitem': transferinfo.target_diritem,
+                    'file_list': transferinfo.file_list_new,
+                    'overwrite': False
+                })
+            # 移除已完成的任务
+            self.jobview.remove_job(task)
+
         transferhis = TransferHistoryOper()
         if not transferinfo.success:
             # 转移失败
@@ -416,6 +453,10 @@ class TransferChain(ChainBase, metaclass=Singleton):
             ))
             # 整理失败
             self.jobview.fail_task(task)
+            with task_lock:
+                # 整理完成且有成功的任务时
+                if self.jobview.is_finished(task):
+                    __do_finished()
             return False, transferinfo.message
 
         # 转移成功
@@ -444,55 +485,57 @@ class TransferChain(ChainBase, metaclass=Singleton):
         })
 
         with task_lock:
+            # 登记转移成功文件清单
+            target_dir_path = transferinfo.target_diritem.path
+            target_files = transferinfo.file_list_new
+            if self._success_target_files.get(target_dir_path):
+                self._success_target_files[target_dir_path].extend(target_files)
+            else:
+                self._success_target_files[target_dir_path] = target_files
             # 全部整理成功时
             if self.jobview.is_success(task):
                 # 移动模式删除空目录
                 if transferinfo.transfer_type in ["move"]:
                     # 所有成功的业务
                     tasks = self.jobview.success_tasks(task.mediainfo, task.meta.begin_season)
-                    # 记录已处理的种子hash
-                    processed_hashes = set()
                     storagechain = StorageChain()
+                    downloadhistoryoper = DownloadHistoryOper()
                     for t in tasks:
                         # 下载器hash
-                        if t.download_hash and t.download_hash not in processed_hashes:
-                            processed_hashes.add(t.download_hash)
-                            if self.remove_torrents(t.download_hash, downloader=t.downloader):
-                                logger.info(f"移动模式删除种子成功：{t.download_hash} ")
-                        # 删除残留目录
-                        if t.fileitem:
-                            storagechain.delete_media_file(t.fileitem, delete_self=False)
+                        if not t.download_hash:
+                            continue
+                        # 获取种子保存目录
+                        seed_dir_path = self.__get_torrent_save_path(download_hash=t.download_hash,
+                                                                     downloader=t.downloader)
+                        if not seed_dir_path:
+                            # 如果无法从下载器获取，则尝试从历史记录获取
+                            download_history = downloadhistoryoper.get_by_hash(t.download_hash)
+                            if download_history and download_history.path:
+                                seed_dir_path = download_history.path
+                            else:
+                                logger.warn(f"无法获取种子 {t.download_hash} 的保存路径")
+                                continue
+
+                        # 检查种子目录下是否还有有效媒体文件
+                        seed_dir_item = storagechain.get_file_item(storage=t.fileitem.storage,
+                                                                   path=Path(seed_dir_path))
+                        if seed_dir_item and seed_dir_item.type == "dir":
+                            remain_files = storagechain.list_files(seed_dir_item, recursion=True)
+                            has_media = any(
+                                f.extension and f.extension.lower() in [ext.lstrip('.') for ext in self.all_exts]
+                                for f in remain_files if f.type == "file"
+                            )
+                            if not has_media:
+                                if self.remove_torrents(t.download_hash, downloader=t.downloader):
+                                    logger.info(f"移动模式删除种子成功：{t.download_hash} ")
+                                # 删除残留目录
+                                storagechain.delete_media_file(seed_dir_item, delete_self=False)
+                            else:
+                                logger.info(
+                                    f"种子目录 {seed_dir_path} 还有未整理的媒体文件，暂不删除种子和残留目录")
             # 整理完成且有成功的任务时
             if self.jobview.is_finished(task):
-                # 发送通知，实时手动整理时不发
-                if transferinfo.need_notify and (task.background or not task.manual):
-                    se_str = None
-                    if task.mediainfo.type == MediaType.TV:
-                        season_episodes = self.jobview.season_episodes(task.mediainfo, task.meta.begin_season)
-                        if season_episodes:
-                            se_str = f"{task.meta.season} {StringUtils.format_ep(season_episodes)}"
-                        else:
-                            se_str = f"{task.meta.season}"
-                    # 更新文件数量
-                    transferinfo.file_count = self.jobview.count(task.mediainfo, task.meta.begin_season) or 1
-                    # 更新文件大小
-                    transferinfo.total_size = self.jobview.size(task.mediainfo,
-                                                                task.meta.begin_season) or task.fileitem.size
-                    self.send_transfer_message(meta=task.meta,
-                                               mediainfo=task.mediainfo,
-                                               transferinfo=transferinfo,
-                                               season_episode=se_str,
-                                               username=task.username)
-                # 刮削事件
-                if transferinfo.need_scrape:
-                    self.eventmanager.send_event(EventType.MetadataScrape, {
-                        'meta': task.meta,
-                        'mediainfo': task.mediainfo,
-                        'fileitem': transferinfo.target_diritem
-                    })
-
-                # 移除已完成的任务
-                self.jobview.remove_job(task)
+                __do_finished()
 
         return True, ""
 
@@ -789,6 +832,7 @@ class TransferChain(ChainBase, metaclass=Singleton):
                        for dir_info in download_dirs):
                 return True
             logger.info("开始整理下载器中已经完成下载的文件 ...")
+
             # 从下载器获取种子列表
             torrents: Optional[List[TransferTorrent]] = self.list_torrents(status=TorrentStatus.TRANSFER)
             if not torrents:
@@ -797,70 +841,78 @@ class TransferChain(ChainBase, metaclass=Singleton):
 
             logger.info(f"获取到 {len(torrents)} 个已完成的下载任务")
 
-            for torrent in torrents:
-                if global_vars.is_system_stopped:
-                    break
-                # 文件路径
-                file_path = torrent.path
-                if not file_path.exists():
-                    logger.warn(f"文件不存在：{file_path}")
-                    continue
-                # 检查是否为下载器监控目录中的文件
-                is_downloader_monitor = False
-                for dir_info in download_dirs:
-                    if dir_info.monitor_type != "downloader":
-                        continue
-                    if not dir_info.download_path:
-                        continue
-                    if file_path.is_relative_to(Path(dir_info.download_path)):
-                        is_downloader_monitor = True
+            try:
+                for torrent in torrents:
+                    if global_vars.is_system_stopped:
                         break
-                if not is_downloader_monitor:
-                    logger.debug(f"文件 {file_path} 不在下载器监控目录中，不通过下载器进行整理")
-                    continue
-                # 查询下载记录识别情况
-                downloadhis: DownloadHistory = DownloadHistoryOper().get_by_hash(torrent.hash)
-                if downloadhis:
-                    # 类型
-                    try:
-                        mtype = MediaType(downloadhis.type)
-                    except ValueError:
-                        mtype = MediaType.TV
-                    # 按TMDBID识别
-                    mediainfo = self.recognize_media(mtype=mtype,
-                                                     tmdbid=downloadhis.tmdbid,
-                                                     doubanid=downloadhis.doubanid,
-                                                     episode_group=downloadhis.episode_group)
-                    if mediainfo:
-                        # 补充图片
-                        self.obtain_images(mediainfo)
-                        # 更新自定义媒体类别
-                        if downloadhis.media_category:
-                            mediainfo.category = downloadhis.media_category
-                else:
-                    # 非MoviePilot下载的任务，按文件识别
-                    mediainfo = None
+                    # 文件路径
+                    file_path = torrent.path
+                    if not file_path.exists():
+                        logger.warn(f"文件不存在：{file_path}")
+                        continue
+                    # 检查是否为下载器监控目录中的文件
+                    is_downloader_monitor = False
+                    for dir_info in download_dirs:
+                        if dir_info.monitor_type != "downloader":
+                            continue
+                        if not dir_info.download_path:
+                            continue
+                        if file_path.is_relative_to(Path(dir_info.download_path)):
+                            is_downloader_monitor = True
+                            break
+                    if not is_downloader_monitor:
+                        logger.debug(f"文件 {file_path} 不在下载器监控目录中，不通过下载器进行整理")
+                        continue
+                    # 查询下载记录识别情况
+                    downloadhis: DownloadHistory = DownloadHistoryOper().get_by_hash(torrent.hash)
+                    if downloadhis:
+                        # 类型
+                        try:
+                            mtype = MediaType(downloadhis.type)
+                        except ValueError:
+                            mtype = MediaType.TV
+                        # 按TMDBID识别
+                        mediainfo = self.recognize_media(mtype=mtype,
+                                                         tmdbid=downloadhis.tmdbid,
+                                                         doubanid=downloadhis.doubanid,
+                                                         episode_group=downloadhis.episode_group)
+                        if mediainfo:
+                            # 补充图片
+                            self.obtain_images(mediainfo)
+                            # 更新自定义媒体类别
+                            if downloadhis.media_category:
+                                mediainfo.category = downloadhis.media_category
+                    else:
+                        # 非MoviePilot下载的任务，按文件识别
+                        mediainfo = None
 
-                # 执行实时整理，匹配源目录
-                state, errmsg = self.do_transfer(
-                    fileitem=FileItem(
-                        storage="local",
-                        path=str(file_path).replace("\\", "/"),
-                        type="dir" if not file_path.is_file() else "file",
-                        name=file_path.name,
-                        size=file_path.stat().st_size,
-                        extension=file_path.suffix.lstrip('.'),
-                    ),
-                    mediainfo=mediainfo,
-                    downloader=torrent.downloader,
-                    download_hash=torrent.hash,
-                    background=False,
-                )
+                    # 执行实时整理，匹配源目录
+                    state, errmsg = self.do_transfer(
+                        fileitem=FileItem(
+                            storage="local",
+                            path=str(file_path).replace("\\", "/"),
+                            type="dir" if not file_path.is_file() else "file",
+                            name=file_path.name,
+                            size=file_path.stat().st_size,
+                            extension=file_path.suffix.lstrip('.'),
+                        ),
+                        mediainfo=mediainfo,
+                        downloader=torrent.downloader,
+                        download_hash=torrent.hash,
+                        background=False,
+                    )
 
-                # 设置下载任务状态
-                if not state:
-                    logger.warn(f"整理下载器任务失败：{torrent.hash} - {errmsg}")
-                self.transfer_completed(hashs=torrent.hash, downloader=torrent.downloader)
+                    # 设置下载任务状态
+                    if not state:
+                        logger.warn(f"整理下载器任务失败：{torrent.hash} - {errmsg}")
+                    self.transfer_completed(hashs=torrent.hash, downloader=torrent.downloader)
+            finally:
+                torrents.clear()
+                del torrents
+
+            # 如果不是大内存模式，进行垃圾回收
+            if not settings.BIG_MEMORY_MODE:
+                gc.collect()
 
             # 结束
             logger.info("所有下载器中下载完成的文件已整理完成")
@@ -871,7 +923,7 @@ class TransferChain(ChainBase, metaclass=Singleton):
     ) -> List[Tuple[FileItem, bool]]:
         """
         获取整理目录或文件列表
-        
+
         :param fileitem: 文件项
         :param depth: 递归深度，默认为1
         """
@@ -938,7 +990,6 @@ class TransferChain(ChainBase, metaclass=Singleton):
 
         return trans_items
 
-    @memory_optimized(force_gc_after=True, log_memory=True)
     def do_transfer(self, fileitem: FileItem,
                     meta: MetaBase = None, mediainfo: MediaInfo = None,
                     target_directory: TransferDirectoryConf = None,
@@ -1034,111 +1085,116 @@ class TransferChain(ChainBase, metaclass=Singleton):
 
         # 整理所有文件
         transfer_tasks: List[TransferTask] = []
-        for file_item, bluray_dir in file_items:
-            if global_vars.is_system_stopped:
-                break
-            if continue_callback and not continue_callback():
-                break
-            file_path = Path(file_item.path)
-            # 回收站及隐藏的文件不处理
-            if file_item.path.find('/@Recycle/') != -1 \
-                    or file_item.path.find('/#recycle/') != -1 \
-                    or file_item.path.find('/.') != -1 \
-                    or file_item.path.find('/@eaDir') != -1:
-                logger.debug(f"{file_item.path} 是回收站或隐藏的文件")
-                continue
-
-            # 整理屏蔽词不处理
-            is_blocked = False
-            if transfer_exclude_words:
-                for keyword in transfer_exclude_words:
-                    if not keyword:
-                        continue
-                    if keyword and re.search(r"%s" % keyword, file_item.path, re.IGNORECASE):
-                        logger.info(f"{file_item.path} 命中整理屏蔽词 {keyword}，不处理")
-                        is_blocked = True
-                        break
-            if is_blocked:
-                continue
-
-            # 整理成功的不再处理
-            if not force:
-                transferd = TransferHistoryOper().get_by_src(file_item.path, storage=file_item.storage)
-                if transferd:
-                    if not transferd.status:
-                        all_success = False
-                    logger.info(f"{file_item.path} 已整理过，如需重新处理，请删除整理记录。")
-                    err_msgs.append(f"{file_item.name} 已整理过")
+        try:
+            for file_item, bluray_dir in file_items:
+                if global_vars.is_system_stopped:
+                    break
+                if continue_callback and not continue_callback():
+                    break
+                file_path = Path(file_item.path)
+                # 回收站及隐藏的文件不处理
+                if file_item.path.find('/@Recycle/') != -1 \
+                        or file_item.path.find('/#recycle/') != -1 \
+                        or file_item.path.find('/.') != -1 \
+                        or file_item.path.find('/@eaDir') != -1:
+                    logger.debug(f"{file_item.path} 是回收站或隐藏的文件")
                     continue
 
-            if not meta:
-                # 文件元数据
-                file_meta = MetaInfoPath(file_path)
-            else:
-                file_meta = meta
+                # 整理屏蔽词不处理
+                is_blocked = False
+                if transfer_exclude_words:
+                    for keyword in transfer_exclude_words:
+                        if not keyword:
+                            continue
+                        if keyword and re.search(r"%s" % keyword, file_item.path, re.IGNORECASE):
+                            logger.info(f"{file_item.path} 命中整理屏蔽词 {keyword}，不处理")
+                            is_blocked = True
+                            break
+                if is_blocked:
+                    continue
 
-            # 合并季
-            if season is not None:
-                file_meta.begin_season = season
+                # 整理成功的不再处理
+                if not force:
+                    transferd = TransferHistoryOper().get_by_src(file_item.path, storage=file_item.storage)
+                    if transferd:
+                        if not transferd.status:
+                            all_success = False
+                        logger.info(f"{file_item.path} 已整理过，如需重新处理，请删除整理记录。")
+                        err_msgs.append(f"{file_item.name} 已整理过")
+                        continue
 
-            if not file_meta:
-                all_success = False
-                logger.error(f"{file_path.name} 无法识别有效信息")
-                err_msgs.append(f"{file_path.name} 无法识别有效信息")
-                continue
+                if not meta:
+                    # 文件元数据
+                    file_meta = MetaInfoPath(file_path)
+                else:
+                    file_meta = meta
 
-            # 自定义识别
-            if formaterHandler:
-                # 开始集、结束集、PART
-                begin_ep, end_ep, part = formaterHandler.split_episode(file_name=file_path.name, file_meta=file_meta)
-                if begin_ep is not None:
-                    file_meta.begin_episode = begin_ep
-                    file_meta.part = part
-                if end_ep is not None:
-                    file_meta.end_episode = end_ep
+                # 合并季
+                if season is not None:
+                    file_meta.begin_season = season
 
-            # 根据父路径获取下载历史
-            download_history = None
-            downloadhis = DownloadHistoryOper()
-            if bluray_dir:
-                # 蓝光原盘，按目录名查询
-                download_history = downloadhis.get_by_path(str(file_path))
-            else:
-                # 按文件全路径查询
-                download_file = downloadhis.get_file_by_fullpath(str(file_path))
-                if download_file:
-                    download_history = downloadhis.get_by_hash(download_file.download_hash)
+                if not file_meta:
+                    all_success = False
+                    logger.error(f"{file_path.name} 无法识别有效信息")
+                    err_msgs.append(f"{file_path.name} 无法识别有效信息")
+                    continue
 
-            # 获取下载Hash
-            if download_history and (not downloader or not download_hash):
-                downloader = download_history.downloader
-                download_hash = download_history.download_hash
+                # 自定义识别
+                if formaterHandler:
+                    # 开始集、结束集、PART
+                    begin_ep, end_ep, part = formaterHandler.split_episode(file_name=file_path.name,
+                                                                           file_meta=file_meta)
+                    if begin_ep is not None:
+                        file_meta.begin_episode = begin_ep
+                        file_meta.part = part
+                    if end_ep is not None:
+                        file_meta.end_episode = end_ep
 
-            # 后台整理
-            transfer_task = TransferTask(
-                fileitem=file_item,
-                meta=file_meta,
-                mediainfo=mediainfo,
-                target_directory=target_directory,
-                target_storage=target_storage,
-                target_path=target_path,
-                transfer_type=transfer_type,
-                scrape=scrape,
-                library_type_folder=library_type_folder,
-                library_category_folder=library_category_folder,
-                downloader=downloader,
-                download_hash=download_hash,
-                download_history=download_history,
-                manual=manual,
-                background=background
-            )
-            if background:
-                self.put_to_queue(task=transfer_task)
-                logger.info(f"{file_path.name} 已添加到整理队列")
-            else:
-                # 加入列表
-                self.__put_to_jobview(transfer_task)
-                transfer_tasks.append(transfer_task)
+                # 根据父路径获取下载历史
+                download_history = None
+                downloadhis = DownloadHistoryOper()
+                if bluray_dir:
+                    # 蓝光原盘，按目录名查询
+                    download_history = downloadhis.get_by_path(str(file_path))
+                else:
+                    # 按文件全路径查询
+                    download_file = downloadhis.get_file_by_fullpath(str(file_path))
+                    if download_file:
+                        download_history = downloadhis.get_by_hash(download_file.download_hash)
+
+                # 获取下载Hash
+                if download_history and (not downloader or not download_hash):
+                    downloader = download_history.downloader
+                    download_hash = download_history.download_hash
+
+                # 后台整理
+                transfer_task = TransferTask(
+                    fileitem=file_item,
+                    meta=file_meta,
+                    mediainfo=mediainfo,
+                    target_directory=target_directory,
+                    target_storage=target_storage,
+                    target_path=target_path,
+                    transfer_type=transfer_type,
+                    scrape=scrape,
+                    library_type_folder=library_type_folder,
+                    library_category_folder=library_category_folder,
+                    downloader=downloader,
+                    download_hash=download_hash,
+                    download_history=download_history,
+                    manual=manual,
+                    background=background
+                )
+                if background:
+                    self.put_to_queue(task=transfer_task)
+                    logger.info(f"{file_path.name} 已添加到整理队列")
+                else:
+                    # 加入列表
+                    self.__put_to_jobview(transfer_task)
+                    transfer_tasks.append(transfer_task)
+        finally:
+            file_items.clear()
+            del file_items
 
         # 实时整理
         if transfer_tasks:
@@ -1157,29 +1213,32 @@ class TransferChain(ChainBase, metaclass=Singleton):
             progress.update(value=0,
                             text=__process_msg,
                             key=ProgressKey.FileTransfer)
-
-            for transfer_task in transfer_tasks:
-                if global_vars.is_system_stopped:
-                    break
-                if continue_callback and not continue_callback():
-                    break
-                # 更新进度
-                __process_msg = f"正在整理 （{processed_num + fail_num + 1}/{total_num}）{transfer_task.fileitem.name} ..."
-                logger.info(__process_msg)
-                progress.update(value=(processed_num + fail_num) / total_num * 100,
-                                text=__process_msg,
-                                key=ProgressKey.FileTransfer)
-                state, err_msg = self.__handle_transfer(
-                    task=transfer_task,
-                    callback=self.__default_callback
-                )
-                if not state:
-                    all_success = False
-                    logger.warn(f"{transfer_task.fileitem.name} {err_msg}")
-                    err_msgs.append(f"{transfer_task.fileitem.name} {err_msg}")
-                    fail_num += 1
-                else:
-                    processed_num += 1
+            try:
+                for transfer_task in transfer_tasks:
+                    if global_vars.is_system_stopped:
+                        break
+                    if continue_callback and not continue_callback():
+                        break
+                    # 更新进度
+                    __process_msg = f"正在整理 （{processed_num + fail_num + 1}/{total_num}）{transfer_task.fileitem.name} ..."
+                    logger.info(__process_msg)
+                    progress.update(value=(processed_num + fail_num) / total_num * 100,
+                                    text=__process_msg,
+                                    key=ProgressKey.FileTransfer)
+                    state, err_msg = self.__handle_transfer(
+                        task=transfer_task,
+                        callback=self.__default_callback
+                    )
+                    if not state:
+                        all_success = False
+                        logger.warn(f"{transfer_task.fileitem.name} {err_msg}")
+                        err_msgs.append(f"{transfer_task.fileitem.name} {err_msg}")
+                        fail_num += 1
+                    else:
+                        processed_num += 1
+            finally:
+                transfer_tasks.clear()
+                del transfer_tasks
 
             # 整理结束
             __end_msg = f"整理队列处理完成，共整理 {total_num} 个文件，失败 {fail_num} 个"
@@ -1189,7 +1248,8 @@ class TransferChain(ChainBase, metaclass=Singleton):
                             key=ProgressKey.FileTransfer)
             progress.end(ProgressKey.FileTransfer)
 
-        return all_success, "，".join(err_msgs)
+        error_msg = "、".join(err_msgs[:2]) + (f"，等{len(err_msgs)}个文件错误！" if len(err_msgs) > 2 else "")
+        return all_success, error_msg
 
     def remote_transfer(self, arg_str: str, channel: MessageChannel,
                         userid: Union[str, int] = None, source: Optional[str] = None):
@@ -1396,3 +1456,20 @@ class TransferChain(ChainBase, metaclass=Singleton):
             season_episode=season_episode,
             username=username
         )
+
+    def __get_torrent_save_path(self, download_hash: str, downloader: str) -> Optional[str]:
+        """
+        从下载器获取种子的保存路径
+        :param download_hash: 种子Hash
+        :param downloader: 下载器名称
+        :return: 种子保存路径，如果获取失败返回None
+        """
+        try:
+            # 通过下载器获取种子信息
+            torrents = self.list_torrents(hashs=download_hash, downloader=downloader)
+            if not torrents:
+                return None
+            return torrents[0].path
+        except Exception as e:
+            logger.error(f"获取种子 {download_hash} 保存路径失败：{e}")
+            return None

app/command.py

@@ -9,7 +9,6 @@ from app.chain.site import SiteChain
 from app.chain.subscribe import SubscribeChain
 from app.chain.system import SystemChain
 from app.chain.transfer import TransferChain
-from app.core.config import settings
 from app.core.event import Event as ManagerEvent, eventmanager, Event
 from app.core.plugin import PluginManager
 from app.helper.message import MessageHelper
@@ -162,10 +161,6 @@ class Command(metaclass=Singleton):
         """
         初始化菜单命令
         """
-        if settings.DEV:
-            logger.debug("Development mode active. Skipping command initialization.")
-            return
-
         # 使用线程池提交后台任务，避免引起阻塞
         ThreadHelper().submit(self.__init_commands_background, pid)
 
@@ -230,6 +225,9 @@ class Command(metaclass=Singleton):
             添加命令集合
             """
             for cmd, command in source.items():
+                if not command.get("show", True):
+                    continue
+
                 command_data = {
                     "type": command_type,
                     "description": command.get("description"),
@@ -266,6 +264,7 @@ class Command(metaclass=Singleton):
                     "func": self.send_plugin_event,
                     "description": command.get("desc"),
                     "category": command.get("category"),
+                    "show": command.get("show", True),
                     "data": {
                         "etype": command.get("event"),
                         "data": command.get("data")
@@ -340,7 +339,8 @@ class Command(metaclass=Singleton):
         return self._commands.get(cmd, {})
 
     def register(self, cmd: str, func: Any, data: Optional[dict] = None,
-                 desc: Optional[str] = None, category: Optional[str] = None) -> None:
+                 desc: Optional[str] = None, category: Optional[str] = None,
+                 show: bool = True) -> None:
         """
         注册单个命令
         """
@@ -349,7 +349,8 @@ class Command(metaclass=Singleton):
             "func": func,
             "description": desc,
             "category": category,
-            "data": data or {}
+            "data": data or {},
+            "show": show
         }
 
     def execute(self, cmd: str, data_str: Optional[str] = "",

app/core/cache.py

@@ -131,7 +131,7 @@ class CacheToolsBackend(CacheBackend):
     - 不支持按 `key` 独立隔离 TTL 和 Maxsize，仅支持作用于 region 级别
     """
 
-    def __init__(self, maxsize: Optional[int] = 1000, ttl: Optional[int] = 1800):
+    def __init__(self, maxsize: Optional[int] = 512, ttl: Optional[int] = 1800):
         """
         初始化缓存实例
 
@@ -150,7 +150,7 @@ class CacheToolsBackend(CacheBackend):
         region = self.get_region(region)
         return self._region_caches.get(region)
 
-    def set(self, key: str, value: Any, ttl: Optional[int] = None, 
+    def set(self, key: str, value: Any, ttl: Optional[int] = None,
             region: Optional[str] = DEFAULT_CACHE_REGION, **kwargs) -> None:
         """
         设置缓存值支持每个 key 独立配置 TTL 和 Maxsize
@@ -196,7 +196,7 @@ class CacheToolsBackend(CacheBackend):
             return None
         return region_cache.get(key)
 
-    def delete(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> None:
+    def delete(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION):
         """
         删除缓存
 
@@ -205,7 +205,7 @@ class CacheToolsBackend(CacheBackend):
         """
         region_cache = self.__get_region_cache(region)
         if region_cache is None:
-            return None
+            return
         with lock:
             del region_cache[key]
 
@@ -357,7 +357,7 @@ class RedisBackend(CacheBackend):
         region = self.get_region(quote(region))
         return f"{region}:key:{quote(key)}"
 
-    def set(self, key: str, value: Any, ttl: Optional[int] = None, 
+    def set(self, key: str, value: Any, ttl: Optional[int] = None,
             region: Optional[str] = DEFAULT_CACHE_REGION, **kwargs) -> None:
         """
         设置缓存
@@ -454,7 +454,7 @@ class RedisBackend(CacheBackend):
             self.client.close()
 
 
-def get_cache_backend(maxsize: Optional[int] = 1000, ttl: Optional[int] = 1800) -> CacheBackend:
+def get_cache_backend(maxsize: Optional[int] = 512, ttl: Optional[int] = 1800) -> CacheBackend:
     """
     根据配置获取缓存后端实例
 
@@ -482,13 +482,13 @@ def get_cache_backend(maxsize: Optional[int] = 1000, ttl: Optional[int] = 1800)
     return CacheToolsBackend(maxsize=maxsize, ttl=ttl)
 
 
-def cached(region: Optional[str] = None, maxsize: Optional[int] = 1000, ttl: Optional[int] = 1800,
+def cached(region: Optional[str] = None, maxsize: Optional[int] = 512, ttl: Optional[int] = 1800,
            skip_none: Optional[bool] = True, skip_empty: Optional[bool] = False):
     """
     自定义缓存装饰器，支持为每个 key 动态传递 maxsize 和 ttl
 
     :param region: 缓存的区
-    :param maxsize: 缓存的最大条目数，默认值为 1000
+    :param maxsize: 缓存的最大条目数，默认值为 512
     :param ttl: 缓存的存活时间，单位秒，默认值为 1800
     :param skip_none: 跳过 None 缓存，默认为 True
     :param skip_empty: 跳过空值缓存（如 None, [], {}, "", set()），默认为 False

app/core/config.py

@@ -1,6 +1,8 @@
 import copy
 import json
 import os
+import platform
+import re
 import secrets
 import sys
 import threading
@@ -11,8 +13,38 @@ from dotenv import set_key
 from pydantic import BaseModel, BaseSettings, validator, Field
 
 from app.log import logger, log_settings, LogConfigModel
+from app.schemas import MediaType
 from app.utils.system import SystemUtils
 from app.utils.url import UrlUtils
+from version import APP_VERSION
+
+
+class SystemConfModel(BaseModel):
+    """
+    系统关键资源大小配置
+    """
+    # 缓存种子数量
+    torrents: int = 0
+    # 订阅刷新处理数量
+    refresh: int = 0
+    # TMDB请求缓存数量
+    tmdb: int = 0
+    # 豆瓣请求缓存数量
+    douban: int = 0
+    # Bangumi请求缓存数量
+    bangumi: int = 0
+    # Fanart请求缓存数量
+    fanart: int = 0
+    # 元数据缓存过期时间（秒）
+    meta: int = 0
+    # 调度器数量
+    scheduler: int = 0
+    # 线程池大小
+    threadpool: int = 0
+    # 数据库连接池大小
+    dbpool: int = 0
+    # 数据库连接池溢出数量
+    dbpooloverflow: int = 0
 
 
 class ConfigModel(BaseModel):
@@ -57,20 +89,16 @@ class ConfigModel(BaseModel):
     DB_ECHO: bool = False
     # 数据库连接池类型，QueuePool, NullPool
     DB_POOL_TYPE: str = "QueuePool"
-    # 是否在获取连接时进行预先 ping 操作，默认关闭
-    DB_POOL_PRE_PING: bool = False
-    # 数据库连接池的大小，默认 100
-    DB_POOL_SIZE: int = 100
-    # 数据库连接的回收时间（秒），默认 1800 秒
-    DB_POOL_RECYCLE: int = 1800
-    # 数据库连接池获取连接的超时时间（秒），默认 60 秒
-    DB_POOL_TIMEOUT: int = 60
-    # 数据库连接池最大溢出连接数，默认 500
-    DB_MAX_OVERFLOW: int = 500
+    # 是否在获取连接时进行预先 ping 操作
+    DB_POOL_PRE_PING: bool = True
+    # 数据库连接的回收时间（秒）
+    DB_POOL_RECYCLE: int = 300
+    # 数据库连接池获取连接的超时时间（秒）
+    DB_POOL_TIMEOUT: int = 30
     # SQLite 的 busy_timeout 参数，默认为 60 秒
     DB_TIMEOUT: int = 60
-    # SQLite 是否启用 WAL 模式，默认关闭
-    DB_WAL_ENABLE: bool = False
+    # SQLite 是否启用 WAL 模式，默认开启
+    DB_WAL_ENABLE: bool = True
     # 缓存类型，支持 cachetools 和 redis，默认使用 cachetools
     CACHE_BACKEND_TYPE: str = "cachetools"
     # 缓存连接字符串，仅外部缓存（如 Redis、Memcached）需要
@@ -114,6 +142,8 @@ class ConfigModel(BaseModel):
     TVDB_V4_API_PIN: str = ""
     # Fanart开关
     FANART_ENABLE: bool = True
+    # Fanart语言
+    FANART_LANG: str = "zh,en"
     # Fanart API Key
     FANART_API_KEY: str = "d2d31f9ecabea050fc7d68aa3146015f"
     # 115 AppId
@@ -123,7 +153,7 @@ class ConfigModel(BaseModel):
     # 元数据识别缓存过期时间（小时）
     META_CACHE_EXPIRE: int = 0
     # 电视剧动漫的分类genre_ids
-    ANIME_GENREIDS: List[int] = [16]
+    ANIME_GENREIDS: List[int] = Field(default=[16])
     # 用户认证站点
     AUTH_SITE: str = ""
     # 重启自动升级
@@ -139,6 +169,7 @@ class ConfigModel(BaseModel):
                         "api.github.com,"
                         "github.com,"
                         "raw.githubusercontent.com,"
+                        "codeload.github.com,"
                         "api.telegram.org")
     # DOH 解析服务器列表
     DOH_RESOLVERS: str = "1.0.0.1,1.1.1.1,9.9.9.9,149.112.112.112"
@@ -184,6 +215,8 @@ class ConfigModel(BaseModel):
     SITEDATA_REFRESH_INTERVAL: int = 6
     # 读取和发送站点消息
     SITE_MESSAGE: bool = True
+    # 不能缓存站点资源的站点域名，多个使用,分隔
+    NO_CACHE_SITE_KEY: str = "m-team"
     # 种子标签
     TORRENT_TAG: str = "MOVIEPILOT"
     # 下载站点字幕
@@ -202,8 +235,6 @@ class ConfigModel(BaseModel):
     COOKIECLOUD_INTERVAL: Optional[int] = 60 * 24
     # CookieCloud同步黑名单，多个域名,分割
     COOKIECLOUD_BLACKLIST: Optional[str] = None
-    # CookieCloud对应的浏览器UA
-    USER_AGENT: str = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36 Edg/113.0.1774.57"
     # 电影重命名格式
     MOVIE_RENAME_FORMAT: str = "{{title}}{% if year %} ({{year}}){% endif %}" \
                                "/{{title}}{% if year %} ({{year}}){% endif %}{% if part %}-{{part}}{% endif %}{% if videoFormat %} - {{videoFormat}}{% endif %}" \
@@ -241,7 +272,7 @@ class ConfigModel(BaseModel):
     GITHUB_TOKEN: Optional[str] = None
     # Github代理服务器，格式：https://mirror.ghproxy.com/
     GITHUB_PROXY: Optional[str] = ''
-    # pip镜像站点，格式：https://pypi.tuna.tsinghua.edu.cn/simple
+    # pip镜像站点，格式：https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
     PIP_PROXY: Optional[str] = ''
     # 指定的仓库Github token，多个仓库使用,分隔，格式：{user1}/{repo1}:ghp_****,{user2}/{repo2}:github_pat_****
     REPO_GITHUB_TOKEN: Optional[str] = None
@@ -274,14 +305,12 @@ class ConfigModel(BaseModel):
     SECURITY_IMAGE_SUFFIXES: list = Field(default=[".jpg", ".jpeg", ".png", ".webp", ".gif", ".svg", ".avif"])
     # 重命名时支持的S0别名
     RENAME_FORMAT_S0_NAMES: list = Field(default=["Specials", "SPs"])
-    # 启用分词搜索
-    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"
-    # 剧集交集最小置信度  计算后的交集比例( len(torrent_episodes ∩ need_episodes) / len(torrent_episodes) 低于这个阈值表明包含过多不需要的剧集
-    EPISODE_INTERSECTION_MIN_CONFIDENCE: float = 0.0
+    # 工作流数据共享
+    WORKFLOW_STATISTIC_SHARE: bool = True
 
 
 class Settings(BaseSettings, ConfigModel, LogConfigModel):
@@ -481,6 +510,20 @@ class Settings(BaseSettings, ConfigModel, LogConfigModel):
         """
         return "v2"
 
+    @property
+    def USER_AGENT(self) -> str:
+        """
+        全局用户代理字符串
+        """
+        return f"{self.PROJECT_NAME}/{APP_VERSION[1:]} ({platform.system()} {platform.release()}; {SystemUtils.cpu_arch()})"
+
+    @property
+    def NORMAL_USER_AGENT(self) -> str:
+        """
+        默认浏览器用户代理字符串
+        """
+        return "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36"
+
     @property
     def INNER_CONFIG_PATH(self):
         return self.ROOT_PATH / "config"
@@ -520,39 +563,37 @@ class Settings(BaseSettings, ConfigModel, LogConfigModel):
         return self.CONFIG_PATH / "cookies"
 
     @property
-    def CACHE_CONF(self):
+    def CONF(self) -> SystemConfModel:
         """
-        {
-            "torrents": "缓存种子数量",
-            "refresh": "订阅刷新处理数量",
-            "tmdb": "TMDB请求缓存数量",
-            "douban": "豆瓣请求缓存数量",
-            "fanart": "Fanart请求缓存数量",
-            "meta": "元数据缓存过期时间（秒）",
-            "memory": "最大占用内存（MB）"
-        }
+        根据内存模式返回系统配置
         """
         if self.BIG_MEMORY_MODE:
-            return {
-                "torrents": 200,
-                "refresh": 100,
-                "tmdb": 1024,
-                "douban": 512,
-                "bangumi": 512,
-                "fanart": 512,
-                "meta": (self.META_CACHE_EXPIRE or 24) * 3600,
-                "memory": 2 * 1024
-            }
-        return {
-            "torrents": 100,
-            "refresh": 50,
-            "tmdb": 256,
-            "douban": 256,
-            "bangumi": 256,
-            "fanart": 128,
-            "meta": (self.META_CACHE_EXPIRE or 2) * 3600,
-            "memory": 1024
-        }
+            return SystemConfModel(
+                torrents=200,
+                refresh=100,
+                tmdb=1024,
+                douban=512,
+                bangumi=512,
+                fanart=512,
+                meta=(self.META_CACHE_EXPIRE or 24) * 3600,
+                scheduler=100,
+                threadpool=100,
+                dbpool=100,
+                dbpooloverflow=50
+            )
+        return SystemConfModel(
+            torrents=100,
+            refresh=50,
+            tmdb=256,
+            douban=256,
+            bangumi=256,
+            fanart=128,
+            meta=(self.META_CACHE_EXPIRE or 2) * 3600,
+            scheduler=50,
+            threadpool=50,
+            dbpool=50,
+            dbpooloverflow=20
+        )
 
     @property
     def PROXY(self):
@@ -578,7 +619,8 @@ class Settings(BaseSettings, ConfigModel, LogConfigModel):
         """
         if self.GITHUB_TOKEN:
             return {
-                "Authorization": f"Bearer {self.GITHUB_TOKEN}"
+                "Authorization": f"Bearer {self.GITHUB_TOKEN}",
+                "User-Agent": self.NORMAL_USER_AGENT,
             }
         return {}
 
@@ -606,7 +648,8 @@ class Settings(BaseSettings, ConfigModel, LogConfigModel):
                     print(f"无效的令牌或仓库信息: {token_pair}")
                     continue
                 headers[repo_info] = {
-                    "Authorization": f"Bearer {token}"
+                    "Authorization": f"Bearer {token}",
+                    "User-Agent": self.NORMAL_USER_AGENT,
                 }
             except Exception as e:
                 print(f"处理令牌对 '{token_pair}' 时出错: {e}")
@@ -626,6 +669,23 @@ class Settings(BaseSettings, ConfigModel, LogConfigModel):
             return None
         return UrlUtils.combine_url(host=self.APP_DOMAIN, path=url)
 
+    def RENAME_FORMAT(self, media_type: MediaType):
+        """
+        获取指定类型的重命名格式
+
+        :param media_type: MediaType.TV 或 MediaType.Movie
+        :return: 重命名格式
+        """
+        rename_format = (
+            self.TV_RENAME_FORMAT
+            if media_type == MediaType.TV
+            else self.MOVIE_RENAME_FORMAT
+        )
+        # 规范重命名格式
+        rename_format = rename_format.replace("\\", "/")
+        rename_format = re.sub(r'/+', '/', rename_format)
+        return rename_format.strip("/")
+
 
 # 实例化配置
 settings = Settings()

app/core/context.py

@@ -193,7 +193,7 @@ class MediaInfo:
     # LOGO
     logo_path: str = None
     # 评分
-    vote_average: float = 0.0
+    vote_average: float = None
     # 描述
     overview: str = None
     # 风格ID
@@ -237,9 +237,9 @@ class MediaInfo:
     # 流媒体平台
     networks: list = field(default_factory=list)
     # 集数
-    number_of_episodes: int = 0
+    number_of_episodes: int = None
     # 季数
-    number_of_seasons: int = 0
+    number_of_seasons: int = None
     # 原产国
     origin_country: list = field(default_factory=list)
     # 原名
@@ -255,9 +255,9 @@ class MediaInfo:
     # 标签
     tagline: str = None
     # 评价数量
-    vote_count: int = 0
+    vote_count: int = None
     # 流行度
-    popularity: int = 0
+    popularity: int = None
     # 时长
     runtime: int = None
     # 下一集
@@ -474,7 +474,16 @@ class MediaInfo:
         self.names = info.get('names') or []
         # 剩余属性赋值
         for key, value in info.items():
-            if hasattr(self, key) and not getattr(self, key):
+            if not value:
+                continue
+            if not hasattr(self, key):
+                continue
+            current_value = getattr(self, key)
+            if current_value:
+                continue
+            if current_value is None:
+                setattr(self, key, value)
+            elif type(current_value) == type(value):
                 setattr(self, key, value)
 
     def set_douban_info(self, info: dict):
@@ -606,7 +615,16 @@ class MediaInfo:
             self.production_countries = [{"id": country, "name": country} for country in info.get("countries") or []]
         # 剩余属性赋值
         for key, value in info.items():
+            if not value:
+                continue
             if not hasattr(self, key):
+                continue
+            current_value = getattr(self, key)
+            if current_value:
+                continue
+            if current_value is None:
+                setattr(self, key, value)
+            elif type(current_value) == type(value):
                 setattr(self, key, value)
 
     def set_bangumi_info(self, info: dict):

app/core/event.py

@@ -6,7 +6,6 @@ import threading
 import time
 import traceback
 import uuid
-from functools import lru_cache
 from queue import Empty, PriorityQueue
 from typing import Callable, Dict, List, Optional, Union
 
@@ -70,9 +69,6 @@ class EventManager(metaclass=Singleton):
     EventManager 负责管理和调度广播事件和链式事件，包括订阅、发送和处理事件
     """
 
-    # 退出事件
-    __event = threading.Event()
-
     def __init__(self):
         self.__executor = ThreadHelper()  # 动态线程池，用于消费事件
         self.__consumer_threads = []  # 用于保存启动的事件消费者线程
@@ -82,6 +78,7 @@ class EventManager(metaclass=Singleton):
         self.__disabled_handlers = set()  # 禁用的事件处理器集合
         self.__disabled_classes = set()  # 禁用的事件处理器类集合
         self.__lock = threading.Lock()  # 线程锁
+        self.__event = threading.Event()  # 退出事件
 
     def start(self):
         """
@@ -263,7 +260,6 @@ class EventManager(metaclass=Singleton):
         return handler_info
 
     @classmethod
-    @lru_cache(maxsize=1000)
     def __get_handler_identifier(cls, target: Union[Callable, type]) -> Optional[str]:
         """
         获取处理器或处理器类的唯一标识符，包括模块名和类名/方法名
@@ -279,7 +275,6 @@ class EventManager(metaclass=Singleton):
         return f"{module_name}.{qualname}"
 
     @classmethod
-    @lru_cache(maxsize=1000)
     def __get_class_from_callable(cls, handler: Callable) -> Optional[str]:
         """
         获取可调用对象所属类的唯一标识符
@@ -456,6 +451,9 @@ class EventManager(metaclass=Singleton):
             elif class_name.endswith("Chain"):
                 module_name = f"app.chain.{class_name[:-5].lower()}"
                 module = importlib.import_module(module_name)
+            elif class_name.endswith("Helper"):
+                module_name = f"app.helper.{class_name[:-6].lower()}"
+                module = importlib.import_module(module_name)
             else:
                 module_name = f"app.{class_name.lower()}"
                 module = importlib.import_module(module_name)
@@ -465,7 +463,7 @@ class EventManager(metaclass=Singleton):
             else:
                 logger.debug(f"事件处理出错：模块 {module_name} 中没有找到类 {class_name}")
         except Exception as e:
-            logger.error(f"事件处理出错：{str(e)} - {traceback.format_exc()}")
+            logger.debug(f"事件处理出错：{str(e)} - {traceback.format_exc()}")
         return None
 
     def __broadcast_consumer_loop(self):

app/core/meta/customization.py

@@ -9,8 +9,6 @@ class CustomizationMatcher(metaclass=Singleton):
     """
     识别自定义占位符
     """
-    customization = None
-    custom_separator = None
 
     def __init__(self):
         self.systemconfig = SystemConfigOper()

app/core/meta/metabase.py

@@ -55,6 +55,8 @@ class MetaBase(object):
     resource_team: Optional[str] = None
     # 识别的自定义占位符
     customization: Optional[str] = None
+    # 识别的流媒体平台
+    web_source: Optional[str] = None
     # 视频编码
     video_encode: Optional[str] = None
     # 音频编码

app/core/meta/metavideo.py

@@ -10,6 +10,7 @@ from app.core.meta.releasegroup import ReleaseGroupsMatcher
 from app.schemas.types import MediaType
 from app.utils.string import StringUtils
 from app.utils.tokens import Tokens
+from app.core.meta.streamingplatform import StreamingPlatforms
 
 
 class MetaVideo(MetaBase):
@@ -31,7 +32,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$|^HLG$|^HDR10(\+|Plus)$"
+    _effect_re = r"^SDR$|^HDR\d*$|^DOLBY$|^DOVI$|^DV$|^3D$|^REPACK$|^HLG$|^HDR10(\+|Plus)$|^EDR$|^HQ$"
     _resources_type_re = r"%s|%s" % (_source_re, _effect_re)
     _name_no_begin_re = r"^[\[【].+?[\]】]"
     _name_no_chinese_re = r".*版|.*字幕"
@@ -51,7 +52,7 @@ class MetaVideo(MetaBase):
     _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"^(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?$"
+    _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?$|^AV[3S]A$"
 
     def __init__(self, title: str, subtitle: str = None, isfile: bool = False):
         """
@@ -66,6 +67,7 @@ class MetaVideo(MetaBase):
         original_title = title
         self._source = ""
         self._effect = []
+        self._index = 0
         # 判断是否纯数字命名
         if isfile \
                 and title.isdigit() \
@@ -93,9 +95,12 @@ class MetaVideo(MetaBase):
         # 拆分tokens
         tokens = Tokens(title)
         self.tokens = tokens
+        # 实例化StreamingPlatforms对象
+        streaming_platforms = StreamingPlatforms()
         # 解析名称、年份、季、集、资源类型、分辨率等
         token = tokens.get_next()
         while token:
+            self._index += 1  # 更新当前处理的token索引
             # Part
             self.__init_part(token)
             # 标题
@@ -116,6 +121,9 @@ class MetaVideo(MetaBase):
             # 资源类型
             if self._continue_flag:
                 self.__init_resource_type(token)
+            # 流媒体平台
+            if self._continue_flag:
+                self.__init_web_source(token, streaming_platforms)
             # 视频编码
             if self._continue_flag:
                 self.__init_video_encode(token)
@@ -574,6 +582,57 @@ class MetaVideo(MetaBase):
                 self._effect.append(effect)
             self._last_token = effect.upper()
 
+    def __init_web_source(self, token: str, streaming_platforms: StreamingPlatforms):
+        """
+        识别流媒体平台
+        """
+        if not self.name:
+            return
+
+        platform_name = None
+        query_range = 1
+
+        prev_token = None
+        prev_idx = self._index - 2
+        if 0 <= prev_idx < len(self.tokens.tokens):
+            prev_token = self.tokens.tokens[prev_idx]
+
+        next_token = self.tokens.peek()
+
+        if streaming_platforms.is_streaming_platform(token):
+            platform_name = streaming_platforms.get_streaming_platform_name(token)
+        else:
+            for adjacent_token, is_next in [(prev_token, False), (next_token, True)]:
+                if not adjacent_token or platform_name:
+                    continue
+
+                for separator in [" ", "-"]:
+                    if is_next:
+                        combined_token = f"{token}{separator}{adjacent_token}"
+                    else:
+                        combined_token = f"{adjacent_token}{separator}{token}"
+
+                    if streaming_platforms.is_streaming_platform(combined_token):
+                        platform_name = streaming_platforms.get_streaming_platform_name(combined_token)
+                        query_range = 2
+                        if is_next:
+                            self.tokens.get_next()
+                        break
+
+        if not platform_name:
+            return
+
+        web_tokens = ["WEB", "DL", "WEBDL", "WEBRIP"]
+        match_start_idx = self._index - query_range
+        match_end_idx = self._index - 1
+        start_index = max(0, match_start_idx - query_range)
+        end_index = min(len(self.tokens.tokens), match_end_idx + 1 + query_range)
+        tokens_to_check = self.tokens.tokens[start_index:end_index]
+
+        if any(tok and tok.upper() in web_tokens for tok in tokens_to_check):
+            self.web_source = platform_name
+            self._continue_flag = False
+
     def __init_video_encode(self, token: str):
         """
         识别视频编码

app/core/meta/releasegroup.py

@@ -9,7 +9,6 @@ class ReleaseGroupsMatcher(metaclass=Singleton):
     """
     识别制作组、字幕组
     """
-    __release_groups: str = None
     # 内置组
     RELEASE_GROUPS: dict = {
         "0ff": ['FF(?:(?:A|WE)B|CD|E(?:DU|B)|TV)'],

app/core/meta/streamingplatform.py

@@ -0,0 +1,314 @@
+from typing import Optional, List, Tuple
+
+from app.utils.singleton import Singleton
+
+
+class StreamingPlatforms(metaclass=Singleton):
+    """
+    流媒体平台简称与全称。
+    """
+    STREAMING_PLATFORMS: List[Tuple[str, str]] = [
+        ("AMZN", "Amazon"),
+        ("NF", "Netflix"),
+        ("ATVP", "Apple TV+"),
+        ("iT", "iTunes"),
+        ("DSNP", "Disney+"),
+        ("HS", "Hotstar"),
+        ("APPS", "Disney+ MENA"),
+        ("PMTP", "Paramount+"),
+        ("HMAX", "Max"),
+        ("", "Max"),
+        ("HULU", "Hulu Networks"),
+        ("MA", "Movies Anywhere"),
+        ("BCORE", "Bravia Core"),
+        ("MS", "Microsoft Store"),
+        ("SHO", "Showtime"),
+        ("STAN", "Stan"),
+        ("PCOK", "Peacock"),
+        ("SKST", "SkyShowtime"),
+        ("NOW", "Now"),
+        ("FXTL", "Foxtel Now"),
+        ("BNGE", "Binge"),
+        ("CRKL", "Crackle"),
+        ("RKTN", "Rakuten TV"),
+        ("ALL4", "Channel 4"),
+        ("AS", "Adult Swim"),
+        ("BRTB", "Brtb TV"),
+        ("CNLP", "Canal+"),
+        ("CRIT", "Criterion Channel"),
+        ("DSCP", "Discovery+"),
+        ("FOOD", "Food Network"),
+        ("MUBI", "Mubi"),
+        ("PLAY", "Google Play"),
+        ("YT", "YouTube"),
+        ("", "friDay"),
+        ("", "KKTV"),
+        ("", "ofiii"),
+        ("", "LiTV"),
+        ("", "MyVideo"),
+        ("Hami", "Hami Video"),
+        ("HamiVideo", "Hami Video"),
+        ("MW", "meWATCH"),
+        ("CATCHPLAY", "CATCHPLAY+"),
+        ("CPP", "CATCHPLAY+"),
+        ("LINETV", "LINE TV"),
+        ("VIU", "Viu"),
+        ("IQ", ""),
+        ("", "WeTV"),
+        ("ABMA", "Abema"),
+        ("ADN", ""),
+        ("AT-X", ""),
+        ("Baha", ""),
+        ("BG", "B-Global"),
+        ("CR", "Crunchyroll"),
+        ("", "DMM"),
+        ("FOD", ""),
+        ("FUNi", "Funimation"),
+        ("HIDI", "HIDIVE"),
+        ("UNXT", "U-NEXT"),
+        ("FAA", "Filmarchiv Austria"),
+        ("CC", "Comedy Central"),
+        ("iP", "BBC iPlayer"),
+        ("9NOW", "9Now"),
+        ("ABC", ""),
+        ("", "AMC"),
+        ("", "ZEE5"),
+        ("", "WAVO"),
+        ("SHAHID", "Shahid"),
+        ("Flixole", "FlixOlé"),
+        ("TOU", "Ici TOU.TV"),
+        ("ROKU", "Roku"),
+        ("KNPY", "Kanopy"),
+        ("SNXT", "Sun NXT"),
+        ("CUR", "Curiosity Stream"),
+        ("MY5", "Channel 5"),
+        ("AHA", "aha"),
+        ("WOWP", "WOW Presents Plus"),
+        ("JC", "JioCinema"),
+        ("", "Dekkoo"),
+        ("FILMZIE", "Filmzie"),
+        ("HoiChoi", "Hoichoi"),
+        ("VIKI", "Rakuten Viki"),
+        ("SF", "SF Anytime"),
+        ("PLEX", "Plex"),
+        ("SHDR", "Shudder"),
+        ("CRAV", "Crave"),
+        ("CPE", "Cineplex Entertainment"),
+        ("JF HC", ""),
+        ("JF", ""),
+        ("JFFP", ""),
+        ("VIAP", "Viaplay"),
+        ("TUBI", "TubiTV"),
+        ("", "PBS"),
+        ("PBSK", "PBS KIDS"),
+        ("LGP", "Lionsgate Play"),
+        ("", "CTV"),
+        ("", "Cineverse"),
+        ("LN", "Love Nature"),
+        ("MP", "Movistar Plus+"),
+        ("RUNTIME", "Runtime"),
+        ("STZ", "STARZ"),
+        ("FUBO", "fuboTV"),
+        ("TENK", "Tënk"),
+        ("KNOW", "Knowledge Network"),
+        ("TVO", "tvo"),
+        ("", "OVID"),
+        ("CBC", "CBC Gem"),
+        ("FANDOR", "fandor"),
+        ("CW", "The CW"),
+        ("KNPY", "Kanopy"),
+        ("FREE", "Freeform"),
+        ("AE", "A&E"),
+        ("LIFE", "Lifetime"),
+        ("WWEN", "WWE Network"),
+        ("CMAX", "Cinemax"),
+        ("HLMK", "Hallmark"),
+        ("BYU", "BYUtv"),
+        ("", "ViX"),
+        ("VICE", "Viceland"),
+        ("", "TVING"),
+        ("USAN", "USA Network"),
+        ("FOX", ""),
+        ("", "TCM"),
+        ("BRAV", "BravoTV"),
+        ("", "TNT"),
+        ("", "ZDF"),
+        ("", "IndieFlix"),
+        ("", "TLC"),
+        ("", "HGTV"),
+        ("ANPL", "Animal Planet"),
+        ("TRVL", "Travel Channel"),
+        ("", "VH1"),
+        ("SAINA", "Saina Play"),
+        ("SP", "Saina Play"),
+        ("OXGN", "Oxygen"),
+        ("PSN", "PlayStation Network"),
+        ("PMNT", "Paramount Network"),
+        ("FAWESOME", "Fawesome"),
+        ("KLASSIKI", "Klassiki"),
+        ("STRP", "Star+"),
+        ("NATG", "National Geographic"),
+        ("REVEEL", "Reveel"),
+        ("FYI", "FYI Network"),
+        ("WatchiT", "WATCH IT"),
+        ("ITVX", "ITV"),
+        ("GAIA", "Gaia"),
+        ("", "FlixLatino"),
+        ("CNNP", "CNN+"),
+        ("TROMA", "Troma"),
+        ("IVI", "Ivi"),
+        ("9NOW", "9Now"),
+        ("A3P", "Atresplayer"),
+        ("7PLUS", "7plus"),
+        ("", "SBS"),
+        ("TEN", "10Play"),
+        ("AUBC", ""),
+        ("DSNY", "Disney Networks"),
+        ("OSN", "OSN+"),
+        ("SVT", "Sveriges Television"),
+        ("LACINETEK", "LaCinetek"),
+        ("", "Maxdome"),
+        ("RTL", "RTL+"),
+        ("ARTE", "Arte"),
+        ("JOYN", "Joyn"),
+        ("TV2", "TV 2"),
+        ("3SAT", "3sat"),
+        ("FILMINGO", "filmingo"),
+        ("", "WOW"),
+        ("OKKO", "Okko"),
+        ("", "Go3"),
+        ("ARGP", "Argo"),
+        ("VOYO", "Voyo"),
+        ("VMAX", "vivamax"),
+        ("FILMIN", "Filmin"),
+        ("", "Mitele"),
+        ("MY5", "Channel 5"),
+        ("", "ARD"),
+        ("BK", "Bentkey"),
+        ("BOOM", "Boomerang"),
+        ("", "CBS"),
+        ("CLBI", "Club illico"),
+        ("CMOR", "C More"),
+        ("CMT", ""),
+        ("", "CNBC"),
+        ("COOK", "Cooking Channel"),
+        ("CWS", "CW Seed"),
+        ("DCU", "DC Universe"),
+        ("DDY", "Digiturk Dilediğin Yerde"),
+        ("DEST", "Destination America"),
+        ("DISC", "Discovery Channel"),
+        ("DW", "DailyWire+"),
+        ("DLWP", "DailyWire+"),
+        ("DPLY", "dplay"),
+        ("DRPO", "Dropout"),
+        ("EPIX", "EPIX MGM+"),
+        ("ESQ", "Esquire"),
+        ("ETV", "E!"),
+        ("FBWatch", "Facebook Watch"),
+        ("FPT", "FPT Play"),
+        ("FTV", "France.tv"),
+        ("GLOB", "GloboSat Play"),
+        ("GLBO", "Globoplay"),
+        ("GO90", "go90"),
+        ("HIST", "History Channel"),
+        ("HPLAY", "Hungama Play"),
+        ("KS", "Kaleidescape"),
+        ("", "MBC"),
+        ("MMAX", "ManoramaMAX"),
+        ("MNBC", "MSNBC"),
+        ("MTOD", "Motor Trend OnDemand"),
+        ("NBC", ""),
+        ("NBLA", "Nebula"),
+        ("NICK", "Nickelodeon"),
+        ("ODK", "OnDemandKorea"),
+        ("POGO", "PokerGO"),
+        ("PUHU", "puhutv"),
+        ("QIBI", "Quibi"),
+        ("RTE", "RTÉ"),
+        ("SESO", "Seeso"),
+        ("SPIK", "Spike"),
+        ("SS", "Simply South"),
+        ("SYFY", "SyFy"),
+        ("TIMV", "TIMvision"),
+        ("TK", "Tentkotta"),
+        ("", "TV4"),
+        ("TVL", "TV Land"),
+        ("", "TVNZ"),
+        ("", "UKTV"),
+        ("VLCT", "Discovery Velocity"),
+        ("VMEO", "Vimeo"),
+        ("VRV", "VRV Defunct"),
+        ("WTCH", "Watcha"),
+        ("", "NowPlayer"),
+        ("HuluJP", "Hulu Networks"),
+        ("Gaga", "GagaOOLala"),
+        ("MyTVS", "MyTVSuper"),
+        ("", "BBC"),
+        ("CC", "Comedy Central"),
+        ("NowE", "Now E"),
+        ("WAVVE", "Wavve"),
+        ("SE", ""),
+        ("", "BritBox"),
+        ("AOD", "Anime on Demand"),
+        ("AF", ""),
+        ("BCH", "Bandai Channel"),
+        ("VMJ", "VideoMarket"),
+        ("LFTL", "Laftel"),
+        ("WAKA", "Wakanim"),
+        ("WAKANIM", "Wakanim"),
+        ("AO", "AnimeOnegai"),
+        ("", "Lemino"),
+        ("VIDIO", "Vidio"),
+        ("TVER", "TVer"),
+        ("", "MBS"),
+        ("LFTLNET", "Laftel"),
+        ("JONU", "Jonu Play"),
+        ("PlutoTV", "Pluto TV"),
+        ("AbemaTV", "Abema"),
+        ("", "dTV"),
+        ("NYMEY", "Nymey"),
+        ("SMNS", "SAMANSA"),
+        ("CTHP", "CATCHPLAY+"),
+        ("HBOGO", "HBO GO"),
+        ("HBO", "HBO"),
+        ("FPTP", "FPT Play"),
+        ("", "LOCIPO"),
+        ("DANT", "DANET"),
+        ("OV", "OceanVeil"),
+    ]
+
+    def __init__(self):
+        """初始化流媒体平台匹配器"""
+        self._lookup_cache = {}
+        self._build_cache()
+
+    def _build_cache(self) -> None:
+        """
+        构建查询缓存。
+        """
+        self._lookup_cache.clear()
+        for short_name, full_name in self.STREAMING_PLATFORMS:
+            canonical_name = full_name or short_name
+            if not canonical_name:
+                continue
+
+            aliases = {short_name, full_name}
+            for alias in aliases:
+                if alias:
+                    self._lookup_cache[alias.upper()] = canonical_name
+
+    def get_streaming_platform_name(self, platform_code: str) -> Optional[str]:
+        """
+        根据流媒体平台简称或全称获取标准名称。
+        """
+        if platform_code is None:
+            return None
+        return self._lookup_cache.get(platform_code.upper())
+
+    def is_streaming_platform(self, name: str) -> bool:
+        """
+        判断给定的字符串是否为已知的流媒体平台代码或名称。
+        """
+        if name is None:
+            return False
+        return name.upper() in self._lookup_cache

app/core/metainfo.py

@@ -154,35 +154,35 @@ def find_metainfo(title: str) -> Tuple[str, dict]:
             # 去除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']:

app/core/module.py

@@ -16,14 +16,14 @@ class ModuleManager(metaclass=Singleton):
     模块管理器
     """
 
-    # 模块列表
-    _modules: dict = {}
-    # 运行态模块列表
-    _running_modules: dict = {}
     # 子模块类型集合
     SubType = Union[DownloaderType, MediaServerType, MessageChannel, StorageSchema, OtherModulesType]
 
     def __init__(self):
+        # 模块列表
+        self._modules: dict = {}
+        # 运行态模块列表
+        self._running_modules: dict = {}
         self.load_modules()
 
     def load_modules(self):

app/core/plugin.py

@@ -3,12 +3,14 @@ import concurrent.futures
 import importlib.util
 import inspect
 import os
+import sys
 import time
 import traceback
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Type, Union, Callable, Tuple
 
+from app.helper.sites import SitesHelper
 from fastapi import HTTPException
 from starlette import status
 from watchdog.events import FileSystemEventHandler
@@ -19,9 +21,7 @@ from app.core.config import settings
 from app.core.event import eventmanager, Event
 from app.db.plugindata_oper import PluginDataOper
 from app.db.systemconfig_oper import SystemConfigOper
-from app.helper.module import ModuleHelper
 from app.helper.plugin import PluginHelper
-from app.helper.sites import SitesHelper
 from app.log import logger
 from app.schemas.types import EventType, SystemConfigKey
 from app.utils.crypto import RSAUtils
@@ -88,16 +88,15 @@ class PluginManager(metaclass=Singleton):
     插件管理器
     """
 
-    # 插件列表
-    _plugins: dict = {}
-    # 运行态插件列表
-    _running_plugins: dict = {}
-    # 配置Key
-    _config_key: str = "plugin.%s"
-    # 监听器
-    _observer: Observer = None
-
     def __init__(self):
+        # 插件列表
+        self._plugins: dict = {}
+        # 运行态插件列表
+        self._running_plugins: dict = {}
+        # 配置Key
+        self._config_key: str = "plugin.%s"
+        # 监听器
+        self._observer: Observer = None
         # 开发者模式监测插件修改
         if settings.DEV or settings.PLUGIN_AUTO_RELOAD:
             self.__start_monitor()
@@ -122,21 +121,10 @@ class PluginManager(metaclass=Singleton):
                 return False
             return True
 
-        # 扫描插件目录
-        if pid:
-            # 加载指定插件
-            plugins = ModuleHelper.load_with_pre_filter(
-                "app.plugins",
-                filter_func=lambda name, obj: check_module(obj) and name == pid
-            )
-        else:
-            # 加载所有插件
-            plugins = ModuleHelper.load(
-                "app.plugins",
-                filter_func=lambda _, obj: check_module(obj)
-            )
         # 已安装插件
         installed_plugins = SystemConfigOper().get(SystemConfigKey.UserInstalledPlugins) or []
+        # 扫描插件目录，只加载符合条件的插件
+        plugins = self._load_selective_plugins(pid, installed_plugins, check_module)
         # 排序
         plugins.sort(key=lambda x: x.plugin_order if hasattr(x, "plugin_order") else 0)
         for plugin in plugins:
@@ -152,11 +140,6 @@ class PluginManager(metaclass=Singleton):
                     continue
                 # 存储Class
                 self._plugins[plugin_id] = plugin
-                # 未安装的不加载
-                if plugin_id not in installed_plugins:
-                    # 设置事件状态为不可用
-                    eventmanager.disable_event_handler(plugin)
-                    continue
                 # 生成实例
                 plugin_obj = plugin()
                 # 生效插件配置
@@ -201,7 +184,7 @@ class PluginManager(metaclass=Singleton):
             logger.info(f"正在停止插件 {pid}...")
             plugin_obj = self._running_plugins.get(pid)
             if not plugin_obj:
-                logger.warning(f"插件 {pid} 不存在或未加载")
+                logger.debug(f"插件 {pid} 不存在或未加载")
                 return
             plugins = {pid: plugin_obj}
         else:
@@ -213,13 +196,92 @@ class PluginManager(metaclass=Singleton):
         # 清空对像
         if pid:
             # 清空指定插件
+            self._plugins.pop(pid, None)
             self._running_plugins.pop(pid, None)
+            # 清除插件模块缓存，包括所有子模块
+            self._clear_plugin_modules(pid)
         else:
             # 清空
             self._plugins = {}
             self._running_plugins = {}
+            # 清除所有插件模块缓存
+            self._clear_plugin_modules()
         logger.info("插件停止完成")
 
+    @staticmethod
+    def _load_selective_plugins(pid: Optional[str], installed_plugins: List[str],
+                                check_module_func: Callable) -> List[Any]:
+        """
+        选择性加载插件，只import符合条件的插件
+        :param pid: 指定插件ID，为空则加载所有已安装插件
+        :param installed_plugins: 已安装插件列表
+        :param check_module_func: 模块检查函数
+        :return: 插件类列表
+        """
+        import importlib
+
+        plugins = []
+        plugins_dir = settings.ROOT_PATH / "app" / "plugins"
+
+        if not plugins_dir.exists():
+            logger.warning(f"插件目录不存在：{plugins_dir}")
+            return plugins
+
+        # 确定需要加载的插件目录名称列表
+        if pid:
+            # 加载指定插件
+            target_plugins = [pid.lower()]
+        else:
+            # 加载已安装插件
+            target_plugins = [plugin_id.lower() for plugin_id in installed_plugins]
+
+        if not target_plugins:
+            logger.debug("没有需要加载的插件")
+            return plugins
+
+        # 扫描plugins目录
+        _loaded_modules = set()
+        for plugin_dir in plugins_dir.iterdir():
+            if not plugin_dir.is_dir() or plugin_dir.name.startswith('_'):
+                continue
+
+            # 检查是否是需要加载的插件
+            if plugin_dir.name not in target_plugins:
+                logger.debug(f"跳过插件目录：{plugin_dir.name}（不在加载列表中）")
+                continue
+
+            # 检查__init__.py是否存在
+            init_file = plugin_dir / "__init__.py"
+            if not init_file.exists():
+                logger.debug(f"跳过插件目录：{plugin_dir.name}（缺少__init__.py）")
+                continue
+
+            try:
+                # 构建模块名
+                module_name = f"app.plugins.{plugin_dir.name}"
+                logger.debug(f"正在导入插件模块：{module_name}")
+
+                # 导入模块
+                module = importlib.import_module(module_name)
+                importlib.reload(module)
+
+                # 检查模块中的类
+                for name, obj in module.__dict__.items():
+                    if name.startswith('_') or not isinstance(obj, type):
+                        continue
+                    if name in _loaded_modules:
+                        continue
+                    if check_module_func(obj):
+                        _loaded_modules.add(name)
+                        plugins.append(obj)
+                        logger.debug(f"找到符合条件的插件类：{name}")
+                        break
+
+            except Exception as err:
+                logger.error(f"加载插件 {plugin_dir.name} 失败：{str(err)} - {traceback.format_exc()}")
+
+        return plugins
+
     @property
     def running_plugins(self) -> Dict[str, Any]:
         """
@@ -247,6 +309,7 @@ class PluginManager(metaclass=Singleton):
         event_data: schemas.ConfigChangeEventData = event.event_data
         if event_data.key not in ['DEV', 'PLUGIN_AUTO_RELOAD']:
             return
+        logger.info("配置变更，重新加载插件文件修改监测...")
         self.reload_monitor()
 
     def reload_monitor(self):
@@ -312,16 +375,49 @@ class PluginManager(metaclass=Singleton):
         将一个插件重新加载到内存
         :param plugin_id: 插件ID
         """
-        # 先移除
+        # 先移除插件实例
         self.stop(plugin_id)
         # 重新加载
         self.start(plugin_id)
         # 广播事件
         eventmanager.send_event(EventType.PluginReload, data={"plugin_id": plugin_id})
 
+    @staticmethod
+    def _clear_plugin_modules(plugin_id: Optional[str] = None):
+        """
+        清除插件及其所有子模块的缓存
+        :param plugin_id: 插件ID
+        """
+
+        # 构建插件模块前缀
+        if plugin_id:
+            plugin_module_prefix = f"app.plugins.{plugin_id.lower()}"
+        else:
+            plugin_module_prefix = "app.plugins"
+
+        # 收集需要删除的模块名（创建模块名列表的副本以避免迭代时修改字典）
+        modules_to_remove = []
+        for module_name in list(sys.modules.keys()):
+            if module_name == plugin_module_prefix or module_name.startswith(plugin_module_prefix + "."):
+                modules_to_remove.append(module_name)
+
+        # 删除模块
+        for module_name in modules_to_remove:
+            try:
+                del sys.modules[module_name]
+                logger.debug(f"已清除插件模块缓存：{module_name}")
+            except KeyError:
+                # 模块可能已经被删除
+                pass
+        if plugin_id:
+            if modules_to_remove:
+                logger.info(f"插件 {plugin_id} 共清除 {len(modules_to_remove)} 个模块缓存：{modules_to_remove}")
+            else:
+                logger.debug(f"插件 {plugin_id} 没有找到需要清除的模块缓存")
+
     def sync(self) -> List[str]:
         """
-        安装本地不存在的在线插件
+        安装本地不存在或需要更新的插件
         """
 
         def install_plugin(plugin):
@@ -347,7 +443,7 @@ class PluginManager(metaclass=Singleton):
         # 确定需要安装的插件
         plugins_to_install = [
             plugin for plugin in online_plugins
-            if plugin.id in install_plugins and not self.is_plugin_exists(plugin.id)
+            if plugin.id in install_plugins and not self.is_plugin_exists(plugin.id, plugin.plugin_version)
         ]
 
         if not plugins_to_install:
@@ -412,13 +508,14 @@ class PluginManager(metaclass=Singleton):
             return {k: v for k, v in conf.items() if k}
         return {}
 
-    def save_plugin_config(self, pid: str, conf: dict) -> bool:
+    def save_plugin_config(self, pid: str, conf: dict, force: bool = False) -> bool:
         """
         保存插件配置
         :param pid: 插件ID
         :param conf: 配置
+        :param force: 强制保存
         """
-        if not self._plugins.get(pid):
+        if not force and not self._plugins.get(pid):
             return False
         SystemConfigOper().set(self._config_key % pid, conf)
         return True
@@ -462,7 +559,9 @@ class PluginManager(metaclass=Singleton):
         }]
         """
         ret_commands = []
-        for plugin_id, plugin in self._running_plugins.items():
+        # 创建字典快照避免并发修改
+        running_plugins_snapshot = dict(self._running_plugins)
+        for plugin_id, plugin in running_plugins_snapshot.items():
             if pid and pid != plugin_id:
                 continue
             if hasattr(plugin, "get_command") and ObjectUtils.check_method(plugin.get_command):
@@ -522,7 +621,9 @@ class PluginManager(metaclass=Singleton):
         }]
         """
         ret_services = []
-        for plugin_id, plugin in self._running_plugins.items():
+        # 创建字典快照避免并发修改
+        running_plugins_snapshot = dict(self._running_plugins)
+        for plugin_id, plugin in running_plugins_snapshot.items():
             if pid and pid != plugin_id:
                 continue
             if hasattr(plugin, "get_service") and ObjectUtils.check_method(plugin.get_service):
@@ -545,7 +646,9 @@ class PluginManager(metaclass=Singleton):
         }
         """
         ret_modules = {}
-        for plugin_id, plugin in self._running_plugins.items():
+        # 创建字典快照避免并发修改
+        running_plugins_snapshot = dict(self._running_plugins)
+        for plugin_id, plugin in running_plugins_snapshot.items():
             if pid and pid != plugin_id:
                 continue
             if hasattr(plugin, "get_module") and ObjectUtils.check_method(plugin.get_module):
@@ -569,7 +672,9 @@ class PluginManager(metaclass=Singleton):
         }]
         """
         ret_actions = []
-        for plugin_id, plugin in self._running_plugins.items():
+        # 创建字典快照避免并发修改
+        running_plugins_snapshot = dict(self._running_plugins)
+        for plugin_id, plugin in running_plugins_snapshot.items():
             if pid and pid != plugin_id:
                 continue
             if hasattr(plugin, "get_actions") and ObjectUtils.check_method(plugin.get_actions):
@@ -606,7 +711,9 @@ class PluginManager(metaclass=Singleton):
         获取插件联邦组件列表
         """
         remotes = []
-        for plugin_id, plugin in self._running_plugins.items():
+        # 创建字典快照避免并发修改
+        running_plugins_snapshot = dict(self._running_plugins)
+        for plugin_id, plugin in running_plugins_snapshot.items():
             if pid and pid != plugin_id:
                 continue
             if hasattr(plugin, "get_render_mode"):
@@ -625,7 +732,9 @@ class PluginManager(metaclass=Singleton):
         获取所有插件仪表盘元信息
         """
         dashboard_meta = []
-        for plugin_id, plugin in self._running_plugins.items():
+        # 创建字典快照避免并发修改
+        running_plugins_snapshot = dict(self._running_plugins)
+        for plugin_id, plugin in running_plugins_snapshot.items():
             if not hasattr(plugin, "get_dashboard") or not ObjectUtils.check_method(plugin.get_dashboard):
                 continue
             try:
@@ -734,7 +843,7 @@ class PluginManager(metaclass=Singleton):
         """
         return list(self._running_plugins.keys())
 
-    def get_online_plugins(self) -> List[schemas.Plugin]:
+    def get_online_plugins(self, force: bool = False) -> List[schemas.Plugin]:
         """
         获取所有在线插件信息
         """
@@ -755,12 +864,13 @@ class PluginManager(metaclass=Singleton):
                 if not m:
                     continue
                 # 提交任务获取 v1 版本插件，存储 future 到 version 的映射
-                base_future = executor.submit(self.get_plugins_from_market, m, None)
+                base_future = executor.submit(self.get_plugins_from_market, m, None, force)
                 futures_to_version[base_future] = "base_version"
 
                 # 提交任务获取高版本插件（如 v2、v3），存储 future 到 version 的映射
                 if settings.VERSION_FLAG:
-                    higher_version_future = executor.submit(self.get_plugins_from_market, m, settings.VERSION_FLAG)
+                    higher_version_future = executor.submit(self.get_plugins_from_market, m,
+                                                            settings.VERSION_FLAG, force)
                     futures_to_version[higher_version_future] = "higher_version"
 
             # 按照完成顺序处理结果
@@ -868,10 +978,11 @@ class PluginManager(metaclass=Singleton):
         return plugins
 
     @staticmethod
-    def is_plugin_exists(pid: str) -> bool:
+    def is_plugin_exists(pid: str, version: str = None) -> bool:
         """
-        判断插件是否在本地包中存在
+        判断插件是否存在，并满足版本要求(有传入version时)
         :param pid: 插件ID
+        :param version: 插件版本
         """
         if not pid:
             return False
@@ -882,17 +993,30 @@ class PluginManager(metaclass=Singleton):
             spec = importlib.util.find_spec(package_name)
             package_exists = spec is not None and spec.origin is not None
             logger.debug(f"{pid} exists: {package_exists}")
-            return package_exists
+            if not package_exists:
+                return False
+
+            local_version = PluginManager().get_plugin_attr(pid=pid, attr="plugin_version")
+            if not local_version:
+                return False
+
+            if version and not StringUtils.compare_version(local_version, ">=", version):
+                logger.warn(f"Plugin {pid} version: {local_version} (older than version: {version})")
+                return False
+
+            return True
         except Exception as e:
             logger.debug(f"获取插件是否在本地包中存在失败，{e}")
             return False
 
     def get_plugins_from_market(self, market: str,
-                                package_version: Optional[str] = None) -> Optional[List[schemas.Plugin]]:
+                                package_version: Optional[str] = None,
+                                force: bool = False) -> Optional[List[schemas.Plugin]]:
         """
         从指定的市场获取插件信息
         :param market: 市场的 URL 或标识
         :param package_version: 首选插件版本 (如 "v2", "v3")，如果不指定则获取 v1 版本
+        :param force: 是否强制刷新（忽略缓存）
         :return: 返回插件的列表，若获取失败返回 []
         """
         if not market:
@@ -900,7 +1024,7 @@ class PluginManager(metaclass=Singleton):
         # 已安装插件
         installed_apps = SystemConfigOper().get(SystemConfigKey.UserInstalledPlugins) or []
         # 获取在线插件
-        online_plugins = PluginHelper().get_plugins(market, package_version)
+        online_plugins = PluginHelper().get_plugins(market, package_version, force)
         if online_plugins is None:
             logger.warning(
                 f"获取{package_version if package_version else ''}插件库失败：{market}，请检查 GitHub 网络连接")
@@ -1086,7 +1210,7 @@ class PluginManager(metaclass=Singleton):
             success, msg = self._modify_plugin_files(
                 plugin_dir=clone_plugin_dir,
                 original_id=plugin_id,
-                suffix=suffix,
+                suffix=suffix.lower(),
                 name=name,
                 description=description,
                 version=version,
@@ -1116,7 +1240,7 @@ class PluginManager(metaclass=Singleton):
                 # 默认禁用分身插件，让用户手动配置
                 clone_config['enable'] = False
                 clone_config['enabled'] = False
-                self.save_plugin_config(clone_id, clone_config)
+                self.save_plugin_config(clone_id, clone_config, force=True)
                 logger.info(f"已为分身插件 {clone_id} 设置初始配置")
             else:
                 logger.info(f"原插件 {plugin_id} 没有配置，分身插件 {clone_id} 将使用默认配置")
@@ -1322,8 +1446,9 @@ class PluginManager(metaclass=Singleton):
                             content = f.read()
 
                         # 替换CSS中可能的类名引用
-                        content = content.replace(original_class_name.lower(), clone_class_name.lower())
-                        content = content.replace(original_class_name, clone_class_name)
+                        content = content.replace(original_class_name.lower(),
+                                                  clone_class_name.lower()).replace(original_class_name,
+                                                                                    clone_class_name)
 
                         with open(file_path, 'w', encoding='utf-8') as f:
                             f.write(content)

app/core/workflow.py

@@ -13,10 +13,9 @@ class WorkFlowManager(metaclass=Singleton):
     工作流管理器
     """
 
-    # 所有动作定义
-    _actions: Dict[str, Any] = {}
-
     def __init__(self):
+        # 所有动作定义
+        self._actions: Dict[str, Any] = {}
         self.init()
 
     def init(self):

app/db/__init__.py

@@ -24,9 +24,9 @@ db_kwargs = {
 # 当使用 QueuePool 时，添加 QueuePool 特有的参数
 if pool_class == QueuePool:
     db_kwargs.update({
-        "pool_size": settings.DB_POOL_SIZE,
+        "pool_size": settings.CONF.dbpool,
         "pool_timeout": settings.DB_POOL_TIMEOUT,
-        "max_overflow": settings.DB_MAX_OVERFLOW
+        "max_overflow": settings.CONF.dbpooloverflow
     })
 # 创建数据库引擎
 Engine = create_engine(**db_kwargs)
@@ -221,8 +221,7 @@ class Base:
     @classmethod
     @db_query
     def list(cls, db: Session) -> List[Self]:
-        result = db.query(cls).all()
-        return list(result)
+        return db.query(cls).all()
 
     def to_dict(self):
         return {c.name: getattr(self, c.name, None) for c in self.__table__.columns} # noqa
@@ -236,7 +235,6 @@ class DbOper:
     """
     数据库操作基类
     """
-    _db: Session = None
 
     def __init__(self, db: Session = None):
         self._db = db

app/db/models/__init__.py

@@ -9,3 +9,4 @@ from .transferhistory import TransferHistory
 from .user import User
 from .userconfig import UserConfig
 from .workflow import Workflow
+from .userrequest import UserRequest

app/db/models/downloadhistory.py

@@ -1,7 +1,7 @@
 import time
 from typing import Optional
 
-from sqlalchemy import Column, Integer, String, Sequence, JSON, or_
+from sqlalchemy import Column, Integer, String, Sequence, JSON
 from sqlalchemy.orm import Session
 
 from app.db import db_query, db_update, Base
@@ -74,8 +74,7 @@ class DownloadHistory(Base):
     @staticmethod
     @db_query
     def list_by_page(db: Session, page: Optional[int] = 1, count: Optional[int] = 30):
-        result = db.query(DownloadHistory).offset((page - 1) * count).limit(count).all()
-        return list(result)
+        return db.query(DownloadHistory).offset((page - 1) * count).limit(count).all()
 
     @staticmethod
     @db_query
@@ -91,50 +90,47 @@ class DownloadHistory(Base):
         据tmdbid、season、season_episode查询下载记录
         tmdbid + mtype 或 title + year
         """
-        result = None
         # 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(
+                return 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(
+                return 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(
+                return 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(
+                return 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(
+                return 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(
+                return db.query(DownloadHistory).filter(DownloadHistory.title == title,
+                                                        DownloadHistory.year == year).order_by(
                     DownloadHistory.id.desc()).all()
 
-        if result:
-            return list(result)
         return []
 
     @staticmethod
@@ -144,13 +140,12 @@ class DownloadHistory(Base):
         查询某用户某时间之后的下载历史
         """
         if username:
-            result = db.query(DownloadHistory).filter(DownloadHistory.date < date,
-                                                      DownloadHistory.username == username).order_by(
+            return db.query(DownloadHistory).filter(DownloadHistory.date < date,
+                                                    DownloadHistory.username == username).order_by(
                 DownloadHistory.id.desc()).all()
         else:
-            result = db.query(DownloadHistory).filter(DownloadHistory.date < date).order_by(
+            return db.query(DownloadHistory).filter(DownloadHistory.date < date).order_by(
                 DownloadHistory.id.desc()).all()
-        return list(result)
 
     @staticmethod
     @db_query
@@ -173,12 +168,11 @@ class DownloadHistory(Base):
     @staticmethod
     @db_query
     def list_by_type(db: Session, mtype: str, days: int):
-        result = db.query(DownloadHistory) \
+        return db.query(DownloadHistory) \
             .filter(DownloadHistory.type == mtype,
                     DownloadHistory.date >= time.strftime("%Y-%m-%d %H:%M:%S",
                                                           time.localtime(time.time() - 86400 * int(days)))
                     ).all()
-        return list(result)
 
 
 class DownloadFiles(Base):
@@ -205,12 +199,10 @@ class DownloadFiles(Base):
     @db_query
     def get_by_hash(db: Session, download_hash: str, state: Optional[int] = None):
         if state:
-            result = db.query(DownloadFiles).filter(DownloadFiles.download_hash == download_hash,
-                                                    DownloadFiles.state == state).all()
+            return db.query(DownloadFiles).filter(DownloadFiles.download_hash == download_hash,
+                                                  DownloadFiles.state == state).all()
         else:
-            result = db.query(DownloadFiles).filter(DownloadFiles.download_hash == download_hash).all()
-
-        return list(result)
+            return db.query(DownloadFiles).filter(DownloadFiles.download_hash == download_hash).all()
 
     @staticmethod
     @db_query
@@ -225,8 +217,7 @@ class DownloadFiles(Base):
     @staticmethod
     @db_query
     def get_by_savepath(db: Session, savepath: str):
-        result = db.query(DownloadFiles).filter(DownloadFiles.savepath == savepath).all()
-        return list(result)
+        return db.query(DownloadFiles).filter(DownloadFiles.savepath == savepath).all()
 
     @staticmethod
     @db_update

app/db/models/message.py

@@ -37,7 +37,4 @@ class Message(Base):
     @staticmethod
     @db_query
     def list_by_page(db: Session, page: Optional[int] = 1, count: Optional[int] = 30):
-        result = db.query(Message).order_by(Message.reg_time.desc()).offset((page - 1) * count).limit(
-            count).all()
-        result.sort(key=lambda x: x.reg_time, reverse=False)
-        return list(result)
+        return db.query(Message).order_by(Message.reg_time.desc()).offset((page - 1) * count).limit(count).all()

app/db/models/plugindata.py

@@ -16,8 +16,7 @@ class PluginData(Base):
     @staticmethod
     @db_query
     def get_plugin_data(db: Session, plugin_id: str):
-        result = db.query(PluginData).filter(PluginData.plugin_id == plugin_id).all()
-        return list(result)
+        return db.query(PluginData).filter(PluginData.plugin_id == plugin_id).all()
 
     @staticmethod
     @db_query
@@ -37,5 +36,4 @@ class PluginData(Base):
     @staticmethod
     @db_query
     def get_plugin_data_by_plugin_id(db: Session, plugin_id: str):
-        result = db.query(PluginData).filter(PluginData.plugin_id == plugin_id).all()
-        return list(result)
+        return db.query(PluginData).filter(PluginData.plugin_id == plugin_id).all()

app/db/models/site.py

@@ -62,20 +62,17 @@ class Site(Base):
     @staticmethod
     @db_query
     def get_actives(db: Session):
-        result = db.query(Site).filter(Site.is_active == 1).all()
-        return list(result)
+        return db.query(Site).filter(Site.is_active == 1).all()
 
     @staticmethod
     @db_query
     def list_order_by_pri(db: Session):
-        result = db.query(Site).order_by(Site.pri).all()
-        return list(result)
+        return db.query(Site).order_by(Site.pri).all()
 
     @staticmethod
     @db_query
     def get_domains_by_ids(db: Session, ids: list):
-        result = db.query(Site.domain).filter(Site.id.in_(ids)).all()
-        return [r[0] for r in result]
+        return [r[0] for r in db.query(Site.domain).filter(Site.id.in_(ids)).all()]
 
     @staticmethod
     @db_update

app/db/models/subscribe.py

@@ -104,12 +104,10 @@ class Subscribe(Base):
     def get_by_state(db: Session, state: str):
         # 如果 state 为空或 None，返回所有订阅
         if not state:
-            result = db.query(Subscribe).all()
+            return db.query(Subscribe).all()
         else:
             # 如果传入的状态不为空，拆分成多个状态
-            states = state.split(',')
-            result = db.query(Subscribe).filter(Subscribe.state.in_(states)).all()
-        return list(result)
+            return db.query(Subscribe).filter(Subscribe.state.in_(state.split(','))).all()
 
     @staticmethod
     @db_query
@@ -123,11 +121,10 @@ class Subscribe(Base):
     @db_query
     def get_by_tmdbid(db: Session, tmdbid: int, season: Optional[int] = None):
         if season:
-            result = db.query(Subscribe).filter(Subscribe.tmdbid == tmdbid,
-                                                Subscribe.season == season).all()
+            return db.query(Subscribe).filter(Subscribe.tmdbid == tmdbid,
+                                              Subscribe.season == season).all()
         else:
-            result = db.query(Subscribe).filter(Subscribe.tmdbid == tmdbid).all()
-        return list(result)
+            return db.query(Subscribe).filter(Subscribe.tmdbid == tmdbid).all()
 
     @staticmethod
     @db_query
@@ -170,26 +167,24 @@ class Subscribe(Base):
     def list_by_username(db: Session, username: str, state: Optional[str] = None, mtype: Optional[str] = None):
         if mtype:
             if state:
-                result = db.query(Subscribe).filter(Subscribe.state == state,
-                                                    Subscribe.username == username,
-                                                    Subscribe.type == mtype).all()
+                return db.query(Subscribe).filter(Subscribe.state == state,
+                                                  Subscribe.username == username,
+                                                  Subscribe.type == mtype).all()
             else:
-                result = db.query(Subscribe).filter(Subscribe.username == username,
-                                                    Subscribe.type == mtype).all()
+                return db.query(Subscribe).filter(Subscribe.username == username,
+                                                  Subscribe.type == mtype).all()
         else:
             if state:
-                result = db.query(Subscribe).filter(Subscribe.state == state,
-                                                    Subscribe.username == username).all()
+                return db.query(Subscribe).filter(Subscribe.state == state,
+                                                  Subscribe.username == username).all()
             else:
-                result = db.query(Subscribe).filter(Subscribe.username == username).all()
-        return list(result)
+                return db.query(Subscribe).filter(Subscribe.username == username).all()
 
     @staticmethod
     @db_query
     def list_by_type(db: Session, mtype: str, days: int):
-        result = db.query(Subscribe) \
+        return db.query(Subscribe) \
             .filter(Subscribe.type == mtype,
                     Subscribe.date >= time.strftime("%Y-%m-%d %H:%M:%S",
                                                     time.localtime(time.time() - 86400 * int(days)))
                     ).all()
-        return list(result)

app/db/models/subscribehistory.py

@@ -75,12 +75,11 @@ class SubscribeHistory(Base):
     @staticmethod
     @db_query
     def list_by_type(db: Session, mtype: str, page: Optional[int] = 1, count: Optional[int] = 30):
-        result = db.query(SubscribeHistory).filter(
+        return db.query(SubscribeHistory).filter(
             SubscribeHistory.type == mtype
         ).order_by(
             SubscribeHistory.date.desc()
         ).offset((page - 1) * count).limit(count).all()
-        return list(result)
 
     @staticmethod
     @db_query

app/db/models/transferhistory.py

@@ -63,35 +63,33 @@ class TransferHistory(Base):
     @db_query
     def list_by_title(db: Session, title: str, page: Optional[int] = 1, count: Optional[int] = 30, status: bool = None):
         if status is not None:
-            result = db.query(TransferHistory).filter(
+            return db.query(TransferHistory).filter(
                 TransferHistory.status == status
             ).order_by(
                 TransferHistory.date.desc()
             ).offset((page - 1) * count).limit(count).all()
         else:
-            result = db.query(TransferHistory).filter(or_(
+            return db.query(TransferHistory).filter(or_(
                 TransferHistory.title.like(f'%{title}%'),
                 TransferHistory.src.like(f'%{title}%'),
                 TransferHistory.dest.like(f'%{title}%'),
             )).order_by(
                 TransferHistory.date.desc()
             ).offset((page - 1) * count).limit(count).all()
-        return list(result)
 
     @staticmethod
     @db_query
     def list_by_page(db: Session, page: Optional[int] = 1, count: Optional[int] = 30, status: bool = None):
         if status is not None:
-            result = db.query(TransferHistory).filter(
+            return db.query(TransferHistory).filter(
                 TransferHistory.status == status
             ).order_by(
                 TransferHistory.date.desc()
             ).offset((page - 1) * count).limit(count).all()
         else:
-            result = db.query(TransferHistory).order_by(
+            return db.query(TransferHistory).order_by(
                 TransferHistory.date.desc()
             ).offset((page - 1) * count).limit(count).all()
-        return list(result)
 
     @staticmethod
     @db_query
@@ -115,8 +113,7 @@ class TransferHistory(Base):
     @staticmethod
     @db_query
     def list_by_hash(db: Session, download_hash: str):
-        result = db.query(TransferHistory).filter(TransferHistory.download_hash == download_hash).all()
-        return list(result)
+        return db.query(TransferHistory).filter(TransferHistory.download_hash == download_hash).all()
 
     @staticmethod
     @db_query
@@ -128,8 +125,7 @@ class TransferHistory(Base):
                              TransferHistory.id.label('id')).filter(
             TransferHistory.date >= time.strftime("%Y-%m-%d %H:%M:%S",
                                                   time.localtime(time.time() - 86400 * days))).subquery()
-        result = db.query(sub_query.c.date, func.count(sub_query.c.id)).group_by(sub_query.c.date).all()
-        return list(result)
+        return db.query(sub_query.c.date, func.count(sub_query.c.id)).group_by(sub_query.c.date).all()
 
     @staticmethod
     @db_query
@@ -153,70 +149,67 @@ class TransferHistory(Base):
 
     @staticmethod
     @db_query
-    def list_by(db: Session, mtype: Optional[str] = None, title: Optional[str] = None, year: Optional[str] = None, season: Optional[str] = None,
+    def list_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, dest: Optional[str] = None):
         """
         据tmdbid、season、season_episode查询转移记录
         tmdbid + mtype 或 title + year 必输
         """
-        result = None
         # TMDBID + 类型
         if tmdbid and mtype:
             # 电视剧某季某集
             if season and episode:
-                result = db.query(TransferHistory).filter(TransferHistory.tmdbid == tmdbid,
-                                                          TransferHistory.type == mtype,
-                                                          TransferHistory.seasons == season,
-                                                          TransferHistory.episodes == episode,
-                                                          TransferHistory.dest == dest).all()
+                return db.query(TransferHistory).filter(TransferHistory.tmdbid == tmdbid,
+                                                        TransferHistory.type == mtype,
+                                                        TransferHistory.seasons == season,
+                                                        TransferHistory.episodes == episode,
+                                                        TransferHistory.dest == dest).all()
             # 电视剧某季
             elif season:
-                result = db.query(TransferHistory).filter(TransferHistory.tmdbid == tmdbid,
-                                                          TransferHistory.type == mtype,
-                                                          TransferHistory.seasons == season).all()
+                return db.query(TransferHistory).filter(TransferHistory.tmdbid == tmdbid,
+                                                        TransferHistory.type == mtype,
+                                                        TransferHistory.seasons == season).all()
             else:
                 if dest:
                     # 电影
-                    result = db.query(TransferHistory).filter(TransferHistory.tmdbid == tmdbid,
-                                                              TransferHistory.type == mtype,
-                                                              TransferHistory.dest == dest).all()
+                    return db.query(TransferHistory).filter(TransferHistory.tmdbid == tmdbid,
+                                                            TransferHistory.type == mtype,
+                                                            TransferHistory.dest == dest).all()
                 else:
                     # 电视剧所有季集
-                    result = db.query(TransferHistory).filter(TransferHistory.tmdbid == tmdbid,
-                                                              TransferHistory.type == mtype).all()
+                    return db.query(TransferHistory).filter(TransferHistory.tmdbid == tmdbid,
+                                                            TransferHistory.type == mtype).all()
         # 标题 + 年份
         elif title and year:
             # 电视剧某季某集
             if season and episode:
-                result = db.query(TransferHistory).filter(TransferHistory.title == title,
-                                                          TransferHistory.year == year,
-                                                          TransferHistory.seasons == season,
-                                                          TransferHistory.episodes == episode,
-                                                          TransferHistory.dest == dest).all()
+                return db.query(TransferHistory).filter(TransferHistory.title == title,
+                                                        TransferHistory.year == year,
+                                                        TransferHistory.seasons == season,
+                                                        TransferHistory.episodes == episode,
+                                                        TransferHistory.dest == dest).all()
             # 电视剧某季
             elif season:
-                result = db.query(TransferHistory).filter(TransferHistory.title == title,
-                                                          TransferHistory.year == year,
-                                                          TransferHistory.seasons == season).all()
+                return db.query(TransferHistory).filter(TransferHistory.title == title,
+                                                        TransferHistory.year == year,
+                                                        TransferHistory.seasons == season).all()
             else:
                 if dest:
                     # 电影
-                    result = db.query(TransferHistory).filter(TransferHistory.title == title,
-                                                              TransferHistory.year == year,
-                                                              TransferHistory.dest == dest).all()
+                    return db.query(TransferHistory).filter(TransferHistory.title == title,
+                                                            TransferHistory.year == year,
+                                                            TransferHistory.dest == dest).all()
                 else:
                     # 电视剧所有季集
-                    result = db.query(TransferHistory).filter(TransferHistory.title == title,
-                                                              TransferHistory.year == year).all()
+                    return db.query(TransferHistory).filter(TransferHistory.title == title,
+                                                            TransferHistory.year == year).all()
         # 类型 + 转移路径（emby webhook season无tmdbid场景）
         elif mtype and season and dest:
             # 电视剧某季
-            result = db.query(TransferHistory).filter(TransferHistory.type == mtype,
-                                                      TransferHistory.seasons == season,
-                                                      TransferHistory.dest.like(f"{dest}%")).all()
-
-        if result:
-            return list(result)
+            return db.query(TransferHistory).filter(TransferHistory.type == mtype,
+                                                    TransferHistory.seasons == season,
+                                                    TransferHistory.dest.like(f"{dest}%")).all()
         return []
 
     @staticmethod

app/db/models/workflow.py

@@ -37,6 +37,11 @@ class Workflow(Base):
     # 最后执行时间
     last_time = Column(String)
 
+    @staticmethod
+    @db_query
+    def list(db):
+        return db.query(Workflow).all()
+
     @staticmethod
     @db_query
     def get_enabled_workflows(db):

app/db/systemconfig_oper.py

@@ -1,4 +1,5 @@
-from typing import Any, Union, Optional
+import copy
+from typing import Any, Optional, Union
 
 from app.db import DbOper
 from app.db.models.systemconfig import SystemConfig
@@ -7,14 +8,15 @@ from app.utils.singleton import Singleton
 
 
 class SystemConfigOper(DbOper, metaclass=Singleton):
-    # 配置对象
-    __SYSTEMCONF: dict = {}
-
+    """
+    系统配置管理
+    """
     def __init__(self):
         """
         加载配置到内存
         """
         super().__init__()
+        self.__SYSTEMCONF = {}
         for item in SystemConfig.list(self._db):
             self.__SYSTEMCONF[item.key] = item.value
 
@@ -29,8 +31,8 @@ class SystemConfigOper(DbOper, metaclass=Singleton):
             key = key.value
         # 旧值
         old_value = self.__SYSTEMCONF.get(key)
-        # 更新内存
-        self.__SYSTEMCONF[key] = value
+        # 更新内存(deepcopy避免内存共享)
+        self.__SYSTEMCONF[key] = copy.deepcopy(value)
         conf = SystemConfig.get_by_key(self._db, key)
         if conf:
             if old_value != value:
@@ -52,14 +54,16 @@ class SystemConfigOper(DbOper, metaclass=Singleton):
         if isinstance(key, SystemConfigKey):
             key = key.value
         if not key:
-            return self.__SYSTEMCONF
-        return self.__SYSTEMCONF.get(key)
+            return self.all()
+        # 避免将__SYSTEMCONF内的值引用出去，会导致set时误判没有变动
+        return copy.deepcopy(self.__SYSTEMCONF.get(key))
 
     def all(self):
         """
         获取所有系统设置
         """
-        return self.__SYSTEMCONF or {}
+        # 避免将__SYSTEMCONF内的值引用出去，会导致set时误判没有变动
+        return copy.deepcopy(self.__SYSTEMCONF)
 
     def delete(self, key: Union[str, SystemConfigKey]) -> bool:
         """
@@ -74,7 +78,3 @@ class SystemConfigOper(DbOper, metaclass=Singleton):
         if conf:
             conf.delete(self._db, conf.id)
         return True
-
-    def __del__(self):
-        if self._db:
-            self._db.close()

app/db/userconfig_oper.py

@@ -7,14 +7,15 @@ from app.utils.singleton import Singleton
 
 
 class UserConfigOper(DbOper, metaclass=Singleton):
-    # 配置缓存
-    __USERCONF: Dict[str, Dict[str, Any]] = {}
-
+    """
+    用户配置管理
+    """
     def __init__(self):
         """
         加载配置到内存
         """
         super().__init__()
+        self.__USERCONF = {}
         for item in UserConfig.list(self._db):
             self.__set_config_cache(username=item.username, key=item.key, value=item.value)
 
@@ -49,10 +50,6 @@ class UserConfigOper(DbOper, metaclass=Singleton):
             return self.__get_config_caches(username=username)
         return self.__get_config_cache(username=username, key=key)
 
-    def __del__(self):
-        if self._db:
-            self._db.close()
-
     def __set_config_cache(self, username: str, key: str, value: Any):
         """
         设置配置缓存

app/db/workflow_oper.py

@@ -25,6 +25,12 @@ class WorkflowOper(DbOper):
         """
         return Workflow.get(self._db, wid)
 
+    def list(self) -> List[Workflow]:
+        """
+        获取所有工作流列表
+        """
+        return Workflow.list(self._db)
+
     def list_enabled(self) -> List[Workflow]:
         """
         获取启用的工作流列表

app/helper/__init__.py

@@ -1,2 +1 @@
-from .doh import doh_query_json
 from .cloudflare import under_challenge

app/helper/browser.py

@@ -1,8 +1,8 @@
 from typing import Callable, Any, Optional
-import gc
 
-from playwright.sync_api import sync_playwright, Page
 from cf_clearance import sync_cf_retry, sync_stealth
+from playwright.sync_api import sync_playwright, Page
+
 from app.log import logger
 
 
@@ -46,17 +46,17 @@ class PlaywrightHelper:
                     browser = playwright[self.browser_type].launch(headless=headless)
                     context = browser.new_context(user_agent=ua, proxy=proxies)
                     page = context.new_page()
-                    
+
                     if cookies:
                         page.set_extra_http_headers({"cookie": cookies})
-                    
+
                     if not self.__pass_cloudflare(url, page):
                         logger.warn("cloudflare challenge fail！")
                     page.wait_for_load_state("networkidle", timeout=timeout * 1000)
-                    
+
                     # 回调函数
                     result = callback(page)
-                    
+
                 except Exception as e:
                     logger.error(f"网页操作失败: {str(e)}")
                 finally:
@@ -67,11 +67,9 @@ class PlaywrightHelper:
                         context.close()
                     if browser:
                         browser.close()
-                    # 强制垃圾回收
-                    gc.collect()
         except Exception as e:
             logger.error(f"Playwright初始化失败: {str(e)}")
-        
+
         return result
 
     def get_page_source(self, url: str,
@@ -99,16 +97,16 @@ class PlaywrightHelper:
                     browser = playwright[self.browser_type].launch(headless=headless)
                     context = browser.new_context(user_agent=ua, proxy=proxies)
                     page = context.new_page()
-                    
+
                     if cookies:
                         page.set_extra_http_headers({"cookie": cookies})
-                    
+
                     if not self.__pass_cloudflare(url, page):
                         logger.warn("cloudflare challenge fail！")
                     page.wait_for_load_state("networkidle", timeout=timeout * 1000)
-                    
+
                     source = page.content()
-                    
+
                 except Exception as e:
                     logger.error(f"获取网页源码失败: {str(e)}")
                     source = None
@@ -120,11 +118,9 @@ class PlaywrightHelper:
                         context.close()
                     if browser:
                         browser.close()
-                    # 强制垃圾回收
-                    gc.collect()
         except Exception as e:
             logger.error(f"Playwright初始化失败: {str(e)}")
-        
+
         return source
 
 

app/helper/cookie.py

@@ -96,53 +96,58 @@ class CookieHelper:
                 return None, None, "获取源码失败"
             # 查找用户名输入框
             html = etree.HTML(html_text)
-            username_xpath = None
-            for xpath in self._SITE_LOGIN_XPATH.get("username"):
-                if html.xpath(xpath):
-                    username_xpath = xpath
-                    break
-            if not username_xpath:
-                return None, None, "未找到用户名输入框"
-            # 查找密码输入框
-            password_xpath = None
-            for xpath in self._SITE_LOGIN_XPATH.get("password"):
-                if html.xpath(xpath):
-                    password_xpath = xpath
-                    break
-            if not password_xpath:
-                return None, None, "未找到密码输入框"
-            # 处理二步验证码
-            otp_code = TwoFactorAuth(two_step_code).get_code()
-            # 查找二步验证码输入框
-            twostep_xpath = None
-            if otp_code:
-                for xpath in self._SITE_LOGIN_XPATH.get("twostep"):
+            try:
+                username_xpath = None
+                for xpath in self._SITE_LOGIN_XPATH.get("username"):
                     if html.xpath(xpath):
-                        twostep_xpath = xpath
+                        username_xpath = xpath
                         break
-            # 查找验证码输入框
-            captcha_xpath = None
-            for xpath in self._SITE_LOGIN_XPATH.get("captcha"):
-                if html.xpath(xpath):
-                    captcha_xpath = xpath
-                    break
-            # 查找验证码图片
-            captcha_img_url = None
-            if captcha_xpath:
-                for xpath in self._SITE_LOGIN_XPATH.get("captcha_img"):
+                if not username_xpath:
+                    return None, None, "未找到用户名输入框"
+                # 查找密码输入框
+                password_xpath = None
+                for xpath in self._SITE_LOGIN_XPATH.get("password"):
                     if html.xpath(xpath):
-                        captcha_img_url = html.xpath(xpath)[0]
+                        password_xpath = xpath
                         break
-                if not captcha_img_url:
-                    return None, None, "未找到验证码图片"
-            # 查找登录按钮
-            submit_xpath = None
-            for xpath in self._SITE_LOGIN_XPATH.get("submit"):
-                if html.xpath(xpath):
-                    submit_xpath = xpath
-                    break
-            if not submit_xpath:
-                return None, None, "未找到登录按钮"
+                if not password_xpath:
+                    return None, None, "未找到密码输入框"
+                # 处理二步验证码
+                otp_code = TwoFactorAuth(two_step_code).get_code()
+                # 查找二步验证码输入框
+                twostep_xpath = None
+                if otp_code:
+                    for xpath in self._SITE_LOGIN_XPATH.get("twostep"):
+                        if html.xpath(xpath):
+                            twostep_xpath = xpath
+                            break
+                # 查找验证码输入框
+                captcha_xpath = None
+                for xpath in self._SITE_LOGIN_XPATH.get("captcha"):
+                    if html.xpath(xpath):
+                        captcha_xpath = xpath
+                        break
+                # 查找验证码图片
+                captcha_img_url = None
+                if captcha_xpath:
+                    for xpath in self._SITE_LOGIN_XPATH.get("captcha_img"):
+                        if html.xpath(xpath):
+                            captcha_img_url = html.xpath(xpath)[0]
+                            break
+                    if not captcha_img_url:
+                        return None, None, "未找到验证码图片"
+                # 查找登录按钮
+                submit_xpath = None
+                for xpath in self._SITE_LOGIN_XPATH.get("submit"):
+                    if html.xpath(xpath):
+                        submit_xpath = xpath
+                        break
+                if not submit_xpath:
+                    return None, None, "未找到登录按钮"
+            finally:
+                if html is not None:
+                    del html
+
             # 点击登录按钮
             try:
                 # 等待登录按钮准备好
@@ -185,19 +190,23 @@ class CookieHelper:
                 if not otp_code:
                     return None, None, "需要二次验证码"
                 html = etree.HTML(page.content())
-                for xpath in self._SITE_LOGIN_XPATH.get("twostep"):
-                    if html.xpath(xpath):
-                        try:
-                            # 刷新一下 2fa code
-                            otp_code = TwoFactorAuth(two_step_code).get_code()
-                            page.fill(xpath, otp_code)
-                            # 登录按钮 xpath 理论上相同，不再重复查找
-                            page.click(submit_xpath)
-                            page.wait_for_load_state("networkidle", timeout=30 * 1000)
-                        except Exception as e:
-                            logger.error(f"二次验证码输入失败：{str(e)}")
-                            return None, None, f"二次验证码输入失败：{str(e)}"
-                        break
+                try:
+                    for xpath in self._SITE_LOGIN_XPATH.get("twostep"):
+                        if html.xpath(xpath):
+                            try:
+                                # 刷新一下 2fa code
+                                otp_code = TwoFactorAuth(two_step_code).get_code()
+                                page.fill(xpath, otp_code)
+                                # 登录按钮 xpath 理论上相同，不再重复查找
+                                page.click(submit_xpath)
+                                page.wait_for_load_state("networkidle", timeout=30 * 1000)
+                            except Exception as e:
+                                logger.error(f"二次验证码输入失败：{str(e)}")
+                                return None, None, f"二次验证码输入失败：{str(e)}"
+                            break
+                finally:
+                    if html is not None:
+                        del html
             # 登录后的源码
             html_text = page.content()
             if not html_text:

app/helper/directory.py

@@ -1,12 +1,16 @@
+import re
 from pathlib import Path
 from typing import List, Optional
 
 from app import schemas
 from app.core.context import MediaInfo
 from app.db.systemconfig_oper import SystemConfigOper
+from app.log import logger
 from app.schemas.types import SystemConfigKey
 from app.utils.system import SystemUtils
 
+JINJA2_VAR_PATTERN = re.compile(r"\{\{.*?\}\}", re.DOTALL)
+
 
 class DirectoryHelper:
     """
@@ -109,3 +113,42 @@ class DirectoryHelper:
                         return matched_dir
             return matched_dirs[0]
         return None
+
+    @staticmethod
+    def get_media_root_path(rename_format: str, rename_path: Path) -> Optional[Path]:
+        """
+        获取重命名后的媒体文件根路径
+
+        :param rename_format: 重命名格式
+        :param rename_path: 重命名后的路径
+        :return: 媒体文件根路径
+        """
+        if not rename_format:
+            logger.error("重命名格式不能为空")
+            return None
+        # 计算重命名中的文件夹层数
+        rename_list = rename_format.split("/")
+        rename_format_level = len(rename_list) - 1
+        # 查找标题参数所在层
+        for level, name in enumerate(rename_list):
+            matchs = JINJA2_VAR_PATTERN.findall(name)
+            if not matchs:
+                continue
+            # 处理特例，有的人重命名的第一层是年份、分辨率
+            if any("title" in m for m in matchs):
+                # 找出含标题的这一层作为媒体根目录
+                rename_format_level -= level
+                break
+        else:
+            # 假定第一层目录是媒体根目录
+            logger.warn(f"重命名格式 {rename_format} 缺少标题参数")
+        if rename_format_level > len(rename_path.parents):
+            # 通常因为路径以/结尾，被Path规范化删除了
+            logger.error(f"路径 {rename_path} 不匹配重命名格式 {rename_format}")
+            return None
+        if rename_format_level <= 0:
+            # 所有媒体文件都存在一个目录内的特殊需求
+            rename_format_level = 1
+        # 媒体根路径
+        media_root = rename_path.parents[rename_format_level - 1]
+        return media_root

app/helper/display.py

@@ -8,9 +8,9 @@ import os
 
 
 class DisplayHelper(metaclass=Singleton):
-    _display: Display = None
 
     def __init__(self):
+        self._display = None
         if not SystemUtils.is_docker():
             return
         try:

app/helper/doh.py

@@ -10,10 +10,15 @@ import socket
 import struct
 import urllib
 import urllib.request
+from threading import Lock
 from typing import Dict, Optional
 
 from app.core.config import settings
+from app.core.event import Event, eventmanager
 from app.log import logger
+from app.schemas import ConfigChangeEventData
+from app.schemas.types import EventType
+from app.utils.singleton import Singleton
 
 # 定义一个全局线程池执行器
 _executor = concurrent.futures.ThreadPoolExecutor()
@@ -21,41 +26,67 @@ _executor = concurrent.futures.ThreadPoolExecutor()
 # 定义默认的DoH配置
 _doh_timeout = 5
 _doh_cache: Dict[str, str] = {}
+_doh_lock = Lock()
+# 保存原始的 socket.getaddrinfo 方法
+_orig_getaddrinfo = socket.getaddrinfo
 
 
-def _patched_getaddrinfo(host, *args, **kwargs):
+def enable_doh(enable: bool):
     """
-    socket.getaddrinfo的补丁版本。
+    对 socket.getaddrinfo 进行补丁
     """
-    if host not in settings.DOH_DOMAINS.split(","):
+
+    def _patched_getaddrinfo(host, *args, **kwargs):
+        """
+        socket.getaddrinfo的补丁版本。
+        """
+        if host not in settings.DOH_DOMAINS.split(","):
+            return _orig_getaddrinfo(host, *args, **kwargs)
+        # 检查主机是否已解析
+        with _doh_lock:
+            ip = _doh_cache.get("host", None)
+        if ip is not None:
+            logger.info("已解析 [%s] 为 [%s] (缓存)", host, ip)
+            return _orig_getaddrinfo(ip, *args, **kwargs)
+        # 使用DoH解析主机
+        futures = []
+        for resolver in settings.DOH_RESOLVERS.split(","):
+            futures.append(_executor.submit(_doh_query, resolver, host))
+        for future in concurrent.futures.as_completed(futures):
+            ip = future.result()
+            if ip is not None:
+                logger.info("已解析 [%s] 为 [%s]", host, ip)
+                with _doh_lock:
+                    _doh_cache[host] = ip
+                host = ip
+                break
         return _orig_getaddrinfo(host, *args, **kwargs)
 
-    # 检查主机是否已解析
-    if host in _doh_cache:
-        ip = _doh_cache[host]
-        logger.info("已解析 [%s] 为 [%s] (缓存)", host, ip)
-        return _orig_getaddrinfo(ip, *args, **kwargs)
-
-    # 使用DoH解析主机
-    futures = []
-    for resolver in settings.DOH_RESOLVERS.split(","):
-        futures.append(_executor.submit(_doh_query, resolver, host))
-
-    for future in concurrent.futures.as_completed(futures):
-        ip = future.result()
-        if ip is not None:
-            logger.info("已解析 [%s] 为 [%s]", host, ip)
-            _doh_cache[host] = ip
-            host = ip
-            break
-
-    return _orig_getaddrinfo(host, *args, **kwargs)
+    if enable:
+        # 替换 socket.getaddrinfo 方法
+        socket.getaddrinfo = _patched_getaddrinfo
+    else:
+        socket.getaddrinfo = _orig_getaddrinfo
 
 
-# 对 socket.getaddrinfo 进行补丁
-if settings.DOH_ENABLE:
-    _orig_getaddrinfo = socket.getaddrinfo
-    socket.getaddrinfo = _patched_getaddrinfo
+class DohHelper(metaclass=Singleton):
+    """
+    DoH帮助类，用于处理DNS over HTTPS解析。
+    """
+    def __init__(self):
+        enable_doh(settings.DOH_ENABLE)
+
+    @eventmanager.register(EventType.ConfigChanged)
+    def handle_config_changed(self, event: Event):
+        if not event:
+            return
+        event_data: ConfigChangeEventData = event.event_data
+        if event_data.key not in ["DOH_ENABLE", "DOH_DOMAINS", "DOH_RESOLVERS"]:
+            return
+        with _doh_lock:
+            # DOH配置有变动的情况下，清空缓存
+            _doh_cache.clear()
+        enable_doh(settings.DOH_ENABLE)
 
 
 def _doh_query(resolver: str, host: str) -> Optional[str]:

app/helper/memory.py

@@ -1,176 +0,0 @@
-import gc
-import psutil
-import threading
-import time
-from typing import Optional, Callable, Any
-from functools import wraps
-from app.log import logger
-from app.utils.singleton import Singleton
-
-
-class MemoryManager(metaclass=Singleton):
-    """
-    内存管理工具类，用于监控和优化内存使用
-    """
-    
-    def __init__(self):
-        self._memory_threshold = 512  # 内存使用阈值(MB)
-        self._check_interval = 300   # 检查间隔(秒)
-        self._monitoring = False
-        self._monitor_thread: Optional[threading.Thread] = None
-        
-    @staticmethod
-    def get_memory_usage() -> dict:
-        """
-        获取当前内存使用情况
-        """
-        process = psutil.Process()
-        memory_info = process.memory_info()
-        system_memory = psutil.virtual_memory()
-        
-        return {
-            'rss': memory_info.rss / 1024 / 1024,  # MB
-            'vms': memory_info.vms / 1024 / 1024,  # MB
-            'percent': process.memory_percent(),
-            'system_percent': system_memory.percent,
-            'system_available': system_memory.available / 1024 / 1024 / 1024  # GB
-        }
-    
-    def force_gc(self, generation: Optional[int] = None) -> int:
-        """
-        强制执行垃圾回收
-        :param generation: 垃圾回收代数，None表示所有代数
-        :return: 回收的对象数量
-        """
-        before_memory = self.get_memory_usage()
-        logger.info(f"开始强制垃圾回收，当前内存使用: {before_memory['rss']:.2f}MB")
-
-        if generation is not None:
-            collected = gc.collect(generation)
-        else:
-            collected = gc.collect()
-            
-        after_memory = self.get_memory_usage()
-        memory_freed = before_memory['rss'] - after_memory['rss']
-        
-        if memory_freed > 0:
-            logger.info(f"垃圾回收完成: 回收对象 {collected} 个, 释放内存 {memory_freed:.2f}MB")
-            
-        return collected
-    
-    def check_memory_and_cleanup(self) -> bool:
-        """
-        检查内存使用量，如果超过阈值则执行清理
-        :return: 是否执行了清理
-        """
-        memory_info = self.get_memory_usage()
-        current_memory_mb = memory_info['rss']
-        
-        if current_memory_mb > self._memory_threshold:
-            logger.warning(f"内存使用超过阈值: {current_memory_mb:.1f}MB > {self._memory_threshold:.1f}MB, 开始清理...")
-            self.force_gc()
-            
-            # 再次检查清理效果
-            after_memory = self.get_memory_usage()
-            logger.info(f"清理后内存: {after_memory['rss']:.1f}MB")
-            return True
-        return False
-    
-    def start_monitoring(self):
-        """
-        开始内存监控
-        """
-        if self._monitoring:
-            return
-            
-        self._monitoring = True
-        self._monitor_thread = threading.Thread(target=self._monitor_loop, daemon=True)
-        self._monitor_thread.start()
-        logger.info(f"内存监控已启动 - 阈值: {self._memory_threshold}MB, 检查间隔: {self._check_interval}秒")
-    
-    def stop_monitoring(self):
-        """
-        停止内存监控
-        """
-        self._monitoring = False
-        if self._monitor_thread:
-            self._monitor_thread.join(timeout=5)
-        logger.info("内存监控已停止")
-    
-    def _monitor_loop(self):
-        """
-        内存监控循环
-        """
-        while self._monitoring:
-            try:
-                self.check_memory_and_cleanup()
-                time.sleep(self._check_interval)
-            except Exception as e:
-                logger.error(f"内存监控出错: {e}")
-                time.sleep(60)  # 出错后等待1分钟再继续
-    
-    def set_threshold(self, threshold_mb: int):
-        """
-        设置内存使用阈值
-        :param threshold_mb: 内存阈值，单位MB（500-4096之间）
-        """
-        self._memory_threshold = max(512, min(4096, threshold_mb))
-        logger.info(f"内存阈值已设置为: {self._memory_threshold}MB")
-    
-    def set_check_interval(self, interval: int):
-        """
-        设置检查间隔
-        :param interval: 检查间隔，单位秒（最少60秒）
-        """
-        self._check_interval = max(60, interval)
-        logger.info(f"内存检查间隔已设置为: {self._check_interval}秒")
-    
-    def get_threshold(self) -> int:
-        """
-        获取当前内存阈值
-        :return: 当前阈值(MB)
-        """
-        return self._memory_threshold
-
-
-def memory_optimized(force_gc_after: bool = False, log_memory: bool = False):
-    """
-    内存优化装饰器
-    :param force_gc_after: 函数执行后是否强制垃圾回收
-    :param log_memory: 是否记录内存使用情况
-    """
-    def decorator(func: Callable) -> Callable:
-        @wraps(func)
-        def wrapper(*args, **kwargs) -> Any:
-            memory_manager = MemoryManager()
-            
-            if log_memory:
-                before_memory = memory_manager.get_memory_usage()
-                logger.info(f"{func.__name__} 执行前内存: {before_memory['rss']:.1f}MB")
-            
-            try:
-                result = func(*args, **kwargs)
-                return result
-            finally:
-                if force_gc_after:
-                    memory_manager.force_gc()
-                
-                if log_memory:
-                    after_memory = memory_manager.get_memory_usage()
-                    logger.info(f"{func.__name__} 执行后内存: {after_memory['rss']:.1f}MB")
-        
-        return wrapper
-    return decorator
-
-
-def clear_large_objects(*objects):
-    """
-    清理大型对象的辅助函数
-    """
-    for obj in objects:
-        if hasattr(obj, 'clear') and callable(obj.clear):
-            obj.clear()
-        elif hasattr(obj, '__dict__'):
-            obj.__dict__.clear()
-        del obj
-    gc.collect()

app/helper/message.py

@@ -183,6 +183,8 @@ class TemplateContextBuilder:
             "videoCodec": meta.video_encode,
             # 音频编码
             "audioCodec": meta.audio_encode,
+            # 流媒体平台
+            "webSource": meta.web_source,
         }
         self._context.update({**meta_info, **tech_metadata, **episode_data})
 
@@ -241,7 +243,7 @@ class TemplateContextBuilder:
             "total_size": StringUtils.str_filesize(transferinfo.total_size),
             "err_msg": transferinfo.message,
         }
-        self._context.update(ctx)
+        return self._context.update(ctx)
 
     def _add_file_info(self, file_extension: Optional[str]):
         """
@@ -363,7 +365,7 @@ class TemplateHelper(metaclass=SingletonClass):
                 self.set_cache_context(rendered, context)
                 # 返回渲染结果
                 return rendered
-
+            return None
         except Exception as e:
             logger.error(f"模板处理失败: {str(e)}")
             raise ValueError(f"模板处理失败: {str(e)}") from e
@@ -539,8 +541,6 @@ class MessageQueueManager(metaclass=SingletonClass):
     消息发送队列管理器
     """
 
-    schedule_periods: List[tuple[int, int, int, int]] = []
-
     def __init__(
             self,
             send_callback: Optional[Callable] = None,
@@ -552,6 +552,8 @@ class MessageQueueManager(metaclass=SingletonClass):
         :param send_callback: 实际发送消息的回调函数
         :param check_interval: 时间检查间隔（秒）
         """
+        self.schedule_periods: List[tuple[int, int, int, int]] = []
+
         self.init_config()
 
         self.queue: queue.Queue[Any] = queue.Queue()
@@ -645,7 +647,8 @@ class MessageQueueManager(metaclass=SingletonClass):
         """
         发送消息（立即发送或加入队列）
         """
-        if self._is_in_scheduled_time(datetime.now()):
+        immediately = kwargs.pop("immediately", False)
+        if immediately or self._is_in_scheduled_time(datetime.now()):
             self._send(*args, **kwargs)
         else:
             self.queue.put({

app/helper/ocr.py

@@ -9,7 +9,7 @@ class OcrHelper:
 
     _ocr_b64_url = f"{settings.OCR_HOST}/captcha/base64"
 
-    def get_captcha_text(self, image_url: Optional[str] = None, image_b64: Optional[str] = None, 
+    def get_captcha_text(self, image_url: Optional[str] = None, image_b64: Optional[str] = None,
                          cookie: Optional[str] = None, ua: Optional[str] = None):
         """
         根据图片地址，获取验证码图片，并识别内容

app/helper/plugin.py

@@ -1,15 +1,16 @@
-import sys
+import importlib
 import json
 import shutil
-import traceback
 import site
-import importlib
+import sys
+import traceback
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Set
+from typing import Dict, List, Optional, Tuple, Set
 
 from packaging.specifiers import SpecifierSet, InvalidSpecifier
 from packaging.version import Version, InvalidVersion
 from pkg_resources import Requirement, working_set
+from requests import Response
 
 from app.core.cache import cached
 from app.core.config import settings
@@ -17,14 +18,14 @@ 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
+from app.utils.singleton import WeakSingleton
 from app.utils.system import SystemUtils
 from app.utils.url import UrlUtils
 
 PLUGIN_DIR = Path(settings.ROOT_PATH) / "app" / "plugins"
 
 
-class PluginHelper(metaclass=Singleton):
+class PluginHelper(metaclass=WeakSingleton):
     """
     插件市场管理，下载安装插件到本地
     """
@@ -41,12 +42,35 @@ class PluginHelper(metaclass=Singleton):
                 if self.install_report():
                     self.systemconfig.set(SystemConfigKey.PluginInstallReport, "1")
 
-    @cached(maxsize=64, ttl=1800)
-    def get_plugins(self, repo_url: str, package_version: Optional[str] = None) -> Optional[Dict[str, dict]]:
+    def get_plugins(self, repo_url: str, package_version: Optional[str] = None,
+                    force: bool = False) -> Optional[Dict[str, dict]]:
         """
         获取Github所有最新插件列表
         :param repo_url: Github仓库地址
         :param package_version: 首选插件版本 (如 "v2", "v3")，如果不指定则获取 v1 版本
+        :param force: 是否强制刷新，忽略缓存
+        """
+        # 如果强制刷新，直接调用不带缓存的版本
+        if force:
+            return self._get_plugins_uncached(repo_url, package_version)
+
+        # 正常情况下调用带缓存的版本
+        return self._get_plugins_cached(repo_url, package_version)
+
+    @cached(maxsize=64, ttl=1800)
+    def _get_plugins_cached(self, repo_url: str, package_version: Optional[str] = None) -> Optional[Dict[str, dict]]:
+        """
+        获取Github所有最新插件列表（使用缓存）
+        :param repo_url: Github仓库地址
+        :param package_version: 首选插件版本 (如 "v2", "v3")，如果不指定则获取 v1 版本
+        """
+        return self._get_plugins_uncached(repo_url, package_version)
+
+    def _get_plugins_uncached(self, repo_url: str, package_version: Optional[str] = None) -> Optional[Dict[str, dict]]:
+        """
+        获取Github所有最新插件列表（不使用缓存）
+        :param repo_url: Github仓库地址
+        :param package_version: 首选插件版本 (如 "v2", "v3")，如果不指定则获取 v1 版本
         """
         if not repo_url:
             return None
@@ -62,11 +86,13 @@ class PluginHelper(metaclass=Singleton):
         if res is None:
             return None
         if res:
+            content = res.text
             try:
-                return json.loads(res.text)
+                return json.loads(content)
             except json.JSONDecodeError:
-                logger.error(f"插件包数据解析失败：{res.text}")
-                return None
+                if "404: Not Found" not in content:
+                    logger.warn(f"插件包数据解析失败：{content}")
+                    return None
         return {}
 
     def get_plugin_package_version(self, pid: str, repo_url: str, package_version: Optional[str] = None) -> Optional[str]:
@@ -86,14 +112,11 @@ class PluginHelper(metaclass=Singleton):
             package_version = settings.VERSION_FLAG
 
         # 优先检查指定版本的插件，即 package.v(x).json 文件中是否存在该插件，如果存在，返回该版本号
-        plugins = self.get_plugins(repo_url, package_version)
-        if pid in plugins:
+        if pid in (self.get_plugins(repo_url, package_version) or []):
             return package_version
 
         # 如果指定版本的插件不存在，检查全局 package.json 文件，查看插件是否兼容指定的版本
-        global_plugins = self.get_plugins(repo_url)
-        plugin = global_plugins.get(pid, None)
-
+        plugin = (self.get_plugins(repo_url) or {}).get(pid, None)
         # 检查插件是否明确支持当前指定的版本（如 v2 或 v3），如果支持，返回空字符串表示使用 package.json（v1）
         if plugin and plugin.get(package_version) is True:
             return ""
@@ -285,7 +308,7 @@ class PluginHelper(metaclass=Singleton):
             return None, "连接仓库失败"
         elif res.status_code != 200:
             return None, f"连接仓库失败：{res.status_code} - " \
-                         f"{'超出速率限制，请配置GITHUB_TOKEN环境变量或稍后重试' if res.status_code == 403 else res.reason}"
+                         f"{'超出速率限制，请设置Github Token或稍后重试' if res.status_code == 403 else res.reason}"
 
         try:
             ret = res.json()
@@ -294,7 +317,7 @@ class PluginHelper(metaclass=Singleton):
             else:
                 return None, "插件在仓库中不存在或返回数据格式不正确"
         except Exception as e:
-            logger.error(f"插件数据解析失败：{res.text}，{e}")
+            logger.error(f"插件数据解析失败：{e}")
             return None, "插件数据解析失败"
 
     def __download_files(self, pid: str, file_list: List[dict], user_repo: str,
@@ -376,8 +399,7 @@ class PluginHelper(metaclass=Singleton):
             with open(requirements_file_path, "w", encoding="utf-8") as f:
                 f.write(requirements_txt)
 
-            success, message = self.__pip_install_with_fallback(requirements_file_path)
-            return success, message
+            return self.pip_install_with_fallback(requirements_file_path)
 
         return True, ""  # 如果 requirements.txt 为空，视作成功
 
@@ -394,7 +416,7 @@ class PluginHelper(metaclass=Singleton):
         # 检查是否存在 requirements.txt 文件
         if requirements_file.exists():
             logger.info(f"{pid} 存在依赖，开始尝试安装依赖")
-            success, error_message = self.__pip_install_with_fallback(requirements_file)
+            success, error_message = self.pip_install_with_fallback(requirements_file)
             if success:
                 return True, True, ""
             else:
@@ -452,7 +474,7 @@ class PluginHelper(metaclass=Singleton):
             shutil.rmtree(plugin_dir, ignore_errors=True)
 
     @staticmethod
-    def __pip_install_with_fallback(requirements_file: Path) -> Tuple[bool, str]:
+    def pip_install_with_fallback(requirements_file: Path) -> Tuple[bool, str]:
         """
         使用自动降级策略安装依赖，并确保新安装的包可被动态导入
         :param requirements_file: 依赖的 requirements.txt 文件路径
@@ -497,7 +519,7 @@ class PluginHelper(metaclass=Singleton):
     def __request_with_fallback(url: str,
                                 headers: Optional[dict] = None,
                                 timeout: Optional[int] = 60,
-                                is_api: bool = False) -> Optional[Any]:
+                                is_api: bool = False) -> Optional[Response]:
         """
         使用自动降级策略，请求资源，优先级依次为镜像站、代理、直连
         :param url: 目标URL
@@ -573,7 +595,6 @@ class PluginHelper(metaclass=Singleton):
     def install_dependencies(self, dependencies: List[str]) -> Tuple[bool, str]:
         """
         安装指定的依赖项列表
-
         :param dependencies: 需要安装或更新的依赖项列表
         :return: (success, message)
         """
@@ -588,12 +609,12 @@ class PluginHelper(metaclass=Singleton):
             with open(requirements_temp_file, "w", encoding="utf-8") as f:
                 for dep in dependencies:
                     f.write(dep + "\n")
-
-            # 使用自动降级策略安装依赖
-            success, message = self.__pip_install_with_fallback(requirements_temp_file)
-            # 删除临时文件
-            requirements_temp_file.unlink()
-            return success, message
+            try:
+                # 使用自动降级策略安装依赖
+                return self.pip_install_with_fallback(requirements_temp_file)
+            finally:
+                # 删除临时文件
+                requirements_temp_file.unlink()
         except Exception as e:
             logger.error(f"安装依赖项时发生错误：{e}")
             return False, f"安装依赖项时发生错误：{e}"
@@ -628,10 +649,20 @@ class PluginHelper(metaclass=Singleton):
         """
         dependencies = {}
         try:
+            install_plugins = {
+                plugin_id.lower()  # 对应插件的小写目录名
+                for plugin_id in SystemConfigOper().get(
+                    SystemConfigKey.UserInstalledPlugins
+                ) or []
+            }
             for plugin_dir in PLUGIN_DIR.iterdir():
                 if plugin_dir.is_dir():
                     requirements_file = plugin_dir / "requirements.txt"
                     if requirements_file.exists():
+                        if plugin_dir.name not in install_plugins:
+                            # 这个插件不在安装列表中 忽略它的依赖
+                            logger.debug(f"忽略插件 {plugin_dir.name} 的依赖")
+                            continue
                         # 解析当前插件的 requirements.txt，获取依赖项
                         plugin_deps = self.__parse_requirements(requirements_file)
                         for pkg_name, version_specifiers in plugin_deps.items():

app/helper/progress.py

@@ -1,12 +1,11 @@
 from enum import Enum
-from typing import Union, Dict, Optional
+from typing import Union, Optional
 
 from app.schemas.types import ProgressKey
-from app.utils.singleton import Singleton
+from app.utils.singleton import WeakSingleton
 
 
-class ProgressHelper(metaclass=Singleton):
-    _process_detail: Dict[str, dict] = {}
+class ProgressHelper(metaclass=WeakSingleton):
 
     def __init__(self):
         self._process_detail = {}

app/helper/resource.py

@@ -8,6 +8,7 @@ from app.log import logger
 from app.utils.http import RequestUtils
 from app.utils.string import StringUtils
 from app.utils.system import SystemUtils
+from version import APP_VERSION
 
 
 class ResourceHelper:
@@ -15,8 +16,8 @@ class ResourceHelper:
     检测和更新资源包
     """
     # 资源包的git仓库地址
-    _repo = f"{settings.GITHUB_PROXY}https://raw.githubusercontent.com/jxxghp/MoviePilot-Resources/main/package.json"
-    _files_api = f"https://api.github.com/repos/jxxghp/MoviePilot-Resources/contents/resources"
+    _repo = f"{settings.GITHUB_PROXY}https://raw.githubusercontent.com/jxxghp/MoviePilot-Resources/main/package.v2.json"
+    _files_api = f"https://api.github.com/repos/jxxghp/MoviePilot-Resources/contents/resources.v2"
     _base_dir: Path = settings.ROOT_PATH
 
     def __init__(self):
@@ -58,6 +59,12 @@ class ResourceHelper:
                         if rtype == "auth":
                             # 站点认证资源
                             local_version = SitesHelper().auth_version
+                            # 阻断站点认证资源v2.3.0以下的版本直接更新，避免无限重启
+                            if StringUtils.compare_version(local_version, "<", "2.3.0"):
+                                continue
+                            # 阻断主程序版本v2.6.3以下的版本直接更新，避免搜索异常
+                            if StringUtils.compare_version(APP_VERSION, "<", "2.6.3"):
+                                continue
                         elif rtype == "sites":
                             # 站点索引资源
                             local_version = SitesHelper().indexer_version
@@ -78,6 +85,8 @@ class ResourceHelper:
                         elif not r:
                             return None, "连接仓库失败"
                         files_info = r.json()
+                        # 下载资源文件
+                        success = True
                         for item in files_info:
                             save_path = need_updates.get(item.get("name"))
                             if not save_path:
@@ -90,16 +99,23 @@ class ResourceHelper:
                                                    timeout=180).get_res(download_url)
                                 if not res:
                                     logger.error(f"文件 {item.get('name')} 下载失败！")
+                                    success = False
+                                    break
                                 elif res.status_code != 200:
                                     logger.error(f"下载文件 {item.get('name')} 失败：{res.status_code} - {res.reason}")
+                                    success = False
+                                    break
                                 # 创建插件文件夹
                                 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()
+                        if success:
+                            logger.info("资源包更新完成，开始重启服务...")
+                            SystemHelper.restart()
+                        else:
+                            logger.warn("资源包更新失败，跳过升级！")
                     else:
                         logger.info("所有资源已最新，无需更新")
             except json.JSONDecodeError:

app/helper/rss.py

@@ -1,4 +1,3 @@
-import gc
 import re
 import traceback
 from typing import List, Tuple, Union, Optional
@@ -18,11 +17,11 @@ class RssHelper:
     """
     RSS帮助类，解析RSS报文、获取RSS地址等
     """
-    
+
     # RSS解析限制配置
     MAX_RSS_SIZE = 50 * 1024 * 1024  # 50MB最大RSS文件大小
     MAX_RSS_ITEMS = 1000  # 最大解析条目数
-    
+
     # 各站点RSS链接获取配置
     rss_link_conf = {
         "default": {
@@ -228,7 +227,8 @@ class RssHelper:
         },
     }
 
-    def parse(self, url, proxy: bool = False, timeout: Optional[int] = 15, headers: dict = None) -> Union[List[dict], None, bool]:
+    def parse(self, url, proxy: bool = False,
+              timeout: Optional[int] = 15, headers: dict = None) -> Union[List[dict], None, bool]:
         """
         解析RSS订阅URL，获取RSS中的种子信息
         :param url: RSS地址
@@ -241,26 +241,31 @@ class RssHelper:
         ret_array: list = []
         if not url:
             return False
-        
+
         try:
             ret = RequestUtils(proxies=settings.PROXY if proxy else None,
                                timeout=timeout, headers=headers).get_res(url)
             if not ret:
+                logger.error(f"获取RSS失败：请求返回空值，URL: {url}")
                 return False
         except Exception as err:
             logger.error(f"获取RSS失败：{str(err)} - {traceback.format_exc()}")
             return False
-        
+
         if ret:
+            # 检查HTTP状态码
+            if ret.status_code != 200:
+                logger.error(f"RSS请求失败，状态码: {ret.status_code}, URL: {url}")
+                return False
             ret_xml = None
             root = None
             try:
                 # 检查响应大小，避免处理过大的RSS文件
                 raw_data = ret.content
                 if raw_data and len(raw_data) > self.MAX_RSS_SIZE:
-                    logger.warning(f"RSS文件过大: {len(raw_data)/1024/1024:.1f}MB，跳过解析")
+                    logger.warning(f"RSS文件过大: {len(raw_data) / 1024 / 1024:.1f}MB，跳过解析")
                     return False
-                
+
                 if raw_data:
                     try:
                         result = chardet.detect(raw_data)
@@ -279,7 +284,18 @@ class RssHelper:
                             ret.encoding = ret.apparent_encoding
                 if not ret_xml:
                     ret_xml = ret.text
-                
+
+                # 验证RSS内容是否有效
+                if not ret_xml or not ret_xml.strip():
+                    logger.error("RSS内容为空")
+                    return False
+
+                # 检查是否包含基本的RSS/XML结构
+                ret_xml_stripped = ret_xml.strip()
+                if not ret_xml_stripped.startswith('<'):
+                    logger.error("RSS内容不是有效的XML格式")
+                    return False
+
                 # 使用lxml.etree解析XML
                 parser = None
                 try:
@@ -292,7 +308,8 @@ class RssHelper:
                         huge_tree=False  # 禁用大文档解析，避免内存问题
                     )
                     root = etree.fromstring(ret_xml.encode('utf-8'), parser=parser)
-                except etree.XMLSyntaxError:
+                except etree.XMLSyntaxError as xml_error:
+                    logger.debug(f"XML解析失败：{str(xml_error)}，尝试HTML解析")
                     # 如果XML解析失败，尝试作为HTML解析
                     try:
                         root = etree.HTML(ret_xml)
@@ -304,89 +321,95 @@ class RssHelper:
                     except Exception as e:
                         logger.error(f"HTML解析也失败：{str(e)}")
                         return False
+                except Exception as general_error:
+                    logger.error(f"解析RSS时发生未预期错误：{str(general_error)}")
+                    return False
                 finally:
                     if parser is not None:
+                        try:
+                            parser.close()
+                        except Exception as close_error:
+                            logger.debug(f"关闭解析器时出错：{str(close_error)}")
                         del parser
-                
+
                 if root is None:
                     logger.error("无法解析RSS内容")
                     return False
-                
+
                 # 查找所有item或entry节点
                 items = root.xpath('.//item | .//entry')
-                
+
                 # 限制处理的条目数量
                 items_count = min(len(items), self.MAX_RSS_ITEMS)
                 if len(items) > self.MAX_RSS_ITEMS:
                     logger.warning(f"RSS条目过多: {len(items)}，仅处理前{self.MAX_RSS_ITEMS}个")
-                
-                for i, item in enumerate(items[:items_count]):
-                    try:
-                        # 定期执行垃圾回收
-                        if i > 0 and i % 100 == 0:
-                            gc.collect()
-                        
-                        # 使用xpath提取信息，更高效
-                        title_nodes = item.xpath('.//title')
-                        title = title_nodes[0].text if title_nodes and title_nodes[0].text else ""
-                        if not title:
+                try:
+                    for item in items[:items_count]:
+                        try:
+                            # 使用xpath提取信息，更高效
+                            title_nodes = item.xpath('.//title')
+                            title = title_nodes[0].text if title_nodes and title_nodes[0].text else ""
+                            if not title:
+                                continue
+
+                            # 描述
+                            desc_nodes = item.xpath('.//description | .//summary')
+                            description = desc_nodes[0].text if desc_nodes and desc_nodes[0].text else ""
+
+                            # 种子页面
+                            link_nodes = item.xpath('.//link')
+                            if link_nodes:
+                                link = link_nodes[0].text if hasattr(link_nodes[0], 'text') and link_nodes[0].text else link_nodes[0].get('href', '')
+                            else:
+                                link = ""
+
+                            # 种子链接
+                            enclosure_nodes = item.xpath('.//enclosure')
+                            enclosure = enclosure_nodes[0].get('url', '') if enclosure_nodes else ""
+                            if not enclosure and not link:
+                                continue
+                            # 部分RSS只有link没有enclosure
+                            if not enclosure and link:
+                                enclosure = link
+
+                            # 大小
+                            size = 0
+                            if enclosure_nodes:
+                                size_attr = enclosure_nodes[0].get('length', '0')
+                                if size_attr and str(size_attr).isdigit():
+                                    size = int(size_attr)
+
+                            # 发布日期
+                            pubdate_nodes = item.xpath('.//pubDate | .//published | .//updated')
+                            pubdate = ""
+                            if pubdate_nodes and pubdate_nodes[0].text:
+                                pubdate = StringUtils.get_time(pubdate_nodes[0].text)
+
+                            # 获取豆瓣昵称
+                            nickname_nodes = item.xpath('.//*[local-name()="creator"]')
+                            nickname = nickname_nodes[0].text if nickname_nodes and nickname_nodes[0].text else ""
+
+                            # 返回对象
+                            tmp_dict = {
+                                'title': title,
+                                'enclosure': enclosure,
+                                'size': size,
+                                'description': description,
+                                'link': link,
+                                'pubdate': pubdate
+                            }
+                            # 如果豆瓣昵称不为空，返回数据增加豆瓣昵称，供doubansync插件获取
+                            if nickname:
+                                tmp_dict['nickname'] = nickname
+                            ret_array.append(tmp_dict)
+
+                        except Exception as e1:
+                            logger.debug(f"解析RSS条目失败：{str(e1)} - {traceback.format_exc()}")
                             continue
-                        
-                        # 描述
-                        desc_nodes = item.xpath('.//description | .//summary')
-                        description = desc_nodes[0].text if desc_nodes and desc_nodes[0].text else ""
-                        
-                        # 种子页面
-                        link_nodes = item.xpath('.//link')
-                        if link_nodes:
-                            link = link_nodes[0].text if hasattr(link_nodes[0], 'text') and link_nodes[0].text else link_nodes[0].get('href', '')
-                        else:
-                            link = ""
-                        
-                        # 种子链接
-                        enclosure_nodes = item.xpath('.//enclosure')
-                        enclosure = enclosure_nodes[0].get('url', '') if enclosure_nodes else ""
-                        if not enclosure and not link:
-                            continue
-                        # 部分RSS只有link没有enclosure
-                        if not enclosure and link:
-                            enclosure = link
-                        
-                        # 大小
-                        size = 0
-                        if enclosure_nodes:
-                            size_attr = enclosure_nodes[0].get('length', '0')
-                            if size_attr and str(size_attr).isdigit():
-                                size = int(size_attr)
-                        
-                        # 发布日期
-                        pubdate_nodes = item.xpath('.//pubDate | .//published | .//updated')
-                        pubdate = ""
-                        if pubdate_nodes and pubdate_nodes[0].text:
-                            pubdate = StringUtils.get_time(pubdate_nodes[0].text)
-                        
-                        # 获取豆瓣昵称
-                        nickname_nodes = item.xpath('.//*[local-name()="creator"]')
-                        nickname = nickname_nodes[0].text if nickname_nodes and nickname_nodes[0].text else ""
-                        
-                        # 返回对象
-                        tmp_dict = {
-                            'title': title,
-                            'enclosure': enclosure,
-                            'size': size,
-                            'description': description,
-                            'link': link,
-                            'pubdate': pubdate
-                        }
-                        # 如果豆瓣昵称不为空，返回数据增加豆瓣昵称，供doubansync插件获取
-                        if nickname:
-                            tmp_dict['nickname'] = nickname
-                        ret_array.append(tmp_dict)
-                        
-                    except Exception as e1:
-                        logger.debug(f"解析RSS条目失败：{str(e1)} - {traceback.format_exc()}")
-                        continue
-                        
+                finally:
+                    items.clear()
+                    del items
+
             except Exception as e2:
                 logger.error(f"解析RSS失败：{str(e2)} - {traceback.format_exc()}")
                 # RSS过期检查
@@ -403,8 +426,7 @@ class RssHelper:
                     del root
                 if ret_xml is not None:
                     del ret_xml
-                gc.collect()
-        
+
         return ret_array
 
     def get_rss_link(self, url: str, cookie: str, ua: str, proxy: bool = False) -> Tuple[str, str]:
@@ -446,7 +468,7 @@ class RssHelper:
                     return "", f"获取 {url} RSS链接失败，错误码：{res.status_code}，错误原因：{res.reason}"
                 else:
                     return "", f"获取RSS链接失败：无法连接 {url} "
-            
+
             # 解析HTML
             if html_text:
                 html = None
@@ -459,7 +481,7 @@ class RssHelper:
                 finally:
                     if html is not None:
                         del html
-                    
+
             return "", f"获取RSS链接失败：{url}"
         except Exception as e:
             return "", f"获取 {url} RSS链接失败：{str(e)}"

app/helper/service.py

@@ -107,8 +107,7 @@ class ServiceBaseHelper(Generic[TConf]):
         迭代所有模块的实例及其对应的配置，返回 ServiceInfo 实例
         """
         configs = self.get_configs()
-        modules = self.modulemanager.get_running_type_modules(self.module_type)
-        for module in modules:
+        for module in self.modulemanager.get_running_type_modules(self.module_type):
             if not module:
                 continue
             module_instances = module.get_instances()

app/helper/subscribe.py

@@ -8,11 +8,11 @@ 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
+from app.utils.singleton import WeakSingleton
 from app.utils.system import SystemUtils
 
 
-class SubscribeHelper(metaclass=Singleton):
+class SubscribeHelper(metaclass=WeakSingleton):
     """
     订阅数据统计/订阅分享等
     """
@@ -29,6 +29,8 @@ class SubscribeHelper(metaclass=Singleton):
 
     _sub_shares = f"{settings.MP_SERVER_HOST}/subscribe/shares"
 
+    _sub_share_statistic = f"{settings.MP_SERVER_HOST}/subscribe/share/statistics"
+
     _sub_fork = f"{settings.MP_SERVER_HOST}/subscribe/fork/%s"
 
     _shares_cache_region = "subscribe_share"
@@ -58,7 +60,7 @@ class SubscribeHelper(metaclass=Singleton):
         self.get_user_uuid()
         self.get_github_user()
 
-    @cached(maxsize=20, ttl=1800)
+    @cached(maxsize=5, ttl=1800)
     def get_statistic(self, stype: str, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
         """
         获取订阅统计数据
@@ -199,7 +201,7 @@ class SubscribeHelper(metaclass=Singleton):
         else:
             return False, res.json().get("message")
 
-    @cached(region=_shares_cache_region)
+    @cached(region=_shares_cache_region, maxsize=1, ttl=1800, skip_empty=True)
     def get_shares(self, name: Optional[str] = None, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
         """
         获取订阅分享数据
@@ -215,6 +217,18 @@ class SubscribeHelper(metaclass=Singleton):
             return res.json()
         return []
 
+    @cached(region=_shares_cache_region, maxsize=1, ttl=1800, skip_empty=True)
+    def get_share_statistics(self) -> List[dict]:
+        """
+        获取订阅分享统计数据
+        """
+        if not settings.SUBSCRIBE_STATISTIC_SHARE:
+            return []
+        res = RequestUtils(proxies=settings.PROXY, timeout=15).get_res(self._sub_share_statistic)
+        if res and res.status_code == 200:
+            return res.json()
+        return []
+
     def get_user_uuid(self) -> str:
         """
         获取用户uuid

app/helper/system.py

@@ -1,9 +1,15 @@
+import os
+import signal
 from pathlib import Path
 from typing import Tuple
 
 import docker
 
 from app.core.config import settings
+from app.core.event import eventmanager, Event
+from app.log import logger
+from app.schemas import ConfigChangeEventData
+from app.schemas.types import EventType
 from app.utils.system import SystemUtils
 
 
@@ -12,6 +18,23 @@ class SystemHelper:
     系统工具类，提供系统相关的操作和判断
     """
 
+    __system_flag_file = "/var/log/nginx/__moviepilot__"
+
+    @eventmanager.register(EventType.ConfigChanged)
+    def handle_config_changed(self, event: Event):
+        """
+        处理配置变更事件，更新日志设置
+        :param event: 事件对象
+        """
+        if not event:
+            return
+        event_data: ConfigChangeEventData = event.event_data
+        if event_data.key not in ['DEBUG', 'LOG_LEVEL', 'LOG_MAX_FILE_SIZE', 'LOG_BACKUP_COUNT',
+                                  'LOG_FILE_FORMAT', 'LOG_CONSOLE_FORMAT']:
+            return
+        logger.info("配置变更，更新日志设置...")
+        logger.update_loggers()
+
     @staticmethod
     def can_restart() -> bool:
         """
@@ -23,17 +46,12 @@ class SystemHelper:
         )
 
     @staticmethod
-    def restart() -> Tuple[bool, str]:
+    def _get_container_id() -> str:
         """
-        执行Docker重启操作
+        获取当前容器ID
         """
-        if not SystemUtils.is_docker():
-            return False, "非Docker环境，无法重启！"
+        container_id = None
         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")
@@ -49,11 +67,97 @@ class SystemHelper:
                                 data.rfind("/", 0, index_second_slash) + 1
                             )
                             container_id = data[index_first_slash:index_second_slash]
+        except Exception as e:
+            logger.debug(f"获取容器ID失败: {str(e)}")
+        return container_id.strip() if container_id else None
+
+    @staticmethod
+    def _check_restart_policy() -> bool:
+        """
+        检查当前容器是否配置了自动重启策略
+        """
+        try:
+            # 获取当前容器ID
+            container_id = SystemHelper._get_container_id()
+            if not container_id:
+                return False
+
+            # 创建 Docker 客户端
+            client = docker.DockerClient(base_url=settings.DOCKER_CLIENT_API)
+            # 获取容器信息
+            container = client.containers.get(container_id)
+            restart_policy = container.attrs.get('HostConfig', {}).get('RestartPolicy', {})
+            policy_name = restart_policy.get('Name', 'no')
+            # 检查是否有有效的重启策略
+            auto_restart_policies = ['always', 'unless-stopped', 'on-failure']
+            has_restart_policy = policy_name in auto_restart_policies
+
+            logger.info(f"容器重启策略: {policy_name}, 支持自动重启: {has_restart_policy}")
+            return has_restart_policy
+
+        except Exception as e:
+            logger.warning(f"检查重启策略失败: {str(e)}")
+            return False
+
+    @staticmethod
+    def restart() -> Tuple[bool, str]:
+        """
+        执行Docker重启操作
+        """
+        if not SystemUtils.is_docker():
+            return False, "非Docker环境，无法重启！"
+
+        try:
+            # 检查容器是否配置了自动重启策略
+            has_restart_policy = SystemHelper._check_restart_policy()
+            if has_restart_policy:
+                # 有重启策略，使用优雅退出方式
+                logger.info("检测到容器配置了自动重启策略，使用优雅重启方式...")
+                # 发送SIGTERM信号给当前进程，触发优雅停止
+                os.kill(os.getpid(), signal.SIGTERM)
+                return True, ""
+            else:
+                # 没有重启策略，使用Docker API强制重启
+                logger.info("容器未配置自动重启策略，使用Docker API重启...")
+                return SystemHelper._docker_api_restart()
+        except Exception as err:
+            logger.error(f"重启失败: {str(err)}")
+            # 降级为Docker API重启
+            logger.warning("降级为Docker API重启...")
+            return SystemHelper._docker_api_restart()
+
+    @staticmethod
+    def _docker_api_restart() -> Tuple[bool, str]:
+        """
+        使用Docker API重启容器，并尝试优雅停止
+        """
+        try:
+            # 创建 Docker 客户端
+            client = docker.DockerClient(base_url=settings.DOCKER_CLIENT_API)
+            container_id = SystemHelper._get_container_id()
             if not container_id:
                 return False, "获取容器ID失败！"
-            # 重启当前容器
-            client.containers.get(container_id.strip()).restart()
+            # 重启容器
+            client.containers.get(container_id).restart()
             return True, ""
-        except Exception as err:
-            print(str(err))
-            return False, f"重启时发生错误：{str(err)}"
+        except Exception as docker_err:
+            return False, f"重启时发生错误：{str(docker_err)}"
+
+    def set_system_modified(self):
+        """
+        设置系统已修改标志
+        """
+        try:
+            if SystemUtils.is_docker():
+                Path(self.__system_flag_file).touch(exist_ok=True)
+        except Exception as e:
+            print(f"设置系统修改标志失败: {str(e)}")
+
+    def is_system_reset(self) -> bool:
+        """
+        检查系统是否已被重置
+        :return: 如果系统已重置，返回 True；否则返回 False
+        """
+        if SystemUtils.is_docker():
+            return not Path(self.__system_flag_file).exists()
+        return False

app/helper/thread.py

@@ -1,6 +1,6 @@
 from concurrent.futures import ThreadPoolExecutor
-from typing import Optional
 
+from app.core.config import settings
 from app.utils.singleton import Singleton
 
 
@@ -8,8 +8,8 @@ class ThreadHelper(metaclass=Singleton):
     """
     线程池管理
     """
-    def __init__(self, max_workers: Optional[int] = 50):
-        self.pool = ThreadPoolExecutor(max_workers=max_workers)
+    def __init__(self):
+        self.pool = ThreadPoolExecutor(max_workers=settings.CONF.threadpool)
 
     def submit(self, func, *args, **kwargs):
         """
@@ -27,6 +27,3 @@ class ThreadHelper(metaclass=Singleton):
         :return:
         """
         self.pool.shutdown()
-
-    def __del__(self):
-        self.shutdown()

app/helper/torrent.py

@@ -1,10 +1,9 @@
 import datetime
 import re
 from pathlib import Path
-from typing import Tuple, Optional, List, Union, Dict
+from typing import Tuple, Optional, List, Union, Dict, Any
 from urllib.parse import unquote
 
-from requests import Response
 from torrentool.api import Torrent
 
 from app.core.config import settings
@@ -16,17 +15,17 @@ from app.db.systemconfig_oper import SystemConfigOper
 from app.log import logger
 from app.schemas.types import MediaType, SystemConfigKey
 from app.utils.http import RequestUtils
-from app.utils.singleton import Singleton
+from app.utils.singleton import WeakSingleton
 from app.utils.string import StringUtils
 
 
-class TorrentHelper(metaclass=Singleton):
+class TorrentHelper(metaclass=WeakSingleton):
     """
     种子帮助类
     """
 
-    # 失败的种子：站点链接
-    _invalid_torrents = []
+    def __init__(self):
+        self._invalid_torrents = []
 
     def download_torrent(self, url: str,
                          cookie: Optional[str] = None,
@@ -40,6 +39,22 @@ class TorrentHelper(metaclass=Singleton):
         """
         if url.startswith("magnet:"):
             return None, url, "", [], f"磁力链接"
+        # 构建 torrent 种子文件的存储路径
+        file_path = (Path(settings.TEMP_PATH) / StringUtils.md5_hash(url)).with_suffix(".torrent")
+        if file_path.exists():
+            try:
+                # 获取种子目录和文件清单
+                folder_name, file_list = self.get_torrent_info(file_path)
+                # 无法获取信息，则认为缓存文件无效
+                if not folder_name and not file_list:
+                    raise ValueError("无效的缓存种子文件")
+                # 获取种子数据
+                content = file_path.read_bytes()
+                # 成功拿到种子数据
+                return file_path, content, folder_name, file_list, ""
+            except Exception as err:
+                logger.error(f"处理缓存的种子文件 {file_path} 时出错: {err}，将重新下载")
+                file_path.unlink(missing_ok=True)
         # 请求种子文件
         req = RequestUtils(
             ua=ua,
@@ -106,10 +121,6 @@ class TorrentHelper(metaclass=Singleton):
             if req.content:
                 # 检查是不是种子文件，如果不是仍然抛出异常
                 try:
-                    # 读取种子文件名
-                    file_name = self.get_url_filename(req, url)
-                    # 种子文件路径
-                    file_path = Path(settings.TEMP_PATH) / file_name
                     # 保存到文件
                     file_path.write_bytes(req.content)
                     # 获取种子目录和文件清单
@@ -170,7 +181,7 @@ class TorrentHelper(metaclass=Singleton):
             return "", []
 
     @staticmethod
-    def get_url_filename(req: Response, url: str) -> str:
+    def get_url_filename(req: Any, url: str) -> str:
         """
         从下载请求中获取种子文件名
         """
@@ -308,7 +319,7 @@ class TorrentHelper(metaclass=Singleton):
             self._invalid_torrents.append(url)
 
     @staticmethod
-    def match_torrent(mediainfo: MediaInfo, torrent_meta: MetaInfo, torrent: TorrentInfo) -> bool:
+    def match_torrent(mediainfo: MediaInfo, torrent_meta: MetaBase, torrent: TorrentInfo) -> bool:
         """
         检查种子是否匹配媒体信息
         :param mediainfo: 需要匹配的媒体信息

app/helper/wallpaper.py

@@ -18,14 +18,14 @@ class WallpaperHelper(metaclass=Singleton):
         获取登录页面壁纸
         """
         if settings.WALLPAPER == "bing":
-            url = self.get_bing_wallpaper()
+            return self.get_bing_wallpaper()
         elif settings.WALLPAPER == "mediaserver":
-            url = self.get_mediaserver_wallpaper()
+            return self.get_mediaserver_wallpaper()
         elif settings.WALLPAPER == "customize":
-            url = self.get_customize_wallpaper()
-        else:
-            url = self.get_tmdb_wallpaper()
-        return url
+            return self.get_customize_wallpaper()
+        elif settings.WALLPAPER == "tmdb":
+            return self.get_tmdb_wallpaper()
+        return ''
 
     def get_wallpapers(self, num: int = 10) -> List[str]:
         """
@@ -37,8 +37,9 @@ class WallpaperHelper(metaclass=Singleton):
             return self.get_mediaserver_wallpapers(num)
         elif settings.WALLPAPER == "customize":
             return self.get_customize_wallpapers()
-        else:
+        elif settings.WALLPAPER == "tmdb":
             return self.get_tmdb_wallpapers(num)
+        return []
 
     @cached(maxsize=1, ttl=3600)
     def get_tmdb_wallpaper(self) -> Optional[str]:
@@ -47,7 +48,7 @@ class WallpaperHelper(metaclass=Singleton):
         """
         return TmdbChain().get_random_wallpager()
 
-    @cached(maxsize=1, ttl=3600)
+    @cached(maxsize=1, ttl=3600, skip_empty=True)
     def get_tmdb_wallpapers(self, num: int = 10) -> List[str]:
         """
         获取7天的TMDB每日壁纸
@@ -71,7 +72,7 @@ class WallpaperHelper(metaclass=Singleton):
                 print(str(err))
         return None
 
-    @cached(maxsize=1, ttl=3600)
+    @cached(maxsize=1, ttl=3600, skip_empty=True)
     def get_bing_wallpapers(self, num: int = 7) -> List[str]:
         """
         获取7天的Bing每日壁纸
@@ -94,7 +95,7 @@ class WallpaperHelper(metaclass=Singleton):
         """
         return MediaServerChain().get_latest_wallpaper()
 
-    @cached(maxsize=1, ttl=3600)
+    @cached(maxsize=1, ttl=3600, skip_empty=True)
     def get_mediaserver_wallpapers(self, num: int = 10) -> List[str]:
         """
         获取媒体服务器壁纸列表
@@ -111,7 +112,7 @@ class WallpaperHelper(metaclass=Singleton):
             return wallpaper_list[0]
         return None
 
-    @cached(maxsize=1, ttl=3600)
+    @cached(maxsize=1, ttl=3600, skip_empty=True)
     def get_customize_wallpapers(self) -> List[str]:
         """
         获取自定义壁纸api壁纸

app/helper/workflow.py

@@ -0,0 +1,132 @@
+import json
+from typing import List, Tuple, Optional
+
+from app.core.cache import cached, cache_backend
+from app.core.config import settings
+from app.db.workflow_oper import WorkflowOper
+from app.log import logger
+from app.utils.http import RequestUtils
+from app.utils.singleton import WeakSingleton
+from app.utils.system import SystemUtils
+
+
+class WorkflowHelper(metaclass=WeakSingleton):
+    """
+    工作流分享等
+    """
+
+    _workflow_share = f"{settings.MP_SERVER_HOST}/workflow/share"
+
+    _workflow_shares = f"{settings.MP_SERVER_HOST}/workflow/shares"
+
+    _workflow_fork = f"{settings.MP_SERVER_HOST}/workflow/fork/%s"
+
+    _shares_cache_region = "workflow_share"
+
+    _share_user_id = None
+
+    def __init__(self):
+        self.get_user_uuid()
+
+    def workflow_share(self, workflow_id: int,
+                       share_title: str, share_comment: str, share_user: str) -> Tuple[bool, str]:
+        """
+        分享工作流
+        """
+        if not settings.WORKFLOW_STATISTIC_SHARE:  # 使用独立的工作流分享开关
+            return False, "当前没有开启工作流数据共享功能"
+        
+        # 获取工作流信息
+        workflow = WorkflowOper().get(workflow_id)
+        if not workflow:
+            return False, "工作流不存在"
+
+        if not workflow.actions or not workflow.flows:
+            return False, "请分享有动作和流程的工作流"
+
+        workflow_dict = workflow.to_dict()
+        workflow_dict.pop("id", None)
+        workflow_dict.pop("context", None)
+        workflow_dict['actions'] = json.dumps(workflow_dict['actions'] or [])
+        workflow_dict['flows'] = json.dumps(workflow_dict['flows'] or [])
+
+        # 发送分享请求
+        res = RequestUtils(proxies=settings.PROXY or {}, content_type="application/json",
+                           timeout=10).post(self._workflow_share,
+                                            json={
+                                                "share_title": share_title,
+                                                "share_comment": share_comment,
+                                                "share_user": share_user,
+                                                "share_uid": self._share_user_id,
+                                                **workflow_dict
+                                            })
+        if res is None:
+            return False, "连接MoviePilot服务器失败"
+        if res.ok:
+            # 清除 get_shares 的缓存，以便实时看到结果
+            cache_backend.clear(region=self._shares_cache_region)
+            return True, ""
+        else:
+            return False, res.json().get("message")
+
+    def share_delete(self, share_id: int) -> Tuple[bool, str]:
+        """
+        删除分享
+        """
+        if not settings.WORKFLOW_STATISTIC_SHARE:  # 使用独立的工作流分享开关
+            return False, "当前没有开启工作流数据共享功能"
+        
+        res = RequestUtils(proxies=settings.PROXY or {},
+                           timeout=5).delete_res(f"{self._workflow_share}/{share_id}",
+                                                 params={"share_uid": self._share_user_id})
+        if res is None:
+            return False, "连接MoviePilot服务器失败"
+        if res.ok:
+            # 清除 get_shares 的缓存，以便实时看到结果
+            cache_backend.clear(region=self._shares_cache_region)
+            return True, ""
+        else:
+            return False, res.json().get("message")
+
+    def workflow_fork(self, share_id: int) -> Tuple[bool, str]:
+        """
+        复用分享的工作流
+        """
+        if not settings.WORKFLOW_STATISTIC_SHARE:  # 使用独立的工作流分享开关
+            return False, "当前没有开启工作流数据共享功能"
+        
+        res = RequestUtils(proxies=settings.PROXY or {}, timeout=5, headers={
+            "Content-Type": "application/json"
+        }).get_res(self._workflow_fork % share_id)
+        if res is None:
+            return False, "连接MoviePilot服务器失败"
+        if res.ok:
+            return True, ""
+        else:
+            return False, res.json().get("message")
+
+    @cached(region=_shares_cache_region, maxsize=1, skip_empty=True)
+    def get_shares(self, name: Optional[str] = None, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
+        """
+        获取工作流分享数据
+        """
+        if not settings.WORKFLOW_STATISTIC_SHARE:  # 使用独立的工作流分享开关
+            return []
+        
+        res = RequestUtils(proxies=settings.PROXY or {}, timeout=15).get_res(self._workflow_shares, params={
+            "name": name,
+            "page": page,
+            "count": count
+        })
+        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 or ""

app/log.py

@@ -99,6 +99,24 @@ class LoggerManager:
     # 线程锁
     _lock = threading.Lock()
 
+    def get_logger(self, name: str) -> logging.Logger:
+        """
+        获取一个指定名称的、独立的日志记录器。
+        创建一个独立的日志文件，例如 'diag_memory.log'。
+        :param name: 日志记录器的名称，也将用作文件名。
+        :return: 一个配置好的 logging.Logger 实例。
+        """
+        # 使用名称作为日志文件名
+        logfile = f"{name}.log"
+        with LoggerManager._lock:
+            # 检查是否已经创建过这个 logger
+            _logger = self._loggers.get(logfile)
+            if not _logger:
+                # 如果没有，就使用现有的 __setup_logger 来创建一个新的
+                _logger = self.__setup_logger(log_file=logfile)
+                self._loggers[logfile] = _logger
+        return _logger
+
     @staticmethod
     def __get_caller():
         """

app/main.py

@@ -1,5 +1,7 @@
 import multiprocessing
 import os
+import setproctitle
+import signal
 import sys
 import threading
 
@@ -18,10 +20,13 @@ if SystemUtils.is_frozen():
 from app.core.config import settings
 from app.db.init import init_db, update_db
 
+# 设置进程名
+setproctitle.setproctitle(settings.PROJECT_NAME)
+
 # uvicorn服务
 Server = uvicorn.Server(Config(app, host=settings.HOST, port=settings.PORT,
                                reload=settings.DEV, workers=multiprocessing.cpu_count(),
-                               timeout_graceful_shutdown=5))
+                               timeout_graceful_shutdown=60))
 
 
 def start_tray():
@@ -70,7 +75,19 @@ def start_tray():
     threading.Thread(target=TrayIcon.run, daemon=True).start()
 
 
+def signal_handler(signum, frame):
+    """
+    信号处理函数，用于优雅停止服务
+    """
+    print(f"收到信号 {signum}，开始优雅停止服务...")
+    Server.should_exit = True
+
+
 if __name__ == '__main__':
+    # 注册信号处理器
+    signal.signal(signal.SIGTERM, signal_handler)
+    signal.signal(signal.SIGINT, signal_handler)
+
     # 启动托盘
     start_tray()
     # 初始化数据库

app/modules/__init__.py

@@ -112,7 +112,7 @@ class ServiceBase(Generic[TService, TConf], metaclass=ABCMeta):
             # 通过服务类型或工厂函数来创建实例
             if isinstance(service_type, type):
                 # 如果传入的是类类型，调用构造函数实例化
-                self._instances[conf.name] = service_type(**conf.config)
+                self._instances[conf.name] = service_type(name=conf.name, **conf.config)
             else:
                 # 如果传入的是工厂函数，直接调用工厂函数
                 self._instances[conf.name] = service_type(conf)
@@ -191,8 +191,6 @@ class _MessageBase(ServiceBase[TService, NotificationConf]):
 
         :return: 返回消息通知的配置字典
         """
-        if self._configs is not None:
-            return self._configs
         configs = ServiceConfigHelper.get_notification_configs()
         if not self._service_name:
             return {}
@@ -212,8 +210,8 @@ class _MessageBase(ServiceBase[TService, NotificationConf]):
         # 检查消息来源
         if message.source and message.source != source:
             return False
-        # 检查消息类型开关
-        if message.mtype:
+        # 不是定向发送时，检查消息类型开关
+        if not message.userid and message.mtype:
             conf = self.get_config(source)
             if conf:
                 switchs = conf.switchs or []
@@ -260,8 +258,6 @@ class _DownloaderBase(ServiceBase[TService, DownloaderConf]):
 
         :return: 返回下载器配置字典
         """
-        if self._configs is not None:
-            return self._configs
         configs = ServiceConfigHelper.get_downloader_configs()
         if not self._service_name:
             return {}
@@ -279,8 +275,6 @@ class _MediaServerBase(ServiceBase[TService, MediaServerConf]):
 
         :return: 返回媒体服务器配置字典
         """
-        if self._configs is not None:
-            return self._configs
         configs = ServiceConfigHelper.get_mediaserver_configs()
         if not self._service_name:
             return {}

app/modules/bangumi/__init__.py

@@ -51,7 +51,7 @@ class BangumiModule(_ModuleBase):
         获取模块子类型
         """
         return MediaRecognizeType.Bangumi
-    
+
     @staticmethod
     def get_priority() -> int:
         """

app/modules/bangumi/bangumi.py

@@ -30,7 +30,7 @@ class BangumiApi(object):
         self._session = requests.Session()
         self._req = RequestUtils(session=self._session)
 
-    @cached(maxsize=settings.CACHE_CONF["bangumi"], ttl=settings.CACHE_CONF["meta"])
+    @cached(maxsize=settings.CONF.bangumi, ttl=settings.CONF.meta)
     def __invoke(self, url, key: Optional[str] = None, **kwargs):
         req_url = self._base_url + url
         params = {}

app/modules/douban/apiv2.py

@@ -12,10 +12,10 @@ import requests
 from app.core.cache import cached
 from app.core.config import settings
 from app.utils.http import RequestUtils
-from app.utils.singleton import Singleton
+from app.utils.singleton import WeakSingleton
 
 
-class DoubanApi(metaclass=Singleton):
+class DoubanApi(metaclass=WeakSingleton):
     _urls = {
         # 搜索类
         # sort=U:近期热门 T:标记最多 S:评分最高 R:最新上映
@@ -151,7 +151,6 @@ class DoubanApi(metaclass=Singleton):
     _api_key2 = "0ab215a8b1977939201640fa14c66bab"
     _base_url = "https://frodo.douban.com/api/v2"
     _api_url = "https://api.douban.com/v2"
-    _session = None
 
     def __init__(self):
         self._session = requests.Session()
@@ -171,14 +170,14 @@ class DoubanApi(metaclass=Singleton):
             ).digest()
         ).decode()
 
-    @cached(maxsize=settings.CACHE_CONF["douban"], ttl=settings.CACHE_CONF["meta"])
+    @cached(maxsize=settings.CONF.douban, ttl=settings.CONF.meta)
     def __invoke_recommend(self, url: str, **kwargs) -> dict:
         """
         推荐/发现类API
         """
         return self.__invoke(url, **kwargs)
 
-    @cached(maxsize=settings.CACHE_CONF["douban"], ttl=settings.CACHE_CONF["meta"])
+    @cached(maxsize=settings.CONF.douban, ttl=settings.CONF.meta)
     def __invoke_search(self, url: str, **kwargs) -> dict:
         """
         搜索类API
@@ -213,7 +212,7 @@ class DoubanApi(metaclass=Singleton):
             return resp.json()
         return resp.json() if resp else {}
 
-    @cached(maxsize=settings.CACHE_CONF["douban"], ttl=settings.CACHE_CONF["meta"])
+    @cached(maxsize=settings.CONF.douban, ttl=settings.CONF.meta)
     def __post(self, url: str, **kwargs) -> dict:
         """
         POST请求
@@ -235,7 +234,7 @@ class DoubanApi(metaclass=Singleton):
         if '_ts' in params:
             params.pop('_ts')
         resp = RequestUtils(
-            ua=settings.USER_AGENT,
+            ua=settings.NORMAL_USER_AGENT,
             session=self._session,
         ).post_res(url=req_url, data=params)
         if resp is not None and resp.status_code == 400 and "rate_limit" in resp.text:

app/modules/douban/douban_cache.py

@@ -10,16 +10,16 @@ from app.core.config import settings
 from app.core.meta import MetaBase
 from app.core.metainfo import MetaInfo
 from app.log import logger
-from app.utils.singleton import Singleton
+from app.utils.singleton import WeakSingleton
 from app.schemas.types import MediaType
 
 lock = RLock()
 
 CACHE_EXPIRE_TIMESTAMP_STR = "cache_expire_timestamp"
-EXPIRE_TIMESTAMP = settings.CACHE_CONF["meta"]
+EXPIRE_TIMESTAMP = settings.CONF.meta
 
 
-class DoubanCache(metaclass=Singleton):
+class DoubanCache(metaclass=WeakSingleton):
     """
     豆瓣缓存数据
     {
@@ -29,9 +29,6 @@ class DoubanCache(metaclass=Singleton):
         "type": MediaType
     }
     """
-    _meta_data: dict = {}
-    # 缓存文件路径
-    _meta_path: Path = None
     # TMDB缓存过期
     _tmdb_cache_expire: bool = True
 
@@ -233,3 +230,6 @@ class DoubanCache(metaclass=Singleton):
         if not cache_media_info:
             return
         self._meta_data[key]['title'] = cn_title
+
+    def __del__(self):
+        self.save()

app/modules/emby/__init__.py

@@ -29,6 +29,7 @@ class EmbyModule(_ModuleBase, _MediaServerBase[Emby]):
         event_data: schemas.ConfigChangeEventData = event.event_data
         if event_data.key not in [SystemConfigKey.MediaServers.value]:
             return
+        logger.info("配置变更，重新初始化Emby模块...")
         self.init_module()
 
     @staticmethod

app/modules/emby/emby.py

@@ -166,7 +166,8 @@ class Emby:
                     type=library_type,
                     image=image,
                     link=f'{self._playhost or self._host}web/index.html'
-                         f'#!/videos?serverId={self.serverid}&parentId={library.get("Id")}'
+                         f'#!/videos?serverId={self.serverid}&parentId={library.get("Id")}',
+                    server_type= "emby"
                 )
             )
         return libraries
@@ -1167,7 +1168,8 @@ class Emby:
                         type=item_type,
                         image=image,
                         link=link,
-                        percent=item.get("UserData", {}).get("PlayedPercentage")
+                        percent=item.get("UserData", {}).get("PlayedPercentage"),
+                        server_type='emby'
                     ))
                 return ret_resume
             else:
@@ -1219,7 +1221,8 @@ class Emby:
                         type=item_type,
                         image=image,
                         link=link,
-                        BackdropImageTags=item.get("BackdropImageTags")
+                        BackdropImageTags=item.get("BackdropImageTags"),
+                        server_type='emby'
                     ))
                 return ret_latest
             else:

app/modules/fanart/__init__.py

@@ -399,10 +399,30 @@ class FanartModule(_ModuleBase):
                         if not mediainfo.get_image(season_image):
                             mediainfo.set_image(season_image, image_obj.get('url'))
             else:
-                # 其他图片，按欢迎程度倒排
-                images.sort(key=lambda x: int(x.get('likes', 0)), reverse=True)
-                # 取第一张图片
-                image_obj = images[0]
+
+                # 其他图片，优先环境变量指定语言，再like最多
+                def __pick_best_image(_images):
+                    lang_env = settings.FANART_LANG
+                    if lang_env:
+                        langs = [lang.strip() for lang in lang_env.split(",") if lang.strip()]
+                        for lang in langs:
+                            lang_images = [img for img in _images if img.get('lang') == lang]
+                            if lang_images:
+                                lang_images.sort(key=lambda x: int(x.get('likes', 0)), reverse=True)
+                                return lang_images[0]
+                    # 没设置或没找到，按原逻辑 zh、en、like最多
+                    zh_images = [img for img in _images if img.get('lang') == 'zh']
+                    if zh_images:
+                        zh_images.sort(key=lambda x: int(x.get('likes', 0)), reverse=True)
+                        return zh_images[0]
+                    en_images = [img for img in _images if img.get('lang') == 'en']
+                    if en_images:
+                        en_images.sort(key=lambda x: int(x.get('likes', 0)), reverse=True)
+                        return en_images[0]
+                    _images.sort(key=lambda x: int(x.get('likes', 0)), reverse=True)
+                    return _images[0]
+
+                image_obj = __pick_best_image(images)
                 # 设置图片，没有图片才设置
                 if not mediainfo.get_image(image_name):
                     mediainfo.set_image(image_name, image_obj.get('url'))
@@ -420,7 +440,7 @@ class FanartModule(_ModuleBase):
         return result
 
     @classmethod
-    @cached(maxsize=settings.CACHE_CONF["fanart"], ttl=settings.CACHE_CONF["meta"])
+    @cached(maxsize=settings.CONF.fanart, ttl=settings.CONF.meta)
     def __request_fanart(cls, media_type: MediaType, queryid: Union[str, int]) -> Optional[dict]:
         if media_type == MediaType.MOVIE:
             image_url = cls._movie_url % queryid