更新 plugin.py

feat(command): 增加 `show` ，用来判断是否注册进菜单里显示

.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/issues.yml

@@ -27,4 +27,6 @@ jobs:
          # 忽略所有的 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

@@ -8,17 +8,17 @@ 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@v5
       with:
         python-version: '3.12'
         cache: 'pip'
-        
+
     - name: Cache pip dependencies
       uses: actions/cache@v4
       with:
@@ -26,7 +26,7 @@ jobs:
         key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt', '**/requirements.in') }}
         restore-keys: |
           ${{ runner.os }}-pip-
-          
+
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip setuptools wheel
@@ -41,7 +41,7 @@ jobs:
         else
           echo "⚠️ 未找到依赖文件，仅安装 pylint"
         fi
-        
+
     - name: Verify pylint config
       run: |
         # 检查项目中的pylint配置文件是否存在
@@ -57,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@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/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/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

@@ -147,7 +147,7 @@ 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]
     # 在线插件
@@ -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

@@ -1,5 +1,6 @@
 from typing import List, Any, Dict, Optional
 
+from app.helper.sites import SitesHelper
 from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.orm import Session
 from starlette.background import BackgroundTasks
@@ -21,7 +22,6 @@ from app.db.models.siteuserdata import SiteUserData
 from app.db.site_oper import SiteOper
 from app.db.systemconfig_oper import SystemConfigOper
 from app.db.user_oper import get_current_active_superuser
-from app.helper.sites import SitesHelper
 from app.scheduler import Scheduler
 from app.schemas.types import SystemConfigKey, EventType
 from app.utils.string import StringUtils
@@ -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]:

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,7 +11,7 @@ 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 fastapi import APIRouter, Body, Depends, HTTPException, Header, Request, Response
 from fastapi.responses import StreamingResponse
 
 from app import schemas
@@ -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)
 
 
@@ -287,8 +289,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 +451,55 @@ 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
+    if "github" in url or "{GITHUB_PROXY}" in url:
+        # 这是github的连通性测试
+        url = url.replace(
+            "{GITHUB_PROXY}", UrlUtils.standardize_base_url(settings.GITHUB_PROXY or "")
+        )
+        headers = settings.GITHUB_HEADERS
     url = url.replace("{TMDBAPIKEY}", settings.TMDB_API_KEY)
-    result = RequestUtils(proxies=settings.PROXY if proxy else None,
-                          ua=settings.USER_AGENT).get_res(url)
+    url = url.replace(
+        "{PIP_PROXY}",
+        UrlUtils.standardize_base_url(settings.PIP_PROXY or "https://pypi.org/simple/"),
+    )
+    result = RequestUtils(
+        proxies=settings.PROXY if proxy else None,
+        headers=headers,
+        timeout=10,
+        ua=settings.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="无法连接", 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}")
+            return schemas.Response(
+                success=False,
+                message=f"无效响应，不匹配 {include}",
+                data={"time": time},
+            )
+        return schemas.Response(success=True, data={"time": time})
     else:
-        return schemas.Response(success=False, message="网络连接失败！")
+        return schemas.Response(
+            success=False, message=f"错误码：{result.status_code}", data={"time": time}
+        )
 
 
 @router.get("/modulelist", summary="查询已加载的模块ID列表", response_model=schemas.Response)

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/chain/__init__.py

@@ -22,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
 
 
@@ -94,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]
@@ -138,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()
@@ -612,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:
         """
@@ -624,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:
         """
@@ -636,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

@@ -324,10 +324,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,
@@ -939,21 +941,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,9 +10,10 @@ 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
 
@@ -26,6 +27,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]:
         """
@@ -383,7 +427,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.USER_AGENT).get_res(url=_url)
                 if r:
                     return r.content
                 else:
@@ -404,37 +448,47 @@ 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文件到上级目录
+                            __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)
@@ -449,16 +503,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,38 +547,45 @@ 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)
@@ -521,71 +603,95 @@ 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 +699,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/search.py

@@ -202,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)
@@ -256,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,
@@ -364,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:
@@ -351,9 +356,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 +577,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]:
         """

app/chain/subscribe.py

@@ -1,4 +1,5 @@
 import copy
+import gc
 import json
 import random
 import threading
@@ -221,10 +222,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,
@@ -283,148 +287,161 @@ class SubscribeChain(ChainBase):
                 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:
-                        if global_vars.is_system_stopped:
-                            break
-                        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")
+
+                logger.debug(f"search Lock released at {datetime.now()}")
+            finally:
+                subscribes.clear()
+                del subscribes
+
+            # 如果不是大内存模式，进行垃圾回收
+            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 +514,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 +545,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))
         # 去重
@@ -550,8 +566,6 @@ class SubscribeChain(ChainBase):
 
         with self._rlock:
             logger.debug(f"match lock acquired at {datetime.now()}")
-            # 所有订阅
-            subscribes = SubscribeOper().list(self.get_states_for_search('R'))
 
             # 预识别所有未识别的种子
             processed_torrents: Dict[str, List[Context]] = {}
@@ -574,232 +588,239 @@ 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
-                    logger.debug(f'开始匹配站点：{domain}，共缓存了 {len(contexts)} 个种子...')
-                    for context in contexts:
+                    # 订阅的站点域名列表
+                    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():
                         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
-
-                        # 不在订阅站点范围的不处理
-                        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} 不符合订阅站点要求")
+                        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
 
-                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
+                            # 洗版时，优先级小于已下载优先级的不要
+                            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
 
-                # 开始批量择优下载
-                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)
-                                                                  )
+                            # 匹配成功
+                            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)
 
-                # 同步外部修改，更新订阅信息
-                subscribe = SubscribeOper().get(subscribe.id)
+                    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
 
-                # 判断是否要完成订阅
-                if subscribe:
-                    self.finish_subscribe_or_not(subscribe=subscribe, meta=meta, mediainfo=mediainfo,
-                                                 downloads=downloads, lefts=lefts)
+                    # 开始批量择优下载
+                    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)
+                                                                      )
+
+                    # 同步外部修改，更新订阅信息
+                    subscribe = SubscribeOper().get(subscribe.id)
+
+                    # 判断是否要完成订阅
+                    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
 
             logger.debug(f"match Lock released at {datetime.now()}")
 
@@ -809,12 +830,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} ...')
@@ -870,11 +887,10 @@ 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")

app/chain/system.py

@@ -1,5 +1,6 @@
 import json
 import re
+import shutil
 from pathlib import Path
 from typing import Union, Optional
 
@@ -10,6 +11,7 @@ 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
 
 
@@ -33,7 +35,7 @@ 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))
@@ -42,11 +44,124 @@ 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}")
+                        # 安装依赖
+                        requirements_file = target_path / "requirements.txt"
+                        if requirements_file.exists():
+                            logger.info(f"正在安装插件 {item.name} 的依赖...")
+                            success, message = PluginHelper.pip_install_with_fallback(requirements_file)
+                            if not success:
+                                logger.warn(f"插件 {item.name} 依赖安装失败: {message}")
+                        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} 个项目")
+
+        # 删除备份目录
+        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

@@ -98,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:
@@ -109,25 +110,28 @@ 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
 
     def refresh(self, stype: Optional[str] = None, sites: List[int] = None) -> Dict[str, List[Context]]:
@@ -152,13 +156,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
             # 未开启的站点不刷新
@@ -175,7 +176,7 @@ class TorrentsChain(ChainBase):
             # 按pubdate降序排列
             torrents.sort(key=lambda x: x.pubdate or '', reverse=True)
             # 取前N条
-            torrents = torrents[:settings.CONF["refresh"]]
+            torrents = torrents[:settings.CONF.refresh]
             if torrents:
                 # 过滤出没有处理过的种子 - 优化：使用集合查找，避免重复创建字符串列表
                 cached_signatures = {f'{t.torrent_info.title}{t.torrent_info.description}'
@@ -187,36 +188,40 @@ class TorrentsChain(ChainBase):
                 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.CONF["torrents"]:
-                        torrents_cache[domain] = torrents_cache[domain][-settings.CONF["torrents"]:]
+                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")} 没有获取到种子')
 

app/chain/transfer.py

@@ -1,3 +1,4 @@
+import gc
 import queue
 import re
 import threading
@@ -788,6 +789,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:
@@ -796,70 +798,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("所有下载器中下载完成的文件已整理完成")
@@ -870,7 +880,7 @@ class TransferChain(ChainBase, metaclass=Singleton):
     ) -> List[Tuple[FileItem, bool]]:
         """
         获取整理目录或文件列表
-        
+
         :param fileitem: 文件项
         :param depth: 递归深度，默认为1
         """
@@ -1032,111 +1042,115 @@ 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:
@@ -1155,29 +1169,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} 个"

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
@@ -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

@@ -15,6 +15,34 @@ from app.utils.system import SystemUtils
 from app.utils.url import UrlUtils
 
 
+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):
     """
     Pydantic 配置模型，描述所有配置项及其类型和默认值
@@ -57,16 +85,12 @@ 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 模式，默认开启
@@ -114,6 +138,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 +149,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 +165,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"
@@ -241,7 +268,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
@@ -250,7 +277,7 @@ class ConfigModel(BaseModel):
     # 是否启用内存监控
     MEMORY_ANALYSIS: bool = False
     # 内存快照间隔（分钟）
-    MEMORY_SNAPSHOT_INTERVAL: int = 60
+    MEMORY_SNAPSHOT_INTERVAL: int = 30
     # 保留的内存快照文件数量
     MEMORY_SNAPSHOT_KEEP_COUNT: int = 20
     # 全局图片缓存，将媒体图片缓存到本地
@@ -280,8 +307,6 @@ 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地址
@@ -524,43 +549,37 @@ class Settings(BaseSettings, ConfigModel, LogConfigModel):
         return self.CONFIG_PATH / "cookies"
 
     @property
-    def CONF(self):
+    def CONF(self) -> SystemConfModel:
         """
-        {
-            "torrents": "缓存种子数量",
-            "refresh": "订阅刷新处理数量",
-            "tmdb": "TMDB请求缓存数量",
-            "douban": "豆瓣请求缓存数量",
-            "fanart": "Fanart请求缓存数量",
-            "meta": "元数据缓存过期时间（秒）",
-            "memory": "最大占用内存（MB）",
-            "scheduler": "调度器缓存数量"
-            "threadpool": "线程池数量"
-        }
+        根据内存模式返回系统配置
         """
         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,
-                "scheduler": 100,
-                "threadpool": 100
-            }
-        return {
-            "torrents": 100,
-            "refresh": 50,
-            "tmdb": 256,
-            "douban": 256,
-            "bangumi": 256,
-            "fanart": 128,
-            "meta": (self.META_CACHE_EXPIRE or 2) * 3600,
-            "scheduler": 50,
-            "threadpool": 50
-        }
+            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):
@@ -586,7 +605,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.USER_AGENT,
             }
         return {}
 
@@ -614,7 +634,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.USER_AGENT,
                 }
             except Exception as e:
                 print(f"处理令牌对 '{token_pair}' 时出错: {e}")

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
 
@@ -263,7 +262,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 +277,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]:
         """
         获取可调用对象所属类的唯一标识符

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/streamingplatform.py

@@ -0,0 +1,315 @@
+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/plugin.py

@@ -3,6 +3,7 @@ import concurrent.futures
 import importlib.util
 import inspect
 import os
+import sys
 import time
 import traceback
 from concurrent.futures import ThreadPoolExecutor, as_completed
@@ -19,7 +20,6 @@ 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
@@ -122,21 +122,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 +141,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 +185,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 +197,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 +310,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):
@@ -307,28 +371,54 @@ class PluginManager(metaclass=Singleton):
         """
         self.stop(plugin_id)
 
-        # 从模块列表中移除插件
-        from sys import modules
-        try:
-            del modules[f"app.plugins.{plugin_id.lower()}"]
-        except KeyError:
-            pass
-
     def reload_plugin(self, plugin_id: str):
         """
         将一个插件重新加载到内存
         :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):
@@ -354,7 +444,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:
@@ -889,10 +979,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
@@ -903,7 +994,18 @@ 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
@@ -1345,8 +1447,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/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

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/systemconfig_oper.py

@@ -31,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:
@@ -78,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

@@ -50,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/helper/__init__.py

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

app/helper/browser.py

@@ -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:
@@ -69,7 +69,7 @@ class PlaywrightHelper:
                         browser.close()
         except Exception as e:
             logger.error(f"Playwright初始化失败: {str(e)}")
-        
+
         return result
 
     def get_page_source(self, url: str,
@@ -97,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,7 +120,7 @@ class PlaywrightHelper:
                         browser.close()
         except Exception as e:
             logger.error(f"Playwright初始化失败: {str(e)}")
-        
+
         return source
 
 

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,11 +26,15 @@ _executor = concurrent.futures.ThreadPoolExecutor()
 # 定义默认的DoH配置
 _doh_timeout = 5
 _doh_cache: Dict[str, str] = {}
+_doh_lock = Lock()
+# 保存原始的 socket.getaddrinfo 方法
+_orig_getaddrinfo = socket.getaddrinfo
 
-# 对 socket.getaddrinfo 进行补丁
-if settings.DOH_ENABLE:
-    # 保存原始的 socket.getaddrinfo 方法
-    _orig_getaddrinfo = socket.getaddrinfo
+
+def enable_doh(enable: bool):
+    """
+    对 socket.getaddrinfo 进行补丁
+    """
 
     def _patched_getaddrinfo(host, *args, **kwargs):
         """
@@ -34,8 +43,9 @@ if settings.DOH_ENABLE:
         if host not in settings.DOH_DOMAINS.split(","):
             return _orig_getaddrinfo(host, *args, **kwargs)
         # 检查主机是否已解析
-        if host in _doh_cache:
-            ip = _doh_cache[host]
+        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解析主机
@@ -46,13 +56,34 @@ if settings.DOH_ENABLE:
             ip = future.result()
             if ip is not None:
                 logger.info("已解析 [%s] 为 [%s]", host, ip)
-                _doh_cache[host] = ip
+                with _doh_lock:
+                    _doh_cache[host] = ip
                 host = ip
                 break
         return _orig_getaddrinfo(host, *args, **kwargs)
 
-    # 替换 socket.getaddrinfo 方法
-    socket.getaddrinfo = _patched_getaddrinfo
+    if enable:
+        # 替换 socket.getaddrinfo 方法
+        socket.getaddrinfo = _patched_getaddrinfo
+    else:
+        socket.getaddrinfo = _orig_getaddrinfo
+
+
+class DohHelper(metaclass=Singleton):
+    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

@@ -361,7 +361,7 @@ class MemoryHelper(metaclass=Singleton):
 
                 # 对于较大的对象，使用 asizeof 进行深度计算
                 size_bytes = asizeof.asizeof(obj)
-                
+
                 # 只处理大于10KB的对象，提高分析效率
                 if size_bytes < 10240:
                     continue

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
@@ -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
@@ -52,10 +53,10 @@ class PluginHelper(metaclass=Singleton):
         # 如果强制刷新，直接调用不带缓存的版本
         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]]:
         """
@@ -64,7 +65,7 @@ class PluginHelper(metaclass=Singleton):
         :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所有最新插件列表（不使用缓存）
@@ -85,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]:
@@ -109,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 ""
@@ -308,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()
@@ -317,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,
@@ -399,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 为空，视作成功
 
@@ -417,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:
@@ -475,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 文件路径
@@ -520,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
@@ -596,7 +595,6 @@ class PluginHelper(metaclass=Singleton):
     def install_dependencies(self, dependencies: List[str]) -> Tuple[bool, str]:
         """
         安装指定的依赖项列表
-
         :param dependencies: 需要安装或更新的依赖项列表
         :return: (success, message)
         """
@@ -611,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}"

app/helper/resource.py

@@ -15,8 +15,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,9 +58,15 @@ class ResourceHelper:
                         if rtype == "auth":
                             # 站点认证资源
                             local_version = SitesHelper().auth_version
+                            # 阻断v2.3.0以下的版本直接更新，避免无限重启
+                            if StringUtils.compare_version(local_version, "<", "2.3.0"):
+                                continue
                         elif rtype == "sites":
                             # 站点索引资源
                             local_version = SitesHelper().indexer_version
+                            # 阻断v2.0.0以下的版本直接更新，避免无限重启
+                            if StringUtils.compare_version(local_version, "<", "2.0.0"):
+                                continue
                         else:
                             continue
                         if StringUtils.compare_version(version, ">", local_version):

app/helper/rss.py

@@ -246,12 +246,17 @@ class RssHelper:
             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:
@@ -280,6 +285,17 @@ class RssHelper:
                 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,8 +321,15 @@ 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:
@@ -319,70 +343,72 @@ class RssHelper:
                 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}个")
+                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
 
-                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:
+                            # 描述
+                            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()}")

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

@@ -58,7 +58,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]:
         """
         获取订阅统计数据

app/helper/system.py

@@ -32,6 +32,7 @@ class SystemHelper:
         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
@@ -90,10 +91,10 @@ class SystemHelper:
             # 检查是否有有效的重启策略
             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
@@ -105,11 +106,10 @@ class SystemHelper:
         """
         if not SystemUtils.is_docker():
             return False, "非Docker环境，无法重启！"
-        
+
         try:
             # 检查容器是否配置了自动重启策略
             has_restart_policy = SystemHelper._check_restart_policy()
-            
             if has_restart_policy:
                 # 有重启策略，使用优雅退出方式
                 logger.info("检测到容器配置了自动重启策略，使用优雅重启方式...")
@@ -120,7 +120,6 @@ class SystemHelper:
                 # 没有重启策略，使用Docker API强制重启
                 logger.info("容器未配置自动重启策略，使用Docker API重启...")
                 return SystemHelper._docker_api_restart()
-                
         except Exception as err:
             logger.error(f"重启失败: {str(err)}")
             # 降级为Docker API重启
@@ -141,7 +140,6 @@ class SystemHelper:
             # 重启容器
             client.containers.get(container_id).restart()
             return True, ""
-
         except Exception as docker_err:
             return False, f"重启时发生错误：{str(docker_err)}"
 

app/helper/thread.py

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

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]:

app/main.py

@@ -83,7 +83,7 @@ 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.CONF["bangumi"], ttl=settings.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

@@ -171,14 +171,14 @@ class DoubanApi(metaclass=Singleton):
             ).digest()
         ).decode()
 
-    @cached(maxsize=settings.CONF["douban"], ttl=settings.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.CONF["douban"], ttl=settings.CONF["meta"])
+    @cached(maxsize=settings.CONF.douban, ttl=settings.CONF.meta)
     def __invoke_search(self, url: str, **kwargs) -> dict:
         """
         搜索类API
@@ -213,7 +213,7 @@ class DoubanApi(metaclass=Singleton):
             return resp.json()
         return resp.json() if resp else {}
 
-    @cached(maxsize=settings.CONF["douban"], ttl=settings.CONF["meta"])
+    @cached(maxsize=settings.CONF.douban, ttl=settings.CONF.meta)
     def __post(self, url: str, **kwargs) -> dict:
         """
         POST请求

app/modules/douban/douban_cache.py

@@ -16,7 +16,7 @@ from app.schemas.types import MediaType
 lock = RLock()
 
 CACHE_EXPIRE_TIMESTAMP_STR = "cache_expire_timestamp"
-EXPIRE_TIMESTAMP = settings.CONF["meta"]
+EXPIRE_TIMESTAMP = settings.CONF.meta
 
 
 class DoubanCache(metaclass=Singleton):

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/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.CONF["fanart"], ttl=settings.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

app/modules/filemanager/__init__.py

