fix

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

.github/ISSUE_TEMPLATE/rfc.yml

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

.github/workflows/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/actions/note.py

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

app/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

@@ -1,5 +1,6 @@
 from typing import List, Any, Optional
 
+import jieba
 from fastapi import APIRouter, Depends
 from sqlalchemy.orm import Session
 
@@ -57,6 +58,8 @@ def transfer_history(title: Optional[str] = None,
         status = True
 
     if title:
+        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/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

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

app/api/endpoints/subscribe.py

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

app/api/endpoints/system.py

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

app/api/endpoints/transfer.py

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

app/api/endpoints/user.py

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

app/api/endpoints/workflow.py

@@ -1,3 +1,4 @@
+import json
 from datetime import datetime
 from typing import List, Any, Optional
 
@@ -5,15 +6,18 @@ from fastapi import APIRouter, Depends
 from sqlalchemy.orm import Session
 
 from app import schemas
+from app.chain.workflow import WorkflowChain
 from app.core.config import global_vars
 from app.core.plugin import PluginManager
 from app.core.workflow import WorkFlowManager
 from app.db import get_db
-from app.db.models.workflow import Workflow
+from app.db.models import Workflow
 from app.db.systemconfig_oper import SystemConfigOper
 from app.db.user_oper import get_current_active_user
-from app.chain.workflow import WorkflowChain
+from app.db.workflow_oper import WorkflowOper
+from app.helper.workflow import WorkflowHelper
 from app.scheduler import Scheduler
+from app.schemas.types import EventType, EVENT_TYPE_NAMES
 
 router = APIRouter()
 
@@ -24,7 +28,8 @@ def list_workflows(db: Session = Depends(get_db),
     """
     获取工作流列表
     """
-    return Workflow.list(db)
+    from app.db.workflow_oper import WorkflowOper
+    return WorkflowOper(db).list()
 
 
 @router.post("/", summary="创建工作流", response_model=schemas.Response)
@@ -34,12 +39,14 @@ def create_workflow(workflow: schemas.Workflow,
     """
     创建工作流
     """
-    if Workflow.get_by_name(db, workflow.name):
+    if workflow.name and WorkflowOper(db).get_by_name(workflow.name):
         return schemas.Response(success=False, message="已存在相同名称的工作流")
     if not workflow.add_time:
         workflow.add_time = datetime.strftime(datetime.now(), "%Y-%m-%d %H:%M:%S")
     if not workflow.state:
         workflow.state = "P"
+    if not workflow.trigger_type:
+        workflow.trigger_type = "timer"
     Workflow(**workflow.dict()).create(db)
     return schemas.Response(success=True, message="创建工作流成功")
 
@@ -60,47 +67,111 @@ def list_actions(_: schemas.TokenPayload = Depends(get_current_active_user)) ->
     return WorkFlowManager().list_actions()
 
 
-@router.get("/{workflow_id}", summary="工作流详情", response_model=schemas.Workflow)
-def get_workflow(workflow_id: int,
-                 db: Session = Depends(get_db),
-                 _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+@router.get("/event_types", summary="获取所有事件类型", response_model=List[dict])
+def get_event_types(_: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
     """
-    获取工作流详情
+    获取所有事件类型
     """
-    return Workflow.get(db, workflow_id)
+    return [{
+        "title": EVENT_TYPE_NAMES.get(event_type, event_type.name),
+        "value": event_type.value
+    } for event_type in EventType]
 
 
-@router.put("/{workflow_id}", summary="更新工作流", response_model=schemas.Response)
-def update_workflow(workflow: schemas.Workflow,
-                    db: Session = Depends(get_db),
-                    _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+@router.post("/share", summary="分享工作流", response_model=schemas.Response)
+def workflow_share(
+        workflow: schemas.WorkflowShare,
+        _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
     """
-    更新工作流
+    分享工作流
     """
-    wf = Workflow.get(db, workflow.id)
-    if not wf:
-        return schemas.Response(success=False, message="工作流不存在")
-    wf.update(db, workflow.dict())
-    return schemas.Response(success=True, message="更新成功")
+    if not workflow.id or not workflow.share_title or not workflow.share_user:
+        return schemas.Response(success=False, message="请填写工作流ID、分享标题和分享人")
+
+    state, errmsg = WorkflowHelper().workflow_share(workflow_id=workflow.id,
+                                                    share_title=workflow.share_title or "",
+                                                    share_comment=workflow.share_comment or "",
+                                                    share_user=workflow.share_user or "")
+    return schemas.Response(success=state, message=errmsg)
 
 
-@router.delete("/{workflow_id}", summary="删除工作流", response_model=schemas.Response)
-def delete_workflow(workflow_id: int,
-                    db: Session = Depends(get_db),
-                    _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+@router.delete("/share/{share_id}", summary="删除分享", response_model=schemas.Response)
+def workflow_share_delete(
+        share_id: int,
+        _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
     """
-    删除工作流
+    删除分享
     """
-    workflow = Workflow.get(db, workflow_id)
-    if not workflow:
-        return schemas.Response(success=False, message="工作流不存在")
-    # 删除定时任务
-    Scheduler().remove_workflow_job(workflow)
-    # 删除工作流
-    Workflow.delete(db, workflow_id)
-    # 删除缓存
-    SystemConfigOper().delete(f"WorkflowCache-{workflow_id}")
-    return schemas.Response(success=True, message="删除成功")
+    state, errmsg = WorkflowHelper().share_delete(share_id=share_id)
+    return schemas.Response(success=state, message=errmsg)
+
+
+@router.post("/fork", summary="复用工作流", response_model=schemas.Response)
+def workflow_fork(
+        workflow: schemas.WorkflowShare,
+        db: Session = Depends(get_db),
+        _: schemas.User = Depends(get_current_active_user)) -> Any:
+    """
+    复用工作流
+    """
+    if not workflow.name:
+        return schemas.Response(success=False, message="工作流名称不能为空")
+
+    # 解析JSON数据，添加错误处理
+    try:
+        actions = json.loads(workflow.actions or "[]")
+    except json.JSONDecodeError:
+        return schemas.Response(success=False, message="actions字段JSON格式错误")
+
+    try:
+        flows = json.loads(workflow.flows or "[]")
+    except json.JSONDecodeError:
+        return schemas.Response(success=False, message="flows字段JSON格式错误")
+
+    try:
+        context = json.loads(workflow.context or "{}")
+    except json.JSONDecodeError:
+        return schemas.Response(success=False, message="context字段JSON格式错误")
+
+    # 创建工作流
+    workflow_dict = {
+        "name": workflow.name,
+        "description": workflow.description,
+        "timer": workflow.timer,
+        "trigger_type": workflow.trigger_type or "timer",
+        "event_type": workflow.event_type,
+        "event_conditions": json.loads(workflow.event_conditions or "{}") if workflow.event_conditions else {},
+        "actions": actions,
+        "flows": flows,
+        "context": context,
+        "state": "P"  # 默认暂停状态
+    }
+
+    # 检查名称是否重复
+    if Workflow.get_by_name(db, workflow_dict["name"]):
+        return schemas.Response(success=False, message="已存在相同名称的工作流")
+
+    # 创建新工作流
+    workflow = Workflow(**workflow_dict)
+    workflow.create(db)
+
+    # 更新复用次数
+    if workflow.id:
+        WorkflowHelper().workflow_fork(share_id=workflow.id)
+
+    return schemas.Response(success=True, message="复用成功")
+
+
+@router.get("/shares", summary="查询分享的工作流", response_model=List[schemas.WorkflowShare])
+def workflow_shares(
+        name: Optional[str] = None,
+        page: Optional[int] = 1,
+        count: Optional[int] = 30,
+        _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    查询分享的工作流
+    """
+    return WorkflowHelper().get_shares(name=name, page=page, count=count)
 
 
 @router.post("/{workflow_id}/run", summary="执行工作流", response_model=schemas.Response)
@@ -123,11 +194,16 @@ def start_workflow(workflow_id: int,
     """
     启用工作流
     """
-    workflow = Workflow.get(db, workflow_id)
+    from app.db.workflow_oper import WorkflowOper
+    workflow = WorkflowOper(db).get(workflow_id)
     if not workflow:
         return schemas.Response(success=False, message="工作流不存在")
-    # 添加定时任务
-    Scheduler().update_workflow_job(workflow)
+    if not workflow.trigger_type or workflow.trigger_type == "timer":
+        # 添加定时任务
+        Scheduler().update_workflow_job(workflow)
+    else:
+        # 事件触发：添加到事件触发器
+        WorkFlowManager().load_workflow_events(workflow_id)
     # 更新状态
     workflow.update_state(db, workflow_id, "W")
     return schemas.Response(success=True)
@@ -140,11 +216,16 @@ def pause_workflow(workflow_id: int,
     """
     停用工作流
     """
-    workflow = Workflow.get(db, workflow_id)
+    workflow = WorkflowOper(db).get(workflow_id)
     if not workflow:
         return schemas.Response(success=False, message="工作流不存在")
-    # 删除定时任务
-    Scheduler().remove_workflow_job(workflow)
+    # 根据触发类型进行不同处理
+    if workflow.trigger_type == "timer":
+        # 定时触发：移除定时任务
+        Scheduler().remove_workflow_job(workflow)
+    elif workflow.trigger_type == "event":
+        # 事件触发：从事件触发器中移除
+        WorkFlowManager().remove_workflow_event(workflow_id, workflow.event_type)
     # 停止工作流
     global_vars.stop_workflow(workflow_id)
     # 更新状态
@@ -159,7 +240,8 @@ def reset_workflow(workflow_id: int,
     """
     重置工作流
     """
-    workflow = Workflow.get(db, workflow_id)
+    from app.db.workflow_oper import WorkflowOper
+    workflow = WorkflowOper(db).get(workflow_id)
     if not workflow:
         return schemas.Response(success=False, message="工作流不存在")
     # 停止工作流
@@ -169,3 +251,61 @@ def reset_workflow(workflow_id: int,
     # 删除缓存
     SystemConfigOper().delete(f"WorkflowCache-{workflow_id}")
     return schemas.Response(success=True)
+
+
+@router.get("/{workflow_id}", summary="工作流详情", response_model=schemas.Workflow)
+def get_workflow(workflow_id: int,
+                 db: Session = Depends(get_db),
+                 _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    获取工作流详情
+    """
+    from app.db.workflow_oper import WorkflowOper
+    return WorkflowOper(db).get(workflow_id)
+
+
+@router.put("/{workflow_id}", summary="更新工作流", response_model=schemas.Response)
+def update_workflow(workflow: schemas.Workflow,
+                    db: Session = Depends(get_db),
+                    _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    更新工作流
+    """
+    if not workflow.id:
+        return schemas.Response(success=False, message="工作流ID不能为空")
+    wf = WorkflowOper(db).get(workflow.id)
+    if not wf:
+        return schemas.Response(success=False, message="工作流不存在")
+    if not wf.trigger_type:
+        workflow.trigger_type = "timer"
+    wf.update(db, workflow.dict())
+    # 更新后的工作流对象
+    updated_workflow = wf.get(workflow.id)
+    # 更新定时任务
+    Scheduler().update_workflow_job(updated_workflow)
+    # 更新事件注册
+    WorkFlowManager().update_workflow_event(updated_workflow)
+    return schemas.Response(success=True, message="更新成功")
+
+
+@router.delete("/{workflow_id}", summary="删除工作流", response_model=schemas.Response)
+def delete_workflow(workflow_id: int,
+                    db: Session = Depends(get_db),
+                    _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    删除工作流
+    """
+    workflow = WorkflowOper(db).get(workflow_id)
+    if not workflow:
+        return schemas.Response(success=False, message="工作流不存在")
+    if not workflow.trigger_type or workflow.trigger_type == "timer":
+        # 定时触发：删除定时任务
+        Scheduler().remove_workflow_job(workflow)
+    else:
+        # 事件触发：从事件触发器中移除
+        WorkFlowManager().remove_workflow_event(workflow_id, workflow.event_type)
+    # 删除工作流
+    Workflow.delete(db, workflow_id)
+    # 删除缓存
+    SystemConfigOper().delete(f"WorkflowCache-{workflow_id}")
+    return schemas.Response(success=True, message="删除成功")

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

@@ -188,6 +188,9 @@ class DownloadChain(ChainBase):
                     f"Resource download canceled by event: {event_data.source},"
                     f"Reason: {event_data.reason}")
                 return None
+            # 如果事件修改了下载路径，使用新路径
+            if event_data.options and event_data.options.get("save_path"):
+                save_path = event_data.options.get("save_path")
 
         # 补充完整的media数据
         if not _media.genre_ids:
@@ -324,10 +327,12 @@ class DownloadChain(ChainBase):
             self.post_message(
                 Notification(
                     channel=channel,
+                    source=source if channel else None,
                     mtype=NotificationType.Download,
                     ctype=ContentType.DownloadAdded,
                     image=_media.get_message_image(),
                     link=settings.MP_DOMAIN('/#/downloading'),
+                    userid=userid,
                     username=username
                 ),
                 meta=_meta,
@@ -939,21 +944,21 @@ class DownloadChain(ChainBase):
             ret_torrents.append(torrent)
         return ret_torrents
 
-    def set_downloading(self, hash_str, oper: str) -> bool:
+    def set_downloading(self, hash_str, oper: str, name: Optional[str] = None) -> bool:
         """
         控制下载任务 start/stop
         """
         if oper == "start":
-            return self.start_torrents(hashs=[hash_str])
+            return self.start_torrents(hashs=[hash_str], downloader=name)
         elif oper == "stop":
-            return self.stop_torrents(hashs=[hash_str])
+            return self.stop_torrents(hashs=[hash_str], downloader=name)
         return False
 
-    def remove_downloading(self, hash_str: str) -> bool:
+    def remove_downloading(self, hash_str: str, name: Optional[str] = None) -> bool:
         """
         删除下载任务
         """
-        return self.remove_torrents(hashs=[hash_str])
+        return self.remove_torrents(hashs=[hash_str], downloader=name)
 
     @eventmanager.register(EventType.DownloadFileDeleted)
     def download_file_deleted(self, event: Event):

app/chain/media.py

@@ -19,7 +19,6 @@ from app.utils.string import StringUtils
 
 recognize_lock = Lock()
 scraping_lock = Lock()
-scraping_files = []
 
 
 class MediaChain(ChainBase):
@@ -35,25 +34,25 @@ class MediaChain(ChainBase):
         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      # 集缩略图
+            '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():
@@ -344,23 +343,49 @@ class MediaChain(ChainBase):
             return
         event_data = event.event_data or {}
         fileitem: FileItem = event_data.get("fileitem")
+        file_list: List[str] = event_data.get("file_list", [])
         meta: MetaBase = event_data.get("meta")
         mediainfo: MediaInfo = event_data.get("mediainfo")
         overwrite = event_data.get("overwrite", False)
         if not fileitem:
             return
+
         # 刮削锁
         with scraping_lock:
-            if fileitem.path in scraping_files:
+            # 检查文件项是否存在
+            storagechain = StorageChain()
+            if not storagechain.get_item(fileitem):
+                logger.warn(f"文件项不存在：{fileitem.path}")
                 return
-            scraping_files.append(fileitem.path)
-        try:
-            # 执行刮削
-            self.scrape_metadata(fileitem=fileitem, meta=meta, mediainfo=mediainfo, overwrite=overwrite)
-        finally:
-            # 释放锁
-            with scraping_lock:
-                scraping_files.remove(fileitem.path)
+            # 检查是否为目录
+            if fileitem.type == "file":
+                # 单个文件刮削
+                self.scrape_metadata(fileitem=fileitem,
+                                     mediainfo=mediainfo,
+                                     init_folder=False,
+                                     parent=storagechain.get_parent_item(fileitem),
+                                     overwrite=overwrite)
+            else:
+                # 检查目的目录下是否已经有nfo刮削文件
+                has_nfo_file = storagechain.any_files(fileitem, extensions=['.nfo'])
+                if has_nfo_file and file_list:
+                    logger.info(f"目录 {fileitem.path} 已有NFO文件，开始增量刮削...")
+                    for file_path in file_list:
+                        file_item = storagechain.get_file_item(storage=fileitem.storage,
+                                                               path=Path(file_path))
+                        if file_item:
+                            # 对于电视剧文件，应该保存到与视频文件相同的目录
+                            # 而不是电视剧根目录
+                            self.scrape_metadata(fileitem=file_item,
+                                                 mediainfo=mediainfo,
+                                                 init_folder=False,
+                                                 parent=None,  # 让函数内部自动获取正确的父目录
+                                                 overwrite=overwrite)
+                else:
+                    # 执行全量刮削
+                    logger.info(f"开始全量刮削目录 {fileitem.path} ...")
+                    self.scrape_metadata(fileitem=fileitem, meta=meta, init_folder=True,
+                                         mediainfo=mediainfo, overwrite=overwrite)
 
     def scrape_metadata(self, fileitem: schemas.FileItem,
                         meta: MetaBase = None, mediainfo: MediaInfo = None,
@@ -407,8 +432,10 @@ class MediaChain(ChainBase):
             """
             if not _fileitem or not _content or not _path:
                 return
-            # 保存文件到临时目录，文件名随机
-            tmp_file = settings.TEMP_PATH / f"{_path.name}.{StringUtils.generate_random_str(10)}"
+            # 保存文件到临时目录
+            tmp_dir = settings.TEMP_PATH / StringUtils.generate_random_str(10)
+            tmp_dir.mkdir(parents=True, exist_ok=True)
+            tmp_file = tmp_dir / _path.name
             tmp_file.write_bytes(_content)
             # 获取文件的父目录
             try:
@@ -427,7 +454,7 @@ class MediaChain(ChainBase):
             """
             try:
                 logger.info(f"正在下载图片：{_url} ...")
-                r = RequestUtils(proxies=settings.PROXY).get_res(url=_url)
+                r = RequestUtils(proxies=settings.PROXY, ua=settings.NORMAL_USER_AGENT).get_res(url=_url)
                 if r:
                     return r.content
                 else:
@@ -436,6 +463,9 @@ class MediaChain(ChainBase):
                 logger.error(f"{_url} 图片下载失败：{str(err)}！")
             return None
 
+        if not fileitem:
+            return
+
         # 当前文件路径
         filepath = Path(fileitem.path)
         if fileitem.type == "file" \
@@ -448,7 +478,7 @@ class MediaChain(ChainBase):
         if not mediainfo:
             logger.warn(f"{filepath} 无法识别文件媒体信息！")
             return
-        
+
         # 获取刮削开关配置
         scraping_switchs = self._get_scraping_switchs()
         logger.info(f"开始刮削：{filepath} ...")
@@ -464,6 +494,8 @@ class MediaChain(ChainBase):
                         movie_nfo = self.metadata_nfo(meta=meta, mediainfo=mediainfo)
                         if movie_nfo:
                             # 保存或上传nfo文件到上级目录
+                            if not parent:
+                                parent = storagechain.get_parent_item(fileitem)
                             __save_file(_fileitem=parent, _path=nfo_path, _content=movie_nfo)
                         else:
                             logger.warn(f"{filepath.name} nfo文件生成失败！")
@@ -494,8 +526,9 @@ class MediaChain(ChainBase):
                     files = __list_files(_fileitem=fileitem)
                     for file in files:
                         self.scrape_metadata(fileitem=file,
-                                             meta=meta, mediainfo=mediainfo,
-                                             init_folder=False, parent=fileitem,
+                                             mediainfo=mediainfo,
+                                             init_folder=False,
+                                             parent=fileitem,
                                              overwrite=overwrite)
                 # 生成目录内图片文件
                 if init_folder:
@@ -506,7 +539,9 @@ class MediaChain(ChainBase):
                             # 根据图片类型检查开关
                             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():
+                            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)
@@ -518,7 +553,7 @@ class MediaChain(ChainBase):
                                 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,
@@ -585,11 +620,11 @@ class MediaChain(ChainBase):
                 else:
                     logger.info("集缩略图刮削已关闭，跳过")
             else:
-                # 当前为目录，处理目录内的文件
+                # 当前为电视剧目录，处理目录内的文件
                 files = __list_files(_fileitem=fileitem)
                 for file in files:
                     self.scrape_metadata(fileitem=file,
-                                         meta=meta, mediainfo=mediainfo,
+                                         mediainfo=mediainfo,
                                          parent=fileitem if file.type == "file" else None,
                                          init_folder=True if file.type == "dir" else False,
                                          overwrite=overwrite)
@@ -651,13 +686,14 @@ class MediaChain(ChainBase):
                                         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}")
+                                            logger.info(
+                                                f"当前刮削季为：{season_meta.begin_season}，跳过文件：{image_path}")
                                             continue
                                         if overwrite or not storagechain.get_file_item(storage=fileitem.storage,
                                                                                        path=image_path):
@@ -700,7 +736,9 @@ class MediaChain(ChainBase):
                                 # 根据电视剧图片类型检查开关
                                 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():
+                                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)
@@ -710,7 +748,7 @@ class MediaChain(ChainBase):
                                     should_scrape = scraping_switchs.get('tv_thumb', True)
                                 else:
                                     should_scrape = True  # 未知类型默认刮削
-                                
+
                                 if should_scrape:
                                     image_path = filepath / image_name
                                     if overwrite or not storagechain.get_file_item(storage=fileitem.storage,

app/chain/recommend.py

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

app/chain/search.py

@@ -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,7 @@ class SiteChain(ChainBase):
             EventManager().send_event(EventType.SiteRefreshed, {
                 "site_id": "*"
             })
+
         return result
 
     def is_special_site(self, domain: str) -> bool:
@@ -266,16 +267,20 @@ class SiteChain(ChainBase):
             logger.error(f"获取站点页面失败：{url}")
             return favicon_url, None
         html = etree.HTML(html_text)
-        if StringUtils.is_valid_html_element(html):
-            fav_link = html.xpath('//head/link[contains(@rel, "icon")]/@href')
-            if fav_link:
-                favicon_url = urljoin(url, fav_link[0])
+        try:
+            if StringUtils.is_valid_html_element(html):
+                fav_link = html.xpath('//head/link[contains(@rel, "icon")]/@href')
+                if fav_link:
+                    favicon_url = urljoin(url, fav_link[0])
 
-        res = RequestUtils(cookies=cookie, timeout=15, ua=ua).get_res(url=favicon_url)
-        if res:
-            return favicon_url, base64.b64encode(res.content).decode()
-        else:
-            logger.error(f"获取站点图标失败：{favicon_url}")
+            res = RequestUtils(cookies=cookie, timeout=15, ua=ua).get_res(url=favicon_url)
+            if res:
+                return favicon_url, base64.b64encode(res.content).decode()
+            else:
+                logger.error(f"获取站点图标失败：{favicon_url}")
+        finally:
+            if html is not None:
+                del html
         return favicon_url, None
 
     def sync_cookies(self, manual=False) -> Tuple[bool, str]:
@@ -351,9 +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]:
         """
@@ -172,15 +178,14 @@ class StorageChain(ChainBase):
 
         if mtype:
             # 重命名格式
-            rename_format = settings.TV_RENAME_FORMAT \
-                if mtype == MediaType.TV else settings.MOVIE_RENAME_FORMAT
-            # 计算重命名中的文件夹层数
-            rename_format_level = len(rename_format.split("/")) - 1
-            if rename_format_level < 1:
+            rename_format = settings.RENAME_FORMAT(mtype)
+            media_path = DirectoryHelper.get_media_root_path(
+                rename_format, rename_path=Path(fileitem.path)
+            )
+            if not media_path:
                 return True
             # 处理媒体文件根目录
-            dir_item = self.get_file_item(storage=fileitem.storage,
-                                          path=Path(fileitem.path).parents[rename_format_level - 1])
+            dir_item = self.get_file_item(storage=fileitem.storage, path=media_path)
         else:
             # 处理上级目录
             dir_item = self.get_parent_item(fileitem)

app/chain/subscribe.py

@@ -38,6 +38,8 @@ class SubscribeChain(ChainBase):
     """
 
     _rlock = threading.RLock()
+    # 避免莫名原因导致长时间持有锁
+    _LOCK_TIMOUT = 3600 * 2
 
     def add(self, title: str, year: str,
             mtype: MediaType = None,
@@ -221,10 +223,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,
@@ -275,156 +280,175 @@ class SubscribeChain(ChainBase):
         :param manual: 是否手动搜索
         :return: 更新订阅状态为R或删除订阅
         """
-        with self._rlock:
-            logger.debug(f"search lock acquired at {datetime.now()}")
+        lock_acquired = False
+        try:
+            if lock_acquired := self._rlock.acquire(
+                    blocking=True, timeout=self._LOCK_TIMOUT
+            ):
+                logger.debug(f"search lock acquired at {datetime.now()}")
+            else:
+                logger.warn("search上锁超时")
+
             subscribeoper = SubscribeOper()
             if sid:
                 subscribe = subscribeoper.get(sid)
                 subscribes = [subscribe] if subscribe else []
             else:
                 subscribes = subscribeoper.list(self.get_states_for_search(state))
-            # 遍历订阅
-            for subscribe in subscribes:
-                if global_vars.is_system_stopped:
-                    break
-                mediakey = subscribe.tmdbid or subscribe.doubanid
-                custom_word_list = subscribe.custom_words.split("\n") if subscribe.custom_words else None
-                # 校验当前时间减订阅创建时间是否大于1分钟，否则跳过先，留出编辑订阅的时间
-                if subscribe.date:
-                    now = datetime.now()
-                    subscribe_time = datetime.strptime(subscribe.date, '%Y-%m-%d %H:%M:%S')
-                    if (now - subscribe_time).total_seconds() < 60:
-                        logger.debug(f"订阅标题：{subscribe.name} 新增小于1分钟，暂不搜索...")
-                        continue
-                # 随机休眠1-5分钟
-                if not sid and state in ['R', 'P']:
-                    sleep_time = random.randint(60, 300)
-                    logger.info(f'订阅搜索随机休眠 {sleep_time} 秒 ...')
-                    time.sleep(sleep_time)
-                try:
-                    logger.info(f'开始搜索订阅，标题：{subscribe.name} ...')
-                    # 生成元数据
-                    meta = MetaInfo(subscribe.name)
-                    meta.year = subscribe.year
-                    meta.begin_season = subscribe.season or None
+
+            try:
+                # 遍历订阅
+                for subscribe in subscribes:
+                    if global_vars.is_system_stopped:
+                        break
+                    mediakey = subscribe.tmdbid or subscribe.doubanid
+                    custom_word_list = subscribe.custom_words.split("\n") if subscribe.custom_words else None
+                    # 校验当前时间减订阅创建时间是否大于1分钟，否则跳过先，留出编辑订阅的时间
+                    if subscribe.date:
+                        now = datetime.now()
+                        subscribe_time = datetime.strptime(subscribe.date, '%Y-%m-%d %H:%M:%S')
+                        if (now - subscribe_time).total_seconds() < 60:
+                            logger.debug(f"订阅标题：{subscribe.name} 新增小于1分钟，暂不搜索...")
+                            continue
+                    # 随机休眠1-5分钟
+                    if not sid and state in ['R', 'P']:
+                        sleep_time = random.randint(60, 300)
+                        logger.info(f'订阅搜索随机休眠 {sleep_time} 秒 ...')
+                        time.sleep(sleep_time)
                     try:
-                        meta.type = MediaType(subscribe.type)
-                    except ValueError:
-                        logger.error(f'订阅 {subscribe.name} 类型错误：{subscribe.type}')
-                        continue
-                    # 识别媒体信息
-                    mediainfo: MediaInfo = self.recognize_media(meta=meta, mtype=meta.type,
-                                                                tmdbid=subscribe.tmdbid,
-                                                                doubanid=subscribe.doubanid,
-                                                                episode_group=subscribe.episode_group,
-                                                                cache=False)
-                    if not mediainfo:
-                        logger.warn(
-                            f'未识别到媒体信息，标题：{subscribe.name}，tmdbid：{subscribe.tmdbid}，doubanid：{subscribe.doubanid}')
-                        continue
+                        logger.info(f'开始搜索订阅，标题：{subscribe.name} ...')
+                        # 生成元数据
+                        meta = MetaInfo(subscribe.name)
+                        meta.year = subscribe.year
+                        meta.begin_season = subscribe.season or None
+                        try:
+                            meta.type = MediaType(subscribe.type)
+                        except ValueError:
+                            logger.error(f'订阅 {subscribe.name} 类型错误：{subscribe.type}')
+                            continue
+                        # 识别媒体信息
+                        mediainfo: MediaInfo = self.recognize_media(meta=meta, mtype=meta.type,
+                                                                    tmdbid=subscribe.tmdbid,
+                                                                    doubanid=subscribe.doubanid,
+                                                                    episode_group=subscribe.episode_group,
+                                                                    cache=False)
+                        if not mediainfo:
+                            logger.warn(
+                                f'未识别到媒体信息，标题：{subscribe.name}，tmdbid：{subscribe.tmdbid}，doubanid：{subscribe.doubanid}')
+                            continue
 
-                    # 如果媒体已存在或已下载完毕，跳过当前订阅处理
-                    exist_flag, no_exists = self.check_and_handle_existing_media(subscribe=subscribe,
-                                                                                 meta=meta,
-                                                                                 mediainfo=mediainfo,
-                                                                                 mediakey=mediakey)
-                    if exist_flag:
-                        continue
+                        # 如果媒体已存在或已下载完毕，跳过当前订阅处理
+                        exist_flag, no_exists = self.check_and_handle_existing_media(subscribe=subscribe,
+                                                                                     meta=meta,
+                                                                                     mediainfo=mediainfo,
+                                                                                     mediakey=mediakey)
+                        if exist_flag:
+                            continue
 
-                    # 站点范围
-                    sites = self.get_sub_sites(subscribe)
+                        # 站点范围
+                        sites = self.get_sub_sites(subscribe)
 
-                    # 优先级过滤规则
-                    if subscribe.best_version:
-                        rule_groups = subscribe.filter_groups \
-                                      or SystemConfigOper().get(SystemConfigKey.BestVersionFilterRuleGroups) or []
-                    else:
-                        rule_groups = subscribe.filter_groups \
-                                      or SystemConfigOper().get(SystemConfigKey.SubscribeFilterRuleGroups) or []
-
-                    # 搜索，同时电视剧会过滤掉不需要的剧集
-                    contexts = SearchChain().process(mediainfo=mediainfo,
-                                                     keyword=subscribe.keyword,
-                                                     no_exists=no_exists,
-                                                     sites=sites,
-                                                     rule_groups=rule_groups,
-                                                     area="imdbid" if subscribe.search_imdbid else "title",
-                                                     custom_words=custom_word_list,
-                                                     filter_params=self.get_params(subscribe))
-                    if not contexts:
-                        logger.warn(f'订阅 {subscribe.keyword or subscribe.name} 未搜索到资源')
-                        self.finish_subscribe_or_not(subscribe=subscribe, meta=meta,
-                                                     mediainfo=mediainfo, lefts=no_exists)
-                        continue
-
-                    # 过滤搜索结果
-                    matched_contexts = []
-                    for context in contexts:
-                        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")
+
+            finally:
+                subscribes.clear()
+                del subscribes
+        finally:
+            if lock_acquired:
+                self._rlock.release()
+                logger.debug(f"search Lock released at {datetime.now()}")
 
     def update_subscribe_priority(self, subscribe: Subscribe, meta: MetaBase,
                                   mediainfo: MediaInfo, downloads: Optional[List[Context]]):
@@ -525,15 +549,16 @@ class SubscribeChain(ChainBase):
         获取订阅中涉及的所有站点清单（节约资源）
         :return: 返回[]代表所有站点命中，返回None代表没有订阅
         """
-        # 查询所有订阅
-        subscribes = SubscribeOper().list(self.get_states_for_search('R'))
-        if not subscribes:
-            return None
         ret_sites = []
+        subscribes = SubscribeOper().list()
+        if not subscribes:
+            # 没有订阅
+            return None
         # 刷新订阅选中的Rss站点
         for subscribe in subscribes:
             # 刷新选中的站点
-            ret_sites.extend(self.get_sub_sites(subscribe))
+            if subscribe.state in self.get_states_for_search('R'):
+                ret_sites.extend(self.get_sub_sites(subscribe))
         # 去重
         if ret_sites:
             ret_sites = list(set(ret_sites))
@@ -548,10 +573,14 @@ class SubscribeChain(ChainBase):
             logger.warn('没有缓存资源，无法匹配订阅')
             return
 
-        with self._rlock:
-            logger.debug(f"match lock acquired at {datetime.now()}")
-            # 所有订阅
-            subscribes = SubscribeOper().list(self.get_states_for_search('R'))
+        lock_acquired = False
+        try:
+            if lock_acquired := self._rlock.acquire(
+                    blocking=True, timeout=self._LOCK_TIMOUT
+            ):
+                logger.debug(f"match lock acquired at {datetime.now()}")
+            else:
+                logger.warn("match上锁超时")
 
             # 预识别所有未识别的种子
             processed_torrents: Dict[str, List[Context]] = {}
@@ -574,234 +603,244 @@ 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)
+                                                                      )
 
-            logger.debug(f"match Lock released at {datetime.now()}")
+                    # 同步外部修改，更新订阅信息
+                    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
+        finally:
+            if lock_acquired:
+                self._rlock.release()
+                logger.debug(f"match Lock released at {datetime.now()}")
 
     def check(self):
         """
@@ -809,12 +848,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 +905,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,15 +1,18 @@
 import json
 import re
+import shutil
 from pathlib import Path
 from typing import Union, Optional
 
 from app.chain import ChainBase
 from app.core.config import settings
+from app.core.plugin import PluginManager
 from app.log import logger
 from app.schemas import Notification, MessageChannel
 from app.utils.http import RequestUtils
 from app.utils.system import SystemUtils
 from app.helper.system import SystemHelper
+from app.helper.plugin import PluginHelper
 from version import FRONTEND_VERSION, APP_VERSION
 
 
@@ -33,7 +36,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 +45,120 @@ class SystemChain(ChainBase):
                 "channel": channel.value,
                 "userid": userid
             }, self._restart_file)
+        # 主动备份一次插件
+        self.backup_plugins()
         # 设置停止标志，通知所有模块准备停止
         global_vars.stop_system()
         # 重启
         SystemHelper.restart()
 
+    @staticmethod
+    def backup_plugins():
+        """
+        备份插件到用户配置目录（仅docker环境）
+        """
+
+        # 非docker环境不处理
+        if not SystemUtils.is_docker():
+            return
+
+        try:
+            # 使用绝对路径确保准确性
+            plugins_dir = settings.ROOT_PATH / "app" / "plugins"
+            backup_dir = settings.CONFIG_PATH / "plugins_backup"
+
+            if not plugins_dir.exists():
+                logger.info("插件目录不存在，跳过备份")
+                return
+
+            # 确保备份目录存在
+            backup_dir.mkdir(parents=True, exist_ok=True)
+
+            # 需要排除的文件和目录
+            exclude_items = {"__init__.py", "__pycache__", ".DS_Store"}
+
+            # 遍历插件目录，备份除排除项外的所有内容
+            for item in plugins_dir.iterdir():
+                if item.name in exclude_items:
+                    continue
+
+                target_path = backup_dir / item.name
+
+                # 如果是目录
+                if item.is_dir():
+                    if target_path.exists():
+                        continue
+                    shutil.copytree(item, target_path)
+                    logger.info(f"已备份插件目录: {item.name}")
+                # 如果是文件
+                elif item.is_file():
+                    if target_path.exists():
+                        continue
+                    shutil.copy2(item, target_path)
+                    logger.info(f"已备份插件文件: {item.name}")
+
+            logger.info(f"插件备份完成，备份位置: {backup_dir}")
+
+        except Exception as e:
+            logger.error(f"插件备份失败: {str(e)}")
+
+    @staticmethod
+    def restore_plugins():
+        """
+        从备份恢复插件到app/plugins目录，恢复完成后删除备份（仅docker环境）
+        """
+
+        # 非docker环境不处理
+        if not SystemUtils.is_docker():
+            return
+
+        # 使用绝对路径确保准确性
+        plugins_dir = settings.ROOT_PATH / "app" / "plugins"
+        backup_dir = settings.CONFIG_PATH / "plugins_backup"
+
+        if not backup_dir.exists():
+            logger.info("插件备份目录不存在，跳过恢复")
+            return
+
+        # 系统被重置才恢复插件
+        if SystemHelper().is_system_reset():
+
+            # 确保插件目录存在
+            plugins_dir.mkdir(parents=True, exist_ok=True)
+
+            # 遍历备份目录，恢复所有内容
+            restored_count = 0
+            for item in backup_dir.iterdir():
+                target_path = plugins_dir / item.name
+                try:
+                    # 如果是目录，且目录内有内容
+                    if item.is_dir() and any(item.iterdir()):
+                        if target_path.exists():
+                            shutil.rmtree(target_path)
+                        shutil.copytree(item, target_path)
+                        logger.info(f"已恢复插件目录: {item.name}")
+                        restored_count += 1
+                    # 如果是文件
+                    elif item.is_file():
+                        shutil.copy2(item, target_path)
+                        logger.info(f"已恢复插件文件: {item.name}")
+                        restored_count += 1
+                except Exception as e:
+                    logger.error(f"恢复插件 {item.name} 时发生错误: {str(e)}")
+                    continue
+
+            logger.info(f"插件恢复完成，共恢复 {restored_count} 个项目")
+
+            # 安装缺少的依赖
+            PluginManager.install_plugin_missing_dependencies()
+
+        # 删除备份目录
+        try:
+            shutil.rmtree(backup_dir)
+            logger.info(f"已删除插件备份目录: {backup_dir}")
+        except Exception as e:
+            logger.warning(f"删除备份目录失败: {str(e)}")
+
     def __get_version_message(self) -> str:
         """
         获取版本信息文本

app/chain/torrents.py

@@ -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]]:
@@ -136,6 +140,16 @@ class TorrentsChain(ChainBase):
         :param stype: 强制指定缓存类型，spider:爬虫缓存，rss:rss缓存
         :param sites: 强制指定站点ID列表，为空则读取设置的订阅站点
         """
+
+        def __is_no_cache_site(_domain: str) -> bool:
+            """
+            判断站点是否不需要缓存
+            """
+            for url_key in settings.NO_CACHE_SITE_KEY.split(','):
+                if url_key in _domain:
+                    return True
+            return False
+
         # 刷新类型
         if not stype:
             stype = settings.SUBSCRIBE_MODE
@@ -152,13 +166,10 @@ class TorrentsChain(ChainBase):
             torrents_cache[_domain] = [_torrent for _torrent in _torrents
                                        if not TorrentHelper().is_invalid(_torrent.torrent_info.enclosure)]
 
-        # 所有站点索引
-        indexers = SitesHelper().get_indexers()
         # 需要刷新的站点domain
         domains = []
-
         # 遍历站点缓存资源
-        for indexer in indexers:
+        for indexer in SitesHelper().get_indexers():
             if global_vars.is_system_stopped:
                 break
             # 未开启的站点不刷新
@@ -168,55 +179,72 @@ class TorrentsChain(ChainBase):
             domains.append(domain)
             if stype == "spider":
                 # 刷新首页种子
-                torrents: List[TorrentInfo] = self.browse(domain=domain)
+                torrents: List[TorrentInfo] = []
+                # 读取第0页和第1页
+                for page in range(2):
+                    page_torrents = self.browse(domain=domain, page=page)
+                    if page_torrents:
+                        torrents.extend(page_torrents)
+                    else:
+                        # 如果某一页没有数据，说明已经到最后一页，停止获取
+                        break
             else:
                 # 刷新RSS种子
                 torrents: List[TorrentInfo] = self.rss(domain=domain)
             # 按pubdate降序排列
             torrents.sort(key=lambda x: x.pubdate or '', reverse=True)
             # 取前N条
-            torrents = torrents[:settings.CONF["refresh"]]
+            torrents = torrents[:settings.CONF.refresh]
             if torrents:
-                # 过滤出没有处理过的种子 - 优化：使用集合查找，避免重复创建字符串列表
-                cached_signatures = {f'{t.torrent_info.title}{t.torrent_info.description}'
-                                     for t in torrents_cache.get(domain) or []}
-                torrents = [torrent for torrent in torrents
-                            if f'{torrent.title}{torrent.description}' not in cached_signatures]
+                if __is_no_cache_site(domain):
+                    # 不需要缓存的站点，直接处理
+                    logger.info(f'{indexer.get("name")} 有 {len(torrents)} 个种子 (不缓存)')
+                    torrents_cache[domain] = []
+                else:
+                    # 过滤出没有处理过的种子 - 优化：使用集合查找，避免重复创建字符串列表
+                    cached_signatures = {f'{t.torrent_info.title}{t.torrent_info.description}'
+                                         for t in torrents_cache.get(domain) or []}
+                    torrents = [torrent for torrent in torrents
+                                if f'{torrent.title}{torrent.description}' not in cached_signatures]
                 if torrents:
                     logger.info(f'{indexer.get("name")} 有 {len(torrents)} 个新种子')
                 else:
                     logger.info(f'{indexer.get("name")} 没有新种子')
                     continue
-                for torrent in torrents:
-                    if global_vars.is_system_stopped:
-                        break
-                    logger.info(f'处理资源：{torrent.title} ...')
-                    # 识别
-                    meta = MetaInfo(title=torrent.title, subtitle=torrent.description)
-                    if torrent.title != meta.org_string:
-                        logger.info(f'种子名称应用识别词后发生改变：{torrent.title} => {meta.org_string}')
-                    # 使用站点种子分类，校正类型识别
-                    if meta.type != MediaType.TV \
-                            and torrent.category == MediaType.TV.value:
-                        meta.type = MediaType.TV
-                    # 识别媒体信息
-                    mediainfo: MediaInfo = MediaChain().recognize_by_meta(meta)
-                    if not mediainfo:
-                        logger.warn(f'{torrent.title} 未识别到媒体信息')
-                        # 存储空的媒体信息
-                        mediainfo = MediaInfo()
-                    # 清理多余数据，减少内存占用
-                    mediainfo.clear()
-                    # 上下文
-                    context = Context(meta_info=meta, media_info=mediainfo, torrent_info=torrent)
-                    # 添加到缓存
-                    if not torrents_cache.get(domain):
-                        torrents_cache[domain] = [context]
-                    else:
-                        torrents_cache[domain].append(context)
-                    # 如果超过了限制条数则移除掉前面的
-                    if len(torrents_cache[domain]) > settings.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,10 +1,10 @@
+import gc
 import queue
 import re
 import threading
 import traceback
 from copy import deepcopy
 from pathlib import Path
-from queue import Queue
 from time import sleep
 from typing import List, Optional, Tuple, Union, Dict, Callable
 
@@ -15,9 +15,9 @@ from app.chain.storage import StorageChain
 from app.chain.tmdb import TmdbChain
 from app.core.config import settings, global_vars
 from app.core.context import MediaInfo
+from app.core.event import eventmanager
 from app.core.meta import MetaBase
 from app.core.metainfo import MetaInfoPath
-from app.core.event import eventmanager
 from app.db.downloadhistory_oper import DownloadHistoryOper
 from app.db.models.downloadhistory import DownloadHistory
 from app.db.models.transferhistory import TransferHistory
@@ -27,11 +27,11 @@ from app.helper.directory import DirectoryHelper
 from app.helper.format import FormatParser
 from app.helper.progress import ProgressHelper
 from app.log import logger
+from app.schemas import StorageOperSelectionEventData
 from app.schemas import TransferInfo, TransferTorrent, Notification, EpisodeFormat, FileItem, TransferDirectoryConf, \
     TransferTask, TransferQueue, TransferJob, TransferJobTask
 from app.schemas.types import TorrentStatus, EventType, MediaType, ProgressKey, NotificationType, MessageChannel, \
     SystemConfigKey, ChainEventType, ContentType
-from app.schemas import StorageOperSelectionEventData
 from app.utils.singleton import Singleton
 from app.utils.string import StringUtils
 
@@ -212,6 +212,7 @@ class JobManager:
                                 set(self._season_episodes[mediaid]) - set(task.meta.episode_list)
                             )
                         return task
+            return None
 
     def remove_job(self, task: TransferTask) -> Optional[TransferJob]:
         """
@@ -225,6 +226,7 @@ class JobManager:
                 if __mediaid__ in self._season_episodes:
                     self._season_episodes.pop(__mediaid__)
                 return self._job_view.pop(__mediaid__)
+            return None
 
     def is_done(self, task: TransferTask) -> bool:
         """
@@ -310,7 +312,7 @@ class JobManager:
 
     def count(self, media: MediaInfo, season: Optional[int] = None) -> int:
         """
-        获取某项任务总数
+        获取某项任务成功总数
         """
         __mediaid__ = self.__get_media_id(media=media, season=season)
         with job_lock:
@@ -321,7 +323,7 @@ class JobManager:
 
     def size(self, media: MediaInfo, season: Optional[int] = None) -> int:
         """
-        获取某项任务总大小
+        获取某项任务成功文件总大小
         """
         __mediaid__ = self.__get_media_id(media=media, season=season)
         with job_lock:
@@ -358,22 +360,20 @@ class TransferChain(ChainBase, metaclass=Singleton):
     文件整理处理链
     """
 
-    # 可处理的文件后缀
-    all_exts = settings.RMT_MEDIAEXT
-
-    # 待整理任务队列
-    _queue = Queue()
-
-    # 文件整理线程
-    _transfer_thread = None
-
-    # 队列间隔时间（秒）
-    _transfer_interval = 15
-
     def __init__(self):
         super().__init__()
+        # 可处理的文件后缀
+        self.all_exts = settings.RMT_MEDIAEXT
+        # 待整理任务队列
+        self._queue = queue.Queue()
+        # 文件整理线程
+        self._transfer_thread = None
+        # 队列间隔时间（秒）
+        self._transfer_interval = 15
+        # 事件管理器
         self.jobview = JobManager()
-
+        # 车移成功的文件清单
+        self._success_target_files: Dict[str, List[str]] = {}
         # 启动整理任务
         self.__init()
 
@@ -390,6 +390,44 @@ class TransferChain(ChainBase, metaclass=Singleton):
         """
         整理完成后处理
         """
+
+        def __do_finished():
+            """
+            完成时发送消息、刮削事件、移除任务等
+            """
+            # 更新文件数量
+            transferinfo.file_count = self.jobview.count(task.mediainfo, task.meta.begin_season) or 1
+            # 更新文件大小
+            transferinfo.total_size = self.jobview.size(task.mediainfo,
+                                                        task.meta.begin_season) or task.fileitem.size
+            # 更新文件清单
+            transferinfo.file_list_new = self._success_target_files.pop(transferinfo.target_diritem.path, [])
+            # 发送通知，实时手动整理时不发
+            if transferinfo.need_notify and (task.background or not task.manual):
+                se_str = None
+                if task.mediainfo.type == MediaType.TV:
+                    season_episodes = self.jobview.season_episodes(task.mediainfo, task.meta.begin_season)
+                    if season_episodes:
+                        se_str = f"{task.meta.season} {StringUtils.format_ep(season_episodes)}"
+                    else:
+                        se_str = f"{task.meta.season}"
+                self.send_transfer_message(meta=task.meta,
+                                           mediainfo=task.mediainfo,
+                                           transferinfo=transferinfo,
+                                           season_episode=se_str,
+                                           username=task.username)
+            # 刮削事件
+            if transferinfo.need_scrape:
+                self.eventmanager.send_event(EventType.MetadataScrape, {
+                    'meta': task.meta,
+                    'mediainfo': task.mediainfo,
+                    'fileitem': transferinfo.target_diritem,
+                    'file_list': transferinfo.file_list_new,
+                    'overwrite': False
+                })
+            # 移除已完成的任务
+            self.jobview.remove_job(task)
+
         transferhis = TransferHistoryOper()
         if not transferinfo.success:
             # 转移失败
@@ -415,6 +453,10 @@ class TransferChain(ChainBase, metaclass=Singleton):
             ))
             # 整理失败
             self.jobview.fail_task(task)
+            with task_lock:
+                # 整理完成且有成功的任务时
+                if self.jobview.is_finished(task):
+                    __do_finished()
             return False, transferinfo.message
 
         # 转移成功
@@ -443,55 +485,57 @@ class TransferChain(ChainBase, metaclass=Singleton):
         })
 
         with task_lock:
+            # 登记转移成功文件清单
+            target_dir_path = transferinfo.target_diritem.path
+            target_files = transferinfo.file_list_new
+            if self._success_target_files.get(target_dir_path):
+                self._success_target_files[target_dir_path].extend(target_files)
+            else:
+                self._success_target_files[target_dir_path] = target_files
             # 全部整理成功时
             if self.jobview.is_success(task):
                 # 移动模式删除空目录
                 if transferinfo.transfer_type in ["move"]:
                     # 所有成功的业务
                     tasks = self.jobview.success_tasks(task.mediainfo, task.meta.begin_season)
-                    # 记录已处理的种子hash
-                    processed_hashes = set()
                     storagechain = StorageChain()
+                    downloadhistoryoper = DownloadHistoryOper()
                     for t in tasks:
                         # 下载器hash
-                        if t.download_hash and t.download_hash not in processed_hashes:
-                            processed_hashes.add(t.download_hash)
-                            if self.remove_torrents(t.download_hash, downloader=t.downloader):
-                                logger.info(f"移动模式删除种子成功：{t.download_hash} ")
-                        # 删除残留目录
-                        if t.fileitem:
-                            storagechain.delete_media_file(t.fileitem, delete_self=False)
+                        if not t.download_hash:
+                            continue
+                        # 获取种子保存目录
+                        seed_dir_path = self.__get_torrent_save_path(download_hash=t.download_hash,
+                                                                     downloader=t.downloader)
+                        if not seed_dir_path:
+                            # 如果无法从下载器获取，则尝试从历史记录获取
+                            download_history = downloadhistoryoper.get_by_hash(t.download_hash)
+                            if download_history and download_history.path:
+                                seed_dir_path = download_history.path
+                            else:
+                                logger.warn(f"无法获取种子 {t.download_hash} 的保存路径")
+                                continue
+
+                        # 检查种子目录下是否还有有效媒体文件
+                        seed_dir_item = storagechain.get_file_item(storage=t.fileitem.storage,
+                                                                   path=Path(seed_dir_path))
+                        if seed_dir_item and seed_dir_item.type == "dir":
+                            remain_files = storagechain.list_files(seed_dir_item, recursion=True)
+                            has_media = any(
+                                f.extension and f.extension.lower() in [ext.lstrip('.') for ext in self.all_exts]
+                                for f in remain_files if f.type == "file"
+                            )
+                            if not has_media:
+                                if self.remove_torrents(t.download_hash, downloader=t.downloader):
+                                    logger.info(f"移动模式删除种子成功：{t.download_hash} ")
+                                # 删除残留目录
+                                storagechain.delete_media_file(seed_dir_item, delete_self=False)
+                            else:
+                                logger.info(
+                                    f"种子目录 {seed_dir_path} 还有未整理的媒体文件，暂不删除种子和残留目录")
             # 整理完成且有成功的任务时
             if self.jobview.is_finished(task):
-                # 发送通知，实时手动整理时不发
-                if transferinfo.need_notify and (task.background or not task.manual):
-                    se_str = None
-                    if task.mediainfo.type == MediaType.TV:
-                        season_episodes = self.jobview.season_episodes(task.mediainfo, task.meta.begin_season)
-                        if season_episodes:
-                            se_str = f"{task.meta.season} {StringUtils.format_ep(season_episodes)}"
-                        else:
-                            se_str = f"{task.meta.season}"
-                    # 更新文件数量
-                    transferinfo.file_count = self.jobview.count(task.mediainfo, task.meta.begin_season) or 1
-                    # 更新文件大小
-                    transferinfo.total_size = self.jobview.size(task.mediainfo,
-                                                                task.meta.begin_season) or task.fileitem.size
-                    self.send_transfer_message(meta=task.meta,
-                                               mediainfo=task.mediainfo,
-                                               transferinfo=transferinfo,
-                                               season_episode=se_str,
-                                               username=task.username)
-                # 刮削事件
-                if transferinfo.need_scrape:
-                    self.eventmanager.send_event(EventType.MetadataScrape, {
-                        'meta': task.meta,
-                        'mediainfo': task.mediainfo,
-                        'fileitem': transferinfo.target_diritem
-                    })
-
-                # 移除已完成的任务
-                self.jobview.remove_job(task)
+                __do_finished()
 
         return True, ""
 
@@ -788,6 +832,7 @@ class TransferChain(ChainBase, metaclass=Singleton):
                        for dir_info in download_dirs):
                 return True
             logger.info("开始整理下载器中已经完成下载的文件 ...")
+
             # 从下载器获取种子列表
             torrents: Optional[List[TransferTorrent]] = self.list_torrents(status=TorrentStatus.TRANSFER)
             if not torrents:
@@ -796,70 +841,74 @@ 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=file_path.as_posix(),
+                            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
 
             # 结束
             logger.info("所有下载器中下载完成的文件已整理完成")
@@ -870,7 +919,7 @@ class TransferChain(ChainBase, metaclass=Singleton):
     ) -> List[Tuple[FileItem, bool]]:
         """
         获取整理目录或文件列表
-        
+
         :param fileitem: 文件项
         :param depth: 递归深度，默认为1
         """
