更新 version.py

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

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

@@ -11,6 +11,7 @@ from typing import Optional, Union, Annotated
 import aiofiles
 import pillow_avif  # noqa 用于自动注册AVIF支持
 from PIL import Image
+from app.helper.sites import SitesHelper
 from fastapi import APIRouter, Body, Depends, HTTPException, Header, Request, Response
 from fastapi.responses import StreamingResponse
 
@@ -18,10 +19,10 @@ 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
@@ -29,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
@@ -144,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:
@@ -154,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)
 
 
@@ -186,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)
@@ -289,9 +292,9 @@ def get_setting(key: str,
 
 @router.post("/setting/{key}", summary="更新系统设置", response_model=schemas.Response)
 def set_setting(
-    key: str,
-    value: Annotated[Union[list, dict, bool, int, str] | None, Body()] = None,
-    _: User = Depends(get_current_active_superuser),
+        key: str,
+        value: Annotated[Union[list, dict, bool, int, str] | None, Body()] = None,
+        _: User = Depends(get_current_active_superuser),
 ):
     """
     更新系统设置（仅管理员）
@@ -451,10 +454,10 @@ def ruletest(title: str,
 
 @router.get("/nettest", summary="测试网络连通性")
 def nettest(
-    url: str,
-    proxy: bool,
-    include: Optional[str] = None,
-    _: schemas.TokenPayload = Depends(verify_token),
+        url: str,
+        proxy: bool,
+        include: Optional[str] = None,
+        _: schemas.TokenPayload = Depends(verify_token),
 ):
     """
     测试网络连通性
@@ -462,17 +465,27 @@ def nettest(
     # 记录开始的毫秒数
     start_time = datetime.now()
     headers = None
-    if "github" in url or "{GITHUB_PROXY}" in url:
+    # 当前使用的加速代理
+    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 "")
         )
-        headers = settings.GITHUB_HEADERS
+        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)
-    url = url.replace(
-        "{PIP_PROXY}",
-        UrlUtils.standardize_base_url(settings.PIP_PROXY or "https://pypi.org/simple/"),
-    )
     result = RequestUtils(
         proxies=settings.PROXY if proxy else None,
         headers=headers,
@@ -484,21 +497,36 @@ def nettest(
     time = round((end_time - start_time).total_seconds() * 1000)
     # 计算相关秒数
     if result is None:
-        return schemas.Response(success=False, message="无法连接", data={"time": time})
+        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=f"无效响应，不匹配 {include}",
+                message=message,
                 data={"time": time},
             )
         return schemas.Response(success=True, data={"time": time})
     else:
-        return schemas.Response(
-            success=False, message=f"错误码：{result.status_code}", data={"time": time}
-        )
+        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/workflow.py

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

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

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,
@@ -436,6 +461,9 @@ class MediaChain(ChainBase):
                 logger.error(f"{_url} 图片下载失败：{str(err)}！")
             return None
 
+        if not fileitem:
+            return
+
         # 当前文件路径
         filepath = Path(fileitem.path)
         if fileitem.type == "file" \
@@ -464,6 +492,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 +524,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:
@@ -587,11 +618,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)
@@ -659,7 +690,8 @@ class MediaChain(ChainBase):
                                         # 只下载当前刮削季的图片
                                         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):

app/chain/site.py

@@ -271,16 +271,20 @@ class SiteChain(ChainBase):
             logger.error(f"获取站点页面失败：{url}")
             return favicon_url, None
         html = etree.HTML(html_text)
-        if StringUtils.is_valid_html_element(html):
-            fav_link = html.xpath('//head/link[contains(@rel, "icon")]/@href')
-            if fav_link:
-                favicon_url = urljoin(url, fav_link[0])
+        try:
+            if StringUtils.is_valid_html_element(html):
+                fav_link = html.xpath('//head/link[contains(@rel, "icon")]/@href')
+                if fav_link:
+                    favicon_url = urljoin(url, fav_link[0])
 
-        res = RequestUtils(cookies=cookie, timeout=15, ua=ua).get_res(url=favicon_url)
-        if res:
-            return favicon_url, base64.b64encode(res.content).decode()
-        else:
-            logger.error(f"获取站点图标失败：{favicon_url}")
+            res = RequestUtils(cookies=cookie, timeout=15, ua=ua).get_res(url=favicon_url)
+            if res:
+                return favicon_url, base64.b64encode(res.content).decode()
+            else:
+                logger.error(f"获取站点图标失败：{favicon_url}")
+        finally:
+            if html is not None:
+                del html
         return favicon_url, None
 
     def sync_cookies(self, manual=False) -> Tuple[bool, str]:

app/chain/storage.py

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

@@ -39,6 +39,8 @@ class SubscribeChain(ChainBase):
     """
 
     _rlock = threading.RLock()
+    # 避免莫名原因导致长时间持有锁
+    _LOCK_TIMOUT = 3600 * 2
 
     def add(self, title: str, year: str,
             mtype: MediaType = None,
@@ -279,8 +281,15 @@ 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)
@@ -434,14 +443,17 @@ class SubscribeChain(ChainBase):
                     else:
                         self.messagehelper.put('没有找到订阅！', title="订阅搜索", role="system")
 
-                logger.debug(f"search Lock released at {datetime.now()}")
             finally:
                 subscribes.clear()
                 del subscribes
+        finally:
+            if lock_acquired:
+                self._rlock.release()
+                logger.debug(f"search Lock released at {datetime.now()}")
 
-            # 如果不是大内存模式，进行垃圾回收
-            if not settings.BIG_MEMORY_MODE:
-                gc.collect()
+        # 如果不是大内存模式，进行垃圾回收
+        if not settings.BIG_MEMORY_MODE:
+            gc.collect()
 
     def update_subscribe_priority(self, subscribe: Subscribe, meta: MetaBase,
                                   mediainfo: MediaInfo, downloads: Optional[List[Context]]):
@@ -564,8 +576,14 @@ class SubscribeChain(ChainBase):
             logger.warn('没有缓存资源，无法匹配订阅')
             return
 
-        with self._rlock:
-            logger.debug(f"match lock acquired at {datetime.now()}")
+        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]] = {}
@@ -821,8 +839,10 @@ class SubscribeChain(ChainBase):
                 del processed_torrents
                 subscribes.clear()
                 del subscribes
-
-            logger.debug(f"match Lock released at {datetime.now()}")
+        finally:
+            if lock_acquired:
+                self._rlock.release()
+                logger.debug(f"match Lock released at {datetime.now()}")
 
     def check(self):
         """

app/chain/system.py

@@ -6,6 +6,7 @@ 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
@@ -136,13 +137,6 @@ class SystemChain(ChainBase):
                             shutil.rmtree(target_path)
                         shutil.copytree(item, target_path)
                         logger.info(f"已恢复插件目录: {item.name}")
-                        # 安装依赖
-                        requirements_file = target_path / "requirements.txt"
-                        if requirements_file.exists():
-                            logger.info(f"正在安装插件 {item.name} 的依赖...")
-                            success, message = PluginHelper.pip_install_with_fallback(requirements_file)
-                            if not success:
-                                logger.warn(f"插件 {item.name} 依赖安装失败: {message}")
                         restored_count += 1
                     # 如果是文件
                     elif item.is_file():
@@ -155,6 +149,9 @@ class SystemChain(ChainBase):
 
             logger.info(f"插件恢复完成，共恢复 {restored_count} 个项目")
 
+            # 安装缺少的依赖
+            PluginManager.install_plugin_missing_dependencies()
+
         # 删除备份目录
         try:
             shutil.rmtree(backup_dir)

app/chain/torrents.py

@@ -140,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
@@ -178,11 +188,16 @@ class TorrentsChain(ChainBase):
             # 取前N条
             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:

app/chain/transfer.py

@@ -5,7 +5,6 @@ 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
 
@@ -16,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
@@ -28,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
 
@@ -213,6 +212,7 @@ class JobManager:
                                 set(self._season_episodes[mediaid]) - set(task.meta.episode_list)
                             )
                         return task
+            return None
 
     def remove_job(self, task: TransferTask) -> Optional[TransferJob]:
         """
@@ -226,6 +226,7 @@ class JobManager:
                 if __mediaid__ in self._season_episodes:
                     self._season_episodes.pop(__mediaid__)
                 return self._job_view.pop(__mediaid__)
+            return None
 
     def is_done(self, task: TransferTask) -> bool:
         """
@@ -311,7 +312,7 @@ class JobManager:
 
     def count(self, media: MediaInfo, season: Optional[int] = None) -> int:
         """
-        获取某项任务总数
+        获取某项任务成功总数
         """
         __mediaid__ = self.__get_media_id(media=media, season=season)
         with job_lock:
@@ -322,7 +323,7 @@ class JobManager:
 
     def size(self, media: MediaInfo, season: Optional[int] = None) -> int:
         """
-        获取某项任务总大小
+        获取某项任务成功文件总大小
         """
         __mediaid__ = self.__get_media_id(media=media, season=season)
         with job_lock:
@@ -359,22 +360,20 @@ class TransferChain(ChainBase, metaclass=Singleton):
     文件整理处理链
     """
 
-    # 可处理的文件后缀
-    all_exts = settings.RMT_MEDIAEXT
-
-    # 待整理任务队列
-    _queue = Queue()
-
-    # 文件整理线程
-    _transfer_thread = None
-
-    # 队列间隔时间（秒）
-    _transfer_interval = 15
-
     def __init__(self):
         super().__init__()
+        # 可处理的文件后缀
+        self.all_exts = settings.RMT_MEDIAEXT
+        # 待整理任务队列
+        self._queue = queue.Queue()
+        # 文件整理线程
+        self._transfer_thread = None
+        # 队列间隔时间（秒）
+        self._transfer_interval = 15
+        # 事件管理器
         self.jobview = JobManager()
-
+        # 车移成功的文件清单
+        self._success_target_files: Dict[str, List[str]] = {}
         # 启动整理任务
         self.__init()
 
@@ -391,6 +390,44 @@ class TransferChain(ChainBase, metaclass=Singleton):
         """
         整理完成后处理
         """
+
+        def __do_finished():
+            """
+            完成时发送消息、刮削事件、移除任务等
+            """
+            # 更新文件数量
+            transferinfo.file_count = self.jobview.count(task.mediainfo, task.meta.begin_season) or 1
+            # 更新文件大小
+            transferinfo.total_size = self.jobview.size(task.mediainfo,
+                                                        task.meta.begin_season) or task.fileitem.size
+            # 更新文件清单
+            transferinfo.file_list_new = self._success_target_files.pop(transferinfo.target_diritem.path, [])
+            # 发送通知，实时手动整理时不发
+            if transferinfo.need_notify and (task.background or not task.manual):
+                se_str = None
+                if task.mediainfo.type == MediaType.TV:
+                    season_episodes = self.jobview.season_episodes(task.mediainfo, task.meta.begin_season)
+                    if season_episodes:
+                        se_str = f"{task.meta.season} {StringUtils.format_ep(season_episodes)}"
+                    else:
+                        se_str = f"{task.meta.season}"
+                self.send_transfer_message(meta=task.meta,
+                                           mediainfo=task.mediainfo,
+                                           transferinfo=transferinfo,
+                                           season_episode=se_str,
+                                           username=task.username)
+            # 刮削事件
+            if transferinfo.need_scrape:
+                self.eventmanager.send_event(EventType.MetadataScrape, {
+                    'meta': task.meta,
+                    'mediainfo': task.mediainfo,
+                    'fileitem': transferinfo.target_diritem,
+                    'file_list': transferinfo.file_list_new,
+                    'overwrite': False
+                })
+            # 移除已完成的任务
+            self.jobview.remove_job(task)
+
         transferhis = TransferHistoryOper()
         if not transferinfo.success:
             # 转移失败
@@ -416,6 +453,10 @@ class TransferChain(ChainBase, metaclass=Singleton):
             ))
             # 整理失败
             self.jobview.fail_task(task)
+            with task_lock:
+                # 整理完成且有成功的任务时
+                if self.jobview.is_finished(task):
+                    __do_finished()
             return False, transferinfo.message
 
         # 转移成功
@@ -444,55 +485,49 @@ 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
+                        # 通过download_hash获取种子保存目录
+                        download_history = downloadhistoryoper.get_by_hash(t.download_hash)
+                        if download_history and download_history.path:
+                            # 检查种子目录下是否还有有效媒体文件
+                            seed_dir_item = storagechain.get_file_item(storage=t.fileitem.storage,
+                                                                       path=Path(download_history.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} ")
+                                    # 删除残留目录
+                                    if t.fileitem:
+                                        storagechain.delete_media_file(t.fileitem, delete_self=False)
+                                else:
+                                    logger.info(
+                                        f"种子目录 {download_history.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, ""
 
@@ -1099,7 +1134,8 @@ class TransferChain(ChainBase, metaclass=Singleton):
                 # 自定义识别
                 if formaterHandler:
                     # 开始集、结束集、PART
-                    begin_ep, end_ep, part = formaterHandler.split_episode(file_name=file_path.name, file_meta=file_meta)
+                    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
@@ -1204,7 +1240,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):

app/core/config.py

@@ -1,6 +1,7 @@
 import copy
 import json
 import os
+import re
 import secrets
 import sys
 import threading
@@ -13,6 +14,7 @@ from pydantic import BaseModel, BaseSettings, validator, Field
 from app.log import logger, log_settings, LogConfigModel
 from app.utils.system import SystemUtils
 from app.utils.url import UrlUtils
+from app.schemas import MediaType
 
 
 class SystemConfModel(BaseModel):
@@ -211,6 +213,8 @@ class ConfigModel(BaseModel):
     SITEDATA_REFRESH_INTERVAL: int = 6
     # 读取和发送站点消息
     SITE_MESSAGE: bool = True
+    # 不能缓存站点资源的站点域名，多个使用,分隔
+    NO_CACHE_SITE_KEY: str = "m-team"
     # 种子标签
     TORRENT_TAG: str = "MOVIEPILOT"
     # 下载站点字幕
@@ -274,12 +278,6 @@ class ConfigModel(BaseModel):
     REPO_GITHUB_TOKEN: Optional[str] = None
     # 大内存模式
     BIG_MEMORY_MODE: bool = False
-    # 是否启用内存监控
-    MEMORY_ANALYSIS: bool = False
-    # 内存快照间隔（分钟）
-    MEMORY_SNAPSHOT_INTERVAL: int = 30
-    # 保留的内存快照文件数量
-    MEMORY_SNAPSHOT_KEEP_COUNT: int = 20
     # 全局图片缓存，将媒体图片缓存到本地
     GLOBAL_IMAGE_CACHE: bool = False
     # 是否启用编码探测的性能模式
@@ -311,6 +309,8 @@ 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
 
 
 class Settings(BaseSettings, ConfigModel, LogConfigModel):
@@ -655,6 +655,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,7 @@ class MediaInfo:
         self.names = info.get('names') or []
         # 剩余属性赋值
         for key, value in info.items():
-            if hasattr(self, key) and not getattr(self, key):
+            if hasattr(self, key) and getattr(self, key) is None:
                 setattr(self, key, value)
 
     def set_douban_info(self, info: dict):
@@ -606,7 +606,7 @@ class MediaInfo:
             self.production_countries = [{"id": country, "name": country} for country in info.get("countries") or []]
         # 剩余属性赋值
         for key, value in info.items():
-            if not hasattr(self, key):
+            if hasattr(self, key) and getattr(self, key) is None:
                 setattr(self, key, value)
 
     def set_bangumi_info(self, info: dict):

app/core/event.py

@@ -69,9 +69,6 @@ class EventManager(metaclass=Singleton):
     EventManager 负责管理和调度广播事件和链式事件，包括订阅、发送和处理事件
     """
 
