v2.2.2

- 分享的订阅支持删除（仅新分享的订阅有效）
- 媒体信息搜索支持系列合集
- 优化了实时日志的性能
- 优化了订阅识别词的生效优先级
- 优化了多处UI细节

.github/ISSUE_TEMPLATE/rfc.yml

@@ -0,0 +1,45 @@
+name: 功能提案
+description: Request for Comments
+title: "[RFC]"
+labels: ["RFC"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        一份提案(RFC)定位为 **「在某功能/重构的具体开发前，用于开发者间 review 技术设计/方案的文档」**，
+        目的是让协作的开发者间清晰的知道「要做什么」和「具体会怎么做」，以及所有的开发者都能公开透明的参与讨论；
+        以便评估和讨论产生的影响 (遗漏的考虑、向后兼容性、与现有功能的冲突)，
+        因此提案侧重在对解决问题的 **方案、设计、步骤** 的描述上。
+          
+        如果仅希望讨论是否添加或改进某功能本身，请使用 -> [Issue: 功能改进](https://github.com/jxxghp/MoviePilot/issues/new?assignees=&labels=feature+request&projects=&template=feature_request.yml&title=%5BFeature+Request%5D%3A+)
+  - type: textarea
+    id: background
+    attributes:
+      label: 背景 or 问题
+      description: 简单描述遇到的什么问题或需要改动什么。可以引用其他 issue、讨论、文档等。
+    validations:
+      required: true
+  - type: textarea
+    id: goal
+    attributes:
+      label: "目标 & 方案简述"
+      description: 简单描述提案此提案实现后，**预期的目标效果**，以及简单大致描述会采取的方案/步骤，可能会/不会产生什么影响。
+    validations:
+      required: true
+  - type: textarea
+    id: design
+    attributes:
+      label: "方案设计 & 实现步骤"
+      description: |
+        详细描述你设计的具体方案，可以考虑拆分列表或要点，一步步描述具体打算如何实现的步骤和相关细节。
+        这部份不需要一次性写完整，即使在创建完此提案 issue 后，依旧可以再次编辑修改。
+    validations:
+      required: false
+  - type: textarea
+    id: alternative
+    attributes:
+      label: "替代方案 & 对比"
+      description: |
+        [可选] 为来实现目标效果，还考虑过什么其他方案，有什么对比？
+    validations:
+      required: false

.github/workflows/build.yml

@@ -5,10 +5,7 @@ on:
     branches:
       - v2
     paths:
-      - '.github/workflows/build.yml'
-      - 'Dockerfile'
       - 'version.py'
-      - 'requirements.in'
 
 jobs:
   Docker-build:

Dockerfile

@@ -10,10 +10,7 @@ ENV LANG="C.UTF-8" \
     UMASK=000 \
     PORT=3001 \
     NGINX_PORT=3000 \
-    PROXY_HOST="" \
-    MOVIEPILOT_AUTO_UPDATE=false \
-    AUTH_SITE="iyuu" \
-    IYUU_SIGN=""
+    MOVIEPILOT_AUTO_UPDATE=release
 WORKDIR "/app"
 RUN apt-get update -y \
     && apt-get upgrade -y \

README.md

@@ -6,6 +6,7 @@
 ![GitHub repo size](https://img.shields.io/github/repo-size/jxxghp/MoviePilot?style=for-the-badge)
 ![GitHub issues](https://img.shields.io/github/issues/jxxghp/MoviePilot?style=for-the-badge)
 ![Docker Pulls](https://img.shields.io/docker/pulls/jxxghp/moviepilot?style=for-the-badge)
+![Docker Pulls V2](https://img.shields.io/docker/pulls/jxxghp/moviepilot-v2?style=for-the-badge)
 ![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20Linux%20%7C%20Synology-blue?style=for-the-badge)
 
 

app/api/endpoints/bangumi.py

@@ -4,6 +4,7 @@ from fastapi import APIRouter, Depends
 
 from app import schemas
 from app.chain.bangumi import BangumiChain
+from app.chain.recommend import RecommendChain
 from app.core.context import MediaInfo
 from app.core.security import verify_token
 
@@ -17,10 +18,7 @@ def calendar(page: int = 1,
     """
     浏览Bangumi每日放送
     """
-    medias = BangumiChain().calendar()
-    if medias:
-        return [media.to_dict() for media in medias[(page - 1) * count: page * count]]
-    return []
+    return RecommendChain().bangumi_calendar(page=page, count=count)
 
 
 @router.get("/credits/{bangumiid}", summary="查询Bangumi演职员表", response_model=List[schemas.MediaPerson])

app/api/endpoints/douban.py

@@ -4,6 +4,7 @@ from fastapi import APIRouter, Depends
 
 from app import schemas
 from app.chain.douban import DoubanChain
+from app.chain.recommend import RecommendChain
 from app.core.context import MediaInfo
 from app.core.security import verify_token
 from app.schemas import MediaType
@@ -40,10 +41,7 @@ def movie_showing(page: int = 1,
     """
     浏览豆瓣正在热映
     """
-    movies = DoubanChain().movie_showing(page=page, count=count)
-    if movies:
-        return [media.to_dict() for media in movies]
-    return []
+    return RecommendChain().douban_movie_showing(page=page, count=count)
 
 
 @router.get("/movies", summary="豆瓣电影", response_model=List[schemas.MediaInfo])
@@ -55,11 +53,7 @@ def douban_movies(sort: str = "R",
     """
     浏览豆瓣电影信息
     """
-    movies = DoubanChain().douban_discover(mtype=MediaType.MOVIE,
-                                           sort=sort, tags=tags, page=page, count=count)
-    if movies:
-        return [media.to_dict() for media in movies]
-    return []
+    return RecommendChain().douban_movies(sort=sort, tags=tags, page=page, count=count)
 
 
 @router.get("/tvs", summary="豆瓣剧集", response_model=List[schemas.MediaInfo])
@@ -71,11 +65,7 @@ def douban_tvs(sort: str = "R",
     """
     浏览豆瓣剧集信息
     """
-    tvs = DoubanChain().douban_discover(mtype=MediaType.TV,
-                                        sort=sort, tags=tags, page=page, count=count)
-    if tvs:
-        return [media.to_dict() for media in tvs]
-    return []
+    return RecommendChain().douban_tvs(sort=sort, tags=tags, page=page, count=count)
 
 
 @router.get("/movie_top250", summary="豆瓣电影TOP250", response_model=List[schemas.MediaInfo])
@@ -85,10 +75,7 @@ def movie_top250(page: int = 1,
     """
     浏览豆瓣剧集信息
     """
-    movies = DoubanChain().movie_top250(page=page, count=count)
-    if movies:
-        return [media.to_dict() for media in movies]
-    return []
+    return RecommendChain().douban_movie_top250(page=page, count=count)
 
 
 @router.get("/tv_weekly_chinese", summary="豆瓣国产剧集周榜", response_model=List[schemas.MediaInfo])
@@ -98,10 +85,7 @@ def tv_weekly_chinese(page: int = 1,
     """
     中国每周剧集口碑榜
     """
-    tvs = DoubanChain().tv_weekly_chinese(page=page, count=count)
-    if tvs:
-        return [media.to_dict() for media in tvs]
-    return []
+    return RecommendChain().douban_tv_weekly_chinese(page=page, count=count)
 
 
 @router.get("/tv_weekly_global", summary="豆瓣全球剧集周榜", response_model=List[schemas.MediaInfo])
@@ -111,10 +95,7 @@ def tv_weekly_global(page: int = 1,
     """
     全球每周剧集口碑榜
     """
-    tvs = DoubanChain().tv_weekly_global(page=page, count=count)
-    if tvs:
-        return [media.to_dict() for media in tvs]
-    return []
+    return RecommendChain().douban_tv_weekly_global(page=page, count=count)
 
 
 @router.get("/tv_animation", summary="豆瓣动画剧集", response_model=List[schemas.MediaInfo])
@@ -124,10 +105,7 @@ def tv_animation(page: int = 1,
     """
     热门动画剧集
     """
-    tvs = DoubanChain().tv_animation(page=page, count=count)
-    if tvs:
-        return [media.to_dict() for media in tvs]
-    return []
+    return RecommendChain().douban_tv_animation(page=page, count=count)
 
 
 @router.get("/movie_hot", summary="豆瓣热门电影", response_model=List[schemas.MediaInfo])
@@ -137,10 +115,7 @@ def movie_hot(page: int = 1,
     """
     热门电影
     """
-    movies = DoubanChain().movie_hot(page=page, count=count)
-    if movies:
-        return [media.to_dict() for media in movies]
-    return []
+    return RecommendChain().douban_movie_hot(page=page, count=count)
 
 
 @router.get("/tv_hot", summary="豆瓣热门电视剧", response_model=List[schemas.MediaInfo])
@@ -150,10 +125,7 @@ def tv_hot(page: int = 1,
     """
     热门电视剧
     """
-    tvs = DoubanChain().tv_hot(page=page, count=count)
-    if tvs:
-        return [media.to_dict() for media in tvs]
-    return []
+    return RecommendChain().douban_tv_hot(page=page, count=count)
 
 
 @router.get("/credits/{doubanid}/{type_name}", summary="豆瓣演员阵容", response_model=List[schemas.MediaPerson])

app/api/endpoints/download.py

@@ -9,13 +9,15 @@ from app.core.context import MediaInfo, Context, TorrentInfo
 from app.core.metainfo import MetaInfo
 from app.core.security import verify_token
 from app.db.models.user import User
+from app.db.systemconfig_oper import SystemConfigOper
 from app.db.user_oper import get_current_active_user
+from app.schemas.types import SystemConfigKey
 
 router = APIRouter()
 
 
 @router.get("/", summary="正在下载", response_model=List[schemas.DownloadingTorrent])
-def list(
+def current(
         name: str = None,
         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
@@ -49,7 +51,7 @@ def download(
         torrent_info=torrentinfo
     )
     did = DownloadChain().download_single(context=context, username=current_user.name,
-                                          downloader=downloader, save_path=save_path)
+                                          downloader=downloader, save_path=save_path, source="Manual")
     if not did:
         return schemas.Response(success=False, message="任务添加失败")
     return schemas.Response(success=True, data={
@@ -82,7 +84,7 @@ def add(
         torrent_info=torrentinfo
     )
     did = DownloadChain().download_single(context=context, username=current_user.name,
-                                          downloader=downloader, save_path=save_path)
+                                          downloader=downloader, save_path=save_path, source="Manual")
     if not did:
         return schemas.Response(success=False, message="任务添加失败")
     return schemas.Response(success=True, data={
@@ -111,6 +113,17 @@ def stop(hashString: str,
     return schemas.Response(success=True if ret else False)
 
 
+@router.get("/clients", summary="查询可用下载器", response_model=List[dict])
+def clients(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询可用下载器
+    """
+    downloaders: List[dict] = SystemConfigOper().get(SystemConfigKey.Downloaders)
+    if downloaders:
+        return [{"name": d.get("name"), "type": d.get("type")} for d in downloaders if d.get("enabled")]
+    return []
+
+
 @router.delete("/{hashString}", summary="删除下载任务", response_model=schemas.Response)
 def delete(hashString: str,
            _: schemas.TokenPayload = Depends(verify_token)) -> Any:

app/api/endpoints/history.py

@@ -1,10 +1,12 @@
 from typing import List, Any
 
+import jieba
 from fastapi import APIRouter, Depends
 from sqlalchemy.orm import Session
 
 from app import schemas
 from app.chain.storage import StorageChain
+from app.core.config import settings
 from app.core.event import eventmanager
 from app.core.security import verify_token
 from app.db import get_db
@@ -39,7 +41,7 @@ def delete_download_history(history_in: schemas.DownloadHistory,
     return schemas.Response(success=True)
 
 
-@router.get("/transfer", summary="查询转移历史记录", response_model=schemas.Response)
+@router.get("/transfer", summary="查询整理记录", response_model=schemas.Response)
 def transfer_history(title: str = None,
                      page: int = 1,
                      count: int = 30,
@@ -47,7 +49,7 @@ def transfer_history(title: str = None,
                      db: Session = Depends(get_db),
                      _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
-    查询转移历史记录
+    查询整理记录
     """
     if title == "失败":
         title = None
@@ -57,6 +59,9 @@ def transfer_history(title: str = None,
         status = True
 
     if title:
+        if settings.TOKENIZED_SEARCH:
+            words = jieba.cut(title, HMM=False)
+            title = "%".join(words)
         total = TransferHistory.count_by_title(db, title=title, status=status)
         result = TransferHistory.list_by_title(db, title=title, page=page,
                                                count=count, status=status)
@@ -71,14 +76,14 @@ def transfer_history(title: str = None,
                             })
 
 
-@router.delete("/transfer", summary="删除转移历史记录", response_model=schemas.Response)
+@router.delete("/transfer", summary="删除整理记录", response_model=schemas.Response)
 def delete_transfer_history(history_in: schemas.TransferHistory,
                             deletesrc: bool = False,
                             deletedest: bool = False,
                             db: Session = Depends(get_db),
                             _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
     """
-    删除转移历史记录
+    删除整理记录
     """
     history: TransferHistory = TransferHistory.get(db, history_in.id)
     if not history:
@@ -86,9 +91,7 @@ def delete_transfer_history(history_in: schemas.TransferHistory,
     # 册除媒体库文件
     if deletedest and history.dest_fileitem:
         dest_fileitem = schemas.FileItem(**history.dest_fileitem)
-        state = StorageChain().delete_media_file(fileitem=dest_fileitem, mtype=MediaType(history.type))
-        if not state:
-            return schemas.Response(success=False, message=f"{dest_fileitem.path} 删除失败")
+        StorageChain().delete_media_file(fileitem=dest_fileitem, mtype=MediaType(history.type))
 
     # 删除源文件
     if deletesrc and history.src_fileitem:
@@ -109,11 +112,11 @@ def delete_transfer_history(history_in: schemas.TransferHistory,
     return schemas.Response(success=True)
 
 
-@router.get("/empty/transfer", summary="清空转移历史记录", response_model=schemas.Response)
+@router.get("/empty/transfer", summary="清空整理记录", response_model=schemas.Response)
 def delete_transfer_history(db: Session = Depends(get_db),
                             _: User = Depends(get_current_active_superuser)) -> Any:
     """
-    清空转移历史记录
+    清空整理记录
     """
     TransferHistory.truncate(db)
     return schemas.Response(success=True)

app/api/endpoints/media.py

@@ -72,7 +72,7 @@ def search(title: str,
     """
     模糊搜索媒体/人物信息列表 media：媒体信息，person：人物信息
     """
-    def __get_source(obj: Union[dict, schemas.MediaPerson]):
+    def __get_source(obj: Union[schemas.MediaInfo, schemas.MediaPerson, dict]):
         """
         获取对象属性
         """
@@ -85,6 +85,8 @@ def search(title: str,
         _, medias = MediaChain().search(title=title)
         if medias:
             result = [media.to_dict() for media in medias]
+    elif type == "collection":
+        result = MediaChain().search_collections(name=title)
     else:
         result = MediaChain().search_persons(name=title)
     if result:
@@ -111,16 +113,13 @@ def scrape(fileitem: schemas.FileItem,
     scrape_path = Path(fileitem.path)
     meta = MetaInfoPath(scrape_path)
     mediainfo = chain.recognize_by_meta(meta)
-    if not media_info:
+    if not mediainfo:
         return schemas.Response(success=False, message="刮削失败，无法识别媒体信息")
     if storage == "local":
         if not scrape_path.exists():
             return schemas.Response(success=False, message="刮削路径不存在")
-    else:
-        if not fileitem.fileid:
-            return schemas.Response(success=False, message="刮削文件ID无效")
     # 手动刮削
-    chain.scrape_metadata(fileitem=fileitem, meta=meta, mediainfo=mediainfo)
+    chain.scrape_metadata(fileitem=fileitem, meta=meta, mediainfo=mediainfo, overwrite=True)
     return schemas.Response(success=True, message=f"{fileitem.path} 刮削完成")
 
 

app/api/endpoints/mediaserver.py

@@ -12,8 +12,10 @@ from app.core.security import verify_token
 from app.db import get_db
 from app.db.mediaserver_oper import MediaServerOper
 from app.db.models import MediaServerItem
+from app.db.systemconfig_oper import SystemConfigOper
 from app.helper.mediaserver import MediaServerHelper
 from app.schemas import MediaType, NotExistMediaInfo
+from app.schemas.types import SystemConfigKey
 
 router = APIRouter()
 
@@ -143,3 +145,14 @@ def library(server: str, hidden: bool = False,
     获取媒体服务器媒体库列表
     """
     return MediaServerChain().librarys(server=server, username=userinfo.username, hidden=hidden) or []
+
+
+@router.get("/clients", summary="查询可用媒体服务器", response_model=List[dict])
+def clients(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询可用媒体服务器
+    """
+    mediaservers: List[dict] = SystemConfigOper().get(SystemConfigKey.MediaServers)
+    if mediaservers:
+        return [{"name": d.get("name"), "type": d.get("type")} for d in mediaservers if d.get("enabled")]
+    return []

app/api/endpoints/plugin.py

@@ -3,7 +3,7 @@ from typing import Annotated, Any, List, Optional
 from fastapi import APIRouter, Depends, Header
 
 from app import schemas
-from app.chain.command import CommandChain
+from app.command import Command
 from app.core.config import settings
 from app.core.plugin import PluginManager
 from app.core.security import verify_apikey, verify_token
@@ -212,7 +212,7 @@ def install(plugin_id: str,
     # 注册插件服务
     Scheduler().update_plugin_job(plugin_id)
     # 注册菜单命令
-    CommandChain().init_commands(plugin_id)
+    Command().init_commands(plugin_id)
     # 注册插件API
     register_plugin_api(plugin_id)
     return schemas.Response(success=True)
@@ -280,7 +280,7 @@ def reset_plugin(plugin_id: str,
     # 注册插件服务
     Scheduler().update_plugin_job(plugin_id)
     # 注册菜单命令
-    CommandChain().init_commands(plugin_id)
+    Command().init_commands(plugin_id)
     # 注册插件API
     register_plugin_api(plugin_id)
     return schemas.Response(success=True)
@@ -308,7 +308,7 @@ def set_plugin_config(plugin_id: str, conf: dict,
     # 注册插件服务
     Scheduler().update_plugin_job(plugin_id)
     # 注册菜单命令
-    CommandChain().init_commands(plugin_id)
+    Command().init_commands(plugin_id)
     # 注册插件API
     register_plugin_api(plugin_id)
     return schemas.Response(success=True)

app/api/endpoints/site.py

@@ -8,6 +8,7 @@ from app import schemas
 from app.chain.site import SiteChain
 from app.chain.torrents import TorrentsChain
 from app.core.event import EventManager
+from app.core.plugin import PluginManager
 from app.core.security import verify_token
 from app.db import get_db
 from app.db.models import User
@@ -331,6 +332,31 @@ def read_rss_sites(db: Session = Depends(get_db),
     return rss_sites
 
 
+@router.get("/auth", summary="查询认证站点", response_model=dict)
+def read_auth_sites(_: schemas.TokenPayload = Depends(verify_token)) -> dict:
+    """
+    获取可认证站点列表
+    """
+    return SitesHelper().get_authsites()
+
+
+@router.post("/auth", summary="用户站点认证", response_model=schemas.Response)
+def auth_site(
+        auth_info: schemas.SiteAuth,
+        _: User = Depends(get_current_active_superuser)
+) -> Any:
+    """
+    用户站点认证
+    """
+    if not auth_info or not auth_info.site or not auth_info.params:
+        return schemas.Response(success=False, message="请输入认证站点和认证参数")
+    status, msg = SitesHelper().check_user(auth_info.site, auth_info.params)
+    SystemConfigOper().set(SystemConfigKey.UserSiteAuthParams, auth_info.dict())
+    PluginManager().init_config()
+    Scheduler().init_plugin_jobs()
+    return schemas.Response(success=status, message=msg)
+
+
 @router.get("/{site_id}", summary="站点详情", response_model=schemas.Site)
 def read_site(
         site_id: int,

app/api/endpoints/storage.py

@@ -151,8 +151,6 @@ def rename(fileitem: schemas.FileItem,
     """
     if not new_name:
         return schemas.Response(success=False, message="新名称为空")
-    if fileitem.storage != 'local' and not fileitem.fileid:
-            return schemas.Response(success=False, message="资源ID获取失败")
     result = StorageChain().rename_file(fileitem, new_name)
     if result:
         if recursive:

app/api/endpoints/subscribe.py

@@ -8,6 +8,7 @@ from app import schemas
 from app.chain.subscribe import SubscribeChain
 from app.core.config import settings
 from app.core.context import MediaInfo
+from app.core.event import eventmanager
 from app.core.metainfo import MetaInfo
 from app.core.security import verify_token, verify_apitoken
 from app.db import get_db
@@ -17,7 +18,7 @@ from app.db.models.user import User
 from app.db.user_oper import get_current_active_user
 from app.helper.subscribe import SubscribeHelper
 from app.scheduler import Scheduler
-from app.schemas.types import MediaType
+from app.schemas.types import MediaType, EventType
 
 router = APIRouter()
 
@@ -121,6 +122,32 @@ def update_subscribe(
     if subscribe_in.total_episode != subscribe.total_episode:
         subscribe_dict["manual_total_episode"] = 1
     subscribe.update(db, subscribe_dict)
+    # 发送订阅调整事件
+    eventmanager.send_event(EventType.SubscribeModified, {
+        "subscribe_id": subscribe.id,
+        "subscribe_info": subscribe_dict,
+    })
+    return schemas.Response(success=True)
+
+
+@router.put("/status/{subid}", summary="更新订阅状态", response_model=schemas.Response)
+def update_subscribe_status(
+        subid: int,
+        state: str,
+        db: Session = Depends(get_db),
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    更新订阅状态
+    """
+    subscribe = Subscribe.get(db, subid)
+    if not subscribe:
+        return schemas.Response(success=False, message="订阅不存在")
+    valid_states = ["R", "P", "S"]
+    if state not in valid_states:
+        return schemas.Response(success=False, message="无效的订阅状态")
+    subscribe.update(db, {
+        "state": state
+    })
     return schemas.Response(success=True)
 
 
@@ -186,8 +213,9 @@ def reset_subscribes(
     subscribe = Subscribe.get(db, subid)
     if subscribe:
         subscribe.update(db, {
-            "note": "",
-            "lack_episode": subscribe.total_episode
+            "note": [],
+            "lack_episode": subscribe.total_episode,
+            "state": "R"
         })
         return schemas.Response(success=True)
     return schemas.Response(success=False, message="订阅不存在")
@@ -252,17 +280,27 @@ def delete_subscribe_by_mediaid(
     """
     根据TMDBID或豆瓣ID删除订阅 tmdb:/douban:
     """
+    delete_subscribes = []
     if mediaid.startswith("tmdb:"):
         tmdbid = mediaid[5:]
         if not tmdbid or not str(tmdbid).isdigit():
             return schemas.Response(success=False)
-        Subscribe().delete_by_tmdbid(db, int(tmdbid), season)
+        subscribes = Subscribe().get_by_tmdbid(db, int(tmdbid), season)
+        delete_subscribes.extend(subscribes)
     elif mediaid.startswith("douban:"):
         doubanid = mediaid[7:]
         if not doubanid:
             return schemas.Response(success=False)
-        Subscribe().delete_by_doubanid(db, doubanid)
-
+        subscribe = Subscribe().get_by_doubanid(db, doubanid)
+        if subscribe:
+            delete_subscribes.append(subscribe)
+    for subscribe in delete_subscribes:
+        Subscribe().delete(db, subscribe.id)
+        # 发送事件
+        eventmanager.send_event(EventType.SubscribeDeleted, {
+            "subscribe_id": subscribe.id,
+            "subscribe_info": subscribe.to_dict()
+        })
     return schemas.Response(success=True)
 
 
@@ -429,6 +467,17 @@ def subscribe_share(
     return schemas.Response(success=state, message=errmsg)
 
 
+@router.delete("/share/{share_id}", summary="删除分享", response_model=schemas.Response)
+def subscribe_share_delete(
+        share_id: int,
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    删除分享
+    """
+    state, errmsg = SubscribeHelper().share_delete(share_id=share_id)
+    return schemas.Response(success=state, message=errmsg)
+
+
 @router.post("/fork", summary="复用订阅", response_model=schemas.Response)
 def subscribe_fork(
         sub: schemas.SubscribeShare,
@@ -485,9 +534,14 @@ def delete_subscribe(
     subscribe = Subscribe.get(db, subscribe_id)
     if subscribe:
         subscribe.delete(db, subscribe_id)
-    # 统计订阅
-    SubscribeHelper().sub_done_async({
-        "tmdbid": subscribe.tmdbid,
-        "doubanid": subscribe.doubanid
-    })
+        # 发送事件
+        eventmanager.send_event(EventType.SubscribeDeleted, {
+            "subscribe_id": subscribe_id,
+            "subscribe_info": subscribe.to_dict()
+        })
+        # 统计订阅
+        SubscribeHelper().sub_done_async({
+            "tmdbid": subscribe.tmdbid,
+            "doubanid": subscribe.doubanid
+        })
     return schemas.Response(success=True)

app/api/endpoints/system.py

@@ -16,6 +16,7 @@ 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.metainfo import MetaInfo
 from app.core.module import ModuleManager
 from app.core.security import verify_apitoken, verify_resource_token, verify_token
 from app.db.models import User
@@ -159,7 +160,8 @@ def cache_img(
     本地缓存图片文件，支持 HTTP 缓存，如果启用全局图片缓存，则使用磁盘缓存
     """
     # 如果没有启用全局图片缓存，则不使用磁盘缓存
-    return fetch_image(url=url, proxy=False, use_disk_cache=settings.GLOBAL_IMAGE_CACHE, if_none_match=if_none_match)
+    proxy = "doubanio.com" not in url
+    return fetch_image(url=url, proxy=proxy, use_disk_cache=settings.GLOBAL_IMAGE_CACHE, if_none_match=if_none_match)
 
 
 @router.get("/global", summary="查询非敏感系统设置", response_model=schemas.Response)
@@ -172,6 +174,10 @@ def get_global_setting():
         exclude={"SECRET_KEY", "RESOURCE_SECRET_KEY", "API_TOKEN", "TMDB_API_KEY", "TVDB_API_KEY", "FANART_API_KEY",
                  "COOKIECLOUD_KEY", "COOKIECLOUD_PASSWORD", "GITHUB_TOKEN", "REPO_GITHUB_TOKEN"}
     )
+    # 追加用户唯一ID
+    info.update({
+        "USER_UNIQUE_ID": SystemUtils.generate_user_unique_id()
+    })
     return schemas.Response(success=True,
                             data=info)
 
@@ -384,9 +390,14 @@ def ruletest(title: str,
     if not rulegroup:
         return schemas.Response(success=False, message=f"过滤规则组 {rulegroup_name} 不存在！")
 
+    # 根据标题查询媒体信息
+    media_info = SearchChain().recognize_media(MetaInfo(title=title, subtitle=subtitle))
+    if not media_info:
+        return schemas.Response(success=False, message="未识别到媒体信息！")
+
     # 过滤
     result = SearchChain().filter_torrents(rule_groups=[rulegroup.name],
-                                           torrent_list=[torrent])
+                                           torrent_list=[torrent], mediainfo=media_info)
     if not result:
         return schemas.Response(success=False, message="不符合过滤规则！")
     return schemas.Response(success=True, data={

app/api/endpoints/tmdb.py

@@ -3,6 +3,7 @@ from typing import List, Any
 from fastapi import APIRouter, Depends
 
 from app import schemas
+from app.chain.recommend import RecommendChain
 from app.chain.tmdb import TmdbChain
 from app.core.security import verify_token
 from app.schemas.types import MediaType
@@ -59,6 +60,20 @@ def tmdb_recommend(tmdbid: int,
     return []
 
 
+@router.get("/collection/{collection_id}", summary="系列合集详情", response_model=List[schemas.MediaInfo])
+def tmdb_collection(collection_id: int,
+                    page: int = 1,
+                    count: int = 20,
+                    _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    根据合集ID查询合集详情
+    """
+    medias = TmdbChain().tmdb_collection(collection_id=collection_id)
+    if medias:
+        return [media.to_dict() for media in medias][(page - 1) * count:page * count]
+    return []
+
+
 @router.get("/credits/{tmdbid}/{type_name}", summary="演员阵容", response_model=List[schemas.MediaPerson])
 def tmdb_credits(tmdbid: int,
                  type_name: str,
@@ -108,14 +123,10 @@ def tmdb_movies(sort_by: str = "popularity.desc",
     """
     浏览TMDB电影信息
     """
-    movies = TmdbChain().tmdb_discover(mtype=MediaType.MOVIE,
-                                       sort_by=sort_by,
-                                       with_genres=with_genres,
-                                       with_original_language=with_original_language,
-                                       page=page)
-    if not movies:
-        return []
-    return [movie.to_dict() for movie in movies]
+    return RecommendChain().tmdb_movies(sort_by=sort_by,
+                                        with_genres=with_genres,
+                                        with_original_language=with_original_language,
+                                        page=page)
 
 
 @router.get("/tvs", summary="TMDB剧集", response_model=List[schemas.MediaInfo])
@@ -127,26 +138,19 @@ def tmdb_tvs(sort_by: str = "popularity.desc",
     """
     浏览TMDB剧集信息
     """
-    tvs = TmdbChain().tmdb_discover(mtype=MediaType.TV,
-                                    sort_by=sort_by,
-                                    with_genres=with_genres,
-                                    with_original_language=with_original_language,
-                                    page=page)
-    if not tvs:
-        return []
-    return [tv.to_dict() for tv in tvs]
+    return RecommendChain().tmdb_tvs(sort_by=sort_by,
+                                     with_genres=with_genres,
+                                     with_original_language=with_original_language,
+                                     page=page)
 
 
 @router.get("/trending", summary="TMDB流行趋势", response_model=List[schemas.MediaInfo])
 def tmdb_trending(page: int = 1,
                   _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
-    浏览TMDB剧集信息
+    TMDB流行趋势
     """
-    infos = TmdbChain().tmdb_trending(page=page)
-    if not infos:
-        return []
-    return [info.to_dict() for info in infos]
+    return RecommendChain().tmdb_trending(page=page)
 
 
 @router.get("/{tmdbid}/{season}", summary="TMDB季所有集", response_model=List[schemas.TmdbEpisode])

app/api/endpoints/transfer.py

@@ -1,8 +1,7 @@
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any, List
 
 from fastapi import APIRouter, Depends
-from pydantic import BaseModel
 from sqlalchemy.orm import Session
 
 from app import schemas
@@ -14,30 +13,11 @@ 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.schemas import MediaType, FileItem
+from app.schemas import MediaType, FileItem, ManualTransferItem
 
 router = APIRouter()
 
 
-class ManualTransferItem(BaseModel):
-    fileitem: FileItem = None,
-    logid: Optional[int] = None,
-    target_storage: Optional[str] = None,
-    target_path: Optional[str] = None,
-    tmdbid: Optional[int] = None,
-    doubanid: Optional[str] = None,
-    type_name: Optional[str] = None,
-    season: Optional[int] = None,
-    transfer_type: Optional[str] = None,
-    episode_format: Optional[str] = None,
-    episode_detail: Optional[str] = None,
-    episode_part: Optional[str] = None,
-    episode_offset: Optional[int] = 0,
-    min_filesize: Optional[int] = 0,
-    scrape: bool = False,
-    from_history: bool = False
-
-
 @router.get("/name", summary="查询整理后的名称", response_model=schemas.Response)
 def query_name(path: str, filetype: str,
                _: schemas.TokenPayload = Depends(verify_token)) -> Any:
@@ -67,13 +47,35 @@ def query_name(path: str, filetype: str,
     })
 
 
+@router.get("/queue", summary="查询整理队列", response_model=List[schemas.TransferJob])
+def query_queue(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询整理队列
+    :param _: Token校验
+    """
+    return TransferChain().get_queue_tasks()
+
+
+@router.delete("/queue", summary="从整理队列中删除任务", response_model=schemas.Response)
+def remove_queue(fileitem: schemas.FileItem, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询整理队列
+    :param fileitem: 文件项
+    :param _: Token校验
+    """
+    TransferChain().remove_from_queue(fileitem)
+    return schemas.Response(success=True)
+
+
 @router.post("/manual", summary="手动转移", response_model=schemas.Response)
 def manual_transfer(transer_item: ManualTransferItem,
+                    background: bool = False,
                     db: Session = Depends(get_db),
                     _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
     """
     手动转移，文件或历史记录，支持自定义剧集识别格式
     :param transer_item: 手工整理项
+    :param background: 后台运行
     :param db: 数据库
     :param _: Token校验
     """
@@ -83,7 +85,7 @@ def manual_transfer(transer_item: ManualTransferItem,
         # 查询历史记录
         history: TransferHistory = TransferHistory.get(db, transer_item.logid)
         if not history:
-            return schemas.Response(success=False, message=f"历史记录不存在，ID：{transer_item.logid}")
+            return schemas.Response(success=False, message=f"整理记录不存在，ID：{transer_item.logid}")
         # 强制转移
         force = True
         if history.status and ("move" in history.mode):
@@ -148,7 +150,10 @@ def manual_transfer(transer_item: ManualTransferItem,
         epformat=epformat,
         min_filesize=transer_item.min_filesize,
         scrape=transer_item.scrape,
-        force=force
+        library_type_folder=transer_item.library_type_folder,
+        library_category_folder=transer_item.library_category_folder,
+        force=force,
+        background=background
     )
     # 失败
     if not state:

app/api/servcookie.py

@@ -19,7 +19,7 @@ class GzipRequest(Request):
             body = await super().body()
             if "gzip" in self.headers.getlist("Content-Encoding"):
                 body = gzip.decompress(body)
-            self._body = body
+            self._body = body # noqa
         return self._body
 
 

app/chain/__init__.py

@@ -1,3 +1,4 @@
+import copy
 import gc
 import pickle
 import traceback
@@ -61,7 +62,7 @@ class ChainBase(metaclass=ABCMeta):
         """
         try:
             with open(settings.TEMP_PATH / filename, 'wb') as f:
-                pickle.dump(cache, f)
+                pickle.dump(cache, f) # noqa
         except Exception as err:
             logger.error(f"保存缓存 {filename} 出错：{str(err)}")
         finally:
@@ -300,6 +301,13 @@ class ChainBase(metaclass=ABCMeta):
         """
         return self.run_module("search_persons", name=name)
 
+    def search_collections(self, name: str) -> Optional[List[MediaInfo]]:
+        """
+        搜索集合信息
+        :param name:  集合名称
+        """
+        return self.run_module("search_collections", name=name)
+
     def search_torrents(self, site: CommentedMap,
                         keywords: List[str],
                         mtype: MediaType = None,
@@ -325,24 +333,21 @@ class ChainBase(metaclass=ABCMeta):
 
     def filter_torrents(self, rule_groups: List[str],
                         torrent_list: List[TorrentInfo],
-                        season_episodes: Dict[int, list] = None,
                         mediainfo: MediaInfo = None) -> List[TorrentInfo]:
         """
         过滤种子资源
         :param rule_groups:  过滤规则组名称列表
         :param torrent_list:  资源列表
-        :param season_episodes:  季集数过滤 {season:[episodes]}
         :param mediainfo:  识别的媒体信息
         :return: 过滤后的资源列表，添加资源优先级
         """
         return self.run_module("filter_torrents", rule_groups=rule_groups,
-                               torrent_list=torrent_list, season_episodes=season_episodes,
-                               mediainfo=mediainfo)
+                               torrent_list=torrent_list, mediainfo=mediainfo)
 
     def download(self, content: Union[Path, str], download_dir: Path, cookie: str,
                  episodes: Set[int] = None, category: str = None,
                  downloader: str = None
-                 ) -> Optional[Tuple[Optional[str], Optional[str], str]]:
+                 ) -> Optional[Tuple[Optional[str], Optional[str], Optional[str], str]]:
         """
         根据种子文件，选择并添加下载任务
         :param content:  种子文件地址或者磁力链接
@@ -351,7 +356,7 @@ class ChainBase(metaclass=ABCMeta):
         :param episodes:  需要下载的集数
         :param category:  种子分类
         :param downloader:  下载器
-        :return: 下载器名称、种子Hash、错误信息
+        :return: 下载器名称、种子Hash、种子文件布局、错误原因
         """
         return self.run_module("download", content=content, download_dir=download_dir,
                                cookie=cookie, episodes=episodes, category=category,
@@ -385,6 +390,7 @@ class ChainBase(metaclass=ABCMeta):
                  target_directory: TransferDirectoryConf = None,
                  target_storage: str = None, target_path: Path = None,
                  transfer_type: str = None, scrape: bool = None,
+                 library_type_folder: bool = None, library_category_folder: bool = None,
                  episodes_info: List[TmdbEpisode] = None) -> Optional[TransferInfo]:
         """
         文件转移
@@ -396,6 +402,8 @@ class ChainBase(metaclass=ABCMeta):
         :param target_path:  目标路径
         :param transfer_type:  转移模式
         :param scrape: 是否刮削元数据
+        :param library_type_folder: 是否按类型创建目录
+        :param library_category_folder: 是否按类别创建目录
         :param episodes_info: 当前季的全部集信息
         :return: {path, target_path, message}
         """
@@ -404,6 +412,8 @@ class ChainBase(metaclass=ABCMeta):
                                target_directory=target_directory,
                                target_path=target_path, target_storage=target_storage,
                                transfer_type=transfer_type, scrape=scrape,
+                               library_type_folder=library_type_folder,
+                               library_category_folder=library_category_folder,
                                episodes_info=episodes_info)
 
     def transfer_completed(self, hashs: str, downloader: str = None) -> None:
@@ -483,32 +493,58 @@ class ChainBase(metaclass=ABCMeta):
                     f"title={message.title}, "
                     f"text={message.text}，"
                     f"userid={message.userid}")
-        if not message.userid and message.mtype:
-            # 没有指定用户ID时，按规则确定发送对象
-            # 默认发送全体
-            to_targets = None
-            notify_action = ServiceConfigHelper.get_notification_switch(message.mtype)
-            if notify_action == "admin":
-                # 仅发送管理员
-                logger.info(f"已设置 {message.mtype} 的消息只发送给管理员")
-                to_targets = self.useroper.get_settings(settings.SUPERUSER)
-            elif notify_action == "user":
-                # 发送对应用户
-                if message.username:
-                    logger.info(f"已设置 {message.mtype} 的消息只发送给用户 {message.username}")
-                    to_targets = self.useroper.get_settings(message.username)
-                if not message.username or to_targets is None:
-                    if message.username:
-                        logger.info(f"没有 {message.username} 这个用户，该消息将发送给管理员")
-                    # 回滚发送管理员
-                    to_targets = self.useroper.get_settings(settings.SUPERUSER)
-            message.targets = to_targets
-        # 发送事件
-        self.eventmanager.send_event(etype=EventType.NoticeMessage, data={**message.dict(), "type": message.mtype})
-        # 保存消息
+        # 保存原消息
         self.messagehelper.put(message, role="user", title=message.title)
         self.messageoper.add(**message.dict())
-        # 发送
+        # 发送消息按设置隔离
+        if not message.userid and message.mtype:
+            # 消息隔离设置
+            notify_action = ServiceConfigHelper.get_notification_switch(message.mtype)
+            if notify_action:
+                # 'admin' 'user,admin' 'user' 'all'
+                actions = notify_action.split(",")
+                # 是否已发送管理员标志
+                admin_sended = False
+                send_orignal = False
+                for action in actions:
+                    send_message = copy.deepcopy(message)
+                    if action == "admin" and not admin_sended:
+                        # 仅发送管理员
+                        logger.info(f"{send_message.mtype} 的消息已设置发送给管理员")
+                        # 读取管理员消息IDS
+                        send_message.targets = self.useroper.get_settings(settings.SUPERUSER)
+                        admin_sended = True
+                    elif action == "user" and send_message.username:
+                        # 发送对应用户
+                        logger.info(f"{send_message.mtype} 的消息已设置发送给用户 {send_message.username}")
+                        # 读取用户消息IDS
+                        send_message.targets = self.useroper.get_settings(send_message.username)
+                        if send_message.targets is None:
+                            # 没有找到用户
+                            if not admin_sended:
+                                # 回滚发送管理员
+                                logger.info(f"用户 {send_message.username} 不存在，消息将发送给管理员")
+                                # 读取管理员消息IDS
+                                send_message.targets = self.useroper.get_settings(settings.SUPERUSER)
+                                admin_sended = True
+                            else:
+                                # 管理员发过了，此消息不发了
+                                logger.info(f"用户 {send_message.username} 不存在，消息无法发送到对应用户")
+                                continue
+                    else:
+                        # 按原消息发送全体
+                        if not admin_sended:
+                            send_orignal = True
+                        break
+                    # 按设定发送
+                    self.eventmanager.send_event(etype=EventType.NoticeMessage,
+                                                 data={**send_message.dict(), "type": send_message.mtype})
+                    self.run_module("post_message", message=send_message)
+                if not send_orignal:
+                    return
+        # 发送消息事件
+        self.eventmanager.send_event(etype=EventType.NoticeMessage, data={**message.dict(), "type": message.mtype})
+        # 按原消息发送
         self.run_module("post_message", message=message)
 
     def post_medias_message(self, message: Notification, medias: List[MediaInfo]) -> None:

app/chain/download.py

@@ -19,8 +19,8 @@ from app.helper.directory import DirectoryHelper
 from app.helper.message import MessageHelper
 from app.helper.torrent import TorrentHelper
 from app.log import logger
-from app.schemas import ExistMediaInfo, NotExistMediaInfo, DownloadingTorrent, Notification
-from app.schemas.types import MediaType, TorrentStatus, EventType, MessageChannel, NotificationType
+from app.schemas import ExistMediaInfo, NotExistMediaInfo, DownloadingTorrent, Notification, ResourceSelectionEventData, ResourceDownloadEventData
+from app.schemas.types import MediaType, TorrentStatus, EventType, MessageChannel, NotificationType, ChainEventType
 from app.utils.http import RequestUtils
 from app.utils.string import StringUtils
 
@@ -180,7 +180,7 @@ class DownloadChain(ChainBase):
         torrent_file, content, download_folder, files, error_msg = self.torrent.download_torrent(
             url=torrent_url,
             cookie=site_cookie,
-            ua=torrent.site_ua,
+            ua=torrent.site_ua or settings.USER_AGENT,
             proxy=torrent.site_proxy)
 
         if isinstance(content, str):
@@ -191,7 +191,7 @@ class DownloadChain(ChainBase):
             logger.error(f"下载种子文件失败：{torrent.title} - {torrent_url}")
             self.post_message(Notification(
                 channel=channel,
-                source=source,
+                source=source if channel else None,
                 mtype=NotificationType.Manual,
                 title=f"{torrent.title} 种子下载失败！",
                 text=f"错误信息：{error_msg}\n站点：{torrent.site_name}",
@@ -203,11 +203,12 @@ class DownloadChain(ChainBase):
 
     def download_single(self, context: Context, torrent_file: Path = None,
                         episodes: Set[int] = None,
-                        channel: MessageChannel = None, source: str = None,
+                        channel: MessageChannel = None,
+                        source: str = None,
+                        downloader: str = None,
                         save_path: str = None,
                         userid: Union[str, int] = None,
                         username: str = None,
-                        downloader: str = None,
                         media_category: str = None) -> Optional[str]:
         """
         下载及发送通知
@@ -215,16 +216,42 @@ class DownloadChain(ChainBase):
         :param torrent_file: 种子文件路径
         :param episodes: 需要下载的集数
         :param channel: 通知渠道
-        :param source: 通知来源
+        :param source: 来源（消息通知、Subscribe、Manual等）
+        :param downloader: 下载器
         :param save_path: 保存路径
         :param userid: 用户ID
         :param username: 调用下载的用户名/插件名
-        :param downloader: 下载器
         :param media_category: 自定义媒体类别
         """
+        # 发送资源下载事件，允许外部拦截下载
+        event_data = ResourceDownloadEventData(
+            context=context,
+            episodes=episodes or context.meta_info.episode_list,
+            channel=channel,
+            origin=source,
+            downloader=downloader,
+            options={
+                "save_path": save_path,
+                "userid": userid,
+                "username": username,
+                "media_category": media_category
+            }
+        )
+        # 触发资源下载事件
+        event = eventmanager.send_event(ChainEventType.ResourceDownload, event_data)
+        if event and event.event_data:
+            event_data: ResourceDownloadEventData = event.event_data
+            # 如果事件被取消，跳过资源下载
+            if event_data.cancel:
+                logger.debug(
+                    f"Resource download canceled by event: {event_data.source},"
+                    f"Reason: {event_data.reason}")
+                return None
+
         _torrent = context.torrent_info
         _media = context.media_info
         _meta = context.meta_info
+        _site_downloader = _torrent.site_downloader
 
         # 补充完整的media数据
         if not _media.genre_ids:
@@ -251,35 +278,31 @@ class DownloadChain(ChainBase):
 
         # 下载目录
         if save_path:
-            # 有自定义下载目录时，尝试匹配目录配置
-            dir_info = self.directoryhelper.get_dir(_media, src_path=Path(save_path), local=True)
-        else:
-            # 根据媒体信息查询下载目录配置
-            dir_info = self.directoryhelper.get_dir(_media, local=True)
-
-        # 拼装子目录
-        if dir_info:
-            # 一级目录
-            if not dir_info.media_type and dir_info.download_type_folder:
-                # 一级自动分类
-                download_dir = Path(dir_info.download_path) / _media.type.value
-            else:
-                # 一级不分类
-                download_dir = Path(dir_info.download_path)
-
-            # 二级目录
-            if not dir_info.media_category and dir_info.download_category_folder and _media and _media.category:
-                # 二级自动分类
-                download_dir = download_dir / _media.category
-        elif save_path:
-            # 自定义下载目录
+            # 下载目录使用自定义的
             download_dir = Path(save_path)
         else:
-            # 未找到下载目录，且没有自定义下载目录
-            logger.error(f"未找到下载目录：{_media.type.value} {_media.title_year}")
-            self.messagehelper.put(f"{_media.type.value} {_media.title_year} 未找到下载目录！",
-                                   title="下载失败", role="system")
-            return None
+            # 根据媒体信息查询下载目录配置
+            dir_info = self.directoryhelper.get_dir(_media, storage="local", include_unsorted=True)
+            # 拼装子目录
+            if dir_info:
+                # 一级目录
+                if not dir_info.media_type and dir_info.download_type_folder:
+                    # 一级自动分类
+                    download_dir = Path(dir_info.download_path) / _media.type.value
+                else:
+                    # 一级不分类
+                    download_dir = Path(dir_info.download_path)
+
+                # 二级目录
+                if not dir_info.media_category and dir_info.download_category_folder and _media and _media.category:
+                    # 二级自动分类
+                    download_dir = download_dir / _media.category
+            else:
+                # 未找到下载目录，且没有自定义下载目录
+                logger.error(f"未找到下载目录：{_media.type.value} {_media.title_year}")
+                self.messagehelper.put(f"{_media.type.value} {_media.title_year} 未找到下载目录！",
+                                       title="下载失败", role="system")
+                return None
 
         # 添加下载
         result: Optional[tuple] = self.download(content=content,
@@ -287,18 +310,25 @@ class DownloadChain(ChainBase):
                                                 episodes=episodes,
                                                 download_dir=download_dir,
                                                 category=_media.category,
-                                                downloader=downloader)
+                                                downloader=downloader or _site_downloader)
         if result:
-            _downloader, _hash, error_msg = result
+            _downloader, _hash, _layout, error_msg = result
         else:
-            _downloader, _hash, error_msg = None, None, "未找到下载器"
+            _downloader, _hash, _layout, error_msg = None, None, None, "未找到下载器"
 
         if _hash:
-            # 下载文件路径
-            if _folder_name:
-                download_path = download_dir / _folder_name
-            else:
+            # `不创建子文件夹` 或 `不存在子文件夹`
+            if _layout == "NoSubfolder" or not _folder_name:
+                # 下载路径记录至文件
                 download_path = download_dir / _file_list[0] if _file_list else download_dir
+            # 原始布局
+            elif _folder_name:
+                download_path = download_dir / _folder_name
+            # 创建子文件夹
+            else:
+                download_path = download_dir / Path(_file_list[0]).stem if _file_list else download_dir
+            # 文件保存路径
+            _save_path = download_dir if _layout == "NoSubfolder" or not _folder_name else download_path
 
             # 登记下载记录
             self.downloadhis.add(
@@ -313,6 +343,7 @@ class DownloadChain(ChainBase):
                 seasons=_meta.season,
                 episodes=download_episodes or _meta.episode,
                 image=_media.get_backdrop_image(),
+                downloader=_downloader,
                 download_hash=_hash,
                 torrent_name=_torrent.title,
                 torrent_description=_torrent.description,
@@ -321,7 +352,8 @@ class DownloadChain(ChainBase):
                 username=username,
                 channel=channel.value if channel else None,
                 date=time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()),
-                media_category=media_category
+                media_category=media_category,
+                note={"source": source}
             )
 
             # 登记下载文件
@@ -335,13 +367,13 @@ class DownloadChain(ChainBase):
                         continue
                 # 只处理视频格式
                 if not Path(file).suffix \
-                        or Path(file).suffix not in settings.RMT_MEDIAEXT:
+                        or Path(file).suffix.lower() not in settings.RMT_MEDIAEXT:
                     continue
                 files_to_add.append({
                     "download_hash": _hash,
                     "downloader": _downloader,
-                    "fullpath": str(download_dir / _folder_name / file),
-                    "savepath": str(download_dir / _folder_name),
+                    "fullpath": str(_save_path / file),
+                    "savepath": str(_save_path),
                     "filepath": file,
                     "torrentname": _meta.org_string,
                 })
@@ -358,7 +390,9 @@ class DownloadChain(ChainBase):
                 "hash": _hash,
                 "context": context,
                 "username": username,
-                "downloader": _downloader
+                "downloader": _downloader,
+                "episodes": episodes or _meta.episode_list,
+                "source": source
             })
         else:
             # 下载失败
@@ -367,7 +401,7 @@ class DownloadChain(ChainBase):
             # 只发送给对应渠道和用户
             self.post_message(Notification(
                 channel=channel,
-                source=source,
+                source=source if channel else None,
                 mtype=NotificationType.Manual,
                 title="添加下载任务失败：%s %s"
                       % (_media.title_year, _meta.season_episode),
@@ -386,7 +420,8 @@ class DownloadChain(ChainBase):
                        source: str = None,
                        userid: str = None,
                        username: str = None,
-                       media_category: str = None
+                       media_category: str = None,
+                       downloader: str = None
                        ) -> Tuple[List[Context], Dict[Union[int, str], Dict[int, NotExistMediaInfo]]]:
         """
         根据缺失数据，自动种子列表中组合择优下载
@@ -394,10 +429,11 @@ class DownloadChain(ChainBase):
         :param no_exists:  缺失的剧集信息
         :param save_path:  保存路径
         :param channel:  通知渠道
-        :param source:  通知来源
+        :param source:  来源（消息通知、订阅、手工下载等）
         :param userid:  用户ID
         :param username: 调用下载的用户名/插件名
         :param media_category: 自定义媒体类别
+        :param downloader: 下载器
         :return: 已经下载的资源列表、剩余未下载到的剧集 no_exists[tmdb_id/douban_id] = {season: NotExistMediaInfo}
         """
         # 已下载的项目
@@ -458,6 +494,22 @@ class DownloadChain(ChainBase):
                 return 9999
             return no_exist[season].total_episode
 
+        # 发送资源选择事件，允许外部修改上下文数据
+        logger.debug(f"Initial contexts: {len(contexts)} items, Downloader: {downloader}")
+        event_data = ResourceSelectionEventData(
+            contexts=contexts,
+            downloader=downloader,
+            origin=source
+        )
+        event = eventmanager.send_event(ChainEventType.ResourceSelection, event_data)
+        # 如果事件修改了上下文数据，使用更新后的数据
+        if event and event.event_data:
+            event_data: ResourceSelectionEventData = event.event_data
+            if event_data.updated and event_data.updated_contexts is not None:
+                logger.debug(f"Contexts updated by event: "
+                             f"{len(event_data.updated_contexts)} items (source: {event_data.source})")
+                contexts = event_data.updated_contexts
+
         # 分组排序
         contexts = TorrentHelper().sort_group_torrents(contexts)
 
@@ -469,14 +521,14 @@ class DownloadChain(ChainBase):
                 logger.info(f"开始下载电影 {context.torrent_info.title} ...")
                 if self.download_single(context, save_path=save_path, channel=channel,
                                         source=source, userid=userid, username=username,
-                                        media_category=media_category):
+                                        media_category=media_category, downloader=downloader):
                     # 下载成功
                     logger.info(f"{context.torrent_info.title} 添加下载成功")
                     downloaded_list.append(context)
 
         # 电视剧整季匹配
-        logger.info(f"开始匹配电视剧整季：{no_exists}")
         if no_exists:
+            logger.info(f"开始匹配电视剧整季：{no_exists}")
             # 先把整季缺失的拿出来，看是否刚好有所有季都满足的种子 {tmdbid: [seasons]}
             need_seasons: Dict[int, list] = {}
             for need_mid, need_tv in no_exists.items():
@@ -554,7 +606,8 @@ class DownloadChain(ChainBase):
                                         source=source,
                                         userid=userid,
                                         username=username,
-                                        media_category=media_category
+                                        media_category=media_category,
+                                        downloader=downloader,
                                     )
                             else:
                                 # 下载
@@ -562,7 +615,8 @@ class DownloadChain(ChainBase):
                                 download_id = self.download_single(context, save_path=save_path,
                                                                    channel=channel, source=source,
                                                                    userid=userid, username=username,
-                                                                   media_category=media_category)
+                                                                   media_category=media_category,
+                                                                   downloader=downloader)
 
                             if download_id:
                                 # 下载成功
@@ -577,8 +631,8 @@ class DownloadChain(ChainBase):
                                     # 全部下载完成
                                     break
         # 电视剧季内的集匹配
-        logger.info(f"开始电视剧完整集匹配：{no_exists}")
         if no_exists:
+            logger.info(f"开始电视剧完整集匹配：{no_exists}")
             # TMDBID列表
             need_tv_list = list(no_exists)
             for need_mid in need_tv_list:
@@ -633,7 +687,8 @@ class DownloadChain(ChainBase):
                                 download_id = self.download_single(context, save_path=save_path,
                                                                    channel=channel, source=source,
                                                                    userid=userid, username=username,
-                                                                   media_category=media_category)
+                                                                   media_category=media_category,
+                                                                   downloader=downloader)
                                 if download_id:
                                     # 下载成功
                                     logger.info(f"{meta.title} 添加下载成功")
@@ -646,8 +701,8 @@ class DownloadChain(ChainBase):
                                     logger.info(f"季 {need_season} 剩余需要集：{need_episodes}")
 
         # 仍然缺失的剧集，从整季中选择需要的集数文件下载，仅支持QB和TR
-        logger.info(f"开始电视剧多集拆包匹配：{no_exists}")
         if no_exists:
+            logger.info(f"开始电视剧多集拆包匹配：{no_exists}")
             # TMDBID列表
             no_exists_list = list(no_exists)
             for need_mid in no_exists_list:
@@ -722,7 +777,8 @@ class DownloadChain(ChainBase):
                                 source=source,
                                 userid=userid,
                                 username=username,
-                                media_category=media_category
+                                media_category=media_category,
+                                downloader=downloader
                             )
                             if not download_id:
                                 continue

app/chain/media.py

@@ -11,12 +11,15 @@ from app.core.event import eventmanager, Event
 from app.core.meta import MetaBase
 from app.core.metainfo import MetaInfo, MetaInfoPath
 from app.log import logger
+from app.schemas import FileItem
 from app.schemas.types import EventType, MediaType, ChainEventType
 from app.utils.http import RequestUtils
 from app.utils.singleton import Singleton
 from app.utils.string import StringUtils
 
 recognize_lock = Lock()
+scraping_lock = Lock()
+scraping_files = []
 
 
 class MediaChain(ChainBase, metaclass=Singleton):
@@ -301,12 +304,24 @@ class MediaChain(ChainBase, metaclass=Singleton):
         if not event:
             return
         event_data = event.event_data or {}
-        fileitem = event_data.get("fileitem")
-        meta = event_data.get("meta")
-        mediainfo = event_data.get("mediainfo")
+        fileitem: FileItem = event_data.get("fileitem")
+        meta: MetaBase = event_data.get("meta")
+        mediainfo: MediaInfo = event_data.get("mediainfo")
+        overwrite = event_data.get("overwrite", False)
         if not fileitem:
             return
-        self.scrape_metadata(fileitem=fileitem, meta=meta, mediainfo=mediainfo)
+        # 刮削锁
+        with scraping_lock:
+            if fileitem.path in scraping_files:
+                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)
 
     def scrape_metadata(self, fileitem: schemas.FileItem,
                         meta: MetaBase = None, mediainfo: MediaInfo = None,
@@ -322,6 +337,20 @@ class MediaChain(ChainBase, metaclass=Singleton):
         :param overwrite: 是否覆盖已有文件
         """
 
+        def is_bluray_folder(_fileitem: schemas.FileItem) -> bool:
+            """
+            判断是否为原盘目录
+            """
+            if not _fileitem or _fileitem.type != "dir":
+                return False
+            # 蓝光原盘目录必备的文件或文件夹
+            required_files = ['BDMV', 'CERTIFICATE']
+            # 检查目录下是否存在所需文件或文件夹
+            for item in self.storagechain.list_files(_fileitem):
+                if item.name in required_files:
+                    return True
+            return False
+
         def __list_files(_fileitem: schemas.FileItem):
             """
             列出下级文件
@@ -337,13 +366,19 @@ class MediaChain(ChainBase, metaclass=Singleton):
             """
             if not _fileitem or not _content or not _path:
                 return
-            tmp_file = settings.TEMP_PATH / _path.name
+            # 保存文件到临时目录，文件名随机
+            tmp_file = settings.TEMP_PATH / f"{_path.name}.{StringUtils.generate_random_str(10)}"
             tmp_file.write_bytes(_content)
-            logger.info(f"保存文件：【{_fileitem.storage}】{_path}")
-            _fileitem.path = str(_path.parent)
-            self.storagechain.upload_file(fileitem=_fileitem, path=tmp_file)
-            if tmp_file.exists():
-                tmp_file.unlink()
+            # 获取文件的父目录
+            try:
+                item = self.storagechain.upload_file(fileitem=_fileitem, path=tmp_file, new_name=_path.name)
+                if item:
+                    logger.info(f"已保存文件：{item.path}")
+                else:
+                    logger.warn(f"文件保存失败：{item.path}")
+            finally:
+                if tmp_file.exists():
+                    tmp_file.unlink()
 
         def __download_image(_url: str) -> Optional[bytes]:
             """
@@ -376,25 +411,40 @@ class MediaChain(ChainBase, metaclass=Singleton):
         if mediainfo.type == MediaType.MOVIE:
             # 电影
             if fileitem.type == "file":
-                # 电影文件
-                logger.info(f"正在生成电影nfo：{mediainfo.title_year} - {filepath.name}")
-                movie_nfo = self.metadata_nfo(meta=meta, mediainfo=mediainfo)
-                if not movie_nfo:
-                    logger.warn(f"{filepath.name} nfo文件生成失败！")
-                    return
-                # 保存或上传nfo文件到上级目录
+                # 是否已存在
                 nfo_path = filepath.with_suffix(".nfo")
-                if not overwrite and self.storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
+                if overwrite or not self.storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
+                    # 电影文件
+                    movie_nfo = self.metadata_nfo(meta=meta, mediainfo=mediainfo)
+                    if movie_nfo:
+                        # 保存或上传nfo文件到上级目录
+                        __save_file(_fileitem=parent, _path=nfo_path, _content=movie_nfo)
+                    else:
+                        logger.warn(f"{filepath.name} nfo文件生成失败！")
+                else:
                     logger.info(f"已存在nfo文件：{nfo_path}")
-                    return
-                __save_file(_fileitem=parent, _path=nfo_path, _content=movie_nfo)
             else:
                 # 电影目录
-                files = __list_files(_fileitem=fileitem)
-                for file in files:
-                    self.scrape_metadata(fileitem=file,
-                                         meta=meta, mediainfo=mediainfo,
-                                         init_folder=False, parent=fileitem)
+                if is_bluray_folder(fileitem):
+                    # 原盘目录
+                    nfo_path = filepath / (filepath.name + ".nfo")
+                    if overwrite or not self.storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
+                        # 生成原盘nfo
+                        movie_nfo = self.metadata_nfo(meta=meta, mediainfo=mediainfo)
+                        if movie_nfo:
+                            # 保存或上传nfo文件到当前目录
+                            __save_file(_fileitem=fileitem, _path=nfo_path, _content=movie_nfo)
+                        else:
+                            logger.warn(f"{filepath.name} nfo文件生成失败！")
+                    else:
+                        logger.info(f"已存在nfo文件：{nfo_path}")
+                else:
+                    # 处理目录内的文件
+                    files = __list_files(_fileitem=fileitem)
+                    for file in files:
+                        self.scrape_metadata(fileitem=file,
+                                             meta=meta, mediainfo=mediainfo,
+                                             init_folder=False, parent=fileitem)
                 # 生成目录内图片文件
                 if init_folder:
                     # 图片
@@ -406,54 +456,58 @@ class MediaChain(ChainBase, metaclass=Singleton):
                                 and attr_value.startswith("http"):
                             image_name = attr_name.replace("_path", "") + Path(attr_value).suffix
                             image_path = filepath / image_name
-                            if not overwrite and self.storagechain.get_file_item(storage=fileitem.storage,
-                                                                                 path=image_path):
+                            if overwrite or not self.storagechain.get_file_item(storage=fileitem.storage,
+                                                                                path=image_path):
+                                # 下载图片
+                                content = __download_image(_url=attr_value)
+                                # 写入图片到当前目录
+                                if content:
+                                    __save_file(_fileitem=fileitem, _path=image_path, _content=content)
+                            else:
                                 logger.info(f"已存在图片文件：{image_path}")
-                                continue
-                            # 下载图片
-                            content = __download_image(_url=attr_value)
-                            # 写入图片到当前目录
-                            if content:
-                                __save_file(_fileitem=fileitem, _path=image_path, _content=content)
         else:
             # 电视剧
             if fileitem.type == "file":
-                # 当前为集文件，重新识别季集
+                # 重新识别季集
                 file_meta = MetaInfoPath(filepath)
                 if not file_meta.begin_episode:
                     logger.warn(f"{filepath.name} 无法识别文件集数！")
                     return
-                file_mediainfo = self.recognize_media(meta=file_meta)
+                file_mediainfo = self.recognize_media(meta=file_meta, tmdbid=mediainfo.tmdb_id)
                 if not file_mediainfo:
                     logger.warn(f"{filepath.name} 无法识别文件媒体信息！")
                     return
-                # 获取集的nfo文件
-                episode_nfo = self.metadata_nfo(meta=file_meta, mediainfo=file_mediainfo,
-                                                season=file_meta.begin_season, episode=file_meta.begin_episode)
-                if not episode_nfo:
-                    logger.warn(f"{filepath.name} nfo生成失败！")
-                    return
-                # 保存或上传nfo文件到上级目录
+                # 是否已存在
                 nfo_path = filepath.with_suffix(".nfo")
-                if not overwrite and self.storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
+                if overwrite or not self.storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
+                    # 获取集的nfo文件
+                    episode_nfo = self.metadata_nfo(meta=file_meta, mediainfo=file_mediainfo,
+                                                    season=file_meta.begin_season, episode=file_meta.begin_episode)
+                    if episode_nfo:
+                        # 保存或上传nfo文件到上级目录
+                        if not parent:
+                            parent = self.storagechain.get_parent_item(fileitem)
+                        __save_file(_fileitem=parent, _path=nfo_path, _content=episode_nfo)
+                    else:
+                        logger.warn(f"{filepath.name} nfo文件生成失败！")
+                else:
                     logger.info(f"已存在nfo文件：{nfo_path}")
-                    return
-                __save_file(_fileitem=parent, _path=nfo_path, _content=episode_nfo)
                 # 获取集的图片
                 image_dict = self.metadata_img(mediainfo=file_mediainfo,
                                                season=file_meta.begin_season, episode=file_meta.begin_episode)
                 if image_dict:
                     for episode, image_url in image_dict.items():
                         image_path = filepath.with_suffix(Path(image_url).suffix)
-                        if not overwrite and self.storagechain.get_file_item(storage=fileitem.storage, path=image_path):
+                        if overwrite or not self.storagechain.get_file_item(storage=fileitem.storage, path=image_path):
+                            # 下载图片
+                            content = __download_image(image_url)
+                            # 保存图片文件到当前目录
+                            if content:
+                                if not parent:
+                                    parent = self.storagechain.get_parent_item(fileitem)
+                                __save_file(_fileitem=parent, _path=image_path, _content=content)
+                        else:
                             logger.info(f"已存在图片文件：{image_path}")
-                            continue
-                        # 下载图片
-                        content = __download_image(image_url)
-                        # 保存图片文件到当前目录
-                        if content:
-                            __save_file(_fileitem=parent, _path=image_path, _content=content)
-
             else:
                 # 当前为目录，处理目录内的文件
                 files = __list_files(_fileitem=fileitem)
@@ -466,58 +520,90 @@ class MediaChain(ChainBase, metaclass=Singleton):
                 if init_folder:
                     # 识别文件夹名称
                     season_meta = MetaInfo(filepath.name)
-                    if season_meta.begin_season:
-                        # 当前目录有季号，生成季nfo
-                        season_nfo = self.metadata_nfo(meta=meta, mediainfo=mediainfo, season=season_meta.begin_season)
-                        if not season_nfo:
-                            logger.warn(f"无法生成电视剧季nfo文件：{meta.name}")
-                            return
-                        # 写入nfo到根目录
+                    # 当前文件夹为Specials或者SPs时，设置为S0
+                    if filepath.name in settings.RENAME_FORMAT_S0_NAMES:
+                        season_meta.begin_season = 0
+                    if season_meta.begin_season is not None:
+                        # 是否已存在
                         nfo_path = filepath / "season.nfo"
-                        if not overwrite and self.storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
+                        if overwrite or not self.storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
+                            # 当前目录有季号，生成季nfo
+                            season_nfo = self.metadata_nfo(meta=meta, mediainfo=mediainfo,
+                                                           season=season_meta.begin_season)
+                            if season_nfo:
+                                # 写入nfo到根目录
+                                __save_file(_fileitem=fileitem, _path=nfo_path, _content=season_nfo)
+                            else:
+                                logger.warn(f"无法生成电视剧季nfo文件：{meta.name}")
+                        else:
                             logger.info(f"已存在nfo文件：{nfo_path}")
-                            return
-                        __save_file(_fileitem=fileitem, _path=nfo_path, _content=season_nfo)
                         # TMDB季poster图片
                         image_dict = self.metadata_img(mediainfo=mediainfo, season=season_meta.begin_season)
                         if image_dict:
                             for image_name, image_url in image_dict.items():
                                 image_path = filepath.with_name(image_name)
-                                if not overwrite and self.storagechain.get_file_item(storage=fileitem.storage,
-                                                                                     path=image_path):
+                                if overwrite or not self.storagechain.get_file_item(storage=fileitem.storage,
+                                                                                    path=image_path):
+                                    # 下载图片
+                                    content = __download_image(image_url)
+                                    # 保存图片文件到剧集目录
+                                    if content:
+                                        if not parent:
+                                            parent = self.storagechain.get_parent_item(fileitem)
+                                        __save_file(_fileitem=parent, _path=image_path, _content=content)
+                                else:
                                     logger.info(f"已存在图片文件：{image_path}")
-                                    continue
-                                # 下载图片
-                                content = __download_image(image_url)
-                                # 保存图片文件到当前目录
-                                if content:
-                                    __save_file(_fileitem=fileitem, _path=image_path, _content=content)
+                        # 额外fanart季图片：poster thumb banner
+                        image_dict = self.metadata_img(mediainfo=mediainfo)
+                        if image_dict:
+                            for image_name, image_url in image_dict.items():
+                                if image_name.startswith("season"):
+                                    image_path = filepath.with_name(image_name)
+                                    # 只下载当前刮削季的图片
+                                    image_season = "00" if "specials" in image_name else image_name[6:8]
+                                    if image_season != str(season_meta.begin_season).rjust(2, '0'):
+                                        logger.info(f"当前刮削季为：{season_meta.begin_season}，跳过文件：{image_path}")
+                                        continue
+                                    if overwrite or not self.storagechain.get_file_item(storage=fileitem.storage,
+                                                                                        path=image_path):
+                                        # 下载图片
+                                        content = __download_image(image_url)
+                                        # 保存图片文件到当前目录
+                                        if content:
+                                            if not parent:
+                                                parent = self.storagechain.get_parent_item(fileitem)
+                                            __save_file(_fileitem=parent, _path=image_path, _content=content)
+                                    else:
+                                        logger.info(f"已存在图片文件：{image_path}")
                     # 判断当前目录是不是剧集根目录
-                    if season_meta.name:
-                        # 当前目录有名称，生成tvshow nfo 和 tv图片
-                        tv_nfo = self.metadata_nfo(meta=meta, mediainfo=mediainfo)
-                        if not tv_nfo:
-                            logger.warn(f"无法生成电视剧nfo文件：{meta.name}")
-                            return
-                        # 写入tvshow nfo到根目录
+                    if not season_meta.season:
+                        # 是否已存在
                         nfo_path = filepath / "tvshow.nfo"
-                        if not overwrite and self.storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
+                        if overwrite or not self.storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
+                            # 当前目录有名称，生成tvshow nfo 和 tv图片
+                            tv_nfo = self.metadata_nfo(meta=meta, mediainfo=mediainfo)
+                            if tv_nfo:
+                                # 写入tvshow nfo到根目录
+                                __save_file(_fileitem=fileitem, _path=nfo_path, _content=tv_nfo)
+                            else:
+                                logger.warn(f"无法生成电视剧nfo文件：{meta.name}")
+                        else:
                             logger.info(f"已存在nfo文件：{nfo_path}")
-                            return
-                        __save_file(_fileitem=fileitem, _path=nfo_path, _content=tv_nfo)
                         # 生成目录图片
                         image_dict = self.metadata_img(mediainfo=mediainfo)
                         if image_dict:
                             for image_name, image_url in image_dict.items():
-                                image_path = filepath / image_name
-                                if not overwrite and self.storagechain.get_file_item(storage=fileitem.storage,
-                                                                                     path=image_path):
-                                    logger.info(f"已存在图片文件：{image_path}")
+                                # 不下载季图片
+                                if image_name.startswith("season"):
                                     continue
-                                # 下载图片
-                                content = __download_image(image_url)
-                                # 保存图片文件到当前目录
-                                if content:
-                                    __save_file(_fileitem=fileitem, _path=image_path, _content=content)
-
+                                image_path = filepath / image_name
+                                if overwrite or not self.storagechain.get_file_item(storage=fileitem.storage,
+                                                                                    path=image_path):
+                                    # 下载图片
+                                    content = __download_image(image_url)
+                                    # 保存图片文件到当前目录
+                                    if content:
+                                        __save_file(_fileitem=fileitem, _path=image_path, _content=content)
+                                else:
+                                    logger.info(f"已存在图片文件：{image_path}")
         logger.info(f"{filepath.name} 刮削完成")

app/chain/mediaserver.py

@@ -3,12 +3,12 @@ from typing import List, Union, Optional, Generator
 
 from cachetools import cached, TTLCache
 
-from app import schemas
 from app.chain import ChainBase
 from app.core.config import global_vars
 from app.db.mediaserver_oper import MediaServerOper
 from app.helper.service import ServiceConfigHelper
 from app.log import logger
+from app.schemas import MediaServerLibrary, MediaServerItem, MediaServerSeasonInfo, MediaServerPlayItem
 
 lock = threading.Lock()
 
@@ -22,7 +22,7 @@ class MediaServerChain(ChainBase):
         super().__init__()
         self.dboper = MediaServerOper()
 
-    def librarys(self, server: str, username: str = None, hidden: bool = False) -> List[schemas.MediaServerLibrary]:
+    def librarys(self, server: str, username: str = None, hidden: bool = False) -> List[MediaServerLibrary]:
         """
         获取媒体服务器所有媒体库
         """
@@ -70,25 +70,25 @@ class MediaServerChain(ChainBase):
         yield from self.run_module("mediaserver_items", server=server, library_id=library_id,
                                    start_index=start_index, limit=limit)
 
-    def iteminfo(self, server: str, item_id: Union[str, int]) -> schemas.MediaServerItem:
+    def iteminfo(self, server: str, item_id: Union[str, int]) -> MediaServerItem:
         """
         获取媒体服务器项目信息
         """
         return self.run_module("mediaserver_iteminfo", server=server, item_id=item_id)
 
-    def episodes(self, server: str, item_id: Union[str, int]) -> List[schemas.MediaServerSeasonInfo]:
+    def episodes(self, server: str, item_id: Union[str, int]) -> List[MediaServerSeasonInfo]:
         """
         获取媒体服务器剧集信息
         """
         return self.run_module("mediaserver_tv_episodes", server=server, item_id=item_id)
 
-    def playing(self, server: str, count: int = 20, username: str = None) -> List[schemas.MediaServerPlayItem]:
+    def playing(self, server: str, count: int = 20, username: str = None) -> List[MediaServerPlayItem]:
         """
         获取媒体服务器正在播放信息
         """
         return self.run_module("mediaserver_playing", count=count, server=server, username=username)
 
-    def latest(self, server: str, count: int = 20, username: str = None) -> List[schemas.MediaServerPlayItem]:
+    def latest(self, server: str, count: int = 20, username: str = None) -> List[MediaServerPlayItem]:
         """
         获取媒体服务器最新入库条目
         """

app/chain/message.py

@@ -111,6 +111,8 @@ class MessageChain(ChainBase):
         info = self.message_parser(source=source, body=body, form=form, args=args)
         if not info:
             return
+        # 更新消息来源
+        source = info.source
         # 渠道
         channel = info.channel
         # 用户ID

app/chain/recommend.py

@@ -0,0 +1,323 @@
+import inspect
+import io
+import tempfile
+from functools import wraps
+from pathlib import Path
+from typing import Any, Callable, List
+
+from PIL import Image
+from cachetools import TTLCache
+from cachetools.keys import hashkey
+
+from app.chain import ChainBase
+from app.chain.bangumi import BangumiChain
+from app.chain.douban import DoubanChain
+from app.chain.tmdb import TmdbChain
+from app.core.config import settings, global_vars
+from app.log import logger
+from app.schemas import MediaType
+from app.utils.common import log_execution_time
+from app.utils.http import RequestUtils
+from app.utils.security import SecurityUtils
+from app.utils.singleton import Singleton
+
+# 推荐相关的专用缓存
+recommend_ttl = 24 * 3600
+recommend_cache = TTLCache(maxsize=256, ttl=recommend_ttl)
+
+
+# 推荐缓存装饰器，避免偶发网络获取数据为空时，页面由于缓存为空长时间渲染异常问题
+def cached_with_empty_check(func: Callable):
+    """
+    缓存装饰器，用于缓存函数的返回结果，仅在结果非空时进行缓存
+
+    :param func: 被装饰的函数
+    :return: 包装后的函数
+    """
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        signature = inspect.signature(func)
+        resolved_kwargs = {}
+        # 获取默认值并结合传递的参数（如果有）
+        for param, value in signature.parameters.items():
+            if param in kwargs:
+                # 使用显式传递的参数
+                resolved_kwargs[param] = kwargs[param]
+            elif value.default is not inspect.Parameter.empty:
+                # 没有传递参数时使用默认值
+                resolved_kwargs[param] = value.default
+        # 使用 cachetools 缓存，构造缓存键
+        cache_key = f"{func.__name__}_{hashkey(*args, **resolved_kwargs)}"
+        if cache_key in recommend_cache:
+            return recommend_cache[cache_key]
+        result = func(*args, **kwargs)
+        # 如果返回值为空，则不缓存
+        if result in [None, [], {}]:
+            return result
+        recommend_cache[cache_key] = result
+        return result
+
+    return wrapper
+
+
+class RecommendChain(ChainBase, metaclass=Singleton):
+    """
+    推荐处理链，单例运行
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.tmdbchain = TmdbChain()
+        self.doubanchain = DoubanChain()
+        self.bangumichain = BangumiChain()
+        self.cache_max_pages = 5
+
+    def refresh_recommend(self):
+        """
+        刷新推荐
+        """
+        logger.debug("Starting to refresh Recommend data.")
+        recommend_cache.clear()
+        logger.debug("Recommend Cache has been cleared.")
+
+        # 推荐来源方法
+        recommend_methods = [
+            self.tmdb_movies,
+            self.tmdb_tvs,
+            self.tmdb_trending,
+            self.bangumi_calendar,
+            self.douban_movie_showing,
+            self.douban_movies,
+            self.douban_tvs,
+            self.douban_movie_top250,
+            self.douban_tv_weekly_chinese,
+            self.douban_tv_weekly_global,
+            self.douban_tv_animation,
+            self.douban_movie_hot,
+            self.douban_tv_hot,
+        ]
+
+        # 缓存并刷新所有推荐数据
+        recommends = []
+        # 记录哪些方法已完成
+        methods_finished = set()
+        # 这里避免区间内连续调用相同来源，因此遍历方案为每页遍历所有推荐来源，再进行页数遍历
+        for page in range(1, self.cache_max_pages + 1):
+            for method in recommend_methods:
+                if global_vars.is_system_stopped:
+                    return
+                if method in methods_finished:
+                    continue
+                logger.debug(f"Fetch {method.__name__} data for page {page}.")
+                data = method(page=page)
+                if not data:
+                    logger.debug("All recommendation methods have finished fetching data. Ending pagination early.")
+                    methods_finished.add(method)
+                    continue
+                recommends.extend(data)
+            # 如果所有方法都已经完成，提前结束循环
+            if len(methods_finished) == len(recommend_methods):
+                break
+
+        # 缓存收集到的海报
+        self.__cache_posters(recommends)
+        logger.debug("Recommend data refresh completed.")
+
+    def __cache_posters(self, datas: List[dict]):
+        """
+        提取 poster_path 并缓存图片
+        :param datas: 数据列表
+        """
+        if not settings.GLOBAL_IMAGE_CACHE:
+            return
+
+        for data in datas:
+            if global_vars.is_system_stopped:
+                return
+            poster_path = data.get("poster_path")
+            if poster_path:
+                poster_url = poster_path.replace("original", "w500")
+                logger.debug(f"Caching poster image: {poster_url}")
+                self.__fetch_and_save_image(poster_url)
+
+    @staticmethod
+    def __fetch_and_save_image(url: str):
+        """
+        请求并保存图片
+        :param url: 图片路径
+        """
+        if not settings.GLOBAL_IMAGE_CACHE or not url:
+            return
+
+        # 生成缓存路径
+        sanitized_path = SecurityUtils.sanitize_url_path(url)
+        cache_path = settings.CACHE_PATH / "images" / sanitized_path
+
+        # 确保缓存路径和文件类型合法
+        if not SecurityUtils.is_safe_path(settings.CACHE_PATH, cache_path, settings.SECURITY_IMAGE_SUFFIXES):
+            logger.debug(f"Invalid cache path or file type for URL: {url}, sanitized path: {sanitized_path}")
+            return
+
+        # 本地存在缓存图片，则直接跳过
+        if cache_path.exists():
+            logger.debug(f"Cache hit: Image already exists at {cache_path}")
+            return
+
+        # 请求远程图片
+        referer = "https://movie.douban.com/" if "doubanio.com" in url else None
+        proxies = settings.PROXY if not referer else None
+        response = RequestUtils(ua=settings.USER_AGENT, proxies=proxies, referer=referer).get_res(url=url)
+        if not response:
+            logger.debug(f"Empty response for URL: {url}")
+            return
+
+        # 验证下载的内容是否为有效图片
+        try:
+            Image.open(io.BytesIO(response.content)).verify()
+        except Exception as e:
+            logger.debug(f"Invalid image format for URL {url}: {e}")
+            return
+
+        if not cache_path:
+            return
+
+        try:
+            if not cache_path.parent.exists():
+                cache_path.parent.mkdir(parents=True, exist_ok=True)
+            with tempfile.NamedTemporaryFile(dir=cache_path.parent, delete=False) as tmp_file:
+                tmp_file.write(response.content)
+                temp_path = Path(tmp_file.name)
+            temp_path.replace(cache_path)
+            logger.debug(f"Successfully cached image at {cache_path} for URL: {url}")
+        except Exception as e:
+            logger.debug(f"Failed to write cache file {cache_path} for URL {url}: {e}")
+
+    @log_execution_time(logger=logger)
+    @cached_with_empty_check
+    def tmdb_movies(self, sort_by: str = "popularity.desc", with_genres: str = "",
+                    with_original_language: str = "", page: int = 1) -> Any:
+        """
+        TMDB热门电影
+        """
+        movies = self.tmdbchain.tmdb_discover(mtype=MediaType.MOVIE,
+                                              sort_by=sort_by,
+                                              with_genres=with_genres,
+                                              with_original_language=with_original_language,
+                                              page=page)
+        return [movie.to_dict() for movie in movies] if movies else []
+
+    @log_execution_time(logger=logger)
+    @cached_with_empty_check
+    def tmdb_tvs(self, sort_by: str = "popularity.desc", with_genres: str = "",
+                 with_original_language: str = "zh|en|ja|ko", page: int = 1) -> Any:
+        """
+        TMDB热门电视剧
+        """
+        tvs = self.tmdbchain.tmdb_discover(mtype=MediaType.TV,
+                                           sort_by=sort_by,
+                                           with_genres=with_genres,
+                                           with_original_language=with_original_language,
+                                           page=page)
+        return [tv.to_dict() for tv in tvs] if tvs else []
+
+    @log_execution_time(logger=logger)
+    @cached_with_empty_check
+    def tmdb_trending(self, page: int = 1) -> Any:
+        """
+        TMDB流行趋势
+        """
+        infos = self.tmdbchain.tmdb_trending(page=page)
+        return [info.to_dict() for info in infos] if infos else []
+
+    @log_execution_time(logger=logger)
+    @cached_with_empty_check
+    def bangumi_calendar(self, page: int = 1, count: int = 30) -> Any:
+        """
+        Bangumi每日放送
+        """
+        medias = self.bangumichain.calendar()
+        return [media.to_dict() for media in medias[(page - 1) * count: page * count]] if medias else []
+
+    @log_execution_time(logger=logger)
+    @cached_with_empty_check
+    def douban_movie_showing(self, page: int = 1, count: int = 30) -> Any:
+        """
+        豆瓣正在热映
+        """
+        movies = self.doubanchain.movie_showing(page=page, count=count)
+        return [media.to_dict() for media in movies] if movies else []
+
+    @log_execution_time(logger=logger)
+    @cached_with_empty_check
+    def douban_movies(self, sort: str = "R", tags: str = "", page: int = 1, count: int = 30) -> Any:
+        """
+        豆瓣最新电影
+        """
+        movies = self.doubanchain.douban_discover(mtype=MediaType.MOVIE,
+                                                  sort=sort, tags=tags, page=page, count=count)
+        return [media.to_dict() for media in movies] if movies else []
+
+    @log_execution_time(logger=logger)
+    @cached_with_empty_check
+    def douban_tvs(self, sort: str = "R", tags: str = "", page: int = 1, count: int = 30) -> Any:
+        """
+        豆瓣最新电视剧
+        """
+        tvs = self.doubanchain.douban_discover(mtype=MediaType.TV,
+                                               sort=sort, tags=tags, page=page, count=count)
+        return [media.to_dict() for media in tvs] if tvs else []
+
+    @log_execution_time(logger=logger)
+    @cached_with_empty_check
+    def douban_movie_top250(self, page: int = 1, count: int = 30) -> Any:
+        """
+        豆瓣电影TOP250
+        """
+        movies = self.doubanchain.movie_top250(page=page, count=count)
+        return [media.to_dict() for media in movies] if movies else []
+
+    @log_execution_time(logger=logger)
+    @cached_with_empty_check
+    def douban_tv_weekly_chinese(self, page: int = 1, count: int = 30) -> Any:
+        """
+        豆瓣国产剧集榜
+        """
+        tvs = self.doubanchain.tv_weekly_chinese(page=page, count=count)
+        return [media.to_dict() for media in tvs] if tvs else []
+
+    @log_execution_time(logger=logger)
+    @cached_with_empty_check
+    def douban_tv_weekly_global(self, page: int = 1, count: int = 30) -> Any:
+        """
+        豆瓣全球剧集榜
+        """
+        tvs = self.doubanchain.tv_weekly_global(page=page, count=count)
+        return [media.to_dict() for media in tvs] if tvs else []
+
+    @log_execution_time(logger=logger)
+    @cached_with_empty_check
+    def douban_tv_animation(self, page: int = 1, count: int = 30) -> Any:
+        """
+        豆瓣热门动漫
+        """
+        tvs = self.doubanchain.tv_animation(page=page, count=count)
+        return [media.to_dict() for media in tvs] if tvs else []
+
+    @log_execution_time(logger=logger)
+    @cached_with_empty_check
+    def douban_movie_hot(self, page: int = 1, count: int = 30) -> Any:
+        """
+        豆瓣热门电影
+        """
+        movies = self.doubanchain.movie_hot(page=page, count=count)
+        return [media.to_dict() for media in movies] if movies else []
+
+    @log_execution_time(logger=logger)
+    @cached_with_empty_check
+    def douban_tv_hot(self, page: int = 1, count: int = 30) -> Any:
+        """
+        豆瓣热门电视剧
+        """
+        tvs = self.doubanchain.tv_hot(page=page, count=count)
+        return [media.to_dict() for media in tvs] if tvs else []

app/chain/search.py

@@ -125,7 +125,6 @@ class SearchChain(ChainBase):
             """
             return self.filter_torrents(rule_groups=rule_groups,
                                         torrent_list=torrent_list,
-                                        season_episodes=season_episodes,
                                         mediainfo=mediainfo) or []
 
         # 豆瓣标题处理
@@ -185,7 +184,10 @@ class SearchChain(ChainBase):
         # 开始过滤
         self.progress.update(value=0, text=f'开始过滤，总 {len(torrents)} 个资源，请稍候...',
                              key=ProgressKey.Search)
-
+        # 匹配订阅附加参数
+        if filter_params:
+            logger.info(f'开始附加参数过滤，附加参数：{filter_params} ...')
+            torrents = [torrent for torrent in torrents if self.torrenthelper.filter_torrent(torrent, filter_params)]
         # 开始过滤规则过滤
         if rule_groups is None:
             # 取搜索过滤规则
@@ -221,11 +223,19 @@ class SearchChain(ChainBase):
                                      key=ProgressKey.Search)
                 if not torrent.title:
                     continue
+
                 # 识别元数据
                 torrent_meta = MetaInfo(title=torrent.title, subtitle=torrent.description,
                                         custom_words=custom_words)
                 if torrent.title != torrent_meta.org_string:
                     logger.info(f"种子名称应用识别词后发生改变：{torrent.title} => {torrent_meta.org_string}")
+                # 季集数过滤
+                if season_episodes \
+                    and not self.torrenthelper.match_season_episodes(
+                        torrent=torrent,
+                        meta=torrent_meta,
+                        season_episodes=season_episodes):
+                    continue
                 # 比对IMDBID
                 if torrent.imdbid \
                         and mediainfo.imdb_id \
@@ -234,11 +244,6 @@ class SearchChain(ChainBase):
                     _match_torrents.append((torrent, torrent_meta))
                     continue
 
-                # 匹配订阅附加参数
-                if filter_params and not self.torrenthelper.filter_torrent(torrent_info=torrent,
-                                                                           filter_params=filter_params):
-                    continue
-
                 # 比对种子
                 if self.torrenthelper.match_torrent(mediainfo=mediainfo,
                                                     torrent_meta=torrent_meta,

app/chain/site.py

@@ -1,7 +1,8 @@
 import base64
 import re
 from datetime import datetime
-from typing import Optional, Tuple, Union
+from time import time
+from typing import Optional, Tuple, Union, Dict
 from urllib.parse import urljoin
 
 from lxml import etree
@@ -86,25 +87,36 @@ class SiteChain(ChainBase):
                               f"{userdata.message_unread} 条新消息，请登陆查看",
                         link=site.get("url")
                     ))
+            # 低分享率警告
+            if userdata.ratio and float(userdata.ratio) < 1 and not bool(
+                    re.search(r"(贵宾|VIP?)", userdata.user_level or "", re.IGNORECASE)):
+                self.post_message(Notification(
+                    mtype=NotificationType.SiteMessage,
+                    title=f"【站点分享率低预警】",
+                    text=f"站点 {site.get('name')} 分享率 {userdata.ratio}，请注意！"
+                ))
         return userdata
 
-    def refresh_userdatas(self) -> None:
+    def refresh_userdatas(self) -> Optional[Dict[str, SiteUserData]]:
         """
         刷新所有站点的用户数据
         """
         sites = self.siteshelper.get_indexers()
         any_site_updated = False
+        result = {}
         for site in sites:
             if global_vars.is_system_stopped:
-                return
+                return None
             if site.get("is_active"):
                 userdata = self.refresh_userdata(site)
                 if userdata:
                     any_site_updated = True
+                    result[site.get("name")] = userdata
         if any_site_updated:
             EventManager().send_event(EventType.SiteRefreshed, {
                 "site_id": "*"
             })
+        return result
 
     def is_special_site(self, domain: str) -> bool:
         """
@@ -161,27 +173,37 @@ class SiteChain(ChainBase):
             "Content-Type": "application/json",
             "User-Agent": user_agent,
             "Accept": "application/json, text/plain, */*",
-            "Authorization": site.token
+            "Authorization": site.token,
+            "x-api-key": site.apikey,
+            "ts": str(int(time()))
         }
         res = RequestUtils(
             headers=headers,
             proxies=settings.PROXY if site.proxy else None,
             timeout=site.timeout or 15
         ).post_res(url=url)
+        state = False
+        message = "鉴权已过期或无效"
         if res and res.status_code == 200:
-            user_info = res.json()
-            if user_info and user_info.get("data"):
+            user_info = res.json() or {}
+            if user_info.get("data"):
                 # 更新最后访问时间
+                del headers["x-api-key"]
                 res = RequestUtils(headers=headers,
                                    timeout=site.timeout or 15,
                                    proxies=settings.PROXY if site.proxy else None,
                                    referer=f"{site.url}index"
                                    ).post_res(url=f"https://api.{domain}/api/member/updateLastBrowse")
-                if res:
-                    return True, "连接成功"
-                else:
-                    return True, f"连接成功，但更新状态失败"
-        return False, "鉴权已过期或无效"
+                state = True
+                message = "连接成功，但更新状态失败"
+                if res and res.status_code == 200:
+                    update_info = res.json() or {}
+                    if "code" in update_info and int(update_info["code"]) == 0:
+                        message = "连接成功"
+            elif user_info.get("message"):
+                # 使用馒头的错误提示
+                message = user_info.get("message")
+        return state, message
 
     @staticmethod
     def __yema_test(site: Site) -> Tuple[bool, str]:
@@ -308,6 +330,7 @@ class SiteChain(ChainBase):
                     continue
                 # 新增站点
                 domain_url = __indexer_domain(inx=indexer, sub_domain=domain)
+                proxy = False
                 res = RequestUtils(cookies=cookie,
                                    ua=settings.USER_AGENT
                                    ).get_res(url=domain_url)
@@ -325,16 +348,37 @@ class SiteChain(ChainBase):
                     logger.warn(f"站点 {indexer.get('name')} 连接状态码：{res.status_code}，无法添加站点")
                     continue
                 else:
-                    _fail_count += 1
-                    logger.warn(f"站点 {indexer.get('name')} 连接失败，无法添加站点")
-                    continue
+                    if not settings.PROXY_HOST:
+                        _fail_count += 1
+                        logger.warn(f"站点 {indexer.get('name')} 连接失败，无法添加站点")
+                        continue
+                    else:
+                        # 如果配置了代理，尝试通过代理重试
+                        logger.info(f"站点 {indexer.get('name')} 初次连接失败，尝试通过代理重试...")
+                        proxy = True
+                        res = RequestUtils(cookies=cookie,
+                                           ua=settings.USER_AGENT,
+                                           proxies=settings.PROXY
+                                           ).get_res(url=domain_url)
+                        if res and res.status_code in [200, 500, 403]:
+                            if not indexer.get("public") and not SiteUtils.is_logged_in(res.text):
+                                logger.warn(f"站点 {indexer.get('name')} 登录失败，即使通过代理，无法添加站点")
+                                _fail_count += 1
+                                continue
+                            logger.info(f"站点 {indexer.get('name')} 通过代理连接成功")
+                        else:
+                            logger.warn(f"站点 {indexer.get('name')} 通过代理连接失败，无法添加站点")
+                            _fail_count += 1
+                            continue
+
                 # 获取rss地址
                 rss_url = None
                 if not indexer.get("public") and domain_url:
                     # 自动生成rss地址
                     rss_url, errmsg = self.rsshelper.get_rss_link(url=domain_url,
                                                                   cookie=cookie,
-                                                                  ua=settings.USER_AGENT)
+                                                                  ua=settings.USER_AGENT,
+                                                                  proxy=proxy)
                     if errmsg:
                         logger.warn(errmsg)
                 # 插入数据库
@@ -344,6 +388,7 @@ class SiteChain(ChainBase):
                                   domain=domain,
                                   cookie=cookie,
                                   rss=rss_url,
+                                  proxy=1 if proxy else 0,
                                   public=1 if indexer.get("public") else 0)
                 _add_count += 1
 
@@ -705,3 +750,66 @@ class SiteChain(ChainBase):
                 source=source,
                 title=f"【{site_info.name}】 Cookie&UA更新成功",
                 userid=userid))
+
+    def remote_refresh_userdatas(self, channel: MessageChannel,
+                                 userid: Union[str, int] = None, source: str = None):
+        """
+        刷新所有站点用户数据
+        """
+        logger.info("收到命令，开始刷新站点数据 ...")
+        self.post_message(Notification(
+            channel=channel,
+            source=source,
+            title="开始刷新站点数据 ...",
+            userid=userid
+        ))
+        # 刷新站点数据
+        site_datas = self.refresh_userdatas()
+        if site_datas:
+            # 发送消息
+            messages = {}
+            # 总上传
+            incUploads = 0
+            # 总下载
+            incDownloads = 0
+            # 今天日期
+            today_date = datetime.now().strftime("%Y-%m-%d")
+
+            for rand, site in enumerate(site_datas.keys()):
+                upload = int(site_datas[site].upload or 0)
+                download = int(site_datas[site].download or 0)
+                updated_date = site_datas[site].updated_day
+                if updated_date and updated_date != today_date:
+                    updated_date = f"（{updated_date}）"
+                else:
+                    updated_date = ""
+
+                if upload > 0 or download > 0:
+                    incUploads += upload
+                    incDownloads += download
+                    messages[upload + (rand / 1000)] = (
+                            f"【{site}】{updated_date}\n"
+                            + f"上传量：{StringUtils.str_filesize(upload)}\n"
+                            + f"下载量：{StringUtils.str_filesize(download)}\n"
+                            + "————————————"
+                    )
+            if incDownloads or incUploads:
+                sorted_messages = [messages[key] for key in sorted(messages.keys(), reverse=True)]
+                sorted_messages.insert(0, f"【汇总】\n"
+                                          f"总上传：{StringUtils.str_filesize(incUploads)}\n"
+                                          f"总下载：{StringUtils.str_filesize(incDownloads)}\n"
+                                          f"————————————")
+                self.post_message(Notification(
+                    channel=channel,
+                    source=source,
+                    title="【站点数据统计】",
+                    text="\n".join(sorted_messages),
+                    userid=userid
+                ))
+        else:
+            self.post_message(Notification(
+                channel=channel,
+                source=source,
+                title="没有刷新到任何站点数据！",
+                userid=userid
+            ))

app/chain/storage.py

@@ -4,6 +4,7 @@ from typing import Optional, Tuple, List, Dict
 from app import schemas
 from app.chain import ChainBase
 from app.core.config import settings
+from app.helper.directory import DirectoryHelper
 from app.log import logger
 from app.schemas import MediaType
 
@@ -13,6 +14,10 @@ class StorageChain(ChainBase):
     存储处理链
     """
 
+    def __init__(self):
+        super().__init__()
+        self.directoryhelper = DirectoryHelper()
+
     def save_config(self, storage: str, conf: dict) -> None:
         """
         保存存储配置
@@ -57,13 +62,15 @@ class StorageChain(ChainBase):
         """
         return self.run_module("download_file", fileitem=fileitem, path=path)
 
-    def upload_file(self, fileitem: schemas.FileItem, path: Path) -> Optional[bool]:
+    def upload_file(self, fileitem: schemas.FileItem, path: Path,
+                    new_name: str = None) -> Optional[schemas.FileItem]:
         """
         上传文件
         :param fileitem: 保存目录项
         :param path: 本地文件路径
+        :param new_name: 新文件名
         """
-        return self.run_module("upload_file", fileitem=fileitem, path=path)
+        return self.run_module("upload_file", fileitem=fileitem, path=path, new_name=new_name)
 
     def delete_file(self, fileitem: schemas.FileItem) -> Optional[bool]:
         """
@@ -77,6 +84,12 @@ class StorageChain(ChainBase):
         """
         return self.run_module("rename_file", fileitem=fileitem, name=name)
 
+    def get_item(self, fileitem: schemas.FileItem) -> Optional[schemas.FileItem]:
+        """
+        查询目录或文件
+        """
+        return self.get_file_item(storage=fileitem.storage, path=Path(fileitem.path))
+
     def get_file_item(self, storage: str, path: Path) -> Optional[schemas.FileItem]:
         """
         根据路径获取文件项
@@ -101,30 +114,64 @@ class StorageChain(ChainBase):
         """
         return self.run_module("storage_usage", storage=storage)
 
-    def support_transtype(self, storage: str) -> Optional[str]:
+    def support_transtype(self, storage: str) -> Optional[dict]:
         """
         获取支持的整理方式
         """
         return self.run_module("support_transtype", storage=storage)
 
-    def delete_media_file(self, fileitem: schemas.FileItem, mtype: MediaType = None) -> bool:
+    def delete_media_file(self, fileitem: schemas.FileItem,
+                          mtype: MediaType = None, delete_self: bool = True) -> bool:
         """
         删除媒体文件，以及不含媒体文件的目录
         """
-        state = self.delete_file(fileitem)
-        if not state:
-            logger.warn(f"【{fileitem.storage}】{fileitem.path} 删除失败")
+        media_exts = settings.RMT_MEDIAEXT + settings.DOWNLOAD_TMPEXT
+        if fileitem.path == "/" or len(Path(fileitem.path).parts) <= 2:
+            logger.warn(f"【{fileitem.storage}】{fileitem.path} 根目录或一级目录不允许删除")
             return False
-        # 上级目录
-        if mtype and mtype == MediaType.TV:
-            dir_path = Path(fileitem.path).parent.parent
-            dir_item = self.get_file_item(storage=fileitem.storage, path=dir_path)
+        if fileitem.type == "dir":
+            # 本身是目录
+            if _blue_dir := self.list_files(fileitem=fileitem, recursion=False):
+                # 删除蓝光目录
+                for _f in _blue_dir:
+                    if _f.type == "dir" and _f.name in ["BDMV", "CERTIFICATE"]:
+                        logger.warn(f"【{fileitem.storage}】{_f.path} 删除蓝光目录")
+                        self.delete_file(_f)
+            if self.any_files(fileitem, extensions=media_exts) is False:
+                logger.warn(f"【{fileitem.storage}】{fileitem.path} 不存在其它媒体文件，删除空目录")
+                return self.delete_file(fileitem)
+            return False
+        elif delete_self:
+            # 本身是文件
+            logger.warn(f"正在删除【{fileitem.storage}】{fileitem.path}")
+            if not self.delete_file(fileitem):
+                logger.warn(f"【{fileitem.storage}】{fileitem.path} 删除失败")
+                return False
+        if mtype:
+            # 重命名格式
+            rename_format = settings.TV_RENAME_FORMAT \
+                if mtype == MediaType.TV else settings.MOVIE_RENAME_FORMAT
+            # 计算重命名中的文件夹层数
+            rename_format_level = len(rename_format.split("/")) - 1
+            if rename_format_level < 1:
+                return True
+            # 处理上级目录
+            dir_item = self.get_file_item(storage=fileitem.storage,
+                                          path=Path(fileitem.path).parents[rename_format_level - 1])
         else:
             dir_item = self.get_parent_item(fileitem)
-        if dir_item:
+        if dir_item and len(Path(dir_item.path).parts) > 2:
+            # 如何目录是所有下载目录、媒体库目录的上级，则不处理
+            for d in self.directoryhelper.get_dirs():
+                if d.download_path and Path(d.download_path).is_relative_to(Path(dir_item.path)):
+                    logger.debug(f"【{dir_item.storage}】{dir_item.path} 是下载目录本级或上级目录，不删除")
+                    return True
+                if d.library_path and Path(d.library_path).is_relative_to(Path(dir_item.path)):
+                    logger.debug(f"【{dir_item.storage}】{dir_item.path} 是媒体库目录本级或上级目录，不删除")
+                    return True
             # 不存在其他媒体文件，删除空目录
-            if not self.any_files(dir_item, extensions=settings.RMT_MEDIAEXT):
+            if self.any_files(dir_item, extensions=media_exts) is False:
+                logger.warn(f"【{dir_item.storage}】{dir_item.path} 不存在其它媒体文件，删除空目录")
                 return self.delete_file(dir_item)
 
-        # 存在媒体文件，返回文件删除状态
-        return state
+        return True

app/chain/system.py

@@ -1,5 +1,6 @@
 import json
 import re
+from pathlib import Path
 from typing import Union
 
 from app.chain import ChainBase
@@ -161,4 +162,15 @@ class SystemChain(ChainBase, metaclass=Singleton):
         """
         获取前端版本
         """
+        if SystemUtils.is_frozen() and SystemUtils.is_windows():
+            version_file = settings.CONFIG_PATH.parent / "nginx" / "html" / "version.txt"
+        else:
+            version_file = Path(settings.FRONTEND_PATH) / "version.txt"
+        if version_file.exists():
+            try:
+                with open(version_file, 'r') as f:
+                    version = str(f.read()).strip()
+                return version
+            except Exception as err:
+                logger.debug(f"加载版本文件 {version_file} 出错：{str(err)}")
         return FRONTEND_VERSION

app/chain/tmdb.py

@@ -38,6 +38,13 @@ class TmdbChain(ChainBase, metaclass=Singleton):
         """
         return self.run_module("tmdb_trending", page=page)
 
+    def tmdb_collection(self, collection_id: int) -> Optional[List[MediaInfo]]:
+        """
+        根据合集ID查询集合
+        :param collection_id:  合集ID
+        """
+        return self.run_module("tmdb_collection", collection_id=collection_id)
+
     def tmdb_seasons(self, tmdbid: int) -> List[schemas.TmdbSeason]:
         """
         根据TMDBID查询themoviedb所有季信息

app/chain/torrents.py

@@ -120,6 +120,7 @@ class TorrentsChain(ChainBase, metaclass=Singleton):
                 site_ua=site.get("ua") or settings.USER_AGENT,
                 site_proxy=site.get("proxy"),
                 site_order=site.get("pri"),
+                site_downloader=site.get("downloader"),
                 title=item.get("title"),
                 enclosure=item.get("enclosure"),
                 page_url=item.get("link"),
@@ -174,7 +175,7 @@ class TorrentsChain(ChainBase, metaclass=Singleton):
             # 按pubdate降序排列
             torrents.sort(key=lambda x: x.pubdate or '', reverse=True)
             # 取前N条
-            torrents = torrents[:settings.CACHE_CONF.get('refresh')]
+            torrents = torrents[:settings.CACHE_CONF["refresh"]]
             if torrents:
                 # 过滤出没有处理过的种子
                 torrents = [torrent for torrent in torrents
@@ -214,8 +215,8 @@ class TorrentsChain(ChainBase, metaclass=Singleton):
                     else:
                         torrents_cache[domain].append(context)
                     # 如果超过了限制条数则移除掉前面的
-                    if len(torrents_cache[domain]) > settings.CACHE_CONF.get('torrents'):
-                        torrents_cache[domain] = torrents_cache[domain][-settings.CACHE_CONF.get('torrents'):]
+                    if len(torrents_cache[domain]) > settings.CACHE_CONF["torrents"]:
+                        torrents_cache[domain] = torrents_cache[domain][-settings.CACHE_CONF["torrents"]:]
                 # 回收资源
                 del torrents
             else:

app/chain/user.py

@@ -7,7 +7,7 @@ from app.core.security import get_password_hash, verify_password
 from app.db.models.user import User
 from app.db.user_oper import UserOper
 from app.log import logger
-from app.schemas.event import AuthCredentials, AuthInterceptCredentials
+from app.schemas import AuthCredentials, AuthInterceptCredentials
 from app.schemas.types import ChainEventType
 from app.utils.otp import OtpUtils
 from app.utils.singleton import Singleton

app/command.py

@@ -15,15 +15,18 @@ from app.helper.message import MessageHelper
 from app.helper.thread import ThreadHelper
 from app.log import logger
 from app.scheduler import Scheduler
-from app.schemas import Notification
-from app.schemas.event import CommandRegisterEventData
+from app.schemas import Notification, CommandRegisterEventData
 from app.schemas.types import EventType, MessageChannel, ChainEventType
 from app.utils.object import ObjectUtils
 from app.utils.singleton import Singleton
 from app.utils.structures import DictUtils
 
 
-class CommandChain(ChainBase, metaclass=Singleton):
+class CommandChain(ChainBase):
+    pass
+
+
+class Command(metaclass=Singleton):
     """
     全局命令管理，消费事件
     """
@@ -54,6 +57,11 @@ class CommandChain(ChainBase, metaclass=Singleton):
                 "description": "更新站点Cookie",
                 "data": {}
             },
+            "/site_statistic": {
+                "func": SiteChain().remote_refresh_userdatas,
+                "description": "站点数据统计",
+                "data": {}
+            },
             "/site_enable": {
                 "func": SiteChain().remote_enable,
                 "description": "启用站点",
@@ -205,7 +213,7 @@ class CommandChain(ChainBase, metaclass=Singleton):
                 if filtered_initial_commands != self._registered_commands or force_register:
                     logger.debug("Command set has changed or force registration is enabled.")
                     self._registered_commands = filtered_initial_commands
-                    super().register_commands(commands=filtered_initial_commands)
+                    CommandChain().register_commands(commands=filtered_initial_commands)
                 else:
                     logger.debug("Command set unchanged, skipping broadcast registration.")
         except Exception as e:
@@ -243,7 +251,7 @@ class CommandChain(ChainBase, metaclass=Singleton):
         event = eventmanager.send_event(ChainEventType.CommandRegister, event_data)
         return event, commands
 
-    def __build_plugin_commands(self, pid: Optional[str] = None) -> Dict[str, dict]:
+    def __build_plugin_commands(self, _: Optional[str] = None) -> Dict[str, dict]:
         """
         构建插件命令
         """
@@ -272,7 +280,7 @@ class CommandChain(ChainBase, metaclass=Singleton):
         if command.get("type") == "scheduler":
             # 定时服务
             if userid:
-                self.post_message(
+                CommandChain().post_message(
                     Notification(
                         channel=channel,
                         source=source,
@@ -285,7 +293,7 @@ class CommandChain(ChainBase, metaclass=Singleton):
             self.scheduler.start(job_id=command.get("id"))
 
             if userid:
-                self.post_message(
+                CommandChain().post_message(
                     Notification(
                         channel=channel,
                         source=source,
@@ -402,7 +410,7 @@ class CommandChain(ChainBase, metaclass=Singleton):
                              channel=event_channel, source=event_source, userid=event_user)
 
     @eventmanager.register(EventType.ModuleReload)
-    def module_reload_event(self, event: ManagerEvent) -> None:
+    def module_reload_event(self, _: ManagerEvent) -> None:
         """
         注册模块重载事件
         """

app/core/config.py

@@ -8,9 +8,9 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Type
 
 from dotenv import set_key
-from pydantic import BaseModel, BaseSettings, validator
+from pydantic import BaseModel, BaseSettings, validator, Field
 
-from app.log import logger
+from app.log import logger, log_settings, LogConfigModel
 from app.utils.system import SystemUtils
 from app.utils.url import UrlUtils
 
@@ -36,7 +36,7 @@ class ConfigModel(BaseModel):
     # RESOURCE密钥
     RESOURCE_SECRET_KEY: str = secrets.token_urlsafe(32)
     # 允许的域名
-    ALLOWED_HOSTS: list = ["*"]
+    ALLOWED_HOSTS: list = Field(default_factory=lambda: ["*"])
     # TOKEN过期时间
     ACCESS_TOKEN_EXPIRE_MINUTES: int = 60 * 24 * 8
     # RESOURCE_TOKEN过期时间
@@ -114,29 +114,39 @@ class ConfigModel(BaseModel):
     # 是否启用DOH解析域名
     DOH_ENABLE: bool = True
     # 使用 DOH 解析的域名列表
-    DOH_DOMAINS: str = "api.themoviedb.org,api.tmdb.org,webservice.fanart.tv,api.github.com,github.com,raw.githubusercontent.com,api.telegram.org"
+    DOH_DOMAINS: str = ("api.themoviedb.org,"
+                        "api.tmdb.org,"
+                        "webservice.fanart.tv,"
+                        "api.github.com,"
+                        "github.com,"
+                        "raw.githubusercontent.com,"
+                        "api.telegram.org")
     # DOH 解析服务器列表
     DOH_RESOLVERS: str = "1.0.0.1,1.1.1.1,9.9.9.9,149.112.112.112"
     # 支持的后缀格式
-    RMT_MEDIAEXT: list = ['.mp4', '.mkv', '.ts', '.iso',
-                          '.rmvb', '.avi', '.mov', '.mpeg',
-                          '.mpg', '.wmv', '.3gp', '.asf',
-                          '.m4v', '.flv', '.m2ts', '.strm',
-                          '.tp', '.f4v']
+    RMT_MEDIAEXT: list = Field(
+        default_factory=lambda: ['.mp4', '.mkv', '.ts', '.iso',
+                                 '.rmvb', '.avi', '.mov', '.mpeg',
+                                 '.mpg', '.wmv', '.3gp', '.asf',
+                                 '.m4v', '.flv', '.m2ts', '.strm',
+                                 '.tp', '.f4v']
+    )
     # 支持的字幕文件后缀格式
-    RMT_SUBEXT: list = ['.srt', '.ass', '.ssa', '.sup']
+    RMT_SUBEXT: list = Field(default_factory=lambda: ['.srt', '.ass', '.ssa', '.sup'])
     # 支持的音轨文件后缀格式
-    RMT_AUDIO_TRACK_EXT: list = ['.mka']
+    RMT_AUDIO_TRACK_EXT: list = Field(default_factory=lambda: ['.mka'])
     # 音轨文件后缀格式
-    RMT_AUDIOEXT: list = ['.aac', '.ac3', '.amr', '.caf', '.cda', '.dsf',
-                          '.dff', '.kar', '.m4a', '.mp1', '.mp2', '.mp3',
-                          '.mid', '.mod', '.mka', '.mpc', '.nsf', '.ogg',
-                          '.pcm', '.rmi', '.s3m', '.snd', '.spx', '.tak',
-                          '.tta', '.vqf', '.wav', '.wma',
-                          '.aifc', '.aiff', '.alac', '.adif', '.adts',
-                          '.flac', '.midi', '.opus', '.sfalc']
+    RMT_AUDIOEXT: list = Field(
+        default_factory=lambda: ['.aac', '.ac3', '.amr', '.caf', '.cda', '.dsf',
+                                 '.dff', '.kar', '.m4a', '.mp1', '.mp2', '.mp3',
+                                 '.mid', '.mod', '.mka', '.mpc', '.nsf', '.ogg',
+                                 '.pcm', '.rmi', '.s3m', '.snd', '.spx', '.tak',
+                                 '.tta', '.vqf', '.wav', '.wma',
+                                 '.aifc', '.aiff', '.alac', '.adif', '.adts',
+                                 '.flac', '.midi', '.opus', '.sfalc']
+    )
     # 下载器临时文件后缀
-    DOWNLOAD_TMPEXT: list = ['.!qB', '.part']
+    DOWNLOAD_TMPEXT: list = Field(default_factory=lambda: ['.!qb', '.part'])
     # 媒体服务器同步间隔（小时）
     MEDIASERVER_SYNC_INTERVAL: int = 6
     # 订阅模式
@@ -189,7 +199,10 @@ class ConfigModel(BaseModel):
     # 服务器地址，对应 https://github.com/jxxghp/MoviePilot-Server 项目
     MP_SERVER_HOST: str = "https://movie-pilot.org"
     # 插件市场仓库地址，多个地址使用,分隔，地址以/结尾
-    PLUGIN_MARKET: str = "https://github.com/jxxghp/MoviePilot-Plugins,https://github.com/thsrite/MoviePilot-Plugins,https://github.com/honue/MoviePilot-Plugins,https://github.com/InfinityPacer/MoviePilot-Plugins"
+    PLUGIN_MARKET: str = ("https://github.com/jxxghp/MoviePilot-Plugins,"
+                          "https://github.com/thsrite/MoviePilot-Plugins,"
+                          "https://github.com/honue/MoviePilot-Plugins,"
+                          "https://github.com/InfinityPacer/MoviePilot-Plugins")
     # 插件安装数据共享
     PLUGIN_STATISTIC_SHARE: bool = True
     # 是否开启插件热加载
@@ -206,14 +219,32 @@ class ConfigModel(BaseModel):
     BIG_MEMORY_MODE: bool = False
     # 全局图片缓存，将媒体图片缓存到本地
     GLOBAL_IMAGE_CACHE: bool = False
+    # 是否启用编码探测的性能模式
+    ENCODING_DETECTION_PERFORMANCE_MODE: bool = True
+    # 编码探测的最低置信度阈值
+    ENCODING_DETECTION_MIN_CONFIDENCE: float = 0.8
     # 允许的图片缓存域名
-    SECURITY_IMAGE_DOMAINS: List[str] = ["image.tmdb.org", "static-mdb.v.geilijiasu.com", "doubanio.com", "lain.bgm.tv",
-                                         "raw.githubusercontent.com", "github.com"]
+    SECURITY_IMAGE_DOMAINS: List[str] = Field(
+        default_factory=lambda: ["image.tmdb.org",
+                                 "static-mdb.v.geilijiasu.com",
+                                 "doubanio.com",
+                                 "lain.bgm.tv",
+                                 "raw.githubusercontent.com",
+                                 "github.com"]
+    )
     # 允许的图片文件后缀格式
-    SECURITY_IMAGE_SUFFIXES: List[str] = [".jpg", ".jpeg", ".png", ".webp", ".gif", ".svg"]
+    SECURITY_IMAGE_SUFFIXES: List[str] = Field(
+        default_factory=lambda: [".jpg", ".jpeg", ".png", ".webp", ".gif", ".svg"]
+    )
+    # 重命名时支持的S0别名
+    RENAME_FORMAT_S0_NAMES: List[str] = Field(
+        default_factory=lambda: ["Specials", "SPs"]
+    )
+    # 启用分词搜索
+    TOKENIZED_SEARCH: bool = False
 
 
-class Settings(BaseSettings, ConfigModel):
+class Settings(BaseSettings, ConfigModel, LogConfigModel):
     """
     系统配置类
     """
@@ -320,7 +351,7 @@ class Settings(BaseSettings, ConfigModel):
             return default, True
 
     @validator('*', pre=True, always=True)
-    def generic_type_validator(cls, value: Any, field):
+    def generic_type_validator(cls, value: Any, field): # noqa
         """
         通用校验器，尝试将配置值转换为期望的类型
         """
@@ -345,10 +376,9 @@ class Settings(BaseSettings, ConfigModel):
             logger.warning(message)
 
         if field.name in os.environ:
-            if is_converted:
-                message = f"配置项 '{field.name}' 已在环境变量中设置，请手动更新以保持一致性"
-                logger.warning(message)
-                return False, message
+            message = f"配置项 '{field.name}' 已在环境变量中设置，请手动更新以保持一致性"
+            logger.warning(message)
+            return False, message
         else:
             set_key(SystemUtils.get_env_path(), field.name, str(converted_value) if converted_value is not None else "")
             if is_converted:
@@ -372,10 +402,12 @@ class Settings(BaseSettings, ConfigModel):
                                                                             field.default, key)
             # 如果没有抛出异常，则统一使用 converted_value 进行更新
             if needs_update or str(value) != str(converted_value):
-                success, message = self.update_env_config(field, original_value, converted_value)
+                success, message = self.update_env_config(field, value, converted_value)
                 # 仅成功更新配置时，才更新内存
                 if success:
                     setattr(self, key, converted_value)
+                    if hasattr(log_settings, key):
+                        setattr(log_settings, key, converted_value)
                 return success, message
             return True, ""
         except Exception as e:
@@ -386,8 +418,21 @@ class Settings(BaseSettings, ConfigModel):
         更新多个配置项
         """
         results = {}
+        log_updated, plugin_monitor_updated = False, False
         for k, v in env.items():
             results[k] = self.update_setting(k, v)
+            if hasattr(log_settings, k):
+                log_updated = True
+            if k in ["PLUGIN_AUTO_RELOAD", "DEV"]:
+                plugin_monitor_updated = True
+        # 本次更新存在日志配置项更新，需要重新加载日志配置
+        if log_updated:
+            logger.update_loggers()
+        # 本次更新存在插件监控配置项更新，需要重新加载插件监控
+        if plugin_monitor_updated:
+            # 解决顶层循环导入问题
+            from app.core.plugin import PluginManager
+            PluginManager().reload_monitor()
         return results
 
     @property
@@ -437,22 +482,34 @@ class Settings(BaseSettings, ConfigModel):
 
     @property
     def CACHE_CONF(self):
+        """
+        {
+            "torrents": "缓存种子数量",
+            "refresh": "订阅刷新处理数量",
+            "tmdb": "TMDB请求缓存数量",
+            "douban": "豆瓣请求缓存数量",
+            "fanart": "Fanart请求缓存数量",
+            "meta": "元数据缓存过期时间（秒）"
+        }
+        """
         if self.BIG_MEMORY_MODE:
             return {
+                "torrents": 200,
+                "refresh": 100,
                 "tmdb": 1024,
-                "refresh": 50,
-                "torrents": 100,
                 "douban": 512,
+                "bangumi": 512,
                 "fanart": 512,
-                "meta": (self.META_CACHE_EXPIRE or 168) * 3600
+                "meta": (self.META_CACHE_EXPIRE or 24) * 3600
             }
         return {
+            "torrents": 100,
+            "refresh": 50,
             "tmdb": 256,
-            "refresh": 30,
-            "torrents": 50,
             "douban": 256,
+            "bangumi": 256,
             "fanart": 128,
-            "meta": (self.META_CACHE_EXPIRE or 72) * 3600
+            "meta": (self.META_CACHE_EXPIRE or 2) * 3600
         }
 
     @property

app/core/context.py

@@ -1,5 +1,6 @@
 import re
-from dataclasses import dataclass, field, asdict
+from dataclasses import dataclass, field
+from datetime import datetime
 from typing import List, Dict, Any, Tuple
 
 from app.core.config import settings
@@ -23,6 +24,8 @@ class TorrentInfo:
     site_proxy: bool = False
     # 站点优先级
     site_order: int = 0
+    # 站点下载器
+    site_downloader: str = None
     # 种子名称
     title: str = None
     # 种子副标题
@@ -121,11 +124,25 @@ class TorrentInfo:
             return ""
         return StringUtils.diff_time_str(self.freedate)
 
+    def pub_minutes(self) -> float:
+        """
+        返回发布时间距离当前时间的分钟数
+        """
+        if not self.pubdate:
+            return 0
+        try:
+            pub_date = datetime.strptime(self.pubdate, "%Y-%m-%d %H:%M:%S")
+            now_datetime = datetime.now()
+            return (now_datetime - pub_date).total_seconds() // 60
+        except Exception as e:
+            print(f"种子发布时间获取失败: {e}")
+            return 0
+
     def to_dict(self):
         """
         返回字典
         """
-        dicts = asdict(self)
+        dicts = vars(self).copy()
         dicts["volume_factor"] = self.volume_factor
         dicts["freedate_diff"] = self.freedate_diff
         return dicts
@@ -161,6 +178,8 @@ class MediaInfo:
     douban_id: str = None
     # Bangumi ID
     bangumi_id: int = None
+    # 合集ID
+    collection_id: int = None
     # 媒体原语种
     original_language: str = None
     # 媒体原发行标题
@@ -380,6 +399,8 @@ class MediaInfo:
         if info.get("external_ids"):
             self.tvdb_id = info.get("external_ids", {}).get("tvdb_id")
             self.imdb_id = info.get("external_ids", {}).get("imdb_id")
+        # 合集ID
+        self.collection_id = info.get('collection_id')
         # 评分
         self.vote_average = round(float(info.get('vote_average')), 1) if info.get('vote_average') else 0
         # 描述
@@ -723,7 +744,7 @@ class MediaInfo:
         """
         返回字典
         """
-        dicts = asdict(self)
+        dicts = vars(self).copy()
         dicts["type"] = self.type.value if self.type else None
         dicts["detail_link"] = self.detail_link
         dicts["title_year"] = self.title_year

app/core/event.py

@@ -13,7 +13,7 @@ from typing import Callable, Dict, List, Optional, Union
 from app.helper.message import MessageHelper
 from app.helper.thread import ThreadHelper
 from app.log import logger
-from app.schemas.event import ChainEventData
+from app.schemas import ChainEventData
 from app.schemas.types import ChainEventType, EventType
 from app.utils.limit import ExponentialBackoffRateLimiter
 from app.utils.singleton import Singleton
@@ -233,23 +233,29 @@ class EventManager(metaclass=Singleton):
         可视化所有事件处理器，包括是否被禁用的状态
         :return: 处理器列表，包含事件类型、处理器标识符、优先级（如果有）和状态
         """
+
+        def parse_handler_data(data):
+            """
+            解析处理器数据，判断是否包含优先级
+            :param data: 订阅者数据，可能是元组或单一值
+            :return: (priority, handler)，若没有优先级则返回 (None, handler)
+            """
+            if isinstance(data, tuple) and len(data) == 2:
+                return data
+            return None, data
+
         handler_info = []
         # 统一处理广播事件和链式事件
         for event_type, subscribers in {**self.__broadcast_subscribers, **self.__chain_subscribers}.items():
-            for handler_data in subscribers:
-                if isinstance(subscribers, dict):
-                    priority, handler = handler_data
-                else:
-                    priority = None
-                    handler = handler_data
-                # 获取处理器的唯一标识符
-                handler_id = self.__get_handler_identifier(handler)
+            for handler_identifier, handler_data in subscribers.items():
+                # 解析优先级和处理器
+                priority, handler = parse_handler_data(handler_data)
                 # 检查处理器的启用状态
                 status = "enabled" if self.__is_handler_enabled(handler) else "disabled"
                 # 构建处理器信息字典
                 handler_dict = {
                     "event_type": event_type.value,
-                    "handler_identifier": handler_id,
+                    "handler_identifier": handler_identifier,
                     "status": status
                 }
                 if priority is not None:
@@ -287,7 +293,7 @@ class EventManager(metaclass=Singleton):
 
         # 对于类实例（实现了 __call__ 方法）
         if not inspect.isfunction(handler) and hasattr(handler, "__call__"):
-            handler_cls = handler.__class__
+            handler_cls = handler.__class__ # noqa
             return cls.__get_handler_identifier(handler_cls)
 
         # 对于未绑定方法、静态方法、类方法，使用 __qualname__ 提取类信息
@@ -341,8 +347,17 @@ class EventManager(metaclass=Singleton):
         if not handlers:
             logger.debug(f"No handlers found for chain event: {event}")
             return False
+
+        # 过滤出启用的处理器
+        enabled_handlers = {handler_id: (priority, handler) for handler_id, (priority, handler) in handlers.items()
+                            if self.__is_handler_enabled(handler)}
+
+        if not enabled_handlers:
+            logger.debug(f"No enabled handlers found for chain event: {event}. Skipping execution.")
+            return False
+
         self.__log_event_lifecycle(event, "Started")
-        for handler_id, (priority, handler) in handlers.items():
+        for handler_id, (priority, handler) in enabled_handlers.items():
             start_time = time.time()
             self.__safe_invoke_handler(handler, event)
             logger.debug(
@@ -423,12 +438,15 @@ class EventManager(metaclass=Singleton):
 
         # 如果类不在全局变量中，尝试动态导入模块并创建实例
         try:
-            # 导入模块，除了插件，只有chain能响应事件
-            if not class_name.endswith("Chain"):
+            if class_name == "Command":
+                module_name = "app.command"
+                module = importlib.import_module(module_name)
+            elif class_name.endswith("Chain"):
+                module_name = f"app.chain.{class_name[:-5].lower()}"
+                module = importlib.import_module(module_name)
+            else:
                 logger.debug(f"事件处理出错：无效的 Chain 类名: {class_name}，类名必须以 'Chain' 结尾")
                 return None
-            module_name = f"app.chain.{class_name[:-5].lower()}"
-            module = importlib.import_module(module_name)
             if hasattr(module, class_name):
                 class_obj = getattr(module, class_name)()
                 return class_obj
@@ -487,30 +505,34 @@ class EventManager(metaclass=Singleton):
             }
         )
 
-    def register(self, etype: Union[EventType, ChainEventType, List[Union[EventType, ChainEventType]], type]):
+    def register(self, etype: Union[EventType, ChainEventType, List[Union[EventType, ChainEventType]], type],
+                 priority: int = DEFAULT_EVENT_PRIORITY):
         """
         事件注册装饰器，用于将函数注册为事件的处理器
         :param etype:
             - 单个事件类型成员 (如 EventType.MetadataScrape, ChainEventType.PluginAction)
             - 事件类型类 (EventType, ChainEventType)
             - 或事件类型成员的列表
+        :param priority: 可选，链式事件的优先级，默认为 DEFAULT_EVENT_PRIORITY
         """
 
         def decorator(f: Callable):
             # 将输入的事件类型统一转换为列表格式
             if isinstance(etype, list):
-                event_list = etype  # 传入的已经是列表，直接使用
+                # 传入的已经是列表，直接使用
+                event_list = etype
             else:
-                event_list = [etype]  # 不是列表则包裹成单一元素的列表
+                # 不是列表则包裹成单一元素的列表
+                event_list = [etype]
 
             # 遍历列表，处理每个事件类型
             for event in event_list:
                 if isinstance(event, (EventType, ChainEventType)):
-                    self.add_event_listener(event, f)
+                    self.add_event_listener(event, f, priority)
                 elif isinstance(event, type) and issubclass(event, (EventType, ChainEventType)):
                     # 如果是 EventType 或 ChainEventType 类，提取该类中的所有成员
                     for et in event.__members__.values():
-                        self.add_event_listener(et, f)
+                        self.add_event_listener(et, f, priority)
                 else:
                     raise ValueError(f"无效的事件类型: {event}")
 

app/core/meta/metabase.py

@@ -1,13 +1,13 @@
 import traceback
-from dataclasses import dataclass, asdict
+from dataclasses import dataclass
 from typing import Union, Optional, List, Self
 
 import cn2an
 import regex as re
 
 from app.log import logger
-from app.utils.string import StringUtils
 from app.schemas.types import MediaType
+from app.utils.string import StringUtils
 
 
 @dataclass
@@ -589,9 +589,10 @@ class MetaBase(object):
         """
         转为字典
         """
-        dicts = asdict(self)
+        dicts = vars(self).copy()
         dicts["type"] = self.type.value if self.type else None
         dicts["season_episode"] = self.season_episode
         dicts["edition"] = self.edition
         dicts["name"] = self.name
+        dicts["episode_list"] = self.episode_list
         return dicts

app/core/meta/metavideo.py

@@ -30,8 +30,8 @@ class MetaVideo(MetaBase):
     _episode_re = r"EP?(\d{2,4})$|^EP?(\d{1,4})$|^S\d{1,2}EP?(\d{1,4})$|S\d{2}EP?(\d{2,4})"
     _part_re = r"(^PART[0-9ABI]{0,2}$|^CD[0-9]{0,2}$|^DVD[0-9]{0,2}$|^DISK[0-9]{0,2}$|^DISC[0-9]{0,2}$)"
     _roman_numerals = r"^(?=[MDCLXVI])M*(C[MD]|D?C{0,3})(X[CL]|L?X{0,3})(I[XV]|V?I{0,3})$"
-    _source_re = r"^BLURAY$|^HDTV$|^UHDTV$|^HDDVD$|^WEBRIP$|^DVDRIP$|^BDRIP$|^BLU$|^WEB$|^BD$|^HDRip$|^REMUX$|^UHD$|^REPACK$"
-    _effect_re = r"^SDR$|^HDR\d*$|^DOLBY$|^DOVI$|^DV$|^3D$"
+    _source_re = r"^BLURAY$|^HDTV$|^UHDTV$|^HDDVD$|^WEBRIP$|^DVDRIP$|^BDRIP$|^BLU$|^WEB$|^BD$|^HDRip$|^REMUX$|^UHD$"
+    _effect_re = r"^SDR$|^HDR\d*$|^DOLBY$|^DOVI$|^DV$|^3D$|^REPACK$"
     _resources_type_re = r"%s|%s" % (_source_re, _effect_re)
     _name_no_begin_re = r"^[\[【].+?[\]】]"
     _name_no_chinese_re = r".*版|.*字幕"
@@ -524,16 +524,7 @@ class MetaVideo(MetaBase):
         """
         if not self.name:
             return
-        source_res = re.search(r"(%s)" % self._source_re, token, re.IGNORECASE)
-        if source_res:
-            self._last_token_type = "source"
-            self._continue_flag = False
-            self._stop_name_flag = True
-            if not self._source:
-                self._source = source_res.group(1)
-                self._last_token = self._source.upper()
-            return
-        elif token.upper() == "DL" \
+        if token.upper() == "DL" \
                 and self._last_token_type == "source" \
                 and self._last_token == "WEB":
             self._source = "WEB-DL"
@@ -542,13 +533,37 @@ class MetaVideo(MetaBase):
         elif token.upper() == "RAY" \
                 and self._last_token_type == "source" \
                 and self._last_token == "BLU":
-            self._source = "BluRay"
+            # UHD BluRay组合
+            if self._source == "UHD":
+                self._source = "UHD BluRay"
+            else:
+                self._source = "BluRay"
             self._continue_flag = False
             return
         elif token.upper() == "WEBDL":
             self._source = "WEB-DL"
             self._continue_flag = False
             return
+            # UHD REMUX组合
+        if token.upper() == "REMUX" \
+                and self._source == "BluRay":
+            self._source = "BluRay REMUX"
+            self._continue_flag = False
+            return
+        elif token.upper() == "BLURAY" \
+                and self._source == "UHD":
+            self._source = "UHD BluRay"
+            self._continue_flag = False
+            return
+        source_res = re.search(r"(%s)" % self._source_re, token, re.IGNORECASE)
+        if source_res:
+            self._last_token_type = "source"
+            self._continue_flag = False
+            self._stop_name_flag = True
+            if not self._source:
+                self._source = source_res.group(1)
+                self._last_token = self._source.upper()
+            return
         effect_res = re.search(r"(%s)" % self._effect_re, token, re.IGNORECASE)
         if effect_res:
             self._last_token_type = "effect"

app/core/module.py

@@ -1,11 +1,12 @@
 import traceback
-from typing import Generator, Optional, Tuple, Any
+from typing import Generator, Optional, Tuple, Any, Union
 
 from app.core.config import settings
 from app.core.event import eventmanager
 from app.helper.module import ModuleHelper
 from app.log import logger
-from app.schemas.types import EventType, ModuleType
+from app.schemas.types import EventType, ModuleType, DownloaderType, MediaServerType, MessageChannel, StorageSchema, \
+    OtherModulesType
 from app.utils.object import ObjectUtils
 from app.utils.singleton import Singleton
 
@@ -19,6 +20,8 @@ class ModuleManager(metaclass=Singleton):
     _modules: dict = {}
     # 运行态模块列表
     _running_modules: dict = {}
+    # 子模块类型集合
+    SubType = Union[DownloaderType, MediaServerType, MessageChannel, StorageSchema, OtherModulesType]
 
     def __init__(self):
         self.load_modules()
@@ -135,6 +138,17 @@ class ModuleManager(metaclass=Singleton):
                     and module.get_type() == module_type:
                 yield module
 
+    def get_running_subtype_module(self, module_subtype: SubType) -> Generator:
+        """
+        获取指定子类型的模块
+        """
+        if not self._running_modules:
+            return []
+        for _, module in self._running_modules.items():
+            if hasattr(module, 'get_subtype') \
+                    and module.get_subtype() == module_subtype:
+                yield module
+
     def get_module(self, module_id: str) -> Any:
         """
         根据模块id获取模块

app/core/plugin.py

@@ -220,11 +220,23 @@ class PluginManager(metaclass=Singleton):
             self._running_plugins = {}
         logger.info("插件停止完成")
 
+    def reload_monitor(self):
+        """
+        重新加载插件文件修改监测
+        """
+        if settings.DEV or settings.PLUGIN_AUTO_RELOAD:
+            if self._observer and self._observer.is_alive():
+                logger.info("插件文件修改监测已经在运行中...")
+            else:
+                self.__start_monitor()
+        else:
+            self.stop_monitor()
+
     def __start_monitor(self):
         """
-        开发者模式下监测插件文件修改
+        启用监测插件文件修改监测
         """
-        logger.info("开发者模式下开始监测插件文件修改...")
+        logger.info("开始监测插件文件修改...")
         monitor_handler = PluginMonitorHandler()
         self._observer = Observer()
         self._observer.schedule(monitor_handler, str(settings.ROOT_PATH / "app" / "plugins"), recursive=True)
@@ -232,14 +244,16 @@ class PluginManager(metaclass=Singleton):
 
     def stop_monitor(self):
         """
-        停止监测插件修改
+        停止监测插件文件修改监测
         """
         # 停止监测
-        if self._observer:
+        if self._observer and self._observer.is_alive():
             logger.info("正在停止插件文件修改监测...")
             self._observer.stop()
             self._observer.join()
             logger.info("插件文件修改监测停止完成")
+        else:
+            logger.info("未启用插件文件修改监测，无需停止")
 
     @staticmethod
     def __stop_plugin(plugin: Any):
@@ -526,7 +540,8 @@ class PluginManager(metaclass=Singleton):
             "name": "服务名称",
             "trigger": "触发器：cron、interval、date、CronTrigger.from_crontab()",
             "func": self.xxx,
-            "kwargs": {} # 定时器参数
+            "kwargs": {} # 定时器参数,
+            "func_kwargs": {} # 方法参数
         }]
         """
         ret_services = []
@@ -667,7 +682,7 @@ class PluginManager(metaclass=Singleton):
         # 相同 ID 的插件保留版本号最大的版本
         max_versions = {}
         for p in all_plugins:
-            if p.id not in max_versions or StringUtils.compare_version(p.plugin_version, max_versions[p.id]) > 0:
+            if p.id not in max_versions or StringUtils.compare_version(p.plugin_version, ">", max_versions[p.id]):
                 max_versions[p.id] = p.plugin_version
         result = [p for p in all_plugins if p.plugin_version == max_versions[p.id]]
         logger.info(f"共获取到 {len(result)} 个线上插件")
@@ -808,7 +823,7 @@ class PluginManager(metaclass=Singleton):
             plugin.has_update = False
             if plugin_static:
                 installed_version = getattr(plugin_static, "plugin_version")
-                if StringUtils.compare_version(installed_version, plugin_info.get("version")) < 0:
+                if StringUtils.compare_version(installed_version, "<", plugin_info.get("version")):
                     # 需要更新
                     plugin.has_update = True
             # 运行状态

app/core/security.py

@@ -286,7 +286,7 @@ def decrypt(data: bytes, key: bytes) -> Optional[bytes]:
         return None
 
 
-def encrypt_message(message: str, key: bytes):
+def encrypt_message(message: str, key: bytes) -> str:
     """
     使用给定的key对消息进行加密，并返回加密后的字符串
     """
@@ -295,14 +295,14 @@ def encrypt_message(message: str, key: bytes):
     return encrypted_message.decode()
 
 
-def hash_sha256(message):
+def hash_sha256(message: str) -> str:
     """
     对字符串做hash运算
     """
     return hashlib.sha256(message.encode()).hexdigest()
 
 
-def aes_decrypt(data, key):
+def aes_decrypt(data: str, key: str) -> str:
     """
     AES解密
     """
@@ -322,7 +322,7 @@ def aes_decrypt(data, key):
     return result.decode('utf-8')
 
 
-def aes_encrypt(data, key):
+def aes_encrypt(data: str, key: str) -> str:
     """
     AES加密
     """
@@ -338,7 +338,7 @@ def aes_encrypt(data, key):
     return base64.b64encode(cipher.iv + result).decode('utf-8')
 
 
-def nexusphp_encrypt(data_str: str, key):
+def nexusphp_encrypt(data_str: str, key: bytes) -> str:
     """
     NexusPHP加密
     """

app/db/__init__.py

@@ -13,7 +13,7 @@ connect_args = {
 # 启用 WAL 模式时的额外配置
 if settings.DB_WAL_ENABLE:
     connect_args["check_same_thread"] = False
-kwargs = {
+db_kwargs = {
     "url": f"sqlite:///{settings.CONFIG_PATH}/user.db",
     "pool_pre_ping": settings.DB_POOL_PRE_PING,
     "echo": settings.DB_ECHO,
@@ -23,13 +23,13 @@ kwargs = {
 }
 # 当使用 QueuePool 时，添加 QueuePool 特有的参数
 if pool_class == QueuePool:
-    kwargs.update({
+    db_kwargs.update({
         "pool_size": settings.DB_POOL_SIZE,
         "pool_timeout": settings.DB_POOL_TIMEOUT,
         "max_overflow": settings.DB_MAX_OVERFLOW
     })
 # 创建数据库引擎
-Engine = create_engine(**kwargs)
+Engine = create_engine(**db_kwargs)
 # 根据配置设置日志模式
 journal_mode = "WAL" if settings.DB_WAL_ENABLE else "DELETE"
 with Engine.connect() as connection:
@@ -198,7 +198,7 @@ class Base:
     @classmethod
     @db_query
     def get(cls, db: Session, rid: int) -> Self:
-        return db.query(cls).filter(cls.id == rid).first()
+        return db.query(cls).filter(and_(cls.id == rid)).first()
 
     @db_update
     def update(self, db: Session, payload: dict):
@@ -225,7 +225,7 @@ class Base:
         return list(result)
 
     def to_dict(self):
-        return {c.name: getattr(self, c.name, None) for c in self.__table__.columns}
+        return {c.name: getattr(self, c.name, None) for c in self.__table__.columns} # noqa
 
     @declared_attr
     def __tablename__(self) -> str:

app/db/init.py

@@ -11,7 +11,7 @@ def init_db():
     初始化数据库
     """
     # 全量建表
-    Base.metadata.create_all(bind=Engine)
+    Base.metadata.create_all(bind=Engine) # noqa
 
 
 def update_db():

app/db/message_oper.py

@@ -57,7 +57,7 @@ class MessageOper(DbOper):
 
         # 从kwargs中去掉Message中没有的字段
         for k in list(kwargs.keys()):
-            if k not in Message.__table__.columns.keys():
+            if k not in Message.__table__.columns.keys(): # noqa
                 kwargs.pop(k)
 
         Message(**kwargs).create(self._db)

app/db/models/downloadhistory.py

@@ -29,6 +29,8 @@ class DownloadHistory(Base):
     episodes = Column(String)
     # 海报
     image = Column(String)
+    # 下载器
+    downloader = Column(String)
     # 下载任务Hash
     download_hash = Column(String, index=True)
     # 种子名称
@@ -53,7 +55,9 @@ class DownloadHistory(Base):
     @staticmethod
     @db_query
     def get_by_hash(db: Session, download_hash: str):
-        return db.query(DownloadHistory).filter(DownloadHistory.download_hash == download_hash).first()
+        return db.query(DownloadHistory).filter(DownloadHistory.download_hash == download_hash).order_by(
+            DownloadHistory.date.desc()
+        ).first()
 
     @staticmethod
     @db_query
@@ -166,10 +170,10 @@ class DownloadFiles(Base):
     下载文件记录
     """
     id = Column(Integer, Sequence('id'), primary_key=True, index=True)
-    # 下载任务Hash
-    download_hash = Column(String, index=True)
     # 下载器
     downloader = Column(String)
+    # 下载任务Hash
+    download_hash = Column(String, index=True)
     # 完整路径
     fullpath = Column(String, index=True)
     # 保存路径

app/db/models/site.py

@@ -46,11 +46,13 @@ class Site(Base):
     # 流控间隔
     limit_seconds = Column(Integer, default=0)
     # 超时时间
-    timeout = Column(Integer, default=0)
+    timeout = Column(Integer, default=15)
     # 是否启用
     is_active = Column(Boolean(), default=True)
     # 创建时间
     lst_mod_date = Column(String, default=datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
+    # 下载器
+    downloader = Column(String)
 
     @staticmethod
     @db_query

app/db/models/siteuserdata.py

@@ -1,6 +1,6 @@
 from datetime import datetime
 
-from sqlalchemy import Column, Integer, String, Sequence, Float, JSON, func
+from sqlalchemy import Column, Integer, String, Sequence, Float, JSON, func, or_
 from sqlalchemy.orm import Session
 
 from app.db import db_query, Base
@@ -81,7 +81,7 @@ class SiteUserData(Base):
                 func.max(SiteUserData.updated_day).label('latest_update_day')
             )
             .group_by(SiteUserData.domain)
-            .filter(SiteUserData.err_msg == None)
+            .filter(or_(SiteUserData.err_msg.is_(None), SiteUserData.err_msg == ""))
             .subquery()
         )
 

app/db/models/subscribe.py

@@ -54,7 +54,7 @@ class Subscribe(Base):
     lack_episode = Column(Integer)
     # 附加信息
     note = Column(JSON)
-    # 状态：N-新建， R-订阅中
+    # 状态：N-新建 R-订阅中 P-待定 S-暂停
     state = Column(String, nullable=False, index=True, default='N')
     # 最后更新时间
     last_update = Column(String)
@@ -64,6 +64,8 @@ class Subscribe(Base):
     username = Column(String)
     # 订阅站点
     sites = Column(JSON, default=list)
+    # 下载器
+    downloader = Column(String)
     # 是否洗版
     best_version = Column(Integer, default=0)
     # 当前优先级
@@ -96,7 +98,13 @@ class Subscribe(Base):
     @staticmethod
     @db_query
     def get_by_state(db: Session, state: str):
-        result = db.query(Subscribe).filter(Subscribe.state == state).all()
+        # 如果 state 为空或 None，返回所有订阅
+        if not state:
+            result = db.query(Subscribe).all()
+        else:
+            # 如果传入的状态不为空，拆分成多个状态
+            states = state.split(',')
+            result = db.query(Subscribe).filter(Subscribe.state.in_(states)).all()
         return list(result)
 
     @staticmethod

app/db/models/transferhistory.py

@@ -8,7 +8,7 @@ from app.db import db_query, db_update, Base
 
 class TransferHistory(Base):
     """
-    转移历史记录
+    整理记录
     """
     id = Column(Integer, Sequence('id'), primary_key=True, index=True)
     # 源路径
@@ -43,6 +43,8 @@ class TransferHistory(Base):
     episodes = Column(String)
     # 海报
     image = Column(String)
+    # 下载器
+    downloader = Column(String)
     # 下载器hash
     download_hash = Column(String, index=True)
     # 转移成功状态

app/db/site_oper.py

@@ -114,7 +114,8 @@ class SiteOper(DbOper):
             "domain": domain,
             "name": name,
             "updated_day": current_day,
-            "updated_time": current_time
+            "updated_time": current_time,
+            "err_msg": payload.get("err_msg") or ""
         })
         # 按站点+天判断是否存在数据
         siteuserdatas = SiteUserData.get_by_domain(self._db, domain=domain, workdate=current_day)

app/db/subscribe_oper.py

@@ -83,7 +83,8 @@ class SubscribeOper(DbOper):
         更新订阅
         """
         subscribe = self.get(sid)
-        subscribe.update(self._db, payload)
+        if subscribe:
+            subscribe.update(self._db, payload)
         return subscribe
 
     def list_by_tmdbid(self, tmdbid: int, season: int = None) -> List[Subscribe]:

app/db/transferhistory_oper.py

@@ -120,7 +120,7 @@ class TransferHistoryOper(DbOper):
 
     def add_success(self, fileitem: FileItem, mode: str, meta: MetaBase,
                     mediainfo: MediaInfo, transferinfo: TransferInfo,
-                    download_hash: str = None):
+                    downloader: str = None, download_hash: str = None):
         """
         新增转移成功历史记录
         """
@@ -143,13 +143,14 @@ class TransferHistoryOper(DbOper):
             seasons=meta.season,
             episodes=meta.episode,
             image=mediainfo.get_poster_image(),
+            downloader=downloader,
             download_hash=download_hash,
             status=1,
             files=transferinfo.file_list
         )
 
     def add_fail(self, fileitem: FileItem, mode: str, meta: MetaBase, mediainfo: MediaInfo = None,
-                 transferinfo: TransferInfo = None, download_hash: str = None):
+                 transferinfo: TransferInfo = None, downloader: str = None, download_hash: str = None):
         """
         新增转移失败历史记录
         """
@@ -173,6 +174,7 @@ class TransferHistoryOper(DbOper):
                 seasons=meta.season,
                 episodes=meta.episode,
                 image=mediainfo.get_poster_image(),
+                downloader=downloader,
                 download_hash=download_hash,
                 status=0,
                 errmsg=transferinfo.message or '未知错误',
@@ -188,6 +190,7 @@ class TransferHistoryOper(DbOper):
                 mode=mode,
                 seasons=meta.season,
                 episodes=meta.episode,
+                downloader=downloader,
                 download_hash=download_hash,
                 status=0,
                 errmsg="未识别到媒体信息"

app/helper/browser.py

@@ -16,7 +16,7 @@ class PlaywrightHelper:
         """
         sync_stealth(page, pure=True)
         page.goto(url)
-        return sync_cf_retry(page)
+        return sync_cf_retry(page)[0]
 
     def action(self, url: str,
                callback: Callable,

app/helper/directory.py

@@ -4,7 +4,8 @@ from typing import List, Optional
 from app import schemas
 from app.core.context import MediaInfo
 from app.db.systemconfig_oper import SystemConfigOper
-from app.schemas.types import SystemConfigKey, MediaType
+from app.schemas.types import SystemConfigKey
+from app.utils.system import SystemUtils
 
 
 class DirectoryHelper:
@@ -48,49 +49,65 @@ class DirectoryHelper:
         """
         return [d for d in self.get_library_dirs() if d.library_storage == "local"]
 
-    def get_dir(self, media: MediaInfo, src_path: Path = None, dest_path: Path = None,
-                fileitem: schemas.FileItem = None, local: bool = False) -> Optional[schemas.TransferDirectoryConf]:
+    def get_dir(self, media: MediaInfo, include_unsorted: bool = False,
+                storage: str = None, src_path: Path = None,
+                target_storage: str = None, dest_path: Path = None
+                ) -> Optional[schemas.TransferDirectoryConf]:
         """
         根据媒体信息获取下载目录、媒体库目录配置
         :param media: 媒体信息
+        :param include_unsorted: 包含不整理目录
+        :param storage: 源存储类型
+        :param target_storage: 目标存储类型
         :param src_path: 源目录，有值时直接匹配
         :param dest_path: 目标目录，有值时直接匹配
-        :param fileitem: 文件项，使用文件路径匹配
-        :param local: 是否本地目录
         """
         # 处理类型
-        if media:
-            media_type = media.type.value
-        else:
-            media_type = MediaType.UNKNOWN.value
+        if not media:
+            return None
+        # 电影/电视剧
+        media_type = media.type.value
         dirs = self.get_dirs()
+
+        # 如果存在源目录，并源目录为任一下载目录的子目录时，则进行源目录匹配，否则，允许源目录按同盘优先的逻辑匹配
+        matching_dirs = [d for d in dirs if src_path.is_relative_to(d.download_path)] if src_path else []
+        # 根据是否有匹配的源目录，决定要考虑的目录集合
+        dirs_to_consider = matching_dirs if matching_dirs else dirs
+
+        # 已匹配的目录
+        matched_dirs: List[schemas.TransferDirectoryConf] = []
         # 按照配置顺序查找
-        for d in dirs:
-            # 下载目录
-            download_path = Path(d.download_path)
-            # 媒体库目录
-            library_path = Path(d.library_path)
-            # 下载目录不匹配, 不符合条件, 通常处理`下载`匹配
-            if src_path and download_path != src_path:
+        for d in dirs_to_consider:
+            # 没有启用整理的目录
+            if not d.monitor_type and not include_unsorted:
                 continue
-            # 媒体库目录不匹配, 或监控方式为None(即不自动整理), 不符合条件, 通常处理`整理`匹配
-            if dest_path:
-                if library_path != dest_path or not d.monitor_type:
-                    continue
-            # 没有目录配置时起作用, 通常处理`手动整理`未选择`目标目录`的情况
-            if fileitem and not Path(fileitem.path).is_relative_to(download_path):
+            # 源存储类型不匹配
+            if storage and d.storage != storage:
                 continue
-            # 本地目录
-            if local and d.storage != "local":
+            # 目标存储类型不匹配
+            if target_storage and d.library_storage != target_storage:
+                continue
+            # 有目标目录时，目标目录不匹配媒体库目录
+            if dest_path and dest_path != Path(d.library_path):
                 continue
             # 目录类型为全部的，符合条件
             if not d.media_type:
-                return d
+                matched_dirs.append(d)
+                continue
             # 目录类型相等，目录类别为全部，符合条件
             if d.media_type == media_type and not d.media_category:
-                return d
+                matched_dirs.append(d)
+                continue
             # 目录类型相等，目录类别相等，符合条件
             if d.media_type == media_type and d.media_category == media.category:
-                return d
-
+                matched_dirs.append(d)
+                continue
+        if matched_dirs:
+            if src_path:
+                # 优先源目录同盘
+                for matched_dir in matched_dirs:
+                    matched_path = Path(matched_dir.download_path)
+                    if SystemUtils.is_same_disk(matched_path, src_path):
+                        return matched_dir
+            return matched_dirs[0]
         return None

app/helper/format.py

@@ -3,6 +3,8 @@ from typing import Tuple, Optional
 
 import parse
 
+from app.core.meta.metabase import MetaBase
+
 
 class FormatParser(object):
     _key = ""
@@ -20,7 +22,15 @@ class FormatParser(object):
         self._format = eformat
         self._start_ep = None
         self._end_ep = None
-        self.__offset = offset or "EP"
+        if not offset:
+            self.__offset = "EP"
+        elif "EP" in offset:
+            self.__offset = offset
+        else:
+            if offset.startswith("-") or offset.startswith("+"):
+                self.__offset = f"EP{offset}"
+            else:
+                self.__offset = f"EP+{offset}"
         self._key = key
         self._part = None
         if part:
@@ -69,29 +79,42 @@ class FormatParser(object):
             return True
         return False
 
-    def split_episode(self, file_name: str) -> Tuple[Optional[int], Optional[int], Optional[str]]:
+    def split_episode(self, file_name: str, file_meta: MetaBase) -> Tuple[Optional[int], Optional[int], Optional[str]]:
         """
         拆分集数，返回开始集数，结束集数，Part信息
         """
         # 指定的具体集数，直接返回
-        if self._start_ep is not None and self._start_ep == self._end_ep:
-            if isinstance(self._start_ep, str):
-                s, e = self._start_ep.split("-")
-                start_ep = self.__offset.replace("EP", s)
-                end_ep = self.__offset.replace("EP", e)
-                if int(s) == int(e):
+        if self._start_ep is not None:
+            if self._start_ep == self._end_ep:
+                # `details` 格式为 `X-X` 或者 `X`
+                if isinstance(self._start_ep, str):
+                    # `details` 格式为 `X-X`
+                    s, e = self._start_ep.split("-")
+                    start_ep = self.__offset.replace("EP", s)
+                    end_ep = self.__offset.replace("EP", e)
+                    if int(s) == int(e):
+                        return int(eval(start_ep)), None, self.part
+                    return int(eval(start_ep)), int(eval(end_ep)), self.part
+                else:
+                    # `details` 格式为 `X`
+                    start_ep = self.__offset.replace("EP", str(self._start_ep))
                     return int(eval(start_ep)), None, self.part
-                return int(eval(start_ep)), int(eval(end_ep)), self.part
             else:
+                # `details` 格式为 `X,X`
                 start_ep = self.__offset.replace("EP", str(self._start_ep))
-                return int(eval(start_ep)), None, self.part
+                end_ep = self.__offset.replace("EP", str(self._end_ep))
+                return int(eval(start_ep)), int(eval(end_ep)), self.part
         if not self._format:
-            return self._start_ep, self._end_ep, self.part
+            # 未填入`集数定位` 且没有`指定集数` 仅处理`集数偏移`
+            start_ep = eval(self.__offset.replace("EP", str(file_meta.begin_episode))) if file_meta.begin_episode else None
+            end_ep = eval(self.__offset.replace("EP", str(file_meta.end_episode))) if file_meta.end_episode else None
+            return int(start_ep) if start_ep else None, int(end_ep) if end_ep else None, self.part
         else:
+            # 有`集数定位`
             s, e = self.__handle_single(file_name)
             start_ep = self.__offset.replace("EP", str(s)) if s else None
             end_ep = self.__offset.replace("EP", str(e)) if e else None
-            return int(eval(start_ep)) if start_ep else None,  int(eval(end_ep)) if end_ep else None, self.part
+            return int(eval(start_ep)) if start_ep else None, int(eval(end_ep)) if end_ep else None, self.part
 
     def __handle_single(self, file: str) -> Tuple[Optional[int], Optional[int]]:
         """

app/helper/plugin.py

@@ -120,7 +120,7 @@ class PluginHelper(metaclass=Singleton):
         """
         if not settings.PLUGIN_STATISTIC_SHARE:
             return {}
-        res = RequestUtils(timeout=10).get_res(self._install_statistic)
+        res = RequestUtils(proxies=settings.PROXY, timeout=10).get_res(self._install_statistic)
         if res and res.status_code == 200:
             return res.json()
         return {}
@@ -134,7 +134,7 @@ class PluginHelper(metaclass=Singleton):
         if not pid:
             return False
         install_reg_url = self._install_reg.format(pid=pid)
-        res = RequestUtils(timeout=5).get_res(install_reg_url)
+        res = RequestUtils(proxies=settings.PROXY, timeout=5).get_res(install_reg_url)
         if res and res.status_code == 200:
             return True
         return False
@@ -148,7 +148,8 @@ class PluginHelper(metaclass=Singleton):
         plugins = self.systemconfig.get(SystemConfigKey.UserInstalledPlugins)
         if not plugins:
             return False
-        res = RequestUtils(content_type="application/json",
+        res = RequestUtils(proxies=settings.PROXY,
+                           content_type="application/json",
                            timeout=5).post(self._install_report,
                                            json={"plugins": [{"plugin_id": plugin} for plugin in plugins]})
         return True if res else False

app/helper/resource.py

@@ -70,7 +70,7 @@ class ResourceHelper(metaclass=Singleton):
                 local_version = self.siteshelper.indexer_version
             else:
                 continue
-            if StringUtils.compare_version(version, local_version) > 0:
+            if StringUtils.compare_version(version, ">", local_version):
                 logger.info(f"{rname} 资源包有更新，最新版本：v{version}")
             else:
                 continue

app/helper/subscribe.py

@@ -9,6 +9,7 @@ from app.db.systemconfig_oper import SystemConfigOper
 from app.schemas.types import SystemConfigKey
 from app.utils.http import RequestUtils
 from app.utils.singleton import Singleton
+from app.utils.system import SystemUtils
 
 
 class SubscribeHelper(metaclass=Singleton):
@@ -30,8 +31,11 @@ class SubscribeHelper(metaclass=Singleton):
 
     _sub_fork = f"{settings.MP_SERVER_HOST}/subscribe/fork/%s"
 
+    _shares_cache = TTLCache(maxsize=20, ttl=1800)
+
     def __init__(self):
         self.systemconfig = SystemConfigOper()
+        self.share_user_id = SystemUtils.generate_user_unique_id()
         if settings.SUBSCRIBE_STATISTIC_SHARE:
             if not self.systemconfig.get(SystemConfigKey.SubscribeReport):
                 if self.sub_report():
@@ -44,7 +48,7 @@ class SubscribeHelper(metaclass=Singleton):
         """
         if not settings.SUBSCRIBE_STATISTIC_SHARE:
             return []
-        res = RequestUtils(timeout=15).get_res(self._sub_statistic, params={
+        res = RequestUtils(proxies=settings.PROXY, timeout=15).get_res(self._sub_statistic, params={
             "stype": stype,
             "page": page,
             "count": count
@@ -59,7 +63,7 @@ class SubscribeHelper(metaclass=Singleton):
         """
         if not settings.SUBSCRIBE_STATISTIC_SHARE:
             return False
-        res = RequestUtils(timeout=5, headers={
+        res = RequestUtils(proxies=settings.PROXY, timeout=5, headers={
             "Content-Type": "application/json"
         }).post_res(self._sub_reg, json=sub)
         if res and res.status_code == 200:
@@ -72,7 +76,7 @@ class SubscribeHelper(metaclass=Singleton):
         """
         if not settings.SUBSCRIBE_STATISTIC_SHARE:
             return False
-        res = RequestUtils(timeout=5, headers={
+        res = RequestUtils(proxies=settings.PROXY, timeout=5, headers={
             "Content-Type": "application/json"
         }).post_res(self._sub_done, json=sub)
         if res and res.status_code == 200:
@@ -104,7 +108,7 @@ class SubscribeHelper(metaclass=Singleton):
         subscribes = SubscribeOper().list()
         if not subscribes:
             return True
-        res = RequestUtils(content_type="application/json",
+        res = RequestUtils(proxies=settings.PROXY, content_type="application/json",
                            timeout=10).post(self._sub_report,
                                             json={
                                                 "subscribes": [
@@ -125,17 +129,38 @@ class SubscribeHelper(metaclass=Singleton):
             return False, "订阅不存在"
         subscribe_dict = subscribe.to_dict()
         subscribe_dict.pop("id")
-        res = RequestUtils(content_type="application/json",
+        res = RequestUtils(proxies=settings.PROXY, content_type="application/json",
                            timeout=10).post(self._sub_share,
                                             json={
                                                 "share_title": share_title,
                                                 "share_comment": share_comment,
                                                 "share_user": share_user,
+                                                "share_uid": self.share_user_id,
                                                 **subscribe_dict
                                             })
         if res is None:
             return False, "连接MoviePilot服务器失败"
         if res.ok:
+            # 清除 get_shares 的缓存，以便实时看到结果
+            self._shares_cache.clear()
+            return True, ""
+        else:
+            return False, res.json().get("message")
+
+    def share_delete(self, share_id: int) -> Tuple[bool, str]:
+        """
+        删除分享
+        """
+        if not settings.SUBSCRIBE_STATISTIC_SHARE:
+            return False, "当前没有开启订阅数据共享功能"
+        res = RequestUtils(proxies=settings.PROXY,
+                           timeout=5).delete_res(f"{self._sub_share}/{share_id}",
+                                                 params={"share_uid": self.share_user_id})
+        if res is None:
+            return False, "连接MoviePilot服务器失败"
+        if res.ok:
+            # 清除 get_shares 的缓存，以便实时看到结果
+            self._shares_cache.clear()
             return True, ""
         else:
             return False, res.json().get("message")
@@ -146,7 +171,7 @@ class SubscribeHelper(metaclass=Singleton):
         """
         if not settings.SUBSCRIBE_STATISTIC_SHARE:
             return False, "当前没有开启订阅数据共享功能"
-        res = RequestUtils(timeout=5, headers={
+        res = RequestUtils(proxies=settings.PROXY, timeout=5, headers={
             "Content-Type": "application/json"
         }).get_res(self._sub_fork % share_id)
         if res is None:
@@ -156,14 +181,14 @@ class SubscribeHelper(metaclass=Singleton):
         else:
             return False, res.json().get("message")
 
-    @cached(cache=TTLCache(maxsize=20, ttl=1800))
+    @cached(cache=_shares_cache)
     def get_shares(self, name: str, page: int = 1, count: int = 30) -> List[dict]:
         """
         获取订阅分享数据
         """
         if not settings.SUBSCRIBE_STATISTIC_SHARE:
             return []
-        res = RequestUtils(timeout=15).get_res(self._sub_shares, params={
+        res = RequestUtils(proxies=settings.PROXY, timeout=15).get_res(self._sub_shares, params={
             "name": name,
             "page": page,
             "count": count

app/helper/torrent.py

@@ -9,6 +9,7 @@ from torrentool.api import Torrent
 
 from app.core.config import settings
 from app.core.context import Context, TorrentInfo, MediaInfo
+from app.core.meta import MetaBase
 from app.core.metainfo import MetaInfo
 from app.db.site_oper import SiteOper
 from app.db.systemconfig_oper import SystemConfigOper
@@ -64,10 +65,10 @@ class TorrentHelper(metaclass=Singleton):
             if not req.content:
                 return None, None, "", [], "未下载到种子数据"
             # 解析内容格式
-            if req.text and str(req.text).startswith("magnet:"):
+            if req.content.startswith(b"magnet:"):
                 # 磁力链接
                 return None, req.text, "", [], f"获取到磁力链接"
-            elif req.text and "下载种子文件" in req.text:
+            if "下载种子文件".encode("utf-8") in req.content:
                 # 首次下载提示页面
                 skip_flag = False
                 try:
@@ -287,10 +288,10 @@ class TorrentHelper(metaclass=Singleton):
             if not file:
                 continue
             file_path = Path(file)
-            if file_path.suffix not in settings.RMT_MEDIAEXT:
+            if not file_path.suffix or file_path.suffix.lower() not in settings.RMT_MEDIAEXT:
                 continue
             # 只使用文件名识别
-            meta = MetaInfo(file_path.stem)
+            meta = MetaInfo(file_path.name)
             if not meta.begin_episode:
                 continue
             episodes = list(set(episodes).union(set(meta.episode_list)))
@@ -445,3 +446,38 @@ class TorrentHelper(metaclass=Singleton):
                 return False
 
         return True
+
+    @staticmethod
+    def match_season_episodes(torrent: TorrentInfo, meta: MetaBase, season_episodes: Dict[int, list]) -> bool:
+        """
+        判断种子是否匹配季集数
+        :param torrent: 种子信息
+        :param meta: 种子元数据
+        :param season_episodes: 季集数 {season:[episodes]}
+        """
+        # 匹配季
+        seasons = season_episodes.keys()
+        # 种子季
+        torrent_seasons = meta.season_list
+        if not torrent_seasons:
+            # 按第一季处理
+            torrent_seasons = [1]
+        # 种子集
+        torrent_episodes = meta.episode_list
+        if not set(torrent_seasons).issubset(set(seasons)):
+            # 种子季不在过滤季中
+            logger.debug(
+                f"种子 {torrent.site_name} - {torrent.title} 包含季 {torrent_seasons} 不是需要的季 {list(seasons)}")
+            return False
+        if not torrent_episodes:
+            # 整季按匹配处理
+            return True
+        if len(torrent_seasons) == 1:
+            need_episodes = season_episodes.get(torrent_seasons[0])
+            if need_episodes \
+                    and not set(torrent_episodes).intersection(set(need_episodes)):
+                # 单季集没有交集的不要
+                logger.debug(f"种子 {torrent.site_name} - {torrent.title} "
+                             f"集 {torrent_episodes} 没有需要的集：{need_episodes}")
+                return False
+        return True

app/helper/twofa.py

@@ -10,7 +10,7 @@ from app.log import logger
 
 class TwoFactorAuth:
     def __init__(self, code_or_secret: str):
-        if code_or_secret and len(code_or_secret) > 16:
+        if code_or_secret and len(code_or_secret) >= 16:
             self.code = None
             self.secret = code_or_secret
         else:

app/log.py

@@ -1,19 +1,24 @@
-import inspect
 import logging
+import sys
+import threading
 from logging.handlers import RotatingFileHandler
 from pathlib import Path
 from typing import Dict, Any, Optional
 
 import click
-from pydantic import BaseSettings
+from pydantic import BaseSettings, BaseModel
 
 from app.utils.system import SystemUtils
 
 
-class LogSettings(BaseSettings):
+class LogConfigModel(BaseModel):
     """
-    日志设置
+    Pydantic 配置模型，描述所有配置项及其类型和默认值
     """
+
+    class Config:
+        extra = "ignore"  # 忽略未定义的配置项
+
     # 配置文件目录
     CONFIG_DIR: Optional[str] = None
     # 是否为调试模式
@@ -29,6 +34,12 @@ class LogSettings(BaseSettings):
     # 文件日志格式
     LOG_FILE_FORMAT: str = "【%(levelname)s】%(asctime)s - %(message)s"
 
+
+class LogSettings(BaseSettings, LogConfigModel):
+    """
+    日志设置类
+    """
+
     @property
     def CONFIG_PATH(self):
         return SystemUtils.get_config_path(self.CONFIG_DIR)
@@ -85,6 +96,8 @@ class LoggerManager:
     _loggers: Dict[str, Any] = {}
     # 默认日志文件名称
     _default_log_file = "moviepilot.log"
+    # 线程锁
+    _lock = threading.Lock()
 
     @staticmethod
     def __get_caller():
@@ -96,35 +109,54 @@ class LoggerManager:
         caller_name = None
         # 调用者插件名称
         plugin_name = None
-        for i in inspect.stack()[3:]:
-            filepath = Path(i.filename)
+
+        try:
+            frame = sys._getframe(3)  # noqa
+        except (AttributeError, ValueError):
+            # 如果无法获取帧，返回默认值
+            return "log.py", None
+
+        while frame:
+            filepath = Path(frame.f_code.co_filename)
             parts = filepath.parts
+            # 设定调用者文件名称
             if not caller_name:
-                # 设定调用者文件名称
-                if parts[-1] == "__init__.py":
+                if parts[-1] == "__init__.py" and len(parts) >= 2:
                     caller_name = parts[-2]
                 else:
                     caller_name = parts[-1]
+            # 设定调用者插件名称
             if "app" in parts:
                 if not plugin_name and "plugins" in parts:
-                    # 设定调用者插件名称
-                    plugin_name = parts[parts.index("plugins") + 1]
-                    if plugin_name == "__init__.py":
-                        plugin_name = "plugin"
-                    break
+                    try:
+                        plugins_index = parts.index("plugins")
+                        if plugins_index + 1 < len(parts):
+                            plugin_candidate = parts[plugins_index + 1]
+                            if plugin_candidate == "__init__.py":
+                                plugin_name = "plugin"
+                            else:
+                                plugin_name = plugin_candidate
+                            break
+                    except ValueError:
+                        pass
                 if "main.py" in parts:
-                    # 已经到达程序的入口
+                    # 已经到达程序的入口，停止遍历
                     break
             elif len(parts) != 1:
-                # 已经超出程序范围
+                # 已经超出程序范围，停止遍历
+                break
+            # 获取上一个帧
+            try:
+                frame = frame.f_back
+            except AttributeError:
                 break
         return caller_name or "log.py", plugin_name
 
     @staticmethod
     def __setup_logger(log_file: str):
         """
-        设置日志
-        log_file：日志文件相对路径
+        初始化日志实例
+        :param log_file：日志文件相对路径
         """
         log_file_path = log_settings.LOG_PATH / log_file
         log_file_path.parent.mkdir(parents=True, exist_ok=True)
@@ -132,11 +164,8 @@ class LoggerManager:
         # 创建新实例
         _logger = logging.getLogger(log_file_path.stem)
 
-        if log_settings.DEBUG:
-            _logger.setLevel(logging.DEBUG)
-        else:
-            loglevel = getattr(logging, log_settings.LOG_LEVEL.upper(), logging.INFO)
-            _logger.setLevel(loglevel)
+        # 设置日志级别
+        _logger.setLevel(LoggerManager.__get_log_level())
 
         # 移除已有的 handler，避免重复添加
         for handler in _logger.handlers:
@@ -162,6 +191,46 @@ class LoggerManager:
 
         return _logger
 
+    def update_loggers(self):
+        """
+        更新日志实例
+        """
+        with LoggerManager._lock:
+            for _logger in self._loggers.values():
+                self.__update_logger_handlers(_logger)
+
+    @staticmethod
+    def __update_logger_handlers(_logger: logging.Logger):
+        """
+        更新 Logger 的 handler 配置
+        :param _logger: 需要更新的 Logger 实例
+        """
+        # 更新现有 handler
+        for handler in _logger.handlers:
+            try:
+                if isinstance(handler, RotatingFileHandler):
+                    # 更新最大文件大小和备份数量
+                    handler.maxBytes = log_settings.LOG_MAX_FILE_SIZE_BYTES
+                    handler.backupCount = log_settings.LOG_BACKUP_COUNT
+                    # 更新日志文件输出格式
+                    file_formatter = CustomFormatter(log_settings.LOG_FILE_FORMAT)
+                    handler.setFormatter(file_formatter)
+                elif isinstance(handler, logging.StreamHandler):
+                    # 更新控制台输出格式
+                    console_formatter = CustomFormatter(log_settings.LOG_CONSOLE_FORMAT)
+                    handler.setFormatter(console_formatter)
+            except Exception as e:
+                logger.error(f"Failed to update handler: {handler}. Error: {e}")
+        # 更新日志级别
+        _logger.setLevel(LoggerManager.__get_log_level())
+
+    @staticmethod
+    def __get_log_level():
+        """
+        获取当前日志级别
+        """
+        return logging.DEBUG if log_settings.DEBUG else getattr(logging, log_settings.LOG_LEVEL.upper(), logging.INFO)
+
     def logger(self, method: str, msg: str, *args, **kwargs):
         """
         获取模块的logger
@@ -181,7 +250,7 @@ class LoggerManager:
         # 获取调用者的模块的logger
         _logger = self._loggers.get(logfile)
         if not _logger:
-            _logger = self.__setup_logger(logfile)
+            _logger = self.__setup_logger(log_file=logfile)
             self._loggers[logfile] = _logger
         # 调用logger的方法打印日志
         if hasattr(_logger, method):
@@ -210,7 +279,7 @@ class LoggerManager:
         """
         输出警告级别日志（兼容）
         """
-        self.logger("warning", msg, *args, **kwargs)
+        self.warning(msg, *args, **kwargs)
 
     def error(self, msg: str, *args, **kwargs):
         """

app/modules/__init__.py

@@ -2,8 +2,9 @@ from abc import abstractmethod, ABCMeta
 from typing import Generic, Tuple, Union, TypeVar, Type, Dict, Optional, Callable
 
 from app.helper.service import ServiceConfigHelper
-from app.schemas import Notification, MessageChannel, NotificationConf, MediaServerConf, DownloaderConf
-from app.schemas.types import ModuleType
+from app.schemas import Notification, NotificationConf, MediaServerConf, DownloaderConf
+from app.schemas.types import ModuleType, DownloaderType, MediaServerType, MessageChannel, StorageSchema, \
+    OtherModulesType
 
 
 class _ModuleBase(metaclass=ABCMeta):
@@ -43,6 +44,14 @@ class _ModuleBase(metaclass=ABCMeta):
         """
         pass
 
+    @staticmethod
+    @abstractmethod
+    def get_subtype() -> Union[DownloaderType, MediaServerType, MessageChannel, StorageSchema, OtherModulesType]:
+        """
+        获取模块子类型（下载器、媒体服务器、消息通道、存储类型、其他杂项模块类型）
+        """
+        pass
+
     @staticmethod
     @abstractmethod
     def get_priority() -> int:

app/modules/bangumi/__init__.py

@@ -7,7 +7,7 @@ from app.core.meta import MetaBase
 from app.log import logger
 from app.modules import _ModuleBase
 from app.modules.bangumi.bangumi import BangumiApi
-from app.schemas.types import ModuleType
+from app.schemas.types import ModuleType, MediaRecognizeType
 from app.utils.http import RequestUtils
 
 
@@ -44,6 +44,13 @@ class BangumiModule(_ModuleBase):
         获取模块类型
         """
         return ModuleType.MediaRecognize
+
+    @staticmethod
+    def get_subtype() -> MediaRecognizeType:
+        """
+        获取模块子类型
+        """
+        return MediaRecognizeType.Bangumi
     
     @staticmethod
     def get_priority() -> int:

app/modules/bangumi/bangumi.py

@@ -1,8 +1,9 @@
 from datetime import datetime
-from functools import lru_cache
 
 import requests
+from cachetools import TTLCache, cached
 
+from app.core.config import settings
 from app.utils.http import RequestUtils
 
 
@@ -28,7 +29,7 @@ class BangumiApi(object):
         pass
 
     @classmethod
-    @lru_cache(maxsize=128)
+    @cached(cache=TTLCache(maxsize=settings.CACHE_CONF["bangumi"], ttl=settings.CACHE_CONF["meta"]))
     def __invoke(cls, url, **kwargs):
         req_url = cls._base_url + url
         params = {}

app/modules/douban/__init__.py

@@ -15,7 +15,7 @@ from app.modules.douban.apiv2 import DoubanApi
 from app.modules.douban.douban_cache import DoubanCache
 from app.modules.douban.scraper import DoubanScraper
 from app.schemas import MediaPerson, APIRateLimitException
-from app.schemas.types import MediaType, ModuleType
+from app.schemas.types import MediaType, ModuleType, MediaRecognizeType
 from app.utils.common import retry
 from app.utils.http import RequestUtils
 from app.utils.limit import rate_limit_exponential
@@ -59,6 +59,13 @@ class DoubanModule(_ModuleBase):
         """
         return ModuleType.MediaRecognize
 
+    @staticmethod
+    def get_subtype() -> MediaRecognizeType:
+        """
+        获取模块子类型
+        """
+        return MediaRecognizeType.Douban
+
     @staticmethod
     def get_priority() -> int:
         """

app/modules/douban/apiv2.py

@@ -3,11 +3,11 @@ import base64
 import hashlib
 import hmac
 from datetime import datetime
-from functools import lru_cache
 from random import choice
 from urllib import parse
 
 import requests
+from cachetools import TTLCache, cached
 
 from app.core.config import settings
 from app.utils.http import RequestUtils
@@ -160,12 +160,12 @@ class DoubanApi(metaclass=Singleton):
         self._session = requests.Session()
 
     @classmethod
-    def __sign(cls, url: str, ts: int, method='GET') -> str:
+    def __sign(cls, url: str, ts: str, method='GET') -> str:
         """
         签名
         """
         url_path = parse.urlparse(url).path
-        raw_sign = '&'.join([method.upper(), parse.quote(url_path, safe=''), str(ts)])
+        raw_sign = '&'.join([method.upper(), parse.quote(url_path, safe=''), ts])
         return base64.b64encode(
             hmac.new(
                 cls._api_secret_key.encode(),
@@ -174,7 +174,20 @@ class DoubanApi(metaclass=Singleton):
             ).digest()
         ).decode()
 
-    @lru_cache(maxsize=settings.CACHE_CONF.get('douban'))
+    @cached(cache=TTLCache(maxsize=settings.CACHE_CONF["douban"], ttl=settings.CACHE_CONF["meta"]))
+    def __invoke_recommend(self, url: str, **kwargs) -> dict:
+        """
+        推荐/发现类API
+        """
+        return self.__invoke(url, **kwargs)
+
+    @cached(cache=TTLCache(maxsize=settings.CACHE_CONF["douban"], ttl=settings.CACHE_CONF["meta"]))
+    def __invoke_search(self, url: str, **kwargs) -> dict:
+        """
+        搜索类API
+        """
+        return self.__invoke(url, **kwargs)
+
     def __invoke(self, url: str, **kwargs) -> dict:
         """
         GET请求
@@ -203,7 +216,7 @@ class DoubanApi(metaclass=Singleton):
             return resp.json()
         return resp.json() if resp else {}
 
-    @lru_cache(maxsize=settings.CACHE_CONF.get('douban'))
+    @cached(cache=TTLCache(maxsize=settings.CACHE_CONF["douban"], ttl=settings.CACHE_CONF["meta"]))
     def __post(self, url: str, **kwargs) -> dict:
         """
         POST请求
@@ -244,189 +257,189 @@ class DoubanApi(metaclass=Singleton):
         """
         关键字搜索
         """
-        return self.__invoke(self._urls["search"], q=keyword,
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_search(self._urls["search"], q=keyword,
+                                    start=start, count=count, _ts=ts)
 
     def movie_search(self, keyword: str, start: int = 0, count: int = 20,
                      ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         电影搜索
         """
-        return self.__invoke(self._urls["movie_search"], q=keyword,
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_search(self._urls["movie_search"], q=keyword,
+                                    start=start, count=count, _ts=ts)
 
     def tv_search(self, keyword: str, start: int = 0, count: int = 20,
                   ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         电视搜索
         """
-        return self.__invoke(self._urls["tv_search"], q=keyword,
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_search(self._urls["tv_search"], q=keyword,
+                                    start=start, count=count, _ts=ts)
 
     def book_search(self, keyword: str, start: int = 0, count: int = 20,
                     ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         书籍搜索
         """
-        return self.__invoke(self._urls["book_search"], q=keyword,
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_search(self._urls["book_search"], q=keyword,
+                                    start=start, count=count, _ts=ts)
 
     def group_search(self, keyword: str, start: int = 0, count: int = 20,
                      ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         小组搜索
         """
-        return self.__invoke(self._urls["group_search"], q=keyword,
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_search(self._urls["group_search"], q=keyword,
+                                    start=start, count=count, _ts=ts)
 
     def person_search(self, keyword: str, start: int = 0, count: int = 20,
                       ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         人物搜索
         """
-        return self.__invoke(self._urls["search_subject"], type="person", q=keyword,
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_search(self._urls["search_subject"], type="person", q=keyword,
+                                    start=start, count=count, _ts=ts)
 
     def movie_showing(self, start: int = 0, count: int = 20,
                       ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         正在热映
         """
-        return self.__invoke(self._urls["movie_showing"],
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_recommend(self._urls["movie_showing"],
+                                       start=start, count=count, _ts=ts)
 
     def movie_soon(self, start: int = 0, count: int = 20,
                    ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         即将上映
         """
-        return self.__invoke(self._urls["movie_soon"],
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_recommend(self._urls["movie_soon"],
+                                       start=start, count=count, _ts=ts)
 
     def movie_hot_gaia(self, start: int = 0, count: int = 20,
                        ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         热门电影
         """
-        return self.__invoke(self._urls["movie_hot_gaia"],
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_recommend(self._urls["movie_hot_gaia"],
+                                       start=start, count=count, _ts=ts)
 
     def tv_hot(self, start: int = 0, count: int = 20,
                ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         热门剧集
         """
-        return self.__invoke(self._urls["tv_hot"],
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_recommend(self._urls["tv_hot"],
+                                       start=start, count=count, _ts=ts)
 
     def tv_animation(self, start: int = 0, count: int = 20,
                      ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         动画
         """
-        return self.__invoke(self._urls["tv_animation"],
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_recommend(self._urls["tv_animation"],
+                                       start=start, count=count, _ts=ts)
 
     def tv_variety_show(self, start: int = 0, count: int = 20,
                         ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         综艺
         """
-        return self.__invoke(self._urls["tv_variety_show"],
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_recommend(self._urls["tv_variety_show"],
+                                       start=start, count=count, _ts=ts)
 
     def tv_rank_list(self, start: int = 0, count: int = 20,
                      ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         电视剧排行榜
         """
-        return self.__invoke(self._urls["tv_rank_list"],
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_recommend(self._urls["tv_rank_list"],
+                                       start=start, count=count, _ts=ts)
 
     def show_hot(self, start: int = 0, count: int = 20,
                  ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         综艺热门
         """
-        return self.__invoke(self._urls["show_hot"],
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_recommend(self._urls["show_hot"],
+                                       start=start, count=count, _ts=ts)
 
     def movie_detail(self, subject_id: str):
         """
         电影详情
         """
-        return self.__invoke(self._urls["movie_detail"] + subject_id)
+        return self.__invoke_search(self._urls["movie_detail"] + subject_id)
 
     def movie_celebrities(self, subject_id: str):
         """
         电影演职员
         """
-        return self.__invoke(self._urls["movie_celebrities"] % subject_id)
+        return self.__invoke_search(self._urls["movie_celebrities"] % subject_id)
 
     def tv_detail(self, subject_id: str):
         """
         电视剧详情
         """
-        return self.__invoke(self._urls["tv_detail"] + subject_id)
+        return self.__invoke_search(self._urls["tv_detail"] + subject_id)
 
     def tv_celebrities(self, subject_id: str):
         """
         电视剧演职员
         """
-        return self.__invoke(self._urls["tv_celebrities"] % subject_id)
+        return self.__invoke_search(self._urls["tv_celebrities"] % subject_id)
 
     def book_detail(self, subject_id: str):
         """
         书籍详情
         """
-        return self.__invoke(self._urls["book_detail"] + subject_id)
+        return self.__invoke_search(self._urls["book_detail"] + subject_id)
 
     def movie_top250(self, start: int = 0, count: int = 20,
                      ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         电影TOP250
         """
-        return self.__invoke(self._urls["movie_top250"],
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_recommend(self._urls["movie_top250"],
+                                       start=start, count=count, _ts=ts)
 
     def movie_recommend(self, tags='', sort='R', start: int = 0, count: int = 20,
                         ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         电影探索
         """
-        return self.__invoke(self._urls["movie_recommend"], tags=tags, sort=sort,
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_recommend(self._urls["movie_recommend"], tags=tags, sort=sort,
+                                       start=start, count=count, _ts=ts)
 
     def tv_recommend(self, tags='', sort='R', start: int = 0, count: int = 20,
                      ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         电视剧探索
         """
-        return self.__invoke(self._urls["tv_recommend"], tags=tags, sort=sort,
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_recommend(self._urls["tv_recommend"], tags=tags, sort=sort,
+                                       start=start, count=count, _ts=ts)
 
     def tv_chinese_best_weekly(self, start: int = 0, count: int = 20,
                                ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         华语口碑周榜
         """
-        return self.__invoke(self._urls["tv_chinese_best_weekly"],
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_recommend(self._urls["tv_chinese_best_weekly"],
+                                       start=start, count=count, _ts=ts)
 
     def tv_global_best_weekly(self, start: int = 0, count: int = 20,
                               ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         全球口碑周榜
         """
-        return self.__invoke(self._urls["tv_global_best_weekly"],
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_recommend(self._urls["tv_global_best_weekly"],
+                                       start=start, count=count, _ts=ts)
 
     def doulist_detail(self, subject_id: str):
         """
         豆列详情
         :param subject_id: 豆列id
         """
-        return self.__invoke(self._urls["doulist"] + subject_id)
+        return self.__invoke_search(self._urls["doulist"] + subject_id)
 
     def doulist_items(self, subject_id: str, start: int = 0, count: int = 20,
                       ts=datetime.strftime(datetime.now(), '%Y%m%d')):
@@ -437,8 +450,8 @@ class DoubanApi(metaclass=Singleton):
         :param count: 数量
         :param ts: 时间戳
         """
-        return self.__invoke(self._urls["doulist_items"] % subject_id,
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_search(self._urls["doulist_items"] % subject_id,
+                                    start=start, count=count, _ts=ts)
 
     def movie_recommendations(self, subject_id: str, start: int = 0, count: int = 20,
                               ts=datetime.strftime(datetime.now(), '%Y%m%d')):
@@ -449,8 +462,8 @@ class DoubanApi(metaclass=Singleton):
         :param count: 数量
         :param ts: 时间戳
         """
-        return self.__invoke(self._urls["movie_recommendations"] % subject_id,
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_recommend(self._urls["movie_recommendations"] % subject_id,
+                                       start=start, count=count, _ts=ts)
 
     def tv_recommendations(self, subject_id: str, start: int = 0, count: int = 20,
                            ts=datetime.strftime(datetime.now(), '%Y%m%d')):
@@ -461,8 +474,8 @@ class DoubanApi(metaclass=Singleton):
         :param count: 数量
         :param ts: 时间戳
         """
-        return self.__invoke(self._urls["tv_recommendations"] % subject_id,
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_recommend(self._urls["tv_recommendations"] % subject_id,
+                                       start=start, count=count, _ts=ts)
 
     def movie_photos(self, subject_id: str, start: int = 0, count: int = 20,
                      ts=datetime.strftime(datetime.now(), '%Y%m%d')):
@@ -473,8 +486,8 @@ class DoubanApi(metaclass=Singleton):
         :param count: 数量
         :param ts: 时间戳
         """
-        return self.__invoke(self._urls["movie_photos"] % subject_id,
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_search(self._urls["movie_photos"] % subject_id,
+                                    start=start, count=count, _ts=ts)
 
     def tv_photos(self, subject_id: str, start: int = 0, count: int = 20,
                   ts=datetime.strftime(datetime.now(), '%Y%m%d')):
@@ -485,8 +498,8 @@ class DoubanApi(metaclass=Singleton):
         :param count: 数量
         :param ts: 时间戳
         """
-        return self.__invoke(self._urls["tv_photos"] % subject_id,
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_search(self._urls["tv_photos"] % subject_id,
+                                    start=start, count=count, _ts=ts)
 
     def person_detail(self, subject_id: int):
         """
@@ -494,7 +507,7 @@ class DoubanApi(metaclass=Singleton):
         :param subject_id: 人物 id
         :return:
         """
-        return self.__invoke(self._urls["person_detail"] + str(subject_id))
+        return self.__invoke_search(self._urls["person_detail"] + str(subject_id))
 
     def person_work(self, subject_id: int, start: int = 0, count: int = 20, sort_by: str = "time",
                     collection_title: str = "影视",
@@ -509,14 +522,16 @@ class DoubanApi(metaclass=Singleton):
         :param ts: 时间戳
         :return:
         """
-        return self.__invoke(self._urls["person_work"] % subject_id, sortby=sort_by, collection_title=collection_title,
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_search(self._urls["person_work"] % subject_id, sortby=sort_by,
+                                    collection_title=collection_title,
+                                    start=start, count=count, _ts=ts)
 
     def clear_cache(self):
         """
         清空LRU缓存
         """
-        self.__invoke.cache_clear()
+        # 尚未支持缓存清理
+        pass
 
     def close(self):
         if self._session:

app/modules/douban/douban_cache.py

@@ -16,7 +16,7 @@ from app.schemas.types import MediaType
 lock = RLock()
 
 CACHE_EXPIRE_TIMESTAMP_STR = "cache_expire_timestamp"
-EXPIRE_TIMESTAMP = settings.CACHE_CONF.get('meta')
+EXPIRE_TIMESTAMP = settings.CACHE_CONF["meta"]
 
 
 class DoubanCache(metaclass=Singleton):
@@ -77,7 +77,7 @@ class DoubanCache(metaclass=Singleton):
         @return: 被删除的缓存内容
         """
         with lock:
-            return self._meta_data.pop(key, None)
+            return self._meta_data.pop(key, {})
 
     def delete_by_doubanid(self, doubanid: str) -> None:
         """
@@ -179,7 +179,7 @@ class DoubanCache(metaclass=Singleton):
             return
 
         with open(self._meta_path, 'wb') as f:
-            pickle.dump(new_meta_data, f, pickle.HIGHEST_PROTOCOL)
+            pickle.dump(new_meta_data, f, pickle.HIGHEST_PROTOCOL) # noqa
 
     def _random_sample(self, new_meta_data: dict) -> bool:
         """

app/modules/douban/scraper.py

@@ -28,7 +28,7 @@ class DoubanScraper:
                 # 电视剧元数据文件
                 doc = self.__gen_tv_nfo_file(mediainfo=mediainfo)
         if doc:
-            return doc.toprettyxml(indent="  ", encoding="utf-8")
+            return doc.toprettyxml(indent="  ", encoding="utf-8") # noqa
 
         return None
 

app/modules/emby/__init__.py

@@ -6,8 +6,7 @@ from app.core.event import eventmanager
 from app.log import logger
 from app.modules import _MediaServerBase, _ModuleBase
 from app.modules.emby.emby import Emby
-from app.schemas.event import AuthCredentials, AuthInterceptCredentials
-from app.schemas.types import MediaType, ModuleType, ChainEventType
+from app.schemas.types import MediaType, ModuleType, ChainEventType, MediaServerType
 
 
 class EmbyModule(_ModuleBase, _MediaServerBase[Emby]):
@@ -30,6 +29,13 @@ class EmbyModule(_ModuleBase, _MediaServerBase[Emby]):
         """
         return ModuleType.MediaServer
 
+    @staticmethod
+    def get_subtype() -> MediaServerType:
+        """
+        获取模块子类型
+        """
+        return MediaServerType.Emby
+
     @staticmethod
     def get_priority() -> int:
         """
@@ -66,24 +72,34 @@ class EmbyModule(_ModuleBase, _MediaServerBase[Emby]):
                 logger.info(f"Emby服务器 {name} 连接断开，尝试重连 ...")
                 server.reconnect()
 
-    def user_authenticate(self, credentials: AuthCredentials) -> Optional[AuthCredentials]:
+    def user_authenticate(self, credentials: schemas.AuthCredentials, service_name: Optional[str] = None) \
+            -> Optional[schemas.AuthCredentials]:
         """
         使用Emby用户辅助完成用户认证
         :param credentials: 认证数据
+        :param service_name: 指定要认证的媒体服务器名称，若为 None 则认证所有服务
         :return: 认证数据
         """
         # Emby认证
         if not credentials or credentials.grant_type != "password":
             return None
-        for name, server in self.get_instances().items():
+        # 确定要认证的服务器列表
+        if service_name:
+            # 如果指定了服务名，获取该服务实例
+            servers = [(service_name, server)] if (server := self.get_instance(service_name)) else []
+        else:
+            # 如果没有指定服务名，遍历所有服务
+            servers = self.get_instances().items()
+        # 遍历要认证的服务器
+        for name, server in servers:
             # 触发认证拦截事件
             intercept_event = eventmanager.send_event(
                 etype=ChainEventType.AuthIntercept,
-                data=AuthInterceptCredentials(username=credentials.username, channel=self.get_name(),
-                                              service=name, status="triggered")
+                data=schemas.AuthInterceptCredentials(username=credentials.username, channel=self.get_name(),
+                                                      service=name, status="triggered")
             )
             if intercept_event and intercept_event.event_data:
-                intercept_data: AuthInterceptCredentials = intercept_event.event_data
+                intercept_data: schemas.AuthInterceptCredentials = intercept_event.event_data
                 if intercept_data.cancel:
                     continue
             token = server.authenticate(credentials.username, credentials.password)

app/modules/emby/emby.py

@@ -391,7 +391,7 @@ class Emby:
                         year: str = None,
                         tmdb_id: int = None,
                         season: int = None
-                        ) -> Tuple[Optional[str], Optional[Dict[int, List[Dict[int, list]]]]]:
+                        ) -> Tuple[Optional[str], Optional[Dict[int, List[int]]]]:
         """
         根据标题和年份和季，返回Emby中的剧集列表
         :param item_id: Emby中的ID

app/modules/fanart/__init__.py

@@ -1,12 +1,13 @@
 import re
-from functools import lru_cache
 from typing import Optional, Tuple, Union
 
+from cachetools import TTLCache, cached
+
 from app.core.context import MediaInfo, settings
 from app.log import logger
 from app.modules import _ModuleBase
+from app.schemas.types import MediaType, ModuleType, OtherModulesType
 from app.utils.http import RequestUtils
-from app.schemas.types import MediaType, ModuleType
 
 
 class FanartModule(_ModuleBase):
@@ -342,6 +343,13 @@ class FanartModule(_ModuleBase):
         """
         return ModuleType.Other
 
+    @staticmethod
+    def get_subtype() -> OtherModulesType:
+        """
+        获取模块子类型
+        """
+        return OtherModulesType.Fanart
+
     @staticmethod
     def get_priority() -> int:
         """
@@ -376,20 +384,30 @@ class FanartModule(_ModuleBase):
                 continue
             if not isinstance(images, list):
                 continue
-            # 按欢迎程度倒排
-            images.sort(key=lambda x: int(x.get('likes', 0)), reverse=True)
-            # 取第一张图片
-            image_obj = images[0]
+            
             # 图片属性xx_path
             image_name = self.__name(name)
-            image_season = image_obj.get('season')
-            # 设置图片
-            if image_name.startswith("season") and image_season:
-                # 季图片格式 seasonxx-poster
-                image_name = f"season{str(image_season).rjust(2, '0')}-{image_name[6:]}"
-            if not mediainfo.get_image(image_name):
-                # 没有图片才设置
-                mediainfo.set_image(image_name, image_obj.get('url'))
+            if image_name.startswith("season"):
+                # 季图片，图片格式seasonxx-xxxx/season-specials-xxxx
+                for image_obj in images:
+                    image_season = image_obj.get('season')
+                    if image_season is not None:
+                        # 包括poster,thumb,banner
+                        if image_season == '0':
+                            season_image = f"season-specials-{image_name[6:]}"
+                        else:
+                            season_image = f"season{str(image_season).rjust(2, '0')}-{image_name[6:]}"
+                        # 设置图片，没有图片才设置
+                        if not mediainfo.get_image(season_image):
+                            mediainfo.set_image(season_image, image_obj.get('url'))
+            else:
+                # 其他图片，按欢迎程度倒排
+                images.sort(key=lambda x: int(x.get('likes', 0)), reverse=True)
+                # 取第一张图片
+                image_obj = images[0]
+                # 设置图片，没有图片才设置
+                if not mediainfo.get_image(image_name):
+                    mediainfo.set_image(image_name, image_obj.get('url'))
 
         return mediainfo
 
@@ -404,7 +422,7 @@ class FanartModule(_ModuleBase):
         return result
 
     @classmethod
-    @lru_cache(maxsize=settings.CACHE_CONF.get('fanart'))
+    @cached(cache=TTLCache(maxsize=settings.CACHE_CONF["fanart"], ttl=settings.CACHE_CONF["meta"]))
     def __request_fanart(cls, media_type: MediaType, queryid: Union[str, int]) -> Optional[dict]:
         if media_type == MediaType.MOVIE:
             image_url = cls._movie_url % queryid

app/modules/filemanager/__init__.py

@@ -1,4 +1,3 @@
-import copy
 import re
 from pathlib import Path
 from threading import Lock
@@ -8,6 +7,7 @@ from jinja2 import Template
 
 from app.core.config import settings
 from app.core.context import MediaInfo
+from app.core.event import eventmanager
 from app.core.meta import MetaBase
 from app.core.metainfo import MetaInfo, MetaInfoPath
 from app.helper.directory import DirectoryHelper
@@ -16,8 +16,8 @@ from app.helper.module import ModuleHelper
 from app.log import logger
 from app.modules import _ModuleBase
 from app.modules.filemanager.storages import StorageBase
-from app.schemas import TransferInfo, ExistMediaInfo, TmdbEpisode, TransferDirectoryConf, FileItem, StorageUsage
-from app.schemas.types import MediaType, ModuleType
+from app.schemas import TransferInfo, ExistMediaInfo, TmdbEpisode, TransferDirectoryConf, FileItem, StorageUsage, TransferRenameEventData
+from app.schemas.types import MediaType, ModuleType, ChainEventType, OtherModulesType
 from app.utils.system import SystemUtils
 
 lock = Lock()
@@ -51,6 +51,13 @@ class FileManagerModule(_ModuleBase):
         """
         return ModuleType.Other
 
+    @staticmethod
+    def get_subtype() -> OtherModulesType:
+        """
+        获取模块子类型
+        """
+        return OtherModulesType.FileManager
+
     @staticmethod
     def get_priority() -> int:
         """
@@ -65,9 +72,8 @@ class FileManagerModule(_ModuleBase):
         """
         测试模块连接性
         """
-        directoryhelper = DirectoryHelper()
         # 检查目录
-        dirs = directoryhelper.get_dirs()
+        dirs = self.directoryhelper.get_dirs()
         if not dirs:
             return False, "未设置任何目录"
         for d in dirs:
@@ -103,7 +109,7 @@ class FileManagerModule(_ModuleBase):
     def init_setting(self) -> Tuple[str, Union[str, bool]]:
         pass
 
-    def support_transtype(self, storage: str) -> Optional[Dict[str, str]]:
+    def support_transtype(self, storage: str) -> Optional[dict]:
         """
         支持的整理方式
         """
@@ -132,8 +138,6 @@ class FileManagerModule(_ModuleBase):
         )
         return str(path)
 
-        pass
-
     def save_config(self, storage: str, conf: Dict) -> None:
         """
         保存存储配置
@@ -144,7 +148,7 @@ class FileManagerModule(_ModuleBase):
             return
         storage_oper.set_config(conf)
 
-    def generate_qrcode(self, storage: str) -> Optional[Dict[str, str]]:
+    def generate_qrcode(self, storage: str) -> Optional[Tuple[dict, str]]:
         """
         生成二维码
         """
@@ -220,7 +224,8 @@ class FileManagerModule(_ModuleBase):
                             and f".{t.extension.lower()}" in extensions):
                         return True
                     elif t.type == "dir":
-                        return __any_file(t)
+                        if __any_file(t):
+                            return True
             return False
 
         # 返回结果
@@ -269,7 +274,7 @@ class FileManagerModule(_ModuleBase):
             return None
         return storage_oper.download(fileitem, path=path)
 
-    def upload_file(self, fileitem: FileItem, path: Path) -> Optional[FileItem]:
+    def upload_file(self, fileitem: FileItem, path: Path, new_name: str = None) -> Optional[FileItem]:
         """
         上传文件
         """
@@ -277,7 +282,7 @@ class FileManagerModule(_ModuleBase):
         if not storage_oper:
             logger.error(f"不支持 {fileitem.storage} 的上传处理")
             return None
-        return storage_oper.upload(fileitem, path)
+        return storage_oper.upload(fileitem, path, new_name)
 
     def get_file_item(self, storage: str, path: Path) -> Optional[FileItem]:
         """
@@ -323,6 +328,7 @@ class FileManagerModule(_ModuleBase):
                  target_directory: TransferDirectoryConf = None,
                  target_storage: str = None, target_path: Path = None,
                  transfer_type: str = None, scrape: bool = None,
+                 library_type_folder: bool = None, library_category_folder: bool = None,
                  episodes_info: List[TmdbEpisode] = None) -> TransferInfo:
         """
         文件整理
@@ -334,6 +340,8 @@ class FileManagerModule(_ModuleBase):
         :param target_path:  目标路径
         :param transfer_type:  转移模式
         :param scrape: 是否刮削元数据
+        :param library_type_folder: 是否按媒体类型创建目录
+        :param library_category_folder: 是否按媒体类别创建目录
         :param episodes_info: 当前季的全部集信息
         :return: {path, target_path, message}
         """
@@ -349,41 +357,34 @@ class FileManagerModule(_ModuleBase):
                                 fileitem=fileitem,
                                 message=f"{target_path} 不是有效目录")
         # 获取目标路径
-        directoryhelper = DirectoryHelper()
-        if not target_directory:
-            # 根据目的路径查找目录配置
-            if target_path:
-                target_directory = directoryhelper.get_dir(mediainfo, dest_path=target_path)
-            else:
-                target_directory = directoryhelper.get_dir(mediainfo, fileitem=fileitem)
-
         if target_directory:
-            # 拼装媒体库一、二级子目录
-            target_path = self.__get_dest_dir(mediainfo=mediainfo, target_dir=target_directory)
-            # 目标存储类型
-            if not target_storage:
-                target_storage = target_directory.library_storage
             # 整理方式
             if not transfer_type:
                 transfer_type = target_directory.transfer_type
-            # 是否需要刮削
-            if scrape is None:
-                need_scrape = target_directory.scraping
-            else:
-                need_scrape = scrape
             # 是否需要重命名
             need_rename = target_directory.renaming
             # 是否需要通知
             need_notify = target_directory.notify
             # 覆盖模式
             overwrite_mode = target_directory.overwrite_mode
+            # 是否需要刮削
+            need_scrape = scrape or target_directory.scraping
+            # 目标存储类型
+            if not target_storage:
+                target_storage = target_directory.library_storage
+            # 拼装媒体库一、二级子目录
+            target_path = self.__get_dest_dir(mediainfo=mediainfo, target_dir=target_directory,
+                                              need_type_folder=library_type_folder,
+                                              need_category_folder=library_category_folder)
         elif target_path:
-            # 自定义目标路径，仅适用于手动整理的场景
             need_scrape = scrape or False
             need_rename = True
             need_notify = False
             overwrite_mode = "never"
-            logger.warn(f"{target_path} 为自定义路径, 通知将不会发送")
+            # 手动整理的场景，有自定义目标路径
+            target_path = self.__get_dest_path(mediainfo=mediainfo, target_path=target_path,
+                                               need_type_folder=library_type_folder,
+                                               need_category_folder=library_category_folder)
         else:
             # 未找到有效的媒体库目录
             logger.error(
@@ -391,9 +392,14 @@ class FileManagerModule(_ModuleBase):
             return TransferInfo(success=False,
                                 fileitem=fileitem,
                                 message="未找到有效的媒体库目录")
-
-        logger.info(f"获取整理目标路径：【{target_storage}】{target_path}")
+        # 整理方式
+        if not transfer_type:
+            logger.error(f"{target_directory.name} 未设置整理方式")
+            return TransferInfo(success=False,
+                                fileitem=fileitem,
+                                message=f"{target_directory.name} 未设置整理方式")
         # 整理
+        logger.info(f"获取整理目标路径：【{target_storage}】{target_path}")
         return self.transfer_media(fileitem=fileitem,
                                    in_meta=meta,
                                    mediainfo=mediainfo,
@@ -467,13 +473,15 @@ class FileManagerModule(_ModuleBase):
                     target_file.parent.mkdir(parents=True)
                 # 本地到本地
                 if transfer_type == "copy":
-                    state = source_oper.copy(fileitem, target_file)
+                    state = source_oper.copy(fileitem, target_file.parent, target_file.name)
                 elif transfer_type == "move":
-                    state = source_oper.move(fileitem, target_file)
+                    state = source_oper.move(fileitem, target_file.parent, target_file.name)
                 elif transfer_type == "link":
                     state = source_oper.link(fileitem, target_file)
                 elif transfer_type == "softlink":
                     state = source_oper.softlink(fileitem, target_file)
+                else:
+                    return None, f"不支持的整理方式：{transfer_type}"
                 if state:
                     return __get_targetitem(target_file), ""
                 else:
@@ -489,38 +497,28 @@ class FileManagerModule(_ModuleBase):
                     target_fileitem = target_oper.get_folder(target_file.parent)
                     if target_fileitem:
                         # 上传文件
-                        new_item = target_oper.upload(target_fileitem, filepath)
+                        new_item = target_oper.upload(target_fileitem, filepath, target_file.name)
                         if new_item:
-                            # 重命名为目标文件名
-                            if new_item.name != target_file.name:
-                                if target_oper.rename(new_item, target_file.name):
-                                    new_item.name = target_file.name
-                                    new_item.path = str(Path(new_item.path).parent / target_file.name)
                             return new_item, ""
                         else:
                             return None, f"{fileitem.path} 上传 {target_storage} 失败"
                     else:
-                        return None, f"{target_file.parent} {target_storage} 目录获取失败"
+                        return None, f"【{target_storage}】{target_file.parent} 目录获取失败"
                 elif transfer_type == "move":
                     # 移动
                     # 根据目的路径获取文件夹
                     target_fileitem = target_oper.get_folder(target_file.parent)
                     if target_fileitem:
                         # 上传文件
-                        new_item = target_oper.upload(target_fileitem, filepath)
+                        new_item = target_oper.upload(target_fileitem, filepath, target_file.name)
                         if new_item:
-                            # 重命名为目标文件名
-                            if new_item.name != target_file.name:
-                                if target_oper.rename(new_item, target_file.name):
-                                    new_item.name = target_file.name
-                                    new_item.path = str(Path(new_item.path).parent / target_file.name)
                             # 删除源文件
                             source_oper.delete(fileitem)
                             return new_item, ""
                         else:
                             return None, f"{fileitem.path} 上传 {target_storage} 失败"
                     else:
-                        return None, f"{target_file.parent} {target_storage} 目录获取失败"
+                        return None, f"【{target_storage}】{target_file.parent} 目录获取失败"
             elif fileitem.storage != "local" and target_storage == "local":
                 # 网盘到本地
                 if target_file.exists():
@@ -544,25 +542,28 @@ class FileManagerModule(_ModuleBase):
                         return None, f"{fileitem.path} {fileitem.storage} 下载失败"
             elif fileitem.storage == target_storage:
                 # 同一网盘
-                # 根据目的路径获取文件夹
-                target_diritem = target_oper.get_folder(target_file.parent)
-                if target_diritem:
-                    # 重命名文件
-                    if target_oper.rename(fileitem, target_file.name):
-                        # 移动文件到新目录
-                        if source_oper.move(fileitem, target_diritem):
-                            ret_fileitem = copy.deepcopy(fileitem)
-                            ret_fileitem.path = target_diritem.path + "/" + target_file.name
-                            ret_fileitem.name = target_file.name
-                            ret_fileitem.basename = target_file.stem
-                            ret_fileitem.parent_fileid = target_diritem.fileid
-                            return ret_fileitem, ""
+                if transfer_type == "copy":
+                    # 复制文件到新目录
+                    target_fileitem = target_oper.get_folder(target_file.parent)
+                    if target_fileitem:
+                        if source_oper.move(fileitem, Path(target_fileitem.path), target_file.name):
+                            return target_oper.get_item(target_file), ""
                         else:
-                            return None, f"{fileitem.path} {target_storage} 移动文件失败"
+                            return None, f"【{target_storage}】{fileitem.path} 复制文件失败"
                     else:
-                        return None, f"{fileitem.path} {target_storage} 重命名文件失败"
+                        return None, f"【{target_storage}】{target_file.parent} 目录获取失败"
+                elif transfer_type == "move":
+                    # 移动文件到新目录
+                    target_fileitem = target_oper.get_folder(target_file.parent)
+                    if target_fileitem:
+                        if source_oper.move(fileitem, Path(target_fileitem.path), target_file.name):
+                            return target_oper.get_item(target_file), ""
+                        else:
+                            return None, f"【{target_storage}】{fileitem.path} 移动文件失败"
+                    else:
+                        return None, f"【{target_storage}】{target_file.parent} 目录获取失败"
                 else:
-                    return None, f"{target_file.parent} {target_storage} 目录获取失败"
+                    return None, f"不支持的整理方式：{transfer_type}"
 
         return None, "未知错误"
 
@@ -604,12 +605,12 @@ class FileManagerModule(_ModuleBase):
                        r"|chinese|(cn|ch[si]|sg|zho?|eng)[-_&]?(cn|ch[si]|sg|zho?|eng)" \
                        r"|简[体中]?)[.\])])" \
                        r"|([\u4e00-\u9fa5]{0,3}[中双][\u4e00-\u9fa5]{0,2}[字文语][\u4e00-\u9fa5]{0,3})" \
-                       r"|简体|简中|JPSC" \
+                       r"|简体|简中|JPSC|sc_jp" \
                        r"|(?<![a-z0-9])gb(?![a-z0-9])"
         _zhtw_sub_re = r"([.\[(](((zh[-_])?(hk|tw|cht|tc))" \
                        r"|(cht|eng)[-_&]?(cht|eng)" \
                        r"|繁[体中]?)[.\])])" \
-                       r"|繁体中[文字]|中[文字]繁体|繁体|JPTC" \
+                       r"|繁体中[文字]|中[文字]繁体|繁体|JPTC|tc_jp" \
                        r"|(?<![a-z0-9])big5(?![a-z0-9])"
         _eng_sub_re = r"[.\[(]eng[.\])]"
 
@@ -625,18 +626,16 @@ class FileManagerModule(_ModuleBase):
         if not parent_item:
             return False, f"{org_path} 上级目录获取失败"
         # 字幕文件列表
-        file_list: List[FileItem] = storage_oper.list(parent_item)
+        file_list: List[FileItem] = storage_oper.list(parent_item) or []
+        file_list = [f for f in file_list if f.type == "file" and f.extension
+                     and f".{f.extension.lower()}" in settings.RMT_SUBEXT]
         if len(file_list) == 0:
-            logger.debug(f"{parent_item.path} 目录下没有找到字幕文件...")
+            logger.info(f"{parent_item.path} 目录下没有找到字幕文件...")
         else:
-            logger.debug("字幕文件清单：" + str(file_list))
+            logger.info(f"字幕文件清单：{[f.name for f in file_list]}")
             # 识别文件名
             metainfo = MetaInfoPath(org_path)
             for sub_item in file_list:
-                if sub_item.type == "dir" or not sub_item.extension:
-                    continue
-                if f".{sub_item.extension.lower()}" not in settings.RMT_SUBEXT:
-                    continue
                 # 识别字幕文件名
                 sub_file_name = re.sub(_zhtw_sub_re,
                                        ".",
@@ -699,7 +698,7 @@ class FileManagerModule(_ModuleBase):
                                 return False, errmsg
                         except Exception as error:
                             logger.info(f"字幕 {new_file} 出错了,原因: {str(error)}")
-        return False, ""
+        return True, ""
 
     def __transfer_audio_track_files(self, fileitem: FileItem, target_storage: str, target_file: Path,
                                      transfer_type: str) -> Tuple[bool, str]:
@@ -723,7 +722,7 @@ class FileManagerModule(_ModuleBase):
         file_list: List[FileItem] = storage_oper.list(parent_item)
         # 匹配音轨文件
         pending_file_list: List[FileItem] = [file for file in file_list
-                                             if Path(file.name).stem == org_path.name
+                                             if Path(file.name).stem == org_path.stem
                                              and file.type == "file" and file.extension
                                              and f".{file.extension.lower()}" in settings.RMT_AUDIOEXT]
         if len(pending_file_list) == 0:
@@ -829,7 +828,8 @@ class FileManagerModule(_ModuleBase):
             else:
                 logger.info(f"正在删除已存在的文件：{target_file}")
                 target_file.unlink()
-        logger.info(f"正在整理文件：【{fileitem.storage}】{fileitem.path} 到 【{target_storage}】{target_file}")
+        logger.info(f"正在整理文件：【{fileitem.storage}】{fileitem.path} 到 【{target_storage}】{target_file}，"
+                    f"操作类型：{transfer_type}")
         new_item, errmsg = self.__transfer_command(fileitem=fileitem,
                                                    target_storage=target_storage,
                                                    target_file=target_file,
@@ -845,26 +845,43 @@ class FileManagerModule(_ModuleBase):
         return None, errmsg
 
     @staticmethod
-    def __get_dest_dir(mediainfo: MediaInfo, target_dir: TransferDirectoryConf) -> Path:
+    def __get_dest_path(mediainfo: MediaInfo, target_path: Path,
+                        need_type_folder: bool = False, need_category_folder: bool = False):
+        """
+        获取目标路径
+        """
+        if need_type_folder:
+            target_path = target_path / mediainfo.type.value
+        if need_category_folder and mediainfo.category:
+            target_path = target_path / mediainfo.category
+        return target_path
+
+    @staticmethod
+    def __get_dest_dir(mediainfo: MediaInfo, target_dir: TransferDirectoryConf,
+                       need_type_folder: bool = None, need_category_folder: bool = None) -> Path:
         """
         根据设置并装媒体库目录
         :param mediainfo: 媒体信息
         :target_dir: 媒体库根目录
-        :typename_dir: 是否加上类型目录
+        :need_type_folder: 是否需要按媒体类型创建目录
+        :need_category_folder: 是否需要按媒体类别创建目录
         """
-        if not target_dir.media_type and target_dir.library_type_folder:
+        if need_type_folder is None:
+            need_type_folder = target_dir.library_type_folder
+        if need_category_folder is None:
+            need_category_folder = target_dir.library_category_folder
+        if not target_dir.media_type and need_type_folder:
             # 一级自动分类
             library_dir = Path(target_dir.library_path) / mediainfo.type.value
-        elif target_dir.media_type and target_dir.library_type_folder:
+        elif target_dir.media_type and need_type_folder:
             # 一级手动分类
             library_dir = Path(target_dir.library_path) / target_dir.media_type
         else:
             library_dir = Path(target_dir.library_path)
-
-        if not target_dir.media_category and target_dir.library_category_folder and mediainfo.category:
+        if not target_dir.media_category and need_category_folder and mediainfo.category:
             # 二级自动分类
             library_dir = library_dir / mediainfo.category
-        elif target_dir.media_category and target_dir.library_category_folder:
+        elif target_dir.media_category and need_category_folder:
             # 二级手动分类
             library_dir = library_dir / target_dir.media_category
 
@@ -903,6 +920,18 @@ class FileManagerModule(_ModuleBase):
         rename_format = settings.TV_RENAME_FORMAT \
             if mediainfo.type == MediaType.TV else settings.MOVIE_RENAME_FORMAT
 
+        # 计算重命名中的文件夹层数
+        rename_format_level = len(rename_format.split("/")) - 1
+
+        if rename_format_level < 1:
+            # 重命名格式不合法
+            logger.error(f"重命名格式不合法：{rename_format}")
+            return TransferInfo(success=False,
+                                message=f"重命名格式不合法",
+                                fileitem=fileitem,
+                                transfer_type=transfer_type,
+                                need_notify=need_notify)
+
         # 判断是否为文件夹
         if fileitem.type == "dir":
             # 整理整个目录，一般为蓝光原盘
@@ -983,9 +1012,15 @@ class FileManagerModule(_ModuleBase):
             # 目的操作对象
             target_oper: StorageBase = self.__get_storage_oper(target_storage)
             # 目标目录
-            target_diritem = target_oper.get_folder(
-                new_file.parent) if mediainfo.type == MediaType.MOVIE else target_oper.get_folder(
-                new_file.parent.parent)
+            target_diritem = target_oper.get_folder(new_file.parents[rename_format_level - 1])
+            if not target_diritem:
+                logger.error(f"目标目录 {new_file.parents[rename_format_level - 1]} 获取失败")
+                return TransferInfo(success=False,
+                                    message=f"目标目录 {new_file.parents[rename_format_level - 1]} 获取失败",
+                                    fileitem=fileitem,
+                                    fail_list=[fileitem.path],
+                                    transfer_type=transfer_type,
+                                    need_notify=need_notify)
             # 目标文件
             target_item = target_oper.get_item(new_file)
             if target_item:
@@ -1094,7 +1129,14 @@ class FileManagerModule(_ModuleBase):
                 if episode.episode_number == meta.begin_episode:
                     episode_title = episode.name
                     break
-
+        # 获取集播出日期
+        episode_date = None
+        if meta.begin_episode and episodes_info:
+            for episode in episodes_info:
+                if episode.episode_number == meta.begin_episode:
+                    episode_date = episode.air_date
+                    break
+        
         return {
             # 标题
             "title": __convert_invalid_characters(mediainfo.title),
@@ -1139,26 +1181,56 @@ class FileManagerModule(_ModuleBase):
             # 集号
             "episode": meta.episode_seqs,
             # 季集 SxxExx
-            "season_episode": "%s%s" % (meta.season, meta.episodes),
+            "season_episode": "%s%s" % (meta.season, meta.episode),
             # 段/节
             "part": meta.part,
             # 剧集标题
             "episode_title": __convert_invalid_characters(episode_title),
+            # 剧集日期根据episodes_info值获取
+            "episode_date": episode_date,
             # 文件后缀
             "fileExt": file_ext,
             # 自定义占位符
-            "customization": meta.customization
+            "customization": meta.customization,
+            # 文件元数据
+            "__meta__": meta,
+            # 识别的媒体信息
+            "__mediainfo__": mediainfo,
+            # 当前季的全部集信息
+            "__episodes_info__": episodes_info,
         }
 
     @staticmethod
     def get_rename_path(template_string: str, rename_dict: dict, path: Path = None) -> Path:
         """
-        生成重命名后的完整路径
+        生成重命名后的完整路径，支持智能重命名事件
+        :param template_string: Jinja2 模板字符串
+        :param rename_dict: 渲染上下文，用于替换模板中的变量
+        :param path: 可选的基础路径，如果提供，将在其基础上拼接生成的路径
+        :return: 生成的完整路径
         """
         # 创建jinja2模板对象
         template = Template(template_string)
         # 渲染生成的字符串
         render_str = template.render(rename_dict)
+
+        logger.debug(f"Initial render string: {render_str}")
+        # 发送智能重命名事件
+        event_data = TransferRenameEventData(
+            template_string=template_string,
+            rename_dict=rename_dict,
+            render_str=render_str,
+            path=path
+        )
+        event = eventmanager.send_event(ChainEventType.TransferRename, event_data)
+        # 检查事件返回的结果
+        if event and event.event_data:
+            event_data: TransferRenameEventData = event.event_data
+            if event_data.updated and event_data.updated_str:
+                logger.debug(f"Render string updated by event: "
+                             f"{render_str} -> {event_data.updated_str} (source: {event_data.source})")
+                render_str = event_data.updated_str
+
         # 目的路径
         if path:
             return path / render_str
@@ -1184,17 +1256,19 @@ class FileManagerModule(_ModuleBase):
             # 重命名格式
             rename_format = settings.TV_RENAME_FORMAT \
                 if mediainfo.type == MediaType.TV else settings.MOVIE_RENAME_FORMAT
-            # 获取相对路径（重命名路径）
-            rel_path = self.get_rename_path(
+            # 计算重命名中的文件夹层数
+            rename_format_level = len(rename_format.split("/")) - 1
+            if rename_format_level < 1:
+                continue
+            # 获取路径（重命名路径）
+            target_path = self.get_rename_path(
+                path=dir_path,
                 template_string=rename_format,
                 rename_dict=self.__get_naming_dict(meta=MetaInfo(mediainfo.title),
                                                    mediainfo=mediainfo)
             )
             # 取相对路径的第1层目录
-            if rel_path.parts:
-                media_path = dir_path / rel_path.parts[0]
-            else:
-                continue
+            media_path = target_path.parents[rename_format_level - 1]
             # 检索媒体文件
             fileitem = storage_oper.get_item(media_path)
             if not fileitem:

app/modules/filemanager/storages/__init__.py

@@ -1,6 +1,6 @@
 from abc import ABCMeta, abstractmethod
 from pathlib import Path
-from typing import Optional, List, Union, Dict
+from typing import Optional, List, Dict, Tuple
 
 from app import schemas
 from app.helper.storage import StorageHelper
@@ -16,7 +16,14 @@ class StorageBase(metaclass=ABCMeta):
     def __init__(self):
         self.storagehelper = StorageHelper()
 
-    def generate_qrcode(self, *args, **kwargs) -> Optional[Dict[str, str]]:
+    @abstractmethod
+    def init_storage(self):
+        """
+        初始化
+        """
+        pass
+
+    def generate_qrcode(self, *args, **kwargs) -> Optional[Tuple[dict, str]]:
         pass
 
     def check_login(self, *args, **kwargs) -> Optional[Dict[str, str]]:
@@ -28,11 +35,19 @@ class StorageBase(metaclass=ABCMeta):
         """
         return self.storagehelper.get_storage(self.schema.value)
 
+    def get_conf(self) -> dict:
+        """
+        获取配置
+        """
+        conf = self.get_config()
+        return conf.config if conf else {}
+
     def set_config(self, conf: dict):
         """
         设置配置
         """
         self.storagehelper.set_storage(self.schema.value, conf)
+        self.init_storage()
 
     def support_transtype(self) -> dict:
         """
@@ -64,6 +79,8 @@ class StorageBase(metaclass=ABCMeta):
     def create_folder(self, fileitem: schemas.FileItem, name: str) -> Optional[schemas.FileItem]:
         """
         创建目录
+        :param fileitem: 父目录
+        :param name: 目录名
         """
         pass
 
@@ -107,16 +124,16 @@ class StorageBase(metaclass=ABCMeta):
         下载文件，保存到本地，返回本地临时文件地址
         :param fileitem: 文件项
         :param path: 文件保存路径
-
         """
         pass
 
     @abstractmethod
-    def upload(self, fileitem: schemas.FileItem, path: Path) -> Optional[schemas.FileItem]:
+    def upload(self, fileitem: schemas.FileItem, path: Path, new_name: str = None) -> Optional[schemas.FileItem]:
         """
         上传文件
         :param fileitem: 上传目录项
         :param path: 本地文件路径
+        :param new_name: 上传后文件名
         """
         pass
 
@@ -128,16 +145,22 @@ class StorageBase(metaclass=ABCMeta):
         pass
 
     @abstractmethod
-    def copy(self, fileitem: schemas.FileItem, target: Union[schemas.FileItem, Path]) -> bool:
+    def copy(self, fileitem: schemas.FileItem, path: Path, new_name: str) -> bool:
         """
         复制文件
+        :param fileitem: 文件项
+        :param path: 目标目录
+        :param new_name: 新文件名
         """
         pass
 
     @abstractmethod
-    def move(self, fileitem: schemas.FileItem, target: Union[schemas.FileItem, Path]) -> bool:
+    def move(self, fileitem: schemas.FileItem, path: Path, new_name: str) -> bool:
         """
         移动文件
+        :param fileitem: 文件项
+        :param path: 目标目录
+        :param new_name: 新文件名
         """
         pass
 

app/modules/filemanager/storages/alipan.py

@@ -16,10 +16,11 @@ from app.schemas.types import StorageSchema
 from app.utils.http import RequestUtils
 from aligo import Aligo, BaseFile
 
+from app.utils.singleton import Singleton
 from app.utils.string import StringUtils
 
 
-class AliPan(StorageBase):
+class AliPan(StorageBase, metaclass=Singleton):
     """
     阿里云相关操作
     """
@@ -29,6 +30,7 @@ class AliPan(StorageBase):
 
     # 支持的整理方式
     transtype = {
+        "copy": "复制",
         "move": "移动",
     }
 
@@ -54,17 +56,27 @@ class AliPan(StorageBase):
         except FileNotFoundError:
             logger.debug('未发现 aria2c')
             self._has_aria2c = False
+        self.init_storage()
 
-        self.__init_aligo()
-
-    def __init_aligo(self):
+    def init_storage(self):
         """
         初始化 aligo
         """
+
+        def show_qrcode(qr_link: str):
+            """
+            显示二维码
+            """
+            logger.info(f"请用阿里云盘 App 扫码登录：{qr_link}")
+
         refresh_token = self.__auth_params.get("refreshToken")
         if refresh_token:
-            self.aligo = Aligo(refresh_token=refresh_token, use_aria2=self._has_aria2c,
-                               name="MoviePilot V2", level=logging.ERROR)
+            try:
+                self.aligo = Aligo(refresh_token=refresh_token, show=show_qrcode, use_aria2=self._has_aria2c, # noqa
+                                   name="MoviePilot V2", level=logging.ERROR, re_login=False)
+            except Exception as err:
+                logger.error(f"初始化阿里云盘失败：{str(err)}")
+                self.__clear_params()
 
     @property
     def __auth_params(self):
@@ -160,7 +172,7 @@ class AliPan(StorageBase):
                         })
                         self.__update_params(data)
                         self.__update_drives()
-                        self.__init_aligo()
+                        self.init_storage()
                 except Exception as e:
                     return {}, f"bizExt 解码失败：{str(e)}"
             return data, ""
@@ -180,12 +192,16 @@ class AliPan(StorageBase):
         """
         获取用户信息（drive_id等）
         """
+        if not self.aligo:
+            return {}
         return self.aligo.get_user()
 
     def __update_drives(self):
         """
         更新用户存储根目录
         """
+        if not self.aligo:
+            return
         drivers = self.aligo.list_my_drives()
         for driver in drivers:
             if driver.category == "resource":
@@ -240,28 +256,9 @@ class AliPan(StorageBase):
             return []
         # 根目录处理
         if not fileitem or not fileitem.drive_id:
-            return [
-                schemas.FileItem(
-                    storage=self.schema.value,
-                    fileid="root",
-                    drive_id=self.__auth_params.get("resourceDriveId"),
-                    parent_fileid="root",
-                    type="dir",
-                    path="/资源库/",
-                    name="资源库",
-                    basename="资源库"
-                ),
-                schemas.FileItem(
-                    storage=self.schema.value,
-                    fileid="root",
-                    drive_id=self.__auth_params.get("backDriveId"),
-                    parent_fileid="root",
-                    type="dir",
-                    path="/备份盘/",
-                    name="备份盘",
-                    basename="备份盘"
-                )
-            ]
+            items = self.aligo.get_file_list()
+            if items:
+                return [self.__get_fileitem(item) for item in items]
         elif fileitem.type == "file":
             # 文件处理
             file = self.detail(fileitem)
@@ -276,6 +273,8 @@ class AliPan(StorageBase):
     def create_folder(self, fileitem: schemas.FileItem, name: str) -> Optional[schemas.FileItem]:
         """
         创建目录
+        :param fileitem: 父目录
+        :param name: 目录名
         """
         if not self.aligo:
             return None
@@ -283,21 +282,43 @@ class AliPan(StorageBase):
         if item:
             if isinstance(item, CreateFileResponse):
                 item = self.aligo.get_file(file_id=item.file_id, drive_id=item.drive_id)
-            return self.__get_fileitem(item)
+            return self.__get_fileitem(item, parent=fileitem.path)
         return None
 
     def get_folder(self, path: Path) -> Optional[schemas.FileItem]:
         """
         根据文件路程获取目录，不存在则创建
         """
-        if not self.aligo:
+
+        def __find_dir(_fileitem: schemas.FileItem, _name: str) -> Optional[schemas.FileItem]:
+            """
+            查找下级目录中匹配名称的目录
+            """
+            for sub_folder in self.list(_fileitem):
+                if sub_folder.type != "dir":
+                    continue
+                if sub_folder.name == _name:
+                    return sub_folder
             return None
-        item = self.aligo.get_folder_by_path(path=str(path), create_folder=True)
-        if item:
-            if isinstance(item, CreateFileResponse):
-                item = self.aligo.get_file(file_id=item.file_id, drive_id=item.drive_id)
-            return self.__get_fileitem(item)
-        return None
+
+        # 是否已存在
+        folder = self.get_item(path)
+        if folder:
+            return folder
+        # 逐级查找和创建目录
+        fileitem = schemas.FileItem(path="/")
+        for part in path.parts:
+            if part == "/":
+                continue
+            dir_file = __find_dir(fileitem, part)
+            if dir_file:
+                fileitem = dir_file
+            else:
+                dir_file = self.create_folder(fileitem, part)
+                if not dir_file:
+                    return None
+                fileitem = dir_file
+        return fileitem
 
     def get_item(self, path: Path) -> Optional[schemas.FileItem]:
         """
@@ -307,7 +328,7 @@ class AliPan(StorageBase):
             return None
         item = self.aligo.get_file_by_path(path=str(path))
         if item:
-            return self.__get_fileitem(item)
+            return self.__get_fileitem(item, parent=str(path.parent))
         return None
 
     def delete(self, fileitem: schemas.FileItem) -> bool:
@@ -328,7 +349,7 @@ class AliPan(StorageBase):
             return None
         item = self.aligo.get_file(file_id=fileitem.fileid, drive_id=fileitem.drive_id)
         if item:
-            return self.__get_fileitem(item)
+            return self.__get_fileitem(item, parent=fileitem.path)
         return None
 
     def rename(self, fileitem: schemas.FileItem, name: str) -> bool:
@@ -347,41 +368,66 @@ class AliPan(StorageBase):
         """
         if not self.aligo:
             return None
-        local_path = self.aligo.download_file(file_id=fileitem.fileid, drive_id=fileitem.drive_id,
+        local_path = self.aligo.download_file(file_id=fileitem.fileid, drive_id=fileitem.drive_id,  # noqa
                                               local_folder=str(path or settings.TEMP_PATH))
         if local_path:
             return Path(local_path)
         return None
 
-    def upload(self, fileitem: schemas.FileItem, path: Path) -> Optional[schemas.FileItem]:
+    def upload(self, fileitem: schemas.FileItem, path: Path, new_name: str = None) -> Optional[schemas.FileItem]:
         """
         上传文件，并标记完成
+        :param fileitem: 上传目录项
+        :param path: 本地文件路径
+        :param new_name: 上传后文件名
         """
         if not self.aligo:
             return None
         # 上传文件
         result = self.aligo.upload_file(file_path=str(path), parent_file_id=fileitem.fileid,
-                                        drive_id=fileitem.drive_id, name=path.name,
+                                        drive_id=fileitem.drive_id, name=new_name or path.name,
                                         check_name_mode="refuse")
         if result:
             item = self.aligo.get_file(file_id=result.file_id, drive_id=result.drive_id)
             if item:
-                return self.__get_fileitem(item)
+                return self.__get_fileitem(item, parent=fileitem.path)
         return None
 
-    def move(self, fileitem: schemas.FileItem, target: schemas.FileItem) -> bool:
+    def move(self, fileitem: schemas.FileItem, path: Path, new_name: str) -> bool:
         """
         移动文件
+        :param fileitem: 文件项
+        :param path: 目标目录
+        :param new_name: 新文件名
         """
         if not self.aligo:
             return False
+        target = self.get_folder(path)
+        if not target:
+            return False
         if self.aligo.move_file(file_id=fileitem.fileid, drive_id=fileitem.drive_id,
-                                to_parent_file_id=target.fileid, to_drive_id=target.drive_id):
+                                to_parent_file_id=target.fileid, to_drive_id=target.drive_id,
+                                new_name=new_name):
             return True
         return False
 
-    def copy(self, fileitem: schemas.FileItem, target: schemas.FileItem) -> bool:
-        pass
+    def copy(self, fileitem: schemas.FileItem, path: Path, new_name: str) -> bool:
+        """
+        复制文件
+        :param fileitem: 文件项
+        :param path: 目标目录
+        :param new_name: 新文件名
+        """
+        if not self.aligo:
+            return False
+        target = self.get_folder(path)
+        if not target:
+            return False
+        if self.aligo.copy_file(file_id=fileitem.fileid, drive_id=fileitem.drive_id,
+                                to_parent_file_id=target.fileid, to_drive_id=target.drive_id,
+                                new_name=new_name):
+            return True
+        return False
 
     def link(self, fileitem: schemas.FileItem, target_file: Path) -> bool:
         """

app/modules/filemanager/storages/alist.py

@@ -0,0 +1,741 @@
+import json
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, List, Dict
+
+from cachetools import cached, TTLCache
+from requests import Response
+
+from app import schemas
+from app.core.config import settings
+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.url import UrlUtils
+
+
+class Alist(StorageBase, metaclass=Singleton):
+    """
+    Alist相关操作
+    api文档：https://alist.nn.ci/zh/guide/api
+    """
+
+    # 存储类型
+    schema = StorageSchema.Alist
+
+    # 支持的整理方式
+    transtype = {
+        "copy": "复制",
+        "move": "移动",
+    }
+
+    def __init__(self):
+        super().__init__()
+
+    def init_storage(self):
+        """
+        初始化
+        """
+        pass
+
+    @property
+    def __get_base_url(self) -> str:
+        """
+        获取基础URL
+        """
+        url = self.get_conf().get("url")
+        if url is None:
+            return ""
+        return UrlUtils.standardize_base_url(self.get_conf().get("url"))
+
+    def __get_api_url(self, path: str) -> str:
+        """
+        获取API URL
+        """
+        return UrlUtils.adapt_request_url(self.__get_base_url, path)
+
+    @property
+    def __get_valuable_toke(self) -> str:
+        """
+        获取一个可用的token
+        如果设置永久令牌则返回永久令牌
+        否则使用账号密码生成临时令牌
+        """
+        return self.__generate_token
+
+    @property
+    @cached(cache=TTLCache(maxsize=1, ttl=60 * 60 * 24 * 2 - 60 * 5))
+    def __generate_token(self) -> str:
+        """
+        使用账号密码生成一个临时token
+        缓存2天，提前5分钟更新
+        """
+        conf = self.get_conf()
+        resp: Response = RequestUtils(headers={
+            'Content-Type': 'application/json'
+        }).post_res(
+            self.__get_api_url("/api/auth/login"),
+            data=json.dumps({
+                "username": conf.get("username"),
+                "password": conf.get("password"),
+            }),
+        )
+        """
+        {
+            "username": "{{alist_username}}",
+            "password": "{{alist_password}}"
+        }
+        ======================================
+        {
+            "code": 200,
+            "message": "success",
+            "data": {
+                "token": "abcd"
+            }
+        }
+        """
+
+        if resp is None:
+            logger.warning("请求登录失败，无法连接alist服务")
+            return ""
+
+        if resp.status_code != 200:
+            logger.warning(f"更新令牌请求发送失败，状态码：{resp.status_code}")
+            return ""
+
+        result = resp.json()
+
+        if result["code"] != 200:
+            logger.critical(f'更新令牌，错误信息：{result["message"]}')
+            return ""
+
+        logger.debug("AList获取令牌成功")
+        return result["data"]["token"]
+
+    def __get_header_with_token(self) -> dict:
+        """
+        获取带有token的header
+        """
+        return {"Authorization": self.__get_valuable_toke}
+
+    def check(self) -> bool:
+        """
+        检查存储是否可用
+        """
+        pass
+
+    def list(
+            self,
+            fileitem: schemas.FileItem,
+            password: str = "",
+            page: int = 1,
+            per_page: int = 0,
+            refresh: bool = False,
+    ) -> Optional[List[schemas.FileItem]]:
+        """
+        浏览文件
+        :param fileitem: 文件项
+        :param password: 路径密码
+        :param page: 页码
+        :param per_page: 每页数量
+        :param refresh: 是否刷新
+        """
+        if fileitem.type == "file":
+            item = self.get_item(Path(fileitem.path))
+            if item:
+                return [item]
+            return None
+        resp: Response = RequestUtils(
+            headers=self.__get_header_with_token()
+        ).post_res(
+            self.__get_api_url("/api/fs/list"),
+            json={
+                "path": fileitem.path,
+                "password": password,
+                "page": page,
+                "per_page": per_page,
+                "refresh": refresh,
+            },
+        )
+        """
+        {
+            "path": "/t",
+            "password": "",
+            "page": 1,
+            "per_page": 0,
+            "refresh": false
+        }
+        ======================================
+        {
+            "code": 200,
+            "message": "success",
+            "data": {
+                "content": [
+                {
+                    "name": "Alist V3.md",
+                    "size": 1592,
+                    "is_dir": false,
+                    "modified": "2024-05-17T13:47:55.4174917+08:00",
+                    "created": "2024-05-17T13:47:47.5725906+08:00",
+                    "sign": "",
+                    "thumb": "",
+                    "type": 4,
+                    "hashinfo": "null",
+                    "hash_info": null
+                }
+                ],
+                "total": 1,
+                "readme": "",
+                "header": "",
+                "write": true,
+                "provider": "Local"
+            }
+        }
+        """
+
+        if resp is None:
+            logging.warning(f"请求获取目录 {fileitem.path} 的文件列表失败，无法连接alist服务")
+            return
+        if resp.status_code != 200:
+            logging.warning(
+                f"请求获取目录 {fileitem.path} 的文件列表失败，状态码：{resp.status_code}"
+            )
+            return
+
+        result = resp.json()
+
+        if result["code"] != 200:
+            logging.warning(
+                f'获取目录 {fileitem.path} 的文件列表失败，错误信息：{result["message"]}'
+            )
+            return
+
+        return [
+            schemas.FileItem(
+                storage=self.schema.value,
+                type="dir" if item["is_dir"] else "file",
+                path=(Path(fileitem.path) / item["name"]).as_posix() + ("/" if item["is_dir"] else ""),
+                name=item["name"],
+                basename=Path(item["name"]).stem,
+                extension=Path(item["name"]).suffix[1:] if not item["is_dir"] else None,
+                size=item["size"] if not item["is_dir"] else None,
+                modify_time=self.__parse_timestamp(item["modified"]),
+                thumbnail=item["thumb"],
+            )
+            for item in result["data"]["content"] or []
+        ]
+
+    def create_folder(
+            self, fileitem: schemas.FileItem, name: str
+    ) -> Optional[schemas.FileItem]:
+        """
+        创建目录
+        :param fileitem: 父目录
+        :param name: 目录名
+        """
+        path = Path(fileitem.path) / name
+        resp: Response = RequestUtils(
+            headers=self.__get_header_with_token()
+        ).post_res(
+            self.__get_api_url("/api/fs/mkdir"),
+            json={"path": path.as_posix()},
+        )
+        """
+        {
+            "path": "/tt"
+        }
+        ======================================
+        {
+            "code": 200,
+            "message": "success",
+            "data": null
+        }
+        """
+        if resp is None:
+            logging.warning(f"请求创建目录 {path} 失败，无法连接alist服务")
+            return
+        if resp.status_code != 200:
+            logging.warning(f"请求创建目录 {path} 失败，状态码：{resp.status_code}")
+            return
+
+        result = resp.json()
+        if result["code"] != 200:
+            logging.warning(f'创建目录 {path} 失败，错误信息：{result["message"]}')
+            return
+
+        return self.get_item(path)
+
+    def get_folder(self, path: Path) -> Optional[schemas.FileItem]:
+        """
+        获取目录，如目录不存在则创建
+        """
+        folder = self.get_item(path)
+        if folder:
+            return folder
+        if not folder:
+            folder = self.create_folder(schemas.FileItem(
+                storage=self.schema.value,
+                type="dir",
+                path=path.parent.as_posix(),
+                name=path.name,
+                basename=path.stem
+            ), path.name)
+        return folder
+
+    def get_item(
+            self,
+            path: Path,
+            password: str = "",
+            page: int = 1,
+            per_page: int = 0,
+            refresh: bool = False,
+    ) -> Optional[schemas.FileItem]:
+        """
+        获取文件或目录，不存在返回None
+        :param path: 文件路径
+        :param password: 路径密码
+        :param page: 页码
+        :param per_page: 每页数量
+        :param refresh: 是否刷新
+        """
+        resp: Response = RequestUtils(
+            headers=self.__get_header_with_token()
+        ).post_res(
+            self.__get_api_url("/api/fs/get"),
+            json={
+                "path": path.as_posix(),
+                "password": password,
+                "page": page,
+                "per_page": per_page,
+                "refresh": refresh,
+            },
+        )
+        """
+        {
+            "path": "/t",
+            "password": "",
+            "page": 1,
+            "per_page": 0,
+            "refresh": false
+        }
+        ======================================
+        {
+            "code": 200,
+            "message": "success",
+            "data": {
+                "name": "Alist V3.md",
+                "size": 2618,
+                "is_dir": false,
+                "modified": "2024-05-17T16:05:36.4651534+08:00",
+                "created": "2024-05-17T16:05:29.2001008+08:00",
+                "sign": "",
+                "thumb": "",
+                "type": 4,
+                "hashinfo": "null",
+                "hash_info": null,
+                "raw_url": "http://127.0.0.1:5244/p/local/Alist%20V3.md",
+                "readme": "",
+                "header": "",
+                "provider": "Local",
+                "related": null
+            }
+        }
+        """
+        if resp is None:
+            logging.warning(f"请求获取文件 {path} 失败，无法连接alist服务")
+            return
+        if resp.status_code != 200:
+            logging.warning(f"请求获取文件 {path} 失败，状态码：{resp.status_code}")
+            return
+
+        result = resp.json()
+        if result["code"] != 200:
+            logging.debug(f'获取文件 {path} 失败，错误信息：{result["message"]}')
+            return
+
+        return schemas.FileItem(
+            storage=self.schema.value,
+            type="dir" if result["data"]["is_dir"] else "file",
+            path=path.as_posix() + ("/" if result["data"]["is_dir"] else ""),
+            name=result["data"]["name"],
+            basename=Path(result["data"]["name"]).stem,
+            extension=Path(result["data"]["name"]).suffix[1:],
+            size=result["data"]["size"],
+            modify_time=self.__parse_timestamp(result["data"]["modified"]),
+            thumbnail=result["data"]["thumb"],
+        )
+
+    def get_parent(self, fileitem: schemas.FileItem) -> Optional[schemas.FileItem]:
+        """
+        获取父目录
+        """
+        return self.get_folder(Path(fileitem.path).parent)
+
+    def delete(self, fileitem: schemas.FileItem) -> bool:
+        """
+        删除文件
+        """
+        resp: Response = RequestUtils(
+            headers=self.__get_header_with_token()
+        ).post_res(
+            self.__get_api_url("/api/fs/remove"),
+            json={
+                "dir": Path(fileitem.path).parent.as_posix(),
+                "names": [fileitem.name],
+            },
+        )
+        """
+        {
+            "names": [
+                "string"
+            ],
+            "dir": "string"
+        }
+        ======================================
+        {
+            "code": 200,
+            "message": "success",
+            "data": null
+        }
+        """
+        if resp is None:
+            logging.warning(f"请求删除文件 {fileitem.path} 失败，无法连接alist服务")
+            return False
+        if resp.status_code != 200:
+            logging.warning(
+                f"请求删除文件 {fileitem.path} 失败，状态码：{resp.status_code}"
+            )
+            return False
+
+        result = resp.json()
+        if result["code"] != 200:
+            logging.warning(
+                f'删除文件 {fileitem.path} 失败，错误信息：{result["message"]}'
+            )
+            return False
+        return True
+
+    def rename(self, fileitem: schemas.FileItem, name: str) -> bool:
+        """
+        重命名文件
+        """
+        resp: Response = RequestUtils(
+            headers=self.__get_header_with_token()
+        ).post_res(
+            self.__get_api_url("/api/fs/rename"),
+            json={
+                "name": name,
+                "path": fileitem.path,
+            },
+        )
+        """
+        {
+            "name": "test3",
+            "path": "/阿里云盘/test2"
+        }
+        ======================================
+        {
+            "code": 200,
+            "message": "success",
+            "data": null
+        }
+        """
+        if not resp:
+            logging.warning(f"请求重命名文件 {fileitem.path} 失败，无法连接alist服务")
+            return False
+        if resp.status_code != 200:
+            logging.warning(
+                f"请求重命名文件 {fileitem.path} 失败，状态码：{resp.status_code}"
+            )
+            return False
+
+        result = resp.json()
+        if result["code"] != 200:
+            logging.warning(
+                f'重命名文件 {fileitem.path} 失败，错误信息：{result["message"]}'
+            )
+            return False
+
+        return True
+
+    def download(
+            self,
+            fileitem: schemas.FileItem,
+            path: Path = None,
+            password: str = "",
+    ) -> Optional[Path]:
+        """
+        下载文件，保存到本地，返回本地临时文件地址
+        :param fileitem: 文件项
+        :param path: 文件保存路径
+        :param password: 文件密码
+        """
+        resp: Response = RequestUtils(
+            headers=self.__get_header_with_token()
+        ).post_res(
+            self.__get_api_url("/api/fs/get"),
+            json={
+                "path": fileitem.path,
+                "password": password,
+                "page": 1,
+                "per_page": 0,
+                "refresh": False,
+            },
+        )
+        """
+        {
+            "code": 200,
+            "message": "success",
+            "data": {
+                "name": "[ANi]輝夜姬想讓人告白～天才們的戀愛頭腦戰～[01][1080P][Baha][WEB-DL].mp4",
+                "size": 924933111,
+                "is_dir": false,
+                "modified": "1970-01-01T00:00:00Z",
+                "created": "1970-01-01T00:00:00Z",
+                "sign": "1v0xkMQz_uG8fkEOQ7-l58OnbB-g4GkdBlUBcrsApCQ=:0",
+                "thumb": "",
+                "type": 2,
+                "hashinfo": "null",
+                "hash_info": null,
+                "raw_url": "xxxxxx",
+                "readme": "",
+                "header": "",
+                "provider": "UrlTree",
+                "related": null
+            }
+        }
+        """
+        if not resp:
+            logging.warning(f"请求获取文件 {path} 失败，无法连接alist服务")
+            return
+        if resp.status_code != 200:
+            logging.warning(f"请求获取文件 {path} 失败，状态码：{resp.status_code}")
+            return
+
+        result = resp.json()
+        if result["code"] != 200:
+            logging.warning(f'获取文件 {path} 失败，错误信息：{result["message"]}')
+            return
+
+        if result["data"]["raw_url"]:
+            download_url = result["data"]["raw_url"]
+        else:
+            download_url = UrlUtils.adapt_request_url(self.__get_base_url, f"/d{fileitem.path}")
+            if result["data"]["sign"]:
+                download_url = download_url + "?sign=" + result["data"]["sign"]
+
+        resp = RequestUtils(
+            headers=self.__get_header_with_token()
+        ).get_res(download_url)
+
+        if not path:
+            new_path = settings.TEMP_PATH / fileitem.name
+        else:
+            new_path = path / fileitem.name
+
+        with open(new_path, "wb") as f:
+            f.write(resp.content)
+
+        if new_path.exists():
+            return new_path
+        return None
+
+    def upload(
+            self, fileitem: schemas.FileItem, path: Path, new_name: str = None, task: bool = False
+    ) -> Optional[schemas.FileItem]:
+        """
+        上传文件
+        :param fileitem: 上传目录项
+        :param path: 本地文件路径
+        :param new_name: 上传后文件名
+        :param task: 是否为任务，默认为False避免未完成上传时对文件进行操作
+        """
+        encoded_path = UrlUtils.quote((Path(fileitem.path) / path.name).as_posix())
+        headers = self.__get_header_with_token()
+        headers.setdefault("Content-Type", "application/octet-stream")
+        headers.setdefault("As-Task", str(task).lower())
+        headers.setdefault("File-Path", encoded_path)
+        with open(path, "rb") as f:
+            resp: Response = RequestUtils(headers=headers).put_res(
+                self.__get_api_url("/api/fs/put"),
+                data=f,
+            )
+
+        if resp.status_code != 200:
+            logging.warning(f"请求上传文件 {path} 失败，状态码：{resp.status_code}")
+            return
+
+        new_item = self.get_item(Path(fileitem.path) / path.name)
+        if new_item and new_name and new_name != path.name:
+            if self.rename(new_item, new_name):
+                return self.get_item(Path(new_item.path).with_name(new_name))
+
+        return new_item
+
+    def detail(self, fileitem: schemas.FileItem) -> Optional[schemas.FileItem]:
+        """
+        获取文件详情
+        """
+        return self.get_item(Path(fileitem.path))
+
+    def copy(self, fileitem: schemas.FileItem, path: Path, new_name: str) -> bool:
+        """
+        复制文件
+        :param fileitem: 文件项
+        :param path: 目标目录
+        :param new_name: 新文件名
+        """
+        resp: Response = RequestUtils(
+            headers=self.__get_header_with_token()
+        ).post_res(
+            self.__get_api_url("/api/fs/copy"),
+            json={
+                "src_dir": Path(fileitem.path).parent.as_posix(),
+                "dst_dir": path.as_posix(),
+                "names": [fileitem.name],
+            },
+        )
+        """
+        {
+            "src_dir": "string",
+            "dst_dir": "string",
+            "names": [
+                "string"
+            ]
+        }
+        ======================================
+        {
+            "code": 200,
+            "message": "success",
+            "data": null
+        }
+        """
+        if resp is None:
+            logging.warning(
+                f"请求复制文件 {fileitem.path} 失败，无法连接alist服务"
+            )
+            return False
+        if resp.status_code != 200:
+            logging.warning(
+                f"请求复制文件 {fileitem.path} 失败，状态码：{resp.status_code}"
+            )
+            return False
+
+        result = resp.json()
+        if result["code"] != 200:
+            logging.warning(
+                f'复制文件 {fileitem.path} 失败，错误信息：{result["message"]}'
+            )
+            return False
+        # 重命名
+        if fileitem.name != new_name:
+            self.rename(
+                self.get_item(path / fileitem.name), new_name
+            )
+        return True
+
+    def move(self, fileitem: schemas.FileItem, path: Path, new_name: str) -> bool:
+        """
+        移动文件
+        :param fileitem: 文件项
+        :param path: 目标目录
+        :param new_name: 新文件名
+        """
+        # 先重命名
+        if fileitem.name != new_name:
+            self.rename(fileitem, new_name)
+        resp: Response = RequestUtils(
+            headers=self.__get_header_with_token()
+        ).post_res(
+            self.__get_api_url("/api/fs/move"),
+            json={
+                "src_dir": Path(fileitem.path).parent.as_posix(),
+                "dst_dir": path.as_posix(),
+                "names": [new_name],
+            },
+        )
+        """
+        {
+            "src_dir": "string",
+            "dst_dir": "string",
+            "names": [
+                "string"
+            ]
+        }
+        ======================================
+        {
+            "code": 200,
+            "message": "success",
+            "data": null
+        }
+        """
+        if resp is None:
+            logging.warning(
+                f"请求移动文件 {fileitem.path} 失败，无法连接alist服务"
+            )
+            return False
+        if resp.status_code != 200:
+            logging.warning(
+                f"请求移动文件 {fileitem.path} 失败，状态码：{resp.status_code}"
+            )
+            return False
+
+        result = resp.json()
+        if result["code"] != 200:
+            logging.warning(
+                f'移动文件 {fileitem.path} 失败，错误信息：{result["message"]}'
+            )
+            return False
+        return True
+
+    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]:
+        """
+        存储使用情况
+        """
+        pass
+
+    def snapshot(self, path: Path) -> Dict[str, float]:
+        """
+        快照文件系统，输出所有层级文件信息（不含目录）
+        """
+        files_info = {}
+
+        def __snapshot_file(_fileitm: schemas.FileItem):
+            """
+            递归获取文件信息
+            """
+            if _fileitm.type == "dir":
+                for sub_file in self.list(_fileitm):
+                    __snapshot_file(sub_file)
+            else:
+                files_info[_fileitm.path] = _fileitm.size
+
+        fileitem = self.get_item(path)
+        if not fileitem:
+            return {}
+
+        __snapshot_file(fileitem)
+
+        return files_info
+
+    @staticmethod
+    def __parse_timestamp(time_str: str) -> float:
+        """
+        直接使用 ISO 8601 格式解析时间
+        """
+        return datetime.fromisoformat(time_str).timestamp()

app/modules/filemanager/storages/local.py

@@ -25,13 +25,19 @@ class LocalStorage(StorageBase):
         "softlink": "软链接"
     }
 
+    def init_storage(self):
+        """
+        初始化
+        """
+        pass
+
     def check(self) -> bool:
         """
         检查存储是否可用
         """
         return True
 
-    def __get_fileitem(self, path: Path):
+    def __get_fileitem(self, path: Path) -> schemas.FileItem:
         """
         获取文件项
         """
@@ -46,7 +52,7 @@ class LocalStorage(StorageBase):
             modify_time=path.stat().st_mtime,
         )
 
-    def __get_diritem(self, path: Path):
+    def __get_diritem(self, path: Path) -> schemas.FileItem:
         """
         获取目录项
         """
@@ -109,6 +115,8 @@ class LocalStorage(StorageBase):
     def create_folder(self, fileitem: schemas.FileItem, name: str) -> Optional[schemas.FileItem]:
         """
         创建目录
+        :param fileitem: 父目录
+        :param name: 目录名
         """
         if not fileitem.path:
             return None
@@ -183,28 +191,20 @@ class LocalStorage(StorageBase):
         """
         return Path(fileitem.path)
 
-    def upload(self, fileitem: schemas.FileItem, path: Path) -> Optional[schemas.FileItem]:
+    def upload(self, fileitem: schemas.FileItem, path: Path, new_name: str = None) -> Optional[schemas.FileItem]:
         """
         上传文件
+        :param fileitem: 上传目录项
+        :param path: 本地文件路径
+        :param new_name: 上传后文件名
         """
         dir_path = Path(fileitem.path)
-        target_path = dir_path / path.name
+        target_path = dir_path / (new_name or path.name)
         code, message = SystemUtils.move(path, target_path)
         if code != 0:
             logger.error(f"移动文件失败：{message}")
             return None
-        return self.__get_diritem(target_path)
-
-    def copy(self, fileitem: schemas.FileItem, target_file: Path) -> bool:
-        """
-        复制文件
-        """
-        file_path = Path(fileitem.path)
-        code, message = SystemUtils.copy(file_path, target_file)
-        if code != 0:
-            logger.error(f"复制文件失败：{message}")
-            return False
-        return True
+        return self.get_item(target_path)
 
     def link(self, fileitem: schemas.FileItem, target_file: Path) -> bool:
         """
@@ -228,12 +228,29 @@ class LocalStorage(StorageBase):
             return False
         return True
 
-    def move(self, fileitem: schemas.FileItem, target: Path) -> bool:
+    def copy(self, fileitem: schemas.FileItem, path: Path, new_name: str) -> bool:
         """
-        移动文件
+        复制文件
+        :param fileitem: 文件项
+        :param path: 目标目录
+        :param new_name: 新文件名
         """
         file_path = Path(fileitem.path)
-        code, message = SystemUtils.move(file_path, target)
+        code, message = SystemUtils.copy(file_path, path / new_name)
+        if code != 0:
+            logger.error(f"复制文件失败：{message}")
+            return False
+        return True
+
+    def move(self, fileitem: schemas.FileItem, path: Path, new_name: str) -> bool:
+        """
+        移动文件
+        :param fileitem: 文件项
+        :param path: 目标目录
+        :param new_name: 新文件名
+        """
+        file_path = Path(fileitem.path)
+        code, message = SystemUtils.move(file_path, path / new_name)
         if code != 0:
             logger.error(f"移动文件失败：{message}")
             return False

app/modules/filemanager/storages/rclone.py

@@ -1,4 +1,3 @@
-import copy
 import json
 import subprocess
 from pathlib import Path
@@ -27,6 +26,12 @@ class Rclone(StorageBase):
         "copy": "复制"
     }
 
+    def init_storage(self):
+        """
+        初始化
+        """
+        pass
+
     def set_config(self, conf: dict):
         """
         设置配置
@@ -39,7 +44,7 @@ class Rclone(StorageBase):
         path = Path(filepath)
         if not path.parent.exists():
             path.parent.mkdir(parents=True)
-        path.write_text(conf.get('content'))
+        path.write_text(conf.get('content'), encoding='utf-8')
 
     @staticmethod
     def __get_hidden_shell():
@@ -51,21 +56,6 @@ class Rclone(StorageBase):
         else:
             return None
 
-    def __get_fileitem(self, path: Path):
-        """
-        获取文件项
-        """
-        return schemas.FileItem(
-            storage=self.schema.value,
-            type="file",
-            path=str(path).replace("\\", "/"),
-            name=path.name,
-            basename=path.stem,
-            extension=path.suffix[1:],
-            size=path.stat().st_size,
-            modify_time=path.stat().st_mtime,
-        )
-
     def __get_rcloneitem(self, item: dict, parent: str = "/") -> schemas.FileItem:
         """
         获取rclone文件项
@@ -76,7 +66,7 @@ class Rclone(StorageBase):
             return schemas.FileItem(
                 storage=self.schema.value,
                 type="dir",
-                path=f"{parent}{item.get('Name')}",
+                path=f"{parent}{item.get('Name')}" + "/",
                 name=item.get("Name"),
                 basename=item.get("Name"),
                 modify_time=StringUtils.str_to_timestamp(item.get("ModTime"))
@@ -133,20 +123,19 @@ class Rclone(StorageBase):
     def create_folder(self, fileitem: schemas.FileItem, name: str) -> Optional[schemas.FileItem]:
         """
         创建目录
+        :param fileitem: 父目录
+        :param name: 目录名
         """
         try:
             retcode = subprocess.run(
                 [
                     'rclone', 'mkdir',
-                    f'MP:{fileitem.path}/{name}'
+                    f'MP:{Path(fileitem.path) / name}'
                 ],
                 startupinfo=self.__get_hidden_shell()
             ).returncode
             if retcode == 0:
-                ret_fileitem = copy.deepcopy(fileitem)
-                ret_fileitem.path = f"{fileitem.path}/{name}/"
-                ret_fileitem.name = name
-                return ret_fileitem
+                return self.get_item(Path(fileitem.path) / name)
         except Exception as err:
             logger.error(f"rclone创建目录失败：{err}")
         return None
@@ -160,13 +149,17 @@ class Rclone(StorageBase):
             """
             查找下级目录中匹配名称的目录
             """
-            for sub_file in self.list(_fileitem):
-                if sub_file.type != "dir":
+            for sub_folder in self.list(_fileitem):
+                if sub_folder.type != "dir":
                     continue
-                if sub_file.name == _name:
-                    return sub_file
+                if sub_folder.name == _name:
+                    return sub_folder
             return None
 
+        # 是否已存在
+        folder = self.get_item(path)
+        if folder:
+            return folder
         # 逐级查找和创建目录
         fileitem = schemas.FileItem(path="/")
         for part in path.parts:
@@ -191,16 +184,19 @@ class Rclone(StorageBase):
             ret = subprocess.run(
                 [
                     'rclone', 'lsjson',
-                    f'MP:{path}'
+                    f'MP:{path.parent}'
                 ],
                 capture_output=True,
                 startupinfo=self.__get_hidden_shell()
             )
             if ret.returncode == 0:
                 items = json.loads(ret.stdout)
-                return self.__get_rcloneitem(items[0])
+                for item in items:
+                    if item.get("Name") == path.name:
+                        return self.__get_rcloneitem(item, parent=str(path.parent) + "/")
+            return None
         except Exception as err:
-            logger.error(f"rclone获取文件失败：{err}")
+            logger.debug(f"rclone获取文件项失败：{err}")
         return None
 
     def delete(self, fileitem: schemas.FileItem) -> bool:
@@ -230,7 +226,7 @@ class Rclone(StorageBase):
                 [
                     'rclone', 'moveto',
                     f'MP:{fileitem.path}',
-                    f'MP:{Path(fileitem.path).parent}/{name}'
+                    f'MP:{Path(fileitem.path).parent / name}'
                 ],
                 startupinfo=self.__get_hidden_shell()
             ).returncode
@@ -260,21 +256,25 @@ class Rclone(StorageBase):
             logger.error(f"rclone复制文件失败：{err}")
         return None
 
-    def upload(self, fileitem: schemas.FileItem, path: Path) -> Optional[schemas.FileItem]:
+    def upload(self, fileitem: schemas.FileItem, path: Path, new_name: str = None) -> Optional[schemas.FileItem]:
         """
         上传文件
+        :param fileitem: 上传目录项
+        :param path: 本地文件路径
+        :param new_name: 上传后文件名
         """
         try:
+            new_path = Path(fileitem.path) / (new_name or path.name)
             retcode = subprocess.run(
                 [
                     'rclone', 'copyto',
                     str(path),
-                    f'MP:{Path(fileitem.path) / path.name}'
+                    f'MP:{new_path}'
                 ],
                 startupinfo=self.__get_hidden_shell()
             ).returncode
             if retcode == 0:
-                return self.__get_fileitem(path)
+                return self.get_item(new_path)
         except Exception as err:
             logger.error(f"rclone上传文件失败：{err}")
         return None
@@ -299,16 +299,19 @@ class Rclone(StorageBase):
             logger.error(f"rclone获取文件详情失败：{err}")
         return None
 
-    def move(self, fileitem: schemas.FileItem, target: Path) -> bool:
+    def move(self, fileitem: schemas.FileItem, path: Path, new_name: str) -> bool:
         """
-        移动文件，target_file格式：rclone:path
+        移动文件
+        :param fileitem: 文件项
+        :param path: 目标目录
+        :param new_name: 新文件名
         """
         try:
             retcode = subprocess.run(
                 [
                     'rclone', 'moveto',
                     f'MP:{fileitem.path}',
-                    f'MP:{target}'
+                    f'MP:{path / new_name}'
                 ],
                 startupinfo=self.__get_hidden_shell()
             ).returncode
@@ -318,8 +321,27 @@ class Rclone(StorageBase):
             logger.error(f"rclone移动文件失败：{err}")
         return False
 
-    def copy(self, fileitem: schemas.FileItem, target_file: Path) -> bool:
-        pass
+    def copy(self, fileitem: schemas.FileItem, path: Path, new_name: str) -> bool:
+        """
+        复制文件
+        :param fileitem: 文件项
+        :param path: 目标目录
+        :param new_name: 新文件名
+        """
+        try:
+            retcode = subprocess.run(
+                [
+                    'rclone', 'copyto',
+                    f'MP:{fileitem.path}',
+                    f'MP:{path / new_name}'
+                ],
+                startupinfo=self.__get_hidden_shell()
+            ).returncode
+            if retcode == 0:
+                return True
+        except Exception as err:
+            logger.error(f"rclone复制文件失败：{err}")
+        return False
 
     def link(self, fileitem: schemas.FileItem, target_file: Path) -> bool:
         pass

app/modules/filemanager/storages/u115.py

@@ -1,12 +1,7 @@
-import base64
-import subprocess
 from pathlib import Path
 from typing import Optional, Tuple, List
 
-import oss2
-import py115
-from py115 import Cloud
-from py115.types import LoginTarget, QrcodeSession, QrcodeStatus, Credential
+from p115 import P115Client, P115Path
 
 from app import schemas
 from app.core.config import settings
@@ -27,57 +22,54 @@ class U115Pan(StorageBase, metaclass=Singleton):
 
     # 支持的整理方式
     transtype = {
-        "move": "移动"
+        "move": "移动",
+        "copy": "复制"
     }
 
-    cloud: Optional[Cloud] = None
-    _session: QrcodeSession = None
+    # 115二维码登录地址
+    qrcode_url = "https://qrcodeapi.115.com/api/1.0/web/1.0/token/"
+    # 115登录状态检查
+    login_check_url = "https://qrcodeapi.115.com/get/status/"
+    # 115登录完成 alipaymini
+    login_done_api = f"https://passportapi.115.com/app/1.0/alipaymini/1.0/login/qrcode/"
 
-    # 是否有aria2c
-    _has_aria2c: bool = False
+    client: P115Client = None
+    session_info: dict = None
 
     def __init__(self):
         super().__init__()
-        try:
-            subprocess.run(['aria2c', '-h'], capture_output=True)
-            self._has_aria2c = True
-            logger.debug('发现 aria2c, 将使用 aria2c 下载文件')
-        except FileNotFoundError:
-            logger.debug('未发现 aria2c')
-            self._has_aria2c = False
+        self.init_storage()
 
-    def __init_cloud(self) -> bool:
+    def init_storage(self):
         """
         初始化Cloud
         """
-        credential = self.__credential
-        if not credential:
-            logger.warn("115未登录，请先登录！")
-            return False
+        if not self.__credential:
+            return
         try:
-            if not self.cloud:
-                self.cloud = py115.connect(credential)
+            self.client = P115Client(self.__credential, app="alipaymini",
+                                     check_for_relogin=False, console_qrcode=False)
         except Exception as err:
-            logger.error(f"115连接失败，请重新扫码登录：{str(err)}")
+            logger.error(f"115连接失败，请重新登录：{str(err)}")
             self.__clear_credential()
-            return False
-        return True
 
     @property
-    def __credential(self) -> Optional[Credential]:
+    def __credential(self) -> Optional[str]:
         """
-        获取已保存的115认证参数
+        获取已保存的115 Cookie
         """
-        cookie_dict = self.get_config()
-        if not cookie_dict:
+        conf = self.get_config()
+        if not conf:
             return None
-        return Credential.from_dict(cookie_dict.dict().get("config"))
+        if not conf.config:
+            return None
+        return conf.config.get("cookie")
 
-    def __save_credential(self, credential: Credential):
+    def __save_credential(self, credential: dict):
         """
         设置115认证参数
         """
-        self.set_config(credential.to_dict())
+        self.set_config(credential)
 
     def __clear_credential(self):
         """
@@ -89,62 +81,75 @@ class U115Pan(StorageBase, metaclass=Singleton):
         """
         生成二维码
         """
-        try:
-            self.cloud = py115.connect()
-            self._session = self.cloud.qrcode_login(LoginTarget.Web)
-            image_bin = self._session.image_data
-            if not image_bin:
+        res = RequestUtils(timeout=10).get_res(self.qrcode_url)
+        if res:
+            self.session_info = res.json().get("data")
+            qrcode_content = self.session_info.pop("qrcode")
+            if not qrcode_content:
                 logger.warn("115生成二维码失败：未获取到二维码数据！")
-                return None
-            # 转换为base64图片格式
-            image_base64 = base64.b64encode(image_bin).decode()
+                return {}, ""
             return {
-                "codeContent": f"data:image/jpeg;base64,{image_base64}"
+                "codeContent": qrcode_content
             }, ""
-        except Exception as e:
-            logger.warn(f"115生成二维码失败：{str(e)}")
-            return {}, f"115生成二维码失败：{str(e)}"
+        elif res is not None:
+            return {}, f"115生成二维码失败：{res.status_code} - {res.reason}"
+        return {}, f"115生成二维码失败：无法连接！"
 
     def check_login(self) -> Optional[Tuple[dict, str]]:
         """
         二维码登录确认
         """
-        if not self._session:
+        if not self.session_info:
             return {}, "请先生成二维码！"
         try:
-            if not self.cloud:
-                return {}, "请先生成二维码！"
-            status = self.cloud.qrcode_poll(self._session)
-            if status == QrcodeStatus.Done:
-                # 确认完成，保存认证信息
-                self.__save_credential(self.cloud.export_credentail())
-                result = {
-                    "status": 1,
-                    "tip": "登录成功！"
-                }
-            elif status == QrcodeStatus.Waiting:
-                result = {
-                    "status": 0,
-                    "tip": "请使用微信或115客户端扫码"
-                }
-            elif status == QrcodeStatus.Expired:
-                result = {
-                    "status": -1,
-                    "tip": "二维码已过期，请重新刷新！"
-                }
-                self.cloud = None
-            elif status == QrcodeStatus.Failed:
-                result = {
-                    "status": -2,
-                    "tip": "登录失败，请重试！"
-                }
-                self.cloud = None
-            else:
-                result = {
-                    "status": -3,
-                    "tip": "未知错误，请重试！"
-                }
-                self.cloud = None
+            resp = RequestUtils(timeout=10).get_res(self.login_check_url, params=self.session_info)
+            if not resp:
+                return {}, "115登录确认失败：无法连接！"
+            result = resp.json()
+            match result["data"].get("status"):
+                case 0:
+                    result = {
+                        "status": 0,
+                        "tip": "请使用微信或115客户端扫码"
+                    }
+                case 1:
+                    result = {
+                        "status": 1,
+                        "tip": "已扫码"
+                    }
+                case 2:
+                    # 确认完成，保存认证信息
+                    resp = RequestUtils(timeout=10).post_res(self.login_done_api,
+                                                             data={"account": self.session_info.get("uid")})
+                    if not resp:
+                        return {}, "115登录确认失败：无法连接！"
+                    if resp:
+                        # 保存认证信息
+                        result = resp.json()
+                        cookie_dict = result["data"]["cookie"]
+                        cookie_str = "; ".join([f"{k}={v}" for k, v in cookie_dict.items()])
+                        cookie_dict.update({"cookie": cookie_str})
+                        self.__save_credential(cookie_dict)
+                        self.init_storage()
+                    result = {
+                        "status": 2,
+                        "tip": "登录成功！"
+                    }
+                case -1:
+                    result = {
+                        "status": -1,
+                        "tip": "二维码已过期，请重新刷新！"
+                    }
+                case -2:
+                    result = {
+                        "status": -2,
+                        "tip": "登录失败，请重试！"
+                    }
+                case _:
+                    result = {
+                        "status": -3,
+                        "tip": "未知错误，请重试！"
+                    }
             return result, ""
         except Exception as e:
             return {}, f"115登录确认失败：{str(e)}"
@@ -153,10 +158,12 @@ class U115Pan(StorageBase, metaclass=Singleton):
         """
         获取存储空间
         """
-        if not self.__init_cloud():
+        if not self.client:
             return None
         try:
-            return self.cloud.storage().space()
+            usage = self.client.fs.space_summury()
+            if usage:
+                return usage['rt_space_info']['all_total']['size'], usage['rt_space_info']['all_remain']['size']
         except Exception as e:
             logger.error(f"115获取存储空间失败：{str(e)}")
         return None
@@ -165,31 +172,27 @@ class U115Pan(StorageBase, metaclass=Singleton):
         """
         检查存储是否可用
         """
-        return True if self.list(schemas.FileItem(
-            fileid="0"
-        )) else False
+        return True if self.list(schemas.FileItem()) else False
 
     def list(self, fileitem: schemas.FileItem) -> Optional[List[schemas.FileItem]]:
         """
         浏览文件
         """
-        if not self.__init_cloud():
+        if not self.client:
             return []
         try:
             if fileitem.type == "file":
                 return [fileitem]
-            items = self.cloud.storage().list(dir_id=fileitem.fileid)
+            items: List[P115Path] = self.client.fs.list(fileitem.path)
             return [schemas.FileItem(
                 storage=self.schema.value,
-                fileid=item.file_id,
-                parent_fileid=item.parent_id,
-                type="dir" if item.is_dir else "file",
-                path=f"{fileitem.path}{item.name}" + ("/" if item.is_dir else ""),
+                type="dir" if item.is_dir() else "file",
+                path=item.path + ("/" if item.is_dir() else ""),
                 name=item.name,
-                size=item.size,
-                extension=Path(item.name).suffix[1:],
-                modify_time=item.modified_time.timestamp() if item.modified_time else 0,
-                pickcode=item.pickcode
+                basename=item.stem,
+                size=item.stat().st_size,
+                extension=item.suffix[1:] if not item.is_dir() else None,
+                modify_time=item.stat().st_mtime
             ) for item in items if item]
         except Exception as e:
             logger.error(f"115浏览文件失败：{str(e)}")
@@ -199,20 +202,18 @@ class U115Pan(StorageBase, metaclass=Singleton):
         """
         创建目录
         """
-        if not self.__init_cloud():
+        if not self.client:
             return None
         try:
-            result = self.cloud.storage().make_dir(fileitem.fileid, name)
+            result = self.client.fs.makedirs(Path(fileitem.path) / name, exist_ok=True)
             if result:
                 return schemas.FileItem(
                     storage=self.schema.value,
-                    fileid=result.file_id,
-                    parent_fileid=result.parent_id,
                     type="dir",
-                    path=f"{fileitem.path}{name}/",
+                    path=f"{result.path}/",
                     name=name,
-                    modify_time=result.modified_time.timestamp() if result.modified_time else 0,
-                    pickcode=result.pickcode
+                    basename=Path(result.name).stem,
+                    modify_time=result.mtime
                 )
         except Exception as e:
             logger.error(f"115创建目录失败：{str(e)}")
@@ -222,73 +223,86 @@ class U115Pan(StorageBase, metaclass=Singleton):
         """
         根据文件路程获取目录，不存在则创建
         """
-
-        def __find_dir(_fileitem: schemas.FileItem, _name: str) -> Optional[schemas.FileItem]:
-            """
-            查找下级目录中匹配名称的目录
-            """
-            for sub_file in self.list(_fileitem):
-                if sub_file.type != "dir":
-                    continue
-                if sub_file.name == _name:
-                    return sub_file
+        if not self.client:
             return None
-
-        # 逐级查找和创建目录
-        fileitem = schemas.FileItem(fileid="0")
-        for part in path.parts:
-            if part == "/":
-                continue
-            dir_file = __find_dir(fileitem, part)
-            if dir_file:
-                fileitem = dir_file
-            else:
-                dir_file = self.create_folder(fileitem, part)
-                if not dir_file:
-                    logger.warn(f"115创建目录 {fileitem.path}{part} 失败!")
-                    return None
-                fileitem = dir_file
-        return fileitem if fileitem.fileid != "0" else None
+        folder = self.get_item(path)
+        if folder:
+            return folder
+        try:
+            result = self.client.fs.makedirs(path, exist_ok=True)
+            if result:
+                return schemas.FileItem(
+                    storage=self.schema.value,
+                    type="dir",
+                    path=result.path + "/",
+                    name=result.name,
+                    basename=Path(result.name).stem,
+                    modify_time=result.mtime
+                )
+        except Exception as e:
+            logger.error(f"115获取目录失败：{str(e)}")
+        return None
 
     def get_item(self, path: Path) -> Optional[schemas.FileItem]:
         """
         获取文件或目录，不存在返回None
         """
-
-        def __find_item(_fileitem: schemas.FileItem, _name: str) -> Optional[schemas.FileItem]:
-            """
-            查找下级目录中匹配名称的目录或文件
-            """
-            for sub_file in self.list(_fileitem):
-                if sub_file.name == _name:
-                    return sub_file
+        if not self.client:
             return None
-
-        # 逐级查找
-        fileitem = schemas.FileItem(fileid="0")
-        for part in path.parts:
-            if part == "/":
-                continue
-            item = __find_item(fileitem, part)
-            if not item:
+        try:
+            try:
+                item = self.client.fs.attr(path)
+            except FileNotFoundError:
                 return None
-            fileitem = item
-        return fileitem
+            if item:
+                return schemas.FileItem(
+                    storage=self.schema.value,
+                    type="dir" if item.is_directory else "file",
+                    path=item.path + ("/" if item.is_directory else ""),
+                    name=item.name,
+                    size=item.size,
+                    extension=Path(item.name).suffix[1:] if not item.is_directory else None,
+                    modify_time=item.mtime,
+                    thumbnail=item.get("thumb")
+                )
+        except Exception as e:
+            logger.info(f"115获取文件失败：{str(e)}")
+        return None
 
     def detail(self, fileitem: schemas.FileItem) -> Optional[schemas.FileItem]:
         """
         获取文件详情
         """
-        pass
+        if not self.client:
+            return None
+        try:
+            try:
+                item = self.client.fs.attr(fileitem.path)
+            except FileNotFoundError:
+                return None
+            if item:
+                return schemas.FileItem(
+                    storage=self.schema.value,
+                    type="dir" if item.is_directory else "file",
+                    path=item.path + ("/" if item.is_directory else ""),
+                    name=item.name,
+                    size=item.size,
+                    extension=Path(item.name).suffix[1:] if not item.is_directory else None,
+                    modify_time=item.mtime,
+                    thumbnail=item.get("thumb")
+                )
+        except Exception as e:
+            logger.error(f"115获取文件详情失败：{str(e)}")
+        return None
 
     def delete(self, fileitem: schemas.FileItem) -> bool:
         """
         删除文件
         """
-        if not self.__init_cloud():
+        if not self.client:
             return False
         try:
-            self.cloud.storage().delete(fileitem.fileid)
+            self.client.fs.remove(fileitem.path)
             return True
         except Exception as e:
             logger.error(f"115删除文件失败：{str(e)}")
@@ -298,10 +312,10 @@ class U115Pan(StorageBase, metaclass=Singleton):
         """
         重命名文件
         """
-        if not self.__init_cloud():
+        if not self.client:
             return False
         try:
-            self.cloud.storage().rename(fileitem.fileid, name)
+            self.client.fs.rename(fileitem.path, Path(fileitem.path).with_name(name))
             return True
         except Exception as e:
             logger.error(f"115重命名文件失败：{str(e)}")
@@ -311,89 +325,77 @@ class U115Pan(StorageBase, metaclass=Singleton):
         """
         获取下载链接
         """
-        if not self.__init_cloud():
+        if not self.client:
             return None
+        local_file = (path or settings.TEMP_PATH) / fileitem.name
         try:
-            ticket = self.cloud.storage().request_download(fileitem.pickcode)
-            if ticket:
-                path = (path or settings.TEMP_PATH) / fileitem.name
-                res = RequestUtils(headers=ticket.headers).get_res(ticket.url)
-                if res:
-                    with open(path, "wb") as f:
-                        f.write(res.content)
-                    return path
-            else:
-                logger.warn(f"{fileitem.path} 未获取到下载链接")
+            task = self.client.fs.download(fileitem.path, file=local_file)
+            if task:
+                return local_file
         except Exception as e:
-            logger.error(f"115下载失败：{str(e)}")
+            logger.error(f"115下载文件失败：{str(e)}")
         return None
 
-    def upload(self, fileitem: schemas.FileItem, path: Path) -> Optional[schemas.FileItem]:
+    def upload(self, fileitem: schemas.FileItem, path: Path, new_name: str = None) -> Optional[schemas.FileItem]:
         """
         上传文件
+        :param fileitem: 上传目录项
+        :param path: 本地文件路径
+        :param new_name: 上传后文件名
         """
-        if not self.__init_cloud():
+        if not self.client:
             return None
         try:
-            ticket = self.cloud.storage().request_upload(dir_id=fileitem.fileid, file_path=str(path))
-            if ticket is None:
-                logger.warn(f"115请求上传出错")
-                return None
-            elif ticket.is_done:
-                file_path = Path(fileitem.path) / path.name
-                logger.warn(f"115上传：{file_path} 文件已存在")
-                return self.get_item(file_path)
-            else:
-                auth = oss2.StsAuth(**ticket.oss_token)
-                bucket = oss2.Bucket(
-                    auth=auth,
-                    endpoint=ticket.oss_endpoint,
-                    bucket_name=ticket.bucket_name,
-                )
-                por = bucket.put_object_from_file(
-                    key=ticket.object_key,
-                    filename=str(path),
-                    headers=ticket.headers,
-                )
-                result = por.resp.response.json()
+            new_path = Path(fileitem.path) / (new_name or path.name)
+            with open(path, "rb") as f:
+                result = self.client.fs.upload(f, new_path)
                 if result:
-                    result_data = result.get('data')
-                    logger.info(f"115上传文件成功：{result_data.get('file_name')}")
                     return schemas.FileItem(
                         storage=self.schema.value,
-                        fileid=result_data.get('file_id'),
-                        parent_fileid=fileitem.fileid,
                         type="file",
-                        name=result_data.get('file_name'),
-                        basename=Path(result_data.get('file_name')).stem,
-                        path=f"{fileitem.path}{result_data.get('file_name')}",
-                        size=result_data.get('file_size'),
-                        extension=Path(result_data.get('file_name')).suffix[1:],
-                        pickcode=result_data.get('pickcode')
+                        path=str(path),
+                        name=result.name,
+                        basename=Path(result.name).stem,
+                        size=result.size,
+                        extension=Path(result.name).suffix[1:],
+                        modify_time=result.mtime
                     )
-                else:
-                    logger.warn(f"115上传文件失败：{por.resp.response.text}")
-                    return None
         except Exception as e:
             logger.error(f"115上传文件失败：{str(e)}")
         return None
 
-    def move(self, fileitem: schemas.FileItem, target: schemas.FileItem) -> bool:
+    def copy(self, fileitem: schemas.FileItem, path: Path, new_name: str) -> bool:
         """
-        移动文件
+        复制文件
+        :param fileitem: 文件项
+        :param path: 目标目录
+        :param new_name: 新文件名
         """
-        if not self.__init_cloud():
+        if not self.client:
             return False
         try:
-            self.cloud.storage().move(fileitem.fileid, target.fileid)
+            self.client.fs.copy(fileitem.path, path / new_name)
+            return True
+        except Exception as e:
+            logger.error(f"115复制文件失败：{str(e)}")
+        return False
+
+    def move(self, fileitem: schemas.FileItem, path: Path, new_name: str) -> bool:
+        """
+        移动文件
+        :param fileitem: 文件项
+        :param path: 目标目录
+        :param new_name: 新文件名
+        """
+        if not self.client:
+            return False
+        try:
+            self.client.fs.move(fileitem.path, path / new_name)
             return True
         except Exception as e:
             logger.error(f"115移动文件失败：{str(e)}")
         return False
 
-    def copy(self, fileitem: schemas.FileItem, target_file: Path) -> bool:
-        pass
-
     def link(self, fileitem: schemas.FileItem, target_file: Path) -> bool:
         pass
 
@@ -406,9 +408,9 @@ class U115Pan(StorageBase, metaclass=Singleton):
         """
         info = self.storage()
         if info:
-            total, used = info
+            total, free = info
             return schemas.StorageUsage(
                 total=total,
-                available=total - used
+                available=free
             )
         return schemas.StorageUsage()

app/modules/filter/__init__.py

@@ -7,7 +7,7 @@ from app.helper.rule import RuleHelper
 from app.log import logger
 from app.modules import _ModuleBase
 from app.modules.filter.RuleParser import RuleParser
-from app.schemas.types import ModuleType
+from app.schemas.types import ModuleType, OtherModulesType
 from app.utils.string import StringUtils
 
 
@@ -167,6 +167,13 @@ class FilterModule(_ModuleBase):
         """
         return ModuleType.Other
 
+    @staticmethod
+    def get_subtype() -> OtherModulesType:
+        """
+        获取模块子类型
+        """
+        return OtherModulesType.Filter
+
     @staticmethod
     def get_priority() -> int:
         """
@@ -185,13 +192,11 @@ class FilterModule(_ModuleBase):
 
     def filter_torrents(self, rule_groups: List[str],
                         torrent_list: List[TorrentInfo],
-                        season_episodes: Dict[int, list] = None,
                         mediainfo: MediaInfo = None) -> List[TorrentInfo]:
         """
         过滤种子资源
         :param rule_groups:  过滤规则组名称列表
         :param torrent_list:  资源列表
-        :param season_episodes:  季集数过滤 {season:[episodes]}
         :param mediainfo:  媒体信息
         :return: 过滤后的资源列表，添加资源优先级
         """
@@ -208,24 +213,18 @@ class FilterModule(_ModuleBase):
                 torrent_list = self.__filter_torrents(
                     rule_string=group.rule_string,
                     rule_name=group.name,
-                    torrent_list=torrent_list,
-                    season_episodes=season_episodes
-                )
+                    torrent_list=torrent_list
+                    )
         return torrent_list
 
     def __filter_torrents(self, rule_string: str, rule_name: str,
-                          torrent_list: List[TorrentInfo],
-                          season_episodes: Dict[int, list]) -> List[TorrentInfo]:
+                          torrent_list: List[TorrentInfo]) -> List[TorrentInfo]:
         """
         过滤种子
         """
         # 返回种子列表
         ret_torrents = []
         for torrent in torrent_list:
-            # 季集数过滤
-            if season_episodes \
-                    and not self.__match_season_episodes(torrent, season_episodes):
-                continue
             # 能命中优先级的才返回
             if not self.__get_order(torrent, rule_string):
                 logger.debug(f"种子 {torrent.site_name} - {torrent.title} {torrent.description} "
@@ -235,39 +234,6 @@ class FilterModule(_ModuleBase):
 
         return ret_torrents
 
-    @staticmethod
-    def __match_season_episodes(torrent: TorrentInfo, season_episodes: Dict[int, list]):
-        """
-        判断种子是否匹配季集数
-        """
-        # 匹配季
-        seasons = season_episodes.keys()
-        meta = MetaInfo(title=torrent.title, subtitle=torrent.description)
-        # 种子季
-        torrent_seasons = meta.season_list
-        if not torrent_seasons:
-            # 按第一季处理
-            torrent_seasons = [1]
-        # 种子集
-        torrent_episodes = meta.episode_list
-        if not set(torrent_seasons).issubset(set(seasons)):
-            # 种子季不在过滤季中
-            logger.debug(
-                f"种子 {torrent.site_name} - {torrent.title} 包含季 {torrent_seasons} 不是需要的季 {list(seasons)}")
-            return False
-        if not torrent_episodes:
-            # 整季按匹配处理
-            return True
-        if len(torrent_seasons) == 1:
-            need_episodes = season_episodes.get(torrent_seasons[0])
-            if need_episodes \
-                    and not set(torrent_episodes).intersection(set(need_episodes)):
-                # 单季集没有交集的不要
-                logger.debug(f"种子 {torrent.site_name} - {torrent.title} "
-                             f"集 {torrent_episodes} 没有需要的集：{need_episodes}")
-                return False
-        return True
-
     def __get_order(self, torrent: TorrentInfo, rule_str: str) -> Optional[TorrentInfo]:
         """
         获取种子匹配的规则优先级，值越大越优先，未匹配时返回None
@@ -359,6 +325,8 @@ class FilterModule(_ModuleBase):
         seeders = self.rule_set[rule_name].get("seeders")
         # FREE规则
         downloadvolumefactor = self.rule_set[rule_name].get("downloadvolumefactor")
+        # 发布时间规则
+        pubdate: str = self.rule_set[rule_name].get("publish_time")
         if includes and not any(re.search(r"%s" % include, content, re.IGNORECASE) for include in includes):
             # 未发现任何包含项
             logger.debug(f"种子 {torrent.site_name} - {torrent.title} 不包含任何项 {includes}")
@@ -385,6 +353,22 @@ class FilterModule(_ModuleBase):
                 logger.debug(
                     f"种子 {torrent.site_name} - {torrent.title} FREE值 {torrent.downloadvolumefactor} 不是 {downloadvolumefactor}")
                 return False
+        if pubdate:
+            # 种子发布时间
+            pub_minutes = torrent.pub_minutes()
+            # 发布时间规则
+            pub_times = [float(t) for t in pubdate.split("-")]
+            if len(pub_times) == 1:
+                # 发布时间小于规则
+                if pub_minutes < pub_times[0]:
+                    logger.debug(f"种子 {torrent.site_name} - {torrent.title} 发布时间 {pub_minutes} 小于 {pub_times[0]}")
+                    return False
+            else:
+                # 区间
+                if not (pub_times[0] <= pub_minutes <= pub_times[1]):
+                    logger.debug(f"种子 {torrent.site_name} - {torrent.title} 发布时间 {pub_minutes} 不在 {pub_times[0]}-{pub_times[1]} 时间区间")
+                    return False
+
         return True
 
     def __match_tmdb(self, tmdb: dict) -> bool:

app/modules/indexer/__init__.py

@@ -18,7 +18,7 @@ from app.modules.indexer.spider.tnode import TNodeSpider
 from app.modules.indexer.spider.torrentleech import TorrentLeech
 from app.modules.indexer.spider.yema import YemaSpider
 from app.schemas import SiteUserData
-from app.schemas.types import MediaType, ModuleType
+from app.schemas.types import MediaType, ModuleType, OtherModulesType
 from app.utils.string import StringUtils
 
 
@@ -47,6 +47,13 @@ class IndexerModule(_ModuleBase):
         """
         return ModuleType.Indexer
 
+    @staticmethod
+    def get_subtype() -> OtherModulesType:
+        """
+        获取模块子类型
+        """
+        return OtherModulesType.Indexer
+
     @staticmethod
     def get_priority() -> int:
         """
@@ -191,6 +198,7 @@ class IndexerModule(_ModuleBase):
                                     site_ua=site.get("ua"),
                                     site_proxy=site.get("proxy"),
                                     site_order=site.get("pri"),
+                                    site_downloader=site.get("downloader"),
                                     **result) for result in result_array]
             # 去重
             return __remove_duplicate(torrents)
@@ -199,7 +207,7 @@ class IndexerModule(_ModuleBase):
     def __spider_search(indexer: CommentedMap,
                         search_word: str = None,
                         mtype: MediaType = None,
-                        page: int = 0) -> (bool, List[dict]):
+                        page: int = 0) -> Tuple[bool, List[dict]]:
         """
         根据关键字搜索单个站点
         :param: indexer: 站点配置
@@ -274,6 +282,6 @@ class IndexerModule(_ModuleBase):
             leeching_size=site_obj.leeching_size,
             message_unread=site_obj.message_unread,
             message_unread_contents=site_obj.message_unread_contents or [],
-            updated_at=datetime.now().strftime('%Y-%m-%d'),
+            updated_day=datetime.now().strftime('%Y-%m-%d'),
             err_msg=site_obj.err_msg
         )

app/modules/indexer/parser/__init__.py

@@ -94,6 +94,7 @@ class SiteParserBase(metaclass=ABCMeta):
         # 未读消息
         self.message_unread = 0
         self.message_unread_contents = []
+        self.message_read_force = False
 
         # 全局附加请求头
         self._addition_headers = None
@@ -202,7 +203,7 @@ class SiteParserBase(metaclass=ABCMeta):
         :return:
         """
         unread_msg_links = []
-        if self.message_unread > 0:
+        if self.message_unread > 0 or self.message_read_force:
             links = {self._user_mail_unread_page, self._sys_mail_unread_page}
             for link in links:
                 if not link:
@@ -226,7 +227,7 @@ class SiteParserBase(metaclass=ABCMeta):
                     )
                 unread_msg_links.extend(msg_links)
         # 重新更新未读消息数（99999表示有消息但数量未知）
-        if self.message_unread == 99999:
+        if unread_msg_links and not self.message_unread:
             self.message_unread = len(unread_msg_links)
         # 解析未读消息内容
         for msg_link in unread_msg_links:
@@ -343,11 +344,9 @@ class SiteParserBase(metaclass=ABCMeta):
                     logger.warn(
                         f"{self._site_name} 检测到Cloudflare，请更新Cookie和UA")
                     return ""
-                if re.search(r"charset=\"?utf-8\"?", res.text, re.IGNORECASE):
-                    res.encoding = "utf-8"
-                else:
-                    res.encoding = res.apparent_encoding
-                return res.text
+                return RequestUtils.get_decoded_html_content(res,
+                                                             settings.ENCODING_DETECTION_PERFORMANCE_MODE,
+                                                             settings.ENCODING_DETECTION_MIN_CONFIDENCE)
 
         return ""
 

app/modules/indexer/parser/mtorrent.py

@@ -91,9 +91,7 @@ class MTorrentSiteUserInfo(SiteParserBase):
         self.download = int(user_info.get("memberCount", {}).get("downloaded") or '0')
         self.ratio = user_info.get("memberCount", {}).get("shareRate") or 0
         self.bonus = user_info.get("memberCount", {}).get("bonus") or 0
-        # 需要解析消息，但不确定消息条数
-        self.message_unread = 99999
-
+        self.message_read_force = True
         self._torrent_seeding_params = {
             "pageNumber": 1,
             "pageSize": 200,

app/modules/indexer/parser/nexus_php.py

@@ -43,7 +43,7 @@ class NexusPhpSiteUserInfo(SiteParserBase):
             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)
+            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])

app/modules/indexer/parser/nexus_rabbit.py

@@ -1,21 +1,60 @@
 # -*- coding: utf-8 -*-
+import re
 import json
 from typing import Optional
-
+from lxml import etree
+from urllib.parse import urljoin
 from app.log import logger
 from app.modules.indexer.parser import SiteSchema
-from app.modules.indexer.parser.nexus_php import NexusPhpSiteUserInfo
+from app.modules.indexer.parser import SiteParserBase
+from app.utils.string import StringUtils
 
 
-class NexusRabbitSiteUserInfo(NexusPhpSiteUserInfo):
+class NexusRabbitSiteUserInfo(SiteParserBase):
     schema = SiteSchema.NexusRabbit
 
     def _parse_site_page(self, html_text: str):
-        super()._parse_site_page(html_text)
-        self._torrent_seeding_page = f"getusertorrentlistajax.php?page=1&limit=5000000&type=seeding&uid={self.userid}"
-        self._torrent_seeding_headers = {"Accept": "application/json, text/javascript, */*; q=0.01"}
+        html_text = self._prepare_html_text(html_text)
 
-    def _parse_user_torrent_seeding_info(self, html_text: str, multi_page: bool = False) -> Optional[str]:
+        user_detail = re.search(r"user.php\?id=(\d+)", html_text)
+
+        if not (user_detail and user_detail.group().strip()):
+            return
+
+        self.userid = user_detail.group(1)
+        self._user_detail_page = f"user.php?id={self.userid}"
+
+        self._user_traffic_page = None
+
+        self._torrent_seeding_page = "api/general"
+        self._torrent_seeding_params = {
+            "page": 1,
+            "limit": 5000000,
+            "action": "userTorrentsList",
+            "data": {"type": "seeding", "id": int(self.userid)},
+        }
+        self._torrent_seeding_headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json, text/plain, */*",
+            "X-Requested-With": "XMLHttpRequest",  # 必须要加上这一条，不然返回的是空数据
+        }
+
+        self._user_mail_unread_page = None
+        self._sys_mail_unread_page = "api/general"
+        self._mail_unread_params = {
+            "page": 1,
+            "limit": 5000000,
+            "action": "getMessageIn",
+        }
+        self._mail_unread_headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json, text/plain, */*",
+            "X-Requested-With": "XMLHttpRequest",
+        }
+
+    def _parse_user_torrent_seeding_info(
+        self, html_text: str, multi_page: bool = False
+    ) -> Optional[str]:
         """
         做种相关信息
         :param html_text:
@@ -24,22 +63,112 @@ class NexusRabbitSiteUserInfo(NexusPhpSiteUserInfo):
         """
 
         try:
-            torrents = json.loads(html_text).get('data')
+            torrents = json.loads(html_text).get("data", [])
         except Exception as e:
             logger.error(f"解析做种信息失败: {str(e)}")
             return
 
-        page_seeding_size = 0
-        page_seeding_info = []
+        seeding_size = 0
+        seeding_info = []
 
-        page_seeding = len(torrents)
         for torrent in torrents:
-            seeders = int(torrent.get('seeders', 0))
-            size = int(torrent.get('size', 0))
-            page_seeding_size += int(torrent.get('size', 0))
+            seeders = int(torrent.get("seeders", 0))
+            size = StringUtils.num_filesize(torrent.get("size"))
+            seeding_size += size
+            seeding_info.append([seeders, size])
 
-            page_seeding_info.append([seeders, size])
+        self.seeding = len(torrents)
+        self.seeding_size = seeding_size
+        self.seeding_info = seeding_info
 
-        self.seeding += page_seeding
-        self.seeding_size += page_seeding_size
-        self.seeding_info.extend(page_seeding_info)
+    def _parse_message_unread_links(
+        self, html_text: str, msg_links: list
+    ) -> str | None:
+        unread_ids = []
+        try:
+            messages = json.loads(html_text).get("data", [])
+        except Exception as e:
+            logger.error(f"解析未读消息失败: {e}")
+            return
+        for msg in messages:
+            msg_id, msg_unread = msg.get("id"), msg.get("unread")
+            if not (msg_id and msg_unread) or msg_unread == "no":
+                continue
+            unread_ids.append(msg_id)
+            head, date, content = msg.get("subject"), msg.get("added"), msg.get("msg")
+            if head and date and content:
+                self.message_unread_contents.append((head, date, content))
+        self.message_unread = len(unread_ids)
+        if unread_ids:
+            self._get_page_content(
+                url=urljoin(self._base_url, "api/general?loading=true"),
+                params={"action": "readMessage", "data": {"ids": unread_ids}},
+                headers={
+                    "Content-Type": "application/json",
+                    "Accept": "application/json, text/plain, */*",
+                    "X-Requested-With": "XMLHttpRequest",
+                },
+            )
+        return None
+
+    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())
+
+    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())
+
+    def _parse_message_content(self, html_text):
+        """
+        解析短消息内容，已经在 _parse_message_unread_links 内实现，重载防止 abstractmethod 报错
+        :param html_text:
+        :return:  head: message, date: time, content: message content
+        """
+        pass
+
+    def _parse_user_traffic_info(self, html_text: str):
+        """
+        解析用户的上传，下载，分享率等信息，已经在 _parse_user_detail_info 内实现，重载防止 abstractmethod 报错
+        :param html_text:
+        :return:
+        """
+        pass

app/modules/indexer/parser/tnode.py

@@ -36,7 +36,10 @@ class TNodeSiteUserInfo(SiteParserBase):
         pass
 
     def _parse_user_detail_info(self, html_text: str):
-        detail = json.loads(html_text)
+        try:
+            detail = json.loads(html_text)
+        except json.JSONDecodeError:
+            return
         if detail.get("status") != 200:
             return
 

app/modules/indexer/spider/__init__.py

@@ -5,7 +5,6 @@ import traceback
 from typing import List
 from urllib.parse import quote, urlencode, urlparse, parse_qs
 
-import chardet
 from jinja2 import Template
 from pyquery import PyQuery
 from ruamel.yaml import CommentedMap
@@ -250,27 +249,9 @@ class TorrentSpider:
                 referer=self.referer,
                 proxies=self.proxies
             ).get_res(searchurl, allow_redirects=True)
-            if ret is not None:
-                # 使用chardet检测字符编码
-                raw_data = ret.content
-                if raw_data:
-                    try:
-                        result = chardet.detect(raw_data)
-                        encoding = result['encoding']
-                        # 解码为字符串
-                        page_source = raw_data.decode(encoding)
-                    except Exception as e:
-                        logger.debug(f"chardet解码失败：{str(e)}")
-                        # 探测utf-8解码
-                        if re.search(r"charset=\"?utf-8\"?", ret.text, re.IGNORECASE):
-                            ret.encoding = "utf-8"
-                        else:
-                            ret.encoding = ret.apparent_encoding
-                        page_source = ret.text
-                else:
-                    page_source = ret.text
-            else:
-                page_source = ""
+            page_source = RequestUtils.get_decoded_html_content(ret,
+                                                                settings.ENCODING_DETECTION_PERFORMANCE_MODE,
+                                                                settings.ENCODING_DETECTION_MIN_CONFIDENCE)
 
         # 解析
         return self.parse(page_source)
@@ -691,7 +672,7 @@ class TorrentSpider:
                 elif method_name == "appendleft":
                     text = f"{args}{text}"
                 elif method_name == "querystring":
-                    parsed_url = urlparse(text)
+                    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 ''

app/modules/indexer/spider/yema.py

@@ -21,14 +21,30 @@ class YemaSpider:
     _cookie = None
     _ua = None
     _size = 40
-    _searchurl = "%sapi/torrent/fetchCategoryOpenTorrentList"
+    _searchurl = "%sapi/torrent/fetchOpenTorrentList"
     _downloadurl = "%sapi/torrent/download?id=%s"
     _pageurl = "%s#/torrent/detail/%s/"
     _timeout = 15
 
     # 分类
-    _movie_category = 4
-    _tv_category = 5
+    _movie_category = [4]
+    _tv_category = [5, 13, 14, 17, 15, 6, 16]
+
+    # 标签 https://wiki.yemapt.org/developer/constants
+    _labels = {
+        "1": "禁转",
+        "2": "首发",
+        "3": "官方",
+        "4": "自制",
+        "5": "国语",
+        "6": "中字",
+        "7": "粤语",
+        "8": "英字",
+        "9": "HDR10",
+        "10": "杜比视界",
+        "11": "分集",
+        "12": "完结",
+    }
 
     def __init__(self, indexer: CommentedMap):
         self.systemconfig = SystemConfigOper()
@@ -47,14 +63,7 @@ class YemaSpider:
         """
         搜索
         """
-        if not mtype:
-            categoryId = self._movie_category
-        elif mtype == MediaType.TV:
-            categoryId = self._tv_category
-        else:
-            categoryId = self._movie_category
         params = {
-            "categoryId": categoryId,
             "pageParam": {
                 "current": page + 1,
                 "pageSize": self._size,
@@ -62,6 +71,12 @@ class YemaSpider:
             },
             "sorter": {}
         }
+        # 新接口可不传 categoryId 参数
+        # if mtype == MediaType.MOVIE:
+        #     params.update({
+        #         "categoryId": self._movie_category,
+        #     })
+        #     pass
         if keyword:
             params.update({
                 "keyword": keyword,
@@ -82,17 +97,27 @@ class YemaSpider:
             results = res.json().get('data', []) or []
             for result in results:
                 category_value = result.get('categoryId')
-                if category_value == self._tv_category:
+                if category_value in self._tv_category:
                     category = MediaType.TV.value
-                elif category_value == self._movie_category:
+                elif category_value in self._movie_category:
                     category = MediaType.MOVIE.value
                 else:
                     category = MediaType.UNKNOWN.value
+                    pass
+
+                torrentLabelIds = result.get('tagList', []) or []
+                torrentLabels = []
+                for labelId in torrentLabelIds:
+                    if self._labels.get(labelId) is not None:
+                        torrentLabels.append(self._labels.get(labelId))
+                        pass
+                    pass
                 torrent = {
                     'title': result.get('showName'),
                     'description': result.get('shortDesc'),
                     'enclosure': self.__get_download_url(result.get('id')),
-                    'pubdate': StringUtils.unify_datetime_str(result.get('gmtCreate')),
+                    # 使用上架时间，而不是用户发布时间，上架时间即其他用户可见时间
+                    'pubdate': StringUtils.unify_datetime_str(result.get('listingTime')),
                     'size': result.get('fileSize'),
                     'seeders': result.get('seedNum'),
                     'peers': result.get('leechNum'),
@@ -101,7 +126,7 @@ class YemaSpider:
                     'uploadvolumefactor': self.__get_uploadvolumefactor(result.get('uploadPromotion')),
                     'freedate': StringUtils.unify_datetime_str(result.get('downloadPromotionEndTime')),
                     'page_url': self._pageurl % (self._domain, result.get('id')),
-                    'labels': [],
+                    'labels': torrentLabels,
                     'category': category
                 }
                 torrents.append(torrent)

app/modules/jellyfin/__init__.py

@@ -6,8 +6,8 @@ from app.core.event import eventmanager
 from app.log import logger
 from app.modules import _MediaServerBase, _ModuleBase
 from app.modules.jellyfin.jellyfin import Jellyfin
-from app.schemas.event import AuthCredentials, AuthInterceptCredentials
-from app.schemas.types import MediaType, ModuleType, ChainEventType
+from app.schemas import AuthCredentials, AuthInterceptCredentials
+from app.schemas.types import MediaType, ModuleType, ChainEventType, MediaServerType
 
 
 class JellyfinModule(_ModuleBase, _MediaServerBase[Jellyfin]):
@@ -30,6 +30,13 @@ class JellyfinModule(_ModuleBase, _MediaServerBase[Jellyfin]):
         """
         return ModuleType.MediaServer
 
+    @staticmethod
+    def get_subtype() -> MediaServerType:
+        """
+        获取模块子类型
+        """
+        return MediaServerType.Jellyfin
+
     @staticmethod
     def get_priority() -> int:
         """
@@ -66,16 +73,26 @@ class JellyfinModule(_ModuleBase, _MediaServerBase[Jellyfin]):
                 return False, f"无法连接Jellyfin服务器：{name}"
         return True, ""
 
-    def user_authenticate(self, credentials: AuthCredentials) -> Optional[AuthCredentials]:
+    def user_authenticate(self, credentials: AuthCredentials, service_name: Optional[str] = None) \
+            -> Optional[AuthCredentials]:
         """
         使用Jellyfin用户辅助完成用户认证
         :param credentials: 认证数据
+        :param service_name: 指定要认证的媒体服务器名称，若为 None 则认证所有服务
         :return: 认证数据
         """
         # Jellyfin认证
         if not credentials or credentials.grant_type != "password":
             return None
-        for name, server in self.get_instances().items():
+        # 确定要认证的服务器列表
+        if service_name:
+            # 如果指定了服务名，获取该服务实例
+            servers = [(service_name, server)] if (server := self.get_instance(service_name)) else []
+        else:
+            # 如果没有指定服务名，遍历所有服务
+            servers = self.get_instances().items()
+        # 遍历要认证的服务器
+        for name, server in servers:
             # 触发认证拦截事件
             intercept_event = eventmanager.send_event(
                 etype=ChainEventType.AuthIntercept,

app/modules/plex/__init__.py

@@ -6,8 +6,8 @@ from app.core.event import eventmanager
 from app.log import logger
 from app.modules import _ModuleBase, _MediaServerBase
 from app.modules.plex.plex import Plex
-from app.schemas.event import AuthCredentials, AuthInterceptCredentials
-from app.schemas.types import MediaType, ModuleType, ChainEventType
+from app.schemas import AuthCredentials, AuthInterceptCredentials
+from app.schemas.types import MediaType, ModuleType, ChainEventType, MediaServerType
 
 
 class PlexModule(_ModuleBase, _MediaServerBase[Plex]):
@@ -30,6 +30,13 @@ class PlexModule(_ModuleBase, _MediaServerBase[Plex]):
         """
         return ModuleType.MediaServer
 
+    @staticmethod
+    def get_subtype() -> MediaServerType:
+        """
+        获取模块子类型
+        """
+        return MediaServerType.Plex
+
     @staticmethod
     def get_priority() -> int:
         """
@@ -66,16 +73,26 @@ class PlexModule(_ModuleBase, _MediaServerBase[Plex]):
                 logger.info(f"Plex {name} 服务器连接断开，尝试重连 ...")
                 server.reconnect()
 
-    def user_authenticate(self, credentials: AuthCredentials) -> Optional[AuthCredentials]:
+    def user_authenticate(self, credentials: AuthCredentials, service_name: Optional[str] = None) \
+            -> Optional[AuthCredentials]:
         """
         使用Plex用户辅助完成用户认证
         :param credentials: 认证数据
+        :param service_name: 指定要认证的媒体服务器名称，若为 None 则认证所有服务
         :return: 认证数据
         """
         # Plex认证
         if not credentials or credentials.grant_type != "password":
             return None
-        for name, server in self.get_instances().items():
+        # 确定要认证的服务器列表
+        if service_name:
+            # 如果指定了服务名，获取该服务实例
+            servers = [(service_name, server)] if (server := self.get_instance(service_name)) else []
+        else:
+            # 如果没有指定服务名，遍历所有服务
+            servers = self.get_instances().items()
+        # 遍历要认证的服务器
+        for name, server in servers:
             # 触发认证拦截事件
             intercept_event = eventmanager.send_event(
                 etype=ChainEventType.AuthIntercept,

app/modules/plex/plex.py

@@ -162,26 +162,26 @@ class Plex:
     def get_medias_count(self) -> schemas.Statistic:
         """
         获得电影、电视剧、动漫媒体数量
-        :return: MovieCount SeriesCount SongCount
+        :return: movie_count tv_count episode_count
         """
         if not self._plex:
             return schemas.Statistic()
         sections = self._plex.library.sections()
-        MovieCount = SeriesCount = EpisodeCount = 0
+        movie_count = tv_count = episode_count = 0
         # 媒体库白名单
         allow_library = [lib.id for lib in self.get_librarys(hidden=True)]
         for sec in sections:
-            if str(sec.key) not in allow_library:
+            if sec.key not in allow_library:
                 continue
             if sec.type == "movie":
-                MovieCount += sec.totalSize
+                movie_count += sec.totalSize
             if sec.type == "show":
-                SeriesCount += sec.totalSize
-                EpisodeCount += sec.totalViewSize(libtype='episode')
+                tv_count += sec.totalSize
+                episode_count += sec.totalViewSize(libtype="episode")
         return schemas.Statistic(
-            movie_count=MovieCount,
-            tv_count=SeriesCount,
-            episode_count=EpisodeCount
+            movie_count=movie_count,
+            tv_count=tv_count,
+            episode_count=episode_count
         )
 
     def get_movies(self,
@@ -294,7 +294,7 @@ class Plex:
         return videos.key, season_episodes
 
     def get_remote_image_by_id(self, 
-                               item_id: str, 
+                               item_id: str,
                                image_type: str,
                                depth: int = 0,
                                plex_url: bool = True) -> Optional[str]:
@@ -310,12 +310,16 @@ class Plex:
             return None
         try:
             image_url = None
-            ekey = f"/library/metadata/{item_id}"
+            ekey = item_id
             item = self._plex.fetchItem(ekey=ekey)
             if not item:
                 return None
             # 如果配置了外网播放地址以及Token，则默认从Plex媒体服务器获取图片，否则返回有外网地址的图片资源
-            if self._playhost and self._token and plex_url:
+            # Plex外网播放地址这个框里目前可以填两种地址
+            #   1. Plex的官方转发地址https://app.plex.tv, 2. 自己处理的端口转发地址
+            #   如果使用的是1的官方转发地址,那么就不能走这个逻辑，因为官方转发地址无法获取到图片
+            if (self._playhost and "app.plex.tv" not in self._playhost
+                    and self._token and plex_url):
                 query = {"X-Plex-Token": self._token}
                 if image_type == "Poster":
                     if item.thumb:
@@ -346,8 +350,8 @@ class Plex:
                         image_url = image.key
                         break
                     # 如果最后还是找不到，则递归父级进行查找
-                if not image_url and hasattr(item, "parentRatingKey"):
-                    return self.get_remote_image_by_id(item_id=item.parentRatingKey,
+                if not image_url and hasattr(item, "parentKey"):
+                    return self.get_remote_image_by_id(item_id=item.parentKey,
                                                        image_type=image_type,
                                                        depth=depth + 1)
             return image_url
@@ -665,7 +669,7 @@ class Plex:
                     "S" + str(message.get('Metadata', {}).get('parentIndex')),
                     "E" + str(message.get('Metadata', {}).get('index')),
                     message.get('Metadata', {}).get('title'))
-                eventItem.item_id = message.get('Metadata', {}).get('ratingKey')
+                eventItem.item_id = message.get('Metadata', {}).get('key')
                 eventItem.season_id = message.get('Metadata', {}).get('parentIndex')
                 eventItem.episode_id = message.get('Metadata', {}).get('index')
 
@@ -680,7 +684,7 @@ class Plex:
                 eventItem.item_name = "%s %s" % (
                     message.get('Metadata', {}).get('title'),
                     "(" + str(message.get('Metadata', {}).get('year')) + ")")
-                eventItem.item_id = message.get('Metadata', {}).get('ratingKey')
+                eventItem.item_id = message.get('Metadata', {}).get('key')
                 if len(message.get('Metadata', {}).get('summary')) > 100:
                     eventItem.overview = str(message.get('Metadata', {}).get('summary'))[:100] + "..."
                 else:
@@ -721,7 +725,7 @@ class Plex:
         if not self._plex:
             return []
         # 媒体库白名单
-        allow_library = ",".join([lib.id for lib in self.get_librarys(hidden=True)])
+        allow_library = ",".join(map(str, (lib.id for lib in self.get_librarys(hidden=True))))
         params = {"contentDirectoryID": allow_library}
         items = self._plex.fetchItems("/hubs/continueWatching/items",
                                       container_start=0,
@@ -757,7 +761,7 @@ class Plex:
         if not self._plex:
             return None
         # 请求参数（除黑名单）
-        allow_library = ",".join([lib.id for lib in self.get_librarys(hidden=True)])
+        allow_library = ",".join(map(str, (lib.id for lib in self.get_librarys(hidden=True))))
         params = {
             "contentDirectoryID": allow_library,
             "count": num,

app/modules/qbittorrent/__init__.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import Set, Tuple, Optional, Union, List
+from typing import Set, Tuple, Optional, Union, List, Dict
 
 from qbittorrentapi import TorrentFilesList
 from torrentool.torrent import Torrent
@@ -11,7 +11,7 @@ from app.log import logger
 from app.modules import _ModuleBase, _DownloaderBase
 from app.modules.qbittorrent.qbittorrent import Qbittorrent
 from app.schemas import TransferTorrent, DownloadingTorrent
-from app.schemas.types import TorrentStatus, ModuleType
+from app.schemas.types import TorrentStatus, ModuleType, DownloaderType
 from app.utils.string import StringUtils
 
 
@@ -35,6 +35,13 @@ class QbittorrentModule(_ModuleBase, _DownloaderBase[Qbittorrent]):
         """
         return ModuleType.Downloader
 
+    @staticmethod
+    def get_subtype() -> DownloaderType:
+        """
+        获取模块子类型
+        """
+        return DownloaderType.Qbittorrent
+
     @staticmethod
     def get_priority() -> int:
         """
@@ -72,7 +79,7 @@ class QbittorrentModule(_ModuleBase, _DownloaderBase[Qbittorrent]):
 
     def download(self, content: Union[Path, str], download_dir: Path, cookie: str,
                  episodes: Set[int] = None, category: str = None,
-                 downloader: str = None) -> Optional[Tuple[Optional[str], Optional[str], str]]:
+                 downloader: str = None) -> Optional[Tuple[Optional[str], Optional[str], Optional[str], str]]:
         """
         根据种子文件，选择并添加下载任务
         :param content:  种子文件地址或者磁力链接
@@ -81,7 +88,7 @@ class QbittorrentModule(_ModuleBase, _DownloaderBase[Qbittorrent]):
         :param episodes:  需要下载的集数
         :param category:  分类
         :param downloader:  下载器
-        :return: 种子Hash，错误信息
+        :return: 下载器名称、种子Hash、种子文件布局、错误原因
         """
 
         def __get_torrent_info() -> Tuple[str, int]:
@@ -99,10 +106,10 @@ class QbittorrentModule(_ModuleBase, _DownloaderBase[Qbittorrent]):
                 return "", 0
 
         if not content:
-            return None, None, "下载内容为空"
+            return None, None, None, "下载内容为空"
         if isinstance(content, Path) and not content.exists():
             logger.error(f"种子文件不存在：{content}")
-            return None, None, f"种子文件不存在：{content}"
+            return None, None, None, f"种子文件不存在：{content}"
 
         # 获取下载器
         server: Qbittorrent = self.get_instance(downloader)
@@ -124,17 +131,22 @@ class QbittorrentModule(_ModuleBase, _DownloaderBase[Qbittorrent]):
             is_paused=is_paused,
             tag=tags,
             cookie=cookie,
-            category=category
+            category=category,
+            ignore_category_check=False
         )
+
+        # 获取种子内容布局: `Original: 原始, Subfolder: 创建子文件夹, NoSubfolder: 不创建子文件夹`
+        torrent_layout = server.get_content_layout()
+
         if not state:
             # 读取种子的名称
             torrent_name, torrent_size = __get_torrent_info()
             if not torrent_name:
-                return None, None, f"添加种子任务失败：无法读取种子文件"
+                return None, None, None, f"添加种子任务失败：无法读取种子文件"
             # 查询所有下载器的种子
             torrents, error = server.get_torrents()
             if error:
-                return None, None, "无法连接qbittorrent下载器"
+                return None, None, None, "无法连接qbittorrent下载器"
             if torrents:
                 for torrent in torrents:
                     # 名称与大小相等则认为是同一个种子
@@ -148,19 +160,19 @@ class QbittorrentModule(_ModuleBase, _DownloaderBase[Qbittorrent]):
                         if settings.TORRENT_TAG and settings.TORRENT_TAG not in torrent_tags:
                             logger.info(f"给种子 {torrent_hash} 打上标签：{settings.TORRENT_TAG}")
                             server.set_torrents_tag(ids=torrent_hash, tags=[settings.TORRENT_TAG])
-                        return downloader or self.get_default_config_name(), torrent_hash, f"下载任务已存在"
-            return None, None, f"添加种子任务失败：{content}"
+                        return downloader or self.get_default_config_name(), torrent_hash, torrent_layout, f"下载任务已存在"
+            return None, None, None, f"添加种子任务失败：{content}"
         else:
             # 获取种子Hash
             torrent_hash = server.get_torrent_id_by_tag(tags=tag)
             if not torrent_hash:
-                return None, None, f"下载任务添加成功，但获取Qbittorrent任务信息失败：{content}"
+                return None, None, None, f"下载任务添加成功，但获取Qbittorrent任务信息失败：{content}"
             else:
                 if is_paused:
                     # 种子文件
                     torrent_files = server.get_files(torrent_hash)
                     if not torrent_files:
-                        return downloader or self.get_default_config_name(), torrent_hash, "获取种子文件失败，下载任务可能在暂停状态"
+                        return downloader or self.get_default_config_name(), torrent_hash, torrent_layout, "获取种子文件失败，下载任务可能在暂停状态"
 
                     # 不需要的文件ID
                     file_ids = []
@@ -185,11 +197,11 @@ class QbittorrentModule(_ModuleBase, _DownloaderBase[Qbittorrent]):
                         server.torrents_set_force_start(torrent_hash)
                     else:
                         server.start_torrents(torrent_hash)
-                    return downloader or self.get_default_config_name(), torrent_hash, f"添加下载成功，已选择集数：{sucess_epidised}"
+                    return downloader or self.get_default_config_name(), torrent_hash, torrent_layout, f"添加下载成功，已选择集数：{sucess_epidised}"
                 else:
                     if server.is_force_resume():
                         server.torrents_set_force_start(torrent_hash)
-                    return downloader or self.get_default_config_name(), torrent_hash, "添加下载成功"
+                    return downloader or self.get_default_config_name(), torrent_hash, torrent_layout, "添加下载成功"
 
     def list_torrents(self, status: TorrentStatus = None,
                       hashs: Union[list, str] = None,
@@ -203,66 +215,75 @@ class QbittorrentModule(_ModuleBase, _DownloaderBase[Qbittorrent]):
         :return: 下载器中符合状态的种子列表
         """
         # 获取下载器
-        server: Qbittorrent = self.get_instance(downloader)
-        if not server:
-            return None
-
+        if downloader:
+            server: Qbittorrent = self.get_instance(downloader)
+            if not server:
+                return None
+            servers = {downloader: server}
+        else:
+            servers: Dict[str, Qbittorrent] = self.get_instances()
         ret_torrents = []
         if hashs:
             # 按Hash获取
-            torrents, _ = server.get_torrents(ids=hashs, tags=settings.TORRENT_TAG)
-            for torrent in torrents or []:
-                content_path = torrent.get("content_path")
-                if content_path:
-                    torrent_path = Path(content_path)
-                else:
-                    torrent_path = Path(torrent.get('save_path')) / torrent.get('name')
-                ret_torrents.append(TransferTorrent(
-                    title=torrent.get('name'),
-                    path=torrent_path,
-                    hash=torrent.get('hash'),
-                    size=torrent.get('total_size'),
-                    tags=torrent.get('tags')
-                ))
+            for name, server in servers.items():
+                torrents, _ = server.get_torrents(ids=hashs, tags=settings.TORRENT_TAG)
+                for torrent in torrents or []:
+                    content_path = torrent.get("content_path")
+                    if content_path:
+                        torrent_path = Path(content_path)
+                    else:
+                        torrent_path = Path(torrent.get('save_path')) / torrent.get('name')
+                    ret_torrents.append(TransferTorrent(
+                        downloader=name,
+                        title=torrent.get('name'),
+                        path=torrent_path,
+                        hash=torrent.get('hash'),
+                        size=torrent.get('total_size'),
+                        tags=torrent.get('tags')
+                    ))
         elif status == TorrentStatus.TRANSFER:
             # 获取已完成且未整理的
-            torrents = server.get_completed_torrents(tags=settings.TORRENT_TAG)
-            for torrent in torrents or []:
-                tags = torrent.get("tags") or []
-                if "已整理" in tags:
-                    continue
-                # 内容路径
-                content_path = torrent.get("content_path")
-                if content_path:
-                    torrent_path = Path(content_path)
-                else:
-                    torrent_path = torrent.get('save_path') / torrent.get('name')
-                ret_torrents.append(TransferTorrent(
-                    title=torrent.get('name'),
-                    path=torrent_path,
-                    hash=torrent.get('hash'),
-                    tags=torrent.get('tags')
-                ))
+            for name, server in servers.items():
+                torrents = server.get_completed_torrents(tags=settings.TORRENT_TAG)
+                for torrent in torrents or []:
+                    tags = torrent.get("tags") or []
+                    if "已整理" in tags:
+                        continue
+                    # 内容路径
+                    content_path = torrent.get("content_path")
+                    if content_path:
+                        torrent_path = Path(content_path)
+                    else:
+                        torrent_path = torrent.get('save_path') / torrent.get('name')
+                    ret_torrents.append(TransferTorrent(
+                        downloader=name,
+                        title=torrent.get('name'),
+                        path=torrent_path,
+                        hash=torrent.get('hash'),
+                        tags=torrent.get('tags')
+                    ))
         elif status == TorrentStatus.DOWNLOADING:
             # 获取正在下载的任务
-            torrents = server.get_downloading_torrents(tags=settings.TORRENT_TAG)
-            for torrent in torrents or []:
-                meta = MetaInfo(torrent.get('name'))
-                ret_torrents.append(DownloadingTorrent(
-                    hash=torrent.get('hash'),
-                    title=torrent.get('name'),
-                    name=meta.name,
-                    year=meta.year,
-                    season_episode=meta.season_episode,
-                    progress=torrent.get('progress') * 100,
-                    size=torrent.get('total_size'),
-                    state="paused" if torrent.get('state') in ("paused", "pausedDL") else "downloading",
-                    dlspeed=StringUtils.str_filesize(torrent.get('dlspeed')),
-                    upspeed=StringUtils.str_filesize(torrent.get('upspeed')),
-                    left_time=StringUtils.str_secends(
-                        (torrent.get('total_size') - torrent.get('completed')) / torrent.get('dlspeed')) if torrent.get(
-                        'dlspeed') > 0 else ''
-                ))
+            for name, server in servers.items():
+                torrents = server.get_downloading_torrents(tags=settings.TORRENT_TAG)
+                for torrent in torrents or []:
+                    meta = MetaInfo(torrent.get('name'))
+                    ret_torrents.append(DownloadingTorrent(
+                        downloader=name,
+                        hash=torrent.get('hash'),
+                        title=torrent.get('name'),
+                        name=meta.name,
+                        year=meta.year,
+                        season_episode=meta.season_episode,
+                        progress=torrent.get('progress') * 100,
+                        size=torrent.get('total_size'),
+                        state="paused" if torrent.get('state') in ("paused", "pausedDL") else "downloading",
+                        dlspeed=StringUtils.str_filesize(torrent.get('dlspeed')),
+                        upspeed=StringUtils.str_filesize(torrent.get('upspeed')),
+                        left_time=StringUtils.str_secends(
+                            (torrent.get('total_size') - torrent.get('completed')) / torrent.get('dlspeed')) if torrent.get(
+                            'dlspeed') > 0 else ''
+                    ))
         else:
             return None
         return ret_torrents

app/modules/qbittorrent/qbittorrent.py

@@ -1,4 +1,5 @@
 import time
+import traceback
 from typing import Optional, Union, Tuple, List
 
 import qbittorrentapi
@@ -75,8 +76,13 @@ class Qbittorrent:
                                         REQUESTS_ARGS={'timeout': (15, 60)})
             try:
                 qbt.auth_log_in()
-            except qbittorrentapi.LoginFailed as e:
-                logger.error(f"qbittorrent 登录失败：{str(e)}")
+            except (qbittorrentapi.LoginFailed, qbittorrentapi.Forbidden403Error) as e:
+                logger.error(f"qbittorrent 登录失败：{str(e).strip() or '请检查用户名和密码是否正确'}")
+                return None
+            except Exception as e:
+                stack_trace = "".join(traceback.format_exception(None, e, e.__traceback__))[:2000]
+                logger.error(f"qbittorrent 登录失败：{str(e)}\n{stack_trace}")
+                return None
             return qbt
         except Exception as err:
             logger.error(f"qbittorrent 连接出错：{str(err)}")
@@ -245,6 +251,7 @@ class Qbittorrent:
         :param category: 种子分类
         :param download_dir: 下载路径
         :param cookie: 站点Cookie用于辅助下载种子
+        :param kwargs: 可选参数，如 ignore_category_check 以及 QB相关参数
         :return: bool
         """
         if not self.qbc or not content:
@@ -270,13 +277,16 @@ class Qbittorrent:
         else:
             tags = None
 
-        # 分类自动管理
-        if category and self._category:
-            is_auto = True
+        # 如果忽略分类检查，则直接使用传入的分类值，否则，仅在分类存在且启用了自动管理时才传递参数
+        ignore_category_check = kwargs.pop("ignore_category_check", True)
+        if ignore_category_check:
+            is_auto = self._category
         else:
-            is_auto = False
-            category = None
-
+            if category and self._category:
+                is_auto = True
+            else:
+                is_auto = False
+                category = None
         try:
             # 添加下载
             qbc_ret = self.qbc.torrents_add(urls=urls,
@@ -438,3 +448,14 @@ class Qbittorrent:
         except Exception as err:
             logger.error(f"修改tracker出错：{str(err)}")
             return False
+
+    def get_content_layout(self) -> Optional[str]:
+        """
+        获取内容布局
+        """
+        if not self.qbc:
+            return None
+        # 获取下载器全局设置
+        application = self.qbc.application.preferences
+        # 获取种子内容布局: `Original: 原始, Subfolder: 创建子文件夹, NoSubfolder: 不创建子文件夹`
+        return application.get("torrent_content_layout", "Original")

app/modules/slack/__init__.py

@@ -31,6 +31,13 @@ class SlackModule(_ModuleBase, _MessageBase[Slack]):
         """
         return ModuleType.Notification
 
+    @staticmethod
+    def get_subtype() -> MessageChannel:
+        """
+        获取模块子类型
+        """
+        return MessageChannel.Slack
+
     @staticmethod
     def get_priority() -> int:
         """

app/modules/subtitle/__init__.py

@@ -10,7 +10,7 @@ from app.core.context import Context
 from app.helper.torrent import TorrentHelper
 from app.log import logger
 from app.modules import _ModuleBase
-from app.schemas.types import ModuleType
+from app.schemas.types import ModuleType, OtherModulesType
 from app.utils.http import RequestUtils
 from app.utils.string import StringUtils
 from app.utils.system import SystemUtils
@@ -40,6 +40,13 @@ class SubtitleModule(_ModuleBase):
         """
         return ModuleType.Other
 
+    @staticmethod
+    def get_subtype() -> OtherModulesType:
+        """
+        获取模块子类型
+        """
+        return OtherModulesType.Subtitle
+
     @staticmethod
     def get_priority() -> int:
         """

app/modules/synologychat/__init__.py

@@ -29,6 +29,13 @@ class SynologyChatModule(_ModuleBase, _MessageBase[SynologyChat]):
         """
         return ModuleType.Notification
 
+    @staticmethod
+    def get_subtype() -> MessageChannel:
+        """
+        获取模块子类型
+        """
+        return MessageChannel.SynologyChat
+
     @staticmethod
     def get_priority() -> int:
         """

app/modules/telegram/__init__.py

@@ -7,8 +7,7 @@ from app.core.event import eventmanager
 from app.log import logger
 from app.modules import _ModuleBase, _MessageBase
 from app.modules.telegram.telegram import Telegram
-from app.schemas import MessageChannel, CommingMessage, Notification
-from app.schemas.event import CommandRegisterEventData
+from app.schemas import MessageChannel, CommingMessage, Notification, CommandRegisterEventData
 from app.schemas.types import ModuleType, ChainEventType
 from app.utils.structures import DictUtils
 
@@ -34,6 +33,13 @@ class TelegramModule(_ModuleBase, _MessageBase[Telegram]):
         """
         return ModuleType.Notification
 
+    @staticmethod
+    def get_subtype() -> MessageChannel:
+        """
+        获取模块子类型
+        """
+        return MessageChannel.Telegram
+
     @staticmethod
     def get_priority() -> int:
         """

app/modules/themoviedb/__init__.py

@@ -14,7 +14,7 @@ from app.modules.themoviedb.scraper import TmdbScraper
 from app.modules.themoviedb.tmdb_cache import TmdbCache
 from app.modules.themoviedb.tmdbapi import TmdbApi
 from app.schemas import MediaPerson
-from app.schemas.types import MediaType, MediaImageType, ModuleType
+from app.schemas.types import MediaType, MediaImageType, ModuleType, MediaRecognizeType
 from app.utils.http import RequestUtils
 
 
@@ -49,6 +49,13 @@ class TheMovieDbModule(_ModuleBase):
         """
         return ModuleType.MediaRecognize
 
+    @staticmethod
+    def get_subtype() -> MediaRecognizeType:
+        """
+        获取模块子类型
+        """
+        return MediaRecognizeType.TMDB
+
     @staticmethod
     def get_priority() -> int:
         """
@@ -304,6 +311,27 @@ class TheMovieDbModule(_ModuleBase):
             return [MediaPerson(source='themoviedb', **person) for person in results]
         return []
 
+    def search_collections(self, name: str) -> Optional[List[MediaInfo]]:
+        """
+        搜索集合信息
+        """
+        if not name:
+            return []
+        results = self.tmdb.search_collections(name)
+        if results:
+            return [MediaInfo(tmdb_info=info) for info in results]
+        return []
+
+    def tmdb_collection(self, collection_id: int) -> Optional[List[MediaInfo]]:
+        """
+        根据合集ID查询集合
+        :param collection_id:  合集ID
+        """
+        results = self.tmdb.get_collection(collection_id)
+        if results:
+            return [MediaInfo(tmdb_info=info) for info in results]
+        return []
+
     def metadata_nfo(self, meta: MetaBase, mediainfo: MediaInfo,
                      season: int = None, episode: int = None) -> Optional[str]:
         """

app/modules/themoviedb/scraper.py

@@ -30,9 +30,9 @@ class TmdbScraper:
             # 电影元数据文件
             doc = self.__gen_movie_nfo_file(mediainfo=mediainfo)
         else:
-            if season:
+            if season is not None:
                 # 查询季信息
-                seasoninfo = self.tmdb.get_tv_season_detail(mediainfo.tmdb_id, meta.begin_season)
+                seasoninfo = self.tmdb.get_tv_season_detail(mediainfo.tmdb_id, season)
                 if episode:
                     # 集元数据文件
                     episodeinfo = self.__get_episode_detail(seasoninfo, meta.begin_episode)
@@ -45,7 +45,7 @@ class TmdbScraper:
                 # 电视剧元数据文件
                 doc = self.__gen_tv_nfo_file(mediainfo=mediainfo)
         if doc:
-            return doc.toprettyxml(indent="  ", encoding="utf-8")
+            return doc.toprettyxml(indent="  ", encoding="utf-8") # noqa
 
         return None
 
@@ -57,7 +57,7 @@ class TmdbScraper:
         :param episode: 集号
         """
         images = {}
-        if season:
+        if season is not None:
             # 只需要集的图片
             if episode:
                 # 集的图片
@@ -102,8 +102,13 @@ class TmdbScraper:
             ext = Path(seasoninfo.get('poster_path')).suffix
             # URL
             url = f"https://{settings.TMDB_IMAGE_DOMAIN}/t/p/original{seasoninfo.get('poster_path')}"
-            image_name = f"season{sea_seq}-poster{ext}"
+            # S0海报格式不同
+            if season == 0:
+                image_name = f"season-specials-poster{ext}"
+            else:
+                image_name = f"season{sea_seq}-poster{ext}"
             return image_name, url
+        return "", ""
 
     @staticmethod
     def __get_episode_detail(seasoninfo: dict, episode: int) -> dict:
@@ -228,7 +233,7 @@ class TmdbScraper:
         xoutline = DomUtils.add_node(doc, root, "outline")
         xoutline.appendChild(doc.createCDATASection(seasoninfo.get("overview") or ""))
         # 标题
-        DomUtils.add_node(doc, root, "title", "季 %s" % season)
+        DomUtils.add_node(doc, root, "title", seasoninfo.get("name") or "季 %s" % season)
         # 发行日期
         DomUtils.add_node(doc, root, "premiered", seasoninfo.get("air_date") or "")
         DomUtils.add_node(doc, root, "releasedate", seasoninfo.get("air_date") or "")

app/modules/themoviedb/tmdb_cache.py

@@ -15,7 +15,7 @@ from app.schemas.types import MediaType
 lock = RLock()
 
 CACHE_EXPIRE_TIMESTAMP_STR = "cache_expire_timestamp"
-EXPIRE_TIMESTAMP = settings.CACHE_CONF.get('meta')
+EXPIRE_TIMESTAMP = settings.CACHE_CONF["meta"]
 
 
 class TmdbCache(metaclass=Singleton):
@@ -75,7 +75,7 @@ class TmdbCache(metaclass=Singleton):
         @return: 被删除的缓存内容
         """
         with lock:
-            return self._meta_data.pop(key, None)
+            return self._meta_data.pop(key, {})
 
     def delete_by_tmdbid(self, tmdbid: int) -> None:
         """
@@ -138,14 +138,14 @@ class TmdbCache(metaclass=Singleton):
                 if cache_year:
                     cache_year = cache_year[:4]
                 self._meta_data[self.__get_key(meta)] = {
-                        "id": info.get("id"),
-                        "type": info.get("media_type"),
-                        "year": cache_year,
-                        "title": cache_title,
-                        "poster_path": info.get("poster_path"),
-                        "backdrop_path": info.get("backdrop_path"),
-                        CACHE_EXPIRE_TIMESTAMP_STR: int(time.time()) + EXPIRE_TIMESTAMP
-                    }
+                    "id": info.get("id"),
+                    "type": info.get("media_type"),
+                    "year": cache_year,
+                    "title": cache_title,
+                    "poster_path": info.get("poster_path"),
+                    "backdrop_path": info.get("backdrop_path"),
+                    CACHE_EXPIRE_TIMESTAMP_STR: int(time.time()) + EXPIRE_TIMESTAMP
+                }
             elif info is not None:
                 # None时不缓存，此时代表网络错误，允许重复请求
                 self._meta_data[self.__get_key(meta)] = {'id': 0}
@@ -164,7 +164,7 @@ class TmdbCache(metaclass=Singleton):
             return
 
         with open(self._meta_path, 'wb') as f:
-            pickle.dump(new_meta_data, f, pickle.HIGHEST_PROTOCOL)
+            pickle.dump(new_meta_data, f, pickle.HIGHEST_PROTOCOL)  # type: ignore
 
     def _random_sample(self, new_meta_data: dict) -> bool:
         """