@@ -1032,111 +1081,116 @@ class TransferChain(ChainBase, metaclass=Singleton):
 
         # 整理所有文件
         transfer_tasks: List[TransferTask] = []
-        for file_item, bluray_dir in file_items:
-            if global_vars.is_system_stopped:
-                break
-            if continue_callback and not continue_callback():
-                break
-            file_path = Path(file_item.path)
-            # 回收站及隐藏的文件不处理
-            if file_item.path.find('/@Recycle/') != -1 \
-                    or file_item.path.find('/#recycle/') != -1 \
-                    or file_item.path.find('/.') != -1 \
-                    or file_item.path.find('/@eaDir') != -1:
-                logger.debug(f"{file_item.path} 是回收站或隐藏的文件")
-                continue
-
-            # 整理屏蔽词不处理
-            is_blocked = False
-            if transfer_exclude_words:
-                for keyword in transfer_exclude_words:
-                    if not keyword:
-                        continue
-                    if keyword and re.search(r"%s" % keyword, file_item.path, re.IGNORECASE):
-                        logger.info(f"{file_item.path} 命中整理屏蔽词 {keyword}，不处理")
-                        is_blocked = True
-                        break
-            if is_blocked:
-                continue
-
-            # 整理成功的不再处理
-            if not force:
-                transferd = TransferHistoryOper().get_by_src(file_item.path, storage=file_item.storage)
-                if transferd:
-                    if not transferd.status:
-                        all_success = False
-                    logger.info(f"{file_item.path} 已整理过，如需重新处理，请删除整理记录。")
-                    err_msgs.append(f"{file_item.name} 已整理过")
+        try:
+            for file_item, bluray_dir in file_items:
+                if global_vars.is_system_stopped:
+                    break
+                if continue_callback and not continue_callback():
+                    break
+                file_path = Path(file_item.path)
+                # 回收站及隐藏的文件不处理
+                if file_item.path.find('/@Recycle/') != -1 \
+                        or file_item.path.find('/#recycle/') != -1 \
+                        or file_item.path.find('/.') != -1 \
+                        or file_item.path.find('/@eaDir') != -1:
+                    logger.debug(f"{file_item.path} 是回收站或隐藏的文件")
                     continue
 