-    # 退出事件
-    __event = threading.Event()
-
     def __init__(self):
         self.__executor = ThreadHelper()  # 动态线程池，用于消费事件
         self.__consumer_threads = []  # 用于保存启动的事件消费者线程
@@ -81,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):
         """

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

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

app/core/meta/streamingplatform.py

@@ -312,4 +312,3 @@ class StreamingPlatforms(metaclass=Singleton):
         if name is None:
             return False
         return name.upper() in self._lookup_cache
-

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

@@ -10,6 +10,7 @@ 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
@@ -21,7 +22,6 @@ from app.core.event import eventmanager, Event
 from app.db.plugindata_oper import PluginDataOper
 from app.db.systemconfig_oper import SystemConfigOper
 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()

app/core/workflow.py

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

app/db/models/workflow.py

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

app/db/workflow_oper.py

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

app/helper/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,7 +8,6 @@ import os
 
 
 class DisplayHelper(metaclass=Singleton):
-    _display: Display = None
 
     def __init__(self):
         if not SystemUtils.is_docker():

app/helper/doh.py

@@ -70,6 +70,9 @@ def enable_doh(enable: bool):
 
 
 class DohHelper(metaclass=Singleton):
+    """
+    DoH帮助类，用于处理DNS over HTTPS解析。
+    """
     def __init__(self):
         enable_doh(settings.DOH_ENABLE)
 

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

@@ -541,8 +541,6 @@ class MessageQueueManager(metaclass=SingletonClass):
     消息发送队列管理器
     """
 
-    schedule_periods: List[tuple[int, int, int, int]] = []
-
     def __init__(
             self,
             send_callback: Optional[Callable] = None,
@@ -554,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()

app/helper/plugin.py

@@ -18,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):
     """
     插件市场管理，下载安装插件到本地
     """
@@ -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()
@@ -649,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:
@@ -58,15 +59,15 @@ class ResourceHelper:
                         if rtype == "auth":
                             # 站点认证资源
                             local_version = SitesHelper().auth_version
-                            # 阻断v2.3.0以下的版本直接更新，避免无限重启
+                            # 阻断站点认证资源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
-                            # 阻断v2.0.0以下的版本直接更新，避免无限重启
-                            if StringUtils.compare_version(local_version, "<", "2.0.0"):
-                                continue
                         else:
                             continue
                         if StringUtils.compare_version(version, ">", local_version):
@@ -84,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:
@@ -96,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/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):
     """
     订阅数据统计/订阅分享等
     """

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/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)
+    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(),

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()

app/modules/douban/douban_cache.py

@@ -10,7 +10,7 @@ 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()
@@ -19,7 +19,7 @@ CACHE_EXPIRE_TIMESTAMP_STR = "cache_expire_timestamp"
 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/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/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,13 +140,29 @@ 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)
@@ -411,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
@@ -510,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:
@@ -548,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/alipan.py

@@ -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,17 +43,12 @@ class AliPan(StorageBase, metaclass=Singleton):
         "copy": "复制"
     }
 
-    # 验证参数
-    _auth_state = {}
-
-    # 上传进度值
-    _last_progress = 0
-
     # 基础url
     base_url = "https://openapi.alipan.com"
 
     def __init__(self):
         super().__init__()
+        self._auth_state = {}
         self.session = requests.Session()
         self._init_session()
 
@@ -244,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]]:
@@ -369,7 +365,7 @@ class AliPan(StorageBase, metaclass=Singleton):
                 break
             next_marker = resp.get("next_marker")
             for item in resp.get("items", []):
-                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

app/modules/filemanager/storages/alist.py

@@ -12,11 +12,11 @@ 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://oplist.org/zh/
@@ -38,7 +38,7 @@ class Alist(StorageBase, metaclass=Singleton):
         """
         初始化
         """
-        pass
+        self.__generate_token.clear_cache()  # noqa
 
     @property
     def __get_base_url(self) -> str:
@@ -127,7 +127,7 @@ class Alist(StorageBase, metaclass=Singleton):
         """
         检查存储是否可用
         """
-        pass
+        return True if self.__generate_token else False
 
     def list(
             self,
@@ -376,10 +376,46 @@ 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
         """
+        # 如果是空目录，优先用 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(
@@ -389,20 +425,6 @@ 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"【OpenList】请求删除文件 {fileitem.path} 失败，无法连接alist服务")
             return False
@@ -411,7 +433,6 @@ class Alist(StorageBase, metaclass=Singleton):
                 f"【OpenList】请求删除文件 {fileitem.path} 失败，状态码：{resp.status_code}"
             )
             return False
-
         result = resp.json()
         if result["code"] != 200:
             logger.warn(

app/modules/filemanager/storages/local.py

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

app/modules/filemanager/storages/smb.py

@@ -0,0 +1,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

@@ -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,18 +41,12 @@ class U115Pan(StorageBase, metaclass=Singleton):
         "move": "移动",
         "copy": "复制"
     }
-
-    # 验证参数
-    _auth_state = {}
-
-    # 上传进度值
-    _last_progress = 0
-
     # 基础url
     base_url = "https://proapi.115.com"
 
     def __init__(self):
         super().__init__()
+        self._auth_state = {}
         self.session = requests.Session()
         self._init_session()
 
@@ -219,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)
 
         # 处理请求错误
@@ -489,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"]

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,

app/modules/indexer/__init__.py

@@ -5,10 +5,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

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

app/modules/indexer/parser/nexus_hhanclub.py

@@ -17,21 +17,25 @@ class NexusHhanclubSiteUserInfo(NexusPhpSiteUserInfo):
         html_text = self._prepare_html_text(html_text)
         html = etree.HTML(html_text)
 
-        # 上传、下载、分享率
-        upload_match = re.search(r"[_<>/a-zA-Z-=\"'\s#;]+([\d,.\s]+[KMGTPI]*B)",
-                                 html.xpath('//*[@id="user-info-panel"]/div[2]/div[2]/div[4]/text()')[0])
-        download_match = re.search(r"[_<>/a-zA-Z-=\"'\s#;]+([\d,.\s]+[KMGTPI]*B)",
-                                   html.xpath('//*[@id="user-info-panel"]/div[2]/div[2]/div[5]/text()')[0])
-        ratio_match = re.search(r"分享率][:：_<>/a-zA-Z-=\"'\s#;]+([\d,.\s]+)",
-                                html.xpath('//*[@id="user-info-panel"]/div[2]/div[1]/div[1]/div/text()')[0])
+        try:
+            # 上传、下载、分享率
+            upload_match = re.search(r"[_<>/a-zA-Z-=\"'\s#;]+([\d,.\s]+[KMGTPI]*B)",
+                                     html.xpath('//*[@id="user-info-panel"]/div[2]/div[2]/div[4]/text()')[0])
+            download_match = re.search(r"[_<>/a-zA-Z-=\"'\s#;]+([\d,.\s]+[KMGTPI]*B)",
+                                       html.xpath('//*[@id="user-info-panel"]/div[2]/div[2]/div[5]/text()')[0])
+            ratio_match = re.search(r"分享率][:：_<>/a-zA-Z-=\"'\s#;]+([\d,.\s]+)",
+                                    html.xpath('//*[@id="user-info-panel"]/div[2]/div[1]/div[1]/div/text()')[0])
 
-        # 计算分享率
-        self.upload = StringUtils.num_filesize(upload_match.group(1).strip()) if upload_match else 0
-        self.download = StringUtils.num_filesize(download_match.group(1).strip()) if download_match else 0
-        # 优先使用页面上的分享率
-        calc_ratio = 0.0 if self.download <= 0.0 else round(self.upload / self.download, 3)
-        self.ratio = StringUtils.str_float(ratio_match.group(1)) if (
-                ratio_match and ratio_match.group(1).strip()) else calc_ratio
+            # 计算分享率
+            self.upload = StringUtils.num_filesize(upload_match.group(1).strip()) if upload_match else 0
+            self.download = StringUtils.num_filesize(download_match.group(1).strip()) if download_match else 0
+            # 优先使用页面上的分享率
+            calc_ratio = 0.0 if self.download <= 0.0 else round(self.upload / self.download, 3)
+            self.ratio = StringUtils.str_float(ratio_match.group(1)) if (
+                    ratio_match and ratio_match.group(1).strip()) else calc_ratio
+        finally:
+            if html is not None:
+                del html
 
     def _parse_user_detail_info(self, html_text: str):
         """
@@ -42,12 +46,16 @@ class NexusHhanclubSiteUserInfo(NexusPhpSiteUserInfo):
         super()._parse_user_detail_info(html_text)
 
         html = etree.HTML(html_text)
-        if not StringUtils.is_valid_html_element(html):
-            return
-        # 加入时间
-        join_at_text = html.xpath('//*[@id="mainContent"]/div/div[2]/div[4]/div[3]/span[2]/text()[1]')
-        if join_at_text:
-            self.join_at = StringUtils.unify_datetime_str(join_at_text[0].split(' (')[0].strip())
+        try:
+            if not StringUtils.is_valid_html_element(html):
+                return
+            # 加入时间
+            join_at_text = html.xpath('//*[@id="mainContent"]/div/div[2]/div[4]/div[3]/span[2]/text()[1]')
+            if join_at_text:
+                self.join_at = StringUtils.unify_datetime_str(join_at_text[0].split(' (')[0].strip())
+        finally:
+            if html is not None:
+                del html
 
     def _get_user_level(self, html):
         super()._get_user_level(html)

app/modules/indexer/parser/nexus_php.py

@@ -34,21 +34,25 @@ class NexusPhpSiteUserInfo(SiteParserBase):
         :return:
         """
         html = etree.HTML(html_text)
-        if not StringUtils.is_valid_html_element(html):
-            return
+        try:
+            if not StringUtils.is_valid_html_element(html):
+                return
 
-        message_labels = html.xpath('//a[@href="messages.php"]/..')
-        message_labels.extend(html.xpath('//a[contains(@href, "messages.php")]/..'))
-        if message_labels:
-            message_text = message_labels[0].xpath("string(.)")
+            message_labels = html.xpath('//a[@href="messages.php"]/..')
+            message_labels.extend(html.xpath('//a[contains(@href, "messages.php")]/..'))
+            if message_labels:
+                message_text = message_labels[0].xpath("string(.)")
 
-            logger.debug(f"{self._site_name} 消息原始信息 {message_text}")
-            message_unread_match = re.findall(r"[^Date](信息箱\s*|\((?![^)]*:)|你有\xa0)(\d+)", message_text)
+                logger.debug(f"{self._site_name} 消息原始信息 {message_text}")
+                message_unread_match = re.findall(r"[^Date](信息箱\s*|\((?![^)]*:)|你有\xa0)(\d+)", message_text)
 
-            if message_unread_match and len(message_unread_match[-1]) == 2:
-                self.message_unread = StringUtils.str_int(message_unread_match[-1][1])
-            elif message_text.isdigit():
-                self.message_unread = StringUtils.str_int(message_text)
+                if message_unread_match and len(message_unread_match[-1]) == 2:
+                    self.message_unread = StringUtils.str_int(message_unread_match[-1][1])
+                elif message_text.isdigit():
+                    self.message_unread = StringUtils.str_int(message_text)
+        finally:
+            if html is not None:
+                del html
 
     def _parse_user_base_info(self, html_text: str):
         """
@@ -61,18 +65,23 @@ class NexusPhpSiteUserInfo(SiteParserBase):
         self._parse_message_unread(html_text)
 
         html = etree.HTML(html_text)
-        if not StringUtils.is_valid_html_element(html):
-            return
+        try:
+            if not StringUtils.is_valid_html_element(html):
+                return
 
-        ret = html.xpath(f'//a[contains(@href, "userdetails") and contains(@href, "{self.userid}")]//b//text()')
-        if ret:
-            self.username = str(ret[0])
-            return
-        ret = html.xpath(f'//a[contains(@href, "userdetails") and contains(@href, "{self.userid}")]//text()')
-        if ret:
-            self.username = str(ret[0])
+            ret = html.xpath(f'//a[contains(@href, "userdetails") and contains(@href, "{self.userid}")]//b//text()')
+            if ret:
+                self.username = str(ret[0])
+                return
+            ret = html.xpath(f'//a[contains(@href, "userdetails") and contains(@href, "{self.userid}")]//text()')
+            if ret:
+                self.username = str(ret[0])
+
+            ret = html.xpath('//a[contains(@href, "userdetails")]//strong//text()')
+        finally:
+            if html is not None:
+                del html
 
-        ret = html.xpath('//a[contains(@href, "userdetails")]//strong//text()')
         if ret:
             self.username = str(ret[0])
             return
@@ -98,28 +107,32 @@ class NexusPhpSiteUserInfo(SiteParserBase):
         self.leeching = StringUtils.str_int(leeching_match.group(2)) if leeching_match and leeching_match.group(
             2).strip() else 0
         html = etree.HTML(html_text)
-        has_ucoin, self.bonus = self._parse_ucoin(html)
-        if has_ucoin:
-            return
-        tmps = html.xpath('//a[contains(@href,"mybonus")]/text()') if html else None
-        if tmps:
-            bonus_text = str(tmps[0]).strip()
-            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))
-                return
-        bonus_match = re.search(r"mybonus.[\[\]:：<>/a-zA-Z_\-=\"'\s#;.(使用魔力值豆]+\s*([\d,.]+)[<()&\s]", html_text)
         try:
-            if bonus_match and bonus_match.group(1).strip():
-                self.bonus = StringUtils.str_float(bonus_match.group(1))
+            has_ucoin, self.bonus = self._parse_ucoin(html)
+            if has_ucoin:
                 return
-            bonus_match = re.search(r"[魔力值|\]][\[\]:：<>/a-zA-Z_\-=\"'\s#;]+\s*([\d,.]+|\"[\d,.]+\")[<>()&\s]",
-                                    html_text,
-                                    flags=re.S)
-            if bonus_match and bonus_match.group(1).strip():
-                self.bonus = StringUtils.str_float(bonus_match.group(1).strip('"'))
-        except Exception as err:
-            logger.error(f"{self._site_name} 解析魔力值出错, 错误信息: {str(err)}")
+            tmps = html.xpath('//a[contains(@href,"mybonus")]/text()') if html else None
+            if tmps:
+                bonus_text = str(tmps[0]).strip()
+                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))
+                    return
+            bonus_match = re.search(r"mybonus.[\[\]:：<>/a-zA-Z_\-=\"'\s#;.(使用魔力值豆]+\s*([\d,.]+)[<()&\s]", html_text)
+            try:
+                if bonus_match and bonus_match.group(1).strip():
+                    self.bonus = StringUtils.str_float(bonus_match.group(1))
+                    return
+                bonus_match = re.search(r"[魔力值|\]][\[\]:：<>/a-zA-Z_\-=\"'\s#;]+\s*([\d,.]+|\"[\d,.]+\")[<>()&\s]",
+                                        html_text,
+                                        flags=re.S)
+                if bonus_match and bonus_match.group(1).strip():
+                    self.bonus = StringUtils.str_float(bonus_match.group(1).strip('"'))
+            except Exception as err:
+                logger.error(f"{self._site_name} 解析魔力值出错, 错误信息: {str(err)}")
+        finally:
+            if html is not None:
+                del html
 
     @staticmethod
     def _parse_ucoin(html):
@@ -155,72 +168,76 @@ class NexusPhpSiteUserInfo(SiteParserBase):
         :return: 下页地址
         """
         html = etree.HTML(str(html_text).replace(r'\/', '/'))
-        if not StringUtils.is_valid_html_element(html):
-            return None
+        try:
+            if not StringUtils.is_valid_html_element(html):
+                return None
 
-        # 首页存在扩展链接，使用扩展链接
-        seeding_url_text = html.xpath('//a[contains(@href,"torrents.php") '
-                                      'and contains(@href,"seeding")]/@href')
-        if multi_page is False and seeding_url_text and seeding_url_text[0].strip():
-            self._torrent_seeding_page = seeding_url_text[0].strip()
-            return self._torrent_seeding_page
+            # 首页存在扩展链接，使用扩展链接
+            seeding_url_text = html.xpath('//a[contains(@href,"torrents.php") '
+                                          'and contains(@href,"seeding")]/@href')
+            if multi_page is False and seeding_url_text and seeding_url_text[0].strip():
+                self._torrent_seeding_page = seeding_url_text[0].strip()
+                return self._torrent_seeding_page
 
-        size_col = 3
-        seeders_col = 4
-        # 搜索size列
-        size_col_xpath = '//tr[position()=1]/' \
-                         'td[(img[@class="size"] and img[@alt="size"])' \
-                         ' or (text() = "大小")' \
-                         ' or (a/img[@class="size" and @alt="size"])]'
-        if html.xpath(size_col_xpath):
-            size_col = len(html.xpath(f'{size_col_xpath}/preceding-sibling::td')) + 1
-        # 搜索seeders列
-        seeders_col_xpath = '//tr[position()=1]/' \
-                            'td[(img[@class="seeders"] and img[@alt="seeders"])' \
-                            ' or (text() = "在做种")' \
-                            ' or (a/img[@class="seeders" and @alt="seeders"])]'
-        if html.xpath(seeders_col_xpath):
-            seeders_col = len(html.xpath(f'{seeders_col_xpath}/preceding-sibling::td')) + 1
+            size_col = 3
+            seeders_col = 4
+            # 搜索size列
+            size_col_xpath = '//tr[position()=1]/' \
+                             'td[(img[@class="size"] and img[@alt="size"])' \
+                             ' or (text() = "大小")' \
+                             ' or (a/img[@class="size" and @alt="size"])]'
+            if html.xpath(size_col_xpath):
+                size_col = len(html.xpath(f'{size_col_xpath}/preceding-sibling::td')) + 1
+            # 搜索seeders列
+            seeders_col_xpath = '//tr[position()=1]/' \
+                                'td[(img[@class="seeders"] and img[@alt="seeders"])' \
+                                ' or (text() = "在做种")' \
+                                ' or (a/img[@class="seeders" and @alt="seeders"])]'
+            if html.xpath(seeders_col_xpath):
+                seeders_col = len(html.xpath(f'{seeders_col_xpath}/preceding-sibling::td')) + 1
 
-        page_seeding = 0
-        page_seeding_size = 0
-        page_seeding_info = []
-        # 如果 table class="torrents"，则增加table[@class="torrents"]
-        table_class = '//table[@class="torrents"]' if html.xpath('//table[@class="torrents"]') else ''
-        seeding_sizes = html.xpath(f'{table_class}//tr[position()>1]/td[{size_col}]')
-        seeding_seeders = html.xpath(f'{table_class}//tr[position()>1]/td[{seeders_col}]/b/a/text()')
-        if not seeding_seeders:
-            seeding_seeders = html.xpath(f'{table_class}//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 = []
+            # 如果 table class="torrents"，则增加table[@class="torrents"]
+            table_class = '//table[@class="torrents"]' if html.xpath('//table[@class="torrents"]') else ''
+            seeding_sizes = html.xpath(f'{table_class}//tr[position()>1]/td[{size_col}]')
+            seeding_seeders = html.xpath(f'{table_class}//tr[position()>1]/td[{seeders_col}]/b/a/text()')
+            if not seeding_seeders:
+                seeding_seeders = html.xpath(f'{table_class}//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(), "下一頁") or contains(.//text(), ">")]/@href')
-
-        # 防止识别到详情页
-        while next_page_text:
-            next_page = next_page_text.pop().strip()
-            if not next_page.startswith('details.php'):
-                break
+            # 是否存在下页数据
             next_page = None
+            next_page_text = html.xpath(
+                '//a[contains(.//text(), "下一页") or contains(.//text(), "下一頁") or contains(.//text(), ">")]/@href')
 
-        # fix up page url
-        if next_page:
-            if self.userid not in next_page:
-                next_page = f'{next_page}&userid={self.userid}&type=seeding'
+            # 防止识别到详情页
+            while next_page_text:
+                next_page = next_page_text.pop().strip()
+                if not next_page.startswith('details.php'):
+                    break
+                next_page = None
+
+            # fix up page url
+            if next_page:
+                if self.userid not in next_page:
+                    next_page = f'{next_page}&userid={self.userid}&type=seeding'
+        finally:
+            if html is not None:
+                del html
 
         return next_page
 
@@ -231,57 +248,61 @@ class NexusPhpSiteUserInfo(SiteParserBase):
         :return:
         """
         html = etree.HTML(html_text)
-        if not StringUtils.is_valid_html_element(html):
-            return
+        try:
+            if not StringUtils.is_valid_html_element(html):
+                return
 
-        self._get_user_level(html)
+            self._get_user_level(html)
 
-        self._fixup_traffic_info(html)
+            self._fixup_traffic_info(html)
 
-        # 加入日期
-        join_at_text = html.xpath(
-            '//tr/td[text()="加入日期" or text()="注册日期" or *[text()="加入日期"]]/following-sibling::td[1]//text()'
-            '|//div/b[text()="加入日期"]/../text()')
-        if join_at_text:
-            self.join_at = StringUtils.unify_datetime_str(join_at_text[0].split(' (')[0].strip())
+            # 加入日期
+            join_at_text = html.xpath(
+                '//tr/td[text()="加入日期" or text()="注册日期" or *[text()="加入日期"]]/following-sibling::td[1]//text()'
+                '|//div/b[text()="加入日期"]/../text()')
+            if join_at_text:
+                self.join_at = StringUtils.unify_datetime_str(join_at_text[0].split(' (')[0].strip())
 
-        # 做种体积 & 做种数
-        # seeding 页面获取不到的话，此处再获取一次
-        seeding_sizes = html.xpath('//tr/td[text()="当前上传"]/following-sibling::td[1]//'
-                                   'table[tr[1][td[4 and text()="尺寸"]]]//tr[position()>1]/td[4]')
-        seeding_seeders = html.xpath('//tr/td[text()="当前上传"]/following-sibling::td[1]//'
-                                     'table[tr[1][td[5 and text()="做种者"]]]//tr[position()>1]/td[5]//text()')
-        tmp_seeding = len(seeding_sizes)
-        tmp_seeding_size = 0
-        tmp_seeding_info = []
-        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])
+            # 做种体积 & 做种数
+            # seeding 页面获取不到的话，此处再获取一次
+            seeding_sizes = html.xpath('//tr/td[text()="当前上传"]/following-sibling::td[1]//'
+                                       'table[tr[1][td[4 and text()="尺寸"]]]//tr[position()>1]/td[4]')
+            seeding_seeders = html.xpath('//tr/td[text()="当前上传"]/following-sibling::td[1]//'
+                                         'table[tr[1][td[5 and text()="做种者"]]]//tr[position()>1]/td[5]//text()')
+            tmp_seeding = len(seeding_sizes)
+            tmp_seeding_size = 0
+            tmp_seeding_info = []
+            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])
 
-            tmp_seeding_size += size
-            tmp_seeding_info.append([seeders, size])
+                tmp_seeding_size += size
+                tmp_seeding_info.append([seeders, size])
 
-        if not self.seeding_size:
-            self.seeding_size = tmp_seeding_size
-        if not self.seeding:
-            self.seeding = tmp_seeding
-        if not self.seeding_info:
-            self.seeding_info = tmp_seeding_info
+            if not self.seeding_size:
+                self.seeding_size = tmp_seeding_size
+            if not self.seeding:
+                self.seeding = tmp_seeding
+            if not self.seeding_info:
+                self.seeding_info = tmp_seeding_info
 
-        seeding_sizes = html.xpath('//tr/td[text()="做种统计"]/following-sibling::td[1]//text()')
-        if seeding_sizes:
-            seeding_match = re.search(r"总做种数:\s+(\d+)", seeding_sizes[0], re.IGNORECASE)
-            seeding_size_match = re.search(r"总做种体积:\s+([\d,.\s]+[KMGTPI]*B)", seeding_sizes[0], re.IGNORECASE)
-            tmp_seeding = StringUtils.str_int(seeding_match.group(1)) if (
-                    seeding_match and seeding_match.group(1)) else 0
-            tmp_seeding_size = StringUtils.num_filesize(
-                seeding_size_match.group(1).strip()) if seeding_size_match else 0
-        if not self.seeding_size:
-            self.seeding_size = tmp_seeding_size
-        if not self.seeding:
-            self.seeding = tmp_seeding
+            seeding_sizes = html.xpath('//tr/td[text()="做种统计"]/following-sibling::td[1]//text()')
+            if seeding_sizes:
+                seeding_match = re.search(r"总做种数:\s+(\d+)", seeding_sizes[0], re.IGNORECASE)
+                seeding_size_match = re.search(r"总做种体积:\s+([\d,.\s]+[KMGTPI]*B)", seeding_sizes[0], re.IGNORECASE)
+                tmp_seeding = StringUtils.str_int(seeding_match.group(1)) if (
+                        seeding_match and seeding_match.group(1)) else 0
+                tmp_seeding_size = StringUtils.num_filesize(
+                    seeding_size_match.group(1).strip()) if seeding_size_match else 0
+            if not self.seeding_size:
+                self.seeding_size = tmp_seeding_size
+            if not self.seeding:
+                self.seeding = tmp_seeding
 