@@ -344,9 +344,14 @@ class FileManagerModule(_ModuleBase):
             return None
         return storage_oper.get_parent(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: 最大递归深度，避免过深遍历
         """
         if storage not in self._support_storages:
             return None
@@ -354,7 +359,7 @@ class FileManagerModule(_ModuleBase):
         if not storage_oper:
             logger.error(f"不支持 {storage} 的快照处理")
             return None
-        return storage_oper.snapshot(path)
+        return storage_oper.snapshot(path, last_snapshot_time=last_snapshot_time, max_depth=max_depth)
 
     def storage_usage(self, storage: str) -> Optional[StorageUsage]:
         """

app/modules/filemanager/storages/__init__.py

@@ -4,6 +4,7 @@ from typing import Optional, List, Dict, Tuple
 
 from app import schemas
 from app.helper.storage import StorageHelper
+from app.log import logger
 
 
 class StorageBase(metaclass=ABCMeta):
@@ -135,7 +136,8 @@ class StorageBase(metaclass=ABCMeta):
         pass
 
     @abstractmethod
-    def upload(self, fileitem: schemas.FileItem, path: Path, new_name: Optional[str] = None) -> Optional[schemas.FileItem]:
+    def upload(self, fileitem: schemas.FileItem, path: Path,
+               new_name: Optional[str] = None) -> Optional[schemas.FileItem]:
         """
         上传文件
         :param fileitem: 上传目录项
@@ -192,21 +194,44 @@ class StorageBase(metaclass=ABCMeta):
         """
         pass
 
-    def snapshot(self, path: Path) -> Dict[str, float]:
+    def snapshot(self, path: Path, last_snapshot_time: float = None, max_depth: int = 5) -> Dict[str, Dict]:
         """
         快照文件系统，输出所有层级文件信息（不含目录）
+        :param path: 路径
+        :param last_snapshot_time: 上次快照时间，用于增量快照
+        :param max_depth: 最大递归深度，避免过深遍历
         """
         files_info = {}
 
-        def __snapshot_file(_fileitm: schemas.FileItem):
+        def __snapshot_file(_fileitm: schemas.FileItem, current_depth: int = 0):
             """
             递归获取文件信息
             """
-            if _fileitm.type == "dir":
-                for sub_file in self.list(_fileitm):
-                    __snapshot_file(sub_file)
-            else:
-                files_info[_fileitm.path] = _fileitm.size
+            try:
+                if _fileitm.type == "dir":
+                    # 检查递归深度限制
+                    if current_depth >= max_depth:
+                        return
+
+                    # 增量检查：如果目录修改时间早于上次快照，跳过
+                    if (last_snapshot_time and
+                            _fileitm.modify_time and
+                            _fileitm.modify_time <= last_snapshot_time):
+                        return
+
+                    # 遍历子文件
+                    sub_files = self.list(_fileitm)
+                    for sub_file in sub_files:
+                        __snapshot_file(sub_file, current_depth + 1)
+                else:
+                    # 记录文件的完整信息用于比对
+                    files_info[_fileitm.path] = {
+                        'size': _fileitm.size or 0,
+                        'modify_time': getattr(_fileitm, 'modify_time', 0),
+                        'type': _fileitm.type
+                    }
+            except Exception as e:
+                logger.debug(f"Snapshot error for {_fileitm.path}: {e}")
 
         fileitem = self.get_item(path)
         if not fileitem:

app/modules/filemanager/storages/alipan.py

@@ -5,7 +5,7 @@ import secrets
 import threading
 import time
 from pathlib import Path
-from typing import List, Dict, Optional, Tuple, Union
+from typing import List, Optional, Tuple, Union
 
 import requests
 from tqdm import tqdm
@@ -52,9 +52,6 @@ class AliPan(StorageBase, metaclass=Singleton):
     # 基础url
     base_url = "https://openapi.alipan.com"
 
-    # CID和路径缓存
-    _id_cache: Dict[str, Tuple[str, str]] = {}
-
     def __init__(self):
         super().__init__()
         self.session = requests.Session()
@@ -279,61 +276,6 @@ class AliPan(StorageBase, metaclass=Singleton):
             return ret_data.get(result_key)
         return ret_data
 
-    def _path_to_id(self, drive_id: str, path: str) -> Tuple[str, str]:
-        """
-        路径转drive_id, file_id（带缓存机制）
-        """
-        # 根目录
-        if path == "/":
-            return drive_id, "root"
-        if len(path) > 1 and path.endswith("/"):
-            path = path[:-1]
-        # 检查缓存
-        if path in self._id_cache:
-            return self._id_cache[path]
-        # 逐级查找缓存
-        file_id = "root"
-        file_path = "/"
-        for p in Path(path).parents:
-            if str(p) in self._id_cache:
-                file_path = str(p)
-                file_id = self._id_cache[file_path]
-                break
-        # 计算相对路径
-        rel_path = Path(path).relative_to(file_path)
-        for part in Path(rel_path).parts:
-            find_part = False
-            next_marker = None
-            while True:
-                resp = self._request_api(
-                    "POST",
-                    "/adrive/v1.0/openFile/list",
-                    json={
-                        "drive_id": drive_id,
-                        "limit": 100,
-                        "marker": next_marker,
-                        "parent_file_id": file_id,
-                    }
-                )
-                if not resp:
-                    break
-                for item in resp.get("items", []):
-                    if item["name"] == part:
-                        file_id = item["file_id"]
-                        find_part = True
-                        break
-                if find_part:
-                    break
-                if len(resp.get("items")) < 100:
-                    break
-            if not find_part:
-                raise FileNotFoundError(f"【阿里云盘】{path} 不存在")
-        if file_id == "root":
-            raise FileNotFoundError(f"【阿里云盘】{path} 不存在")
-        # 缓存路径
-        self._id_cache[path] = (drive_id, file_id)
-        return drive_id, file_id
-
     def __get_fileitem(self, fileinfo: dict, parent: str = "/") -> schemas.FileItem:
         """
         获取文件信息
@@ -427,9 +369,6 @@ class AliPan(StorageBase, metaclass=Singleton):
                 break
             next_marker = resp.get("next_marker")
             for item in resp.get("items", []):
-                # 更新缓存
-                path = f"{fileitem.path}{item.get('name')}"
-                self._id_cache[path] = (drive_id, item.get("file_id"))
                 items.append(self.__get_fileitem(item, parent=fileitem.path))
             if len(resp.get("items")) < 100:
                 break
@@ -467,7 +406,6 @@ class AliPan(StorageBase, metaclass=Singleton):
             return None
         # 缓存新目录
         new_path = Path(parent_item.path) / name
-        self._id_cache[str(new_path)] = (resp.get("drive_id"), resp.get("file_id"))
         return self._delay_get_item(new_path)
 
     @staticmethod
@@ -837,15 +775,9 @@ class AliPan(StorageBase, metaclass=Singleton):
         if resp.get("code"):
             logger.warn(f"【阿里云盘】重命名失败: {resp.get('message')}")
             return False
-        if fileitem.path in self._id_cache:
-            del self._id_cache[fileitem.path]
-            for key in list(self._id_cache.keys()):
-                if key.startswith(fileitem.path):
-                    del self._id_cache[key]
-        self._id_cache[str(Path(fileitem.path).parent / name)] = (resp.get("drive_id"), resp.get("file_id"))
         return True
 
-    def get_item(self, path: Path) -> Optional[schemas.FileItem]:
+    def get_item(self, path: Path, drive_id: str = None) -> Optional[schemas.FileItem]:
         """
         获取指定路径的文件/目录项
         """
@@ -854,7 +786,7 @@ class AliPan(StorageBase, metaclass=Singleton):
                 "POST",
                 "/adrive/v1.0/openFile/get_by_path",
                 json={
-                    "drive_id": self._default_drive_id,
+                    "drive_id": drive_id or self._default_drive_id,
                     "file_path": str(path)
                 }
             )
@@ -910,9 +842,15 @@ class AliPan(StorageBase, metaclass=Singleton):
 
     def copy(self, fileitem: schemas.FileItem, path: Path, new_name: str) -> bool:
         """
-        企业级复制实现（支持目录递归复制）
+        复制文件到指定路径
+        :param fileitem: 要复制的文件项
+        :param path: 目标目录路径
+        :param new_name: 新文件名
         """
-        dest_cid = self._path_to_id(fileitem.drive_id, str(path))
+        dest_fileitem = self.get_item(path, drive_id=fileitem.drive_id)
+        if not dest_fileitem or dest_fileitem.type != "dir":
+            logger.warn(f"【阿里云盘】目标路径 {path} 不存在或不是目录！")
+            return False
         resp = self._request_api(
             "POST",
             "/adrive/v1.0/openFile/copy",
@@ -920,7 +858,7 @@ class AliPan(StorageBase, metaclass=Singleton):
                 "drive_id": fileitem.drive_id,
                 "file_id": fileitem.fileid,
                 "to_drive_id": fileitem.drive_id,
-                "to_parent_file_id": dest_cid
+                "to_parent_file_id": dest_fileitem.fileid,
             }
         )
         if not resp:
@@ -932,18 +870,20 @@ class AliPan(StorageBase, metaclass=Singleton):
         new_path = Path(path) / fileitem.name
         new_file = self._delay_get_item(new_path)
         self.rename(new_file, new_name)
-        # 更新缓存
-        del self._id_cache[fileitem.path]
-        rename_new_path = Path(path) / new_name
-        self._id_cache[str(rename_new_path)] = (resp.get("drive_id"), resp.get("file_id"))
         return True
 
     def move(self, fileitem: schemas.FileItem, path: Path, new_name: str) -> bool:
         """
-        原子性移动操作实现
+        移动文件到指定路径
+        :param fileitem: 要移动的文件项
+        :param path: 目标目录路径
+        :param new_name: 新文件名
         """
         src_fid = fileitem.fileid
-        target_id = self._path_to_id(fileitem.drive_id, str(path))
+        target_fileitem = self.get_item(path, drive_id=fileitem.drive_id)
+        if not target_fileitem or target_fileitem.type != "dir":
+            logger.warn(f"【阿里云盘】目标路径 {path} 不存在或不是目录！")
+            return False
 
         resp = self._request_api(
             "POST",
@@ -951,7 +891,7 @@ class AliPan(StorageBase, metaclass=Singleton):
             json={
                 "drive_id": fileitem.drive_id,
                 "file_id": src_fid,
-                "to_parent_file_id": target_id,
+                "to_parent_file_id": target_fileitem.fileid,
                 "new_name": new_name
             }
         )
@@ -960,10 +900,6 @@ class AliPan(StorageBase, metaclass=Singleton):
         if resp.get("code"):
             logger.warn(f"【阿里云盘】移动文件失败: {resp.get('message')}")
             return False
-        # 更新缓存
-        del self._id_cache[fileitem.path]
-        rename_new_path = Path(path) / new_name
-        self._id_cache[str(rename_new_path)] = (resp.get("drive_id"), resp.get("file_id"))
         return True
 
     def link(self, fileitem: schemas.FileItem, target_file: Path) -> bool:

app/modules/filemanager/storages/alist.py

@@ -1,10 +1,9 @@
 import json
 from datetime import datetime
 from pathlib import Path
-from typing import Optional, List, Dict
+from typing import Optional, List
 
 import requests
-from requests import Response
 
 from app import schemas
 from app.core.cache import cached
@@ -20,7 +19,7 @@ from app.utils.url import UrlUtils
 class Alist(StorageBase, metaclass=Singleton):
     """
     Alist相关操作
-    api文档：https://alist.nn.ci/zh/guide/api
+    api文档：https://oplist.org/zh/
     """
 
     # 存储类型
@@ -39,7 +38,7 @@ class Alist(StorageBase, metaclass=Singleton):
         """
         初始化
         """
-        pass
+        self.__generate_token.clear_cache()
 
     @property
     def __get_base_url(self) -> str:
@@ -77,7 +76,7 @@ class Alist(StorageBase, metaclass=Singleton):
         token = conf.get("token")
         if token:
             return str(token)
-        resp: Response = RequestUtils(headers={
+        resp = RequestUtils(headers={
             'Content-Type': 'application/json'
         }).post_res(
             self.__get_api_url("/api/auth/login"),
@@ -102,20 +101,20 @@ class Alist(StorageBase, metaclass=Singleton):
         """
 
         if resp is None:
-            logger.warning("【alist】请求登录失败，无法连接alist服务")
+            logger.warning("【OpenList】请求登录失败，无法连接alist服务")
             return ""
 
         if resp.status_code != 200:
-            logger.warning(f"【alist】更新令牌请求发送失败，状态码：{resp.status_code}")
+            logger.warning(f"【OpenList】更新令牌请求发送失败，状态码：{resp.status_code}")
             return ""
 
         result = resp.json()
 
         if result["code"] != 200:
-            logger.critical(f'【alist】更新令牌，错误信息：{result["message"]}')
+            logger.critical(f'【OpenList】更新令牌，错误信息：{result["message"]}')
             return ""
 
-        logger.debug("【alist】AList获取令牌成功")
+        logger.debug("【OpenList】AList获取令牌成功")
         return result["data"]["token"]
 
     def __get_header_with_token(self) -> dict:
@@ -128,7 +127,7 @@ class Alist(StorageBase, metaclass=Singleton):
         """
         检查存储是否可用
         """
-        pass
+        return True if self.__generate_token else False
 
     def list(
             self,
@@ -151,7 +150,7 @@ class Alist(StorageBase, metaclass=Singleton):
             if item:
                 return [item]
             return []
-        resp: Response = RequestUtils(
+        resp = RequestUtils(
             headers=self.__get_header_with_token()
         ).post_res(
             self.__get_api_url("/api/fs/list"),
@@ -200,11 +199,11 @@ class Alist(StorageBase, metaclass=Singleton):
         """
 
         if resp is None:
-            logger.warn(f"【alist】请求获取目录 {fileitem.path} 的文件列表失败，无法连接alist服务")
+            logger.warn(f"【OpenList】请求获取目录 {fileitem.path} 的文件列表失败，无法连接alist服务")
             return []
         if resp.status_code != 200:
             logger.warn(
-                f"【alist】请求获取目录 {fileitem.path} 的文件列表失败，状态码：{resp.status_code}"
+                f"【OpenList】请求获取目录 {fileitem.path} 的文件列表失败，状态码：{resp.status_code}"
             )
             return []
 
@@ -212,7 +211,7 @@ class Alist(StorageBase, metaclass=Singleton):
 
         if result["code"] != 200:
             logger.warn(
-                f'【alist】获取目录 {fileitem.path} 的文件列表失败，错误信息：{result["message"]}'
+                f'【OpenList】获取目录 {fileitem.path} 的文件列表失败，错误信息：{result["message"]}'
             )
             return []
 
@@ -240,7 +239,7 @@ class Alist(StorageBase, metaclass=Singleton):
         :param name: 目录名
         """
         path = Path(fileitem.path) / name
-        resp: Response = RequestUtils(
+        resp = RequestUtils(
             headers=self.__get_header_with_token()
         ).post_res(
             self.__get_api_url("/api/fs/mkdir"),
@@ -258,15 +257,15 @@ class Alist(StorageBase, metaclass=Singleton):
         }
         """
         if resp is None:
-            logger.warn(f"【alist】请求创建目录 {path} 失败，无法连接alist服务")
+            logger.warn(f"【OpenList】请求创建目录 {path} 失败，无法连接alist服务")
             return None
         if resp.status_code != 200:
-            logger.warn(f"【alist】请求创建目录 {path} 失败，状态码：{resp.status_code}")
+            logger.warn(f"【OpenList】请求创建目录 {path} 失败，状态码：{resp.status_code}")
             return None
 
         result = resp.json()
         if result["code"] != 200:
-            logger.warn(f'【alist】创建目录 {path} 失败，错误信息：{result["message"]}')
+            logger.warn(f'【OpenList】创建目录 {path} 失败，错误信息：{result["message"]}')
             return None
 
         return self.get_item(path)
@@ -304,7 +303,7 @@ class Alist(StorageBase, metaclass=Singleton):
         :param per_page: 每页数量
         :param refresh: 是否刷新
         """
-        resp: Response = RequestUtils(
+        resp = RequestUtils(
             headers=self.__get_header_with_token()
         ).post_res(
             self.__get_api_url("/api/fs/get"),
@@ -348,15 +347,15 @@ class Alist(StorageBase, metaclass=Singleton):
         }
         """
         if resp is None:
-            logger.warn(f"【alist】请求获取文件 {path} 失败，无法连接alist服务")
+            logger.warn(f"【OpenList】请求获取文件 {path} 失败，无法连接alist服务")
             return None
         if resp.status_code != 200:
-            logger.warn(f"【alist】请求获取文件 {path} 失败，状态码：{resp.status_code}")
+            logger.warn(f"【OpenList】请求获取文件 {path} 失败，状态码：{resp.status_code}")
             return None
 
         result = resp.json()
         if result["code"] != 200:
-            logger.debug(f'【alist】获取文件 {path} 失败，错误信息：{result["message"]}')
+            logger.debug(f'【OpenList】获取文件 {path} 失败，错误信息：{result["message"]}')
             return None
 
         return schemas.FileItem(
@@ -381,7 +380,7 @@ class Alist(StorageBase, metaclass=Singleton):
         """
         删除文件
         """
-        resp: Response = RequestUtils(
+        resp = RequestUtils(
             headers=self.__get_header_with_token()
         ).post_res(
             self.__get_api_url("/api/fs/remove"),
@@ -405,18 +404,18 @@ class Alist(StorageBase, metaclass=Singleton):
         }
         """
         if resp is None:
-            logger.warn(f"【alist】请求删除文件 {fileitem.path} 失败，无法连接alist服务")
+            logger.warn(f"【OpenList】请求删除文件 {fileitem.path} 失败，无法连接alist服务")
             return False
         if resp.status_code != 200:
             logger.warn(
-                f"【alist】请求删除文件 {fileitem.path} 失败，状态码：{resp.status_code}"
+                f"【OpenList】请求删除文件 {fileitem.path} 失败，状态码：{resp.status_code}"
             )
             return False
 
         result = resp.json()
         if result["code"] != 200:
             logger.warn(
-                f'【alist】删除文件 {fileitem.path} 失败，错误信息：{result["message"]}'
+                f'【OpenList】删除文件 {fileitem.path} 失败，错误信息：{result["message"]}'
             )
             return False
         return True
@@ -425,7 +424,7 @@ class Alist(StorageBase, metaclass=Singleton):
         """
         重命名文件
         """
-        resp: Response = RequestUtils(
+        resp = RequestUtils(
             headers=self.__get_header_with_token()
         ).post_res(
             self.__get_api_url("/api/fs/rename"),
@@ -447,18 +446,18 @@ class Alist(StorageBase, metaclass=Singleton):
         }
         """
         if not resp:
-            logger.warn(f"【alist】请求重命名文件 {fileitem.path} 失败，无法连接alist服务")
+            logger.warn(f"【OpenList】请求重命名文件 {fileitem.path} 失败，无法连接alist服务")
             return False
         if resp.status_code != 200:
             logger.warn(
-                f"【alist】请求重命名文件 {fileitem.path} 失败，状态码：{resp.status_code}"
+                f"【OpenList】请求重命名文件 {fileitem.path} 失败，状态码：{resp.status_code}"
             )
             return False
 
         result = resp.json()
         if result["code"] != 200:
             logger.warn(
-                f'【alist】重命名文件 {fileitem.path} 失败，错误信息：{result["message"]}'
+                f'【OpenList】重命名文件 {fileitem.path} 失败，错误信息：{result["message"]}'
             )
             return False
 
@@ -476,7 +475,7 @@ class Alist(StorageBase, metaclass=Singleton):
         :param path: 文件保存路径
         :param password: 文件密码
         """
-        resp: Response = RequestUtils(
+        resp = RequestUtils(
             headers=self.__get_header_with_token()
         ).post_res(
             self.__get_api_url("/api/fs/get"),
@@ -512,15 +511,15 @@ class Alist(StorageBase, metaclass=Singleton):
         }
         """
         if not resp:
-            logger.warn(f"【alist】请求获取文件 {path} 失败，无法连接alist服务")
+            logger.warn(f"【OpenList】请求获取文件 {path} 失败，无法连接alist服务")
             return None
         if resp.status_code != 200:
-            logger.warn(f"【alist】请求获取文件 {path} 失败，状态码：{resp.status_code}")
+            logger.warn(f"【OpenList】请求获取文件 {path} 失败，状态码：{resp.status_code}")
             return None
 
         result = resp.json()
         if result["code"] != 200:
-            logger.warn(f'【alist】获取文件 {path} 失败，错误信息：{result["message"]}')
+            logger.warn(f'【OpenList】获取文件 {path} 失败，错误信息：{result["message"]}')
             return None
 
         if result["data"]["raw_url"]:
@@ -561,13 +560,13 @@ class Alist(StorageBase, metaclass=Singleton):
         headers.setdefault("As-Task", str(task).lower())
         headers.setdefault("File-Path", encoded_path)
         with open(path, "rb") as f:
-            resp: Response = RequestUtils(headers=headers).put_res(
+            resp = RequestUtils(headers=headers).put_res(
                 self.__get_api_url("/api/fs/put"),
                 data=f,
             )
 
         if resp.status_code != 200:
-            logger.warn(f"【alist】请求上传文件 {path} 失败，状态码：{resp.status_code}")
+            logger.warn(f"【OpenList】请求上传文件 {path} 失败，状态码：{resp.status_code}")
             return None
 
         new_item = self.get_item(Path(fileitem.path) / path.name)
@@ -590,7 +589,7 @@ class Alist(StorageBase, metaclass=Singleton):
         :param path: 目标目录
         :param new_name: 新文件名
         """
-        resp: Response = RequestUtils(
+        resp = RequestUtils(
             headers=self.__get_header_with_token()
         ).post_res(
             self.__get_api_url("/api/fs/copy"),
@@ -617,19 +616,19 @@ class Alist(StorageBase, metaclass=Singleton):
         """
         if resp is None:
             logger.warn(
-                f"【alist】请求复制文件 {fileitem.path} 失败，无法连接alist服务"
+                f"【OpenList】请求复制文件 {fileitem.path} 失败，无法连接alist服务"
             )
             return False
         if resp.status_code != 200:
             logger.warn(
-                f"【alist】请求复制文件 {fileitem.path} 失败，状态码：{resp.status_code}"
+                f"【OpenList】请求复制文件 {fileitem.path} 失败，状态码：{resp.status_code}"
             )
             return False
 
         result = resp.json()
         if result["code"] != 200:
             logger.warn(
-                f'【alist】复制文件 {fileitem.path} 失败，错误信息：{result["message"]}'
+                f'【OpenList】复制文件 {fileitem.path} 失败，错误信息：{result["message"]}'
             )
             return False
         # 重命名
@@ -649,7 +648,7 @@ class Alist(StorageBase, metaclass=Singleton):
         # 先重命名
         if fileitem.name != new_name:
             self.rename(fileitem, new_name)
-        resp: Response = RequestUtils(
+        resp = RequestUtils(
             headers=self.__get_header_with_token()
         ).post_res(
             self.__get_api_url("/api/fs/move"),
@@ -676,19 +675,19 @@ class Alist(StorageBase, metaclass=Singleton):
         """
         if resp is None:
             logger.warn(
-                f"【alist】请求移动文件 {fileitem.path} 失败，无法连接alist服务"
+                f"【OpenList】请求移动文件 {fileitem.path} 失败，无法连接alist服务"
             )
             return False
         if resp.status_code != 200:
             logger.warn(
-                f"【alist】请求移动文件 {fileitem.path} 失败，状态码：{resp.status_code}"
+                f"【OpenList】请求移动文件 {fileitem.path} 失败，状态码：{resp.status_code}"
             )
             return False
 
         result = resp.json()
         if result["code"] != 200:
             logger.warn(
-                f'【alist】移动文件 {fileitem.path} 失败，错误信息：{result["message"]}'
+                f'【OpenList】移动文件 {fileitem.path} 失败，错误信息：{result["message"]}'
             )
             return False
         return True
@@ -711,30 +710,6 @@ class Alist(StorageBase, metaclass=Singleton):
         """
         pass
 
-    def snapshot(self, path: Path) -> Dict[str, float]:
-        """
-        快照文件系统，输出所有层级文件信息（不含目录）
-        """
-        files_info = {}
-
-        def __snapshot_file(_fileitm: schemas.FileItem):
-            """
-            递归获取文件信息
-            """
-            if _fileitm.type == "dir":
-                for sub_file in self.list(_fileitm):
-                    __snapshot_file(sub_file)
-            else:
-                files_info[_fileitm.path] = _fileitm.size
-
-        fileitem = self.get_item(path)
-        if not fileitem:
-            return {}
-
-        __snapshot_file(fileitem)
-
-        return files_info
-
     @staticmethod
     def __parse_timestamp(time_str: str) -> float:
         """

app/modules/filemanager/storages/local.py

@@ -191,7 +191,8 @@ class LocalStorage(StorageBase):
         """
         return Path(fileitem.path)
 
-    def upload(self, fileitem: schemas.FileItem, path: Path, new_name: Optional[str] = None) -> Optional[schemas.FileItem]:
+    def upload(self, fileitem: schemas.FileItem, path: Path,
+               new_name: Optional[str] = None) -> Optional[schemas.FileItem]:
         """
         上传文件
         :param fileitem: 上传目录项
@@ -260,8 +261,11 @@ class LocalStorage(StorageBase):
         """
         存储使用情况
         """
-        library_dirs = DirectoryHelper().get_local_library_dirs()
-        total_storage, free_storage = SystemUtils.space_usage([Path(d.library_path) for d in library_dirs])
+        directory_helper = DirectoryHelper()
+        total_storage, free_storage = SystemUtils.space_usage(
+            [Path(d.download_path) for d in directory_helper.get_local_download_dirs() if d.download_path] +
+            [Path(d.library_path) for d in directory_helper.get_local_library_dirs() if d.library_path]
+        )
         return schemas.StorageUsage(
             total=total_storage,
             available=free_storage

app/modules/filemanager/storages/smb.py

@@ -0,0 +1,549 @@
+import threading
+import time
+from pathlib import Path
+from typing import List, Optional, Union
+
+import smbclient
+from smbclient import ClientConfig, register_session, reset_connection_cache
+from smbprotocol.exceptions import SMBException, SMBResponseException, SMBAuthenticationError
+
+from app import schemas
+from app.core.config import settings
+from app.log import logger
+from app.modules.filemanager import StorageBase
+from app.schemas.types import StorageSchema
+from app.utils.singleton import Singleton
+
+lock = threading.Lock()
+
+
+class SMBConnectionError(Exception):
+    """SMB 连接错误"""
+    pass
+
+
+class SMB(StorageBase, metaclass=Singleton):
+    """
+    SMB网络挂载存储相关操作 - 使用 smbclient 高级接口
+    """
+
+    # 存储类型
+    schema = StorageSchema.SMB
+
+    # 支持的整理方式
+    transtype = {
+        "move": "移动",
+        "copy": "复制",
+    }
+
+    def __init__(self):
+        super().__init__()
+        self._connected = False
+        self._server_path = None
+        self._host = None
+        self._username = None
+        self._password = None
+        self._init_connection()
+
+    def _init_connection(self):
+        """
+        初始化SMB连接配置
+        """
+        try:
+            conf = self.get_conf()
+            if not conf:
+                return
+
+            self._host = conf.get("host")
+            self._username = conf.get("username")
+            self._password = conf.get("password")
+            domain = conf.get("domain", "")
+            share = conf.get("share", "")
+            port = conf.get("port", 445)
+
+            if not all([self._host, share]):
+                logger.error("【SMB】缺少必要的连接参数：host 和 share")
+                return
+
+            # 构建服务器路径
+            self._server_path = f"\\\\{self._host}\\{share}"
+
+            # 配置全局客户端设置
+            ClientConfig(
+                username=self._username,
+                password=self._password,
+                domain=domain if domain else None,
+                connection_timeout=60,
+                port=port,
+                auth_protocol="negotiate",  # 使用协商认证
+                require_secure_negotiate=False  # 匿名访问时可能需要关闭安全协商
+            )
+
+            # 注册会话以启用连接池
+            register_session(
+                self._host,
+                username=self._username,
+                password=self._password,
+                port=port,
+                encrypt=False,  # 根据需要启用加密
+                connection_timeout=60
+            )
+
+            # 测试连接
+            self._test_connection()
+
+            self._connected = True
+            # 判断是否为匿名访问
+            if self._is_anonymous_access():
+                logger.info(f"【SMB】匿名连接成功：{self._server_path}")
+            else:
+                logger.info(f"【SMB】认证连接成功：{self._server_path} (用户：{self._username})")
+
+        except Exception as e:
+            logger.error(f"【SMB】连接初始化失败：{e}")
+            self._connected = False
+
+    def _test_connection(self):
+        """
+        测试SMB连接
+        """
+        try:
+            # 尝试列出根目录来测试连接
+            smbclient.listdir(self._server_path)
+        except SMBAuthenticationError as e:
+            raise SMBConnectionError(f"SMB认证失败：{e}")
+        except SMBResponseException as e:
+            raise SMBConnectionError(f"SMB响应错误：{e}")
+        except SMBException as e:
+            raise SMBConnectionError(f"SMB连接错误：{e}")
+        except Exception as e:
+            raise SMBConnectionError(f"连接测试失败：{e}")
+
+    def _is_anonymous_access(self) -> bool:
+        """
+        检查是否为匿名访问
+        """
+        return not self._username and not self._password
+
+    def _check_connection(self):
+        """
+        检查SMB连接状态
+        """
+        if not self._connected or not self._server_path:
+            raise SMBConnectionError("【SMB】连接未建立或已断开，请检查配置！")
+
+    def _normalize_path(self, path: Union[str, Path]) -> str:
+        """
+        标准化路径格式为SMB路径
+        """
+        path_str = str(path)
+
+        # 处理根路径
+        if path_str in ["/", "\\"]:
+            return self._server_path
+
+        # 去除前导斜杠
+        if path_str.startswith("/"):
+            path_str = path_str[1:]
+
+        # 构建完整的SMB路径
+        if path_str:
+            return f"{self._server_path}\\{path_str.replace('/', '\\')}"
+        else:
+            return self._server_path
+
+    def _create_fileitem(self, stat_result, file_path: str, name: str) -> schemas.FileItem:
+        """
+        创建文件项
+        """
+        try:
+            # 检查是否为目录
+            is_directory = smbclient.path.isdir(file_path)
+
+            # 处理路径
+            relative_path = file_path.replace(self._server_path, "").replace("\\", "/")
+            if not relative_path.startswith("/"):
+                relative_path = "/" + relative_path
+
+            if is_directory and not relative_path.endswith("/"):
+                relative_path += "/"
+
+            # 获取时间戳
+            try:
+                modify_time = int(stat_result.st_mtime)
+            except (AttributeError, TypeError):
+                modify_time = int(time.time())
+
+            if is_directory:
+                return schemas.FileItem(
+                    storage=self.schema.value,
+                    type="dir",
+                    path=relative_path,
+                    name=name,
+                    basename=name,
+                    modify_time=modify_time
+                )
+            else:
+                return schemas.FileItem(
+                    storage=self.schema.value,
+                    type="file",
+                    path=relative_path,
+                    name=name,
+                    basename=Path(name).stem,
+                    extension=Path(name).suffix[1:] if Path(name).suffix else None,
+                    size=getattr(stat_result, 'st_size', 0),
+                    modify_time=modify_time
+                )
+        except Exception as e:
+            logger.error(f"【SMB】创建文件项失败：{e}")
+            # 返回基本的文件项信息
+            return schemas.FileItem(
+                storage=self.schema.value,
+                type="file",
+                path=file_path.replace(self._server_path, "").replace("\\", "/"),
+                name=name,
+                basename=Path(name).stem,
+                modify_time=int(time.time())
+            )
+
+    def init_storage(self):
+        """
+        初始化存储
+        """
+        # 重置连接缓存
+        reset_connection_cache()
+        self._init_connection()
+
+    def check(self) -> bool:
+        """
+        检查存储是否可用
+        """
+        if not self._connected:
+            return False
+
+        try:
+            self._test_connection()
+            return True
+        except Exception as e:
+            logger.debug(f"【SMB】连接检查失败：{e}")
+            self._connected = False
+            return False
+
+    def list(self, fileitem: schemas.FileItem) -> List[schemas.FileItem]:
+        """
+        浏览文件
+        """
+        try:
+            self._check_connection()
+
+            if fileitem.type == "file":
+                item = self.detail(fileitem)
+                if item:
+                    return [item]
+                return []
+
+            # 构建SMB路径
+            smb_path = self._normalize_path(fileitem.path.rstrip("/"))
+
+            # 列出目录内容
+            try:
+                entries = smbclient.listdir(smb_path)
+            except SMBResponseException as e:
+                logger.error(f"【SMB】列出目录失败: {smb_path} - {e}")
+                return []
+            except SMBException as e:
+                logger.error(f"【SMB】列出目录失败: {smb_path} - {e}")
+                return []
+
+            items = []
+            for entry in entries:
+                if entry in [".", ".."]:
+                    continue
+
+                entry_path = f"{smb_path}\\{entry}"
+                try:
+                    stat_result = smbclient.stat(entry_path)
+                    item = self._create_fileitem(stat_result, entry_path, entry)
+                    items.append(item)
+                except Exception as e:
+                    logger.debug(f"【SMB】获取文件信息失败: {entry_path} - {e}")
+                    continue
+
+            return items
+        except Exception as e:
+            logger.error(f"【SMB】列出文件失败: {e}")
+            return []
+
+    def create_folder(self, fileitem: schemas.FileItem, name: str) -> Optional[schemas.FileItem]:
+        """
+        创建目录
+        """
+        try:
+            self._check_connection()
+
+            parent_path = self._normalize_path(fileitem.path.rstrip("/"))
+            new_path = f"{parent_path}\\{name}"
+
+            # 创建目录
+            smbclient.mkdir(new_path)
+
+            # 返回创建的目录信息
+            return schemas.FileItem(
+                storage=self.schema.value,
+                type="dir",
+                path=f"{fileitem.path.rstrip('/')}/{name}/",
+                name=name,
+                basename=name,
+                modify_time=int(time.time())
+            )
+        except Exception as e:
+            logger.error(f"【SMB】创建目录失败: {e}")
+            return None
+
+    def get_folder(self, path: Path) -> Optional[schemas.FileItem]:
+        """
+        获取目录，如目录不存在则创建
+        """
+        # 检查目录是否存在
+        folder = self.get_item(path)
+        if folder:
+            return folder
+
+        # 逐级创建目录
+        parts = path.parts
+        current_path = Path("/")
+
+        for part in parts[1:]:  # 跳过根目录
+            current_path = current_path / part
+            folder = self.get_item(current_path)
+            if not folder:
+                parent_folder = self.get_item(current_path.parent)
+                if not parent_folder:
+                    logger.error(f"【SMB】父目录不存在: {current_path.parent}")
+                    return None
+                folder = self.create_folder(parent_folder, part)
+                if not folder:
+                    return None
+
+        return folder
+
+    def get_item(self, path: Path) -> Optional[schemas.FileItem]:
+        """
+        获取文件或目录，不存在返回None
+        """
+        try:
+            self._check_connection()
+
+            # 处理根目录
+            if str(path) == "/":
+                return schemas.FileItem(
+                    storage=self.schema.value,
+                    type="dir",
+                    path="/",
+                    name="",
+                    basename="",
+                    modify_time=int(time.time())
+                )
+
+            smb_path = self._normalize_path(str(path).rstrip("/"))
+
+            # 检查路径是否存在
+            if not smbclient.path.exists(smb_path):
+                return None
+
+            stat_result = smbclient.stat(smb_path)
+            file_name = Path(path).name
+
+            return self._create_fileitem(stat_result, smb_path, file_name)
+
+        except Exception as e:
+            logger.debug(f"【SMB】获取文件项失败: {e}")
+            return None
+
+    def detail(self, fileitem: schemas.FileItem) -> Optional[schemas.FileItem]:
+        """
+        获取文件详情
+        """
+        return self.get_item(Path(fileitem.path))
+
+    def delete(self, fileitem: schemas.FileItem) -> bool:
+        """
+        删除文件或目录
+        """
+        try:
+            self._check_connection()
+
+            smb_path = self._normalize_path(fileitem.path.rstrip("/"))
+
+            if fileitem.type == "dir":
+                # 删除目录
+                smbclient.rmdir(smb_path)
+            else:
+                # 删除文件
+                smbclient.remove(smb_path)
+
+            logger.info(f"【SMB】删除成功: {fileitem.path}")
+            return True
+        except Exception as e:
+            logger.error(f"【SMB】删除失败: {e}")
+            return False
+
+    def rename(self, fileitem: schemas.FileItem, name: str) -> bool:
+        """
+        重命名文件
+        """
+        try:
+            self._check_connection()
+
+            old_path = self._normalize_path(fileitem.path.rstrip("/"))
+            parent_path = Path(fileitem.path).parent
+            new_path = self._normalize_path(str(parent_path / name))
+
+            # 重命名
+            smbclient.rename(old_path, new_path)
+
+            logger.info(f"【SMB】重命名成功: {fileitem.path} -> {name}")
+            return True
+        except Exception as e:
+            logger.error(f"【SMB】重命名失败: {e}")
+            return False
+
+    def download(self, fileitem: schemas.FileItem, path: Path = None) -> Optional[Path]:
+        """
+        下载文件
+        """
+        try:
+            self._check_connection()
+
+            smb_path = self._normalize_path(fileitem.path)
+            local_path = path or settings.TEMP_PATH / fileitem.name
+
+            # 确保本地目录存在
+            local_path.parent.mkdir(parents=True, exist_ok=True)
+
+            # 使用更高效的文件传输方式
+            with smbclient.open_file(smb_path, mode="rb") as src_file:
+                with open(local_path, "wb") as dst_file:
+                    # 使用更大的缓冲区提高性能
+                    buffer_size = 1024 * 1024  # 1MB
+                    while True:
+                        chunk = src_file.read(buffer_size)
+                        if not chunk:
+                            break
+                        dst_file.write(chunk)
+
+            logger.info(f"【SMB】下载成功: {fileitem.path} -> {local_path}")
+            return local_path
+        except Exception as e:
+            logger.error(f"【SMB】下载失败: {e}")
+            return None
+
+    def upload(self, fileitem: schemas.FileItem, path: Path,
+               new_name: Optional[str] = None) -> Optional[schemas.FileItem]:
+        """
+        上传文件
+        """
+        try:
+            self._check_connection()
+
+            target_name = new_name or path.name
+            target_path = Path(fileitem.path) / target_name
+            smb_path = self._normalize_path(str(target_path))
+
+            # 使用更高效的文件传输方式
+            with open(path, "rb") as src_file:
+                with smbclient.open_file(smb_path, mode="wb") as dst_file:
+                    # 使用更大的缓冲区提高性能
+                    buffer_size = 1024 * 1024  # 1MB
+                    while True:
+                        chunk = src_file.read(buffer_size)
+                        if not chunk:
+                            break
+                        dst_file.write(chunk)
+
+            logger.info(f"【SMB】上传成功: {path} -> {target_path}")
+
+            # 返回上传后的文件信息
+            return self.get_item(target_path)
+        except Exception as e:
+            logger.error(f"【SMB】上传失败: {e}")
+            return None
+
+    def copy(self, fileitem: schemas.FileItem, path: Path, new_name: str) -> bool:
+        """
+        复制文件
+        """
+        try:
+            # 下载到临时文件
+            temp_file = self.download(fileitem)
+            if not temp_file:
+                return False
+
+            # 获取目标目录
+            target_folder = self.get_item(path)
+            if not target_folder:
+                return False
+
+            # 上传到目标位置
+            result = self.upload(target_folder, temp_file, new_name)
+
+            # 删除临时文件
+            if temp_file.exists():
+                temp_file.unlink()
+
+            return result is not None
+        except Exception as e:
+            logger.error(f"【SMB】复制失败: {e}")
+            return False
+
+    def move(self, fileitem: schemas.FileItem, path: Path, new_name: str) -> bool:
+        """
+        移动文件
+        """
+        try:
+            # 先复制
+            if not self.copy(fileitem, path, new_name):
+                return False
+
+            # 再删除原文件
+            if not self.delete(fileitem):
+                logger.warn(f"【SMB】删除原文件失败: {fileitem.path}")
+                return False
+
+            return True
+        except Exception as e:
+            logger.error(f"【SMB】移动失败: {e}")
+            return False
+
+    def link(self, fileitem: schemas.FileItem, target_file: Path) -> bool:
+        pass
+
+    def softlink(self, fileitem: schemas.FileItem, target_file: Path) -> bool:
+        pass
+
+    def usage(self) -> Optional[schemas.StorageUsage]:
+        """
+        存储使用情况
+        """
+        try:
+            self._check_connection()
+            volume_stat = smbclient.stat_volume(self._server_path)
+            return schemas.StorageUsage(
+                total=volume_stat.total_size,
+                available=volume_stat.caller_available_size
+            )
+
+        except Exception as e:
+            logger.error(f"【SMB】获取存储使用情况失败: {e}")
+            return None
+
+    def __del__(self):
+        """
+        析构函数，清理连接
+        """
+        try:
+            # smbclient 自动管理连接池，但我们可以重置缓存
+            if hasattr(self, '_connected') and self._connected:
+                reset_connection_cache()
+        except Exception as e:
+            logger.debug(f"【SMB】清理连接失败: {e}")

app/modules/filemanager/storages/u115.py

@@ -5,7 +5,7 @@ import secrets
 import threading
 import time
 from pathlib import Path
-from typing import List, Dict, Optional, Tuple, Union
+from typing import List, Optional, Tuple, Union
 
 import oss2
 import requests
@@ -51,9 +51,6 @@ class U115Pan(StorageBase, metaclass=Singleton):
     # 基础url
     base_url = "https://proapi.115.com"
 
-    # CID和路径缓存
-    _id_cache: Dict[str, str] = {}
-
     def __init__(self):
         super().__init__()
         self.session = requests.Session()
@@ -238,58 +235,6 @@ class U115Pan(StorageBase, metaclass=Singleton):
             return ret_data.get(result_key)
         return ret_data
 
-    def _path_to_id(self, path: str) -> str:
-        """
-        路径转FID（带缓存机制）
-        """
-        # 根目录
-        if path == "/":
-            return '0'
-        if len(path) > 1 and path.endswith("/"):
-            path = path[:-1]
-        # 检查缓存
-        if path in self._id_cache:
-            return self._id_cache[path]
-        # 逐级查找缓存
-        current_id = 0
-        parent_path = "/"
-        for p in Path(path).parents:
-            if str(p) in self._id_cache:
-                parent_path = str(p)
-                current_id = self._id_cache[parent_path]
-                break
-        # 计算相对路径
-        rel_path = Path(path).relative_to(parent_path)
-        for part in Path(rel_path).parts:
-            offset = 0
-            find_part = False
-            while True:
-                resp = self._request_api(
-                    "GET",
-                    "/open/ufile/files",
-                    "data",
-                    params={"cid": current_id, "limit": 1000, "offset": offset, "cur": True, "show_dir": 1}
-                )
-                if not resp:
-                    break
-                for item in resp:
-                    if item["fn"] == part:
-                        current_id = item["fid"]
-                        find_part = True
-                        break
-                if find_part:
-                    break
-                if len(resp) < 1000:
-                    break
-                offset += len(resp)
-            if not find_part:
-                raise FileNotFoundError(f"【115】{path} 不存在")
-        if not current_id:
-            raise FileNotFoundError(f"【115】{path} 不存在")
-        # 缓存路径
-        self._id_cache[path] = str(current_id)
-        return str(current_id)
-
     @staticmethod
     def _calc_sha1(filepath: Path, size: Optional[int] = None) -> str:
         """
@@ -335,7 +280,11 @@ class U115Pan(StorageBase, metaclass=Singleton):
         else:
             cid = fileitem.fileid
             if not cid:
-                cid = self._path_to_id(fileitem.path)
+                _fileitem = self.get_item(Path(fileitem.path))
+                if not _fileitem:
+                    logger.warn(f"【115】获取目录 {fileitem.path} 失败！")
+                    return []
+                cid = _fileitem.fileid
 
         items = []
         offset = 0
@@ -354,8 +303,6 @@ class U115Pan(StorageBase, metaclass=Singleton):
             for item in resp:
                 # 更新缓存
                 path = f"{fileitem.path}{item['fn']}"
-                self._id_cache[path] = str(item["fid"])
-
                 file_path = path + ("/" if item["fc"] == "0" else "")
                 items.append(schemas.FileItem(
                     storage=self.schema.value,
@@ -398,8 +345,6 @@ class U115Pan(StorageBase, metaclass=Singleton):
                 return self.get_item(new_path)
             logger.warn(f"【115】创建目录失败: {resp.get('error')}")
             return None
-        # 缓存新目录
-        self._id_cache[str(new_path)] = str(resp["data"]["file_id"])
         return schemas.FileItem(
             storage=self.schema.value,
             fileid=str(resp["data"]["file_id"]),
@@ -716,13 +661,6 @@ class U115Pan(StorageBase, metaclass=Singleton):
         if not resp:
             return False
         if resp["state"]:
-            if fileitem.path in self._id_cache:
-                del self._id_cache[fileitem.path]
-                for key in list(self._id_cache.keys()):
-                    if key.startswith(fileitem.path):
-                        del self._id_cache[key]
-            new_path = Path(fileitem.path).parent / name
-            self._id_cache[str(new_path)] = fileitem.fileid
             return True
         return False
 
@@ -731,15 +669,12 @@ class U115Pan(StorageBase, metaclass=Singleton):
         获取指定路径的文件/目录项
         """
         try:
-            file_id = self._path_to_id(str(path))
-            if not file_id:
-                return None
             resp = self._request_api(
-                "GET",
+                "POST",
                 "/open/folder/get_info",
                 "data",
-                params={
-                    "file_id": int(file_id)
+                data={
+                    "path": str(path)
                 }
             )
             if not resp:
@@ -753,7 +688,7 @@ class U115Pan(StorageBase, metaclass=Singleton):
                 basename=Path(resp["file_name"]).stem,
                 extension=Path(resp["file_name"]).suffix[1:] if resp["file_category"] == "1" else None,
                 pickcode=resp["pick_code"],
-                size=StringUtils.num_filesize(resp['size']) if resp["file_category"] == "1" else None,
+                size=resp['size_byte'] if resp["file_category"] == "1" else None,
                 modify_time=resp["utime"]
             )
         except Exception as e:
@@ -805,14 +740,17 @@ class U115Pan(StorageBase, metaclass=Singleton):
         企业级复制实现（支持目录递归复制）
         """
         src_fid = fileitem.fileid
-        dest_cid = self._path_to_id(str(path))
+        dest_fileitem = self.get_item(path)
+        if not dest_fileitem or dest_fileitem.type != "dir":
+            logger.warn(f"【115】目标路径 {path} 不是一个有效的目录！")
+            return False
 
         resp = self._request_api(
             "POST",
             "/open/ufile/copy",
             data={
                 "file_id": int(src_fid),
-                "pid": int(dest_cid)
+                "pid": int(dest_fileitem.fileid),
             }
         )
         if not resp:
@@ -821,10 +759,6 @@ class U115Pan(StorageBase, metaclass=Singleton):
             new_path = Path(path) / fileitem.name
             new_item = self._delay_get_item(new_path)
             self.rename(new_item, new_name)
-            # 更新缓存
-            del self._id_cache[fileitem.path]
-            rename_new_path = Path(path) / new_name
-            self._id_cache[str(rename_new_path)] = new_item.fileid
             return True
         return False
 
@@ -833,14 +767,16 @@ class U115Pan(StorageBase, metaclass=Singleton):
         原子性移动操作实现
         """
         src_fid = fileitem.fileid
-        dest_cid = self._path_to_id(str(path))
-
+        dest_fileitem = self.get_item(path)
+        if not dest_fileitem or dest_fileitem.type != "dir":
+            logger.warn(f"【115】目标路径 {path} 不是一个有效的目录！")
+            return False
         resp = self._request_api(
             "POST",
             "/open/ufile/move",
             data={
                 "file_ids": int(src_fid),
-                "to_cid": int(dest_cid)
+                "to_cid": int(dest_fileitem.fileid),
             }
         )
         if not resp:
@@ -849,10 +785,6 @@ class U115Pan(StorageBase, metaclass=Singleton):
             new_path = Path(path) / fileitem.name
             new_file = self._delay_get_item(new_path)
             self.rename(new_file, new_name)
-            # 更新缓存
-            del self._id_cache[fileitem.path]
-            rename_new_path = Path(path) / new_name
-            self._id_cache[str(rename_new_path)] = src_fid
             return True
         return False
 

app/modules/filter/RuleParser.py

@@ -54,7 +54,7 @@ class RuleParser:
 if __name__ == '__main__':
     # 测试代码
     expression_str = """
-     SPECSUB & CNVOI & 4K & !BLU & !REMUX & !WEBDL & 60FPS & !DOLBY & !SDR & !3D > CNSUB & CNVOI & 4K & !BLU & !REMUX & !WEBDL & 60FPS & !DOLBY & !SDR & !3D > SPECSUB & 4K & !BLU & !REMUX & !WEBDL & 60FPS & !DOLBY & !SDR & !3D > CNSUB & 4K & !BLU & !REMUX & !WEBDL & 60FPS & !DOLBY & !SDR & !3D > SPECSUB & CNVOI & 4K & !BLU & !REMUX & !WEBDL & !DOLBY & HDR & !3D > CNSUB & CNVOI & 4K & !BLU & !REMUX & !WEBDL & !DOLBY & HDR & !3D > SPECSUB & CNVOI & 4K & !BLU & !REMUX & !WEBDL & !DOLBY & !3D > CNSUB & CNVOI & 4K & !BLU & !REMUX & !WEBDL & !DOLBY & !3D > SPECSUB & 4K & !BLU & !REMUX & !WEBDL & !DOLBY & HDR & !3D > CNSUB & 4K & !BLU & !REMUX & !WEBDL & !DOLBY & HDR & !3D > SPECSUB & 4K & !BLU & !REMUX & !WEBDL & !DOLBY & !3D > CNSUB & 4K & !BLU & !REMUX & !WEBDL & !DOLBY & !3D > SPECSUB & CNVOI & 4K & WEBDL & 60FPS & !DOLBY & !SDR & !3D > CNSUB & CNVOI & 4K & WEBDL & 60FPS & !DOLBY & !SDR & !3D > SPECSUB & 4K & WEBDL & 60FPS & !DOLBY & !SDR & !3D > CNSUB & 4K & WEBDL & 60FPS & !DOLBY & !SDR & !3D > SPECSUB & CNVOI & 4K & WEBDL & !DOLBY & HDR & !3D > CNSUB & CNVOI & 4K & WEBDL & !DOLBY & HDR & !3D > SPECSUB & CNVOI & 4K & WEBDL & !DOLBY & !3D > CNSUB & CNVOI & 4K & WEBDL & !DOLBY & !3D > SPECSUB & 4K & WEBDL & !DOLBY & HDR & !3D > CNSUB & 4K & WEBDL & !DOLBY & HDR & !3D > SPECSUB & 4K & WEBDL & !DOLBY & !3D > CNSUB & 4K & WEBDL & !DOLBY & !3D > SPECSUB & CNVOI & 4K & !BLU & !WEBDL & !DOLBY & HDR & !3D > CNSUB & CNVOI & 4K & !BLU & !WEBDL & !DOLBY & HDR & !3D > SPECSUB & CNVOI & 4K & !BLU & !WEBDL & !DOLBY & !3D > CNSUB & CNVOI & 4K & !BLU & !WEBDL & !DOLBY & !3D > SPECSUB & 4K & !BLU & !WEBDL & !DOLBY & HDR & !3D > CNSUB & 4K & !BLU & !WEBDL & !DOLBY & HDR & !3D > SPECSUB & 4K & !BLU & !WEBDL & !DOLBY & !SDR & !3D > CNSUB & 4K & !BLU & !WEBDL & !DOLBY & !SDR & !3D > 4K & !BLU & !REMUX & !DOLBY & HDR & !3D > 4K & !BLURAY & !REMUX & !DOLBY & !3D > SPECSUB & 1080P & !BLU & !REMUX & !WEBDL & !DOLBY & HDR & !3D > CNSUB & 1080P & !BLU & !REMUX & !WEBDL & !DOLBY & HDR & !3D > SPECSUB & 1080P & !BLU & !REMUX & !WEBDL & !DOLBY & !3D > CNSUB & 1080P & !BLU & !REMUX & !WEBDL & !DOLBY & !3D > SPECSUB & 1080P & !BLU & !WEBDL & !DOLBY & HDR & !3D > CNSUB & 1080P & !BLU & !WEBDL & !DOLBY & HDR & !3D > SPECSUB & 1080P & !BLU & !WEBDL & !DOLBY & !3D > CNSUB & 1080P & !BLU & !WEBDL & !DOLBY & !3D > SPECSUB & 1080P & WEBDL & !DOLBY & HDR & !3D > CNSUB & 1080P & WEBDL & !DOLBY & HDR & !3D > SPECSUB & 1080P & WEBDL & !DOLBY & !3D > CNSUB & 1080P & WEBDL & !DOLBY & !3D > 1080P & !BLU & !REMUX & !DOLBY & HDR & !3D > 1080P & !BLU & !REMUX & !DOLBY & !3D  
+     SPECSUB & CNVOI & 4K & !BLU & !REMUX & !WEBDL & 60FPS & !DOLBY & !SDR & !3D > CNSUB & CNVOI & 4K & !BLU & !REMUX & !WEBDL & 60FPS & !DOLBY & !SDR & !3D > SPECSUB & 4K & !BLU & !REMUX & !WEBDL & 60FPS & !DOLBY & !SDR & !3D > CNSUB & 4K & !BLU & !REMUX & !WEBDL & 60FPS & !DOLBY & !SDR & !3D > SPECSUB & CNVOI & 4K & !BLU & !REMUX & !WEBDL & !DOLBY & HDR & !3D > CNSUB & CNVOI & 4K & !BLU & !REMUX & !WEBDL & !DOLBY & HDR & !3D > SPECSUB & CNVOI & 4K & !BLU & !REMUX & !WEBDL & !DOLBY & !3D > CNSUB & CNVOI & 4K & !BLU & !REMUX & !WEBDL & !DOLBY & !3D > SPECSUB & 4K & !BLU & !REMUX & !WEBDL & !DOLBY & HDR & !3D > CNSUB & 4K & !BLU & !REMUX & !WEBDL & !DOLBY & HDR & !3D > SPECSUB & 4K & !BLU & !REMUX & !WEBDL & !DOLBY & !3D > CNSUB & 4K & !BLU & !REMUX & !WEBDL & !DOLBY & !3D > SPECSUB & CNVOI & 4K & WEBDL & 60FPS & !DOLBY & !SDR & !3D > CNSUB & CNVOI & 4K & WEBDL & 60FPS & !DOLBY & !SDR & !3D > SPECSUB & 4K & WEBDL & 60FPS & !DOLBY & !SDR & !3D > CNSUB & 4K & WEBDL & 60FPS & !DOLBY & !SDR & !3D > SPECSUB & CNVOI & 4K & WEBDL & !DOLBY & HDR & !3D > CNSUB & CNVOI & 4K & WEBDL & !DOLBY & HDR & !3D > SPECSUB & CNVOI & 4K & WEBDL & !DOLBY & !3D > CNSUB & CNVOI & 4K & WEBDL & !DOLBY & !3D > SPECSUB & 4K & WEBDL & !DOLBY & HDR & !3D > CNSUB & 4K & WEBDL & !DOLBY & HDR & !3D > SPECSUB & 4K & WEBDL & !DOLBY & !3D > CNSUB & 4K & WEBDL & !DOLBY & !3D > SPECSUB & CNVOI & 4K & !BLU & !WEBDL & !DOLBY & HDR & !3D > CNSUB & CNVOI & 4K & !BLU & !WEBDL & !DOLBY & HDR & !3D > SPECSUB & CNVOI & 4K & !BLU & !WEBDL & !DOLBY & !3D > CNSUB & CNVOI & 4K & !BLU & !WEBDL & !DOLBY & !3D > SPECSUB & 4K & !BLU & !WEBDL & !DOLBY & HDR & !3D > CNSUB & 4K & !BLU & !WEBDL & !DOLBY & HDR & !3D > SPECSUB & 4K & !BLU & !WEBDL & !DOLBY & !SDR & !3D > CNSUB & 4K & !BLU & !WEBDL & !DOLBY & !SDR & !3D > 4K & !BLU & !REMUX & !DOLBY & HDR & !3D > 4K & !BLURAY & !REMUX & !DOLBY & !3D > SPECSUB & 1080P & !BLU & !REMUX & !WEBDL & !DOLBY & HDR & !3D > CNSUB & 1080P & !BLU & !REMUX & !WEBDL & !DOLBY & HDR & !3D > SPECSUB & 1080P & !BLU & !REMUX & !WEBDL & !DOLBY & !3D > CNSUB & 1080P & !BLU & !REMUX & !WEBDL & !DOLBY & !3D > SPECSUB & 1080P & !BLU & !WEBDL & !DOLBY & HDR & !3D > CNSUB & 1080P & !BLU & !WEBDL & !DOLBY & HDR & !3D > SPECSUB & 1080P & !BLU & !WEBDL & !DOLBY & !3D > CNSUB & 1080P & !BLU & !WEBDL & !DOLBY & !3D > SPECSUB & 1080P & WEBDL & !DOLBY & HDR & !3D > CNSUB & 1080P & WEBDL & !DOLBY & HDR & !3D > SPECSUB & 1080P & WEBDL & !DOLBY & !3D > CNSUB & 1080P & WEBDL & !DOLBY & !3D > 1080P & !BLU & !REMUX & !DOLBY & HDR & !3D > 1080P & !BLU & !REMUX & !DOLBY & !3D
     """
     for exp in expression_str.split('>'):
         parsed_expr = RuleParser().parse(exp.strip())

app/modules/indexer/__init__.py

@@ -286,26 +286,29 @@ class IndexerModule(_ModuleBase):
             return None
 
         # 获取用户数据
-        logger.info(f"站点 {site.get('name')} 开始以 {site.get('schema')} 模型解析数据...")
-        site_obj.parse()
-        logger.debug(f"站点 {site.get('name')} 数据解析完成")
-        return SiteUserData(
-            domain=StringUtils.get_url_domain(site.get("url")),
-            userid=site_obj.userid,
-            username=site_obj.username,
-            user_level=site_obj.user_level,
-            join_at=site_obj.join_at,
-            upload=site_obj.upload,
-            download=site_obj.download,
-            ratio=site_obj.ratio,
-            bonus=site_obj.bonus,
-            seeding=site_obj.seeding,
-            seeding_size=site_obj.seeding_size,
-            seeding_info=site_obj.seeding_info or [],
-            leeching=site_obj.leeching,
-            leeching_size=site_obj.leeching_size,
-            message_unread=site_obj.message_unread,
-            message_unread_contents=site_obj.message_unread_contents or [],
-            updated_day=datetime.now().strftime('%Y-%m-%d'),
-            err_msg=site_obj.err_msg
-        )
+        try:
+            logger.info(f"站点 {site.get('name')} 开始以 {site.get('schema')} 模型解析数据...")
+            site_obj.parse()
+            logger.debug(f"站点 {site.get('name')} 数据解析完成")
+            return SiteUserData(
+                domain=StringUtils.get_url_domain(site.get("url")),
+                userid=site_obj.userid,
+                username=site_obj.username,
+                user_level=site_obj.user_level,
+                join_at=site_obj.join_at,
+                upload=site_obj.upload,
+                download=site_obj.download,
+                ratio=site_obj.ratio,
+                bonus=site_obj.bonus,
+                seeding=site_obj.seeding,
+                seeding_size=site_obj.seeding_size,
+                seeding_info=site_obj.seeding_info.copy() if site_obj.seeding_info else [],
+                leeching=site_obj.leeching,
+                leeching_size=site_obj.leeching_size,
+                message_unread=site_obj.message_unread,
+                message_unread_contents=site_obj.message_unread_contents.copy() if site_obj.message_unread_contents else [],
+                updated_day=datetime.now().strftime('%Y-%m-%d'),
+                err_msg=site_obj.err_msg
+            )
+        finally:
+            site_obj.clear()

app/modules/indexer/parser/__init__.py

@@ -156,53 +156,57 @@ class SiteParserBase(metaclass=ABCMeta):
         解析站点信息
         :return:
         """
-        # Cookie模式时，获取站点首页html
-        if self.request_mode == "apikey":
-            if not self.apikey and not self.token:
-                logger.warn(f"{self._site_name} 未设置cookie 或 apikey/token，跳过后续操作")
-                return
-            self._index_html = {}
-        else:
-            # 检查是否已经登录
-            self._index_html = self._get_page_content(url=self._site_url)
-            if not self._parse_logged_in(self._index_html):
-                return
-        # 解析站点页面
-        self._parse_site_page(self._index_html)
-        # 解析用户基础信息
-        if self._user_basic_page:
-            self._parse_user_base_info(
-                self._get_page_content(
-                    url=urljoin(self._base_url, self._user_basic_page),
-                    params=self._user_basic_params,
-                    headers=self._user_basic_headers
+        try:
+            # Cookie模式时，获取站点首页html
+            if self.request_mode == "apikey":
+                if not self.apikey and not self.token:
+                    logger.warn(f"{self._site_name} 未设置cookie 或 apikey/token，跳过后续操作")
+                    return
+                self._index_html = {}
+            else:
+                # 检查是否已经登录
+                self._index_html = self._get_page_content(url=self._site_url)
+                if not self._parse_logged_in(self._index_html):
+                    return
+            # 解析站点页面
+            self._parse_site_page(self._index_html)
+            # 解析用户基础信息
+            if self._user_basic_page:
+                self._parse_user_base_info(
+                    self._get_page_content(
+                        url=urljoin(self._base_url, self._user_basic_page),
+                        params=self._user_basic_params,
+                        headers=self._user_basic_headers
+                    )
                 )
-            )
-        else:
-            self._parse_user_base_info(self._index_html)
-        # 解析用户详细信息
-        if self._user_detail_page:
-            self._parse_user_detail_info(
-                self._get_page_content(
-                    url=urljoin(self._base_url, self._user_detail_page),
-                    params=self._user_detail_params,
-                    headers=self._user_detail_headers
+            else:
+                self._parse_user_base_info(self._index_html)
+            # 解析用户详细信息
+            if self._user_detail_page:
+                self._parse_user_detail_info(
+                    self._get_page_content(
+                        url=urljoin(self._base_url, self._user_detail_page),
+                        params=self._user_detail_params,
+                        headers=self._user_detail_headers
+                    )
                 )
-            )
-        # 解析用户未读消息
-        if settings.SITE_MESSAGE:
-            self._pase_unread_msgs()
-        # 解析用户上传、下载、分享率等信息
-        if self._user_traffic_page:
-            self._parse_user_traffic_info(
-                self._get_page_content(
-                    url=urljoin(self._base_url, self._user_traffic_page),
-                    params=self._user_traffic_params,
-                    headers=self._user_traffic_headers
+            # 解析用户未读消息
+            if settings.SITE_MESSAGE:
+                self._pase_unread_msgs()
+            # 解析用户上传、下载、分享率等信息
+            if self._user_traffic_page:
+                self._parse_user_traffic_info(
+                    self._get_page_content(
+                        url=urljoin(self._base_url, self._user_traffic_page),
+                        params=self._user_traffic_params,
+                        headers=self._user_traffic_headers
+                    )
                 )
-            )
-        # 解析用户做种信息
-        self._parse_seeding_pages()
+            # 解析用户做种信息
+            self._parse_seeding_pages()
+        finally:
+            # 关闭连接
+            self.close()
 
     def _pase_unread_msgs(self):
         """
@@ -430,6 +434,22 @@ class SiteParserBase(metaclass=ABCMeta):
         """
         pass
 
+    def close(self):
+        """
+        关闭会话
+        """
+        if self._session:
+            self._session.close()
+            self._session = None
+
+    def clear(self):
+        """
+        清除当前解析器的所有信息
+        """
+        self._index_html = ""
+        self.seeding_info.clear()
+        self.message_unread_contents.clear()
+
     def to_dict(self):
         """
         转化为字典

app/modules/jellyfin/__init__.py

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

app/modules/plex/__init__.py

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

app/modules/plex/plex.py

@@ -84,7 +84,7 @@ class Plex:
             logger.error(f"Authentication failed: {e}")
         return None
 
-    @cached(maxsize=100, ttl=86400)
+    @cached(maxsize=32, ttl=86400)
     def __get_library_images(self, library_key: str, mtype: int) -> Optional[List[str]]:
         """
         获取媒体服务器最近添加的媒体的图片列表
@@ -788,7 +788,7 @@ class Plex:
 
             # 合并排序
             for hub in hubs:
-                for item in hub.items:
+                for item in hub.items():
                     sub_result.append(item)
             sub_result.sort(key=lambda x: x.addedAt, reverse=True)
 

app/modules/qbittorrent/__init__.py

@@ -36,6 +36,7 @@ class QbittorrentModule(_ModuleBase, _DownloaderBase[Qbittorrent]):
         event_data: schemas.ConfigChangeEventData = event.event_data
         if event_data.key not in [SystemConfigKey.Downloaders.value]:
             return
+        logger.info("配置变更，重新加载Qbittorrent模块...")
         self.init_module()
 
     @staticmethod
@@ -165,19 +166,23 @@ class QbittorrentModule(_ModuleBase, _DownloaderBase[Qbittorrent]):
             if error:
                 return None, None, None, "无法连接qbittorrent下载器"
             if torrents:
-                for torrent in torrents:
-                    # 名称与大小相等则认为是同一个种子
-                    if torrent.get("name") == torrent_name and torrent.get("total_size") == torrent_size:
-                        torrent_hash = torrent.get("hash")
-                        torrent_tags = [str(tag).strip() for tag in torrent.get("tags").split(',')]
-                        logger.warn(f"下载器中已存在该种子任务：{torrent_hash} - {torrent.get('name')}")
-                        # 给种子打上标签
-                        if "已整理" in torrent_tags:
-                            server.remove_torrents_tag(ids=torrent_hash, tag=['已整理'])
-                        if settings.TORRENT_TAG and settings.TORRENT_TAG not in torrent_tags:
-                            logger.info(f"给种子 {torrent_hash} 打上标签：{settings.TORRENT_TAG}")
-                            server.set_torrents_tag(ids=torrent_hash, tags=[settings.TORRENT_TAG])
-                        return downloader or self.get_default_config_name(), torrent_hash, torrent_layout, f"下载任务已存在"
+                try:
+                    for torrent in torrents:
+                        # 名称与大小相等则认为是同一个种子
+                        if torrent.get("name") == torrent_name and torrent.get("total_size") == torrent_size:
+                            torrent_hash = torrent.get("hash")
+                            torrent_tags = [str(tag).strip() for tag in torrent.get("tags").split(',')]
+                            logger.warn(f"下载器中已存在该种子任务：{torrent_hash} - {torrent.get('name')}")
+                            # 给种子打上标签
+                            if "已整理" in torrent_tags:
+                                server.remove_torrents_tag(ids=torrent_hash, tag=['已整理'])
+                            if settings.TORRENT_TAG and settings.TORRENT_TAG not in torrent_tags:
+                                logger.info(f"给种子 {torrent_hash} 打上标签：{settings.TORRENT_TAG}")
+                                server.set_torrents_tag(ids=torrent_hash, tags=[settings.TORRENT_TAG])
+                            return downloader or self.get_default_config_name(), torrent_hash, torrent_layout, f"下载任务已存在"
+                finally:
+                    torrents.clear()
+                    del torrents
             return None, None, None, f"添加种子任务失败：{content}"
         else:
             # 获取种子Hash
@@ -195,16 +200,19 @@ class QbittorrentModule(_ModuleBase, _DownloaderBase[Qbittorrent]):
                     file_ids = []
                     # 需要的集清单
                     sucess_epidised = []
-
-                    for torrent_file in torrent_files:
-                        file_id = torrent_file.get("id")
-                        file_name = torrent_file.get("name")
-                        meta_info = MetaInfo(file_name)
-                        if not meta_info.episode_list \
-                                or not set(meta_info.episode_list).issubset(episodes):
-                            file_ids.append(file_id)
-                        else:
-                            sucess_epidised = list(set(sucess_epidised).union(set(meta_info.episode_list)))
+                    try:
+                        for torrent_file in torrent_files:
+                            file_id = torrent_file.get("id")
+                            file_name = torrent_file.get("name")
+                            meta_info = MetaInfo(file_name)
+                            if not meta_info.episode_list \
+                                    or not set(meta_info.episode_list).issubset(episodes):
+                                file_ids.append(file_id)
+                            else:
+                                sucess_epidised = list(set(sucess_epidised).union(set(meta_info.episode_list)))
+                    finally:
+                        torrent_files.clear()
+                        del torrent_files
                     if sucess_epidised and file_ids:
                         # 选择文件
                         server.set_files(torrent_hash=torrent_hash, file_ids=file_ids, priority=0)
@@ -243,70 +251,82 @@ class QbittorrentModule(_ModuleBase, _DownloaderBase[Qbittorrent]):
         if hashs:
             # 按Hash获取
             for name, server in servers.items():
-                torrents, _ = server.get_torrents(ids=hashs, tags=settings.TORRENT_TAG)
-                for torrent in torrents or []:
-                    content_path = torrent.get("content_path")
-                    if content_path:
-                        torrent_path = Path(content_path)
-                    else:
-                        torrent_path = Path(torrent.get('save_path')) / torrent.get('name')
-                    ret_torrents.append(TransferTorrent(
-                        downloader=name,
-                        title=torrent.get('name'),
-                        path=torrent_path,
-                        hash=torrent.get('hash'),
-                        size=torrent.get('total_size'),
-                        tags=torrent.get('tags'),
-                        progress=torrent.get('progress') * 100,
-                        state="paused" if torrent.get('state') in ("paused", "pausedDL") else "downloading",
-                    ))
+                torrents, _ = server.get_torrents(ids=hashs, tags=settings.TORRENT_TAG) or []
+                try:
+                    for torrent in torrents:
+                        content_path = torrent.get("content_path")
+                        if content_path:
+                            torrent_path = Path(content_path)
+                        else:
+                            torrent_path = Path(torrent.get('save_path')) / torrent.get('name')
+                        ret_torrents.append(TransferTorrent(
+                            downloader=name,
+                            title=torrent.get('name'),
+                            path=torrent_path,
+                            hash=torrent.get('hash'),
+                            size=torrent.get('total_size'),
+                            tags=torrent.get('tags'),
+                            progress=torrent.get('progress') * 100,
+                            state="paused" if torrent.get('state') in ("paused", "pausedDL") else "downloading",
+                        ))
+                finally:
+                    torrents.clear()
+                    del torrents
         elif status == TorrentStatus.TRANSFER:
             # 获取已完成且未整理的
             for name, server in servers.items():
-                torrents = server.get_completed_torrents(tags=settings.TORRENT_TAG)
-                for torrent in torrents or []:
-                    tags = torrent.get("tags") or []
-                    if "已整理" in tags:
-                        continue
-                    # 内容路径
-                    content_path = torrent.get("content_path")
-                    if content_path:
-                        torrent_path = Path(content_path)
-                    else:
-                        torrent_path = torrent.get('save_path') / torrent.get('name')
-                    ret_torrents.append(TransferTorrent(
-                        downloader=name,
-                        title=torrent.get('name'),
-                        path=torrent_path,
-                        hash=torrent.get('hash'),
-                        tags=torrent.get('tags')
-                    ))
+                torrents = server.get_completed_torrents(tags=settings.TORRENT_TAG) or []
+                try:
+                    for torrent in torrents:
+                        tags = torrent.get("tags") or []
+                        if "已整理" in tags:
+                            continue
+                        # 内容路径
+                        content_path = torrent.get("content_path")
+                        if content_path:
+                            torrent_path = Path(content_path)
+                        else:
+                            torrent_path = torrent.get('save_path') / torrent.get('name')
+                        ret_torrents.append(TransferTorrent(
+                            downloader=name,
+                            title=torrent.get('name'),
+                            path=torrent_path,
+                            hash=torrent.get('hash'),
+                            tags=torrent.get('tags')
+                        ))
+                finally:
+                    torrents.clear()
+                    del torrents
         elif status == TorrentStatus.DOWNLOADING:
             # 获取正在下载的任务
             for name, server in servers.items():
-                torrents = server.get_downloading_torrents(tags=settings.TORRENT_TAG)
-                for torrent in torrents or []:
-                    meta = MetaInfo(torrent.get('name'))
-                    ret_torrents.append(DownloadingTorrent(
-                        downloader=name,
-                        hash=torrent.get('hash'),
-                        title=torrent.get('name'),
-                        name=meta.name,
-                        year=meta.year,
-                        season_episode=meta.season_episode,
-                        progress=torrent.get('progress') * 100,
-                        size=torrent.get('total_size'),
-                        state="paused" if torrent.get('state') in ("paused", "pausedDL") else "downloading",
-                        dlspeed=StringUtils.str_filesize(torrent.get('dlspeed')),
-                        upspeed=StringUtils.str_filesize(torrent.get('upspeed')),
-                        left_time=StringUtils.str_secends(
-                            (torrent.get('total_size') - torrent.get('completed')) / torrent.get(
-                                'dlspeed')) if torrent.get(
-                            'dlspeed') > 0 else ''
-                    ))
+                torrents = server.get_downloading_torrents(tags=settings.TORRENT_TAG) or []
+                try:
+                    for torrent in torrents:
+                        meta = MetaInfo(torrent.get('name'))
+                        ret_torrents.append(DownloadingTorrent(
+                            downloader=name,
+                            hash=torrent.get('hash'),
+                            title=torrent.get('name'),
+                            name=meta.name,
+                            year=meta.year,
+                            season_episode=meta.season_episode,
+                            progress=torrent.get('progress') * 100,
+                            size=torrent.get('total_size'),
+                            state="paused" if torrent.get('state') in ("paused", "pausedDL") else "downloading",
+                            dlspeed=StringUtils.str_filesize(torrent.get('dlspeed')),
+                            upspeed=StringUtils.str_filesize(torrent.get('upspeed')),
+                            left_time=StringUtils.str_secends(
+                                (torrent.get('total_size') - torrent.get('completed')) / torrent.get(
+                                    'dlspeed')) if torrent.get(
+                                'dlspeed') > 0 else ''
+                        ))
+                finally:
+                    torrents.clear()
+                    del torrents
         else:
             return None
-        return ret_torrents
+        return ret_torrents # noqa
 
     def transfer_completed(self, hashs: str, downloader: Optional[str] = None) -> None:
         """
@@ -318,6 +338,7 @@ class QbittorrentModule(_ModuleBase, _DownloaderBase[Qbittorrent]):
         if not server:
             return None
         server.set_torrents_tag(ids=hashs, tags=['已整理'])
+        return None
 
     def remove_torrents(self, hashs: Union[str, list], delete_file: Optional[bool] = True,
                         downloader: Optional[str] = None) -> Optional[bool]:

app/modules/qbittorrent/qbittorrent.py

@@ -12,16 +12,9 @@ from app.utils.string import StringUtils
 
 
 class Qbittorrent:
-    _host: Optional[str] = None
-    _port: int = None
-    _username: Optional[str] = None
-    _password: Optional[str] = None
-    _category: Optional[bool] = False
-    _sequentail: Optional[bool] = False
-    _force_resume: Optional[bool] = False
-
-    qbc: Client = None
-
+    """
+    qbittorrent下载器
+    """
     def __init__(self, host: Optional[str] = None, port: int = None,
                  username: Optional[str] = None, password: Optional[str] = None,
                  category: Optional[bool] = False, sequentail: Optional[bool] = False,
@@ -43,8 +36,7 @@ class Qbittorrent:
         self._sequentail = sequentail
         self._force_resume = force_resume
         self._first_last_piece = first_last_piece
-        if self._host and self._port:
-            self.qbc = self.__login_qbittorrent()
+        self.qbc = self.__login_qbittorrent()
 
     def is_inactive(self) -> bool:
         """
@@ -65,6 +57,8 @@ class Qbittorrent:
         连接qbittorrent
         :return: qbittorrent对象
         """
+        if not self._host or not self._port:
+            return None
         try:
             # 登录
             logger.info(f"正在连接 qbittorrent：{self._host}:{self._port}")
@@ -104,10 +98,14 @@ class Qbittorrent:
                 results = []
                 if not isinstance(tags, list):
                     tags = [tags]
-                for torrent in torrents:
-                    torrent_tags = [str(tag).strip() for tag in torrent.get("tags").split(',')]
-                    if set(tags).issubset(set(torrent_tags)):
-                        results.append(torrent)
+                try:
+                    for torrent in torrents:
+                        torrent_tags = [str(tag).strip() for tag in torrent.get("tags").split(',')]
+                        if set(tags).issubset(set(torrent_tags)):
+                            results.append(torrent)
+                finally:
+                    torrents.clear()
+                    del torrents
                 return results, False
             return torrents or [], False
         except Exception as err:

app/modules/slack/__init__.py

@@ -32,6 +32,7 @@ class SlackModule(_ModuleBase, _MessageBase[Slack]):
         event_data: ConfigChangeEventData = event.event_data
         if event_data.key not in [SystemConfigKey.Notifications.value]:
             return
+        logger.info("配置变更，重新加载Slack模块...")
         self.init_module()
 
     @staticmethod
@@ -81,8 +82,7 @@ class SlackModule(_ModuleBase, _MessageBase[Slack]):
     def init_setting(self) -> Tuple[str, Union[str, bool]]:
         pass
 
-    def message_parser(self, source: str, body: Any, form: Any,
-                       args: Any) -> Optional[CommingMessage]:
+    def message_parser(self, source: str, body: Any, form: Any, args: Any) -> Optional[CommingMessage]:
         """
         解析消息内容，返回字典，注意以下约定值：
         userid: 用户ID
@@ -219,8 +219,32 @@ class SlackModule(_ModuleBase, _MessageBase[Slack]):
                 username = msg_json.get("user")
             elif msg_json.get("type") == "block_actions":
                 userid = msg_json.get("user", {}).get("id")
-                text = msg_json.get("actions")[0].get("value")
+                callback_data = msg_json.get("actions")[0].get("value")
+                # 使用CALLBACK前缀标识按钮回调
+                text = f"CALLBACK:{callback_data}"
                 username = msg_json.get("user", {}).get("name")
+
+                # 获取原消息信息用于编辑
+                message_info = msg_json.get("message", {})
+                # Slack消息的时间戳作为消息ID
+                message_ts = message_info.get("ts")
+                channel_id = msg_json.get("channel", {}).get("id") or msg_json.get("container", {}).get("channel_id")
+
+                logger.info(f"收到来自 {client_config.name} 的Slack按钮回调："
+                            f"userid={userid}, username={username}, callback_data={callback_data}")
+
+                # 创建包含回调信息的CommingMessage
+                return CommingMessage(
+                    channel=MessageChannel.Slack,
+                    source=client_config.name,
+                    userid=userid,
+                    username=username,
+                    text=text,
+                    is_callback=True,
+                    callback_data=callback_data,
+                    message_id=message_ts,
+                    chat_id=channel_id
+                )
             elif msg_json.get("type") == "event_callback":
                 userid = msg_json.get('event', {}).get('user')
                 text = re.sub(r"<@[0-9A-Z]+>", "", msg_json.get("event", {}).get("text"), flags=re.IGNORECASE).strip()
@@ -259,7 +283,10 @@ class SlackModule(_ModuleBase, _MessageBase[Slack]):
             client: Slack = self.get_instance(conf.name)
             if client:
                 client.send_msg(title=message.title, text=message.text,
-                                image=message.image, userid=userid, link=message.link)
+                                image=message.image, userid=userid, link=message.link,
+                                buttons=message.buttons,
+                                original_message_id=message.original_message_id,
+                                original_chat_id=message.original_chat_id)
 
     def post_medias_message(self, message: Notification, medias: List[MediaInfo]) -> None:
         """
@@ -273,7 +300,10 @@ class SlackModule(_ModuleBase, _MessageBase[Slack]):
                 continue
             client: Slack = self.get_instance(conf.name)
             if client:
-                client.send_medias_msg(title=message.title, medias=medias, userid=message.userid)
+                client.send_medias_msg(title=message.title, medias=medias, userid=message.userid,
+                                       buttons=message.buttons,
+                                       original_message_id=message.original_message_id,
+                                       original_chat_id=message.original_chat_id)
 
     def post_torrents_message(self, message: Notification, torrents: List[Context]) -> None:
         """
@@ -288,4 +318,29 @@ class SlackModule(_ModuleBase, _MessageBase[Slack]):
             client: Slack = self.get_instance(conf.name)
             if client:
                 client.send_torrents_msg(title=message.title, torrents=torrents,
-                                         userid=message.userid)
+                                         userid=message.userid, buttons=message.buttons,
+                                         original_message_id=message.original_message_id,
+                                         original_chat_id=message.original_chat_id)
+
+    def delete_message(self, channel: MessageChannel, source: str,
+                       message_id: str, chat_id: Optional[str] = None) -> bool:
+        """
+        删除消息
+        :param channel: 消息渠道
+        :param source: 指定的消息源
+        :param message_id: 消息ID（Slack中为时间戳）
+        :param chat_id: 聊天ID（频道ID）
+        :return: 删除是否成功
+        """
+        success = False
+        for conf in self.get_configs().values():
+            if channel != self._channel:
+                break
+            if source != conf.name:
+                continue
+            client: Slack = self.get_instance(conf.name)
+            if client:
+                result = client.delete_msg(message_id=message_id, chat_id=chat_id)
+                if result:
+                    success = True
+        return success

app/modules/slack/slack.py

@@ -13,18 +13,16 @@ from app.core.metainfo import MetaInfo
 from app.log import logger
 from app.utils.string import StringUtils
 
-
 lock = Lock()
 
 
 class Slack:
-
     _client: WebClient = None
     _service: SocketModeHandler = None
     _ds_url = f"http://127.0.0.1:{settings.PORT}/api/v1/message?token={settings.API_TOKEN}"
     _channel = ""
 
-    def __init__(self, SLACK_OAUTH_TOKEN: Optional[str] = None, SLACK_APP_TOKEN: Optional[str] = None, 
+    def __init__(self, SLACK_OAUTH_TOKEN: Optional[str] = None, SLACK_APP_TOKEN: Optional[str] = None,
                  SLACK_CHANNEL: Optional[str] = None, **kwargs):
 
         if not SLACK_OAUTH_TOKEN or not SLACK_APP_TOKEN:
@@ -52,7 +50,7 @@ class Slack:
             with requests.post(self._ds_url, json=message, timeout=10) as local_res:
                 logger.debug("message: %s processed, response is: %s" % (message, local_res.text))
 
-        @slack_app.action(re.compile(r"actionId-\d+"))
+        @slack_app.action(re.compile(r"actionId-.*"))
         def slack_action(ack, body):
             ack()
             with requests.post(self._ds_url, json=body, timeout=60) as local_res:
@@ -101,15 +99,21 @@ class Slack:
         """
         return True if self._client else False
 
-    def send_msg(self, title: str, text: Optional[str] = None, image: Optional[str] = None, link: Optional[str] = None, userid: Optional[str] = None):
+    def send_msg(self, title: str, text: Optional[str] = None,
+                 image: Optional[str] = None, link: Optional[str] = None,
+                 userid: Optional[str] = None, buttons: Optional[List[List[dict]]] = None,
+                 original_message_id: Optional[str] = None,
+                 original_chat_id: Optional[str] = None):
         """
-        发送Telegram消息
+        发送Slack消息
         :param title: 消息标题
         :param text: 消息内容
         :param image: 消息图片地址
         :param link: 点击消息转转的URL
         :param userid: 用户ID，如有则只发消息给该用户
-        :user_id: 发送消息的目标用户ID，为空则发给管理员
+        :param buttons: 消息按钮列表，格式为 [[{"text": "按钮文本", "callback_data": "回调数据", "url": "链接"}]]
+        :param original_message_id: 原消息的时间戳，如果提供则编辑原消息
+        :param original_chat_id: 原消息的频道ID，编辑消息时需要
         """
         if not self._client:
             return False, "消息客户端未就绪"
@@ -139,8 +143,42 @@ class Slack:
                         "image_url": f"{image}",
                         "alt_text": f"{title}"
                     }})
-                # 链接
-                if link:
+                # 自定义按钮
+                if buttons:
+                    for button_row in buttons:
+                        elements = []
+                        for button in button_row:
+                            if "url" in button:
+                                # URL按钮
+                                elements.append({
+                                    "type": "button",
+                                    "text": {
+                                        "type": "plain_text",
+                                        "text": button["text"],
+                                        "emoji": True
+                                    },
+                                    "url": button["url"],
+                                    "action_id": f"actionId-url-{button.get('text', 'url')}-{len(elements)}"
+                                })
+                            else:
+                                # 回调按钮
+                                elements.append({
+                                    "type": "button",
+                                    "text": {
+                                        "type": "plain_text",
+                                        "text": button["text"],
+                                        "emoji": True
+                                    },
+                                    "value": button["callback_data"],
+                                    "action_id": f"actionId-{button['callback_data']}"
+                                })
+                        if elements:
+                            blocks.append({
+                                "type": "actions",
+                                "elements": elements
+                            })
+                elif link:
+                    # 默认链接按钮
                     blocks.append({
                         "type": "actions",
                         "elements": [
@@ -157,21 +195,41 @@ class Slack:
                             }
                         ]
                     })
-            # 发送
-            result = self._client.chat_postMessage(
-                channel=channel,
-                text=message_text[:1000],
-                blocks=blocks,
-                mrkdwn=True
-            )
+
+            # 判断是编辑消息还是发送新消息
+            if original_message_id and original_chat_id:
+                # 编辑消息
+                result = self._client.chat_update(
+                    channel=original_chat_id,
+                    ts=original_message_id,
+                    text=message_text[:1000],
+                    blocks=blocks or []
+                )
+            else:
+                # 发送新消息
+                result = self._client.chat_postMessage(
+                    channel=channel,
+                    text=message_text[:1000],
+                    blocks=blocks,
+                    mrkdwn=True
+                )
             return True, result
         except Exception as msg_e:
             logger.error(f"Slack消息发送失败: {msg_e}")
             return False, str(msg_e)
 
-    def send_medias_msg(self, medias: List[MediaInfo], userid: Optional[str] = None, title: Optional[str] = None) -> Optional[bool]:
+    def send_medias_msg(self, medias: List[MediaInfo], userid: Optional[str] = None, title: Optional[str] = None,
+                        buttons: Optional[List[List[dict]]] = None,
+                        original_message_id: Optional[str] = None,
+                        original_chat_id: Optional[str] = None) -> Optional[bool]:
         """
-        发送列表类消息
+        发送媒体列表消息
+        :param medias: 媒体信息列表
+        :param userid: 用户ID，如有则只发消息给该用户
+        :param title: 消息标题
+        :param buttons: 按钮列表，格式：[[{"text": "按钮文本", "callback_data": "回调数据"}]]
+        :param original_message_id: 原消息的时间戳，如果提供则编辑原消息
+        :param original_chat_id: 原消息的频道ID，编辑消息时需要
         """
         if not self._client:
             return False
@@ -198,64 +256,148 @@ class Slack:
                     "type": "divider"
                 })
                 index = 1
-                for media in medias:
-                    if media.get_poster_image():
-                        if media.vote_star:
-                            text = f"{index}. *<{media.detail_link}|{media.title_year}>*" \
-                                   f"\n类型：{media.type.value}" \
-                                   f"\n{media.vote_star}" \
-                                   f"\n{media.get_overview_string(50)}"
-                        else:
-                            text = f"{index}. *<{media.detail_link}|{media.title_year}>*" \
-                                   f"\n类型：{media.type.value}" \
-                                   f"\n{media.get_overview_string(50)}"
-                        blocks.append(
-                            {
-                                "type": "section",
-                                "text": {
-                                    "type": "mrkdwn",
-                                    "text": text
-                                },
-                                "accessory": {
-                                    "type": "image",
-                                    "image_url": f"{media.get_poster_image()}",
-                                    "alt_text": f"{media.title_year}"
-                                }
-                            }
-                        )
-                        blocks.append(
-                            {
-                                "type": "actions",
-                                "elements": [
-                                    {
-                                        "type": "button",
-                                        "text": {
-                                            "type": "plain_text",
-                                            "text": "选择",
-                                            "emoji": True
-                                        },
-                                        "value": f"{index}",
-                                        "action_id": f"actionId-{index}"
+
+                # 如果有自定义按钮，先添加所有媒体项，然后添加统一的按钮
+                if buttons:
+                    # 添加媒体列表（不带单独的选择按钮）
+                    for media in medias:
+                        if media.get_poster_image():
+                            if media.vote_star:
+                                text = f"{index}. *<{media.detail_link}|{media.title_year}>*" \
+                                       f"\n类型：{media.type.value}" \
+                                       f"\n{media.vote_star}" \
+                                       f"\n{media.get_overview_string(50)}"
+                            else:
+                                text = f"{index}. *<{media.detail_link}|{media.title_year}>*" \
+                                       f"\n类型：{media.type.value}" \
+                                       f"\n{media.get_overview_string(50)}"
+                            blocks.append(
+                                {
+                                    "type": "section",
+                                    "text": {
+                                        "type": "mrkdwn",
+                                        "text": text
+                                    },
+                                    "accessory": {
+                                        "type": "image",
+                                        "image_url": f"{media.get_poster_image()}",
+                                        "alt_text": f"{media.title_year}"
                                     }
-                                ]
-                            }
-                        )
-                        index += 1
-            # 发送
-            result = self._client.chat_postMessage(
-                channel=channel,
-                text=title,
-                blocks=blocks
-            )
+                                }
+                            )
+                            index += 1
+
+                    # 添加统一的自定义按钮（在所有媒体项之后）
+                    for button_row in buttons:
+                        elements = []
+                        for button in button_row:
+                            if "url" in button:
+                                elements.append({
+                                    "type": "button",
+                                    "text": {
+                                        "type": "plain_text",
+                                        "text": button["text"],
+                                        "emoji": True
+                                    },
+                                    "url": button["url"],
+                                    "action_id": f"actionId-url-{button.get('text', 'url')}-{len(elements)}"
+                                })
+                            else:
+                                elements.append({
+                                    "type": "button",
+                                    "text": {
+                                        "type": "plain_text",
+                                        "text": button["text"],
+                                        "emoji": True
+                                    },
+                                    "value": button["callback_data"],
+                                    "action_id": f"actionId-{button['callback_data']}"
+                                })
+                        if elements:
+                            blocks.append({
+                                "type": "actions",
+                                "elements": elements
+                            })
+                else:
+                    # 使用默认的每个媒体项单独按钮
+                    for media in medias:
+                        if media.get_poster_image():
+                            if media.vote_star:
+                                text = f"{index}. *<{media.detail_link}|{media.title_year}>*" \
+                                       f"\n类型：{media.type.value}" \
+                                       f"\n{media.vote_star}" \
+                                       f"\n{media.get_overview_string(50)}"
+                            else:
+                                text = f"{index}. *<{media.detail_link}|{media.title_year}>*" \
+                                       f"\n类型：{media.type.value}" \
+                                       f"\n{media.get_overview_string(50)}"
+                            blocks.append(
+                                {
+                                    "type": "section",
+                                    "text": {
+                                        "type": "mrkdwn",
+                                        "text": text
+                                    },
+                                    "accessory": {
+                                        "type": "image",
+                                        "image_url": f"{media.get_poster_image()}",
+                                        "alt_text": f"{media.title_year}"
+                                    }
+                                }
+                            )
+                            # 使用默认选择按钮
+                            blocks.append(
+                                {
+                                    "type": "actions",
+                                    "elements": [
+                                        {
+                                            "type": "button",
+                                            "text": {
+                                                "type": "plain_text",
+                                                "text": "选择",
+                                                "emoji": True
+                                            },
+                                            "value": f"{index}",
+                                            "action_id": f"actionId-{index}"
+                                        }
+                                    ]
+                                }
+                            )
+                            index += 1
+
+            # 判断是编辑消息还是发送新消息
+            if original_message_id and original_chat_id:
+                # 编辑消息
+                result = self._client.chat_update(
+                    channel=original_chat_id,
+                    ts=original_message_id,
+                    text=title,
+                    blocks=blocks or []
+                )
+            else:
+                # 发送新消息
+                result = self._client.chat_postMessage(
+                    channel=channel,
+                    text=title,
+                    blocks=blocks
+                )
             return True if result else False
         except Exception as msg_e:
             logger.error(f"Slack消息发送失败: {msg_e}")
             return False
 
-    def send_torrents_msg(self, torrents: List[Context],
-                          userid: Optional[str] = None, title: Optional[str] = None) -> Optional[bool]:
+    def send_torrents_msg(self, torrents: List[Context], userid: Optional[str] = None, title: Optional[str] = None,
+                          buttons: Optional[List[List[dict]]] = None,
+                          original_message_id: Optional[str] = None,
+                          original_chat_id: Optional[str] = None) -> Optional[bool]:
         """
-        发送列表消息
+        发送种子列表消息
+        :param torrents: 种子信息列表
+        :param userid: 用户ID，如有则只发消息给该用户
+        :param title: 消息标题
+        :param buttons: 按钮列表，格式：[[{"text": "按钮文本", "callback_data": "回调数据"}]]
+        :param original_message_id: 原消息的时间戳，如果提供则编辑原消息
+        :param original_chat_id: 原消息的频道ID，编辑消息时需要
         """
         if not self._client:
             return None
@@ -279,60 +421,172 @@ class Slack:
             }]
             # 列表
             index = 1
-            for context in torrents:
-                torrent = context.torrent_info
-                site_name = torrent.site_name
-                meta = MetaInfo(torrent.title, torrent.description)
-                link = torrent.page_url
-                title = f"{meta.season_episode} " \
-                        f"{meta.resource_term} " \
-                        f"{meta.video_term} " \
-                        f"{meta.release_group}"
-                title = re.sub(r"\s+", " ", title).strip()
-                free = torrent.volume_factor
-                seeder = f"{torrent.seeders}↑"
-                description = torrent.description
-                text = f"{index}. 【{site_name}】<{link}|{title}> " \
-                       f"{StringUtils.str_filesize(torrent.size)} {free} {seeder}\n" \
-                       f"{description}"
-                blocks.append(
-                    {
-                        "type": "section",
-                        "text": {
-                            "type": "mrkdwn",
-                            "text": text
+
+            # 如果有自定义按钮，先添加种子列表，然后添加统一的按钮
+            if buttons:
+                # 添加种子列表（不带单独的选择按钮）
+                for context in torrents:
+                    torrent = context.torrent_info
+                    site_name = torrent.site_name
+                    meta = MetaInfo(torrent.title, torrent.description)
+                    link = torrent.page_url
+                    title_text = f"{meta.season_episode} " \
+                                 f"{meta.resource_term} " \
+                                 f"{meta.video_term} " \
+                                 f"{meta.release_group}"
+                    title_text = re.sub(r"\s+", " ", title_text).strip()
+                    free = torrent.volume_factor
+                    seeder = f"{torrent.seeders}↑"
+                    description = torrent.description
+                    text = f"{index}. 【{site_name}】<{link}|{title_text}> " \
+                           f"{StringUtils.str_filesize(torrent.size)} {free} {seeder}\n" \
+                           f"{description}"
+                    blocks.append(
+                        {
+                            "type": "section",
+                            "text": {
+                                "type": "mrkdwn",
+                                "text": text
+                            }
                         }
-                    }
-                )
-                blocks.append(
-                    {
-                        "type": "actions",
-                        "elements": [
-                            {
+                    )
+                    index += 1
+
+                # 添加统一的自定义按钮
+                for button_row in buttons:
+                    elements = []
+                    for button in button_row:
+                        if "url" in button:
+                            elements.append({
                                 "type": "button",
                                 "text": {
                                     "type": "plain_text",
-                                    "text": "选择",
+                                    "text": button["text"],
                                     "emoji": True
                                 },
-                                "value": f"{index}",
-                                "action_id": f"actionId-{index}"
+                                "url": button["url"],
+                                "action_id": f"actionId-url-{button.get('text', 'url')}-{len(elements)}"
+                            })
+                        else:
+                            elements.append({
+                                "type": "button",
+                                "text": {
+                                    "type": "plain_text",
+                                    "text": button["text"],
+                                    "emoji": True
+                                },
+                                "value": button["callback_data"],
+                                "action_id": f"actionId-{button['callback_data']}"
+                            })
+                    if elements:
+                        blocks.append({
+                            "type": "actions",
+                            "elements": elements
+                        })
+            else:
+                # 使用默认的每个种子单独按钮
+                for context in torrents:
+                    torrent = context.torrent_info
+                    site_name = torrent.site_name
+                    meta = MetaInfo(torrent.title, torrent.description)
+                    link = torrent.page_url
+                    title_text = f"{meta.season_episode} " \
+                                 f"{meta.resource_term} " \
+                                 f"{meta.video_term} " \
+                                 f"{meta.release_group}"
+                    title_text = re.sub(r"\s+", " ", title_text).strip()
+                    free = torrent.volume_factor
+                    seeder = f"{torrent.seeders}↑"
+                    description = torrent.description
+                    text = f"{index}. 【{site_name}】<{link}|{title_text}> " \
+                           f"{StringUtils.str_filesize(torrent.size)} {free} {seeder}\n" \
+                           f"{description}"
+                    blocks.append(
+                        {
+                            "type": "section",
+                            "text": {
+                                "type": "mrkdwn",
+                                "text": text
                             }
-                        ]
-                    }
+                        }
+                    )
+                    blocks.append(
+                        {
+                            "type": "actions",
+                            "elements": [
+                                {
+                                    "type": "button",
+                                    "text": {
+                                        "type": "plain_text",
+                                        "text": "选择",
+                                        "emoji": True
+                                    },
+                                    "value": f"{index}",
+                                    "action_id": f"actionId-{index}"
+                                }
+                            ]
+                        }
+                    )
+                    index += 1
+
+            # 判断是编辑消息还是发送新消息
+            if original_message_id and original_chat_id:
+                # 编辑消息
+                result = self._client.chat_update(
+                    channel=original_chat_id,
+                    ts=original_message_id,
+                    text=title,
+                    blocks=blocks or []
+                )
+            else:
+                # 发送新消息
+                result = self._client.chat_postMessage(
+                    channel=channel,
+                    text=title,
+                    blocks=blocks
                 )
-                index += 1
-            # 发送
-            result = self._client.chat_postMessage(
-                channel=channel,
-                text=title,
-                blocks=blocks
-            )
             return True if result else False
         except Exception as msg_e:
             logger.error(f"Slack消息发送失败: {msg_e}")
             return False
 
+    def delete_msg(self, message_id: str, chat_id: Optional[str] = None) -> Optional[bool]:
+        """
+        删除Slack消息
+        :param message_id: 消息时间戳（Slack消息ID）
+        :param chat_id: 频道ID
+        :return: 删除是否成功
+        """
+        if not self._client:
+            return None
+
+        try:
+            # 确定要删除消息的频道ID
+            if chat_id:
+                target_channel = chat_id
+            else:
+                target_channel = self.__find_public_channel()
+
+            if not target_channel:
+                logger.error("无法确定要删除消息的Slack频道")
+                return False
+
+            # 删除消息
+            result = self._client.chat_delete(
+                channel=target_channel,
+                ts=message_id
+            )
+
+            if result.get("ok"):
+                logger.info(f"成功删除Slack消息: channel={target_channel}, ts={message_id}")
+                return True
+            else:
+                logger.error(f"删除Slack消息失败: {result.get('error', 'unknown error')}")
+                return False
+        except Exception as e:
+            logger.error(f"删除Slack消息异常: {str(e)}")
+            return False
+
     def __find_public_channel(self):
         """
         查找公共频道

app/modules/synologychat/__init__.py

@@ -30,6 +30,7 @@ class SynologyChatModule(_ModuleBase, _MessageBase[SynologyChat]):
         event_data: ConfigChangeEventData = event.event_data
         if event_data.key not in [SystemConfigKey.Notifications.value]:
             return
+        logger.info("配置变更，重新加载SynologyChat模块...")
         self.init_module()
 
     @staticmethod

app/modules/telegram/__init__.py

@@ -9,7 +9,8 @@ from app.core.event import eventmanager
 from app.log import logger
 from app.modules import _ModuleBase, _MessageBase
 from app.modules.telegram.telegram import Telegram
-from app.schemas import MessageChannel, CommingMessage, Notification, CommandRegisterEventData, ConfigChangeEventData
+from app.schemas import MessageChannel, CommingMessage, Notification, CommandRegisterEventData, ConfigChangeEventData, \
+    NotificationConf
 from app.schemas.types import ModuleType, ChainEventType, SystemConfigKey, EventType
 from app.utils.structures import DictUtils
 
@@ -35,6 +36,7 @@ class TelegramModule(_ModuleBase, _MessageBase[Telegram]):
         event_data: ConfigChangeEventData = event.event_data
         if event_data.key not in [SystemConfigKey.Notifications.value]:
             return
+        logger.info("配置变更，重新加载Telegram模块...")
         self.init_module()
 
     @staticmethod
@@ -98,6 +100,7 @@ class TelegramModule(_ModuleBase, _MessageBase[Telegram]):
         :return: 渠道、消息体
         """
         """
+            普通消息格式：
             {
                 'update_id': ,
                 'message': {
@@ -119,6 +122,16 @@ class TelegramModule(_ModuleBase, _MessageBase[Telegram]):
                     'text': ''
                 }
             }
+
+            按钮回调格式：
+            {
+                'callback_query': {
+                    'id': '',
+                    'from': {...},
+                    'message': {...},
+                    'data': 'callback_data'
+                }
+            }
         """
         # 获取服务配置
         client_config = self.get_config(source)
@@ -130,32 +143,88 @@ class TelegramModule(_ModuleBase, _MessageBase[Telegram]):
         except Exception as err:
             logger.debug(f"解析Telegram消息失败：{str(err)}")
             return None
+
         if message:
-            text = message.get("text")
-            user_id = message.get("from", {}).get("id")
-            # 获取用户名
-            user_name = message.get("from", {}).get("username")
-            if text:
-                logger.info(f"收到来自 {client_config.name} 的Telegram消息："
-                            f"userid={user_id}, username={user_name}, text={text}")
-                # 检查权限
-                admin_users = client_config.config.get("TELEGRAM_ADMINS")
-                user_list = client_config.config.get("TELEGRAM_USERS")
-                chat_id = client_config.config.get("TELEGRAM_CHAT_ID")
-                if text.startswith("/"):
-                    if admin_users \
-                            and str(user_id) not in admin_users.split(',') \
-                            and str(user_id) != chat_id:
-                        client.send_msg(title="只有管理员才有权限执行此命令", userid=user_id)
-                        return None
-                else:
-                    if user_list \
-                            and not str(user_id) in user_list.split(','):
-                        logger.info(f"用户{user_id}不在用户白名单中，无法使用此机器人")
-                        client.send_msg(title="你不在用户白名单中，无法使用此机器人", userid=user_id)
-                        return None
-                return CommingMessage(channel=MessageChannel.Telegram, source=client_config.name,
-                                      userid=user_id, username=user_name, text=text)
+            # 处理按钮回调
+            if "callback_query" in message:
+                return self._handle_callback_query(message, client_config)
+
+            # 处理普通消息
+            return self._handle_text_message(message, client_config, client)
+
+        return None
+
+    @staticmethod
+    def _handle_callback_query(message: dict, client_config: NotificationConf) -> Optional[CommingMessage]:
+        """
+        处理按钮回调查询
+        """
+        callback_query = message.get("callback_query", {})
+        user_info = callback_query.get("from", {})
+        callback_data = callback_query.get("data", "")
+        user_id = user_info.get("id")
+        user_name = user_info.get("username")
+
+        if callback_data and user_id:
+            logger.info(f"收到来自 {client_config.name} 的Telegram按钮回调："
+                        f"userid={user_id}, username={user_name}, callback_data={callback_data}")
+
+            # 将callback_data作为特殊格式的text返回，以便主程序识别这是按钮回调
+            callback_text = f"CALLBACK:{callback_data}"
+
+            # 创建包含完整回调信息的CommingMessage
+            return CommingMessage(
+                channel=MessageChannel.Telegram,
+                source=client_config.name,
+                userid=user_id,
+                username=user_name,
+                text=callback_text,
+                is_callback=True,
+                callback_data=callback_data,
+                message_id=callback_query.get("message", {}).get("message_id"),
+                chat_id=str(callback_query.get("message", {}).get("chat", {}).get("id", "")),
+                callback_query=callback_query
+            )
+        return None
+
+    @staticmethod
+    def _handle_text_message(msg: dict, client_config: NotificationConf, client: Telegram) -> Optional[CommingMessage]:
+        """
+        处理普通文本消息
+        """
+        text = msg.get("text")
+        user_id = msg.get("from", {}).get("id")
+        user_name = msg.get("from", {}).get("username")
+
+        if text and user_id:
+            logger.info(f"收到来自 {client_config.name} 的Telegram消息："
+                        f"userid={user_id}, username={user_name}, text={text}")
+
+            # 检查权限
+            admin_users = client_config.config.get("TELEGRAM_ADMINS")
+            user_list = client_config.config.get("TELEGRAM_USERS")
+            chat_id = client_config.config.get("TELEGRAM_CHAT_ID")
+
+            if text.startswith("/"):
+                if admin_users \
+                        and str(user_id) not in admin_users.split(',') \
+                        and str(user_id) != chat_id:
+                    client.send_msg(title="只有管理员才有权限执行此命令", userid=user_id)
+                    return None
+            else:
+                if user_list \
+                        and str(user_id) not in user_list.split(','):
+                    logger.info(f"用户{user_id}不在用户白名单中，无法使用此机器人")
+                    client.send_msg(title="你不在用户白名单中，无法使用此机器人", userid=user_id)
+                    return None
+
+            return CommingMessage(
+                channel=MessageChannel.Telegram,
+                source=client_config.name,
+                userid=user_id,
+                username=user_name,
+                text=text
+            )
         return None
 
     def post_message(self, message: Notification) -> None:
@@ -177,7 +246,10 @@ class TelegramModule(_ModuleBase, _MessageBase[Telegram]):
             client: Telegram = self.get_instance(conf.name)
             if client:
                 client.send_msg(title=message.title, text=message.text,
-                                image=message.image, userid=userid, link=message.link)
+                                image=message.image, userid=userid, link=message.link,
+                                buttons=message.buttons,
+                                original_message_id=message.original_message_id,
+                                original_chat_id=message.original_chat_id)
 
     def post_medias_message(self, message: Notification, medias: List[MediaInfo]) -> None:
         """
@@ -192,7 +264,10 @@ class TelegramModule(_ModuleBase, _MessageBase[Telegram]):
             client: Telegram = self.get_instance(conf.name)
             if client:
                 client.send_medias_msg(title=message.title, medias=medias,
-                                       userid=message.userid, link=message.link)
+                                       userid=message.userid, link=message.link,
+                                       buttons=message.buttons,
+                                       original_message_id=message.original_message_id,
+                                       original_chat_id=message.original_chat_id)
 
     def post_torrents_message(self, message: Notification, torrents: List[Context]) -> None:
         """
@@ -207,7 +282,33 @@ class TelegramModule(_ModuleBase, _MessageBase[Telegram]):
             client: Telegram = self.get_instance(conf.name)
             if client:
                 client.send_torrents_msg(title=message.title, torrents=torrents,
-                                         userid=message.userid, link=message.link)
+                                         userid=message.userid, link=message.link,
+                                         buttons=message.buttons,
+                                         original_message_id=message.original_message_id,
+                                         original_chat_id=message.original_chat_id)
+
+    def delete_message(self, channel: MessageChannel, source: str,
+                       message_id: int, chat_id: Optional[int] = None) -> bool:
+        """
+        删除消息
+        :param channel: 消息渠道
+        :param source: 指定的消息源
+        :param message_id: 消息ID
+        :param chat_id: 聊天ID
+        :return: 删除是否成功
+        """
+        success = False
+        for conf in self.get_configs().values():
+            if channel != self._channel:
+                break
+            if source != conf.name:
+                continue
+            client: Telegram = self.get_instance(conf.name)
+            if client:
+                result = client.delete_msg(message_id=message_id, chat_id=chat_id)
+                if result:
+                    success = True
+        return success
 
     def register_commands(self, commands: Dict[str, dict]):
         """

app/modules/telegram/telegram.py

@@ -3,11 +3,13 @@ import threading
 import uuid
 from pathlib import Path
 from threading import Event
-from typing import Optional, List, Dict
+from typing import Optional, List, Dict, Callable
+from urllib.parse import urljoin
 
 import telebot
 from telebot import apihelper
-from telebot.types import InputFile
+from telebot.types import InputFile, InlineKeyboardMarkup, InlineKeyboardButton
+from telebot.types import InputMediaPhoto
 
 from app.core.config import settings
 from app.core.context import MediaInfo, Context
@@ -17,13 +19,12 @@ from app.utils.common import retry
 from app.utils.http import RequestUtils
 from app.utils.string import StringUtils
 
-apihelper.proxy = settings.PROXY
-
 
 class Telegram:
     _ds_url = f"http://127.0.0.1:{settings.PORT}/api/v1/message?token={settings.API_TOKEN}"
     _event = Event()
     _bot: telebot.TeleBot = None
+    _callback_handlers: Dict[str, Callable] = {}  # 存储回调处理器
 
     def __init__(self, TELEGRAM_TOKEN: Optional[str] = None, TELEGRAM_CHAT_ID: Optional[str] = None, **kwargs):
         """
@@ -38,6 +39,12 @@ class Telegram:
         self._telegram_chat_id = TELEGRAM_CHAT_ID
         # 初始化机器人
         if self._telegram_token and self._telegram_chat_id:
+            # telegram bot api 地址，格式：https://api.telegram.org
+            if kwargs.get("API_URL"):
+                apihelper.API_URL = urljoin(kwargs["API_URL"], '/bot{0}/{1}')
+                apihelper.FILE_URL = urljoin(kwargs["API_URL"], '/file/bot{0}/{1}')
+            else:
+                apihelper.proxy = settings.PROXY
             # bot
             _bot = telebot.TeleBot(self._telegram_token, parse_mode="Markdown")
             # 记录句柄
@@ -52,7 +59,44 @@ class Telegram:
 
             @_bot.message_handler(func=lambda message: True)
             def echo_all(message):
-                RequestUtils(timeout=5).post_res(self._ds_url, json=message.json)
+                RequestUtils(timeout=15).post_res(self._ds_url, json=message.json)
+
+            @_bot.callback_query_handler(func=lambda call: True)
+            def callback_query(call):
+                """
+                处理按钮点击回调
+                """
+                try:
+                    # 解析回调数据
+                    callback_data = call.data
+                    user_id = str(call.from_user.id)
+
+                    logger.info(f"收到按钮回调：{callback_data}，用户：{user_id}")
+
+                    # 发送回调数据给主程序处理
+                    callback_json = {
+                        "callback_query": {
+                            "id": call.id,
+                            "from": call.from_user.to_dict(),
+                            "message": {
+                                "message_id": call.message.message_id,
+                                "chat": {
+                                    "id": call.message.chat.id,
+                                }
+                            },
+                            "data": callback_data
+                        }
+                    }
+
+                    # 先确认回调，避免用户看到loading状态
+                    _bot.answer_callback_query(call.id)
+
+                    # 发送给主程序处理
+                    RequestUtils(timeout=15).post_res(self._ds_url, json=callback_json)
+
+                except Exception as e:
+                    logger.error(f"处理按钮回调失败：{str(e)}")
+                    _bot.answer_callback_query(call.id, "处理失败，请重试")
 
             def run_polling():
                 """
@@ -75,7 +119,10 @@ class Telegram:
         return self._bot is not None
 
     def send_msg(self, title: str, text: Optional[str] = None, image: Optional[str] = None,
-                 userid: Optional[str] = None, link: Optional[str] = None) -> Optional[bool]:
+                 userid: Optional[str] = None, link: Optional[str] = None,
+                 buttons: Optional[List[List[dict]]] = None,
+                 original_message_id: Optional[int] = None,
+                 original_chat_id: Optional[str] = None) -> Optional[bool]:
         """
         发送Telegram消息
         :param title: 消息标题
@@ -83,6 +130,9 @@ class Telegram:
         :param image: 消息图片地址
         :param userid: 用户ID，如有则只发消息给该用户
         :param link: 跳转链接
+        :param buttons: 按钮列表，格式：[[{"text": "按钮文本", "callback_data": "回调数据"}]]
+        :param original_message_id: 原消息ID，如果提供则编辑原消息
+        :param original_chat_id: 原消息的聊天ID，编辑消息时需要
         :userid: 发送消息的目标用户ID，为空则发给管理员
         """
         if not self._telegram_token or not self._telegram_chat_id:
@@ -108,16 +158,37 @@ class Telegram:
             else:
                 chat_id = self._telegram_chat_id
 
-            return self.__send_request(userid=chat_id, image=image, caption=caption)
+            # 创建按钮键盘
+            reply_markup = None
+            if buttons:
+                reply_markup = self._create_inline_keyboard(buttons)
+
+            # 判断是编辑消息还是发送新消息
+            if original_message_id and original_chat_id:
+                # 编辑消息
+                return self.__edit_message(original_chat_id, original_message_id, caption, buttons, image)
+            else:
+                # 发送新消息
+                return self.__send_request(userid=chat_id, image=image, caption=caption, reply_markup=reply_markup)
 
         except Exception as msg_e:
             logger.error(f"发送消息失败：{msg_e}")
             return False
 
     def send_medias_msg(self, medias: List[MediaInfo], userid: Optional[str] = None,
-                        title: Optional[str] = None, link: Optional[str] = None) -> Optional[bool]:
+                        title: Optional[str] = None, link: Optional[str] = None,
+                        buttons: Optional[List[List[Dict]]] = None,
+                        original_message_id: Optional[int] = None,
+                        original_chat_id: Optional[str] = None) -> Optional[bool]:
         """
         发送媒体列表消息
+        :param medias: 媒体信息列表
+        :param userid: 用户ID，如有则只发消息给该用户
+        :param title: 消息标题
+        :param link: 跳转链接
+        :param buttons: 按钮列表，格式：[[{"text": "按钮文本", "callback_data": "回调数据"}]]
+        :param original_message_id: 原消息ID，如果提供则编辑原消息
+        :param original_chat_id: 原消息的聊天ID，编辑消息时需要
         """
         if not self._telegram_token or not self._telegram_chat_id:
             return None
@@ -150,26 +221,44 @@ class Telegram:
             else:
                 chat_id = self._telegram_chat_id
 
-            return self.__send_request(userid=chat_id, image=image, caption=caption)
+            # 创建按钮键盘
+            reply_markup = None
+            if buttons:
+                reply_markup = self._create_inline_keyboard(buttons)
+
+            # 判断是编辑消息还是发送新消息
+            if original_message_id and original_chat_id:
+                # 编辑消息
+                return self.__edit_message(original_chat_id, original_message_id, caption, buttons, image)
+            else:
+                # 发送新消息
+                return self.__send_request(userid=chat_id, image=image, caption=caption, reply_markup=reply_markup)
 
         except Exception as msg_e:
             logger.error(f"发送消息失败：{msg_e}")
             return False
 
     def send_torrents_msg(self, torrents: List[Context],
-                          userid: Optional[str] = None, title: Optional[str] = None, link: Optional[str] = None) -> Optional[bool]:
+                          userid: Optional[str] = None, title: Optional[str] = None,
+                          link: Optional[str] = None, buttons: Optional[List[List[Dict]]] = None,
+                          original_message_id: Optional[int] = None,
+                          original_chat_id: Optional[str] = None) -> Optional[bool]:
         """
-        发送列表消息
+        发送种子列表消息
+        :param torrents: 种子信息列表
+        :param userid: 用户ID，如有则只发消息给该用户
+        :param title: 消息标题
+        :param link: 跳转链接
+        :param buttons: 按钮列表，格式：[[{"text": "按钮文本", "callback_data": "回调数据"}]]
+        :param original_message_id: 原消息ID，如果提供则编辑原消息
+        :param original_chat_id: 原消息的聊天ID，编辑消息时需要
         """
         if not self._telegram_token or not self._telegram_chat_id:
             return None
 
-        if not torrents:
-            return False
-
         try:
             index, caption = 1, "*%s*" % title
-            mediainfo = torrents[0].media_info
+            image = torrents[0].media_info.get_message_image()
             for context in torrents:
                 torrent = context.torrent_info
                 site_name = torrent.site_name
@@ -194,20 +283,142 @@ class Telegram:
             else:
                 chat_id = self._telegram_chat_id
 
-            return self.__send_request(userid=chat_id, caption=caption,
-                                       image=mediainfo.get_message_image())
+            # 创建按钮键盘
+            reply_markup = None
+            if buttons:
+                reply_markup = self._create_inline_keyboard(buttons)
+
+            # 判断是编辑消息还是发送新消息
+            if original_message_id and original_chat_id:
+                # 编辑消息（种子消息通常没有图片）
+                return self.__edit_message(original_chat_id, original_message_id, caption, buttons, image)
+            else:
+                # 发送新消息
+                return self.__send_request(userid=chat_id, image=image, caption=caption, reply_markup=reply_markup)
 
         except Exception as msg_e:
             logger.error(f"发送消息失败：{msg_e}")
             return False
 
+    @staticmethod
+    def _create_inline_keyboard(buttons: List[List[Dict]]) -> InlineKeyboardMarkup:
+        """
+        创建内联键盘
+        :param buttons: 按钮配置，格式：[[{"text": "按钮文本", "callback_data": "回调数据", "url": "链接"}]]
+        :return: InlineKeyboardMarkup对象
+        """
+        keyboard = []
+        for row in buttons:
+            button_row = []
+            for button in row:
+                if "url" in button:
+                    # URL按钮
+                    btn = InlineKeyboardButton(text=button["text"], url=button["url"])
+                else:
+                    # 回调按钮
+                    btn = InlineKeyboardButton(text=button["text"], callback_data=button["callback_data"])
+                button_row.append(btn)
+            keyboard.append(button_row)
+        return InlineKeyboardMarkup(keyboard)
+
+    def answer_callback_query(self, callback_query_id: int, text: Optional[str] = None,
+                              show_alert: bool = False) -> Optional[bool]:
+        """
+        回应回调查询
+        """
+        if not self._bot:
+            return None
+
+        try:
+            self._bot.answer_callback_query(callback_query_id, text=text, show_alert=show_alert)
+            return True
+        except Exception as e:
+            logger.error(f"回应回调查询失败：{str(e)}")
+            return False
+
+    def delete_msg(self, message_id: int, chat_id: Optional[int] = None) -> Optional[bool]:
+        """
+        删除Telegram消息
+        :param message_id: 消息ID
+        :param chat_id: 聊天ID
+        :return: 删除是否成功
+        """
+        if not self._telegram_token or not self._telegram_chat_id:
+            return None
+
+        try:
+            # 确定要删除消息的聊天ID
+            if chat_id:
+                target_chat_id = chat_id
+            else:
+                target_chat_id = self._telegram_chat_id
+
+            # 删除消息
+            result = self._bot.delete_message(chat_id=target_chat_id, message_id=int(message_id))
+            if result:
+                logger.info(f"成功删除Telegram消息: chat_id={target_chat_id}, message_id={message_id}")
+                return True
+            else:
+                logger.error(f"删除Telegram消息失败: chat_id={target_chat_id}, message_id={message_id}")
+                return False
+        except Exception as e:
+            logger.error(f"删除Telegram消息异常: {str(e)}")
+            return False
+
+    def __edit_message(self, chat_id: str, message_id: int, text: str,
+                       buttons: Optional[List[List[dict]]] = None,
+                       image: Optional[str] = None) -> Optional[bool]:
+        """
+        编辑已发送的消息
+        :param chat_id: 聊天ID
+        :param message_id: 消息ID
+        :param text: 新的消息内容
+        :param buttons: 按钮列表
+        :param image: 图片URL或路径
+        :return: 编辑是否成功
+        """
+        if not self._bot:
+            return None
+
+        try:
+
+            # 创建按钮键盘
+            reply_markup = None
+            if buttons:
+                reply_markup = self._create_inline_keyboard(buttons)
+
+            if image:
+                # 如果有图片，使用edit_message_media
+                media = InputMediaPhoto(media=image, caption=text, parse_mode="Markdown")
+                self._bot.edit_message_media(
+                    chat_id=chat_id,
+                    message_id=message_id,
+                    media=media,
+                    reply_markup=reply_markup
+                )
+            else:
+                # 如果没有图片，使用edit_message_text
+                self._bot.edit_message_text(
+                    chat_id=chat_id,
+                    message_id=message_id,
+                    text=text,
+                    parse_mode="Markdown",
+                    reply_markup=reply_markup
+                )
+            return True
+        except Exception as e:
+            logger.error(f"编辑消息失败：{str(e)}")
+            return False
+
     @retry(Exception, logger=logger)
-    def __send_request(self, userid: Optional[str] = None, image="", caption="") -> bool:
+    def __send_request(self, userid: Optional[str] = None, image="", caption="",
+                       reply_markup: Optional[InlineKeyboardMarkup] = None) -> bool:
         """
         向Telegram发送报文
+        :param reply_markup: 内联键盘
         """
         if image:
-            res = RequestUtils(proxies=settings.PROXY).get_res(image)
+            res = RequestUtils(proxies=settings.PROXY, ua=settings.USER_AGENT).get_res(image)
             if res is None:
                 raise Exception("获取图片失败")
             if res.content:
@@ -221,7 +432,8 @@ class Telegram:
                 ret = self._bot.send_photo(chat_id=userid or self._telegram_chat_id,
                                            photo=photo,
                                            caption=caption,
-                                           parse_mode="Markdown")
+                                           parse_mode="Markdown",
+                                           reply_markup=reply_markup)
                 if ret is None:
                     raise Exception("发送图片消息失败")
                 return True
@@ -231,11 +443,13 @@ class Telegram:
             for i in range(0, len(caption), 4095):
                 ret = self._bot.send_message(chat_id=userid or self._telegram_chat_id,
                                              text=caption[i:i + 4095],
-                                             parse_mode="Markdown")
+                                             parse_mode="Markdown",
+                                             reply_markup=reply_markup if i == 0 else None)
         else:
             ret = self._bot.send_message(chat_id=userid or self._telegram_chat_id,
                                          text=caption,
-                                         parse_mode="Markdown")
+                                         parse_mode="Markdown",
+                                         reply_markup=reply_markup)
         if ret is None:
             raise Exception("发送文本消息失败")
         return True if ret else False

app/modules/themoviedb/tmdb_cache.py

@@ -15,7 +15,7 @@ from app.schemas.types import MediaType
 lock = RLock()
 
 CACHE_EXPIRE_TIMESTAMP_STR = "cache_expire_timestamp"
-EXPIRE_TIMESTAMP = settings.CONF["meta"]
+EXPIRE_TIMESTAMP = settings.CONF.meta
 
 
 class TmdbCache(metaclass=Singleton):

app/modules/themoviedb/tmdbapi.py

@@ -500,7 +500,7 @@ class TmdbApi:
 
             return ret_info
 
-    @cached(maxsize=settings.CONF["tmdb"], ttl=settings.CONF["meta"])
+    @cached(maxsize=settings.CONF.tmdb, ttl=settings.CONF.meta)
     @rate_limit_exponential(source="match_tmdb_web", base_wait=5, max_wait=1800, enable_logging=True)
     def match_web(self, name: str, mtype: MediaType) -> Optional[dict]:
         """

app/modules/themoviedb/tmdbv3api/as_obj.py

@@ -59,7 +59,7 @@ class AsObj:
 
     def __setitem__(self, key, value):
         return setattr(self, key, value)
-    
+
     def __str__(self):
         return str(self._obj_list) if self._list_only else str(self._dict())
 
@@ -91,10 +91,10 @@ class AsObj:
 
     def pop(self, key, value=None):
         return self.__dict__.pop(key, value)
-    
+
     def popitem(self):
         return self.__dict__.popitem()
-    
+
     def setdefault(self, key, value=None):
         return self.__dict__.setdefault(key, value)
 

app/modules/themoviedb/tmdbv3api/objs/collection.py

@@ -4,7 +4,7 @@ from ..tmdb import TMDb
 class Collection(TMDb):
     _urls = {
         "details": "/collection/%s",
-        "images": "/collection/%s/images", 
+        "images": "/collection/%s/images",
         "translations": "/collection/%s/translations"
     }
 

app/modules/themoviedb/tmdbv3api/objs/company.py

@@ -3,7 +3,7 @@ from ..tmdb import TMDb
 
 class Company(TMDb):
     _urls = {
-        "details": "/company/%s", 
+        "details": "/company/%s",
         "alternative_names": "/company/%s/alternative_names",
         "images": "/company/%s/images",
         "movies": "/company/%s/movies"

app/modules/themoviedb/tmdbv3api/objs/movie.py

@@ -101,11 +101,11 @@ class Movie(TMDb):
         :return:
         """
         return self._request_obj(self._urls["external_ids"] % movie_id)
-    
+
     def images(self, movie_id, include_image_language=None):
         """
         Get the images that belong to a movie.
-        Querying images with a language parameter will filter the results. 
+        Querying images with a language parameter will filter the results.
         If you want to include a fallback language (especially useful for backdrops)
         you can use the include_image_language parameter.
         This should be a comma separated value like so: include_image_language=en,null.

app/modules/themoviedb/tmdbv3api/objs/search.py

@@ -55,7 +55,7 @@ class Search(TMDb):
             params="query=%s&page=%s" % (quote(term), page),
             key="results"
         )
-    
+
     def movies(self, term, adult=None, region=None, year=None, release_year=None, page=1):
         """
         Search for movies.

app/modules/themoviedb/tmdbv3api/objs/trending.py

@@ -1,12 +1,9 @@
-from app.core.cache import cached
-
 from ..tmdb import TMDb
 
 
 class Trending(TMDb):
     _urls = {"trending": "/trending/%s/%s"}
 
-    @cached(maxsize=1024, ttl=43200)
     def _trending(self, media_type="all", time_window="day", page=1):
         """
         Get trending, TTLCache 12 hours

app/modules/themoviedb/tmdbv3api/tmdb.py

@@ -124,7 +124,7 @@ class TMDb(object):
     def cache(self, cache):
         self._cache_enabled = bool(cache)
 
-    @cached(maxsize=settings.CONF["tmdb"], ttl=settings.CONF["meta"])
+    @cached(maxsize=settings.CONF.tmdb, ttl=settings.CONF.meta)
     def cached_request(self, method, url, data, json,
                        _ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """

app/modules/transmission/__init__.py

@@ -36,6 +36,7 @@ class TransmissionModule(_ModuleBase, _DownloaderBase[Transmission]):
         event_data: schemas.ConfigChangeEventData = event.event_data
         if event_data.key not in [SystemConfigKey.Downloaders.value]:
             return
+        logger.info("配置变更，重新加载Transmission模块...")
         self.init_module()
 
     @staticmethod
@@ -162,24 +163,28 @@ class TransmissionModule(_ModuleBase, _DownloaderBase[Transmission]):
             if error:
                 return None, None, None, "无法连接transmission下载器"
             if torrents:
-                for torrent in torrents:
-                    # 名称与大小相等则认为是同一个种子
-                    if torrent.name == torrent_name and torrent.total_size == torrent_size:
-                        torrent_hash = torrent.hashString
-                        logger.warn(f"下载器中已存在该种子任务：{torrent_hash} - {torrent.name}")
-                        # 给种子打上标签
-                        if settings.TORRENT_TAG:
-                            logger.info(f"给种子 {torrent_hash} 打上标签：{settings.TORRENT_TAG}")
-                            # 种子标签
-                            labels = [str(tag).strip()
-                                      for tag in torrent.labels] if hasattr(torrent, "labels") else []
-                            if "已整理" in labels:
-                                labels.remove("已整理")
-                                server.set_torrent_tag(ids=torrent_hash, tags=labels)
-                            if settings.TORRENT_TAG and settings.TORRENT_TAG not in labels:
-                                labels.append(settings.TORRENT_TAG)
-                                server.set_torrent_tag(ids=torrent_hash, tags=labels)
-                        return downloader or self.get_default_config_name(), torrent_hash, torrent_layout, f"下载任务已存在"
+                try:
+                    for torrent in torrents:
+                        # 名称与大小相等则认为是同一个种子
+                        if torrent.name == torrent_name and torrent.total_size == torrent_size:
+                            torrent_hash = torrent.hashString
+                            logger.warn(f"下载器中已存在该种子任务：{torrent_hash} - {torrent.name}")
+                            # 给种子打上标签
+                            if settings.TORRENT_TAG:
+                                logger.info(f"给种子 {torrent_hash} 打上标签：{settings.TORRENT_TAG}")
+                                # 种子标签
+                                labels = [str(tag).strip()
+                                          for tag in torrent.labels] if hasattr(torrent, "labels") else []
+                                if "已整理" in labels:
+                                    labels.remove("已整理")
+                                    server.set_torrent_tag(ids=torrent_hash, tags=labels)
+                                if settings.TORRENT_TAG and settings.TORRENT_TAG not in labels:
+                                    labels.append(settings.TORRENT_TAG)
+                                    server.set_torrent_tag(ids=torrent_hash, tags=labels)
+                            return downloader or self.get_default_config_name(), torrent_hash, torrent_layout, f"下载任务已存在"
+                finally:
+                    torrents.clear()
+                    del torrents
             return None, None, None, f"添加种子任务失败：{content}"
         else:
             torrent_hash = torrent.hashString
@@ -191,23 +196,27 @@ class TransmissionModule(_ModuleBase, _DownloaderBase[Transmission]):
                 # 需要的文件信息
                 file_ids = []
                 unwanted_file_ids = []
-                for torrent_file in torrent_files:
-                    file_id = torrent_file.id
-                    file_name = torrent_file.name
-                    meta_info = MetaInfo(file_name)
-                    if not meta_info.episode_list:
-                        unwanted_file_ids.append(file_id)
-                        continue
-                    selected = set(meta_info.episode_list).issubset(set(episodes))
-                    if not selected:
-                        unwanted_file_ids.append(file_id)
-                        continue
-                    file_ids.append(file_id)
-                # 选择文件
-                server.set_files(torrent_hash, file_ids)
-                server.set_unwanted_files(torrent_hash, unwanted_file_ids)
-                # 开始任务
-                server.start_torrents(torrent_hash)
+                try:
+                    for torrent_file in torrent_files:
+                        file_id = torrent_file.id
+                        file_name = torrent_file.name
+                        meta_info = MetaInfo(file_name)
+                        if not meta_info.episode_list:
+                            unwanted_file_ids.append(file_id)
+                            continue
+                        selected = set(meta_info.episode_list).issubset(set(episodes))
+                        if not selected:
+                            unwanted_file_ids.append(file_id)
+                            continue
+                        file_ids.append(file_id)
+                    # 选择文件
+                    server.set_files(torrent_hash, file_ids)
+                    server.set_unwanted_files(torrent_hash, unwanted_file_ids)
+                    # 开始任务
+                    server.start_torrents(torrent_hash)
+                finally:
+                    torrent_files.clear()
+                    del torrent_files
                 return downloader or self.get_default_config_name(), torrent_hash, torrent_layout, "添加下载任务成功"
             else:
                 return downloader or self.get_default_config_name(), torrent_hash, torrent_layout, "添加下载任务成功"
@@ -235,64 +244,76 @@ class TransmissionModule(_ModuleBase, _DownloaderBase[Transmission]):
         if hashs:
             # 按Hash获取
             for name, server in servers.items():
-                torrents, _ = server.get_torrents(ids=hashs, tags=settings.TORRENT_TAG)
-                for torrent in torrents or []:
-                    ret_torrents.append(TransferTorrent(
-                        downloader=name,
-                        title=torrent.name,
-                        path=Path(torrent.download_dir) / torrent.name,
-                        hash=torrent.hashString,
-                        size=torrent.total_size,
-                        tags=",".join(torrent.labels or [])
-                    ))
+                torrents, _ = server.get_torrents(ids=hashs, tags=settings.TORRENT_TAG) or []
+                try:
+                    for torrent in torrents:
+                        ret_torrents.append(TransferTorrent(
+                            downloader=name,
+                            title=torrent.name,
+                            path=Path(torrent.download_dir) / torrent.name,
+                            hash=torrent.hashString,
+                            size=torrent.total_size,
+                            tags=",".join(torrent.labels or [])
+                        ))
+                finally:
+                    torrents.clear()
+                    del torrents
         elif status == TorrentStatus.TRANSFER:
             # 获取已完成且未整理的
             for name, server in servers.items():
-                torrents = server.get_completed_torrents(tags=settings.TORRENT_TAG)
-                for torrent in torrents or []:
-                    # 含"已整理"tag的不处理
-                    if "已整理" in torrent.labels or []:
-                        continue
-                    # 下载路径
-                    path = torrent.download_dir
-                    # 无法获取下载路径的不处理
-                    if not path:
-                        logger.debug(f"未获取到 {torrent.name} 下载保存路径")
-                        continue
-                    ret_torrents.append(TransferTorrent(
-                        downloader=name,
-                        title=torrent.name,
-                        path=Path(torrent.download_dir) / torrent.name,
-                        hash=torrent.hashString,
-                        tags=",".join(torrent.labels or []),
-                        progress=torrent.progress,
-                        state="paused" if torrent.status == "stopped" else "downloading",
-                    ))
+                torrents = server.get_completed_torrents(tags=settings.TORRENT_TAG) or []
+                try:
+                    for torrent in torrents:
+                        # 含"已整理"tag的不处理
+                        if "已整理" in torrent.labels or []:
+                            continue
+                        # 下载路径
+                        path = torrent.download_dir
+                        # 无法获取下载路径的不处理
+                        if not path:
+                            logger.debug(f"未获取到 {torrent.name} 下载保存路径")
+                            continue
+                        ret_torrents.append(TransferTorrent(
+                            downloader=name,
+                            title=torrent.name,
+                            path=Path(torrent.download_dir) / torrent.name,
+                            hash=torrent.hashString,
+                            tags=",".join(torrent.labels or []),
+                            progress=torrent.progress,
+                            state="paused" if torrent.status == "stopped" else "downloading",
+                        ))
+                finally:
+                    torrents.clear()
+                    del torrents
         elif status == TorrentStatus.DOWNLOADING:
             # 获取正在下载的任务
             for name, server in servers.items():
-                torrents = server.get_downloading_torrents(tags=settings.TORRENT_TAG)
-                for torrent in torrents or []:
-                    meta = MetaInfo(torrent.name)
-                    dlspeed = torrent.rate_download if hasattr(torrent, "rate_download") else torrent.rateDownload
-                    upspeed = torrent.rate_upload if hasattr(torrent, "rate_upload") else torrent.rateUpload
-                    ret_torrents.append(DownloadingTorrent(
-                        downloader=name,
-                        hash=torrent.hashString,
-                        title=torrent.name,
-                        name=meta.name,
-                        year=meta.year,
-                        season_episode=meta.season_episode,
-                        progress=torrent.progress,
-                        size=torrent.total_size,
-                        state="paused" if torrent.status == "stopped" else "downloading",
-                        dlspeed=StringUtils.str_filesize(dlspeed),
-                        upspeed=StringUtils.str_filesize(upspeed),
-                        left_time=StringUtils.str_secends(torrent.left_until_done / dlspeed) if dlspeed > 0 else ''
-                    ))
+                torrents = server.get_downloading_torrents(tags=settings.TORRENT_TAG) or []
+                try:
+                    for torrent in torrents:
+                        meta = MetaInfo(torrent.name)
+                        dlspeed = torrent.rate_download if hasattr(torrent, "rate_download") else torrent.rateDownload
+                        upspeed = torrent.rate_upload if hasattr(torrent, "rate_upload") else torrent.rateUpload
+                        ret_torrents.append(DownloadingTorrent(
+                            downloader=name,
+                            hash=torrent.hashString,
+                            title=torrent.name,
+                            name=meta.name,
+                            year=meta.year,
+                            season_episode=meta.season_episode,
+                            progress=torrent.progress,
+                            size=torrent.total_size,
+                            state="paused" if torrent.status == "stopped" else "downloading",
+                            dlspeed=StringUtils.str_filesize(dlspeed),
+                            upspeed=StringUtils.str_filesize(upspeed),
+                            left_time=StringUtils.str_secends(torrent.left_until_done / dlspeed) if dlspeed > 0 else ''
+                        ))
+                finally:
+                    torrents.clear()
+                    del torrents
         else:
             return None
-        return ret_torrents
+        return ret_torrents # noqa
 
     def transfer_completed(self, hashs: str, downloader: Optional[str] = None) -> None:
         """
@@ -312,6 +333,7 @@ class TransmissionModule(_ModuleBase, _DownloaderBase[Transmission]):
         else:
             tags = ['已整理']
         server.set_torrent_tag(ids=hashs, tags=tags)
+        return None
 
     def remove_torrents(self, hashs: Union[str, list], delete_file: Optional[bool] = True,
                         downloader: Optional[str] = None) -> Optional[bool]:
@@ -354,7 +376,7 @@ class TransmissionModule(_ModuleBase, _DownloaderBase[Transmission]):
         server: Transmission = self.get_instance(downloader)
         if not server:
             return None
-        return server.start_torrents(ids=hashs)
+        return server.stop_torrents(ids=hashs)
 
     def torrent_files(self, tid: str, downloader: Optional[str] = None) -> Optional[List[File]]:
         """

app/modules/transmission/transmission.py

@@ -1,4 +1,4 @@
-from typing import Optional, Union, Tuple, List, Literal
+from typing import Optional, Union, Tuple, List
 
 import transmission_rpc
 from transmission_rpc import Client, Torrent, File
@@ -9,14 +9,9 @@ from app.utils.url import UrlUtils
 
 
 class Transmission:
-    _protocol: Literal["http", "https"] = "http"
-    _host: Optional[str] = None
-    _port: Optional[int] = None
-    _username: Optional[str] = None
-    _password: Optional[str] = None
-
-    trc: Optional[Client] = None
-
+    """
+    Transmission下载器
+    """
     # 参考transmission web，仅查询需要的参数，加速种子搜索
     _trarg = ["id", "name", "status", "labels", "hashString", "totalSize", "percentDone", "addedDate", "trackerList",
               "trackerStats",
@@ -24,7 +19,7 @@ class Transmission:
               "peersGettingFromUs", "peersSendingToUs", "uploadRatio", "uploadedEver", "downloadedEver", "downloadDir",
               "error", "errorString", "doneDate", "queuePosition", "activityDate", "trackers"]
 
-    def __init__(self, host: Optional[str] = None, port: Optional[int] = None, 
+    def __init__(self, host: Optional[str] = None, port: Optional[int] = None,
                  username: Optional[str] = None, password: Optional[str] = None, **kwargs):
         """
         若不设置参数，则创建配置文件设置的下载器
@@ -43,18 +38,19 @@ class Transmission:
             return
         self._username = username
         self._password = password
-        if self._host and self._port:
-            self.trc = self.__login_transmission()
+        self.trc = self.__login_transmission()
 
     def __login_transmission(self) -> Optional[Client]:
         """
         连接transmission
         :return: transmission对象
         """
+        if not self._host or not self._port:
+            return None
         try:
             # 登录
             logger.info(f"正在连接 transmission：{self._protocol}://{self._host}:{self._port}")
-            trt = transmission_rpc.Client(protocol=self._protocol,
+            trt = transmission_rpc.Client(protocol=self._protocol, # noqa
                                           host=self._host,
                                           port=self._port,
                                           username=self._username,
@@ -97,16 +93,20 @@ class Transmission:
         if tags and not isinstance(tags, list):
             tags = [tags]
         ret_torrents = []
-        for torrent in torrents:
-            # 状态过滤
-            if status and torrent.status not in status:
-                continue
-            # 种子标签
-            labels = [str(tag).strip()
-                      for tag in torrent.labels] if hasattr(torrent, "labels") else []
-            if tags and not set(tags).issubset(set(labels)):
-                continue
-            ret_torrents.append(torrent)
+        try:
+            for torrent in torrents:
+                # 状态过滤
+                if status and torrent.status not in status:
+                    continue
+                # 种子标签
+                labels = [str(tag).strip()
+                          for tag in torrent.labels] if hasattr(torrent, "labels") else []
+                if tags and not set(tags).issubset(set(labels)):
+                    continue
+                ret_torrents.append(torrent)
+        finally:
+            torrents.clear()
+            del torrents
         return ret_torrents, False
 
     def get_completed_torrents(self, ids: Union[str, list] = None,

app/modules/trimemedia/__init__.py

@@ -34,6 +34,7 @@ class TrimeMediaModule(_ModuleBase, _MediaServerBase[TrimeMedia]):
         event_data: schemas.ConfigChangeEventData = event.event_data
         if event_data.key not in [SystemConfigKey.MediaServers.value]:
             return
+        logger.info("配置变更，重新加载飞牛影视模块...")
         self.init_module()
 
     @staticmethod

app/modules/vocechat/__init__.py

@@ -31,6 +31,7 @@ class VoceChatModule(_ModuleBase, _MessageBase[VoceChat]):
         event_data: ConfigChangeEventData = event.event_data
         if event_data.key not in [SystemConfigKey.Notifications.value]:
             return
+        logger.info("配置变更，重新加载VoceChat模块...")
         self.init_module()
 
     @staticmethod

app/modules/webpush/__init__.py

@@ -31,6 +31,7 @@ class WebPushModule(_ModuleBase, _MessageBase):
         event_data: ConfigChangeEventData = event.event_data
         if event_data.key not in [SystemConfigKey.Notifications.value]:
             return
+        logger.info("配置变更，重新加载WebPush模块...")
         self.init_module()
 
     @staticmethod

app/modules/wechat/__init__.py

@@ -35,6 +35,7 @@ class WechatModule(_ModuleBase, _MessageBase[WeChat]):
         event_data: ConfigChangeEventData = event.event_data
         if event_data.key not in [SystemConfigKey.Notifications.value]:
             return
+        logger.info("配置变更，重新加载Wechat模块...")
         self.init_module()
 
     @staticmethod
@@ -127,7 +128,7 @@ class WechatModule(_ModuleBase, _MessageBase[WeChat]):
             1、消息格式：
             <xml>
                <ToUserName><![CDATA[toUser]]></ToUserName>
-               <FromUserName><![CDATA[fromUser]]></FromUserName> 
+               <FromUserName><![CDATA[fromUser]]></FromUserName>
                <CreateTime>1348831860</CreateTime>
                <MsgType><![CDATA[text]]></MsgType>
                <Content><![CDATA[this is a test]]></Content>
@@ -142,7 +143,7 @@ class WechatModule(_ModuleBase, _MessageBase[WeChat]):
                 <MsgType><![CDATA[event]]></MsgType>
                 <Event><![CDATA[subscribe]]></Event>
                 <AgentID>1</AgentID>
-            </xml>            
+            </xml>
             """
             dom_tree = xml.dom.minidom.parseString(sMsg.decode('UTF-8'))
             root_node = dom_tree.documentElement

app/monitor.py

@@ -1,10 +1,13 @@
+import json
 import platform
 import re
+import subprocess
 import threading
+import time
 import traceback
 from pathlib import Path
 from threading import Lock
-from typing import Any, Optional
+from typing import Any, Optional, Dict, List
 
 from apscheduler.schedulers.background import BackgroundScheduler
 from cachetools import TTLCache
@@ -65,8 +68,8 @@ class Monitor(metaclass=Singleton):
     # 定时服务
     _scheduler = None
 
-    # 存储快照
-    _storage_snapshot = {}
+    # 存储快照缓存目录
+    _snapshot_cache_dir = None
 
     # 存储过照间隔（分钟）
     _snapshot_interval = 5
@@ -77,6 +80,9 @@ class Monitor(metaclass=Singleton):
     def __init__(self):
         super().__init__()
         self.all_exts = settings.RMT_MEDIAEXT
+        # 初始化快照缓存目录
+        self._snapshot_cache_dir = settings.TEMP_PATH / "snapshots"
+        self._snapshot_cache_dir.mkdir(exist_ok=True)
         # 启动目录监控和文件整理
         self.init()
 
@@ -91,8 +97,252 @@ class Monitor(metaclass=Singleton):
         event_data: ConfigChangeEventData = event.event_data
         if event_data.key not in [SystemConfigKey.Directories.value]:
             return
+        logger.info("配置变更事件触发，重新初始化目录监控...")
         self.init()
 
+    def save_snapshot(self, storage: str, snapshot: Dict, file_count: int = 0):
+        """
+        保存快照到文件
+        :param storage: 存储名称
+        :param snapshot: 快照数据
+        :param file_count: 文件数量，用于调整监控间隔
+        """
+        try:
+            cache_file = self._snapshot_cache_dir / f"{storage}_snapshot.json"
+            snapshot_data = {
+                'timestamp': time.time(),
+                'file_count': file_count,
+                'snapshot': snapshot
+            }
+            with open(cache_file, 'w', encoding='utf-8') as f:
+                json.dump(snapshot_data, f, ensure_ascii=False, indent=2)  # noqa
+            logger.debug(f"快照已保存到 {cache_file}")
+        except Exception as e:
+            logger.error(f"保存快照失败: {e}")
+
+    def load_snapshot(self, storage: str) -> Optional[Dict]:
+        """
+        从文件加载快照
+        :param storage: 存储名称
+        :return: 快照数据或None
+        """
+        try:
+            cache_file = self._snapshot_cache_dir / f"{storage}_snapshot.json"
+            if cache_file.exists():
+                with open(cache_file, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                    return data
+            return None
+        except Exception as e:
+            logger.error(f"加载快照失败: {e}")
+            return None
+
+    @staticmethod
+    def adjust_monitor_interval(file_count: int) -> int:
+        """
+        根据文件数量动态调整监控间隔
+        :param file_count: 文件数量
+        :return: 监控间隔（分钟）
+        """
+        if file_count < 100:
+            return 5  # 5分钟
+        elif file_count < 500:
+            return 10  # 10分钟
+        elif file_count < 1000:
+            return 15  # 15分钟
+        else:
+            return 30  # 30分钟
+
+    @staticmethod
+    def compare_snapshots(old_snapshot: Dict, new_snapshot: Dict) -> Dict[str, List]:
+        """
+        比对快照，找出变化的文件（只处理新增和修改，不处理删除）
+        :param old_snapshot: 旧快照
+        :param new_snapshot: 新快照
+        :return: 变化信息
+        """
+        changes = {
+            'added': [],
+            'modified': []
+        }
+
+        old_files = set(old_snapshot.keys())
+        new_files = set(new_snapshot.keys())
+
+        # 新增文件
+        changes['added'] = list(new_files - old_files)
+
+        # 修改文件（大小或时间变化）
+        for file_path in old_files & new_files:
+            old_info = old_snapshot[file_path]
+            new_info = new_snapshot[file_path]
+
+            # 检查文件大小变化
+            old_size = old_info.get('size', 0) if isinstance(old_info, dict) else old_info
+            new_size = new_info.get('size', 0) if isinstance(new_info, dict) else new_info
+
+            # 检查修改时间变化（如果有的话）
+            old_time = old_info.get('modify_time', 0) if isinstance(old_info, dict) else 0
+            new_time = new_info.get('modify_time', 0) if isinstance(new_info, dict) else 0
+
+            if old_size != new_size or (old_time and new_time and old_time != new_time):
+                changes['modified'].append(file_path)
+
+        return changes
+
+    @staticmethod
+    def count_directory_files(directory: Path, max_check: int = 10000) -> int:
+        """
+        统计目录下的文件数量（用于检测是否超过系统限制）
+        :param directory: 目录路径
+        :param max_check: 最大检查数量，避免长时间阻塞
+        :return: 文件数量
+        """
+        try:
+            count = 0
+            import os
+            for root, dirs, files in os.walk(str(directory)):
+                count += len(files)
+                if count > max_check:
+                    return count
+            return count
+        except Exception as err:
+            logger.debug(f"统计目录文件数量失败: {err}")
+            return 0
+
+    @staticmethod
+    def check_system_limits() -> Dict[str, Any]:
+        """
+        检查系统限制
+        :return: 系统限制信息
+        """
+        limits = {
+            'max_user_watches': 0,
+            'max_user_instances': 0,
+            'current_watches': 0,
+            'warnings': []
+        }
+
+        try:
+            system = platform.system()
+            if system == 'Linux':
+                # 检查 inotify 限制
+                try:
+                    with open('/proc/sys/fs/inotify/max_user_watches', 'r') as f:
+                        limits['max_user_watches'] = int(f.read().strip())
+                except Exception as e:
+                    logger.debug(f"读取 inotify 限制失败: {e}")
+                    limits['max_user_watches'] = 8192  # 默认值
+
+                try:
+                    with open('/proc/sys/fs/inotify/max_user_instances', 'r') as f:
+                        limits['max_user_instances'] = int(f.read().strip())
+                except Exception as e:
+                    logger.debug(f"读取 inotify 实例限制失败: {e}")
+
+                # 检查当前使用的watches
+                try:
+                    import subprocess
+                    result = subprocess.run(['find', '/proc/*/fd', '-lname', 'anon_inode:inotify', '-printf', '%h\n'],
+                                            capture_output=True, text=True, timeout=5)
+                    if result.returncode == 0:
+                        limits['current_watches'] = len(result.stdout.strip().split('\n'))
+                except Exception as e:
+                    logger.debug(f"检查当前 inotify 使用失败: {e}")
+
+        except Exception as e:
+            limits['warnings'].append(f"检查系统限制时出错: {e}")
+
+        return limits
+
+    @staticmethod
+    def get_system_optimization_tips() -> List[str]:
+        """
+        获取系统优化建议
+        :return: 优化建议列表
+        """
+        tips = []
+        system = platform.system()
+
+        if system == 'Linux':
+            tips.extend([
+                "增加 inotify 监控数量限制:",
+                "echo fs.inotify.max_user_watches=524288 | sudo tee -a /etc/sysctl.conf",
+                "echo fs.inotify.max_user_instances=524288 | sudo tee -a /etc/sysctl.conf",
+                "sudo sysctl -p",
+                "",
+                "如果在Docker中运行，请在宿主机上执行以上命令"
+            ])
+        elif system == 'Darwin':
+            tips.extend([
+                "macOS 系统优化建议:",
+                "sudo sysctl kern.maxfiles=65536",
+                "sudo sysctl kern.maxfilesperproc=32768",
+                "ulimit -n 32768"
+            ])
+        elif system == 'Windows':
+            tips.extend([
+                "Windows 系统优化建议:",
+                "1. 关闭不必要的实时保护软件对监控目录的扫描",
+                "2. 将监控目录添加到Windows Defender排除列表",
+                "3. 确保有足够的可用内存"
+            ])
+
+        return tips
+
+    def should_use_polling(self, directory: Path, monitor_mode: str,
+                           file_count: int, limits: dict) -> tuple[bool, str]:
+        """
+        判断是否应该使用轮询模式
+        :param directory: 监控目录
+        :param monitor_mode: 配置的监控模式
+        :param file_count: 目录文件数量
+        :param limits: 系统限制信息
+        :return: (是否使用轮询, 原因)
+        """
+        if monitor_mode == "compatibility":
+            return True, "用户配置为兼容模式"
+
+        # 检查网络文件系统
+        if self.is_network_filesystem(directory):
+            return True, "检测到网络文件系统，建议使用兼容模式"
+
+        max_watches = limits.get('max_user_watches')
+        if max_watches and file_count > max_watches * 0.8:
+            return True, f"目录文件数量({file_count})接近系统限制({max_watches})"
+        return False, "使用快速模式"
+
+    @staticmethod
+    def is_network_filesystem(directory: Path) -> bool:
+        """
+        检测是否为网络文件系统
+        :param directory: 目录路径
+        :return: 是否为网络文件系统
+        """
+        try:
+            system = platform.system()
+            if system == 'Linux':
+                # 检查挂载信息
+                result = subprocess.run(['df', '-T', str(directory)],
+                                        capture_output=True, text=True, timeout=5)
+                if result.returncode == 0:
+                    output = result.stdout.lower()
+                    network_fs = ['nfs', 'cifs', 'smbfs', 'fuse', 'sshfs', 'ftpfs']
+                    return any(fs in output for fs in network_fs)
+            elif system == 'Darwin':
+                # macOS 检查
+                result = subprocess.run(['df', '-T', str(directory)],
+                                        capture_output=True, text=True, timeout=5)
+                if result.returncode == 0:
+                    output = result.stdout.lower()
+                    return 'nfs' in output or 'smbfs' in output
+            elif system == 'Windows':
+                # Windows 检查网络驱动器
+                return str(directory).startswith('\\\\')
+        except Exception as e:
+            logger.debug(f"检测网络文件系统时出错: {e}")
+        return False
+
     def init(self):
         """
         启动监控
@@ -103,10 +353,12 @@ class Monitor(metaclass=Singleton):
         # 读取目录配置
         monitor_dirs = DirectoryHelper().get_download_dirs()
         if not monitor_dirs:
+            logger.info("未找到任何目录监控配置")
             return
 
         # 按下载目录去重
         monitor_dirs = list({f"{d.storage}_{d.download_path}": d for d in monitor_dirs}.values())
+        logger.info(f"找到 {len(monitor_dirs)} 个目录监控配置")
 
         # 启动定时服务进程
         self._scheduler = BackgroundScheduler(timezone=settings.TZ)
@@ -114,9 +366,12 @@ class Monitor(metaclass=Singleton):
         messagehelper = MessageHelper()
         for mon_dir in monitor_dirs:
             if not mon_dir.library_path:
+                logger.warn(f"跳过监控配置 {mon_dir.download_path}：未设置媒体库目录")
                 continue
             if mon_dir.monitor_type != "monitor":
+                logger.debug(f"跳过监控配置 {mon_dir.download_path}：监控类型为 {mon_dir.monitor_type}")
                 continue
+
             # 检查媒体库目录是不是下载目录的子目录
             mon_path = Path(mon_dir.download_path)
             target_path = Path(mon_dir.library_path)
@@ -128,83 +383,235 @@ class Monitor(metaclass=Singleton):
             # 启动监控
             if mon_dir.storage == "local":
                 # 本地目录监控
+                logger.info(f"正在启动本地目录监控: {mon_path}")
+                logger.info("*** 重要提示：目录监控只处理新增和修改的文件，不会处理监控启动前已存在的文件 ***")
+
                 try:
-                    if mon_dir.monitor_mode == "fast":
-                        observer = self.__choose_observer()
-                    else:
+                    # 统计文件数量并给出提示
+                    file_count = self.count_directory_files(mon_path)
+                    logger.info(f"监控目录 {mon_path} 包含约 {file_count} 个文件")
+
+                    # 检查系统限制
+                    limits = self.check_system_limits()
+
+                    # 检查是否需要使用轮询模式
+                    use_polling, reason = self.should_use_polling(mon_path,
+                                                                  monitor_mode=mon_dir.monitor_mode,
+                                                                  file_count=file_count,
+                                                                  limits=limits)
+                    logger.info(f"监控模式决策: {reason}")
+
+                    if use_polling:
                         observer = PollingObserver()
+                        logger.info(f"使用兼容模式(轮询)监控 {mon_path}")
+                    else:
+                        observer = self.__choose_observer()
+                        if observer is None:
+                            logger.warn(f"快速模式不可用，自动切换到兼容模式监控 {mon_path}")
+                            observer = PollingObserver()
+                        else:
+                            logger.info(f"使用快速模式监控 {mon_path}")
+                            if limits['warnings']:
+                                for warning in limits['warnings']:
+                                    logger.warn(f"系统限制警告: {warning}")
+                            if limits['max_user_watches'] > 0:
+                                usage_percent = (file_count / limits['max_user_watches']) * 100
+                                logger.info(
+                                    f"系统监控资源使用率: {usage_percent:.1f}% ({file_count}/{limits['max_user_watches']})")
+
                     self._observers.append(observer)
                     observer.schedule(FileMonitorHandler(mon_path=mon_path, callback=self),
                                       path=str(mon_path),
                                       recursive=True)
                     observer.daemon = True
                     observer.start()
-                    logger.info(f"已启动 {mon_path} 的目录监控服务, 监控模式：{mon_dir.monitor_mode}")
+
+                    mode_name = "兼容模式(轮询)" if use_polling else "快速模式"
+                    logger.info(f"✓ 本地目录监控已启动: {mon_path} [{mode_name}]")
+
                 except Exception as e:
                     err_msg = str(e)
-                    if "inotify" in err_msg and "reached" in err_msg:
-                        logger.warn(
-                            f"目录监控服务启动出现异常：{err_msg}，请在宿主机上（不是docker容器内）执行以下命令并重启："
-                            + """
-                             echo fs.inotify.max_user_watches=524288 | sudo tee -a /etc/sysctl.conf
-                             echo fs.inotify.max_user_instances=524288 | sudo tee -a /etc/sysctl.conf
-                             sudo sysctl -p
-                             """)
+                    logger.error(f"启动本地目录监控失败: {mon_path}")
+                    logger.error(f"错误详情: {err_msg}")
+
+                    if "inotify" in err_msg.lower():
+                        logger.error("inotify 相关错误，这通常是由于系统监控数量限制导致的")
+                        logger.error("解决方案:")
+                        tips = self.get_system_optimization_tips()
+                        for tip in tips:
+                            logger.error(f"  {tip}")
+                        logger.error("执行上述命令后重启 MoviePilot")
+                    elif "permission" in err_msg.lower():
+                        logger.error("权限错误，请检查 MoviePilot 是否有足够的权限访问监控目录")
                     else:
-                        logger.error(f"{mon_path} 启动目录监控失败：{err_msg}")
-                    messagehelper.put(f"{mon_path} 启动目录监控失败：{err_msg}", title="目录监控")
+                        logger.error("建议尝试使用兼容模式进行监控")
+
+                    messagehelper.put(f"启动本地目录监控失败: {mon_path}\n错误: {err_msg}", title="目录监控")
             else:
-                # 远程目录监控
-                self._scheduler.add_job(self.polling_observer, 'interval', minutes=self._snapshot_interval,
-                                        kwargs={
-                                            'storage': mon_dir.storage,
-                                            'mon_path': mon_path
-                                        })
+                # 远程目录监控 - 使用智能间隔
+                # 先尝试加载已有快照获取文件数量
+                snapshot_data = self.load_snapshot(mon_dir.storage)
+                file_count = snapshot_data.get('file_count', 0) if snapshot_data else 0
+                interval = self.adjust_monitor_interval(file_count)
+
+                logger.info(f"正在启动远程目录监控: {mon_path} [{mon_dir.storage}]")
+                logger.info("*** 重要提示：远程目录监控只处理新增和修改的文件，不会处理监控启动前已存在的文件 ***")
+                logger.info(f"预估文件数量: {file_count}, 监控间隔: {interval}分钟")
+
+                self._scheduler.add_job(
+                    self.polling_observer,
+                    'interval',
+                    minutes=interval,
+                    kwargs={
+                        'storage': mon_dir.storage,
+                        'mon_path': mon_path
+                    },
+                    id=f"monitor_{mon_dir.storage}_{mon_dir.download_path}",
+                    replace_existing=True
+                )
+                logger.info(f"✓ 远程目录监控已启动: {mon_path} [间隔: {interval}分钟]")
+
         # 启动定时服务
         if self._scheduler.get_jobs():
             self._scheduler.print_jobs()
             self._scheduler.start()
+            logger.info("定时监控服务已启动")
 
-    @staticmethod
-    def __choose_observer() -> Any:
+        # 输出监控总结
+        local_count = len([d for d in monitor_dirs if d.storage == "local" and d.monitor_type == "monitor"])
+        remote_count = len([d for d in monitor_dirs if d.storage != "local" and d.monitor_type == "monitor"])
+        logger.info(f"目录监控启动完成: 本地监控 {local_count} 个，远程监控 {remote_count} 个")
+
+    def __choose_observer(self) -> Optional[Any]:
         """
-        选择最优的监控模式
+        选择最优的监控模式（带错误处理和自动回退）
         """
         system = platform.system()
 
+        observers_to_try = []
+
         try:
             if system == 'Linux':
-                from watchdog.observers.inotify import InotifyObserver
-                return InotifyObserver()
+                observers_to_try = [
+                    ('InotifyObserver',
+                     lambda: self.__try_import_observer('watchdog.observers.inotify', 'InotifyObserver')),
+                ]
             elif system == 'Darwin':
-                from watchdog.observers.fsevents import FSEventsObserver
-                return FSEventsObserver()
+                observers_to_try = [
+                    ('FSEventsObserver',
+                     lambda: self.__try_import_observer('watchdog.observers.fsevents', 'FSEventsObserver')),
+                ]
             elif system == 'Windows':
-                from watchdog.observers.read_directory_changes import WindowsApiObserver
-                return WindowsApiObserver()
-        except Exception as error:
-            logger.warn(f"导入模块错误：{error}，将使用 PollingObserver 监控目录")
-        return PollingObserver()
+                observers_to_try = [
+                    ('WindowsApiObserver',
+                     lambda: self.__try_import_observer('watchdog.observers.read_directory_changes',
+                                                        'WindowsApiObserver')),
+                ]
+
+            # 尝试每个观察者
+            for observer_name, observer_func in observers_to_try:
+                try:
+                    observer_class = observer_func()
+                    if observer_class:
+                        # 尝试创建实例以验证是否可用
+                        test_observer = observer_class()
+                        test_observer.stop()  # 立即停止测试实例
+                        logger.debug(f"成功初始化 {observer_name}")
+                        return observer_class()
+                except Exception as e:
+                    logger.debug(f"初始化 {observer_name} 失败: {e}")
+                    continue
+
+        except Exception as e:
+            logger.debug(f"选择观察者时出错: {e}")
+
+        logger.debug("所有快速监控模式都不可用，将使用兼容模式")
+        return None
+
+    @staticmethod
+    def __try_import_observer(module_name: str, class_name: str):
+        """
+        尝试导入观察者类
+        """
+        try:
+            module = __import__(module_name, fromlist=[class_name])
+            return getattr(module, class_name)
+        except (ImportError, AttributeError) as e:
+            logger.debug(f"导入 {module_name}.{class_name} 失败: {e}")
+            return None
 
     def polling_observer(self, storage: str, mon_path: Path):
         """
-        轮询监控
+        轮询监控（改进版）
         """
         with snapshot_lock:
-            # 快照存储
-            new_snapshot = StorageChain().snapshot_storage(storage=storage, path=mon_path)
-            if new_snapshot:
-                # 比较快照
-                old_snapshot = self._storage_snapshot.get(storage)
+            try:
+                logger.debug(f"开始对 {storage}:{mon_path} 进行快照...")
+
+                # 加载上次快照数据
+                old_snapshot_data = self.load_snapshot(storage)
+                old_snapshot = old_snapshot_data.get('snapshot', {}) if old_snapshot_data else {}
+                last_snapshot_time = old_snapshot_data.get('timestamp', 0) if old_snapshot_data else 0
+
+                # 生成新快照（增量模式）
+                new_snapshot = StorageChain().snapshot_storage(
+                    storage=storage,
+                    path=mon_path,
+                    last_snapshot_time=last_snapshot_time
+                )
+
+                if new_snapshot is None:
+                    logger.warn(f"获取 {storage}:{mon_path} 快照失败")
+                    return
+
+                file_count = len(new_snapshot)
+                logger.info(f"{storage}:{mon_path} 快照完成，发现 {file_count} 个文件")
+
                 if old_snapshot:
-                    # 新增的文件
-                    new_files = new_snapshot.keys() - old_snapshot.keys()
-                    for new_file in new_files:
-                        # 添加到待整理队列
-                        self.__handle_file(storage=storage, event_path=Path(new_file),
-                                           file_size=new_snapshot.get(new_file))
-                # 更新快照
-                self._storage_snapshot[storage] = new_snapshot
+                    # 比较快照找出变化
+                    changes = self.compare_snapshots(old_snapshot, new_snapshot)
+
+                    # 处理新增文件
+                    for new_file in changes['added']:
+                        logger.info(f"发现新增文件：{new_file}")
+                        file_info = new_snapshot.get(new_file, {})
+                        file_size = file_info.get('size', 0) if isinstance(file_info, dict) else file_info
+                        self.__handle_file(storage=storage, event_path=Path(new_file), file_size=file_size)
+
+                    # 处理修改文件
+                    for modified_file in changes['modified']:
+                        logger.info(f"发现修改文件：{modified_file}")
+                        file_info = new_snapshot.get(modified_file, {})
+                        file_size = file_info.get('size', 0) if isinstance(file_info, dict) else file_info
+                        self.__handle_file(storage=storage, event_path=Path(modified_file), file_size=file_size)
+
+                    if changes['added'] or changes['modified']:
+                        logger.info(
+                            f"{storage}:{mon_path} 发现 {len(changes['added'])} 个新增文件，{len(changes['modified'])} 个修改文件")
+                    else:
+                        logger.debug(f"{storage}:{mon_path} 无文件变化")
+                else:
+                    logger.info(f"{storage}:{mon_path} 首次快照完成，共 {file_count} 个文件")
+                    logger.info("*** 首次快照仅建立基准，不会处理现有文件。后续监控将处理新增和修改的文件 ***")
+
+                # 保存新快照
+                self.save_snapshot(storage, new_snapshot, file_count)
+
+                # 动态调整监控间隔
+                new_interval = self.adjust_monitor_interval(file_count)
+                current_job = self._scheduler.get_job(f"monitor_{storage}_{mon_path}")
+                if current_job and current_job.trigger.interval.total_seconds() / 60 != new_interval:
+                    # 重新安排任务
+                    self._scheduler.modify_job(
+                        f"monitor_{storage}_{mon_path}",
+                        trigger='interval',
+                        minutes=new_interval
+                    )
+                    logger.info(f"{storage}:{mon_path} 监控间隔已调整为 {new_interval} 分钟")
+
+            except Exception as e:
+                logger.error(f"轮询监控 {storage}:{mon_path} 出现错误：{e}")
+                logger.debug(traceback.format_exc())
 
     def event_handler(self, event, text: str, event_path: str, file_size: float = None):
         """
@@ -216,7 +623,7 @@ class Monitor(metaclass=Singleton):
         """
         if not event.is_directory:
             # 文件发生变化
-            logger.debug(f"文件 {event_path} 发生了 {text}")
+            logger.debug(f"检测到文件变化: {event_path} [{text}]")
             # 整理文件
             self.__handle_file(storage="local", event_path=Path(event_path), file_size=file_size)
 
@@ -253,10 +660,12 @@ class Monitor(metaclass=Singleton):
 
             # TTL缓存控重
             if self._cache.get(str(event_path)):
+                logger.debug(f"文件 {event_path} 在缓存中，跳过处理")
                 return
             self._cache[str(event_path)] = True
 
             try:
+                logger.info(f"开始整理文件: {event_path}")
                 # 开始整理
                 TransferChain().do_transfer(
                     fileitem=FileItem(
@@ -270,7 +679,7 @@ class Monitor(metaclass=Singleton):
                     )
                 )
             except Exception as e:
-                logger.error("目录监控发生错误：%s - %s" % (str(e), traceback.format_exc()))
+                logger.error("目录监控整理文件发生错误：%s - %s" % (str(e), traceback.format_exc()))
 
     def stop(self):
         """
@@ -278,20 +687,22 @@ class Monitor(metaclass=Singleton):
         """
         self._event.set()
         if self._observers:
+            logger.info("正在停止本地目录监控服务...")
             for observer in self._observers:
                 try:
-                    logger.info(f"正在停止目录监控服务：{observer}...")
                     observer.stop()
                     observer.join()
-                    logger.info(f"{observer} 目录监控已停止")
+                    logger.debug(f"已停止监控服务: {observer}")
                 except Exception as e:
                     logger.error(f"停止目录监控服务出现了错误：{e}")
             self._observers = []
+            logger.info("本地目录监控服务已停止")
         if self._scheduler:
             self._scheduler.remove_all_jobs()
             if self._scheduler.running:
                 try:
                     self._scheduler.shutdown()
+                    logger.info("定时监控服务已停止")
                 except Exception as e:
                     logger.error(f"停止定时服务出现了错误：{e}")
             self._scheduler = None