-            if not meta:
-                # 文件元数据
-                file_meta = MetaInfoPath(file_path)
-            else:
-                file_meta = meta
+                # 整理屏蔽词不处理
+                is_blocked = False
+                if transfer_exclude_words:
+                    for keyword in transfer_exclude_words:
+                        if not keyword:
+                            continue
+                        if keyword and re.search(r"%s" % keyword, file_item.path, re.IGNORECASE):
+                            logger.info(f"{file_item.path} 命中整理屏蔽词 {keyword}，不处理")
+                            is_blocked = True
+                            break
+                if is_blocked:
+                    continue
 
-            # 合并季
-            if season is not None:
-                file_meta.begin_season = season
+                # 整理成功的不再处理
+                if not force:
+                    transferd = TransferHistoryOper().get_by_src(file_item.path, storage=file_item.storage)
+                    if transferd:
+                        if not transferd.status:
+                            all_success = False
+                        logger.info(f"{file_item.path} 已整理过，如需重新处理，请删除整理记录。")
+                        err_msgs.append(f"{file_item.name} 已整理过")
+                        continue
 
-            if not file_meta:
-                all_success = False
-                logger.error(f"{file_path.name} 无法识别有效信息")
-                err_msgs.append(f"{file_path.name} 无法识别有效信息")
-                continue
+                if not meta:
+                    # 文件元数据
+                    file_meta = MetaInfoPath(file_path)
+                else:
+                    file_meta = meta
 
-            # 自定义识别
-            if formaterHandler:
-                # 开始集、结束集、PART
-                begin_ep, end_ep, part = formaterHandler.split_episode(file_name=file_path.name, file_meta=file_meta)
-                if begin_ep is not None:
-                    file_meta.begin_episode = begin_ep
-                    file_meta.part = part
-                if end_ep is not None:
-                    file_meta.end_episode = end_ep
+                # 合并季
+                if season is not None:
+                    file_meta.begin_season = season
 
-            # 根据父路径获取下载历史
-            download_history = None
-            downloadhis = DownloadHistoryOper()
-            if bluray_dir:
-                # 蓝光原盘，按目录名查询
-                download_history = downloadhis.get_by_path(str(file_path))
-            else:
-                # 按文件全路径查询
-                download_file = downloadhis.get_file_by_fullpath(str(file_path))
-                if download_file:
-                    download_history = downloadhis.get_by_hash(download_file.download_hash)
+                if not file_meta:
+                    all_success = False
+                    logger.error(f"{file_path.name} 无法识别有效信息")
+                    err_msgs.append(f"{file_path.name} 无法识别有效信息")
+                    continue
 
-            # 获取下载Hash
-            if download_history and (not downloader or not download_hash):
-                downloader = download_history.downloader
-                download_hash = download_history.download_hash
+                # 自定义识别
+                if formaterHandler:
+                    # 开始集、结束集、PART
+                    begin_ep, end_ep, part = formaterHandler.split_episode(file_name=file_path.name,
+                                                                           file_meta=file_meta)
+                    if begin_ep is not None:
+                        file_meta.begin_episode = begin_ep
+                        file_meta.part = part
+                    if end_ep is not None:
+                        file_meta.end_episode = end_ep
 
-            # 后台整理
-            transfer_task = TransferTask(
-                fileitem=file_item,
-                meta=file_meta,
-                mediainfo=mediainfo,
-                target_directory=target_directory,
-                target_storage=target_storage,
-                target_path=target_path,
-                transfer_type=transfer_type,
-                scrape=scrape,
-                library_type_folder=library_type_folder,
-                library_category_folder=library_category_folder,
-                downloader=downloader,
-                download_hash=download_hash,
-                download_history=download_history,
-                manual=manual,
-                background=background
-            )
-            if background:
-                self.put_to_queue(task=transfer_task)
-                logger.info(f"{file_path.name} 已添加到整理队列")
-            else:
-                # 加入列表
-                self.__put_to_jobview(transfer_task)
-                transfer_tasks.append(transfer_task)
+                # 根据父路径获取下载历史
+                download_history = None
+                downloadhis = DownloadHistoryOper()
+                if bluray_dir:
+                    # 蓝光原盘，按目录名查询
+                    download_history = downloadhis.get_by_path(str(file_path))
+                else:
+                    # 按文件全路径查询
+                    download_file = downloadhis.get_file_by_fullpath(str(file_path))
+                    if download_file:
+                        download_history = downloadhis.get_by_hash(download_file.download_hash)
+
+                # 获取下载Hash
+                if download_history and (not downloader or not download_hash):
+                    downloader = download_history.downloader
+                    download_hash = download_history.download_hash
+
+                # 后台整理
+                transfer_task = TransferTask(
+                    fileitem=file_item,
+                    meta=file_meta,
+                    mediainfo=mediainfo,
+                    target_directory=target_directory,
+                    target_storage=target_storage,
+                    target_path=target_path,
+                    transfer_type=transfer_type,
+                    scrape=scrape,
+                    library_type_folder=library_type_folder,
+                    library_category_folder=library_category_folder,
+                    downloader=downloader,
+                    download_hash=download_hash,
+                    download_history=download_history,
+                    manual=manual,
+                    background=background
+                )
+                if background:
+                    self.put_to_queue(task=transfer_task)
+                    logger.info(f"{file_path.name} 已添加到整理队列")
+                else:
+                    # 加入列表
+                    self.__put_to_jobview(transfer_task)
+                    transfer_tasks.append(transfer_task)
+        finally:
+            file_items.clear()
+            del file_items
 
         # 实时整理
         if transfer_tasks:
@@ -1155,29 +1209,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} 个"
@@ -1187,7 +1244,8 @@ class TransferChain(ChainBase, metaclass=Singleton):
                             key=ProgressKey.FileTransfer)
             progress.end(ProgressKey.FileTransfer)
 
-        return all_success, "，".join(err_msgs)
+        error_msg = "、".join(err_msgs[:2]) + (f"，等{len(err_msgs)}个文件错误！" if len(err_msgs) > 2 else "")
+        return all_success, error_msg
 
     def remote_transfer(self, arg_str: str, channel: MessageChannel,
                         userid: Union[str, int] = None, source: Optional[str] = None):
@@ -1324,7 +1382,8 @@ class TransferChain(ChainBase, metaclass=Singleton):
             mediainfo: MediaInfo = MediaChain().recognize_media(tmdbid=tmdbid, doubanid=doubanid,
                                                                 mtype=mtype, episode_group=episode_group)
             if not mediainfo:
-                return False, f"媒体信息识别失败，tmdbid：{tmdbid}，doubanid：{doubanid}，type: {mtype.value}"
+                return (False,
+                        f"媒体信息识别失败，tmdbid：{tmdbid}，doubanid：{doubanid}，type: {mtype.value if mtype else None}")
             else:
                 # 更新媒体图片
                 self.obtain_images(mediainfo=mediainfo)
@@ -1394,3 +1453,20 @@ class TransferChain(ChainBase, metaclass=Singleton):
             season_episode=season_episode,
             username=username
         )
+
+    def __get_torrent_save_path(self, download_hash: str, downloader: str) -> Optional[str]:
+        """
+        从下载器获取种子的保存路径
+        :param download_hash: 种子Hash
+        :param downloader: 下载器名称
+        :return: 种子保存路径，如果获取失败返回None
+        """
+        try:
+            # 通过下载器获取种子信息
+            torrents = self.list_torrents(hashs=download_hash, downloader=downloader)
+            if not torrents:
+                return None
+            return torrents[0].path
+        except Exception as e:
+            logger.error(f"获取种子 {download_hash} 保存路径失败：{e}")
+            return None

app/chain/workflow.py

@@ -10,11 +10,13 @@ from pydantic.fields import Callable
 
 from app.chain import ChainBase
 from app.core.config import global_vars
+from app.core.event import Event, eventmanager
 from app.core.workflow import WorkFlowManager
 from app.db.models import Workflow
 from app.db.workflow_oper import WorkflowOper
 from app.log import logger
 from app.schemas import ActionContext, ActionFlow, Action, ActionExecution
+from app.schemas.types import EventType
 
 
 class WorkflowExecutor:
@@ -188,6 +190,16 @@ class WorkflowChain(ChainBase):
     工作流链
     """
 
+    @eventmanager.register(EventType.WorkflowExecute)
+    def event_process(self, event: Event):
+        """
+        事件触发工作流执行
+        """
+        workflow_id = event.event_data.get('workflow_id')
+        if not workflow_id:
+            return
+        self.process(workflow_id, from_begin=False)
+
     @staticmethod
     def process(workflow_id: int, from_begin: Optional[bool] = True) -> Tuple[bool, str]:
         """
@@ -225,7 +237,7 @@ class WorkflowChain(ChainBase):
             logger.warn(f"工作流 {workflow.name} 无流程")
             return False, "工作流无流程"
 
-        logger.info(f"开始处理 {workflow.name}，共 {len(workflow.actions)} 个动作 ...")
+        logger.info(f"开始执行工作流 {workflow.name}，共 {len(workflow.actions)} 个动作 ...")
         workflowoper.start(workflow_id)
 
         # 执行工作流
@@ -247,3 +259,17 @@ class WorkflowChain(ChainBase):
         获取工作流列表
         """
         return WorkflowOper().list_enabled()
+
+    @staticmethod
+    def get_timer_workflows() -> List[Workflow]:
+        """
+        获取定时触发的工作流列表
+        """
+        return WorkflowOper().get_timer_triggered_workflows()
+
+    @staticmethod
+    def get_event_workflows() -> List[Workflow]:
+        """
+        获取事件触发的工作流列表
+        """
+        return WorkflowOper().get_event_triggered_workflows()

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

@@ -1,6 +1,8 @@
 import copy
 import json
 import os
+import platform
+import re
 import secrets
 import sys
 import threading
@@ -11,8 +13,38 @@ from dotenv import set_key
 from pydantic import BaseModel, BaseSettings, validator, Field
 
 from app.log import logger, log_settings, LogConfigModel
+from app.schemas import MediaType
 from app.utils.system import SystemUtils
 from app.utils.url import UrlUtils
+from version import APP_VERSION
+
+
+class SystemConfModel(BaseModel):
+    """
+    系统关键资源大小配置
+    """
+    # 缓存种子数量
+    torrents: int = 0
+    # 订阅刷新处理数量
+    refresh: int = 0
+    # TMDB请求缓存数量
+    tmdb: int = 0
+    # 豆瓣请求缓存数量
+    douban: int = 0
+    # Bangumi请求缓存数量
+    bangumi: int = 0
+    # Fanart请求缓存数量
+    fanart: int = 0
+    # 元数据缓存过期时间（秒）
+    meta: int = 0
+    # 调度器数量
+    scheduler: int = 0
+    # 线程池大小
+    threadpool: int = 0
+    # 数据库连接池大小
+    dbpool: int = 0
+    # 数据库连接池溢出数量
+    dbpooloverflow: int = 0
 
 
 class ConfigModel(BaseModel):
@@ -57,16 +89,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 模式，默认开启
@@ -125,7 +153,7 @@ class ConfigModel(BaseModel):
     # 元数据识别缓存过期时间（小时）
     META_CACHE_EXPIRE: int = 0
     # 电视剧动漫的分类genre_ids
-    ANIME_GENREIDS: List[int] = [16]
+    ANIME_GENREIDS: List[int] = Field(default=[16])
     # 用户认证站点
     AUTH_SITE: str = ""
     # 重启自动升级
@@ -141,6 +169,7 @@ class ConfigModel(BaseModel):
                         "api.github.com,"
                         "github.com,"
                         "raw.githubusercontent.com,"
+                        "codeload.github.com,"
                         "api.telegram.org")
     # DOH 解析服务器列表
     DOH_RESOLVERS: str = "1.0.0.1,1.1.1.1,9.9.9.9,149.112.112.112"
@@ -186,6 +215,8 @@ class ConfigModel(BaseModel):
     SITEDATA_REFRESH_INTERVAL: int = 6
     # 读取和发送站点消息
     SITE_MESSAGE: bool = True
+    # 不能缓存站点资源的站点域名，多个使用,分隔
+    NO_CACHE_SITE_KEY: str = "m-team"
     # 种子标签
     TORRENT_TAG: str = "MOVIEPILOT"
     # 下载站点字幕
@@ -204,8 +235,6 @@ class ConfigModel(BaseModel):
     COOKIECLOUD_INTERVAL: Optional[int] = 60 * 24
     # CookieCloud同步黑名单，多个域名,分割
     COOKIECLOUD_BLACKLIST: Optional[str] = None
-    # CookieCloud对应的浏览器UA
-    USER_AGENT: str = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36 Edg/113.0.1774.57"
     # 电影重命名格式
     MOVIE_RENAME_FORMAT: str = "{{title}}{% if year %} ({{year}}){% endif %}" \
                                "/{{title}}{% if year %} ({{year}}){% endif %}{% if part %}-{{part}}{% endif %}{% if videoFormat %} - {{videoFormat}}{% endif %}" \
@@ -243,18 +272,12 @@ 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
     # 大内存模式
     BIG_MEMORY_MODE: bool = False
-    # 是否启用内存监控
-    MEMORY_ANALYSIS: bool = False
-    # 内存快照间隔（分钟）
-    MEMORY_SNAPSHOT_INTERVAL: int = 60
-    # 保留的内存快照文件数量
-    MEMORY_SNAPSHOT_KEEP_COUNT: int = 20
     # 全局图片缓存，将媒体图片缓存到本地
     GLOBAL_IMAGE_CACHE: bool = False
     # 是否启用编码探测的性能模式
@@ -286,6 +309,12 @@ class ConfigModel(BaseModel):
     DEFAULT_SUB: Optional[str] = "zh-cn"
     # Docker Client API地址
     DOCKER_CLIENT_API: Optional[str] = "tcp://127.0.0.1:38379"
+    # 工作流数据共享
+    WORKFLOW_STATISTIC_SHARE: bool = True
+    # 对rclone进行快照对比时，是否检查文件夹的修改时间
+    RCLONE_SNAPSHOT_CHECK_FOLDER_MODTIME = True
+    # 对OpenList进行快照对比时，是否检查文件夹的修改时间
+    OPENLIST_SNAPSHOT_CHECK_FOLDER_MODTIME = True
 
 
 class Settings(BaseSettings, ConfigModel, LogConfigModel):
@@ -485,6 +514,20 @@ class Settings(BaseSettings, ConfigModel, LogConfigModel):
         """
         return "v2"
 
+    @property
+    def USER_AGENT(self) -> str:
+        """
+        全局用户代理字符串
+        """
+        return f"{self.PROJECT_NAME}/{APP_VERSION[1:]} ({platform.system()} {platform.release()}; {SystemUtils.cpu_arch()})"
+
+    @property
+    def NORMAL_USER_AGENT(self) -> str:
+        """
+        默认浏览器用户代理字符串
+        """
+        return "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36"
+
     @property
     def INNER_CONFIG_PATH(self):
         return self.ROOT_PATH / "config"