-        self._fixup_torrent_seeding_page(html)
+            self._fixup_torrent_seeding_page(html)
+        finally:
+            if html is not None:
+                del html
 
     def _fixup_torrent_seeding_page(self, html):
         """
@@ -348,43 +369,51 @@ class NexusPhpSiteUserInfo(SiteParserBase):
 
     def _parse_message_unread_links(self, html_text: str, msg_links: list) -> Optional[str]:
         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
 
-        message_links = html.xpath('//tr[not(./td/img[@alt="Read"])]/td/a[contains(@href, "viewmessage")]/@href')
-        msg_links.extend(message_links)
-        # 是否存在下页数据
-        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()
+            message_links = html.xpath('//tr[not(./td/img[@alt="Read"])]/td/a[contains(@href, "viewmessage")]/@href')
+            msg_links.extend(message_links)
+            # 是否存在下页数据
+            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
 
     def _parse_message_content(self, html_text):
         html = etree.HTML(html_text)
-        if not StringUtils.is_valid_html_element(html):
-            return None, None, None
-        # 标题
-        message_head_text = None
-        message_head = html.xpath('//h1/text()'
-                                  '|//div[@class="layui-card-header"]/span[1]/text()')
-        if message_head:
-            message_head_text = message_head[-1].strip()
+        try:
+            if not StringUtils.is_valid_html_element(html):
+                return None, None, None
+            # 标题
+            message_head_text = None
+            message_head = html.xpath('//h1/text()'
+                                      '|//div[@class="layui-card-header"]/span[1]/text()')
+            if message_head:
+                message_head_text = message_head[-1].strip()
 
-        # 消息时间
-        message_date_text = None
-        message_date = html.xpath('//h1/following-sibling::table[.//tr/td[@class="colhead"]]//tr[2]/td[2]'
-                                  '|//div[@class="layui-card-header"]/span[2]/span[2]')
-        if message_date:
-            message_date_text = message_date[0].xpath("string(.)").strip()
+            # 消息时间
+            message_date_text = None
+            message_date = html.xpath('//h1/following-sibling::table[.//tr/td[@class="colhead"]]//tr[2]/td[2]'
+                                      '|//div[@class="layui-card-header"]/span[2]/span[2]')
+            if message_date:
+                message_date_text = message_date[0].xpath("string(.)").strip()
 
-        # 消息内容
-        message_content_text = None
-        message_content = html.xpath('//h1/following-sibling::table[.//tr/td[@class="colhead"]]//tr[3]/td'
-                                     '|//div[contains(@class,"layui-card-body")]')
-        if message_content:
-            message_content_text = message_content[0].xpath("string(.)").strip()
+            # 消息内容
+            message_content_text = None
+            message_content = html.xpath('//h1/following-sibling::table[.//tr/td[@class="colhead"]]//tr[3]/td'
+                                         '|//div[contains(@class,"layui-card-body")]')
+            if message_content:
+                message_content_text = message_content[0].xpath("string(.)").strip()
+        finally:
+            if html is not None:
+                del html
 
         return message_head_text, message_date_text, message_content_text
 

app/modules/indexer/parser/nexus_rabbit.py

@@ -114,48 +114,56 @@ class NexusRabbitSiteUserInfo(SiteParserBase):
     def _parse_user_base_info(self, html_text: str):
         """只有奶糖余额才需要在 base 中获取，其它均可以在详情页拿到"""
         html = etree.HTML(html_text)
-        if not StringUtils.is_valid_html_element(html):
-            return
-        bonus = html.xpath(
-            '//div[contains(text(), "奶糖余额")]/following-sibling::div[1]/text()'
-        )
-        if bonus:
-            self.bonus = StringUtils.str_float(bonus[0].strip())
+        try:
+            if not StringUtils.is_valid_html_element(html):
+                return
+            bonus = html.xpath(
+                '//div[contains(text(), "奶糖余额")]/following-sibling::div[1]/text()'
+            )
+            if bonus:
+                self.bonus = StringUtils.str_float(bonus[0].strip())
+        finally:
+            if html is not None:
+                del html
 
     def _parse_user_detail_info(self, html_text: str):
         html = etree.HTML(html_text)
-        if not StringUtils.is_valid_html_element(html):
-            return
-        # 缩小一下查找范围，所有的信息都在这个 div 里
-        user_info = html.xpath('//div[contains(@class, "layui-hares-user-info-right")]')
-        if not user_info:
-            return
-        user_info = user_info[0]
-        # 用户名
-        if username := user_info.xpath(
-            './/span[contains(text(), "用户名")]/a/span/text()'
-        ):
-            self.username = username[0].strip()
-        # 等级
-        if user_level := user_info.xpath('.//span[contains(text(), "等级")]/b/text()'):
-            self.user_level = user_level[0].strip()
-        # 加入日期
-        if join_date := user_info.xpath('.//span[contains(text(), "注册日期")]/text()'):
-            join_date = join_date[0].strip().split("\r")[0].removeprefix("注册日期：")
-            self.join_at = StringUtils.unify_datetime_str(join_date)
-        # 上传量
-        if upload := user_info.xpath('.//span[contains(text(), "上传量")]/text()'):
-            self.upload = StringUtils.num_filesize(
-                upload[0].strip().removeprefix("上传量：")
-            )
-        # 下载量
-        if download := user_info.xpath('.//span[contains(text(), "下载量")]/text()'):
-            self.download = StringUtils.num_filesize(
-                download[0].strip().removeprefix("下载量：")
-            )
-        # 分享率
-        if ratio := user_info.xpath('.//span[contains(text(), "分享率")]/em/text()'):
-            self.ratio = StringUtils.str_float(ratio[0].strip())
+        try:
+            if not StringUtils.is_valid_html_element(html):
+                return
+            # 缩小一下查找范围，所有的信息都在这个 div 里
+            user_info = html.xpath('//div[contains(@class, "layui-hares-user-info-right")]')
+            if not user_info:
+                return
+            user_info = user_info[0]
+            # 用户名
+            if username := user_info.xpath(
+                './/span[contains(text(), "用户名")]/a/span/text()'
+            ):
+                self.username = username[0].strip()
+            # 等级
+            if user_level := user_info.xpath('.//span[contains(text(), "等级")]/b/text()'):
+                self.user_level = user_level[0].strip()
+            # 加入日期
+            if join_date := user_info.xpath('.//span[contains(text(), "注册日期")]/text()'):
+                join_date = join_date[0].strip().split("\r")[0].removeprefix("注册日期：")
+                self.join_at = StringUtils.unify_datetime_str(join_date)
+            # 上传量
+            if upload := user_info.xpath('.//span[contains(text(), "上传量")]/text()'):
+                self.upload = StringUtils.num_filesize(
+                    upload[0].strip().removeprefix("上传量：")
+                )
+            # 下载量
+            if download := user_info.xpath('.//span[contains(text(), "下载量")]/text()'):
+                self.download = StringUtils.num_filesize(
+                    download[0].strip().removeprefix("下载量：")
+                )
+            # 分享率
+            if ratio := user_info.xpath('.//span[contains(text(), "分享率")]/em/text()'):
+                self.ratio = StringUtils.str_float(ratio[0].strip())
+        finally:
+            if html is not None:
+                del html
 
     def _parse_message_content(self, html_text):
         """

app/modules/indexer/parser/small_horse.py

@@ -24,9 +24,13 @@ class SmallHorseSiteUserInfo(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('//a[contains(@href, "user.php")]//text()')
-        if ret:
-            self.username = str(ret[0])
+        try:
+            ret = html.xpath('//a[contains(@href, "user.php")]//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):
         """
@@ -36,21 +40,25 @@ class SmallHorseSiteUserInfo(SiteParserBase):
         """
         html_text = self._prepare_html_text(html_text)
         html = etree.HTML(html_text)
-        tmps = html.xpath('//ul[@class = "stats nobullet"]')
-        if tmps:
-            if tmps[1].xpath("li") and tmps[1].xpath("li")[0].xpath("span//text()"):
-                self.join_at = StringUtils.unify_datetime_str(tmps[1].xpath("li")[0].xpath("span//text()")[0])
-            self.upload = StringUtils.num_filesize(str(tmps[1].xpath("li")[2].xpath("text()")[0]).split(":")[1].strip())
-            self.download = StringUtils.num_filesize(
-                str(tmps[1].xpath("li")[3].xpath("text()")[0]).split(":")[1].strip())
-            if tmps[1].xpath("li")[4].xpath("span//text()"):
-                self.ratio = StringUtils.str_float(str(tmps[1].xpath("li")[4].xpath("span//text()")[0]).replace('∞', '0'))
-            else:
-                self.ratio = StringUtils.str_float(str(tmps[1].xpath("li")[5].xpath("text()")[0]).split(":")[1])
-            self.bonus = StringUtils.str_float(str(tmps[1].xpath("li")[5].xpath("text()")[0]).split(":")[1])
-            self.user_level = str(tmps[3].xpath("li")[0].xpath("text()")[0]).split(":")[1].strip()
-            self.leeching = StringUtils.str_int(
-                (tmps[4].xpath("li")[6].xpath("text()")[0]).split(":")[1].replace("[", ""))
+        try:
+            tmps = html.xpath('//ul[@class = "stats nobullet"]')
+            if tmps:
+                if tmps[1].xpath("li") and tmps[1].xpath("li")[0].xpath("span//text()"):
+                    self.join_at = StringUtils.unify_datetime_str(tmps[1].xpath("li")[0].xpath("span//text()")[0])
+                self.upload = StringUtils.num_filesize(str(tmps[1].xpath("li")[2].xpath("text()")[0]).split(":")[1].strip())
+                self.download = StringUtils.num_filesize(
+                    str(tmps[1].xpath("li")[3].xpath("text()")[0]).split(":")[1].strip())
+                if tmps[1].xpath("li")[4].xpath("span//text()"):
+                    self.ratio = StringUtils.str_float(str(tmps[1].xpath("li")[4].xpath("span//text()")[0]).replace('∞', '0'))
+                else:
+                    self.ratio = StringUtils.str_float(str(tmps[1].xpath("li")[5].xpath("text()")[0]).split(":")[1])
+                self.bonus = StringUtils.str_float(str(tmps[1].xpath("li")[5].xpath("text()")[0]).split(":")[1])
+                self.user_level = str(tmps[3].xpath("li")[0].xpath("text()")[0]).split(":")[1].strip()
+                self.leeching = StringUtils.str_int(
+                    (tmps[4].xpath("li")[6].xpath("text()")[0]).split(":")[1].replace("[", ""))
+        finally:
+            if html is not None:
+                del html
 
     def _parse_user_detail_info(self, html_text: str):
         pass
@@ -63,39 +71,42 @@ class SmallHorseSiteUserInfo(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 = 8
+            size_col = 6
+            seeders_col = 8
 
-        page_seeding = 0
-        page_seeding_size = 0
-        page_seeding_info = []
-        seeding_sizes = html.xpath(f'//table[@id="torrent_table"]//tr[position()>1]/td[{size_col}]')
-        seeding_seeders = html.xpath(f'//table[@id="torrent_table"]//tr[position()>1]/td[{seeders_col}]')
-        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[@id="torrent_table"]//tr[position()>1]/td[{size_col}]')
+            seeding_seeders = html.xpath(f'//table[@id="torrent_table"]//tr[position()>1]/td[{seeders_col}]')
+            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].xpath("string(.)").strip())
+                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 += page_seeding
-        self.seeding_size += page_seeding_size
-        self.seeding_info.extend(page_seeding_info)
-
-        # 是否存在下页数据
-        next_page = None
-        next_pages = html.xpath('//ul[@class="pagination"]/li[contains(@class,"active")]/following-sibling::li')
-        if next_pages and len(next_pages) > 1:
-            page_num = next_pages[0].xpath("string(.)").strip()
-            if page_num.isdigit():
-                next_page = f"{self._torrent_seeding_page}&page={page_num}"
+            self.seeding += page_seeding
+            self.seeding_size += page_seeding_size
+            self.seeding_info.extend(page_seeding_info)
 
+            # 是否存在下页数据
+            next_page = None
+            next_pages = html.xpath('//ul[@class="pagination"]/li[contains(@class,"active")]/following-sibling::li')
+            if next_pages and len(next_pages) > 1:
+                page_num = next_pages[0].xpath("string(.)").strip()
+                if page_num.isdigit():
+                    next_page = f"{self._torrent_seeding_page}&page={page_num}"
+        finally:
+            if html is not None:
+                del html
         return next_page
 
     def _parse_message_unread_links(self, html_text: str, msg_links: list) -> Optional[str]:

app/modules/indexer/parser/torrent_leech.py

@@ -32,29 +32,33 @@ class TorrentLeechSiteUserInfo(SiteParserBase):
         """
         html_text = self._prepare_html_text(html_text)
         html = etree.HTML(html_text)
-        upload_html = html.xpath('//div[contains(@class,"profile-uploaded")]//span/text()')
-        if upload_html:
-            self.upload = StringUtils.num_filesize(upload_html[0])
-        download_html = html.xpath('//div[contains(@class,"profile-downloaded")]//span/text()')
-        if download_html:
-            self.download = StringUtils.num_filesize(download_html[0])
-        ratio_html = html.xpath('//div[contains(@class,"profile-ratio")]//span/text()')
-        if ratio_html:
-            self.ratio = StringUtils.str_float(ratio_html[0].replace('∞', '0'))
+        try:
+            upload_html = html.xpath('//div[contains(@class,"profile-uploaded")]//span/text()')
+            if upload_html:
+                self.upload = StringUtils.num_filesize(upload_html[0])
+            download_html = html.xpath('//div[contains(@class,"profile-downloaded")]//span/text()')
+            if download_html:
+                self.download = StringUtils.num_filesize(download_html[0])
+            ratio_html = html.xpath('//div[contains(@class,"profile-ratio")]//span/text()')
+            if ratio_html:
+                self.ratio = StringUtils.str_float(ratio_html[0].replace('∞', '0'))
 
-        user_level_html = html.xpath('//table[contains(@class, "profileViewTable")]'
-                                     '//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[contains(@class, "profileViewTable")]'
+                                         '//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[contains(@class, "profileViewTable")]'
-                                  '//tr/td[text()="Registration date"]/following-sibling::td/text()')
-        if join_at_html:
-            self.join_at = StringUtils.unify_datetime_str(join_at_html[0].strip())
+            join_at_html = html.xpath('//table[contains(@class, "profileViewTable")]'
+                                      '//tr/td[text()="Registration date"]/following-sibling::td/text()')
+            if join_at_html:
+                self.join_at = StringUtils.unify_datetime_str(join_at_html[0].strip())
 
-        bonus_html = html.xpath('//span[contains(@class, "total-TL-points")]/text()')
-        if bonus_html:
-            self.bonus = StringUtils.str_float(bonus_html[0].strip())
+            bonus_html = html.xpath('//span[contains(@class, "total-TL-points")]/text()')
+            if bonus_html:
+                self.bonus = StringUtils.str_float(bonus_html[0].strip())
+        finally:
+            if html is not None:
+                del html
 
     def _parse_user_detail_info(self, html_text: str):
         pass
@@ -67,33 +71,37 @@ class TorrentLeechSiteUserInfo(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 = 2
-        seeders_col = 7
+            size_col = 2
+            seeders_col = 7
 
-        page_seeding = 0
-        page_seeding_size = 0
-        page_seeding_info = []
-        seeding_sizes = html.xpath(f'//tbody/tr/td[{size_col}]')
-        seeding_seeders = html.xpath(f'//tbody/tr/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'//tbody/tr/td[{size_col}]')
+            seeding_seeders = html.xpath(f'//tbody/tr/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 = None
+        finally:
+            if html is not None:
+                del html
 
         return next_page
 

app/modules/indexer/parser/unit3d.py

@@ -14,21 +14,24 @@ class Unit3dSiteUserInfo(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, "/users/") and contains(@href, "settings")]/@href')
+            if tmps:
+                user_name_match = re.search(r"/users/(.+)/settings", tmps[0])
+                if user_name_match and user_name_match.group().strip():
+                    self.username = user_name_match.group(1)
+                    self._torrent_seeding_page = f"/users/{self.username}/active?perPage=100&client=&seeding=include"
+                    self._user_detail_page = f"/users/{self.username}"
 
-        tmps = html.xpath('//a[contains(@href, "/users/") and contains(@href, "settings")]/@href')
-        if tmps:
-            user_name_match = re.search(r"/users/(.+)/settings", tmps[0])
-            if user_name_match and user_name_match.group().strip():
-                self.username = user_name_match.group(1)
-                self._torrent_seeding_page = f"/users/{self.username}/active?perPage=100&client=&seeding=include"
-                self._user_detail_page = f"/users/{self.username}"
-
-        tmps = html.xpath('//a[contains(@href, "bonus/earnings")]')
-        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))
+            tmps = html.xpath('//a[contains(@href, "bonus/earnings")]')
+            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
@@ -40,21 +43,25 @@ class Unit3dSiteUserInfo(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('//div[contains(@class, "content")]//span[contains(@class, "badge-user")]/text()')
-        if user_levels_text:
-            self.user_level = user_levels_text[0].strip()
+            # 用户等级
+            user_levels_text = html.xpath('//div[contains(@class, "content")]//span[contains(@class, "badge-user")]/text()')
+            if user_levels_text:
+                self.user_level = user_levels_text[0].strip()
 
-        # 加入日期
-        join_at_text = html.xpath('//div[contains(@class, "content")]//h4[contains(text(), "注册日期") '
-                                  'or contains(text(), "註冊日期") '
-                                  'or contains(text(), "Registration date")]/text()')
-        if join_at_text:
-            self.join_at = StringUtils.unify_datetime_str(
-                join_at_text[0].replace('注册日期', '').replace('註冊日期', '').replace('Registration date', ''))
+            # 加入日期
+            join_at_text = html.xpath('//div[contains(@class, "content")]//h4[contains(text(), "注册日期") '
+                                      'or contains(text(), "註冊日期") '
+                                      'or contains(text(), "Registration date")]/text()')
+            if join_at_text:
+                self.join_at = StringUtils.unify_datetime_str(
+                    join_at_text[0].replace('注册日期', '').replace('註冊日期', '').replace('Registration date', ''))
+        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]:
         """
@@ -64,44 +71,48 @@ class Unit3dSiteUserInfo(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 = 9
-        seeders_col = 2
-        # 搜索size列
-        if html.xpath('//thead//th[contains(@class,"size")]'):
-            size_col = len(html.xpath('//thead//th[contains(@class,"size")][1]/preceding-sibling::th')) + 1
-        # 搜索seeders列
-        if html.xpath('//thead//th[contains(@class,"seeders")]'):
-            seeders_col = len(html.xpath('//thead//th[contains(@class,"seeders")]/preceding-sibling::th')) + 1
+            size_col = 9
+            seeders_col = 2
+            # 搜索size列
+            if html.xpath('//thead//th[contains(@class,"size")]'):
+                size_col = len(html.xpath('//thead//th[contains(@class,"size")][1]/preceding-sibling::th')) + 1
+            # 搜索seeders列
+            if html.xpath('//thead//th[contains(@class,"seeders")]'):
+                seeders_col = len(html.xpath('//thead//th[contains(@class,"seeders")]/preceding-sibling::th')) + 1
 
-        page_seeding = 0
-        page_seeding_size = 0
-        page_seeding_info = []
-        seeding_sizes = html.xpath(f'//tr[position()]/td[{size_col}]')
-        seeding_seeders = html.xpath(f'//tr[position()]/td[{seeders_col}]')
-        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()]/td[{size_col}]')
+            seeding_seeders = html.xpath(f'//tr[position()]/td[{seeders_col}]')
+            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].xpath("string(.)").strip())
+                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 += 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_pages = html.xpath('//ul[@class="pagination"]/li[contains(@class,"active")]/following-sibling::li')
-        if next_pages and len(next_pages) > 1:
-            page_num = next_pages[0].xpath("string(.)").strip()
-            if page_num.isdigit():
-                next_page = f"{self._torrent_seeding_page}&page={page_num}"
+            # 是否存在下页数据
+            next_page = None
+            next_pages = html.xpath('//ul[@class="pagination"]/li[contains(@class,"active")]/following-sibling::li')
+            if next_pages and len(next_pages) > 1:
+                page_num = next_pages[0].xpath("string(.)").strip()
+                if page_num.isdigit():
+                    next_page = f"{self._torrent_seeding_page}&page={page_num}"
+        finally:
+            if html is not None:
+                del html
 
         return next_page
 

app/modules/indexer/spider/__init__.py

@@ -0,0 +1,704 @@
+import datetime
+import re
+import traceback
+from typing import Any, Optional
+from typing import List
+from urllib.parse import quote, urlencode, urlparse, parse_qs
+
+from jinja2 import Template
+from pyquery import PyQuery
+
+from app.core.config import settings
+from app.log import logger
+from app.schemas.types import MediaType
+from app.utils.http import RequestUtils
+from app.utils.string import StringUtils
+
+
+class SiteSpider:
+    """
+    站点爬虫
+    """
+
+    @property
+    def __class__(self):
+        return object
+
+    @property
+    def __dict__(self):
+        return {}
+
+    @property
+    def __dir__(self):
+        raise AttributeError(f"Cannot read protected attribute!")
+
+    def __init__(self,
+                 indexer: dict,
+                 keyword: Optional[str] = None,
+                 mtype: MediaType = None,
+                 cat: Optional[str] = None,
+                 page: Optional[int] = 0,
+                 referer: Optional[str] = None):
+        """
+        设置查询参数
+        :param indexer: 索引器
+        :param keyword: 搜索关键字，如果数组则为批量搜索
+        :param mtype: 媒体类型
+        :param cat: 搜索分类
+        :param page: 页码
+        :param referer: Referer
+        """
+        if not indexer:
+            return
+        self.keyword = keyword
+        self.cat = cat
+        self.mtype = mtype
+        self.indexerid = indexer.get('id')
+        self.indexername = indexer.get('name')
+        self.search = indexer.get('search')
+        self.batch = indexer.get('batch')
+        self.browse = indexer.get('browse')
+        self.category = indexer.get('category')
+        self.list = indexer.get('torrents').get('list', {})
+        self.fields = indexer.get('torrents').get('fields')
+        if not keyword and self.browse:
+            self.list = self.browse.get('list') or self.list
+            self.fields = self.browse.get('fields') or self.fields
+        self.domain = indexer.get('domain')
+        self.result_num = int(indexer.get('result_num') or 100)
+        self._timeout = int(indexer.get('timeout') or 15)
+        self.page = page
+        if self.domain and not str(self.domain).endswith("/"):
+            self.domain = self.domain + "/"
+        self.ua = indexer.get('ua') or settings.USER_AGENT
+        self.proxies = settings.PROXY if indexer.get('proxy') else None
+        self.proxy_server = settings.PROXY_SERVER if indexer.get('proxy') else None
+        self.cookie = indexer.get('cookie')
+        self.referer = referer
+        # 初始化属性
+        self.is_error = False
+        self.torrents_info = {}
+        self.torrents_info_array = []
+
+    def get_torrents(self) -> List[dict]:
+        """
+        开始请求
+        """
+        if not self.search or not self.domain:
+            return []
+
+        # 种子搜索相对路径
+        paths = self.search.get('paths', [])
+        torrentspath = ""
+        if len(paths) == 1:
+            torrentspath = paths[0].get('path', '')
+        else:
+            for path in paths:
+                if path.get("type") == "all" and not self.mtype:
+                    torrentspath = path.get('path')
+                    break
+                elif path.get("type") == "movie" and self.mtype == MediaType.MOVIE:
+                    torrentspath = path.get('path')
+                    break
+                elif path.get("type") == "tv" and self.mtype == MediaType.TV:
+                    torrentspath = path.get('path')
+                    break
+
+        # 精确搜索
+        if self.keyword:
+            if isinstance(self.keyword, list):
+                # 批量查询
+                if self.batch:
+                    delimiter = self.batch.get('delimiter') or ' '
+                    space_replace = self.batch.get('space_replace') or ' '
+                    search_word = delimiter.join([str(k).replace(' ',
+                                                                 space_replace) for k in self.keyword])
+                else:
+                    search_word = " ".join(self.keyword)
+                # 查询模式：或
+                search_mode = "1"
+            else:
+                # 单个查询
+                search_word = self.keyword
+                # 查询模式与
+                search_mode = "0"
+
+            # 搜索URL
+            indexer_params = self.search.get("params", {}).copy()
+            if indexer_params:
+                search_area = indexer_params.get('search_area')
+                # search_area非0表示支持imdbid搜索
+                if (search_area and
+                        (not self.keyword or not self.keyword.startswith('tt'))):
+                    # 支持imdbid搜索，但关键字不是imdbid时，不启用imdbid搜索
+                    indexer_params.pop('search_area')
+                # 变量字典
+                inputs_dict = {
+                    "keyword": search_word
+                }
+                # 查询参数，默认查询标题
+                params = {
+                    "search_mode": search_mode,
+                    "search_area": 0,
+                    "page": self.page or 0,
+                    "notnewword": 1
+                }
+                # 额外参数
+                for key, value in indexer_params.items():
+                    params.update({
+                        "%s" % key: str(value).format(**inputs_dict)
+                    })
+                # 分类条件
+                if self.category:
+                    if self.mtype == MediaType.TV:
+                        cats = self.category.get("tv") or []
+                    elif self.mtype == MediaType.MOVIE:
+                        cats = self.category.get("movie") or []
+                    else:
+                        cats = (self.category.get("movie") or []) + (self.category.get("tv") or [])
+                    for cat in cats:
+                        if self.cat and str(cat.get("id")) not in self.cat:
+                            continue
+                        if self.category.get("field"):
+                            value = params.get(self.category.get("field"), "")
+                            params.update({
+                                "%s" % self.category.get("field"): value + self.category.get("delimiter",
+                                                                                             ' ') + cat.get("id")
+                            })
+                        else:
+                            params.update({
+                                "cat%s" % cat.get("id"): 1
+                            })
+                searchurl = self.domain + torrentspath + "?" + urlencode(params)
+            else:
+                # 变量字典
+                inputs_dict = {
+                    "keyword": quote(search_word),
+                    "page": self.page or 0
+                }
+                # 无额外参数
+                searchurl = self.domain + str(torrentspath).format(**inputs_dict)
+
+        # 列表浏览
+        else:
+            # 变量字典
+            inputs_dict = {
+                "page": self.page or 0,
+                "keyword": ""
+            }
+            # 有单独浏览路径
+            if self.browse:
+                torrentspath = self.browse.get("path")
+                if self.browse.get("start"):
+                    start_page = int(self.browse.get("start")) + int(self.page or 0)
+                    inputs_dict.update({
+                        "page": start_page
+                    })
+            elif self.page:
+                torrentspath = torrentspath + f"?page={self.page}"
+            # 搜索Url
+            searchurl = self.domain + str(torrentspath).format(**inputs_dict)
+
+        logger.info(f"开始请求：{searchurl}")
+
+        # requests请求
+        ret = RequestUtils(
+            ua=self.ua,
+            cookies=self.cookie,
+            timeout=self._timeout,
+            referer=self.referer,
+            proxies=self.proxies
+        ).get_res(searchurl, allow_redirects=True)
+        # 解析返回
+        return self.parse(
+            RequestUtils.get_decoded_html_content(
+                ret,
+                performance_mode=settings.ENCODING_DETECTION_PERFORMANCE_MODE,
+                confidence_threshold=settings.ENCODING_DETECTION_MIN_CONFIDENCE
+            )
+        )
+
+    def __get_title(self, torrent: Any):
+        # title default text
+        if 'title' not in self.fields:
+            return
+        selector = self.fields.get('title', {})
+        if 'selector' in selector:
+            self.torrents_info['title'] = self._safe_query(torrent, selector)
+        elif 'text' in selector:
+            render_dict = {}
+            if "title_default" in self.fields:
+                title_default_selector = self.fields.get('title_default', {})
+                title_default = self._safe_query(torrent, title_default_selector)
+                render_dict.update({'title_default': title_default})
+            if "title_optional" in self.fields:
+                title_optional_selector = self.fields.get('title_optional', {})
+                title_optional = self._safe_query(torrent, title_optional_selector)
+                render_dict.update({'title_optional': title_optional})
+            self.torrents_info['title'] = Template(selector.get('text')).render(fields=render_dict)
+        self.torrents_info['title'] = self.__filter_text(self.torrents_info.get('title'),
+                                                         selector.get('filters'))
+
+    def __get_description(self, torrent: Any):
+        # description text
+        if 'description' not in self.fields:
+            return
+        selector = self.fields.get('description', {})
+        if "selector" in selector or "selectors" in selector:
+            # 对于selectors情况，需要特殊处理selector_config
+            desc_selector = selector.copy()
+            if "selectors" in selector and "selector" not in selector:
+                desc_selector["selector"] = selector.get("selectors", "")
+            self.torrents_info['description'] = self._safe_query(torrent, desc_selector)
+        elif "text" in selector:
+            render_dict = {}
+            if "tags" in self.fields:
+                tags_selector = self.fields.get('tags', {})
+                tag = self._safe_query(torrent, tags_selector)
+                render_dict.update({'tags': tag})
+            if "subject" in self.fields:
+                subject_selector = self.fields.get('subject', {})
+                subject = self._safe_query(torrent, subject_selector)
+                render_dict.update({'subject': subject})
+            if "description_free_forever" in self.fields:
+                description_free_forever_selector = self.fields.get("description_free_forever", {})
+                description_free_forever = self._safe_query(torrent, description_free_forever_selector)
+                render_dict.update({"description_free_forever": description_free_forever})
+            if "description_normal" in self.fields:
+                description_normal_selector = self.fields.get("description_normal", {})
+                description_normal = self._safe_query(torrent, description_normal_selector)
+                render_dict.update({"description_normal": description_normal})
+            self.torrents_info['description'] = Template(selector.get('text')).render(fields=render_dict)
+        self.torrents_info['description'] = self.__filter_text(self.torrents_info.get('description'),
+                                                               selector.get('filters'))
+
+    def __get_detail(self, torrent: Any):
+        # details page text
+        if 'details' not in self.fields:
+            return
+        selector = self.fields.get('details', {})
+        item = self._safe_query(torrent, selector)
+        detail_link = self.__filter_text(item, selector.get('filters'))
+        if detail_link:
+            if not detail_link.startswith("http"):
+                if detail_link.startswith("//"):
+                    self.torrents_info['page_url'] = self.domain.split(":")[0] + ":" + detail_link
+                elif detail_link.startswith("/"):
+                    self.torrents_info['page_url'] = self.domain + detail_link[1:]
+                else:
+                    self.torrents_info['page_url'] = self.domain + detail_link
+            else:
+                self.torrents_info['page_url'] = detail_link
+
+    def __get_download(self, torrent: Any):
+        # download link text
+        if 'download' not in self.fields:
+            return
+        selector = self.fields.get('download', {})
+        item = self._safe_query(torrent, selector)
+        download_link = self.__filter_text(item, selector.get('filters'))
+        if download_link:
+            if not download_link.startswith("http") \
+                    and not download_link.startswith("magnet"):
+                _scheme, _domain = StringUtils.get_url_netloc(self.domain)
+                if _domain in download_link:
+                    if download_link.startswith("/"):
+                        self.torrents_info['enclosure'] = f"{_scheme}:{download_link}"
+                    else:
+                        self.torrents_info['enclosure'] = f"{_scheme}://{download_link}"
+                else:
+                    if download_link.startswith("/"):
+                        self.torrents_info['enclosure'] = f"{self.domain}{download_link[1:]}"
+                    else:
+                        self.torrents_info['enclosure'] = f"{self.domain}{download_link}"
+            else:
+                self.torrents_info['enclosure'] = download_link
+
+    def __get_imdbid(self, torrent: Any):
+        # imdbid
+        if "imdbid" not in self.fields:
+            return
+        selector = self.fields.get('imdbid', {})
+        item = self._safe_query(torrent, selector)
+        self.torrents_info['imdbid'] = self.__filter_text(item, selector.get('filters'))
+
+    def __get_size(self, torrent: Any):
+        # torrent size int
+        if 'size' not in self.fields:
+            return
+        selector = self.fields.get('size', {})
+        item = self._safe_query(torrent, selector)
+        if item:
+            size_val = item.replace("\n", "").strip()
+            size_val = self.__filter_text(size_val,
+                                          selector.get('filters'))
+            self.torrents_info['size'] = StringUtils.num_filesize(size_val)
+        else:
+            self.torrents_info['size'] = 0
+
+    def __get_leechers(self, torrent: Any):
+        # torrent leechers int
+        if 'leechers' not in self.fields:
+            return
+        selector = self.fields.get('leechers', {})
+        item = self._safe_query(torrent, selector)
+        if item:
+            peers_val = item.split("/")[0]
+            peers_val = peers_val.replace(",", "")
+            peers_val = self.__filter_text(peers_val, selector.get('filters'))
+            self.torrents_info['peers'] = int(peers_val) if peers_val and peers_val.isdigit() else 0
+        else:
+            self.torrents_info['peers'] = 0
+
+    def __get_seeders(self, torrent: Any):
+        # torrent seeders int
+        if 'seeders' not in self.fields:
+            return
+        selector = self.fields.get('seeders', {})
+        item = self._safe_query(torrent, selector)
+        if item:
+            seeders_val = item.split("/")[0]
+            seeders_val = seeders_val.replace(",", "")
+            seeders_val = self.__filter_text(seeders_val, selector.get('filters'))
+            self.torrents_info['seeders'] = int(seeders_val) if seeders_val and seeders_val.isdigit() else 0
+        else:
+            self.torrents_info['seeders'] = 0
+
+    def __get_grabs(self, torrent: Any):
+        # torrent grabs int
+        if 'grabs' not in self.fields:
+            return
+        selector = self.fields.get('grabs', {})
+        item = self._safe_query(torrent, selector)
+        if item:
+            grabs_val = item.split("/")[0]
+            grabs_val = grabs_val.replace(",", "")
+            grabs_val = self.__filter_text(grabs_val, selector.get('filters'))
+            self.torrents_info['grabs'] = int(grabs_val) if grabs_val and grabs_val.isdigit() else 0
+        else:
+            self.torrents_info['grabs'] = 0
+
+    def __get_pubdate(self, torrent: Any):
+        # torrent pubdate yyyy-mm-dd hh:mm:ss
+        if 'date_added' not in self.fields:
+            return
+        selector = self.fields.get('date_added', {})
+        pubdate_str = self._safe_query(torrent, selector)
+        if pubdate_str:
+            pubdate_str = pubdate_str.replace('\n', ' ').strip()
+        self.torrents_info['pubdate'] = self.__filter_text(pubdate_str, selector.get('filters'))
+
+    def __get_date_elapsed(self, torrent: Any):
+        # torrent date elapsed text
+        if 'date_elapsed' not in self.fields:
+            return
+        selector = self.fields.get('date_elapsed', {})
+        date_elapsed = self._safe_query(torrent, selector)
+        self.torrents_info['date_elapsed'] = self.__filter_text(date_elapsed, selector.get('filters'))
+
+    def __get_downloadvolumefactor(self, torrent: Any):
+        # downloadvolumefactor int
+        selector = self.fields.get('downloadvolumefactor', {})
+        if not selector:
+            return
+        self.torrents_info['downloadvolumefactor'] = 1
+        if 'case' in selector:
+            for downloadvolumefactorselector in list(selector.get('case', {}).keys()):
+                downloadvolumefactor = torrent(downloadvolumefactorselector)
+                try:
+                    if len(downloadvolumefactor) > 0:
+                        self.torrents_info['downloadvolumefactor'] = selector.get('case', {}).get(
+                            downloadvolumefactorselector)
+                        break
+                finally:
+                    downloadvolumefactor.clear()
+                    del downloadvolumefactor
+        elif "selector" in selector:
+            item = self._safe_query(torrent, selector)
+            if item:
+                downloadvolumefactor = re.search(r'(\d+\.?\d*)', item)
+                if downloadvolumefactor:
+                    self.torrents_info['downloadvolumefactor'] = int(downloadvolumefactor.group(1))
+
+    def __get_uploadvolumefactor(self, torrent: Any):
+        # uploadvolumefactor int
+        selector = self.fields.get('uploadvolumefactor', {})
+        if not selector:
+            return
+        self.torrents_info['uploadvolumefactor'] = 1
+        if 'case' in selector:
+            for uploadvolumefactorselector in list(selector.get('case', {}).keys()):
+                uploadvolumefactor = torrent(uploadvolumefactorselector)
+                try:
+                    if len(uploadvolumefactor) > 0:
+                        self.torrents_info['uploadvolumefactor'] = selector.get('case', {}).get(
+                            uploadvolumefactorselector)
+                        break
+                finally:
+                    uploadvolumefactor.clear()
+                    del uploadvolumefactor
+        elif "selector" in selector:
+            item = self._safe_query(torrent, selector)
+            if item:
+                uploadvolumefactor = re.search(r'(\d+\.?\d*)', item)
+                if uploadvolumefactor:
+                    self.torrents_info['uploadvolumefactor'] = int(uploadvolumefactor.group(1))
+
+    def __get_labels(self, torrent: Any):
+        # labels ['label1', 'label2']
+        if 'labels' not in self.fields:
+            return
+        selector = self.fields.get('labels', {})
+        if not selector.get('selector'):
+            self.torrents_info['labels'] = []
+            return
+
+        # labels需要特殊处理，因为它返回的是列表
+        labels = torrent(selector.get("selector", "")).clone()
+        try:
+            self.__remove(labels, selector)
+            items = self.__attribute_or_text(labels, selector)
+            if items:
+                self.torrents_info['labels'] = [item for item in items if item]
+            else:
+                self.torrents_info['labels'] = []
+        finally:
+            labels.clear()
+            del labels
+
+    def __get_free_date(self, torrent: Any):
+        # free date yyyy-mm-dd hh:mm:ss
+        if 'freedate' not in self.fields:
+            return
+        selector = self.fields.get('freedate', {})
+        freedate = self._safe_query(torrent, selector)
+        self.torrents_info['freedate'] = self.__filter_text(freedate, selector.get('filters'))
+
+    def __get_hit_and_run(self, torrent: Any):
+        # hitandrun True/False
+        if 'hr' not in self.fields:
+            return
+        selector = self.fields.get('hr', {})
+        hit_and_run = torrent(selector.get('selector', ''))
+        try:
+            if hit_and_run:
+                self.torrents_info['hit_and_run'] = True
+            else:
+                self.torrents_info['hit_and_run'] = False
+        finally:
+            hit_and_run.clear()
+            del hit_and_run
+
+    def __get_category(self, torrent: Any):
+        # category 电影/电视剧
+        if 'category' not in self.fields:
+            return
+        selector = self.fields.get('category', {})
+        category_value = self._safe_query(torrent, selector)
+        category_value = self.__filter_text(category_value, selector.get('filters'))
+        if category_value and self.category:
+            tv_cats = [str(cat.get("id")) for cat in self.category.get("tv") or []]
+            movie_cats = [str(cat.get("id")) for cat in self.category.get("movie") or []]
+            if category_value in tv_cats \
+                    and category_value not in movie_cats:
+                self.torrents_info['category'] = MediaType.TV.value
+            elif category_value in movie_cats:
+                self.torrents_info['category'] = MediaType.MOVIE.value
+            else:
+                self.torrents_info['category'] = MediaType.UNKNOWN.value
+        else:
+            self.torrents_info['category'] = MediaType.UNKNOWN.value
+
+    def _safe_query(self, torrent: Any, selector_config: Optional[dict]) -> Optional[str]:
+        """
+        安全地执行PyQuery查询并自动清理资源
+        :param torrent: PyQuery对象
+        :param selector_config: 选择器配置
+        :return: 处理后的结果
+        """
+        if not selector_config or not selector_config.get('selector'):
+            return None
+
+        query_obj = torrent(selector_config.get('selector', '')).clone()
+        try:
+            self.__remove(query_obj, selector_config)
+            items = self.__attribute_or_text(query_obj, selector_config)
+            return self.__index(items, selector_config)
+        finally:
+            query_obj.clear()
+            del query_obj
+
+    def get_info(self, torrent: Any) -> dict:
+        """
+        解析单条种子数据
+        """
+        # 每次调用时重新初始化，避免数据累积
+        self.torrents_info = {}
+        try:
+            # 标题
+            self.__get_title(torrent)
+            # 描述
+            self.__get_description(torrent)
+            # 详情页面
+            self.__get_detail(torrent)
+            # 下载链接
+            self.__get_download(torrent)
+            # 完成数
+            self.__get_grabs(torrent)
+            # 下载数
+            self.__get_leechers(torrent)
+            # 做种数
+            self.__get_seeders(torrent)
+            # 大小
+            self.__get_size(torrent)
+            # IMDBID
+            self.__get_imdbid(torrent)
+            # 下载系数
+            self.__get_downloadvolumefactor(torrent)
+            # 上传系数
+            self.__get_uploadvolumefactor(torrent)
+            # 发布时间
+            self.__get_pubdate(torrent)
+            # 已发布时间
+            self.__get_date_elapsed(torrent)
+            # 免费载止时间
+            self.__get_free_date(torrent)
+            # 标签
+            self.__get_labels(torrent)
+            # HR
+            self.__get_hit_and_run(torrent)
+            # 分类
+            self.__get_category(torrent)
+            # 返回当前种子信息的副本，而不是引用
+            return self.torrents_info.copy() if self.torrents_info else {}
+        except Exception as err:
+            logger.error("%s 搜索出现错误：%s" % (self.indexername, str(err)))
+            return {}
+        finally:
+            self.torrents_info.clear()
+
+    @staticmethod
+    def __filter_text(text: Optional[str], filters: Optional[List[dict]]) -> str:
+        """
+        对文件进行处理
+        """
+        if not text or not filters or not isinstance(filters, list):
+            return text
+        if not isinstance(text, str):
+            text = str(text)
+        for filter_item in filters:
+            if not text:
+                break
+            method_name = filter_item.get("name")
+            try:
+                args = filter_item.get("args")
+                if method_name == "re_search" and isinstance(args, list):
+                    rematch = re.search(r"%s" % args[0], text)
+                    if rematch:
+                        text = rematch.group(args[-1])
+                elif method_name == "split" and isinstance(args, list):
+                    text = text.split(r"%s" % args[0])[args[-1]]
+                elif method_name == "replace" and isinstance(args, list):
+                    text = text.replace(r"%s" % args[0], r"%s" % args[-1])
+                elif method_name == "dateparse" and isinstance(args, str):
+                    text = text.replace("\n", " ").strip()
+                    text = datetime.datetime.strptime(text, r"%s" % args)
+                elif method_name == "strip":
+                    text = text.strip()
+                elif method_name == "appendleft":
+                    text = f"{args}{text}"
+                elif method_name == "querystring":
+                    parsed_url = urlparse(str(text))
+                    query_params = parse_qs(parsed_url.query)
+                    param_value = query_params.get(args)
+                    text = param_value[0] if param_value else ''
+            except Exception as err:
+                logger.debug(f'过滤器 {method_name} 处理失败：{str(err)} - {traceback.format_exc()}')
+        return text.strip()
+
+    @staticmethod
+    def __remove(item: Any, selector: Optional[dict]):
+        """
+        移除元素
+        """
+        if selector and "remove" in selector:
+            removelist = selector.get('remove', '').split(', ')
+            for v in removelist:
+                item.remove(v)
+
+    @staticmethod
+    def __attribute_or_text(item: Any, selector: Optional[dict]) -> list:
+        if not selector:
+            return item
+        if not item:
+            return []
+        if 'attribute' in selector:
+            items = [i.attr(selector.get('attribute')) for i in item.items() if i]
+        else:
+            items = [i.text() for i in item.items() if i]
+        return items
+
+    @staticmethod
+    def __index(items: Optional[list], selector: Optional[dict]) -> Optional[str]:
+        if not items:
+            return None
+        if selector:
+            if "contents" in selector \
+                    and len(items) > int(selector.get("contents")):
+                item = items[0].split("\n")[selector.get("contents")]
+            elif "index" in selector \
+                    and len(items) > int(selector.get("index")):
+                item = items[int(selector.get("index"))]
+            else:
+                item = items[0]
+        else:
+            item = items[0]
+        return item
+
+    def parse(self, html_text: str) -> List[dict]:
+        """
+        解析整个页面
+        """
+        if not html_text:
+            self.is_error = True
+            return []
+
+        # 清空旧结果
+        self.torrents_info_array = []
+        html_doc = None
+        try:
+            # 解析站点文本对象
+            html_doc = PyQuery(html_text)
+            # 种子筛选器
+            torrents_selector = self.list.get('selector', '')
+            # 遍历种子html列表
+            for i, torn in enumerate(html_doc(torrents_selector)):
+                if i >= int(self.result_num):
+                    break
+                # 创建临时PyQuery对象进行解析
+                torrent_query = PyQuery(torn)
+                try:
+                    # 直接获取种子信息，避免深拷贝
+                    torrent_info = self.get_info(torrent_query)
+                    if torrent_info:
+                        # 浅拷贝即可，减少内存使用
+                        self.torrents_info_array.append(torrent_info)
+                finally:
+                    # 显式删除临时PyQuery对象
+                    torrent_query.clear()
+                    del torrent_query
+            # 返回数组的副本，防止被后续清理操作影响
+            return self.torrents_info_array.copy()
+        except Exception as err:
+            self.is_error = True
+            logger.warn(f"错误：{self.indexername} {str(err)}")
+            return []
+        finally:
+            # 清理种子缓存
+            self.torrents_info_array.clear()
+            # 清理HTML文档对象
+            if html_doc is not None:
+                html_doc.clear()
+                del html_doc
+            # 清理html_text引用
+            del html_text