@@ -524,43 +567,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 +623,8 @@ class Settings(BaseSettings, ConfigModel, LogConfigModel):
         """
         if self.GITHUB_TOKEN:
             return {
-                "Authorization": f"Bearer {self.GITHUB_TOKEN}"
+                "Authorization": f"Bearer {self.GITHUB_TOKEN}",
+                "User-Agent": self.NORMAL_USER_AGENT,
             }
         return {}
 
@@ -614,7 +652,8 @@ class Settings(BaseSettings, ConfigModel, LogConfigModel):
                     print(f"无效的令牌或仓库信息: {token_pair}")
                     continue
                 headers[repo_info] = {
-                    "Authorization": f"Bearer {token}"
+                    "Authorization": f"Bearer {token}",
+                    "User-Agent": self.NORMAL_USER_AGENT,
                 }
             except Exception as e:
                 print(f"处理令牌对 '{token_pair}' 时出错: {e}")
@@ -634,6 +673,23 @@ class Settings(BaseSettings, ConfigModel, LogConfigModel):
             return None
         return UrlUtils.combine_url(host=self.APP_DOMAIN, path=url)
 
+    def RENAME_FORMAT(self, media_type: MediaType):
+        """
+        获取指定类型的重命名格式
+
+        :param media_type: MediaType.TV 或 MediaType.Movie
+        :return: 重命名格式
+        """
+        rename_format = (
+            self.TV_RENAME_FORMAT
+            if media_type == MediaType.TV
+            else self.MOVIE_RENAME_FORMAT
+        )
+        # 规范重命名格式
+        rename_format = rename_format.replace("\\", "/")
+        rename_format = re.sub(r'/+', '/', rename_format)
+        return rename_format.strip("/")
+
 
 # 实例化配置
 settings = Settings()

app/core/context.py

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

app/core/event.py

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

app/core/meta/customization.py

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

app/core/meta/metabase.py

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

app/core/meta/metavideo.py

@@ -10,6 +10,7 @@ from app.core.meta.releasegroup import ReleaseGroupsMatcher
 from app.schemas.types import MediaType
 from app.utils.string import StringUtils
 from app.utils.tokens import Tokens
+from app.core.meta.streamingplatform import StreamingPlatforms
 
 
 class MetaVideo(MetaBase):
@@ -31,7 +32,7 @@ class MetaVideo(MetaBase):
     _part_re = r"(^PART[0-9ABI]{0,2}$|^CD[0-9]{0,2}$|^DVD[0-9]{0,2}$|^DISK[0-9]{0,2}$|^DISC[0-9]{0,2}$)"
     _roman_numerals = r"^(?=[MDCLXVI])M*(C[MD]|D?C{0,3})(X[CL]|L?X{0,3})(I[XV]|V?I{0,3})$"
     _source_re = r"^BLURAY$|^HDTV$|^UHDTV$|^HDDVD$|^WEBRIP$|^DVDRIP$|^BDRIP$|^BLU$|^WEB$|^BD$|^HDRip$|^REMUX$|^UHD$"
-    _effect_re = r"^SDR$|^HDR\d*$|^DOLBY$|^DOVI$|^DV$|^3D$|^REPACK$|^HLG$|^HDR10(\+|Plus)$"
+    _effect_re = r"^SDR$|^HDR\d*$|^DOLBY$|^DOVI$|^DV$|^3D$|^REPACK$|^HLG$|^HDR10(\+|Plus)$|^EDR$|^HQ$"
     _resources_type_re = r"%s|%s" % (_source_re, _effect_re)
     _name_no_begin_re = r"^[\[【].+?[\]】]"
     _name_no_chinese_re = r".*版|.*字幕"
@@ -51,7 +52,7 @@ class MetaVideo(MetaBase):
     _resources_pix_re = r"^[SBUHD]*(\d{3,4}[PI]+)|\d{3,4}X(\d{3,4})"
     _resources_pix_re2 = r"(^[248]+K)"
     _video_encode_re = r"^(H26[45])$|^(x26[45])$|^AVC$|^HEVC$|^VC\d?$|^MPEG\d?$|^Xvid$|^DivX$|^AV1$|^HDR\d*$|^AVS(\+|[23])$"
-    _audio_encode_re = r"^DTS\d?$|^DTSHD$|^DTSHDMA$|^Atmos$|^TrueHD\d?$|^AC3$|^\dAudios?$|^DDP\d?$|^DD\+\d?$|^DD\d?$|^LPCM\d?$|^AAC\d?$|^FLAC\d?$|^HD\d?$|^MA\d?$|^HR\d?$|^Opus\d?$|^Vorbis\d?$"
+    _audio_encode_re = r"^DTS\d?$|^DTSHD$|^DTSHDMA$|^Atmos$|^TrueHD\d?$|^AC3$|^\dAudios?$|^DDP\d?$|^DD\+\d?$|^DD\d?$|^LPCM\d?$|^AAC\d?$|^FLAC\d?$|^HD\d?$|^MA\d?$|^HR\d?$|^Opus\d?$|^Vorbis\d?$|^AV[3S]A$"
 
     def __init__(self, title: str, subtitle: str = None, isfile: bool = False):
         """
@@ -66,6 +67,7 @@ class MetaVideo(MetaBase):
         original_title = title
         self._source = ""
         self._effect = []
+        self._index = 0
         # 判断是否纯数字命名
         if isfile \
                 and title.isdigit() \
@@ -93,9 +95,12 @@ class MetaVideo(MetaBase):
         # 拆分tokens
         tokens = Tokens(title)
         self.tokens = tokens
+        # 实例化StreamingPlatforms对象
+        streaming_platforms = StreamingPlatforms()
         # 解析名称、年份、季、集、资源类型、分辨率等
         token = tokens.get_next()
         while token:
+            self._index += 1  # 更新当前处理的token索引
             # Part
             self.__init_part(token)
             # 标题
@@ -116,6 +121,9 @@ class MetaVideo(MetaBase):
             # 资源类型
             if self._continue_flag:
                 self.__init_resource_type(token)
+            # 流媒体平台
+            if self._continue_flag:
+                self.__init_web_source(token, streaming_platforms)
             # 视频编码
             if self._continue_flag:
                 self.__init_video_encode(token)
@@ -574,6 +582,57 @@ class MetaVideo(MetaBase):
                 self._effect.append(effect)
             self._last_token = effect.upper()
 
+    def __init_web_source(self, token: str, streaming_platforms: StreamingPlatforms):
+        """
+        识别流媒体平台
+        """
+        if not self.name:
+            return
+
+        platform_name = None
+        query_range = 1
+
+        prev_token = None
+        prev_idx = self._index - 2
+        if 0 <= prev_idx < len(self.tokens.tokens):
+            prev_token = self.tokens.tokens[prev_idx]
+
+        next_token = self.tokens.peek()
+
+        if streaming_platforms.is_streaming_platform(token):
+            platform_name = streaming_platforms.get_streaming_platform_name(token)
+        else:
+            for adjacent_token, is_next in [(prev_token, False), (next_token, True)]:
+                if not adjacent_token or platform_name:
+                    continue
+
+                for separator in [" ", "-"]:
+                    if is_next:
+                        combined_token = f"{token}{separator}{adjacent_token}"
+                    else:
+                        combined_token = f"{adjacent_token}{separator}{token}"
+
+                    if streaming_platforms.is_streaming_platform(combined_token):
+                        platform_name = streaming_platforms.get_streaming_platform_name(combined_token)
+                        query_range = 2
+                        if is_next:
+                            self.tokens.get_next()
+                        break
+
+        if not platform_name:
+            return
+
+        web_tokens = ["WEB", "DL", "WEBDL", "WEBRIP"]
+        match_start_idx = self._index - query_range
+        match_end_idx = self._index - 1
+        start_index = max(0, match_start_idx - query_range)
+        end_index = min(len(self.tokens.tokens), match_end_idx + 1 + query_range)
+        tokens_to_check = self.tokens.tokens[start_index:end_index]
+
+        if any(tok and tok.upper() in web_tokens for tok in tokens_to_check):
+            self.web_source = platform_name
+            self._continue_flag = False
+
     def __init_video_encode(self, token: str):
         """
         识别视频编码

app/core/meta/releasegroup.py

@@ -9,7 +9,6 @@ class ReleaseGroupsMatcher(metaclass=Singleton):
     """
     识别制作组、字幕组
     """
-    __release_groups: str = None
     # 内置组
     RELEASE_GROUPS: dict = {
         "0ff": ['FF(?:(?:A|WE)B|CD|E(?:DU|B)|TV)'],
@@ -48,7 +47,7 @@ class ReleaseGroupsMatcher(metaclass=Singleton):
         "joyhd": [],
         "keepfrds": ['FRDS', 'Yumi', 'cXcY'],
         "lemonhd": ['L(?:eague(?:(?:C|H)D|(?:M|T)V|NF|WEB)|HD)', 'i18n', 'CiNT'],
-        "mteam": ['MTeam(?:TV|)', 'MPAD'],
+        "mteam": ['MTeam(?:TV|)', 'MPAD', 'MWeb'],
         "nanyangpt": [],
         "nicept": [],
         "oshen": [],
@@ -70,7 +69,7 @@ class ReleaseGroupsMatcher(metaclass=Singleton):
         "U2": [],
         "ultrahd": [],
         "others": ['B(?:MDru|eyondHD|TN)', 'C(?:fandora|trlhd|MRG)', 'DON', 'EVO', 'FLUX', 'HONE(?:yG|)',
-                   'N(?:oGroup|T(?:b|G))', 'PandaMoon', 'SMURF', 'T(?:EPES|aengoo|rollHD )',],
+                   'N(?:oGroup|T(?:b|G))', 'PandaMoon', 'SMURF', 'T(?:EPES|aengoo|rollHD )'],
         "anime": ['ANi', 'HYSUB', 'KTXP', 'LoliHouse', 'MCE', 'Nekomoe kissaten', 'SweetSub', 'MingY',
                   '(?:Lilith|NC)-Raws', '织梦字幕组', '枫叶字幕组', '猎户手抄部', '喵萌奶茶屋', '漫猫字幕社',
                   '霜庭云花Sub', '北宇治字幕组', '氢气烤肉架', '云歌字幕组', '萌樱字幕组', '极影字幕社',

app/core/meta/streamingplatform.py

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

app/core/metainfo.py

@@ -154,35 +154,35 @@ def find_metainfo(title: str) -> Tuple[str, dict]:
             # 去除title中该部分
             if tmdbid or mtype or begin_season or end_season or begin_episode or end_episode:
                 title = title.replace(f"{{[{result}]}}", '')
-    
+
     # 支持Emby格式的ID标签
     # 1. [tmdbid=xxxx] 或 [tmdbid-xxxx] 格式
     tmdb_match = re.search(r'\[tmdbid[=\-](\d+)\]', title)
     if tmdb_match:
         metainfo['tmdbid'] = tmdb_match.group(1)
         title = re.sub(r'\[tmdbid[=\-](\d+)\]', '', title).strip()
-    
+
     # 2. [tmdb=xxxx] 或 [tmdb-xxxx] 格式
     if not metainfo['tmdbid']:
         tmdb_match = re.search(r'\[tmdb[=\-](\d+)\]', title)
         if tmdb_match:
             metainfo['tmdbid'] = tmdb_match.group(1)
             title = re.sub(r'\[tmdb[=\-](\d+)\]', '', title).strip()
-    
+
     # 3. {tmdbid=xxxx} 或 {tmdbid-xxxx} 格式
     if not metainfo['tmdbid']:
         tmdb_match = re.search(r'\{tmdbid[=\-](\d+)\}', title)
         if tmdb_match:
             metainfo['tmdbid'] = tmdb_match.group(1)
             title = re.sub(r'\{tmdbid[=\-](\d+)\}', '', title).strip()
-    
+
     # 4. {tmdb=xxxx} 或 {tmdb-xxxx} 格式
     if not metainfo['tmdbid']:
         tmdb_match = re.search(r'\{tmdb[=\-](\d+)\}', title)
         if tmdb_match:
             metainfo['tmdbid'] = tmdb_match.group(1)
             title = re.sub(r'\{tmdb[=\-](\d+)\}', '', title).strip()
-    
+
     # 计算季集总数
     if metainfo.get('begin_season') and metainfo.get('end_season'):
         if metainfo['begin_season'] > metainfo['end_season']:

app/core/module.py

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

app/core/plugin.py

@@ -3,12 +3,14 @@ import concurrent.futures
 import importlib.util
 import inspect
 import os
+import sys
 import time
 import traceback
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Type, Union, Callable, Tuple
 
+from app.helper.sites import SitesHelper
 from fastapi import HTTPException
 from starlette import status
 from watchdog.events import FileSystemEventHandler
@@ -19,9 +21,7 @@ from app.core.config import settings
 from app.core.event import eventmanager, Event
 from app.db.plugindata_oper import PluginDataOper
 from app.db.systemconfig_oper import SystemConfigOper
-from app.helper.module import ModuleHelper
 from app.helper.plugin import PluginHelper
-from app.helper.sites import SitesHelper
 from app.log import logger
 from app.schemas.types import EventType, SystemConfigKey
 from app.utils.crypto import RSAUtils
@@ -88,16 +88,15 @@ class PluginManager(metaclass=Singleton):
     插件管理器
     """
 
-    # 插件列表
-    _plugins: dict = {}
-    # 运行态插件列表
-    _running_plugins: dict = {}
-    # 配置Key
-    _config_key: str = "plugin.%s"
-    # 监听器
-    _observer: Observer = None
-
     def __init__(self):
+        # 插件列表
+        self._plugins: dict = {}
+        # 运行态插件列表
+        self._running_plugins: dict = {}
+        # 配置Key
+        self._config_key: str = "plugin.%s"
+        # 监听器
+        self._observer: Observer = None
         # 开发者模式监测插件修改
         if settings.DEV or settings.PLUGIN_AUTO_RELOAD:
             self.__start_monitor()
@@ -122,21 +121,10 @@ class PluginManager(metaclass=Singleton):
                 return False
             return True
 
-        # 扫描插件目录
-        if pid:
-            # 加载指定插件
-            plugins = ModuleHelper.load_with_pre_filter(
-                "app.plugins",
-                filter_func=lambda name, obj: check_module(obj) and name == pid
-            )
-        else:
-            # 加载所有插件
-            plugins = ModuleHelper.load(
-                "app.plugins",
-                filter_func=lambda _, obj: check_module(obj)
-            )
         # 已安装插件
         installed_plugins = SystemConfigOper().get(SystemConfigKey.UserInstalledPlugins) or []
+        # 扫描插件目录，只加载符合条件的插件
+        plugins = self._load_selective_plugins(pid, installed_plugins, check_module)
         # 排序
         plugins.sort(key=lambda x: x.plugin_order if hasattr(x, "plugin_order") else 0)
         for plugin in plugins:
@@ -152,11 +140,6 @@ class PluginManager(metaclass=Singleton):
                     continue
                 # 存储Class
                 self._plugins[plugin_id] = plugin
-                # 未安装的不加载
-                if plugin_id not in installed_plugins:
-                    # 设置事件状态为不可用
-                    eventmanager.disable_event_handler(plugin)
-                    continue
                 # 生成实例
                 plugin_obj = plugin()
                 # 生效插件配置
@@ -201,7 +184,7 @@ class PluginManager(metaclass=Singleton):
             logger.info(f"正在停止插件 {pid}...")
             plugin_obj = self._running_plugins.get(pid)
             if not plugin_obj:
-                logger.warning(f"插件 {pid} 不存在或未加载")
+                logger.debug(f"插件 {pid} 不存在或未加载")
                 return
             plugins = {pid: plugin_obj}
         else:
@@ -213,13 +196,92 @@ class PluginManager(metaclass=Singleton):
         # 清空对像
         if pid:
             # 清空指定插件
+            self._plugins.pop(pid, None)
             self._running_plugins.pop(pid, None)
+            # 清除插件模块缓存，包括所有子模块
+            self._clear_plugin_modules(pid)
         else:
             # 清空
             self._plugins = {}
             self._running_plugins = {}
+            # 清除所有插件模块缓存
+            self._clear_plugin_modules()
         logger.info("插件停止完成")
 
+    @staticmethod
+    def _load_selective_plugins(pid: Optional[str], installed_plugins: List[str],
+                                check_module_func: Callable) -> List[Any]:
+        """
+        选择性加载插件，只import符合条件的插件
+        :param pid: 指定插件ID，为空则加载所有已安装插件
+        :param installed_plugins: 已安装插件列表
+        :param check_module_func: 模块检查函数
+        :return: 插件类列表
+        """
+        import importlib
+
+        plugins = []
+        plugins_dir = settings.ROOT_PATH / "app" / "plugins"
+
+        if not plugins_dir.exists():
+            logger.warning(f"插件目录不存在：{plugins_dir}")
+            return plugins
+
+        # 确定需要加载的插件目录名称列表
+        if pid:
+            # 加载指定插件
+            target_plugins = [pid.lower()]
+        else:
+            # 加载已安装插件
+            target_plugins = [plugin_id.lower() for plugin_id in installed_plugins]
+
+        if not target_plugins:
+            logger.debug("没有需要加载的插件")
+            return plugins
+
+        # 扫描plugins目录
+        _loaded_modules = set()
+        for plugin_dir in plugins_dir.iterdir():
+            if not plugin_dir.is_dir() or plugin_dir.name.startswith('_'):
+                continue
+
+            # 检查是否是需要加载的插件
+            if plugin_dir.name not in target_plugins:
+                logger.debug(f"跳过插件目录：{plugin_dir.name}（不在加载列表中）")
+                continue
+
+            # 检查__init__.py是否存在
+            init_file = plugin_dir / "__init__.py"
+            if not init_file.exists():
+                logger.debug(f"跳过插件目录：{plugin_dir.name}（缺少__init__.py）")
+                continue
+
+            try:
+                # 构建模块名
+                module_name = f"app.plugins.{plugin_dir.name}"
+                logger.debug(f"正在导入插件模块：{module_name}")
+
+                # 导入模块
+                module = importlib.import_module(module_name)
+                importlib.reload(module)
+
+                # 检查模块中的类
+                for name, obj in module.__dict__.items():
+                    if name.startswith('_') or not isinstance(obj, type):
+                        continue
+                    if name in _loaded_modules:
+                        continue
+                    if check_module_func(obj):
+                        _loaded_modules.add(name)
+                        plugins.append(obj)
+                        logger.debug(f"找到符合条件的插件类：{name}")
+                        break
+
+            except Exception as err:
+                logger.error(f"加载插件 {plugin_dir.name} 失败：{str(err)} - {traceback.format_exc()}")
+
+        return plugins
+
     @property
     def running_plugins(self) -> Dict[str, Any]:
         """
@@ -247,6 +309,7 @@ class PluginManager(metaclass=Singleton):
         event_data: schemas.ConfigChangeEventData = event.event_data
         if event_data.key not in ['DEV', 'PLUGIN_AUTO_RELOAD']:
             return
+        logger.info("配置变更，重新加载插件文件修改监测...")
         self.reload_monitor()
 
     def reload_monitor(self):
@@ -307,28 +370,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 +443,7 @@ class PluginManager(metaclass=Singleton):
         # 确定需要安装的插件
         plugins_to_install = [
             plugin for plugin in online_plugins
-            if plugin.id in install_plugins and not self.is_plugin_exists(plugin.id)
+            if plugin.id in install_plugins and not self.is_plugin_exists(plugin.id, plugin.plugin_version)
         ]
 
         if not plugins_to_install:
@@ -889,10 +978,11 @@ class PluginManager(metaclass=Singleton):
         return plugins
 
     @staticmethod
-    def is_plugin_exists(pid: str) -> bool:
+    def is_plugin_exists(pid: str, version: str = None) -> bool:
         """
-        判断插件是否在本地包中存在
+        判断插件是否存在，并满足版本要求(有传入version时)
         :param pid: 插件ID
+        :param version: 插件版本
         """
         if not pid:
             return False
@@ -903,7 +993,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
@@ -931,6 +1032,8 @@ class PluginManager(metaclass=Singleton):
         ret_plugins = []
         add_time = len(online_plugins)
         for pid, plugin_info in online_plugins.items():
+            if not isinstance(plugin_info, dict):
+                continue
             # 如 package_version 为空，则需要判断插件是否兼容当前版本
             if not package_version:
                 if plugin_info.get(settings.VERSION_FLAG) is not True:
@@ -1345,8 +1448,9 @@ class PluginManager(metaclass=Singleton):
                             content = f.read()
 
                         # 替换CSS中可能的类名引用
-                        content = content.replace(original_class_name.lower(), clone_class_name.lower())
-                        content = content.replace(original_class_name, clone_class_name)
+                        content = content.replace(original_class_name.lower(),
+                                                  clone_class_name.lower()).replace(original_class_name,
+                                                                                    clone_class_name)
 
                         with open(file_path, 'w', encoding='utf-8') as f:
                             f.write(content)

app/core/workflow.py

@@ -1,10 +1,16 @@
+import threading
 from time import sleep
-from typing import Dict, Any, Tuple, List
+from typing import Dict, Any, Optional
+from typing import List, Tuple
 
 from app.core.config import global_vars
+from app.core.event import eventmanager, Event
+from app.db.models import Workflow
+from app.db.workflow_oper import WorkflowOper
 from app.helper.module import ModuleHelper
 from app.log import logger
-from app.schemas import Action, ActionContext
+from app.schemas import ActionContext, Action
+from app.schemas.types import EventType
 from app.utils.singleton import Singleton
 
 
@@ -13,10 +19,11 @@ class WorkFlowManager(metaclass=Singleton):
     工作流管理器
     """
 
-    # 所有动作定义
-    _actions: Dict[str, Any] = {}
-
     def __init__(self):
+        # 所有动作定义
+        self._lock = threading.Lock()
+        self._actions: Dict[str, Any] = {}
+        self._event_workflows: Dict[str, List[int]] = {}
         self.init()
 
     def init(self):
@@ -49,11 +56,15 @@ class WorkFlowManager(metaclass=Singleton):
             except Exception as err:
                 logger.error(f"加载动作失败: {action.__name__} - {err}")
 
+        # 加载工作流事件触发器
+        self.load_workflow_events()
+
     def stop(self):
         """
         停止
         """
-        pass
+        self._actions = {}
+        self._event_workflows = {}
 
     def excute(self, workflow_id: int, action: Action,
                context: ActionContext = None) -> Tuple[bool, str, ActionContext]:
@@ -110,3 +121,180 @@ class WorkFlowManager(metaclass=Singleton):
                 }
             } for key, action in self._actions.items()
         ]
+
+    def update_workflow_event(self, workflow: Workflow):
+        """
+        更新工作流事件触发器
+        """
+        # 确保先移除旧的事件监听器
+        self.remove_workflow_event(workflow_id=workflow.id, event_type_str=workflow.event_type)
+        # 如果工作流是事件触发类型且未被禁用
+        if workflow.trigger_type == "event" and workflow.state != 'P':
+            # 注册事件触发器
+            self.register_workflow_event(workflow.id, workflow.event_type)
+
+    def load_workflow_events(self, workflow_id: Optional[int] = None):
+        """
+        加载工作流触发事件
+        """
+        workflows = []
+        if workflow_id:
+            workflow = WorkflowOper().get(workflow_id)
+            if workflow:
+                workflows = [workflow]
+        else:
+            workflows = WorkflowOper().get_event_triggered_workflows()
+        try:
+            for workflow in workflows:
+                self.update_workflow_event(workflow)
+        except Exception as e:
+            logger.error(f"加载事件触发工作流失败: {e}")
+
+    def register_workflow_event(self, workflow_id: int, event_type_str: str):
+        """
+        注册工作流事件触发器
+        """
+        try:
+            event_type = EventType(event_type_str)
+        except ValueError:
+            logger.error(f"无效的事件类型: {event_type_str}")
+            return
+        if event_type in EventType:
+            # 确保先移除旧的事件监听器
+            self.remove_workflow_event(workflow_id, event_type.value)
+            with self._lock:
+                # 添加新的事件监听器
+                eventmanager.add_event_listener(event_type, self._handle_event)
+                # 记录工作流事件触发器
+                if event_type.value not in self._event_workflows:
+                    self._event_workflows[event_type.value] = []
+                self._event_workflows[event_type.value].append(workflow_id)
+                logger.info(f"已注册工作流 {workflow_id} 事件触发器: {event_type.value}")
+
+    def remove_workflow_event(self, workflow_id: int, event_type_str: str):
+        """
+        移除工作流事件触发器
+        """
+        try:
+            event_type = EventType(event_type_str)
+        except ValueError:
+            logger.error(f"无效的事件类型: {event_type_str}")
+            return
+        if event_type in EventType:
+            with self._lock:
+                eventmanager.remove_event_listener(event_type, self._handle_event)
+                if event_type.value in self._event_workflows:
+                    if workflow_id in self._event_workflows[event_type.value]:
+                        self._event_workflows[event_type.value].remove(workflow_id)
+                        if not self._event_workflows[event_type.value]:
+                            del self._event_workflows[event_type.value]
+                logger.info(f"已移除工作流 {workflow_id} 事件触发器")
+
+    def _handle_event(self, event: Event):
+        """
+        处理事件，触发相应的工作流
+        """
+        try:
+            event_type_str = str(event.event_type.value)
+            with self._lock:
+                if event_type_str not in self._event_workflows:
+                    return
+                workflow_ids = self._event_workflows[event_type_str].copy()
+            for workflow_id in workflow_ids:
+                self._trigger_workflow(workflow_id, event)
+        except Exception as e:
+            logger.error(f"处理工作流事件失败: {e}")
+
+    def _trigger_workflow(self, workflow_id: int, event: Event):
+        """
+        触发工作流执行
+        """
+        try:
+            # 检查工作流是否存在且启用
+            workflow = WorkflowOper().get(workflow_id)
+            if not workflow or workflow.state == 'P':
+                return
+
+            # 检查事件条件
+            if not self._check_event_conditions(workflow, event):
+                logger.debug(f"工作流 {workflow.name} 事件条件不匹配，跳过执行")
+                return
+
+            # 检查工作流是否正在运行
+            if workflow.state == 'R':
+                logger.warning(f"工作流 {workflow.name} 正在运行中，跳过重复触发")
+                return
+
+            logger.info(f"事件 {event.event_type.value} 触发工作流: {workflow.name}")
+
+            # 发送工作流执行事件以启动工作流
+            eventmanager.send_event(EventType.WorkflowExecute, {
+                "workflow_id": workflow_id,
+            })
+
+        except Exception as e:
+            logger.error(f"触发工作流 {workflow_id} 失败: {e}")
+
+    def _check_event_conditions(self, workflow, event: Event) -> bool:
+        """
+        检查事件是否满足工作流的触发条件
+        """
+        if not workflow.event_conditions:
+            return True
+
+        conditions = workflow.event_conditions
+        event_data = event.event_data or {}
+
+        # 检查字段匹配条件
+        for field, expected_value in conditions.items():
+            if field not in event_data:
+                return False
+            actual_value = event_data[field]
+            # 支持多种条件匹配方式
+            if isinstance(expected_value, dict):
+                # 复杂条件匹配
+                if not self._check_complex_condition(actual_value, expected_value):
+                    return False
+            else:
+                # 简单值匹配
+                if actual_value != expected_value:
+                    return False
+        return True
+
+    @staticmethod
+    def _check_complex_condition(actual_value: any, condition: dict) -> bool:
+        """
+        检查复杂条件匹配
+        支持的操作符：equals, not_equals, contains, not_contains, in, not_in, regex
+        """
+        for operator, expected_value in condition.items():
+            if operator == "equals":
+                if actual_value != expected_value:
+                    return False
+            elif operator == "not_equals":
+                if actual_value == expected_value:
+                    return False
+            elif operator == "contains":
+                if expected_value not in str(actual_value):
+                    return False
+            elif operator == "not_contains":
+                if expected_value in str(actual_value):
+                    return False
+            elif operator == "in":
+                if actual_value not in expected_value:
+                    return False
+            elif operator == "not_in":
+                if actual_value in expected_value:
+                    return False
+            elif operator == "regex":
+                import re
+                if not re.search(expected_value, str(actual_value)):
+                    return False
+        return True
+
+    def get_event_workflows(self) -> dict:
+        """
+        获取所有事件触发的工作流
+        """
+        with self._lock:
+            return self._event_workflows.copy()

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/models/workflow.py