app/modules/jellyfin/jellyfin.py

@@ -168,7 +168,8 @@ class Jellyfin:
                     path=library.get("Path"),
                     type=library_type,
                     image=image,
-                    link=link
+                    link=link,
+                    server_type="jellyfin"
                 ))
         return libraries
 
@@ -934,7 +935,8 @@ class Jellyfin:
                         type=item_type,
                         image=image,
                         link=link,
-                        percent=item.get("UserData", {}).get("PlayedPercentage")
+                        percent=item.get("UserData", {}).get("PlayedPercentage"),
+                        server_type='jellyfin',
                     ))
                 return ret_resume
             else:
@@ -986,7 +988,8 @@ class Jellyfin:
                         type=item_type,
                         image=image,
                         link=link,
-                        BackdropImageTags=item.get("BackdropImageTags")
+                        BackdropImageTags=item.get("BackdropImageTags"),
+                        server_type='jellyfin'
                     ))
                 return ret_latest
             else:

app/modules/plex/plex.py

@@ -154,7 +154,8 @@ class Plex:
                     type=library_type,
                     image_list=image_list,
                     link=f"{self._playhost or self._host}web/index.html#!/media/{self._plex.machineIdentifier}"
-                         f"/com.plexapp.plugins.library?source={library.key}"
+                         f"/com.plexapp.plugins.library?source={library.key}&X-Plex-Token={self._token}",
+                    server_type='plex'
                 )
             )
         return libraries
@@ -387,6 +388,8 @@ class Plex:
             for path, lib_key in result_dict.items():
                 logger.info(f"刷新媒体库：{lib_key} - {path}")
                 self._plex.query(f'/library/sections/{lib_key}/refresh?path={quote_plus(str(Path(path).parent))}')
+                return None
+        return None
 
     @staticmethod
     def __find_librarie(path: Path, libraries: List[Any]) -> Tuple[str, str]:
@@ -541,6 +544,7 @@ class Plex:
                         continue
         except Exception as err:
             logger.error(f"获取媒体库列表出错：{str(err)}")
+        return None
 
     def get_webhook_message(self, form: any) -> Optional[schemas.WebhookEventInfo]:
         """
@@ -718,7 +722,7 @@ class Plex:
         拼装媒体播放链接
         :param item_id: 媒体的的ID
         """
-        return f'{self._playhost or self._host}web/index.html#!/server/{self._plex.machineIdentifier}/details?key={item_id}'
+        return f'{self._playhost or self._host}web/index.html#!/server/{self._plex.machineIdentifier}/details?key={item_id}&X-Plex-Token={self._token}'
 
     def get_resume(self, num: Optional[int] = 12) -> Optional[List[schemas.MediaServerPlayItem]]:
         """
@@ -752,7 +756,8 @@ class Plex:
                 type=item_type,
                 image=image,
                 link=link,
-                percent=item.viewOffset / item.duration * 100 if item.viewOffset and item.duration else 0
+                percent=item.viewOffset / item.duration * 100 if item.viewOffset and item.duration else 0,
+                server_type='plex'
             ))
         return ret_resume[:num]
 
@@ -820,7 +825,8 @@ class Plex:
                     subtitle=item.year,
                     type=item_type,
                     image=image,
-                    link=link
+                    link=link,
+                    server_type='plex'
                 ))
             offset += num
         return ret_resume[:num]

app/modules/subtitle/__init__.py

@@ -104,20 +104,24 @@ class SubtitleModule(_ModuleBase):
                 logger.warn(f"读取页面代码失败：{torrent.page_url}")
                 return
             html = etree.HTML(res.text)
-            sublink_list = []
-            for xpath in self._SITE_SUBTITLE_XPATH:
-                sublinks = html.xpath(xpath)
-                if sublinks:
-                    for sublink in sublinks:
-                        if not sublink:
-                            continue
-                        if not sublink.startswith("http"):
-                            base_url = StringUtils.get_base_url(torrent.page_url)
-                            if sublink.startswith("/"):
-                                sublink = "%s%s" % (base_url, sublink)
-                            else:
-                                sublink = "%s/%s" % (base_url, sublink)
-                        sublink_list.append(sublink)
+            try:
+                sublink_list = []
+                for xpath in self._SITE_SUBTITLE_XPATH:
+                    sublinks = html.xpath(xpath)
+                    if sublinks:
+                        for sublink in sublinks:
+                            if not sublink:
+                                continue
+                            if not sublink.startswith("http"):
+                                base_url = StringUtils.get_base_url(torrent.page_url)
+                                if sublink.startswith("/"):
+                                    sublink = "%s%s" % (base_url, sublink)
+                                else:
+                                    sublink = "%s/%s" % (base_url, sublink)
+                            sublink_list.append(sublink)
+            finally:
+                if html is not None:
+                    del html
             # 下载所有字幕文件
             for sublink in sublink_list:
                 logger.info(f"找到字幕下载链接：{sublink}，开始下载...")

app/modules/themoviedb/category.py

@@ -7,19 +7,19 @@ from ruamel.yaml import CommentedMap
 
 from app.core.config import settings
 from app.log import logger
-from app.utils.singleton import Singleton
+from app.utils.singleton import WeakSingleton
 
 
-class CategoryHelper(metaclass=Singleton):
+class CategoryHelper(metaclass=WeakSingleton):
     """
     二级分类
     """
-    _categorys = {}
-    _movie_categorys = {}
-    _tv_categorys = {}
 
     def __init__(self):
         self._category_path: Path = settings.CONFIG_PATH / "category.yaml"
+        self._categorys = {}
+        self._movie_categorys = {}
+        self._tv_categorys = {}
         self.init()
 
     def init(self):
@@ -69,7 +69,7 @@ class CategoryHelper(metaclass=Singleton):
         """
         if not self._movie_categorys:
             return []
-        return self._movie_categorys.keys()
+        return list(self._movie_categorys.keys())
 
     @property
     def tv_categorys(self) -> list:
@@ -78,7 +78,7 @@ class CategoryHelper(metaclass=Singleton):
         """
         if not self._tv_categorys:
             return []
-        return self._tv_categorys.keys()
+        return list(self._tv_categorys.keys())
 
     def get_movie_category(self, tmdb_info) -> str:
         """
@@ -127,7 +127,7 @@ class CategoryHelper(metaclass=Singleton):
                     continue
                 elif attr == "production_countries":
                     # 制片国家
-                    info_values = [str(val.get("iso_3166_1")).upper() for val in info_value]
+                    info_values = [str(val.get("iso_3166_1")).upper() for val in info_value] # type: ignore
                 else:
                     if isinstance(info_value, list):
                         info_values = [str(val).upper() for val in info_value]

app/modules/themoviedb/tmdb_cache.py

@@ -9,7 +9,7 @@ from typing import Optional
 from app.core.config import settings
 from app.core.meta import MetaBase
 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()
@@ -18,7 +18,7 @@ CACHE_EXPIRE_TIMESTAMP_STR = "cache_expire_timestamp"
 EXPIRE_TIMESTAMP = settings.CONF.meta
 
 
-class TmdbCache(metaclass=Singleton):
+class TmdbCache(metaclass=WeakSingleton):
     """
     TMDB缓存数据
     {
@@ -28,9 +28,6 @@ class TmdbCache(metaclass=Singleton):
         "type": MediaType
     }
     """
-    _meta_data: dict = {}
-    # 缓存文件路径
-    _meta_path: Path = None
     # TMDB缓存过期
     _tmdb_cache_expire: bool = True
 
@@ -218,3 +215,6 @@ class TmdbCache(metaclass=Singleton):
         if not cache_media_info:
             return
         self._meta_data[key]['title'] = cn_title
+
+    def __del__(self):
+        self.save()

app/modules/themoviedb/tmdbapi.py

@@ -563,6 +563,9 @@ class TmdbApi:
         except Exception as err:
             logger.error(f"从TheDbMovie网站查询出错：{str(err)}")
             return {}
+        finally:
+            if html is not None:
+                del html
         return {}
 
     def get_info(self,

app/modules/transmission/transmission.py

@@ -25,7 +25,7 @@ class Transmission:
         若不设置参数，则创建配置文件设置的下载器
         """
         if host and port:
-            self._protocol, self._host, self._port = kwargs.get("protocol", self._protocol), host, port
+            self._protocol, self._host, self._port = kwargs.get("protocol", "http"), host, port
         elif host:
             result = UrlUtils.parse_url_params(url=host)
             if result:

app/modules/trimemedia/api.py

@@ -111,7 +111,7 @@ class Api:
         "_api_path",
         "_request_utils",
         "_version",
-        "_session"
+        "_session",
     )
 
     @property
@@ -287,6 +287,18 @@ class Api:
                 return True
         return False
 
+    def task_running(self):
+        """
+        当前正在运行的任务
+        """
+        if (
+            res := self.__request_api("/task/running")
+        ) and res.success:
+            if res.data:
+                # TODO 具体正在运行的任务
+                return True
+        return False
+
     def __build_item(self, info: dict) -> Item:
         """
         构造媒体Item
@@ -308,7 +320,7 @@ class Api:
         types=None,
         exclude_grouped_video=True,
         page=1,
-        page_size=22,
+        page_size=20,
         sort_by="create_time",
         sort="DESC",
     ) -> Optional[list[Item]]:

app/modules/trimemedia/trimemedia.py

@@ -111,6 +111,8 @@ class TrimeMedia:
         if self._userinfo is None:
             return False
         logger.debug(f"{self._username} 成功登录飞牛影视")
+        # 刷新媒体库列表
+        self.get_librarys()
         return True
 
     def disconnect(self):
@@ -161,6 +163,7 @@ class TrimeMedia:
                         for img_path in library.posters or []
                     ],
                     link=f"{self._playhost or self._api.host}/library/{library.guid}",
+                    server_type='trimemedia'
                 )
             )
         return libraries
@@ -311,6 +314,8 @@ class TrimeMedia:
             logger.error("飞牛仅支持管理员账号刷新媒体库")
             return False
 
+        # 必须调用 否则容易误报 -14 Task duplicate
+        self._api.task_running()
         logger.info("刷新所有媒体库")
         return self._api.mdb_scanall()
 
@@ -337,6 +342,8 @@ class TrimeMedia:
             # 媒体库去重
             libraries.add(lib.guid)
 
+        # 必须调用 否则容易误报 -14 Task duplicate
+        self._api.task_running()
         for lib_guid in libraries:
             # 逐个刷新
             lib = self._libraries[lib_guid]
@@ -452,6 +459,7 @@ class TrimeMedia:
                 if item.duration and item.ts is not None
                 else 0
             ),