@@ -1,7 +1,7 @@
 from datetime import datetime
 from typing import Optional
 
-from sqlalchemy import Column, Integer, JSON, Sequence, String, and_
+from sqlalchemy import Column, Integer, JSON, Sequence, String, and_, or_
 
 from app.db import Base, db_query, db_update
 
@@ -18,6 +18,12 @@ class Workflow(Base):
     description = Column(String)
     # 定时器
     timer = Column(String)
+    # 触发类型：timer-定时触发 event-事件触发 manual-手动触发
+    trigger_type = Column(String, default='timer')
+    # 事件类型（当trigger_type为event时使用）
+    event_type = Column(String)
+    # 事件条件（JSON格式，用于过滤事件）
+    event_conditions = Column(JSON, default=dict)
     # 状态：W-等待 R-运行中 P-暂停 S-成功 F-失败
     state = Column(String, nullable=False, index=True, default='W')
     # 已执行动作（,分隔）
@@ -37,11 +43,41 @@ class Workflow(Base):
     # 最后执行时间
     last_time = Column(String)
 
+    @staticmethod
+    @db_query
+    def list(db):
+        return db.query(Workflow).all()
+
     @staticmethod
     @db_query
     def get_enabled_workflows(db):
         return db.query(Workflow).filter(Workflow.state != 'P').all()
 
+    @staticmethod
+    @db_query
+    def get_timer_triggered_workflows(db):
+        """获取定时触发的工作流"""
+        return db.query(Workflow).filter(
+            and_(
+                or_(
+                    Workflow.trigger_type == 'timer',
+                    not Workflow.trigger_type
+                ),
+                Workflow.state != 'P'
+            )
+        ).all()
+
+    @staticmethod
+    @db_query
+    def get_event_triggered_workflows(db):
+        """获取事件触发的工作流"""
+        return db.query(Workflow).filter(
+            and_(
+                Workflow.trigger_type == 'event',
+                Workflow.state != 'P'
+            )
+        ).all()
+
     @staticmethod
     @db_query
     def get_by_name(db, name: str):

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/db/workflow_oper.py

@@ -25,12 +25,30 @@ class WorkflowOper(DbOper):
         """
         return Workflow.get(self._db, wid)
 
+    def list(self) -> List[Workflow]:
+        """
+        获取所有工作流列表
+        """
+        return Workflow.list(self._db)
+
     def list_enabled(self) -> List[Workflow]:
         """
         获取启用的工作流列表
         """
         return Workflow.get_enabled_workflows(self._db)
 
+    def get_timer_triggered_workflows(self) -> List[Workflow]:
+        """
+        获取定时触发的工作流列表
+        """
+        return Workflow.get_timer_triggered_workflows(self._db)
+
+    def get_event_triggered_workflows(self) -> List[Workflow]:
+        """
+        获取事件触发的工作流列表
+        """
+        return Workflow.get_event_triggered_workflows(self._db)
+
     def get_by_name(self, name: str) -> Workflow:
         """
         按名称获取工作流

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

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

app/helper/directory.py

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

app/helper/display.py

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

app/helper/doh.py

@@ -10,10 +10,15 @@ import socket
 import struct
 import urllib
 import urllib.request
+from threading import Lock
 from typing import Dict, Optional
 
 from app.core.config import settings
+from app.core.event import Event, eventmanager
 from app.log import logger
+from app.schemas import ConfigChangeEventData
+from app.schemas.types import EventType
+from app.utils.singleton import Singleton
 
 # 定义一个全局线程池执行器
 _executor = concurrent.futures.ThreadPoolExecutor()
@@ -21,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,37 @@ 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):
+    """
+    DoH帮助类，用于处理DNS over HTTPS解析。
+    """
+    def __init__(self):
+        enable_doh(settings.DOH_ENABLE)
+
+    @eventmanager.register(EventType.ConfigChanged)
+    def handle_config_changed(self, event: Event):
+        if not event:
+            return
+        event_data: ConfigChangeEventData = event.event_data
+        if event_data.key not in ["DOH_ENABLE", "DOH_DOMAINS", "DOH_RESOLVERS"]:
+            return
+        with _doh_lock:
+            # DOH配置有变动的情况下，清空缓存
+            _doh_cache.clear()
+        enable_doh(settings.DOH_ENABLE)
 
 
 def _doh_query(resolver: str, host: str) -> Optional[str]:

app/helper/memory.py

@@ -1,457 +0,0 @@
-import gc
-import sys
-import threading
-import time
-from datetime import datetime
-from typing import Optional
-
-import psutil
-from pympler import muppy, summary, asizeof
-
-from app.core.config import settings
-from app.core.event import eventmanager, Event
-from app.log import logger
-from app.schemas import ConfigChangeEventData
-from app.schemas.types import EventType
-from app.utils.singleton import Singleton
-
-
-class MemoryHelper(metaclass=Singleton):
-    """
-    内存管理工具类，用于监控和优化内存使用
-    """
-
-    def __init__(self):
-        # 检查间隔(秒) - 从配置获取，默认5分钟
-        self._check_interval = settings.MEMORY_SNAPSHOT_INTERVAL * 60
-        self._monitoring = False
-        self._monitor_thread: Optional[threading.Thread] = None
-        # 内存快照保存目录
-        self._memory_snapshot_dir = settings.LOG_PATH / "memory_snapshots"
-        # 保留的快照文件数量
-        self._keep_count = settings.MEMORY_SNAPSHOT_KEEP_COUNT
-
-    @eventmanager.register(EventType.ConfigChanged)
-    def handle_config_changed(self, event: Event):
-        """
-        处理配置变更事件，更新内存监控设置
-        :param event: 事件对象
-        """
-        if not event:
-            return
-        event_data: ConfigChangeEventData = event.event_data
-        if event_data.key not in ['MEMORY_ANALYSIS', 'MEMORY_SNAPSHOT_INTERVAL', 'MEMORY_SNAPSHOT_KEEP_COUNT']:
-            return
-
-        # 更新配置
-        if event_data.key == 'MEMORY_SNAPSHOT_INTERVAL':
-            self._check_interval = settings.MEMORY_SNAPSHOT_INTERVAL * 60
-        elif event_data.key == 'MEMORY_SNAPSHOT_KEEP_COUNT':
-            self._keep_count = settings.MEMORY_SNAPSHOT_KEEP_COUNT
-        self.stop_monitoring()
-        self.start_monitoring()
-
-    def start_monitoring(self):
-        """
-        开始内存监控
-        """
-        if not settings.MEMORY_ANALYSIS:
-            return
-        if self._monitoring:
-            return
-
-        # 创建内存快照目录
-        self._memory_snapshot_dir.mkdir(parents=True, exist_ok=True)
-
-        # 初始化内存分析器
-        self._monitoring = True
-        self._monitor_thread = threading.Thread(target=self._monitor_loop, daemon=True)
-        self._monitor_thread.start()
-        logger.info("内存监控已启动")
-
-    def stop_monitoring(self):
-        """
-        停止内存监控
-        """
-        self._monitoring = False
-        if self._monitor_thread:
-            self._monitor_thread.join(timeout=5)
-            logger.info("内存监控已停止")
-
-    def _monitor_loop(self):
-        """
-        内存监控循环
-        """
-        logger.info("内存监控循环开始")
-        while self._monitoring:
-            try:
-                # 生成内存快照
-                self._create_memory_snapshot()
-                time.sleep(self._check_interval)
-            except Exception as e:
-                logger.error(f"内存监控出错: {e}")
-                # 出错后等待1分钟再继续
-                time.sleep(60)
-        logger.info("内存监控循环结束")
-
-    def _create_memory_snapshot(self):
-        """
-        创建内存快照并保存到文件
-        """
-        try:
-            # 获取当前时间戳
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-            snapshot_file = self._memory_snapshot_dir / f"memory_snapshot_{timestamp}.txt"
-
-            # 获取系统内存使用情况
-            memory_usage = psutil.Process().memory_info().rss
-
-            logger.info(f"开始创建内存快照: {snapshot_file}")
-
-            # 第一步：写入基本信息和对象类型统计
-            self._write_basic_info(snapshot_file, memory_usage)
-
-            # 第二步：分析并写入类实例内存使用情况
-            self._append_class_analysis(snapshot_file)
-
-            # 第三步：分析并写入大内存变量详情
-            self._append_variable_analysis(snapshot_file)
-
-            logger.info(f"内存快照已保存: {snapshot_file}, 当前内存使用: {memory_usage / 1024 / 1024:.2f} MB")
-
-            # 清理过期的快照文件（保留最近30个）
-            self._cleanup_old_snapshots()
-
-        except Exception as e:
-            logger.error(f"创建内存快照失败: {e}")
-
-    @staticmethod
-    def _write_basic_info(snapshot_file, memory_usage):
-        """
-        写入基本信息和对象类型统计
-        """
-        # 获取当前进程的内存使用情况
-        all_objects = muppy.get_objects()
-        sum1 = summary.summarize(all_objects)
-
-        with open(snapshot_file, 'w', encoding='utf-8') as f:
-            f.write(f"内存快照时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
-            f.write(f"当前进程内存使用: {memory_usage / 1024 / 1024:.2f} MB\n")
-            f.write("=" * 80 + "\n")
-            f.write("对象类型统计:\n")
-            f.write("-" * 80 + "\n")
-
-            # 写入对象统计信息
-            for line in summary.format_(sum1):
-                f.write(line + "\n")
-
-            # 立即刷新到磁盘
-            f.flush()
-
-        logger.debug("基本信息已写入快照文件")
-
-    def _append_class_analysis(self, snapshot_file):
-        """
-        分析并追加类实例内存使用情况
-        """
-        with open(snapshot_file, 'a', encoding='utf-8') as f:
-            f.write("\n" + "=" * 80 + "\n")
-            f.write("类实例内存使用情况 (按内存大小排序):\n")
-            f.write("-" * 80 + "\n")
-            f.write("正在分析中...\n")
-            # 立即刷新，让用户知道这部分开始了
-            f.flush()
-
-        try:
-            logger.debug("开始分析类实例内存使用情况")
-            class_objects = self._get_class_memory_usage()
-
-            # 重新打开文件，移除"正在分析中..."并写入实际结果
-            with open(snapshot_file, 'r', encoding='utf-8') as f:
-                content = f.read()
-
-            # 替换"正在分析中..."
-            content = content.replace("正在分析中...\n", "")
-
-            with open(snapshot_file, 'w', encoding='utf-8') as f:
-                f.write(content)
-
-                if class_objects:
-                    # 只显示前100个类
-                    for i, class_info in enumerate(class_objects[:100], 1):
-                        f.write(f"{i:3d}. {class_info['name']:<50} "
-                                f"{class_info['size_mb']:>8.2f} MB ({class_info['count']} 个实例)\n")
-                else:
-                    f.write("未找到有效的类实例信息\n")
-
-                f.flush()
-
-        except Exception as e:
-            logger.error(f"获取类实例信息失败: {e}")
-
-            # 即使出错也要更新文件
-            with open(snapshot_file, 'r', encoding='utf-8') as f:
-                content = f.read()
-
-            content = content.replace("正在分析中...\n", f"获取类实例信息失败: {e}\n")
-
-            with open(snapshot_file, 'w', encoding='utf-8') as f:
-                f.write(content)
-                f.flush()
-
-        logger.debug("类实例分析已完成并写入")
-
-    def _append_variable_analysis(self, snapshot_file):
-        """
-        分析并追加大内存变量详情
-        """
-        with open(snapshot_file, 'a', encoding='utf-8') as f:
-            f.write("\n" + "=" * 80 + "\n")
-            f.write("大内存变量详情 (前100个):\n")
-            f.write("-" * 80 + "\n")
-            f.write("正在分析中...\n")
-            # 立即刷新，让用户知道这部分开始了
-            f.flush()
-
-        try:
-            logger.debug("开始分析大内存变量")
-            large_variables = self._get_large_variables(100)
-
-            # 重新打开文件，移除"正在分析中..."并写入实际结果
-            with open(snapshot_file, 'r', encoding='utf-8') as f:
-                content = f.read()
-
-            # 替换最后的"正在分析中..."
-            content = content.replace("正在分析中...\n", "")
-
-            with open(snapshot_file, 'w', encoding='utf-8') as f:
-                f.write(content)
-
-                if large_variables:
-                    for i, var_info in enumerate(large_variables, 1):
-                        f.write(
-                            f"{i:3d}. {var_info['name']:<30} {var_info['type']:<15} {var_info['size_mb']:>8.2f} MB\n")
-                else:
-                    f.write("未找到大内存变量\n")
-
-                f.flush()
-
-        except Exception as e:
-            logger.error(f"获取大内存变量信息失败: {e}")
-
-            # 即使出错也要更新文件
-            with open(snapshot_file, 'r', encoding='utf-8') as f:
-                content = f.read()
-
-            content = content.replace("正在分析中...\n", f"获取变量信息失败: {e}\n")
-
-            with open(snapshot_file, 'w', encoding='utf-8') as f:
-                f.write(content)
-                f.flush()
-
-        logger.debug("大内存变量分析已完成并写入")
-
-    def _cleanup_old_snapshots(self):
-        """
-        清理过期的内存快照文件，只保留最近的指定数量文件
-        """
-        try:
-            snapshot_files = list(self._memory_snapshot_dir.glob("memory_snapshot_*.txt"))
-            if len(snapshot_files) > self._keep_count:
-                # 按修改时间排序，删除最旧的文件
-                snapshot_files.sort(key=lambda x: x.stat().st_mtime)
-                for old_file in snapshot_files[:-self._keep_count]:
-                    old_file.unlink()
-                    logger.debug(f"已删除过期内存快照: {old_file}")
-        except Exception as e:
-            logger.error(f"清理过期快照失败: {e}")
-
-    @staticmethod
-    def _get_class_memory_usage():
-        """
-        获取所有类实例的内存使用情况，按内存大小排序
-        """
-        class_info = {}
-        processed_count = 0
-        error_count = 0
-
-        # 获取所有对象
-        all_objects = muppy.get_objects()
-        logger.debug(f"开始分析 {len(all_objects)} 个对象的类实例内存使用情况")
-
-        for obj in all_objects:
-            try:
-                # 跳过类对象本身，统计类的实例
-                if isinstance(obj, type):
-                    continue
-
-                # 获取对象的类名 - 这里可能会出错
-                obj_class = type(obj)
-
-                # 安全地获取类名
-                try:
-                    if hasattr(obj_class, '__module__') and hasattr(obj_class, '__name__'):
-                        class_name = f"{obj_class.__module__}.{obj_class.__name__}"
-                    else:
-                        class_name = str(obj_class)
-                except Exception as e:
-                    # 如果获取类名失败，使用简单的类型描述
-                    class_name = f"<unknown_class_{id(obj_class)}>"
-                    logger.debug(f"获取类名失败: {e}")
-
-                # 计算对象本身的内存使用（不包括引用对象，避免重复计算）
-                size_bytes = sys.getsizeof(obj)
-                if size_bytes < 100:  # 跳过太小的对象
-                    continue
-
-                size_mb = size_bytes / 1024 / 1024
-                processed_count += 1
-
-                if class_name in class_info:
-                    class_info[class_name]['size_mb'] += size_mb
-                    class_info[class_name]['count'] += 1
-                else:
-                    class_info[class_name] = {
-                        'name': class_name,
-                        'size_mb': size_mb,
-                        'count': 1
-                    }
-
-            except Exception as e:
-                # 捕获所有可能的异常，包括SQLAlchemy、ORM等框架的异常
-                error_count += 1
-                if error_count <= 5:  # 只记录前5个错误，避免日志过多
-                    logger.debug(f"分析对象时出错: {e}")
-                continue
-
-        logger.debug(f"类实例分析完成: 处理了 {processed_count} 个对象, 遇到 {error_count} 个错误")
-
-        # 按内存大小排序
-        sorted_classes = sorted(class_info.values(), key=lambda x: x['size_mb'], reverse=True)
-        return sorted_classes
-
-    def _get_large_variables(self, limit=100):
-        """
-        获取大内存变量信息，按内存大小排序
-        使用已计算对象集合避免重复计算
-        """
-        large_vars = []
-        processed_count = 0
-        calculated_objects = set()  # 避免重复计算
-
-        # 获取所有对象
-        all_objects = muppy.get_objects()
-        logger.debug(f"开始分析 {len(all_objects)} 个对象的内存使用情况")
-
-        for obj in all_objects:
-            # 跳过类对象
-            if isinstance(obj, type):
-                continue
-
-            # 跳过已经计算过的对象
-            obj_id = id(obj)
-            if obj_id in calculated_objects:
-                continue
-
-            try:
-                # 首先使用 sys.getsizeof 快速筛选
-                shallow_size = sys.getsizeof(obj)
-                if shallow_size < 1024:  # 只处理大于1KB的对象
-                    continue
-
-                # 对于较大的对象，使用 asizeof 进行深度计算
-                size_bytes = asizeof.asizeof(obj)
-                
-                # 只处理大于10KB的对象，提高分析效率
-                if size_bytes < 10240:
-                    continue
-
-                size_mb = size_bytes / 1024 / 1024
-                processed_count += 1
-                calculated_objects.add(obj_id)
-
-                # 获取对象信息
-                var_info = self._get_variable_info(obj, size_mb)
-                if var_info:
-                    large_vars.append(var_info)
-
-                # 如果已经找到足够多的大对象，可以提前结束
-                if len(large_vars) >= limit * 2:  # 多收集一些，后面排序筛选
-                    break
-
-            except Exception as e:
-                # 更广泛的异常捕获
-                logger.debug(f"分析对象失败: {e}")
-                continue
-
-        logger.debug(f"处理了 {processed_count} 个大对象，找到 {len(large_vars)} 个有效变量")
-
-        # 按内存大小排序并返回前N个
-        large_vars.sort(key=lambda x: x['size_mb'], reverse=True)
-        return large_vars[:limit]
-
-    def _get_variable_info(self, obj, size_mb):
-        """
-        获取变量的描述信息
-        """
-        try:
-            obj_type = type(obj).__name__
-
-            # 尝试获取变量名
-            var_name = self._get_variable_name(obj)
-
-            # 生成描述性信息
-            if isinstance(obj, dict):
-                key_count = len(obj)
-                if key_count > 0:
-                    sample_keys = list(obj.keys())[:3]
-                    var_name += f" ({key_count}项, 键: {sample_keys})"
-            elif isinstance(obj, (list, tuple, set)):
-                var_name += f" ({len(obj)}个元素)"
-            elif isinstance(obj, str):
-                if len(obj) > 50:
-                    var_name += f" (长度: {len(obj)}, 内容: '{obj[:50]}...')"
-                else:
-                    var_name += f" ('{obj}')"
-            elif hasattr(obj, '__class__') and hasattr(obj.__class__, '__name__'):
-                if hasattr(obj, '__dict__'):
-                    attr_count = len(obj.__dict__)
-                    var_name += f" ({attr_count}个属性)"
-
-            return {
-                'name': var_name,
-                'type': obj_type,
-                'size_mb': size_mb
-            }
-
-        except Exception as e:
-            logger.debug(f"获取变量信息失败: {e}")
-            return None
-
-    @staticmethod
-    def _get_variable_name(obj):
-        """
-        尝试获取变量名
-        """
-        try:
-            # 尝试通过gc获取引用该对象的变量名
-            referrers = gc.get_referrers(obj)
-
-            for referrer in referrers:
-                if isinstance(referrer, dict):
-                    # 检查是否在某个模块的全局变量中
-                    for name, value in referrer.items():
-                        if value is obj and isinstance(name, str):
-                            return name
-                elif hasattr(referrer, '__dict__'):
-                    # 检查是否在某个实例的属性中
-                    for name, value in referrer.__dict__.items():
-                        if value is obj and isinstance(name, str):
-                            return f"{type(referrer).__name__}.{name}"
-
-            # 如果找不到变量名，返回对象类型和id
-            return f"{type(obj).__name__}_{id(obj)}"
-
-        except Exception as e:
-            logger.debug(f"获取变量名失败: {e}")
-            return f"{type(obj).__name__}_{id(obj)}"

app/helper/message.py

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

app/helper/ocr.py

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

app/helper/plugin.py

@@ -1,15 +1,16 @@
-import sys
+import importlib
 import json
 import shutil
-import traceback
 import site
-import importlib
+import sys
+import traceback
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Set
+from typing import Dict, List, Optional, Tuple, Set
 
 from packaging.specifiers import SpecifierSet, InvalidSpecifier
 from packaging.version import Version, InvalidVersion
 from pkg_resources import Requirement, working_set
+from requests import Response
 
 from app.core.cache import cached
 from app.core.config import settings
@@ -17,14 +18,14 @@ from app.db.systemconfig_oper import SystemConfigOper
 from app.log import logger
 from app.schemas.types import SystemConfigKey
 from app.utils.http import RequestUtils
-from app.utils.singleton import Singleton
+from app.utils.singleton import WeakSingleton
 from app.utils.system import SystemUtils
 from app.utils.url import UrlUtils
 
 PLUGIN_DIR = Path(settings.ROOT_PATH) / "app" / "plugins"
 
 
-class PluginHelper(metaclass=Singleton):
+class PluginHelper(metaclass=WeakSingleton):
     """
     插件市场管理，下载安装插件到本地
     """
@@ -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}"
@@ -651,10 +649,20 @@ class PluginHelper(metaclass=Singleton):
         """
         dependencies = {}
         try:
+            install_plugins = {
+                plugin_id.lower()  # 对应插件的小写目录名
+                for plugin_id in SystemConfigOper().get(
+                    SystemConfigKey.UserInstalledPlugins
+                ) or []
+            }
             for plugin_dir in PLUGIN_DIR.iterdir():
                 if plugin_dir.is_dir():
                     requirements_file = plugin_dir / "requirements.txt"
                     if requirements_file.exists():
+                        if plugin_dir.name not in install_plugins:
+                            # 这个插件不在安装列表中 忽略它的依赖
+                            logger.debug(f"忽略插件 {plugin_dir.name} 的依赖")
+                            continue
                         # 解析当前插件的 requirements.txt，获取依赖项
                         plugin_deps = self.__parse_requirements(requirements_file)
                         for pkg_name, version_specifiers in plugin_deps.items():

app/helper/progress.py

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

app/helper/resource.py

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

app/helper/rss.py

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

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

app/helper/system.py

@@ -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/torrent.py

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

app/helper/wallpaper.py

@@ -18,14 +18,14 @@ class WallpaperHelper(metaclass=Singleton):
         获取登录页面壁纸
         """
         if settings.WALLPAPER == "bing":
-            url = self.get_bing_wallpaper()
+            return self.get_bing_wallpaper()
         elif settings.WALLPAPER == "mediaserver":
-            url = self.get_mediaserver_wallpaper()
+            return self.get_mediaserver_wallpaper()
         elif settings.WALLPAPER == "customize":
-            url = self.get_customize_wallpaper()
-        else:
-            url = self.get_tmdb_wallpaper()
-        return url
+            return self.get_customize_wallpaper()
+        elif settings.WALLPAPER == "tmdb":
+            return self.get_tmdb_wallpaper()
+        return ''
 
     def get_wallpapers(self, num: int = 10) -> List[str]:
         """
@@ -37,8 +37,9 @@ class WallpaperHelper(metaclass=Singleton):
             return self.get_mediaserver_wallpapers(num)
         elif settings.WALLPAPER == "customize":
             return self.get_customize_wallpapers()
-        else:
+        elif settings.WALLPAPER == "tmdb":
             return self.get_tmdb_wallpapers(num)
+        return []
 
     @cached(maxsize=1, ttl=3600)
     def get_tmdb_wallpaper(self) -> Optional[str]:

app/helper/workflow.py

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

app/main.py

@@ -1,5 +1,6 @@
 import multiprocessing
 import os
+import setproctitle
 import signal
 import sys
 import threading
@@ -19,6 +20,9 @@ if SystemUtils.is_frozen():
 from app.core.config import settings
 from app.db.init import init_db, update_db
 
+# 设置进程名
+setproctitle.setproctitle(settings.PROJECT_NAME)
+
 # uvicorn服务
 Server = uvicorn.Server(Config(app, host=settings.HOST, port=settings.PORT,
                                reload=settings.DEV, workers=multiprocessing.cpu_count(),
@@ -83,7 +87,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)
@@ -210,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 []

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

@@ -12,10 +12,10 @@ import requests
 from app.core.cache import cached
 from app.core.config import settings
 from app.utils.http import RequestUtils
-from app.utils.singleton import Singleton
+from app.utils.singleton import WeakSingleton
 
 
-class DoubanApi(metaclass=Singleton):
+class DoubanApi(metaclass=WeakSingleton):
     _urls = {
         # 搜索类
         # sort=U:近期热门 T:标记最多 S:评分最高 R:最新上映
@@ -151,7 +151,6 @@ class DoubanApi(metaclass=Singleton):
     _api_key2 = "0ab215a8b1977939201640fa14c66bab"
     _base_url = "https://frodo.douban.com/api/v2"
     _api_url = "https://api.douban.com/v2"
-    _session = None
 
     def __init__(self):
         self._session = requests.Session()
@@ -171,14 +170,14 @@ class DoubanApi(metaclass=Singleton):
             ).digest()
         ).decode()
 
-    @cached(maxsize=settings.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 +212,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请求
@@ -235,7 +234,7 @@ class DoubanApi(metaclass=Singleton):
         if '_ts' in params:
             params.pop('_ts')
         resp = RequestUtils(
-            ua=settings.USER_AGENT,
+            ua=settings.NORMAL_USER_AGENT,
             session=self._session,
         ).post_res(url=req_url, data=params)
         if resp is not None and resp.status_code == 400 and "rate_limit" in resp.text:

app/modules/douban/douban_cache.py

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

app/modules/emby/__init__.py

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

app/modules/emby/emby.py

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

app/modules/fanart/__init__.py

@@ -399,28 +399,30 @@ class FanartModule(_ModuleBase):
                         if not mediainfo.get_image(season_image):
                             mediainfo.set_image(season_image, image_obj.get('url'))
             else:
+
                 # 其他图片，优先环境变量指定语言，再like最多
-                def pick_best_image(images):
+                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]
+                            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']
+                    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']
+                    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)
+                    _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'))
@@ -438,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

@@ -1,6 +1,7 @@
 from pathlib import Path
 from typing import Optional, List, Tuple, Union, Dict, Callable
 
+from app.chain.tmdb import TmdbChain
 from app.core.config import settings
 from app.core.context import MediaInfo
 from app.core.meta import MetaBase
@@ -139,16 +140,32 @@ class FileManagerModule(_ModuleBase):
         """
         handler = TransHandler()
         # 重命名格式
-        rename_format = settings.TV_RENAME_FORMAT \
-            if mediainfo.type == MediaType.TV else settings.MOVIE_RENAME_FORMAT
+        rename_format = settings.RENAME_FORMAT(mediainfo.type)
+        # 获取集信息
+        episodes_info: Optional[List[TmdbEpisode]] = None
+        if mediainfo.type == MediaType.TV:
+            # 判断注意season为0的情况
+            season_num = mediainfo.season
+            if season_num is None and meta.season_seq:
+                if meta.season_seq.isdigit():
+                    season_num = int(meta.season_seq)
+            # 默认值1
+            if season_num is None:
+                season_num = 1
+            episodes_info = TmdbChain().tmdb_episodes(
+                tmdbid=mediainfo.tmdb_id,
+                season=season_num,
+                episode_group=mediainfo.episode_group,
+            )
         # 获取重命名后的名称
         path = handler.get_rename_path(
             template_string=rename_format,
             rename_dict=handler.get_naming_dict(meta=meta,
                                                 mediainfo=mediainfo,
+                                                episodes_info=episodes_info,
                                                 file_ext=Path(meta.title).suffix)
         )
-        return str(path)
+        return path.as_posix() if path else ""
 
     def save_config(self, storage: str, conf: Dict) -> None:
         """
@@ -344,9 +361,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 +376,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]:
         """
@@ -406,6 +428,12 @@ class FileManagerModule(_ModuleBase):
                                 message=f"{target_path} 不是有效目录")
         # 获取目标路径
         if target_directory:
+            # 目标媒体库目录未设置
+            if not target_directory.library_path:
+                logger.error(f"目标媒体库目录未设置，无法整理文件，源路径：{fileitem.path}")
+                return TransferInfo(success=False,
+                                    fileitem=fileitem,
+                                    message="目标媒体库目录未设置")
             # 整理方式
             if not transfer_type:
                 transfer_type = target_directory.transfer_type
@@ -505,19 +533,35 @@ class FileManagerModule(_ModuleBase):
             # 媒体分类路径
             dir_path = handler.get_dest_dir(mediainfo=mediainfo, target_dir=dest_dir)
             # 重命名格式
-            rename_format = settings.TV_RENAME_FORMAT \
-                if mediainfo.type == MediaType.TV else settings.MOVIE_RENAME_FORMAT
+            rename_format = settings.RENAME_FORMAT(mediainfo.type)
+            # 元数据补上常用属性，尽可能确保重命名后的路径不出现空白
+            meta = MetaInfo(mediainfo.title)
+            if meta.type == MediaType.UNKNOWN and mediainfo.type is not None:
+                meta.type = mediainfo.type
+            if meta.year is None:
+                meta.year = mediainfo.year
+            if meta.begin_season is None:
+                meta.begin_season = 1
+            if meta.begin_episode is None:
+                meta.begin_episode = 1
             # 获取路径（重命名路径）
             target_path = handler.get_rename_path(
                 path=dir_path,
                 template_string=rename_format,
-                rename_dict=handler.get_naming_dict(meta=MetaInfo(mediainfo.title),
+                rename_dict=handler.get_naming_dict(meta=meta,
                                                     mediainfo=mediainfo)
             )
-            # 计算重命名中的文件夹层数
-            rename_format_level = len(rename_format.split("/")) - 1
-            # 取相对路径的第1层目录
-            media_path = target_path.parents[rename_format_level - 1]
+            # 获取重命名后的媒体文件根路径
+            media_path = DirectoryHelper.get_media_root_path(
+                rename_format, rename_path=target_path
+            )
+            if not media_path:
+                # 忽略
+                continue
+            if dir_path != media_path and dir_path.is_relative_to(media_path):
+                # 兜底检查，避免不必要的扫盘
+                logger.warn(f"{media_path} 是媒体库目录 {dir_path} 的父目录，忽略获取媒体文件列表，请检查重命名格式！")
+                continue
             # 检索媒体文件
             fileitem = storage_oper.get_item(media_path)
             if not fileitem:
@@ -543,9 +587,12 @@ class FileManagerModule(_ModuleBase):
         if not settings.LOCAL_EXISTS_SEARCH:
             return None
 
+        logger.debug(f"正在本地媒体库中查找 {mediainfo.title_year}...")
+
         # 检查媒体库
         fileitems = self.media_files(mediainfo)
         if not fileitems:
+            logger.debug(f"{mediainfo.title_year} 不在本地媒体库中")
             return None
 
         if mediainfo.type == MediaType.MOVIE:

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):
@@ -12,6 +13,7 @@ class StorageBase(metaclass=ABCMeta):
     """
     schema = None
     transtype = {}
+    snapshot_check_folder_modtime = True
 
     def __init__(self):
         self.storagehelper = StorageHelper()
@@ -135,7 +137,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 +195,47 @@ 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 (self.snapshot_check_folder_modtime and
+                            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:
+                    # 记录文件的完整信息用于比对
+                    if getattr(_fileitm, 'modify_time', 0) > last_snapshot_time:
+                        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
@@ -15,7 +15,7 @@ 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
+from app.utils.singleton import WeakSingleton
 from app.utils.string import StringUtils
 
 lock = threading.Lock()
@@ -29,7 +29,7 @@ class SessionInvalidException(Exception):
     pass
 
 
-class AliPan(StorageBase, metaclass=Singleton):
+class AliPan(StorageBase, metaclass=WeakSingleton):
     """
     阿里云盘相关操作
     """
@@ -43,20 +43,12 @@ class AliPan(StorageBase, metaclass=Singleton):
         "copy": "复制"
     }
 
-    # 验证参数
-    _auth_state = {}
-
-    # 上传进度值
-    _last_progress = 0
-
     # 基础url
     base_url = "https://openapi.alipan.com"
 
-    # CID和路径缓存
-    _id_cache: Dict[str, Tuple[str, str]] = {}
-
     def __init__(self):
         super().__init__()
+        self._auth_state = {}
         self.session = requests.Session()
         self._init_session()
 
@@ -247,6 +239,7 @@ class AliPan(StorageBase, metaclass=Singleton):
         conf = self.get_conf()
         conf.update(result)
         self.set_config(conf)
+        return None
 
     def _request_api(self, method: str, endpoint: str,
                      result_key: Optional[str] = None, **kwargs) -> Optional[Union[dict, list]]:
@@ -279,61 +272,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,10 +365,7 @@ 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))
+                items.append(self.__get_fileitem(item, parent=str(fileitem.path)))
             if len(resp.get("items")) < 100:
                 break
         return items
@@ -467,7 +402,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 +771,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,8 +782,8 @@ class AliPan(StorageBase, metaclass=Singleton):
                 "POST",
                 "/adrive/v1.0/openFile/get_by_path",
                 json={
-                    "drive_id": self._default_drive_id,
-                    "file_path": str(path)
+                    "drive_id": drive_id or self._default_drive_id,
+                    "file_path": path.as_posix()
                 }
             )
             if not resp:
@@ -910,9 +838,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 +854,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 +866,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 +887,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 +896,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
@@ -13,14 +12,14 @@ from app.log import logger
 from app.modules.filemanager.storages import StorageBase
 from app.schemas.types import StorageSchema
 from app.utils.http import RequestUtils
-from app.utils.singleton import Singleton
+from app.utils.singleton import WeakSingleton
 from app.utils.url import UrlUtils
 
 
-class Alist(StorageBase, metaclass=Singleton):
+class Alist(StorageBase, metaclass=WeakSingleton):
     """
     Alist相关操作
-    api文档：https://alist.nn.ci/zh/guide/api
+    api文档：https://oplist.org/zh/
     """
 
     # 存储类型
@@ -32,6 +31,8 @@ class Alist(StorageBase, metaclass=Singleton):
         "move": "移动",
     }
 
+    snapshot_check_folder_modtime = settings.OPENLIST_SNAPSHOT_CHECK_FOLDER_MODTIME
+
     def __init__(self):
         super().__init__()
 
@@ -39,7 +40,7 @@ class Alist(StorageBase, metaclass=Singleton):
         """
         初始化
         """
-        pass
+        self.__generate_token.clear_cache()  # noqa
 
     @property
     def __get_base_url(self) -> str:
@@ -77,7 +78,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 +103,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 +129,7 @@ class Alist(StorageBase, metaclass=Singleton):
         """
         检查存储是否可用
         """
-        pass
+        return True if self.__generate_token else False
 
     def list(
             self,
@@ -151,7 +152,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 +201,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 +213,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 +241,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 +259,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 +305,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 +349,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(
@@ -377,11 +378,47 @@ class Alist(StorageBase, metaclass=Singleton):
         """
         return self.get_folder(Path(fileitem.path).parent)
 
+    def __is_empty_dir(self, fileitem: schemas.FileItem) -> bool:
+        """
+        判断目录是否为空
+        """
+        if fileitem.type != "dir":
+            return False
+        # 获取目录内容
+        items = self.list(fileitem)
+        return len(items) == 0
+
     def delete(self, fileitem: schemas.FileItem) -> bool:
         """
-        删除文件
+        删除文件或目录，空目录用专用API
         """
-        resp: Response = RequestUtils(
+        # 如果是空目录，优先用 remove_empty_directory
+        if fileitem.type == "dir" and self.__is_empty_dir(fileitem):
+            resp = RequestUtils(
+                headers=self.__get_header_with_token()
+            ).post_res(
+                self.__get_api_url("/api/fs/remove_empty_directory"),
+                json={
+                    "src_dir": fileitem.path,
+                },
+            )
+            if resp is None:
+                logger.warn(f"【OpenList】请求删除空目录 {fileitem.path} 失败，无法连接alist服务")
+                return False
+            if resp.status_code != 200:
+                logger.warn(
+                    f"【OpenList】请求删除空目录 {fileitem.path} 失败，状态码：{resp.status_code}"
+                )
+                return False
+            result = resp.json()
+            if result["code"] != 200:
+                logger.warn(
+                    f'【OpenList】删除空目录 {fileitem.path} 失败，错误信息：{result["message"]}'
+                )
+                return False
+            return True
+        # 其它情况（文件或非空目录）
+        resp = RequestUtils(
             headers=self.__get_header_with_token()
         ).post_res(
             self.__get_api_url("/api/fs/remove"),
@@ -390,33 +427,18 @@ class Alist(StorageBase, metaclass=Singleton):
                 "names": [fileitem.name],
             },
         )
-        """
-        {
-            "names": [
-                "string"
-            ],
-            "dir": "string"
-        }
-        ======================================
-        {
-            "code": 200,
-            "message": "success",
-            "data": null
-        }
-        """
         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 +447,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 +469,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 +498,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 +534,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 +583,16 @@ 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 is None:
+            logger.warn(f"【OpenList】请求上传文件 {path} 失败")
+            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
 
         new_item = self.get_item(Path(fileitem.path) / path.name)
@@ -590,7 +615,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 +642,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 +674,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 +701,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 +736,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

@@ -44,7 +44,7 @@ class LocalStorage(StorageBase):
         return schemas.FileItem(
             storage=self.schema.value,
             type="file",
-            path=str(path).replace("\\", "/"),
+            path=path.as_posix(),
             name=path.name,
             basename=path.stem,
             extension=path.suffix[1:],
@@ -59,7 +59,7 @@ class LocalStorage(StorageBase):
         return schemas.FileItem(
             storage=self.schema.value,
             type="dir",
-            path=str(path).replace("\\", "/") + "/",
+            path=path.as_posix() + "/",
             name=path.name,
             basename=path.stem,
             modify_time=path.stat().st_mtime,
@@ -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/rclone.py

@@ -26,6 +26,8 @@ class Rclone(StorageBase):
         "copy": "复制"
     }
 
+    snapshot_check_folder_modtime = settings.RCLONE_SNAPSHOT_CHECK_FOLDER_MODTIME
+
     def init_storage(self):
         """
         初始化
@@ -267,7 +269,7 @@ class Rclone(StorageBase):
             retcode = subprocess.run(
                 [
                     'rclone', 'copyto',
-                    str(path),
+                    path.as_posix(),
                     f'MP:{new_path}'
                 ],
                 startupinfo=self.__get_hidden_shell()

app/modules/filemanager/storages/smb.py

@@ -0,0 +1,551 @@
+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 WeakSingleton
+
+lock = threading.Lock()
+
+
+class SMBConnectionError(Exception):
+    """
+    SMB 连接错误
+    """
+    pass
+
+
+class SMB(StorageBase, metaclass=WeakSingleton):
+    """
+    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
@@ -18,7 +18,7 @@ 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
+from app.utils.singleton import WeakSingleton
 from app.utils.string import StringUtils
 
 lock = threading.Lock()
@@ -28,7 +28,7 @@ class NoCheckInException(Exception):
     pass
 
 
-class U115Pan(StorageBase, metaclass=Singleton):
+class U115Pan(StorageBase, metaclass=WeakSingleton):
     """
     115相关操作
     """
@@ -41,21 +41,12 @@ class U115Pan(StorageBase, metaclass=Singleton):
         "move": "移动",
         "copy": "复制"
     }
-
-    # 验证参数
-    _auth_state = {}
-
-    # 上传进度值
-    _last_progress = 0
-
     # 基础url
     base_url = "https://proapi.115.com"
 
-    # CID和路径缓存
-    _id_cache: Dict[str, str] = {}
-
     def __init__(self):
         super().__init__()
+        self._auth_state = {}
         self.session = requests.Session()
         self._init_session()
 
@@ -222,8 +213,11 @@ class U115Pan(StorageBase, metaclass=Singleton):
 
         # 处理速率限制
         if resp.status_code == 429:
-            reset_time = int(resp.headers.get("X-RateLimit-Reset", 60))
-            time.sleep(reset_time + 5)
+            reset_time = 5 + int(resp.headers.get("X-RateLimit-Reset", 60))
+            logger.debug(
+                f"【115】{method} 请求 {endpoint} 限流，等待{reset_time}秒后重试"
+            )
+            time.sleep(reset_time)
             return self._request_api(method, endpoint, result_key, **kwargs)
 
         # 处理请求错误
@@ -238,58 +232,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 +277,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 +300,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 +342,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"]),
@@ -544,7 +486,8 @@ class U115Pan(StorageBase, metaclass=Singleton):
                         type="file" if info_resp["file_category"] == "1" else "dir",
                         name=info_resp["file_name"],
                         basename=Path(info_resp["file_name"]).stem,
-                        extension=Path(info_resp["file_name"]).suffix[1:] if info_resp["file_category"] == "1" else None,
+                        extension=Path(info_resp["file_name"]).suffix[1:] if info_resp[
+                                                                                 "file_category"] == "1" else None,
                         pickcode=info_resp["pick_code"],
                         size=StringUtils.num_filesize(info_resp['size']) if info_resp["file_category"] == "1" else None,
                         modify_time=info_resp["utime"]
@@ -716,13 +659,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 +667,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": path.as_posix()
                 }
             )
             if not resp:
@@ -747,13 +680,13 @@ class U115Pan(StorageBase, metaclass=Singleton):
             return schemas.FileItem(
                 storage=self.schema.value,
                 fileid=str(resp["file_id"]),
-                path=str(path) + ("/" if resp["file_category"] == "0" else ""),
+                path=path.as_posix() + ("/" if resp["file_category"] == "0" else ""),
                 type="file" if resp["file_category"] == "1" else "dir",
                 name=resp["file_name"],
                 basename=Path(resp["file_name"]).stem,
                 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:
@@ -804,15 +737,22 @@ class U115Pan(StorageBase, metaclass=Singleton):
         """
         企业级复制实现（支持目录递归复制）
         """
-        src_fid = fileitem.fileid
-        dest_cid = self._path_to_id(str(path))
+        if fileitem.fileid is None:
+            fileitem = self.get_item(Path(fileitem.path))
+            if not fileitem:
+                logger.warn(f"【115】获取文件 {fileitem.path} 失败！")
+                return False
+        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)
+                "file_id": int(fileitem.fileid),
+                "pid": int(dest_fileitem.fileid),
             }
         )
         if not resp:
@@ -821,10 +761,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
 
@@ -832,15 +768,21 @@ class U115Pan(StorageBase, metaclass=Singleton):
         """
         原子性移动操作实现
         """
-        src_fid = fileitem.fileid
-        dest_cid = self._path_to_id(str(path))
-
+        if fileitem.fileid is None:
+            fileitem = self.get_item(Path(fileitem.path))
+            if not fileitem:
+                logger.warn(f"【115】获取文件 {fileitem.path} 失败！")
+                return False
+        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)
+                "file_ids": int(fileitem.fileid),
+                "to_cid": int(dest_fileitem.fileid),
             }
         )
         if not resp:
@@ -849,10 +791,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/filemanager/transhandler.py

@@ -10,6 +10,7 @@ from app.core.context import MediaInfo
 from app.core.event import eventmanager
 from app.core.meta import MetaBase
 from app.core.metainfo import MetaInfoPath
+from app.helper.directory import DirectoryHelper
 from app.helper.message import TemplateHelper
 from app.log import logger
 from app.modules.filemanager.storages import StorageBase
@@ -26,11 +27,10 @@ class TransHandler:
     文件转移整理类
     """
 
-    result: Optional[TransferInfo] = None
     inner_lock: Lock = Lock()
 
     def __init__(self):
-        self.__reset_result()
+        self.result = None
 
     def __reset_result(self):
         """
@@ -103,185 +103,211 @@ class TransHandler:
         # 重置结果
         self.__reset_result()
 
-        # 重命名格式
-        rename_format = settings.TV_RENAME_FORMAT \
-            if mediainfo.type == MediaType.TV else settings.MOVIE_RENAME_FORMAT
+        try:
 
-        # 判断是否为文件夹
-        if fileitem.type == "dir":
-            # 整理整个目录，一般为蓝光原盘
-            if need_rename:
-                new_path = self.get_rename_path(
-                    path=target_path,
-                    template_string=rename_format,
-                    rename_dict=self.get_naming_dict(meta=in_meta,
-                                                     mediainfo=mediainfo)
-                ).parent
-            else:
-                new_path = target_path / fileitem.name
-            # 整理目录
-            new_diritem, errmsg = self.__transfer_dir(fileitem=fileitem,
-                                                      mediainfo=mediainfo,
-                                                      source_oper=source_oper,
-                                                      target_oper=target_oper,
-                                                      target_storage=target_storage,
-                                                      target_path=new_path,
-                                                      transfer_type=transfer_type)
-            if not new_diritem:
-                logger.error(f"文件夹 {fileitem.path} 整理失败：{errmsg}")
-                self.__set_result(success=False,
-                                  message=errmsg,
-                                  fileitem=fileitem,
-                                  transfer_type=transfer_type,
-                                  need_notify=need_notify)
-                return self.result
+            # 重命名格式
+            rename_format = settings.RENAME_FORMAT(mediainfo.type)
 