+            server_type='trimemedia',
         )
 
     def get_items(

app/monitor.py

@@ -59,26 +59,23 @@ class Monitor(metaclass=Singleton):
     目录监控处理链，单例模式
     """
 
-    # 退出事件
-    _event = threading.Event()
 
-    # 监控服务
-    _observers = []
-
-    # 定时服务
-    _scheduler = None
-
-    # 存储快照缓存目录
-    _snapshot_cache_dir = None
-
-    # 存储过照间隔（分钟）
-    _snapshot_interval = 5
-
-    # TTL缓存，10秒钟有效
-    _cache = TTLCache(maxsize=1024, ttl=10)
 
     def __init__(self):
         super().__init__()
+        # 退出事件
+        self._event = threading.Event()
+        # 监控服务
+        self._observers = []
+        # 定时服务
+        self._scheduler = None
+        # 存储快照缓存目录
+        self._snapshot_cache_dir = None
+        # 存储过照间隔（分钟）
+        self._snapshot_interval = 5
+        # TTL缓存，10秒钟有效
+        self._cache = TTLCache(maxsize=1024, ttl=10)
+        # 监控的文件扩展名
         self.all_exts = settings.RMT_MEDIAEXT
         # 初始化快照缓存目录
         self._snapshot_cache_dir = settings.TEMP_PATH / "snapshots"
@@ -120,6 +117,71 @@ class Monitor(metaclass=Singleton):
         except Exception as e:
             logger.error(f"保存快照失败: {e}")
 
+    def reset_snapshot(self, storage: str) -> bool:
+        """
+        重置快照，强制下次扫描时重新建立基准
+        :param storage: 存储名称
+        :return: 是否成功
+        """
+        try:
+            cache_file = self._snapshot_cache_dir / f"{storage}_snapshot.json"
+            if cache_file.exists():
+                cache_file.unlink()
+                logger.info(f"快照已重置: {storage}")
+                return True
+            logger.debug(f"快照文件不存在，无需重置: {storage}")
+            return True
+        except Exception as e:
+            logger.error(f"重置快照失败: {storage} - {e}")
+            return False
+
+    def force_full_scan(self, storage: str, mon_path: Path) -> bool:
+        """
+        强制全量扫描并处理所有文件（包括已存在的文件）
+        :param storage: 存储名称
+        :param mon_path: 监控路径
+        :return: 是否成功
+        """
+        try:
+            logger.info(f"开始强制全量扫描: {storage}:{mon_path}")
+
+            # 生成快照
+            new_snapshot = StorageChain().snapshot_storage(
+                storage=storage,
+                path=mon_path,
+                last_snapshot_time=0  # 全量扫描，不使用增量
+            )
+
+            if new_snapshot is None:
+                logger.warn(f"获取 {storage}:{mon_path} 快照失败")
+                return False
+
+            file_count = len(new_snapshot)
+            logger.info(f"{storage}:{mon_path} 全量扫描完成，发现 {file_count} 个文件")
+
+            # 处理所有文件
+            processed_count = 0
+            for file_path, file_info in new_snapshot.items():
+                try:
+                    logger.info(f"处理文件：{file_path}")
+                    file_size = file_info.get('size', 0) if isinstance(file_info, dict) else file_info
+                    self.__handle_file(storage=storage, event_path=Path(file_path), file_size=file_size)
+                    processed_count += 1
+                except Exception as e:
+                    logger.error(f"处理文件 {file_path} 失败: {e}")
+                    continue
+
+            logger.info(f"{storage}:{mon_path} 全量扫描完成，共处理 {processed_count}/{file_count} 个文件")
+
+            # 保存快照
+            self.save_snapshot(storage, new_snapshot, file_count)
+
+            return True
+
+        except Exception as e:
+            logger.error(f"强制全量扫描失败: {storage}:{mon_path} - {e}")
+            return False
+
     def load_snapshot(self, storage: str) -> Optional[Dict]:
         """
         从文件加载快照
@@ -131,7 +193,9 @@ class Monitor(metaclass=Singleton):
             if cache_file.exists():
                 with open(cache_file, 'r', encoding='utf-8') as f:
                     data = json.load(f)
+                    logger.debug(f"成功加载快照: {cache_file}, 包含 {len(data.get('snapshot', {}))} 个文件")
                     return data
+            logger.debug(f"快照文件不存在: {cache_file}")
             return None
         except Exception as e:
             logger.error(f"加载快照失败: {e}")
@@ -300,7 +364,7 @@ class Monitor(metaclass=Singleton):
         :param limits: 系统限制信息
         :return: (是否使用轮询, 原因)
         """
-        if monitor_mode == "compatible":
+        if monitor_mode == "compatibility":
             return True, "用户配置为兼容模式"
 
         # 检查网络文件系统
@@ -327,6 +391,14 @@ class Monitor(metaclass=Singleton):
                                         capture_output=True, text=True, timeout=5)
                 if result.returncode == 0:
                     output = result.stdout.lower()
+                    # 以下本地文件系统含有fuse关键字
+                    local_fs = [
+                        "fuse.shfs",  # Unraid
+                        "zfuse.zfsv",  # 极空间(zfuse.zfsv2、zfuse.zfsv3、...)
+                        # TBD
+                    ]
+                    if any(fs in output for fs in local_fs):
+                        return False
                     network_fs = ['nfs', 'cifs', 'smbfs', 'fuse', 'sshfs', 'ftpfs']
                     return any(fs in output for fs in network_fs)
             elif system == 'Darwin':
@@ -553,6 +625,9 @@ class Monitor(metaclass=Singleton):
                 old_snapshot = old_snapshot_data.get('snapshot', {}) if old_snapshot_data else {}
                 last_snapshot_time = old_snapshot_data.get('timestamp', 0) if old_snapshot_data else 0
 
+                # 判断是否为首次快照：检查快照文件是否存在且有效
+                is_first_snapshot = old_snapshot_data is None
+
                 # 生成新快照（增量模式）
                 new_snapshot = StorageChain().snapshot_storage(
                     storage=storage,
@@ -567,7 +642,7 @@ class Monitor(metaclass=Singleton):
                 file_count = len(new_snapshot)
                 logger.info(f"{storage}:{mon_path} 快照完成，发现 {file_count} 个文件")
 
-                if old_snapshot:
+                if not is_first_snapshot:
                     # 比较快照找出变化
                     changes = self.compare_snapshots(old_snapshot, new_snapshot)
 

app/scheduler.py

@@ -40,20 +40,20 @@ class Scheduler(metaclass=Singleton):
     """
     定时任务管理
     """
-    # 定时服务
-    _scheduler = None
-    # 退出事件
-    _event = threading.Event()
-    # 锁
-    _lock = threading.RLock()
-    # 各服务的运行状态
-    _jobs = {}
-    # 用户认证失败次数
-    _auth_count = 0
-    # 用户认证失败消息发送
-    _auth_message = False
 
     def __init__(self):
+        # 定时服务
+        self._scheduler = None
+        # 退出事件
+        self._event = threading.Event()
+        # 锁
+        self._lock = threading.RLock()
+        # 各服务的运行状态
+        self._jobs = {}
+        # 用户认证失败次数
+        self._auth_count = 0
+        # 用户认证失败消息发送
+        self._auth_message = False
         self.init()
 
     @eventmanager.register(EventType.ConfigChanged)
@@ -443,7 +443,7 @@ class Scheduler(metaclass=Singleton):
             return
         with self._lock:
             job_id = f"workflow-{workflow.id}"
-            service = self._jobs.pop(job_id, None)
+            service = self._jobs.pop(job_id, {})
             if not service:
                 return
             try:

app/schemas/event.py

@@ -214,7 +214,7 @@ class ResourceDownloadEventData(ChainEventData):
     channel: Optional[MessageChannel] = Field(None, description="通知渠道")
     origin: Optional[str] = Field(None, description="来源")
     downloader: Optional[str] = Field(None, description="下载器")
-    options: Optional[dict] = Field(None, description="其他参数")
+    options: Optional[dict] = Field(default={}, description="其他参数")
 
     # 输出参数
     cancel: bool = Field(default=False, description="是否取消下载")

app/schemas/mediaserver.py

@@ -72,6 +72,8 @@ class MediaServerLibrary(BaseModel):
     image_list: Optional[List[str]] = None
     # 跳转链接
     link: Optional[str] = None
+    # 服务器类型
+    server_type: Optional[str] = None
 
 
 class MediaServerItemUserState(BaseModel):
@@ -175,3 +177,4 @@ class MediaServerPlayItem(BaseModel):
     link: Optional[str] = None
     percent: Optional[float] = None
     BackdropImageTags: Optional[list] = Field(default_factory=list)
+    server_type: Optional[str] = None

app/schemas/types.py

@@ -290,6 +290,7 @@ class StorageSchema(Enum):
     U115 = "u115"
     Rclone = "rclone"
     Alist = "alist"
+    SMB = "smb"
 
 
 # 模块类型

app/schemas/workflow.py

@@ -82,3 +82,25 @@ class ActionFlow(BaseModel):
     source: Optional[str] = Field(default=None, description="源动作")
     target: Optional[str] = Field(default=None, description="目标动作")
     animated: Optional[bool] = Field(default=True, description="是否动画流程")
+
+
+class WorkflowShare(BaseModel):
+    """
+    工作流分享信息
+    """
+    id: Optional[int] = Field(default=None, description="分享ID")
+    share_title: Optional[str] = Field(default=None, description="分享标题")
+    share_comment: Optional[str] = Field(default=None, description="分享说明")
+    share_user: Optional[str] = Field(default=None, description="分享人")
+    share_uid: Optional[str] = Field(default=None, description="分享人唯一ID")
+    name: Optional[str] = Field(default=None, description="工作流名称")
+    description: Optional[str] = Field(default=None, description="工作流描述")
+    timer: Optional[str] = Field(default=None, description="定时器")
+    actions: Optional[str] = Field(default=None, description="任务列表(JSON字符串)")
+    flows: Optional[str] = Field(default=None, description="任务流(JSON字符串)")
+    context: Optional[str] = Field(default=None, description="执行上下文(JSON字符串)")
+    date: Optional[str] = Field(default=None, description="分享时间")
+    count: Optional[int] = Field(default=0, description="复用人次")
+
+    class Config:
+        orm_mode = True

app/startup/lifecycle.py

@@ -5,7 +5,6 @@ from fastapi import FastAPI
 
 from app.chain.system import SystemChain
 from app.startup.command_initializer import init_command, stop_command, restart_command
-from app.startup.memory_initializer import init_memory_manager, stop_memory_manager
 from app.startup.modules_initializer import init_modules, stop_modules
 from app.startup.monitor_initializer import stop_monitor, init_monitor
 from app.startup.plugins_initializer import init_plugins, stop_plugins, sync_plugins
@@ -52,8 +51,6 @@ async def lifespan(app: FastAPI):
     init_command()
     # 初始化工作流
     init_workflow()
-    # 初始化内存管理
-    init_memory_manager()
     # 插件同步到本地
     sync_plugins_task = asyncio.create_task(init_extra())
     try:
@@ -71,8 +68,6 @@ async def lifespan(app: FastAPI):
             print(str(e))
         # 备份插件
         SystemChain().backup_plugins()
-        # 停止内存管理器
-        stop_memory_manager()
         # 停止工作流
         stop_workflow()
         # 停止命令

app/startup/memory_initializer.py

@@ -1,15 +0,0 @@
-from app.helper.memory import MemoryHelper
-
-
-def init_memory_manager():
-    """
-    初始化内存监控器
-    """
-    MemoryHelper().start_monitoring()
-
-
-def stop_memory_manager():
-    """
-    停止内存监控器
-    """
-    MemoryHelper().stop_monitoring()

app/utils/http.py

@@ -80,6 +80,12 @@ class AutoCloseResponse:
         for name, value in state.items():
             setattr(self, name, value)
 
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
 class RequestUtils:
 
     def __init__(self,

app/utils/singleton.py

@@ -1,4 +1,6 @@
 import abc
+import threading
+import weakref
 
 
 class Singleton(abc.ABCMeta, type):
@@ -40,3 +42,17 @@ class AbstractSingletonClass(abc.ABC, metaclass=SingletonClass):
     抽像类单例模式（按类）
     """
     pass
+
+
+class WeakSingleton(abc.ABCMeta, type):
+    """
+    弱引用单例模式 - 当没有强引用时自动清理
+    """
+    _instances: weakref.WeakKeyDictionary = weakref.WeakKeyDictionary()
+    _lock = threading.RLock()
+
+    def __call__(cls, *args, **kwargs):
+        with cls._lock:
+            if cls not in cls._instances:
+                cls._instances[cls] = super().__call__(*args, **kwargs)
+            return cls._instances[cls]

app/utils/site.py

@@ -13,27 +13,31 @@ class SiteUtils:
         :return:
         """
         html = etree.HTML(html_text)
-        if not StringUtils.is_valid_html_element(html):
+        try:
+            if not StringUtils.is_valid_html_element(html):
+                return False
+            # 存在明显的密码输入框，说明未登录
+            if html.xpath("//input[@type='password']"):
+                return False
+            # 是否存在登出和用户面板等链接
+            xpaths = [
+                '//a[contains(@href, "logout")'
+                ' or contains(@data-url, "logout")'
+                ' or contains(@href, "mybonus") '
+                ' or contains(@onclick, "logout")'
+                ' or contains(@href, "usercp")'
+                ' or contains(@lay-on, "logout")]',
+                '//form[contains(@action, "logout")]',
+                '//div[@class="user-info-side"]',
+                '//a[@id="myitem"]'
+            ]
+            for xpath in xpaths:
+                if html.xpath(xpath):
+                    return True
             return False
-        # 存在明显的密码输入框，说明未登录
-        if html.xpath("//input[@type='password']"):
-            return False
-        # 是否存在登出和用户面板等链接
-        xpaths = [
-            '//a[contains(@href, "logout")'
-            ' or contains(@data-url, "logout")'
-            ' or contains(@href, "mybonus") '
-            ' or contains(@onclick, "logout")'
-            ' or contains(@href, "usercp")'
-            ' or contains(@lay-on, "logout")]',
-            '//form[contains(@action, "logout")]',
-            '//div[@class="user-info-side"]',
-            '//a[@id="myitem"]'
-        ]
-        for xpath in xpaths:
-            if html.xpath(xpath):
-                return True
-        return False
+        finally:
+            if html is not None:
+                del html
 
     @classmethod
     def is_checkin(cls, html_text: str) -> bool:
@@ -42,24 +46,27 @@ class SiteUtils:
         :return True已签到 False未签到
         """
         html = etree.HTML(html_text)
-        if not StringUtils.is_valid_html_element(html):
-            return False
-        # 站点签到支持的识别XPATH
-        xpaths = [
-            '//a[@id="signed"]',
-            '//a[contains(@href, "attendance")]',
-            '//a[contains(text(), "签到")]',
-            '//a/b[contains(text(), "签 到")]',
-            '//span[@id="sign_in"]/a',
-            '//a[contains(@href, "addbonus")]',
-            '//input[@class="dt_button"][contains(@value, "打卡")]',
-            '//a[contains(@href, "sign_in")]',
-            '//a[contains(@onclick, "do_signin")]',
-            '//a[@id="do-attendance"]',
-            '//shark-icon-button[@href="attendance.php"]'
-        ]
-        for xpath in xpaths:
-            if html.xpath(xpath):
+        try:
+            if not StringUtils.is_valid_html_element(html):
                 return False
-
-        return True
+            # 站点签到支持的识别XPATH
+            xpaths = [
+                '//a[@id="signed"]',
+                '//a[contains(@href, "attendance")]',
+                '//a[contains(text(), "签到")]',
+                '//a/b[contains(text(), "签 到")]',
+                '//span[@id="sign_in"]/a',
+                '//a[contains(@href, "addbonus")]',
+                '//input[@class="dt_button"][contains(@value, "打卡")]',
+                '//a[contains(@href, "sign_in")]',
+                '//a[contains(@onclick, "do_signin")]',
+                '//a[@id="do-attendance"]',
+                '//shark-icon-button[@href="attendance.php"]'
+            ]
+            for xpath in xpaths:
+                if html.xpath(xpath):
+                    return False
+            return True
+        finally:
+            if html is not None:
+                del html

app/utils/system.py

@@ -445,6 +445,24 @@ class SystemUtils:
         process_memory_percent = (process_memory / system_memory) * 100
         return [process_memory, int(process_memory_percent)]
 
+    @staticmethod
+    def network_usage() -> List[int]:
+        """
+        获取当前网络流量（上行和下行流量，单位：bytes/s）
+        """
+        import time
+        # 获取初始网络统计
+        net_io_1 = psutil.net_io_counters()
+        time.sleep(1)  # 等待1秒
+        # 获取1秒后的网络统计
+        net_io_2 = psutil.net_io_counters()
+        
+        # 计算1秒内的流量变化
+        upload_speed = net_io_2.bytes_sent - net_io_1.bytes_sent
+        download_speed = net_io_2.bytes_recv - net_io_1.bytes_recv
+        
+        return [upload_speed, download_speed]
+
     @staticmethod
     def is_hardlink(src: Path, dest: Path) -> bool:
         """

requirements.in

@@ -25,7 +25,7 @@ pytz~=2025.2
 pycryptodome~=3.23.0
 qbittorrent-api==2025.5.0
 plexapi~=4.17.0
-transmission-rpc~=7.0.11
+transmission-rpc~=4.3.0
 Jinja2~=3.1.6
 pyparsing~=3.2.3
 func_timeout==4.3.5
@@ -69,3 +69,5 @@ oss2~=2.19.1
 tqdm~=4.67.1
 setuptools~=78.1.0
 pympler~=1.1
+smbprotocol~=1.15.0
+setproctitle~=1.3.6

version.py

@@ -1,2 +1,2 @@
-APP_VERSION = 'v2.6.0'
-FRONTEND_VERSION = 'v2.6.0'
+APP_VERSION = 'v2.6.5'
+FRONTEND_VERSION = 'v2.6.5'