-            logger.info(f"文件夹 {fileitem.path} 整理成功")
-            # 计算目录下所有文件大小
-            total_size = sum(file.stat().st_size for file in Path(fileitem.path).rglob('*') if file.is_file())
-            # 返回整理后的路径
-            self.__set_result(success=True,
-                              fileitem=fileitem,
-                              target_item=new_diritem,
-                              target_diritem=new_diritem,
-                              total_size=total_size,
-                              need_scrape=need_scrape,
-                              need_notify=need_notify,
-                              transfer_type=transfer_type)
-            return self.result
-        else:
-            # 整理单个文件
-            if mediainfo.type == MediaType.TV:
-                # 电视剧
-                if in_meta.begin_episode is None:
-                    logger.warn(f"文件 {fileitem.path} 整理失败：未识别到文件集数")
+            # 判断是否为文件夹
+            if fileitem.type == "dir":
+                # 整理整个目录，一般为蓝光原盘
+                if need_rename:
+                    new_path = self.get_rename_path(
+                        path=target_path,
+                        template_string=rename_format,
+                        rename_dict=self.get_naming_dict(meta=in_meta,
+                                                         mediainfo=mediainfo)
+                    )
+                    new_path = DirectoryHelper.get_media_root_path(
+                        rename_format, rename_path=new_path
+                    )
+                    if not new_path:
+                        self.__set_result(
+                            success=False,
+                            message="重命名格式无效",
+                            fileitem=fileitem,
+                            transfer_type=transfer_type,
+                            need_notify=need_notify,
+                        )
+                        return self.result.copy()
+                else:
+                    new_path = target_path / fileitem.name
+                # 整理目录
+                new_diritem, errmsg = self.__transfer_dir(fileitem=fileitem,
+                                                          mediainfo=mediainfo,
+                                                          source_oper=source_oper,
+                                                          target_oper=target_oper,
+                                                          target_storage=target_storage,
+                                                          target_path=new_path,
+                                                          transfer_type=transfer_type)
+                if not new_diritem:
+                    logger.error(f"文件夹 {fileitem.path} 整理失败：{errmsg}")
                     self.__set_result(success=False,
-                                      message=f"未识别到文件集数",
+                                      message=errmsg,
+                                      fileitem=fileitem,
+                                      transfer_type=transfer_type,
+                                      need_notify=need_notify)
+                    return self.result.copy()
+
+                logger.info(f"文件夹 {fileitem.path} 整理成功")
+                # 计算目录下所有文件大小
+                total_size = sum(file.stat().st_size for file in Path(fileitem.path).rglob('*') if file.is_file())
+                # 返回整理后的路径
+                self.__set_result(success=True,
+                                  fileitem=fileitem,
+                                  target_item=new_diritem,
+                                  target_diritem=new_diritem,
+                                  total_size=total_size,
+                                  need_scrape=need_scrape,
+                                  need_notify=need_notify,
+                                  transfer_type=transfer_type)
+                return self.result.copy()
+            else:
+                # 整理单个文件
+                if mediainfo.type == MediaType.TV:
+                    # 电视剧
+                    if in_meta.begin_episode is None:
+                        logger.warn(f"文件 {fileitem.path} 整理失败：未识别到文件集数")
+                        self.__set_result(success=False,
+                                          message="未识别到文件集数",
+                                          fileitem=fileitem,
+                                          fail_list=[fileitem.path],
+                                          transfer_type=transfer_type,
+                                          need_notify=need_notify)
+                        return self.result.copy()
+
+                    # 文件结束季为空
+                    in_meta.end_season = None
+                    # 文件总季数为1
+                    if in_meta.total_season:
+                        in_meta.total_season = 1
+                    # 文件不可能超过2集
+                    if in_meta.total_episode > 2:
+                        in_meta.total_episode = 1
+                        in_meta.end_episode = None
+
+                # 目的文件名
+                if need_rename:
+                    new_file = self.get_rename_path(
+                        path=target_path,
+                        template_string=rename_format,
+                        rename_dict=self.get_naming_dict(
+                            meta=in_meta,
+                            mediainfo=mediainfo,
+                            episodes_info=episodes_info,
+                            file_ext=f".{fileitem.extension}"
+                        )
+                    )
+                    folder_path = DirectoryHelper.get_media_root_path(
+                        rename_format, rename_path=new_file
+                    )
+                    if not folder_path:
+                        self.__set_result(
+                            success=False,
+                            message="重命名格式无效",
+                            fileitem=fileitem,
+                            fail_list=[fileitem.path],
+                            transfer_type=transfer_type,
+                            need_notify=need_notify,
+                        )
+                        return self.result.copy()
+                else:
+                    new_file = target_path / fileitem.name
+                    folder_path = target_path
+
+                # 判断是否要覆盖
+                overflag = False
+                # 目标目录
+                target_diritem = target_oper.get_folder(folder_path)
+                if not target_diritem:
+                    logger.error(f"目标目录 {folder_path} 获取失败")
+                    self.__set_result(success=False,
+                                      message=f"目标目录 {folder_path} 获取失败",
                                       fileitem=fileitem,
                                       fail_list=[fileitem.path],
                                       transfer_type=transfer_type,
                                       need_notify=need_notify)
-                    return self.result
-
-                # 文件结束季为空
-                in_meta.end_season = None
-                # 文件总季数为1
-                if in_meta.total_season:
-                    in_meta.total_season = 1
-                # 文件不可能超过2集
-                if in_meta.total_episode > 2:
-                    in_meta.total_episode = 1
-                    in_meta.end_episode = None
-
-            # 目的文件名
-            if need_rename:
-                new_file = self.get_rename_path(
-                    path=target_path,
-                    template_string=rename_format,
-                    rename_dict=self.get_naming_dict(
-                        meta=in_meta,
-                        mediainfo=mediainfo,
-                        episodes_info=episodes_info,
-                        file_ext=f".{fileitem.extension}"
-                    )
-                )
-            else:
-                new_file = target_path / fileitem.name
-
-            # 判断是否要覆盖
-            overflag = False
-            # 计算重命名中的文件夹层级
-            rename_format_level = len(rename_format.split("/")) - 1
-            folder_path = new_file.parents[rename_format_level - 1]
-            # 目标目录
-            target_diritem = target_oper.get_folder(folder_path)
-            if not target_diritem:
-                logger.error(f"目标目录 {folder_path} 获取失败")
-                self.__set_result(success=False,
-                                  message=f"目标目录 {folder_path} 获取失败",
-                                  fileitem=fileitem,
-                                  fail_list=[fileitem.path],
-                                  transfer_type=transfer_type,
-                                  need_notify=need_notify)
-                return self.result
-            # 目标文件
-            target_item = target_oper.get_item(new_file)
-            if target_item:
-                # 目标文件已存在
-                target_file = new_file
-                if target_storage == "local" and new_file.is_symlink():
-                    target_file = new_file.readlink()
-                    if not target_file.exists():
-                        overflag = True
-                if not overflag:
+                    return self.result.copy()
+                # 目标文件
+                target_item = target_oper.get_item(new_file)
+                if target_item:
                     # 目标文件已存在
-                    logger.info(f"目的文件系统中已经存在同名文件 {target_file}，当前整理覆盖模式设置为 {overwrite_mode}")
-                    if overwrite_mode == 'always':
-                        # 总是覆盖同名文件
-                        overflag = True
-                    elif overwrite_mode == 'size':
-                        # 存在时大覆盖小
-                        if target_item.size < fileitem.size:
-                            logger.info(f"目标文件文件大小更小，将覆盖：{new_file}")
+                    target_file = new_file
+                    if target_storage == "local" and new_file.is_symlink():
+                        target_file = new_file.readlink()
+                        if not target_file.exists():
                             overflag = True
-                        else:
+                    if not overflag:
+                        # 目标文件已存在
+                        logger.info(f"目的文件系统中已经存在同名文件 {target_file}，当前整理覆盖模式设置为 {overwrite_mode}")
+                        if overwrite_mode == 'always':
+                            # 总是覆盖同名文件
+                            overflag = True
+                        elif overwrite_mode == 'size':
+                            # 存在时大覆盖小
+                            if target_item.size < fileitem.size:
+                                logger.info(f"目标文件文件大小更小，将覆盖：{new_file}")
+                                overflag = True
+                            else:
+                                self.__set_result(success=False,
+                                                  message=f"媒体库存在同名文件，且质量更好",
+                                                  fileitem=fileitem,
+                                                  target_item=target_item,
+                                                  target_diritem=target_diritem,
+                                                  fail_list=[fileitem.path],
+                                                  transfer_type=transfer_type,
+                                                  need_notify=need_notify)
+                                return self.result.copy()
+                        elif overwrite_mode == 'never':
+                            # 存在不覆盖
                             self.__set_result(success=False,
-                                              message=f"媒体库存在同名文件，且质量更好",
+                                              message=f"媒体库存在同名文件，当前覆盖模式为不覆盖",
                                               fileitem=fileitem,
                                               target_item=target_item,
                                               target_diritem=target_diritem,
                                               fail_list=[fileitem.path],
                                               transfer_type=transfer_type,
                                               need_notify=need_notify)
-                            return self.result
-                    elif overwrite_mode == 'never':
-                        # 存在不覆盖
-                        self.__set_result(success=False,
-                                          message=f"媒体库存在同名文件，当前覆盖模式为不覆盖",
-                                          fileitem=fileitem,
-                                          target_item=target_item,
-                                          target_diritem=target_diritem,
-                                          fail_list=[fileitem.path],
-                                          transfer_type=transfer_type,
-                                          need_notify=need_notify)
-                        return self.result
-                    elif overwrite_mode == 'latest':
-                        # 仅保留最新版本
-                        logger.info(f"当前整理覆盖模式设置为仅保留最新版本，将覆盖：{new_file}")
-                        overflag = True
-            else:
-                if overwrite_mode == 'latest':
-                    # 文件不存在，但仅保留最新版本
-                    logger.info(f"当前整理覆盖模式设置为 {overwrite_mode}，仅保留最新版本，正在删除已有版本文件 ...")
-                    self.__delete_version_files(target_oper, new_file)
-            # 整理文件
-            new_item, err_msg = self.__transfer_file(fileitem=fileitem,
-                                                     mediainfo=mediainfo,
-                                                     target_storage=target_storage,
-                                                     target_file=new_file,
-                                                     transfer_type=transfer_type,
-                                                     over_flag=overflag,
-                                                     source_oper=source_oper,
-                                                     target_oper=target_oper)
-            if not new_item:
-                logger.error(f"文件 {fileitem.path} 整理失败：{err_msg}")
-                self.__set_result(success=False,
-                                  message=err_msg,
+                            return self.result.copy()
+                        elif overwrite_mode == 'latest':
+                            # 仅保留最新版本
+                            logger.info(f"当前整理覆盖模式设置为仅保留最新版本，将覆盖：{new_file}")
+                            overflag = True
+                else:
+                    if overwrite_mode == 'latest':
+                        # 文件不存在，但仅保留最新版本
+                        logger.info(f"当前整理覆盖模式设置为 {overwrite_mode}，仅保留最新版本，正在删除已有版本文件 ...")
+                        self.__delete_version_files(target_oper, new_file)
+                # 整理文件
+                new_item, err_msg = self.__transfer_file(fileitem=fileitem,
+                                                         mediainfo=mediainfo,
+                                                         target_storage=target_storage,
+                                                         target_file=new_file,
+                                                         transfer_type=transfer_type,
+                                                         over_flag=overflag,
+                                                         source_oper=source_oper,
+                                                         target_oper=target_oper)
+                if not new_item:
+                    logger.error(f"文件 {fileitem.path} 整理失败：{err_msg}")
+                    self.__set_result(success=False,
+                                      message=err_msg,
+                                      fileitem=fileitem,
+                                      fail_list=[fileitem.path],
+                                      transfer_type=transfer_type,
+                                      need_notify=need_notify)
+                    return self.result.copy()
+
+                logger.info(f"文件 {fileitem.path} 整理成功")
+                self.__set_result(success=True,
                                   fileitem=fileitem,
-                                  fail_list=[fileitem.path],
+                                  target_item=new_item,
+                                  target_diritem=target_diritem,
+                                  need_scrape=need_scrape,
                                   transfer_type=transfer_type,
                                   need_notify=need_notify)
-                return self.result
-
-            logger.info(f"文件 {fileitem.path} 整理成功")
-            self.__set_result(success=True,
-                              fileitem=fileitem,
-                              target_item=new_item,
-                              target_diritem=target_diritem,
-                              need_scrape=need_scrape,
-                              transfer_type=transfer_type,
-                              need_notify=need_notify)
-            return self.result
+                return self.result.copy()
+        finally:
+            self.result = None
 
     @staticmethod
     def __transfer_command(fileitem: FileItem, target_storage: str,
@@ -304,7 +330,7 @@ class TransHandler:
             """
             return FileItem(
                 storage=target_storage,
-                path=str(_path).replace("\\", "/"),
+                path=_path.as_posix(),
                 name=_path.name,
                 basename=_path.stem,
                 type="file",

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

@@ -1,3 +1,5 @@
+import random
+import time
 from datetime import datetime
 from typing import List, Optional, Tuple, Union
 
@@ -5,10 +7,11 @@ from app.core.config import settings
 from app.core.context import TorrentInfo
 from app.db.site_oper import SiteOper
 from app.helper.module import ModuleHelper
-from app.helper.sites import SitesHelper, SiteSpider
+from app.helper.sites import SitesHelper
 from app.log import logger
 from app.modules import _ModuleBase
 from app.modules.indexer.parser import SiteParserBase
+from app.modules.indexer.spider import SiteSpider
 from app.modules.indexer.spider.haidan import HaiDanSpider
 from app.modules.indexer.spider.hddolby import HddolbySpider
 from app.modules.indexer.spider.mtorrent import MTorrentSpider
@@ -113,6 +116,7 @@ class IndexerModule(_ModuleBase):
 
         # 搜索多个关键字
         error_flag = False
+        search_count = 0
         for search_word in keywords:
             # 可能为关键字或ttxxxx
             if search_word \
@@ -128,6 +132,11 @@ class IndexerModule(_ModuleBase):
                 logger.warn(msg)
                 continue
 
+            if search_count > 0:
+                # 强制休眠 1-10 秒
+                logger.info(f"站点 {site.get('name')} 已搜索 {search_count} 次，强制休眠 1-10 秒 ...")
+                time.sleep(random.randint(1, 10))
+
             # 去除搜索关键字中的特殊字符
             if search_word:
                 search_word = StringUtils.clear(search_word, replace_word=" ", allow_space=True)
@@ -187,6 +196,8 @@ class IndexerModule(_ModuleBase):
                     break
             except Exception as err:
                 logger.error(f"{site.get('name')} 搜索出错：{str(err)}")
+            finally:
+                search_count += 1
 
         # 索引花费的时间
         seconds = (datetime.now() - start_time).seconds
@@ -200,10 +211,10 @@ class IndexerModule(_ModuleBase):
 
         # 返回结果
         if not result_array or len(result_array) == 0:
-            logger.warn(f"{site.get('name')} 未搜索到数据，耗时 {seconds} 秒")
+            logger.warn(f"{site.get('name')} 未搜索到数据，共搜索 {search_count} 次，耗时 {seconds} 秒")
             return []
         else:
-            logger.info(f"{site.get('name')} 搜索完成，耗时 {seconds} 秒，返回数据：{len(result_array)}")
+            logger.info(f"{site.get('name')} 搜索完成，共搜索 {search_count} 次，耗时 {seconds} 秒，返回数据：{len(result_array)}")
             # TorrentInfo
             torrents = [TorrentInfo(site=site.get("id"),
                                     site_name=site.get("name"),
@@ -286,26 +297,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/indexer/parser/discuz.py

@@ -14,15 +14,18 @@ class DiscuzUserInfo(SiteParserBase):
     def _parse_user_base_info(self, html_text: str):
         html_text = self._prepare_html_text(html_text)
         html = etree.HTML(html_text)
-
-        user_info = html.xpath('//a[contains(@href, "&uid=")]')
-        if user_info:
-            user_id_match = re.search(r"&uid=(\d+)", user_info[0].attrib['href'])
-            if user_id_match and user_id_match.group().strip():
-                self.userid = user_id_match.group(1)
-                self._torrent_seeding_page = f"forum.php?&mod=torrents&cat_5up=on"
-                self._user_detail_page = user_info[0].attrib['href']
-                self.username = user_info[0].text.strip()
+        try:
+            user_info = html.xpath('//a[contains(@href, "&uid=")]')
+            if user_info:
+                user_id_match = re.search(r"&uid=(\d+)", user_info[0].attrib['href'])
+                if user_id_match and user_id_match.group().strip():
+                    self.userid = user_id_match.group(1)
+                    self._torrent_seeding_page = f"forum.php?&mod=torrents&cat_5up=on"
+                    self._user_detail_page = user_info[0].attrib['href']
+                    self.username = user_info[0].text.strip()
+        finally:
+            if html is not None:
+                del html
 
     def _parse_site_page(self, html_text: str):
         pass
@@ -34,40 +37,44 @@ class DiscuzUserInfo(SiteParserBase):
         :return:
         """
         html = etree.HTML(html_text)
-        if not StringUtils.is_valid_html_element(html):
-            return None
+        try:
+            if not StringUtils.is_valid_html_element(html):
+                return None
 
-        # 用户等级
-        user_levels_text = html.xpath('//a[contains(@href, "usergroup")]/text()')
-        if user_levels_text:
-            self.user_level = user_levels_text[-1].strip()
+            # 用户等级
+            user_levels_text = html.xpath('//a[contains(@href, "usergroup")]/text()')
+            if user_levels_text:
+                self.user_level = user_levels_text[-1].strip()
 
-        # 加入日期
-        join_at_text = html.xpath('//li[em[text()="注册时间"]]/text()')
-        if join_at_text:
-            self.join_at = StringUtils.unify_datetime_str(join_at_text[0].strip())
+            # 加入日期
+            join_at_text = html.xpath('//li[em[text()="注册时间"]]/text()')
+            if join_at_text:
+                self.join_at = StringUtils.unify_datetime_str(join_at_text[0].strip())
 
-        # 分享率
-        ratio_text = html.xpath('//li[contains(.//text(), "分享率")]//text()')
-        if ratio_text:
-            ratio_match = re.search(r"\(([\d,.]+)\)", ratio_text[0])
-            if ratio_match and ratio_match.group(1).strip():
-                self.bonus = StringUtils.str_float(ratio_match.group(1))
+            # 分享率
+            ratio_text = html.xpath('//li[contains(.//text(), "分享率")]//text()')
+            if ratio_text:
+                ratio_match = re.search(r"\(([\d,.]+)\)", ratio_text[0])
+                if ratio_match and ratio_match.group(1).strip():
+                    self.bonus = StringUtils.str_float(ratio_match.group(1))
 
-        # 积分
-        bouns_text = html.xpath('//li[em[text()="积分"]]/text()')
-        if bouns_text:
-            self.bonus = StringUtils.str_float(bouns_text[0].strip())
+            # 积分
+            bouns_text = html.xpath('//li[em[text()="积分"]]/text()')
+            if bouns_text:
+                self.bonus = StringUtils.str_float(bouns_text[0].strip())
 
-        # 上传
-        upload_text = html.xpath('//li[em[contains(text(),"上传量")]]/text()')
-        if upload_text:
-            self.upload = StringUtils.num_filesize(upload_text[0].strip().split('/')[-1])
+            # 上传
+            upload_text = html.xpath('//li[em[contains(text(),"上传量")]]/text()')
+            if upload_text:
+                self.upload = StringUtils.num_filesize(upload_text[0].strip().split('/')[-1])
 
-        # 下载
-        download_text = html.xpath('//li[em[contains(text(),"下载量")]]/text()')
-        if download_text:
-            self.download = StringUtils.num_filesize(download_text[0].strip().split('/')[-1])
+            # 下载
+            download_text = html.xpath('//li[em[contains(text(),"下载量")]]/text()')
+            if download_text:
+                self.download = StringUtils.num_filesize(download_text[0].strip().split('/')[-1])
+        finally:
+            if html is not None:
+                del html
 
     def _parse_user_torrent_seeding_info(self, html_text: str, multi_page: bool = False) -> Optional[str]:
         """
@@ -77,44 +84,48 @@ class DiscuzUserInfo(SiteParserBase):
         :return: 下页地址
         """
         html = etree.HTML(html_text)
-        if not StringUtils.is_valid_html_element(html):
-            return None
+        try:
+            if not StringUtils.is_valid_html_element(html):
+                return None
 
-        size_col = 3
-        seeders_col = 4
-        # 搜索size列
-        if html.xpath('//tr[position()=1]/td[.//img[@class="size"] and .//img[@alt="size"]]'):
-            size_col = len(html.xpath('//tr[position()=1]/td[.//img[@class="size"] '
-                                      'and .//img[@alt="size"]]/preceding-sibling::td')) + 1
-        # 搜索seeders列
-        if html.xpath('//tr[position()=1]/td[.//img[@class="seeders"] and .//img[@alt="seeders"]]'):
-            seeders_col = len(html.xpath('//tr[position()=1]/td[.//img[@class="seeders"] '
-                                         'and .//img[@alt="seeders"]]/preceding-sibling::td')) + 1
+            size_col = 3
+            seeders_col = 4
+            # 搜索size列
+            if html.xpath('//tr[position()=1]/td[.//img[@class="size"] and .//img[@alt="size"]]'):
+                size_col = len(html.xpath('//tr[position()=1]/td[.//img[@class="size"] '
+                                          'and .//img[@alt="size"]]/preceding-sibling::td')) + 1
+            # 搜索seeders列
+            if html.xpath('//tr[position()=1]/td[.//img[@class="seeders"] and .//img[@alt="seeders"]]'):
+                seeders_col = len(html.xpath('//tr[position()=1]/td[.//img[@class="seeders"] '
+                                             'and .//img[@alt="seeders"]]/preceding-sibling::td')) + 1
 
-        page_seeding = 0
-        page_seeding_size = 0
-        page_seeding_info = []
-        seeding_sizes = html.xpath(f'//tr[position()>1]/td[{size_col}]')
-        seeding_seeders = html.xpath(f'//tr[position()>1]/td[{seeders_col}]//text()')
-        if seeding_sizes and seeding_seeders:
-            page_seeding = len(seeding_sizes)
+            page_seeding = 0
+            page_seeding_size = 0
+            page_seeding_info = []
+            seeding_sizes = html.xpath(f'//tr[position()>1]/td[{size_col}]')
+            seeding_seeders = html.xpath(f'//tr[position()>1]/td[{seeders_col}]//text()')
+            if seeding_sizes and seeding_seeders:
+                page_seeding = len(seeding_sizes)
 
-            for i in range(0, len(seeding_sizes)):
-                size = StringUtils.num_filesize(seeding_sizes[i].xpath("string(.)").strip())
-                seeders = StringUtils.str_int(seeding_seeders[i])
+                for i in range(0, len(seeding_sizes)):
+                    size = StringUtils.num_filesize(seeding_sizes[i].xpath("string(.)").strip())
+                    seeders = StringUtils.str_int(seeding_seeders[i])
 
-                page_seeding_size += size
-                page_seeding_info.append([seeders, size])
+                    page_seeding_size += size
+                    page_seeding_info.append([seeders, size])
 
-        self.seeding += page_seeding
-        self.seeding_size += page_seeding_size
-        self.seeding_info.extend(page_seeding_info)
+            self.seeding += page_seeding
+            self.seeding_size += page_seeding_size
+            self.seeding_info.extend(page_seeding_info)
 
-        # 是否存在下页数据
-        next_page = None
-        next_page_text = html.xpath('//a[contains(.//text(), "下一页") or contains(.//text(), "下一頁")]/@href')
-        if next_page_text:
-            next_page = next_page_text[-1].strip()
+            # 是否存在下页数据
+            next_page = None
+            next_page_text = html.xpath('//a[contains(.//text(), "下一页") or contains(.//text(), "下一頁")]/@href')
+            if next_page_text:
+                next_page = next_page_text[-1].strip()
+        finally:
+            if html is not None:
+                del html
 
         return next_page
 

app/modules/indexer/parser/file_list.py

@@ -24,10 +24,13 @@ class FileListSiteUserInfo(SiteParserBase):
     def _parse_user_base_info(self, html_text: str):
         html_text = self._prepare_html_text(html_text)
         html = etree.HTML(html_text)
-
-        ret = html.xpath(f'//a[contains(@href, "userdetails") and contains(@href, "{self.userid}")]//text()')
-        if ret:
-            self.username = str(ret[0])
+        try:
+            ret = html.xpath(f'//a[contains(@href, "userdetails") and contains(@href, "{self.userid}")]//text()')
+            if ret:
+                self.username = str(ret[0])
+        finally:
+            if html is not None:
+                del html
 
     def _parse_user_traffic_info(self, html_text: str):
         """
@@ -40,39 +43,41 @@ class FileListSiteUserInfo(SiteParserBase):
     def _parse_user_detail_info(self, html_text: str):
         html_text = self._prepare_html_text(html_text)
         html = etree.HTML(html_text)
+        try:
+            upload_html = html.xpath('//table//tr/td[text()="Uploaded"]/following-sibling::td//text()')
+            if upload_html:
+                self.upload = StringUtils.num_filesize(upload_html[0])
+            download_html = html.xpath('//table//tr/td[text()="Downloaded"]/following-sibling::td//text()')
+            if download_html:
+                self.download = StringUtils.num_filesize(download_html[0])
 
-        upload_html = html.xpath('//table//tr/td[text()="Uploaded"]/following-sibling::td//text()')
-        if upload_html:
-            self.upload = StringUtils.num_filesize(upload_html[0])
-        download_html = html.xpath('//table//tr/td[text()="Downloaded"]/following-sibling::td//text()')
-        if download_html:
-            self.download = StringUtils.num_filesize(download_html[0])
+            ratio_html = html.xpath('//table//tr/td[text()="Share ratio"]/following-sibling::td//text()')
+            if ratio_html:
+                share_ratio = StringUtils.str_float(ratio_html[0])
+            else:
+                share_ratio = 0
+            self.ratio = 0 if self.download == 0 else share_ratio
 
-        ratio_html = html.xpath('//table//tr/td[text()="Share ratio"]/following-sibling::td//text()')
-        if ratio_html:
-            share_ratio = StringUtils.str_float(ratio_html[0])
-        else:
-            share_ratio = 0
-        self.ratio = 0 if self.download == 0 else share_ratio
+            seed_html = html.xpath('//table//tr/td[text()="Seed bonus"]/following-sibling::td//text()')
+            if seed_html:
+                self.seeding = StringUtils.str_int(seed_html[1])
+                self.seeding_size = StringUtils.num_filesize(seed_html[3])
 
-        seed_html = html.xpath('//table//tr/td[text()="Seed bonus"]/following-sibling::td//text()')
-        if seed_html:
-            self.seeding = StringUtils.str_int(seed_html[1])
-            self.seeding_size = StringUtils.num_filesize(seed_html[3])
+            user_level_html = html.xpath('//table//tr/td[text()="Class"]/following-sibling::td//text()')
+            if user_level_html:
+                self.user_level = user_level_html[0].strip()
 
-        user_level_html = html.xpath('//table//tr/td[text()="Class"]/following-sibling::td//text()')
-        if user_level_html:
-            self.user_level = user_level_html[0].strip()
+            join_at_html = html.xpath('//table//tr/td[contains(text(), "Join")]/following-sibling::td//text()')
+            if join_at_html:
+                join_at = (join_at_html[0].split("("))[0].strip()
+                self.join_at = StringUtils.unify_datetime_str(join_at)
 
-        join_at_html = html.xpath('//table//tr/td[contains(text(), "Join")]/following-sibling::td//text()')
-        if join_at_html:
-            join_at = (join_at_html[0].split("("))[0].strip()
-            self.join_at = StringUtils.unify_datetime_str(join_at)
-
-        bonus_html = html.xpath('//a[contains(@href, "shop.php")]')
-        if bonus_html:
-            self.bonus = StringUtils.str_float(bonus_html[0].xpath("string(.)").strip())
-        pass
+            bonus_html = html.xpath('//a[contains(@href, "shop.php")]')
+            if bonus_html:
+                self.bonus = StringUtils.str_float(bonus_html[0].xpath("string(.)").strip())
+        finally:
+            if html is not None:
+                del html
 
     def _parse_user_torrent_seeding_info(self, html_text: str, multi_page: Optional[bool] = False) -> Optional[str]:
         """
@@ -82,28 +87,32 @@ class FileListSiteUserInfo(SiteParserBase):
         :return: 下页地址
         """
         html = etree.HTML(html_text)
-        if not StringUtils.is_valid_html_element(html):
-            return None
+        try:
+            if not StringUtils.is_valid_html_element(html):
+                return None
 
-        size_col = 6
-        seeders_col = 7
+            size_col = 6
+            seeders_col = 7
 
-        page_seeding_size = 0
-        page_seeding_info = []
-        seeding_sizes = html.xpath(f'//table/tr[position()>1]/td[{size_col}]')
-        seeding_seeders = html.xpath(f'//table/tr[position()>1]/td[{seeders_col}]')
-        if seeding_sizes and seeding_seeders:
-            for i in range(0, len(seeding_sizes)):
-                size = StringUtils.num_filesize(seeding_sizes[i].xpath("string(.)").strip())
-                seeders = StringUtils.str_int(seeding_seeders[i].xpath("string(.)").strip())
+            page_seeding_size = 0
+            page_seeding_info = []
+            seeding_sizes = html.xpath(f'//table/tr[position()>1]/td[{size_col}]')
+            seeding_seeders = html.xpath(f'//table/tr[position()>1]/td[{seeders_col}]')
+            if seeding_sizes and seeding_seeders:
+                for i in range(0, len(seeding_sizes)):
+                    size = StringUtils.num_filesize(seeding_sizes[i].xpath("string(.)").strip())
+                    seeders = StringUtils.str_int(seeding_seeders[i].xpath("string(.)").strip())
 
-                page_seeding_size += size
-                page_seeding_info.append([seeders, size])
+                    page_seeding_size += size
+                    page_seeding_info.append([seeders, size])
 
-        self.seeding_info.extend(page_seeding_info)
+            self.seeding_info.extend(page_seeding_info)
 
-        # 是否存在下页数据
-        next_page = None
+            # 是否存在下页数据
+            next_page = None
+        finally:
+            if html is not None:
+                del html
 
         return next_page
 

app/modules/indexer/parser/gazelle.py

@@ -14,46 +14,49 @@ class GazelleSiteUserInfo(SiteParserBase):
     def _parse_user_base_info(self, html_text: str):
         html_text = self._prepare_html_text(html_text)
         html = etree.HTML(html_text)
+        try:
+            tmps = html.xpath('//a[contains(@href, "user.php?id=")]')
+            if tmps:
+                user_id_match = re.search(r"user.php\?id=(\d+)", tmps[0].attrib['href'])
+                if user_id_match and user_id_match.group().strip():
+                    self.userid = user_id_match.group(1)
+                    self._torrent_seeding_page = f"torrents.php?type=seeding&userid={self.userid}"
+                    self._user_detail_page = f"user.php?id={self.userid}"
+                    self.username = tmps[0].text.strip()
 
-        tmps = html.xpath('//a[contains(@href, "user.php?id=")]')
-        if tmps:
-            user_id_match = re.search(r"user.php\?id=(\d+)", tmps[0].attrib['href'])
-            if user_id_match and user_id_match.group().strip():
-                self.userid = user_id_match.group(1)
-                self._torrent_seeding_page = f"torrents.php?type=seeding&userid={self.userid}"
-                self._user_detail_page = f"user.php?id={self.userid}"
-                self.username = tmps[0].text.strip()
-
-        tmps = html.xpath('//*[@id="header-uploaded-value"]/@data-value')
-        if tmps:
-            self.upload = StringUtils.num_filesize(tmps[0])
-        else:
-            tmps = html.xpath('//li[@id="stats_seeding"]/span/text()')
+            tmps = html.xpath('//*[@id="header-uploaded-value"]/@data-value')
             if tmps:
                 self.upload = StringUtils.num_filesize(tmps[0])
+            else:
+                tmps = html.xpath('//li[@id="stats_seeding"]/span/text()')
+                if tmps:
+                    self.upload = StringUtils.num_filesize(tmps[0])
 
-        tmps = html.xpath('//*[@id="header-downloaded-value"]/@data-value')
-        if tmps:
-            self.download = StringUtils.num_filesize(tmps[0])
-        else:
-            tmps = html.xpath('//li[@id="stats_leeching"]/span/text()')
+            tmps = html.xpath('//*[@id="header-downloaded-value"]/@data-value')
             if tmps:
                 self.download = StringUtils.num_filesize(tmps[0])
+            else:
+                tmps = html.xpath('//li[@id="stats_leeching"]/span/text()')
+                if tmps:
+                    self.download = StringUtils.num_filesize(tmps[0])
 
-        self.ratio = 0.0 if self.download <= 0.0 else round(self.upload / self.download, 3)
+            self.ratio = 0.0 if self.download <= 0.0 else round(self.upload / self.download, 3)
 
-        tmps = html.xpath('//a[contains(@href, "bonus.php")]/@data-tooltip')
-        if tmps:
-            bonus_match = re.search(r"([\d,.]+)", tmps[0])
-            if bonus_match and bonus_match.group(1).strip():
-                self.bonus = StringUtils.str_float(bonus_match.group(1))
-        else:
-            tmps = html.xpath('//a[contains(@href, "bonus.php")]')
+            tmps = html.xpath('//a[contains(@href, "bonus.php")]/@data-tooltip')
             if tmps:
-                bonus_text = tmps[0].xpath("string(.)")
-                bonus_match = re.search(r"([\d,.]+)", bonus_text)
+                bonus_match = re.search(r"([\d,.]+)", tmps[0])
                 if bonus_match and bonus_match.group(1).strip():
                     self.bonus = StringUtils.str_float(bonus_match.group(1))
+            else:
+                tmps = html.xpath('//a[contains(@href, "bonus.php")]')
+                if tmps:
+                    bonus_text = tmps[0].xpath("string(.)")
+                    bonus_match = re.search(r"([\d,.]+)", bonus_text)
+                    if bonus_match and bonus_match.group(1).strip():
+                        self.bonus = StringUtils.str_float(bonus_match.group(1))
+        finally:
+            if html is not None:
+                del html
 
     def _parse_site_page(self, html_text: str):
         pass
@@ -65,27 +68,31 @@ class GazelleSiteUserInfo(SiteParserBase):
         :return:
         """
         html = etree.HTML(html_text)
-        if not StringUtils.is_valid_html_element(html):
-            return None
+        try:
+            if not StringUtils.is_valid_html_element(html):
+                return None
 
-        # 用户等级
-        user_levels_text = html.xpath('//*[@id="class-value"]/@data-value')
-        if user_levels_text:
-            self.user_level = user_levels_text[0].strip()
-        else:
-            user_levels_text = html.xpath('//li[contains(text(), "用户等级")]/text()')
+            # 用户等级
+            user_levels_text = html.xpath('//*[@id="class-value"]/@data-value')
             if user_levels_text:
-                self.user_level = user_levels_text[0].split(':')[1].strip()
+                self.user_level = user_levels_text[0].strip()
+            else:
+                user_levels_text = html.xpath('//li[contains(text(), "用户等级")]/text()')
+                if user_levels_text:
+                    self.user_level = user_levels_text[0].split(':')[1].strip()
 
-        # 加入日期
-        join_at_text = html.xpath('//*[@id="join-date-value"]/@data-value')
-        if join_at_text:
-            self.join_at = StringUtils.unify_datetime_str(join_at_text[0].strip())
-        else:
-            join_at_text = html.xpath(
-                '//div[contains(@class, "box_userinfo_stats")]//li[contains(text(), "加入时间")]/span/text()')
+            # 加入日期
+            join_at_text = html.xpath('//*[@id="join-date-value"]/@data-value')
             if join_at_text:
                 self.join_at = StringUtils.unify_datetime_str(join_at_text[0].strip())
+            else:
+                join_at_text = html.xpath(
+                    '//div[contains(@class, "box_userinfo_stats")]//li[contains(text(), "加入时间")]/span/text()')
+                if join_at_text:
+                    self.join_at = StringUtils.unify_datetime_str(join_at_text[0].strip())
+        finally:
+            if html is not None:
+                del html
 
     def _parse_user_torrent_seeding_info(self, html_text: str, multi_page: Optional[bool] = False) -> Optional[str]:
         """
@@ -95,48 +102,52 @@ class GazelleSiteUserInfo(SiteParserBase):
         :return: 下页地址
         """
         html = etree.HTML(html_text)
-        if not StringUtils.is_valid_html_element(html):
-            return None
+        try:
+            if not StringUtils.is_valid_html_element(html):
+                return None
 
-        size_col = 3
-        # 搜索size列
-        if html.xpath('//table[contains(@id, "torrent")]//tr[1]/td'):
-            size_col = len(html.xpath('//table[contains(@id, "torrent")]//tr[1]/td')) - 3
-        # 搜索seeders列
-        seeders_col = size_col + 2
+            size_col = 3
+            # 搜索size列
+            if html.xpath('//table[contains(@id, "torrent")]//tr[1]/td'):
+                size_col = len(html.xpath('//table[contains(@id, "torrent")]//tr[1]/td')) - 3
+            # 搜索seeders列
+            seeders_col = size_col + 2
 
-        page_seeding = 0
-        page_seeding_size = 0
-        page_seeding_info = []
-        seeding_sizes = html.xpath(f'//table[contains(@id, "torrent")]//tr[position()>1]/td[{size_col}]')
-        seeding_seeders = html.xpath(f'//table[contains(@id, "torrent")]//tr[position()>1]/td[{seeders_col}]/text()')
-        if seeding_sizes and seeding_seeders:
-            page_seeding = len(seeding_sizes)
+            page_seeding = 0
+            page_seeding_size = 0
+            page_seeding_info = []
+            seeding_sizes = html.xpath(f'//table[contains(@id, "torrent")]//tr[position()>1]/td[{size_col}]')
+            seeding_seeders = html.xpath(f'//table[contains(@id, "torrent")]//tr[position()>1]/td[{seeders_col}]/text()')
+            if seeding_sizes and seeding_seeders:
+                page_seeding = len(seeding_sizes)
 
-            for i in range(0, len(seeding_sizes)):
-                size = StringUtils.num_filesize(seeding_sizes[i].xpath("string(.)").strip())
-                seeders = int(seeding_seeders[i])
+                for i in range(0, len(seeding_sizes)):
+                    size = StringUtils.num_filesize(seeding_sizes[i].xpath("string(.)").strip())
+                    seeders = int(seeding_seeders[i])
 
-                page_seeding_size += size
-                page_seeding_info.append([seeders, size])
+                    page_seeding_size += size
+                    page_seeding_info.append([seeders, size])
 
-        if multi_page:
-            self.seeding += page_seeding
-            self.seeding_size += page_seeding_size
-            self.seeding_info.extend(page_seeding_info)
-        else:
-            if not self.seeding:
-                self.seeding = page_seeding
-            if not self.seeding_size:
-                self.seeding_size = page_seeding_size
-            if not self.seeding_info:
-                self.seeding_info = page_seeding_info
+            if multi_page:
+                self.seeding += page_seeding
+                self.seeding_size += page_seeding_size
+                self.seeding_info.extend(page_seeding_info)
+            else:
+                if not self.seeding:
+                    self.seeding = page_seeding
+                if not self.seeding_size:
+                    self.seeding_size = page_seeding_size
+                if not self.seeding_info:
+                    self.seeding_info = page_seeding_info
 
-        # 是否存在下页数据
-        next_page = None
-        next_page_text = html.xpath('//a[contains(.//text(), "Next") or contains(.//text(), "下一页")]/@href')
-        if next_page_text:
-            next_page = next_page_text[-1].strip()
+            # 是否存在下页数据
+            next_page = None
+            next_page_text = html.xpath('//a[contains(.//text(), "Next") or contains(.//text(), "下一页")]/@href')
+            if next_page_text:
+                next_page = next_page_text[-1].strip()
+        finally:
+            if html is not None:
+                del html
 
         return next_page
 

app/modules/indexer/parser/ipt_project.py

@@ -14,67 +14,79 @@ class IptSiteUserInfo(SiteParserBase):
     def _parse_user_base_info(self, html_text: str):
         html_text = self._prepare_html_text(html_text)
         html = etree.HTML(html_text)
-        tmps = html.xpath('//a[contains(@href, "/u/")]//text()')
-        tmps_id = html.xpath('//a[contains(@href, "/u/")]/@href')
-        if tmps:
-            self.username = str(tmps[-1])
-        if tmps_id:
-            user_id_match = re.search(r"/u/(\d+)", tmps_id[0])
-            if user_id_match and user_id_match.group().strip():
-                self.userid = user_id_match.group(1)
-                self._user_detail_page = f"user.php?u={self.userid}"
-                self._torrent_seeding_page = f"peers?u={self.userid}"
+        try:
+            tmps = html.xpath('//a[contains(@href, "/u/")]//text()')
+            tmps_id = html.xpath('//a[contains(@href, "/u/")]/@href')
+            if tmps:
+                self.username = str(tmps[-1])
+            if tmps_id:
+                user_id_match = re.search(r"/u/(\d+)", tmps_id[0])
+                if user_id_match and user_id_match.group().strip():
+                    self.userid = user_id_match.group(1)
+                    self._user_detail_page = f"user.php?u={self.userid}"
+                    self._torrent_seeding_page = f"peers?u={self.userid}"
 
-        tmps = html.xpath('//div[@class = "stats"]/div/div')
-        if tmps:
-            self.upload = StringUtils.num_filesize(str(tmps[0].xpath('span/text()')[1]).strip())
-            self.download = StringUtils.num_filesize(str(tmps[0].xpath('span/text()')[2]).strip())
-            self.seeding = StringUtils.str_int(tmps[0].xpath('a')[2].xpath('text()')[0])
-            self.leeching = StringUtils.str_int(tmps[0].xpath('a')[2].xpath('text()')[1])
-            self.ratio = StringUtils.str_float(str(tmps[0].xpath('span/text()')[0]).strip().replace('-', '0'))
-            self.bonus = StringUtils.str_float(tmps[0].xpath('a')[3].xpath('text()')[0])
+            tmps = html.xpath('//div[@class = "stats"]/div/div')
+            if tmps:
+                self.upload = StringUtils.num_filesize(str(tmps[0].xpath('span/text()')[1]).strip())
+                self.download = StringUtils.num_filesize(str(tmps[0].xpath('span/text()')[2]).strip())
+                self.seeding = StringUtils.str_int(tmps[0].xpath('a')[2].xpath('text()')[0])
+                self.leeching = StringUtils.str_int(tmps[0].xpath('a')[2].xpath('text()')[1])
+                self.ratio = StringUtils.str_float(str(tmps[0].xpath('span/text()')[0]).strip().replace('-', '0'))
+                self.bonus = StringUtils.str_float(tmps[0].xpath('a')[3].xpath('text()')[0])
+        finally:
+            if html is not None:
+                del html
 
     def _parse_site_page(self, html_text: str):
         pass
 
     def _parse_user_detail_info(self, html_text: str):
         html = etree.HTML(html_text)
-        if not StringUtils.is_valid_html_element(html):
-            return
+        try:
+            if not StringUtils.is_valid_html_element(html):
+                return
 
-        user_levels_text = html.xpath('//tr/th[text()="Class"]/following-sibling::td[1]/text()')
-        if user_levels_text:
-            self.user_level = user_levels_text[0].strip()
+            user_levels_text = html.xpath('//tr/th[text()="Class"]/following-sibling::td[1]/text()')
+            if user_levels_text:
+                self.user_level = user_levels_text[0].strip()
 
-        # 加入日期
-        join_at_text = html.xpath('//tr/th[text()="Join date"]/following-sibling::td[1]/text()')
-        if join_at_text:
-            self.join_at = StringUtils.unify_datetime_str(join_at_text[0].split(' (')[0])
+            # 加入日期
+            join_at_text = html.xpath('//tr/th[text()="Join date"]/following-sibling::td[1]/text()')
+            if join_at_text:
+                self.join_at = StringUtils.unify_datetime_str(join_at_text[0].split(' (')[0])
+        finally:
+            if html is not None:
+                del html
 
     def _parse_user_torrent_seeding_info(self, html_text: str, multi_page: bool = False) -> Optional[str]:
         html = etree.HTML(html_text)
-        if not StringUtils.is_valid_html_element(html):
-            return None
-        # seeding start
-        seeding_end_pos = 3
-        if html.xpath('//tr/td[text() = "Leechers"]'):
-            seeding_end_pos = len(html.xpath('//tr/td[text() = "Leechers"]/../preceding-sibling::tr')) + 1
-            seeding_end_pos = seeding_end_pos - 3
+        try:
+            if not StringUtils.is_valid_html_element(html):
+                return None
+            # seeding start
+            seeding_end_pos = 3
+            if html.xpath('//tr/td[text() = "Leechers"]'):
+                seeding_end_pos = len(html.xpath('//tr/td[text() = "Leechers"]/../preceding-sibling::tr')) + 1
+                seeding_end_pos = seeding_end_pos - 3
 
-        page_seeding = 0
-        page_seeding_size = 0
-        seeding_torrents = html.xpath('//tr/td[text() = "Seeders"]/../following-sibling::tr/td[position()=6]/text()')
-        if seeding_torrents:
-            page_seeding = seeding_end_pos
-            for per_size in seeding_torrents[:seeding_end_pos]:
-                if '(' in per_size and ')' in per_size:
-                    per_size = per_size.split('(')[-1]
-                    per_size = per_size.split(')')[0]
+            page_seeding = 0
+            page_seeding_size = 0
+            seeding_torrents = html.xpath('//tr/td[text() = "Seeders"]/../following-sibling::tr/td[position()=6]/text()')
+            if seeding_torrents:
+                page_seeding = seeding_end_pos
+                for per_size in seeding_torrents[:seeding_end_pos]:
+                    if '(' in per_size and ')' in per_size:
+                        per_size = per_size.split('(')[-1]
+                        per_size = per_size.split(')')[0]
 
-                page_seeding_size += StringUtils.num_filesize(per_size)
+                    page_seeding_size += StringUtils.num_filesize(per_size)
 
-        self.seeding = page_seeding
-        self.seeding_size = page_seeding_size
+            self.seeding = page_seeding
+            self.seeding_size = page_seeding_size
+        finally:
+            if html is not None:
+                del html
 
     def _parse_user_traffic_info(self, html_text: str):
         pass

app/modules/indexer/parser/nexus_audiences.py

@@ -23,12 +23,16 @@ class NexusAudiencesSiteUserInfo(NexusPhpSiteUserInfo):
         if not html_text:
             return
         html = etree.HTML(html_text)
-        if not StringUtils.is_valid_html_element(html):
-            return
-        total_row = html.xpath('//table[@class="table table-bordered"]//tr[td[1][normalize-space()="Total"]]')
-        if not total_row:
-            return
-        seeding_count = total_row[0].xpath('./td[2]/text()')
-        seeding_size = total_row[0].xpath('./td[3]/text()')
-        self.seeding = StringUtils.str_int(seeding_count[0]) if seeding_count else 0
-        self.seeding_size = StringUtils.num_filesize(seeding_size[0].strip()) if seeding_size else 0
+        try:
+            if not StringUtils.is_valid_html_element(html):
+                return
+            total_row = html.xpath('//table[@class="table table-bordered"]//tr[td[1][normalize-space()="Total"]]')
+            if not total_row:
+                return
+            seeding_count = total_row[0].xpath('./td[2]/text()')
+            seeding_size = total_row[0].xpath('./td[3]/text()')
+            self.seeding = StringUtils.str_int(seeding_count[0]) if seeding_count else 0
+            self.seeding_size = StringUtils.num_filesize(seeding_size[0].strip()) if seeding_size else 0
+        finally:
+            if html is not None:
+                del html