Merge pull request #4348 from Aqr-K/fix-sh

fix(sh): 引号格式问题

app/actions/fetch_medias.py

@@ -40,54 +40,67 @@ class FetchMediasAction(BaseAction):
             {
                 "func": RecommendChain().tmdb_trending,
                 "name": '流行趋势',
+                "api_path": "recommend/tmdb_trending"
             },
             {
                 "func": RecommendChain().douban_movie_showing,
                 "name": '正在热映',
+                "api_path": "recommend/douban_showing"
             },
             {
                 "func": RecommendChain().bangumi_calendar,
                 "name": 'Bangumi每日放送',
+                "api_path": "recommend/bangumi_calendar"
             },
             {
                 "func": RecommendChain().tmdb_movies,
                 "name": 'TMDB热门电影',
+                "api_path": "recommend/tmdb_movies"
             },
             {
                 "func": RecommendChain().tmdb_tvs,
                 "name": 'TMDB热门电视剧',
+                "api_path": "recommend/tmdb_tvs?with_original_language=zh|en|ja|ko"
             },
             {
                 "func": RecommendChain().douban_movie_hot,
                 "name": '豆瓣热门电影',
+                "api_path": "recommend/douban_movie_hot"
             },
             {
                 "func": RecommendChain().douban_tv_hot,
                 "name": '豆瓣热门电视剧',
+                "api_path": "recommend/douban_tv_hot"
             },
             {
                 "func": RecommendChain().douban_tv_animation,
                 "name": '豆瓣热门动漫',
+                "api_path": "recommend/douban_tv_animation"
             },
             {
                 "func": RecommendChain().douban_movies,
                 "name": '豆瓣最新电影',
+                "api_path": "recommend/douban_movies"
             },
             {
                 "func": RecommendChain().douban_tvs,
                 "name": '豆瓣最新电视剧',
+                "api_path": "recommend/douban_tvs"
             },
             {
                 "func": RecommendChain().douban_movie_top250,
                 "name": '豆瓣电影TOP250',
+                "api_path": "recommend/douban_movie_top250"
             },
             {
                 "func": RecommendChain().douban_tv_weekly_chinese,
                 "name": '豆瓣国产剧集榜',
+                "api_path": "recommend/douban_tv_weekly_chinese"
             },
             {
                 "func": RecommendChain().douban_tv_weekly_global,
                 "name": '豆瓣全球剧集榜',
+                "api_path": "recommend/douban_tv_weekly_global"
             }
         ]
 
@@ -124,7 +137,7 @@ class FetchMediasAction(BaseAction):
         获取数据源
         """
         for s in self.__inner_sources:
-            if s['name'] == source:
+            if s['api_path'] == source:
                 return s
         return None
 
@@ -135,13 +148,14 @@ class FetchMediasAction(BaseAction):
         params = FetchMediasParams(**params)
         try:
             if params.source_type == "ranking":
-                for name in params.sources:
+                for api_path in params.sources:
                     if global_vars.is_workflow_stopped(workflow_id):
                         break
-                    source = self.__get_source(name)
+                    source = self.__get_source(api_path)
                     if not source:
                         continue
                     logger.info(f"获取媒体数据 {source} ...")
+                    name = source.get("name")
                     results = []
                     if source.get("func"):
                         results = source['func']()

app/actions/invoke_plugin.py

@@ -0,0 +1,72 @@
+from pydantic import Field
+
+from app.actions import BaseAction
+from app.core.plugin import PluginManager
+from app.log import logger
+from app.schemas import ActionParams, ActionContext
+
+
+class InvokePluginParams(ActionParams):
+    """
+    调用插件动作参数
+    """
+    plugin_id: str = Field(default=None, description="插件ID")
+    action_id: str = Field(default=None, description="动作ID")
+    action_params: dict = Field(default={}, description="动作参数")
+
+
+class InvokePluginAction(BaseAction):
+    """
+    调用插件
+    """
+
+    _success = False
+
+    def __init__(self, action_id: str):
+        super().__init__(action_id)
+        self._success = False
+
+    @classmethod
+    @property
+    def name(cls) -> str: # noqa
+        return "调用插件"
+
+    @classmethod
+    @property
+    def description(cls) -> str: # noqa
+        return "调用插件提供的动作"
+
+    @classmethod
+    @property
+    def data(cls) -> dict: # noqa
+        return InvokePluginParams().dict()
+
+    @property
+    def success(self) -> bool:
+        return self._success
+
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
+        """
+        执行插件定义的动作
+        """
+        params = InvokePluginParams(**params)
+        if not params.plugin_id or not params.action_id:
+            return context
+        try:
+            plugin_actions = PluginManager().get_plugin_actions(params.plugin_id)
+            if not plugin_actions:
+                logger.error(f"插件不存在: {params.plugin_id}")
+                return context
+            actions = plugin_actions[0].get("actions", [])
+            action = next((action for action in actions if action.action_id == params.action_id), None)
+            if not action or not action.get("func"):
+                logger.error(f"插件动作不存在: {params.plugin_id} - {params.action_id}")
+                return context
+            # 执行插件动作
+            self._success, context = action["func"](context, **params.action_params)
+        except Exception as e:
+            self._success = False
+            logger.error(f"调用插件动作失败: {e}")
+            return context
+        self.job_done()
+        return context

app/api/endpoints/login.py

@@ -11,7 +11,7 @@ from app.chain.mediaserver import MediaServerChain
 from app.core import security
 from app.core.config import settings
 from app.helper.sites import SitesHelper
-from app.utils.web import WebUtils
+from app.helper.wallpaper import WallpaperHelper
 
 router = APIRouter()
 
@@ -55,9 +55,11 @@ def wallpaper() -> Any:
     获取登录页面电影海报
     """
     if settings.WALLPAPER == "bing":
-        url = WebUtils.get_bing_wallpaper()
+        url = WallpaperHelper().get_bing_wallpaper()
     elif settings.WALLPAPER == "mediaserver":
         url = MediaServerChain().get_latest_wallpaper()
+    elif settings.WALLPAPER == "customize":
+        url = WallpaperHelper().get_customize_wallpaper()
     else:
         url = TmdbChain().get_random_wallpager()
     if url:
@@ -74,10 +76,12 @@ def wallpapers() -> Any:
     获取登录页面电影海报
     """
     if settings.WALLPAPER == "bing":
-        return WebUtils.get_bing_wallpapers()
+        return WallpaperHelper().get_bing_wallpapers()
     elif settings.WALLPAPER == "mediaserver":
         return MediaServerChain().get_latest_wallpapers()
     elif settings.WALLPAPER == "tmdb":
         return TmdbChain().get_trending_wallpapers()
+    elif settings.WALLPAPER == "customize":
+        return WallpaperHelper().get_customize_wallpapers()
     else:
         return []

app/api/endpoints/media.py

@@ -219,14 +219,13 @@ def detail(mediaid: str, type_name: str, title: Optional[str] = None, year: str
         )
         event = eventmanager.send_event(ChainEventType.MediaRecognizeConvert, event_data)
         # 使用事件返回的上下文数据
-        if event and event.event_data:
+        if event and event.event_data and event.event_data.media_dict:
             event_data: MediaRecognizeConvertEventData = event.event_data
-            if event_data.media_dict:
-                new_id = event_data.media_dict.get("id")
-                if event_data.convert_type == "themoviedb":
-                    mediainfo = MediaChain().recognize_media(tmdbid=new_id, mtype=mtype)
-                elif event_data.convert_type == "douban":
-                    mediainfo = MediaChain().recognize_media(doubanid=new_id, mtype=mtype)
+            new_id = event_data.media_dict.get("id")
+            if event_data.convert_type == "themoviedb":
+                mediainfo = MediaChain().recognize_media(tmdbid=new_id, mtype=mtype)
+            elif event_data.convert_type == "douban":
+                mediainfo = MediaChain().recognize_media(doubanid=new_id, mtype=mtype)
         elif title:
             # 使用名称识别兜底
             meta = MetaInfo(title)

app/api/endpoints/mediaserver.py

@@ -121,7 +121,7 @@ def not_exists(media_in: schemas.MediaInfo,
 
 
 @router.get("/latest", summary="最新入库条目", response_model=List[schemas.MediaServerPlayItem])
-def latest(server: str, count: Optional[int] = 18,
+def latest(server: str, count: Optional[int] = 20,
            userinfo: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     获取媒体服务器最新入库条目

app/api/endpoints/plugin.py

@@ -144,11 +144,11 @@ def all_plugins(_: schemas.TokenPayload = Depends(get_current_active_superuser),
     local_plugins = PluginManager().get_local_plugins()
     # 已安装插件
     installed_plugins = [plugin for plugin in local_plugins if plugin.installed]
-    # 未安装的本地插件
-    not_installed_plugins = [plugin for plugin in local_plugins if not plugin.installed]
     if state == "installed":
         return installed_plugins
-
+        
+    # 未安装的本地插件
+    not_installed_plugins = [plugin for plugin in local_plugins if not plugin.installed]
     # 在线插件
     online_plugins = PluginManager().get_online_plugins()
     if not online_plugins:
@@ -177,6 +177,7 @@ def all_plugins(_: schemas.TokenPayload = Depends(get_current_active_superuser),
     if state == "market":
         # 返回未安装的插件
         return market_plugins
+        
     # 返回所有插件
     return installed_plugins + market_plugins
 
@@ -374,6 +375,71 @@ def plugin_static_file(plugin_id: str, filepath: str):
         raise HTTPException(status_code=500, detail="Internal Server Error")
 
 
+@router.get("/folders", summary="获取插件文件夹配置", response_model=dict)
+def get_plugin_folders(_: schemas.TokenPayload = Depends(get_current_active_superuser)) -> dict:
+    """
+    获取插件文件夹分组配置
+    """
+    try:
+        result = SystemConfigOper().get(SystemConfigKey.PluginFolders) or {}
+        return result
+    except Exception as e:
+        logger.error(f"[文件夹API] 获取文件夹配置失败: {str(e)}")
+        return {}
+
+
+@router.post("/folders", summary="保存插件文件夹配置", response_model=schemas.Response)
+def save_plugin_folders(folders: dict, _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
+    """
+    保存插件文件夹分组配置
+    """
+    try:
+        SystemConfigOper().set(SystemConfigKey.PluginFolders, folders)
+        return schemas.Response(success=True)
+    except Exception as e:
+        logger.error(f"[文件夹API] 保存文件夹配置失败: {str(e)}")
+        return schemas.Response(success=False, message=str(e))
+
+
+@router.post("/folders/{folder_name}", summary="创建插件文件夹", response_model=schemas.Response)
+def create_plugin_folder(folder_name: str, _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
+    """
+    创建新的插件文件夹
+    """
+    folders = SystemConfigOper().get(SystemConfigKey.PluginFolders) or {}
+    if folder_name not in folders:
+        folders[folder_name] = []
+        SystemConfigOper().set(SystemConfigKey.PluginFolders, folders)
+        return schemas.Response(success=True, message=f"文件夹 '{folder_name}' 创建成功")
+    else:
+        return schemas.Response(success=False, message=f"文件夹 '{folder_name}' 已存在")
+
+
+@router.delete("/folders/{folder_name}", summary="删除插件文件夹", response_model=schemas.Response)
+def delete_plugin_folder(folder_name: str, _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
+    """
+    删除插件文件夹
+    """
+    folders = SystemConfigOper().get(SystemConfigKey.PluginFolders) or {}
+    if folder_name in folders:
+        del folders[folder_name]
+        SystemConfigOper().set(SystemConfigKey.PluginFolders, folders)
+        return schemas.Response(success=True, message=f"文件夹 '{folder_name}' 删除成功")
+    else:
+        return schemas.Response(success=False, message=f"文件夹 '{folder_name}' 不存在")
+
+
+@router.put("/folders/{folder_name}/plugins", summary="更新文件夹中的插件", response_model=schemas.Response)
+def update_folder_plugins(folder_name: str, plugin_ids: List[str], _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
+    """
+    更新指定文件夹中的插件列表
+    """
+    folders = SystemConfigOper().get(SystemConfigKey.PluginFolders) or {}
+    folders[folder_name] = plugin_ids
+    SystemConfigOper().set(SystemConfigKey.PluginFolders, folders)
+    return schemas.Response(success=True, message=f"文件夹 '{folder_name}' 中的插件已更新")
+
+
 @router.get("/{plugin_id}", summary="获取插件配置")
 def plugin_config(plugin_id: str,
                   _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> dict:

app/api/endpoints/system.py

@@ -36,8 +36,8 @@ from app.schemas.types import SystemConfigKey
 from app.utils.crypto import HashUtils
 from app.utils.http import RequestUtils
 from app.utils.security import SecurityUtils
-from app.utils.system import SystemUtils
 from app.utils.url import UrlUtils
+from helper.system import SystemHelper
 from version import APP_VERSION
 
 router = APIRouter()
@@ -474,12 +474,12 @@ def restart_system(_: User = Depends(get_current_active_superuser)):
     """
     重启系统（仅管理员）
     """
-    if not SystemUtils.can_restart():
+    if not SystemHelper.can_restart():
         return schemas.Response(success=False, message="当前运行环境不支持重启操作！")
     # 标识停止事件
     global_vars.stop_system()
     # 执行重启
-    ret, msg = SystemUtils.restart()
+    ret, msg = SystemHelper.restart()
     return schemas.Response(success=ret, message=msg)
 
 

app/api/endpoints/workflow.py

@@ -6,6 +6,7 @@ from sqlalchemy.orm import Session
 
 from app import schemas
 from app.core.config import global_vars
+from app.core.plugin import PluginManager
 from app.core.workflow import WorkFlowManager
 from app.db import get_db
 from app.db.models.workflow import Workflow
@@ -43,6 +44,14 @@ def create_workflow(workflow: schemas.Workflow,
     return schemas.Response(success=True, message="创建工作流成功")
 
 
+@router.get("/plugin/actions", summary="查询插件动作", response_model=List[dict])
+def list_plugin_actions(plugin_id: str = None, _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    获取所有动作
+    """
+    return PluginManager().get_plugin_actions(plugin_id)
+
+
 @router.get("/actions", summary="所有动作", response_model=List[dict])
 def list_actions(_: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
     """

app/chain/__init__.py

@@ -67,7 +67,7 @@ class ChainBase(metaclass=ABCMeta):
         """
         try:
             with open(settings.TEMP_PATH / filename, 'wb') as f:
-                pickle.dump(cache, f) # noqa
+                pickle.dump(cache, f)  # noqa
         except Exception as err:
             logger.error(f"保存缓存 {filename} 出错：{str(err)}")
         finally:
@@ -374,7 +374,7 @@ class ChainBase(metaclass=ABCMeta):
         return self.run_module("search_torrents", site=site, keywords=keywords,
                                mtype=mtype, page=page)
 
-    def refresh_torrents(self, site: dict, keyword: Optional[str] = None, 
+    def refresh_torrents(self, site: dict, keyword: Optional[str] = None,
                          cat: Optional[str] = None, page: Optional[int] = 0) -> List[TorrentInfo]:
         """
         获取站点最新一页的种子，多个站点需要多线程处理
@@ -543,12 +543,12 @@ class ChainBase(metaclass=ABCMeta):
         return self.run_module("media_files", mediainfo=mediainfo)
 
     def post_message(self,
-                    message: Optional[Notification] = None,
-                    meta: Optional[MetaBase] = None,
-                    mediainfo: Optional[MediaInfo] = None,
-                    torrentinfo: Optional[TorrentInfo] = None,
-                    transferinfo: Optional[TransferInfo] = None,
-                    **kwargs) -> None:
+                     message: Optional[Notification] = None,
+                     meta: Optional[MetaBase] = None,
+                     mediainfo: Optional[MediaInfo] = None,
+                     torrentinfo: Optional[TorrentInfo] = None,
+                     transferinfo: Optional[TransferInfo] = None,
+                     **kwargs) -> None:
         """
         发送消息
         :param message:  Notification实例
@@ -561,7 +561,7 @@ class ChainBase(metaclass=ABCMeta):
         """
         # 渲染消息
         message = MessageTemplateHelper.render(message=message, meta=meta, mediainfo=mediainfo,
-                                       torrentinfo=torrentinfo, transferinfo=transferinfo, **kwargs)
+                                               torrentinfo=torrentinfo, transferinfo=transferinfo, **kwargs)
         # 保存消息
         self.messagehelper.put(message, role="user", title=message.title)
         self.messageoper.add(**message.dict())
@@ -643,7 +643,7 @@ class ChainBase(metaclass=ABCMeta):
         self.messageoper.add(**message.dict(), note=note_list)
         return self.messagequeue.send_message("post_torrents_message", message=message, torrents=torrents)
 
-    def metadata_img(self, mediainfo: MediaInfo, 
+    def metadata_img(self, mediainfo: MediaInfo,
                      season: Optional[int] = None, episode: Optional[int] = None) -> Optional[dict]:
         """
         获取图片名称和url

app/chain/message.py

@@ -422,13 +422,17 @@ class MessageChain(ChainBase):
                     or text.find("继续") != -1:
                 # 聊天
                 content = text
-                action = "chat"
+                action = "Chat"
+            elif StringUtils.is_link(text):
+                # 链接
+                content = text
+                action = "Link"
             else:
                 # 搜索
                 content = text
                 action = "Search"
 
-            if action != "chat":
+            if action in ["Search", "ReSearch", "Subscribe", "ReSubscribe"]:
                 # 搜索
                 meta, medias = self.mediachain.search(content)
                 # 识别

app/chain/search.py

@@ -329,36 +329,36 @@ class SearchChain(ChainBase):
         self.progress.update(value=0,
                              text=f"开始搜索，共 {total_num} 个站点 ...",
                              key=ProgressKey.Search)
-        # 多线程
-        executor = ThreadPoolExecutor(max_workers=len(indexer_sites))
-        all_task = []
-        for site in indexer_sites:
-            if area == "imdbid":
-                # 搜索IMDBID
-                task = executor.submit(self.search_torrents, site=site,
-                                       keywords=[mediainfo.imdb_id] if mediainfo else None,
-                                       mtype=mediainfo.type if mediainfo else None,
-                                       page=page)
-            else:
-                # 搜索标题
-                task = executor.submit(self.search_torrents, site=site,
-                                       keywords=keywords,
-                                       mtype=mediainfo.type if mediainfo else None,
-                                       page=page)
-            all_task.append(task)
         # 结果集
         results = []
-        for future in as_completed(all_task):
-            if global_vars.is_system_stopped:
-                break
-            finish_count += 1
-            result = future.result()
-            if result:
-                results.extend(result)
-            logger.info(f"站点搜索进度：{finish_count} / {total_num}")
-            self.progress.update(value=finish_count / total_num * 100,
-                                 text=f"正在搜索{keywords or ''}，已完成 {finish_count} / {total_num} 个站点 ...",
-                                 key=ProgressKey.Search)
+        # 多线程
+        with ThreadPoolExecutor(max_workers=len(indexer_sites)) as executor:
+            all_task = []
+            for site in indexer_sites:
+                if area == "imdbid":
+                    # 搜索IMDBID
+                    task = executor.submit(self.search_torrents, site=site,
+                                           keywords=[mediainfo.imdb_id] if mediainfo else None,
+                                           mtype=mediainfo.type if mediainfo else None,
+                                           page=page)
+                else:
+                    # 搜索标题
+                    task = executor.submit(self.search_torrents, site=site,
+                                           keywords=keywords,
+                                           mtype=mediainfo.type if mediainfo else None,
+                                           page=page)
+                all_task.append(task)
+            for future in as_completed(all_task):
+                if global_vars.is_system_stopped:
+                    break
+                finish_count += 1
+                result = future.result()
+                if result:
+                    results.extend(result)
+                logger.info(f"站点搜索进度：{finish_count} / {total_num}")
+                self.progress.update(value=finish_count / total_num * 100,
+                                     text=f"正在搜索{keywords or ''}，已完成 {finish_count} / {total_num} 个站点 ...",
+                                     key=ProgressKey.Search)
         # 计算耗时
         end_time = datetime.now()
         # 更新进度

app/chain/subscribe.py

@@ -561,6 +561,26 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
             logger.debug(f"match lock acquired at {datetime.now()}")
             # 所有订阅
             subscribes = self.subscribeoper.list(self.get_states_for_search('R'))
+
+            # 预识别所有未识别的种子
+            processed_torrents = {}
+            for domain, contexts in torrents.items():
+                processed_torrents[domain] = []
+                for context in contexts:
+                    # 复制上下文避免修改原始数据
+                    _context = copy.deepcopy(context)
+                    torrent_meta = _context.meta_info
+                    torrent_mediainfo = _context.media_info
+
+                    # 如果种子未识别，尝试识别
+                    if not torrent_mediainfo or (not torrent_mediainfo.tmdb_id and not torrent_mediainfo.douban_id):
+                        torrent_mediainfo = self.recognize_media(meta=torrent_meta)
+                        if torrent_mediainfo:
+                            # 更新种子缓存
+                            context.media_info = torrent_mediainfo
+                    # 添加已预处理
+                    processed_torrents[domain].append(_context)
+
             # 遍历订阅
             for subscribe in subscribes:
                 if global_vars.is_system_stopped:
@@ -604,9 +624,9 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                 else:
                     custom_words_list = None
 
-                # 遍历缓存种子
+                # 遍历预识别后的种子
                 _match_context = []
-                for domain, contexts in torrents.items():
+                for domain, contexts in processed_torrents.items():
                     if global_vars.is_system_stopped:
                         break
                     if domains and domain not in domains:
@@ -638,32 +658,28 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                                                         custom_words=custom_words_list)
                                 # 更新元数据缓存
                                 context.meta_info = torrent_meta
-                                # 媒体信息需要重新识别
-                                torrent_mediainfo = None
-
-                        # 先判断是否有没识别的种子，否则重新识别
-                        if not torrent_mediainfo \
-                                or (not torrent_mediainfo.tmdb_id and not torrent_mediainfo.douban_id):
-                            # 重新识别媒体信息
-                            torrent_mediainfo = self.recognize_media(meta=torrent_meta,
-                                                                     episode_group=subscribe.episode_group)
-                            if torrent_mediainfo:
-                                # 更新种子缓存
-                                context.media_info = torrent_mediainfo
-                            else:
-                                # 通过标题匹配兜底
-                                logger.warn(
-                                    f'{torrent_info.site_name} - {torrent_info.title} 重新识别失败，尝试通过标题匹配...')
-                                if self.torrenthelper.match_torrent(mediainfo=mediainfo,
-                                                                    torrent_meta=torrent_meta,
-                                                                    torrent=torrent_info):
-                                    # 匹配成功
-                                    logger.info(
-                                        f'{mediainfo.title_year} 通过标题匹配到可选资源：{torrent_info.site_name} - {torrent_info.title}')
-                                    torrent_mediainfo = mediainfo
+                                # 重新识别媒体信息
+                                torrent_mediainfo = self.recognize_media(meta=torrent_meta,
+                                                                         episode_group=subscribe.episode_group)
+                                if torrent_mediainfo:
+                                    # 更新种子缓存
                                     context.media_info = torrent_mediainfo
-                                else:
-                                    continue
+
+                        # 如果仍然没有识别到媒体信息，尝试标题匹配
+                        if not torrent_mediainfo or (not torrent_mediainfo.tmdb_id and not torrent_mediainfo.douban_id):
+                            logger.warn(
+                                f'{torrent_info.site_name} - {torrent_info.title} 重新识别失败，尝试通过标题匹配...')
+                            if self.torrenthelper.match_torrent(mediainfo=mediainfo,
+                                                                torrent_meta=torrent_meta,
+                                                                torrent=torrent_info):
+                                # 匹配成功
+                                logger.info(
+                                    f'{mediainfo.title_year} 通过标题匹配到可选资源：{torrent_info.site_name} - {torrent_info.title}')
+                                torrent_mediainfo = mediainfo
+                                # 更新种子缓存
+                                context.media_info = mediainfo
+                            else:
+                                continue
 
                         # 直接比对媒体信息
                         if torrent_mediainfo and (torrent_mediainfo.tmdb_id or torrent_mediainfo.douban_id):

app/chain/system.py

@@ -10,6 +10,7 @@ from app.schemas import Notification, MessageChannel
 from app.utils.http import RequestUtils
 from app.utils.singleton import Singleton
 from app.utils.system import SystemUtils
+from helper.system import SystemHelper
 from version import FRONTEND_VERSION, APP_VERSION
 
 
@@ -45,7 +46,8 @@ class SystemChain(ChainBase, metaclass=Singleton):
                 "channel": channel.value,
                 "userid": userid
             }, self._restart_file)
-        SystemUtils.restart()
+        # 重启
+        SystemHelper.restart()
 
     def __get_version_message(self) -> str:
         """

app/core/config.py

@@ -1,4 +1,5 @@
 import copy
+import json
 import os
 import re
 import secrets
@@ -89,6 +90,8 @@ class ConfigModel(BaseModel):
     PROXY_HOST: Optional[str] = None
     # 登录页面电影海报,tmdb/bing/mediaserver
     WALLPAPER: str = "tmdb"
+    # 自定义壁纸api地址
+    CUSTOMIZE_WALLPAPER_API_URL: Optional[str] = None
     # 媒体搜索来源 themoviedb/douban/bangumi，多个用,分隔
     SEARCH_SOURCE: str = "themoviedb,douban,bangumi"
     # 媒体识别来源 themoviedb/douban
@@ -218,7 +221,16 @@ class ConfigModel(BaseModel):
                           "https://github.com/honue/MoviePilot-Plugins,"
                           "https://github.com/InfinityPacer/MoviePilot-Plugins,"
                           "https://github.com/DDS-Derek/MoviePilot-Plugins,"
-                          "https://github.com/madrays/MoviePilot-Plugins")
+                          "https://github.com/madrays/MoviePilot-Plugins,"
+                          "https://github.com/justzerock/MoviePilot-Plugins,"
+                          "https://github.com/KoWming/MoviePilot-Plugins,"
+                          "https://github.com/wikrin/MoviePilot-Plugins,"
+                          "https://github.com/HankunYu/MoviePilot-Plugins,"
+                          "https://github.com/baozaodetudou/MoviePilot-Plugins,"
+                          "https://github.com/Aqr-K/MoviePilot-Plugins,"
+                          "https://github.com/hotlcc/MoviePilot-Plugins-Third,"
+                          "https://github.com/gxterry/MoviePilot-Plugins,"
+                          "https://github.com/DzAvril/MoviePilot-Plugins")
     # 插件安装数据共享
     PLUGIN_STATISTIC_SHARE: bool = True
     # 是否开启插件热加载
@@ -268,6 +280,8 @@ class ConfigModel(BaseModel):
     TOKENIZED_SEARCH: bool = False
     # 为指定默认字幕添加.default后缀
     DEFAULT_SUB: Optional[str] = "zh-cn"
+    # Docker Client API地址
+    DOCKER_CLIENT_API: Optional[str] = "tcp://127.0.0.1:38379"
 
 
 class Settings(BaseSettings, ConfigModel, LogConfigModel):
@@ -359,13 +373,16 @@ class Settings(BaseSettings, ConfigModel, LogConfigModel):
                 if field_name in fields_not_keep_spaces:
                     value = re.sub(r"\s+", "", value)
                 return value, str(value) != str(original_value)
-            # # 后续考虑支持 list 类型的处理
-            # elif expected_type is list:
-            #     if isinstance(value, list):
-            #         return value, False
-            #     if isinstance(value, str):
-            #         items = [item.strip() for item in value.split(",") if item.strip()]
-            #         return items, items != original_value.split(",")
+            # 支持 list 类型的处理
+            elif expected_type is list:
+                if isinstance(value, list):
+                    return value, str(value) != str(original_value)
+                if isinstance(value, str):
+                    items = json.loads(value)
+                    if isinstance(original_value, list):
+                        return items, items != original_value
+                    else:
+                        return items, str(items) != str(original_value)
             # 可根据需要添加更多类型处理
             else:
                 return value, str(value) != str(original_value)
@@ -406,7 +423,14 @@ class Settings(BaseSettings, ConfigModel, LogConfigModel):
             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 "")
+            # 如果是列表、字典或集合类型，将其转换为JSON字符串
+            if isinstance(converted_value, (list, dict, set)):
+                value_to_write = json.dumps(converted_value)
+            else:
+                value_to_write = str(converted_value) if converted_value is not None else ""
+
+            set_key(dotenv_path=SystemUtils.get_env_path(), key_to_set=field.name, value_to_set=value_to_write,
+                    quote_mode="always")
             if is_converted:
                 logger.info(f"配置项 '{field.name}' 已自动修正并写入到 'app.env' 文件")
         return True, message

app/core/meta/metabase.py

@@ -582,6 +582,12 @@ class MetaBase(object):
         # Part
         if not self.part:
             self.part = meta.part
+        # tmdbid
+        if not self.tmdbid and meta.tmdbid:
+            self.tmdbid = meta.tmdbid
+        # doubanid
+        if not self.doubanid and meta.doubanid:
+            self.doubanid = meta.doubanid
 
     def to_dict(self):
         """

app/core/meta/metavideo.py

@@ -31,7 +31,7 @@ class MetaVideo(MetaBase):
     _part_re = r"(^PART[0-9ABI]{0,2}$|^CD[0-9]{0,2}$|^DVD[0-9]{0,2}$|^DISK[0-9]{0,2}$|^DISC[0-9]{0,2}$)"
     _roman_numerals = r"^(?=[MDCLXVI])M*(C[MD]|D?C{0,3})(X[CL]|L?X{0,3})(I[XV]|V?I{0,3})$"
     _source_re = r"^BLURAY$|^HDTV$|^UHDTV$|^HDDVD$|^WEBRIP$|^DVDRIP$|^BDRIP$|^BLU$|^WEB$|^BD$|^HDRip$|^REMUX$|^UHD$"
-    _effect_re = r"^SDR$|^HDR\d*$|^DOLBY$|^DOVI$|^DV$|^3D$|^REPACK$"
+    _effect_re = r"^SDR$|^HDR\d*$|^DOLBY$|^DOVI$|^DV$|^3D$|^REPACK$|^HLG$|^HDR10(\+|Plus)$"
     _resources_type_re = r"%s|%s" % (_source_re, _effect_re)
     _name_no_begin_re = r"^[\[【].+?[\]】]"
     _name_no_chinese_re = r".*版|.*字幕"
@@ -50,8 +50,8 @@ class MetaVideo(MetaBase):
                         r"|CD[\s.]*[1-9]|DVD[\s.]*[1-9]|DISK[\s.]*[1-9]|DISC[\s.]*[1-9]|\s+GB"
     _resources_pix_re = r"^[SBUHD]*(\d{3,4}[PI]+)|\d{3,4}X(\d{3,4})"
     _resources_pix_re2 = r"(^[248]+K)"
-    _video_encode_re = r"^[HX]26[45]$|^AVC$|^HEVC$|^VC\d?$|^MPEG\d?$|^Xvid$|^DivX$|^HDR\d*$"
-    _audio_encode_re = r"^DTS\d?$|^DTSHD$|^DTSHDMA$|^Atmos$|^TrueHD\d?$|^AC3$|^\dAudios?$|^DDP\d?$|^DD\d?$|^LPCM\d?$|^AAC\d?$|^FLAC\d?$|^HD\d?$|^MA\d?$"
+    _video_encode_re = r"^(H26[45])$|^(x26[45])$|^AVC$|^HEVC$|^VC\d?$|^MPEG\d?$|^Xvid$|^DivX$|^AV1$|^HDR\d*$|^AVS(\+|[23])$"
+    _audio_encode_re = r"^DTS\d?$|^DTSHD$|^DTSHDMA$|^Atmos$|^TrueHD\d?$|^AC3$|^\dAudios?$|^DDP\d?$|^DD\+\d?$|^DD\d?$|^LPCM\d?$|^AAC\d?$|^FLAC\d?$|^HD\d?$|^MA\d?$|^HR\d?$|^Opus\d?$|^Vorbis\d?$"
 
     def __init__(self, title: str, subtitle: str = None, isfile: bool = False):
         """
@@ -592,7 +592,12 @@ class MetaVideo(MetaBase):
             self._stop_name_flag = True
             self._last_token_type = "videoencode"
             if not self.video_encode:
-                self.video_encode = re_res.group(1).upper()
+                if re_res.group(2):
+                    self.video_encode = re_res.group(2).upper()
+                elif re_res.group(3):
+                    self.video_encode = re_res.group(3).lower()
+                else:
+                    self.video_encode = re_res.group(1).upper()
                 self._last_token = self.video_encode
             elif self.video_encode == "10bit":
                 self.video_encode = f"{re_res.group(1).upper()} 10bit"

app/core/metainfo.py

@@ -120,41 +120,69 @@ def find_metainfo(title: str) -> Tuple[str, dict]:
         return title, metainfo
     # 从标题中提取媒体信息 格式为{[tmdbid=xxx;type=xxx;s=xxx;e=xxx]}
     results = re.findall(r'(?<={\[)[\W\w]+(?=]})', title)
-    if not results:
-        return title, metainfo
-    for result in results:
-        # 查找tmdbid信息
-        tmdbid = re.findall(r'(?<=tmdbid=)\d+', result)
-        if tmdbid and tmdbid[0].isdigit():
-            metainfo['tmdbid'] = tmdbid[0]
-        # 查找豆瓣id信息
-        doubanid = re.findall(r'(?<=doubanid=)\d+', result)
-        if doubanid and doubanid[0].isdigit():
-            metainfo['doubanid'] = doubanid[0]
-        # 查找媒体类型
-        mtype = re.findall(r'(?<=type=)\w+', result)
-        if mtype:
-            if mtype[0] == "movies":
-                metainfo['type'] = MediaType.MOVIE
-            elif mtype[0] == "tv":
-                metainfo['type'] = MediaType.TV
-        # 查找季信息
-        begin_season = re.findall(r'(?<=s=)\d+', result)
-        if begin_season and begin_season[0].isdigit():
-            metainfo['begin_season'] = int(begin_season[0])
-        end_season = re.findall(r'(?<=s=\d+-)\d+', result)
-        if end_season and end_season[0].isdigit():
-            metainfo['end_season'] = int(end_season[0])
-        # 查找集信息
-        begin_episode = re.findall(r'(?<=e=)\d+', result)
-        if begin_episode and begin_episode[0].isdigit():
-            metainfo['begin_episode'] = int(begin_episode[0])
-        end_episode = re.findall(r'(?<=e=\d+-)\d+', result)
-        if end_episode and end_episode[0].isdigit():
-            metainfo['end_episode'] = int(end_episode[0])
-        # 去除title中该部分
-        if tmdbid or mtype or begin_season or end_season or begin_episode or end_episode:
-            title = title.replace(f"{{[{result}]}}", '')
+    if results:
+        for result in results:
+            # 查找tmdbid信息
+            tmdbid = re.findall(r'(?<=tmdbid=)\d+', result)
+            if tmdbid and tmdbid[0].isdigit():
+                metainfo['tmdbid'] = tmdbid[0]
+            # 查找豆瓣id信息
+            doubanid = re.findall(r'(?<=doubanid=)\d+', result)
+            if doubanid and doubanid[0].isdigit():
+                metainfo['doubanid'] = doubanid[0]
+            # 查找媒体类型
+            mtype = re.findall(r'(?<=type=)\w+', result)
+            if mtype:
+                if mtype[0] == "movies":
+                    metainfo['type'] = MediaType.MOVIE
+                elif mtype[0] == "tv":
+                    metainfo['type'] = MediaType.TV
+            # 查找季信息
+            begin_season = re.findall(r'(?<=s=)\d+', result)
+            if begin_season and begin_season[0].isdigit():
+                metainfo['begin_season'] = int(begin_season[0])
+            end_season = re.findall(r'(?<=s=\d+-)\d+', result)
+            if end_season and end_season[0].isdigit():
+                metainfo['end_season'] = int(end_season[0])
+            # 查找集信息
+            begin_episode = re.findall(r'(?<=e=)\d+', result)
+            if begin_episode and begin_episode[0].isdigit():
+                metainfo['begin_episode'] = int(begin_episode[0])
+            end_episode = re.findall(r'(?<=e=\d+-)\d+', result)
+            if end_episode and end_episode[0].isdigit():
+                metainfo['end_episode'] = int(end_episode[0])
+            # 去除title中该部分
+            if tmdbid or mtype or begin_season or end_season or begin_episode or end_episode:
+                title = title.replace(f"{{[{result}]}}", '')
+    
+    # 支持Emby格式的ID标签
+    # 1. [tmdbid=xxxx] 或 [tmdbid-xxxx] 格式
+    tmdb_match = re.search(r'\[tmdbid[=\-](\d+)\]', title)
+    if tmdb_match:
+        metainfo['tmdbid'] = tmdb_match.group(1)
+        title = re.sub(r'\[tmdbid[=\-](\d+)\]', '', title).strip()
+    
+    # 2. [tmdb=xxxx] 或 [tmdb-xxxx] 格式
+    if not metainfo['tmdbid']:
+        tmdb_match = re.search(r'\[tmdb[=\-](\d+)\]', title)
+        if tmdb_match:
+            metainfo['tmdbid'] = tmdb_match.group(1)
+            title = re.sub(r'\[tmdb[=\-](\d+)\]', '', title).strip()
+    
+    # 3. {tmdbid=xxxx} 或 {tmdbid-xxxx} 格式
+    if not metainfo['tmdbid']:
+        tmdb_match = re.search(r'\{tmdbid[=\-](\d+)\}', title)
+        if tmdb_match:
+            metainfo['tmdbid'] = tmdb_match.group(1)
+            title = re.sub(r'\{tmdbid[=\-](\d+)\}', '', title).strip()
+    
+    # 4. {tmdb=xxxx} 或 {tmdb-xxxx} 格式
+    if not metainfo['tmdbid']:
+        tmdb_match = re.search(r'\{tmdb[=\-](\d+)\}', title)
+        if tmdb_match:
+            metainfo['tmdbid'] = tmdb_match.group(1)
+            title = re.sub(r'\{tmdb[=\-](\d+)\}', '', title).strip()
+    
     # 计算季集总数
     if metainfo.get('begin_season') and metainfo.get('end_season'):
         if metainfo['begin_season'] > metainfo['end_season']:
@@ -169,3 +197,67 @@ def find_metainfo(title: str) -> Tuple[str, dict]:
     elif metainfo.get('begin_episode') and not metainfo.get('end_episode'):
         metainfo['total_episode'] = 1
     return title, metainfo
+
+
+def test_find_metainfo():
+    """
+    测试find_metainfo函数的各种ID识别格式
+    """
+    test_cases = [
+        # 测试 [tmdbid=xxxx] 格式
+        ("The Vampire Diaries (2009) [tmdbid=18165]", "18165"),
+        # 测试 [tmdbid-xxxx] 格式
+        ("Inception (2010) [tmdbid-27205]", "27205"),
+        # 测试 [tmdb=xxxx] 格式
+        ("Breaking Bad (2008) [tmdb=1396]", "1396"),
+        # 测试 [tmdb-xxxx] 格式
+        ("Interstellar (2014) [tmdb-157336]", "157336"),
+        # 测试 {tmdbid=xxxx} 格式
+        ("Stranger Things (2016) {tmdbid=66732}", "66732"),
+        # 测试 {tmdbid-xxxx} 格式
+        ("The Matrix (1999) {tmdbid-603}", "603"),
+        # 测试 {tmdb=xxxx} 格式
+        ("Game of Thrones (2011) {tmdb=1399}", "1399"),
+        # 测试 {tmdb-xxxx} 格式
+        ("Avatar (2009) {tmdb-19995}", "19995"),
+    ]
+    
+    for title, expected_tmdbid in test_cases:
+        cleaned_title, metainfo = find_metainfo(title)
+        found_tmdbid = metainfo.get('tmdbid')
+        
+        print(f"原标题: {title}")
+        print(f"清理后标题: {cleaned_title}")
+        print(f"期望的tmdbid: {expected_tmdbid}")
+        print(f"识别的tmdbid: {found_tmdbid}")
+        print(f"结果: {'通过' if found_tmdbid == expected_tmdbid else '失败'}")
+        print("-" * 50)
+
+
+def test_meta_info_path():
+    """
+    测试MetaInfoPath函数
+    """
+    # 测试文件路径
+    path_tests = [
+        # 文件名中包含tmdbid
+        Path("/movies/The Vampire Diaries (2009) [tmdbid=18165]/The.Vampire.Diaries.S01E01.1080p.mkv"),
+        # 目录名中包含tmdbid
+        Path("/movies/Inception (2010) [tmdbid-27205]/Inception.2010.1080p.mkv"),
+        # 父目录名中包含tmdbid
+        Path("/movies/Breaking Bad (2008) [tmdb=1396]/Season 1/Breaking.Bad.S01E01.1080p.mkv"),
+        # 祖父目录名中包含tmdbid
+        Path("/tv/Game of Thrones (2011) {tmdb=1399}/Season 1/Game.of.Thrones.S01E01.1080p.mkv"),
+    ]
+    
+    for path in path_tests:
+        meta = MetaInfoPath(path)
+        print(f"测试路径: {path}")
+        print(f"识别结果: tmdbid={meta.tmdbid}")
+        print("-" * 50)
+
+
+if __name__ == "__main__":
+    # 运行测试函数
+    # test_find_metainfo()
+    test_meta_info_path()

app/core/plugin.py

@@ -536,6 +536,35 @@ class PluginManager(metaclass=Singleton):
                     logger.error(f"获取插件 {plugin_id} 模块出错：{str(e)}")
         return ret_modules
 
+    def get_plugin_actions(self, pid: Optional[str] = None) -> List[Dict[str, Any]]:
+        """
+        获取插件动作
+        [{
+            "id": "动作ID",
+            "name": "动作名称",
+            "func": self.xxx,
+            "kwargs": {} # 需要附加传递的参数
+        }]
+        """
+        ret_actions = []
+        for plugin_id, plugin in self._running_plugins.items():
+            if pid and pid != plugin_id:
+                continue
+            if hasattr(plugin, "get_actions") and ObjectUtils.check_method(plugin.get_actions):
+                try:
+                    if not plugin.get_state():
+                        continue
+                    actions = plugin.get_actions()
+                    if actions:
+                        ret_actions.append({
+                            "plugin_id": plugin_id,
+                            "plugin_name": plugin.plugin_name,
+                            "actions": actions
+                        })
+                except Exception as e:
+                    logger.error(f"获取插件 {plugin_id} 动作出错：{str(e)}")
+        return ret_actions
+
     @staticmethod
     def get_plugin_remote_entry(plugin_id: str, dist_path: str) -> str:
         """

app/helper/plugin.py

@@ -2,6 +2,8 @@ import sys
 import json
 import shutil
 import traceback
+import site
+import importlib
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Set
 
@@ -452,7 +454,7 @@ class PluginHelper(metaclass=Singleton):
     @staticmethod
     def __pip_install_with_fallback(requirements_file: Path) -> Tuple[bool, str]:
         """
-        使用自动降级策略，PIP 安装依赖，优先级依次为镜像站、代理、直连
+        使用自动降级策略安装依赖，并确保新安装的包可被动态导入
         :param requirements_file: 依赖的 requirements.txt 文件路径
         :return: (是否成功, 错误信息)
         """
@@ -466,12 +468,25 @@ class PluginHelper(metaclass=Singleton):
             strategies.append(("代理", base_cmd + ["--proxy", settings.PROXY_HOST]))
         strategies.append(("直连", base_cmd))
 
+        # 记录当前已安装的包，以便后续刷新
+        before_installation = set(sys.modules.keys())
+
         # 遍历策略进行安装
         for strategy_name, pip_command in strategies:
             logger.debug(f"[PIP] 尝试使用策略：{strategy_name} 安装依赖，命令：{' '.join(pip_command)}")
             success, message = SystemUtils.execute_with_subprocess(pip_command)
             if success:
                 logger.debug(f"[PIP] 策略：{strategy_name} 安装依赖成功，输出：{message}")
+                # 安装成功后刷新Python的模块系统
+                importlib.reload(site)
+                # 获取新安装的模块
+                current_modules = set(sys.modules.keys())
+                new_modules = current_modules - before_installation
+                # 重新加载新安装的模块
+                for module in new_modules:
+                    if module in sys.modules:
+                        del sys.modules[module]
+                logger.debug(f"[PIP] 已刷新导入系统，新加载的模块: {new_modules}")
                 return True, message
             else:
                 logger.error(f"[PIP] 策略：{strategy_name} 安装依赖失败，错误信息：{message}")

app/helper/resource.py

@@ -8,6 +8,7 @@ from app.utils.http import RequestUtils
 from app.utils.singleton import Singleton
 from app.utils.string import StringUtils
 from app.utils.system import SystemUtils
+from helper.system import SystemHelper
 
 
 class ResourceHelper(metaclass=Singleton):
@@ -32,80 +33,80 @@ class ResourceHelper(metaclass=Singleton):
         检测是否有更新，如有则下载安装
         """
         if not settings.AUTO_UPDATE_RESOURCE:
-            return
+            return None
         if SystemUtils.is_frozen():
-            return
+            return None
         logger.info("开始检测资源包版本...")
         res = RequestUtils(proxies=self.proxies, headers=settings.GITHUB_HEADERS, timeout=10).get_res(self._repo)
         if res:
             try:
                 resource_info = json.loads(res.text)
+                online_version = resource_info.get("version")
+                if online_version:
+                    logger.info(f"最新资源包版本：v{online_version}")
+                    # 需要更新的资源包
+                    need_updates = {}
+                    # 资源明细
+                    resources: dict = resource_info.get("resources") or {}
+                    for rname, resource in resources.items():
+                        rtype = resource.get("type")
+                        platform = resource.get("platform")
+                        target = resource.get("target")
+                        version = resource.get("version")
+                        # 判断平台
+                        if platform and platform != SystemUtils.platform():
+                            continue
+                        # 判断版本号
+                        if rtype == "auth":
+                            # 站点认证资源
+                            local_version = self.siteshelper.auth_version
+                        elif rtype == "sites":
+                            # 站点索引资源
+                            local_version = self.siteshelper.indexer_version
+                        else:
+                            continue
+                        if StringUtils.compare_version(version, ">", local_version):
+                            logger.info(f"{rname} 资源包有更新，最新版本：v{version}")
+                        else:
+                            continue
+                        # 需要安装
+                        need_updates[rname] = target
+                    if need_updates:
+                        # 下载文件信息列表
+                        r = RequestUtils(proxies=settings.PROXY, headers=settings.GITHUB_HEADERS,
+                                         timeout=30).get_res(self._files_api)
+                        if r and not r.ok:
+                            return None, f"连接仓库失败：{r.status_code} - {r.reason}"
+                        elif not r:
+                            return None, "连接仓库失败"
+                        files_info = r.json()
+                        for item in files_info:
+                            save_path = need_updates.get(item.get("name"))
+                            if not save_path:
+                                continue
+                            if item.get("download_url"):
+                                logger.info(f"开始更新资源文件：{item.get('name')} ...")
+                                download_url = f"{settings.GITHUB_PROXY}{item.get('download_url')}"
+                                # 下载资源文件
+                                res = RequestUtils(proxies=self.proxies, headers=settings.GITHUB_HEADERS,
+                                                   timeout=180).get_res(download_url)
+                                if not res:
+                                    logger.error(f"文件 {item.get('name')} 下载失败！")
+                                elif res.status_code != 200:
+                                    logger.error(f"下载文件 {item.get('name')} 失败：{res.status_code} - {res.reason}")
+                                # 创建插件文件夹
+                                file_path = self._base_dir / save_path / item.get("name")
+                                if not file_path.parent.exists():
+                                    file_path.parent.mkdir(parents=True, exist_ok=True)
+                                # 写入文件
+                                file_path.write_bytes(res.content)
+                        logger.info("资源包更新完成，开始重启服务...")
+                        SystemHelper.restart()
+                    else:
+                        logger.info("所有资源已最新，无需更新")
             except json.JSONDecodeError:
                 logger.error("资源包仓库数据解析失败！")
-                return
+                return None
         else:
             logger.warn("无法连接资源包仓库！")
-            return
-        online_version = resource_info.get("version")
-        if online_version:
-            logger.info(f"最新资源包版本：v{online_version}")
-        # 需要更新的资源包
-        need_updates = {}
-        # 资源明细
-        resources: dict = resource_info.get("resources") or {}
-        for rname, resource in resources.items():
-            rtype = resource.get("type")
-            platform = resource.get("platform")
-            target = resource.get("target")
-            version = resource.get("version")
-            # 判断平台
-            if platform and platform != SystemUtils.platform():
-                continue
-            # 判断版本号
-            if rtype == "auth":
-                # 站点认证资源
-                local_version = self.siteshelper.auth_version
-            elif rtype == "sites":
-                # 站点索引资源
-                local_version = self.siteshelper.indexer_version
-            else:
-                continue
-            if StringUtils.compare_version(version, ">", local_version):
-                logger.info(f"{rname} 资源包有更新，最新版本：v{version}")
-            else:
-                continue
-            # 需要安装
-            need_updates[rname] = target
-        if need_updates:
-            # 下载文件信息列表
-            r = RequestUtils(proxies=settings.PROXY, headers=settings.GITHUB_HEADERS,
-                             timeout=30).get_res(self._files_api)
-            if r and not r.ok:
-                return None, f"连接仓库失败：{r.status_code} - {r.reason}"
-            elif not r:
-                return None, "连接仓库失败"
-            files_info = r.json()
-            for item in files_info:
-                save_path = need_updates.get(item.get("name"))
-                if not save_path:
-                    continue
-                if item.get("download_url"):
-                    logger.info(f"开始更新资源文件：{item.get('name')} ...")
-                    download_url = f"{settings.GITHUB_PROXY}{item.get('download_url')}"
-                    # 下载资源文件
-                    res = RequestUtils(proxies=self.proxies, headers=settings.GITHUB_HEADERS,
-                                       timeout=180).get_res(download_url)
-                    if not res:
-                        logger.error(f"文件 {item.get('name')} 下载失败！")
-                    elif res.status_code != 200:
-                        logger.error(f"下载文件 {item.get('name')} 失败：{res.status_code} - {res.reason}")
-                    # 创建插件文件夹
-                    file_path = self._base_dir / save_path / item.get("name")
-                    if not file_path.parent.exists():
-                        file_path.parent.mkdir(parents=True, exist_ok=True)
-                    # 写入文件
-                    file_path.write_bytes(res.content)
-            logger.info("资源包更新完成，开始重启服务...")
-            SystemUtils.restart()
-        else:
-            logger.info("所有资源已最新，无需更新")
+            return None

app/helper/system.py

@@ -0,0 +1,55 @@
+from pathlib import Path
+from typing import Tuple
+
+import docker
+
+from app.core.config import settings
+from app.utils.system import SystemUtils
+
+
+class SystemHelper:
+    @staticmethod
+    def can_restart() -> bool:
+        """
+        判断是否可以内部重启
+        """
+        return (
+            Path("/var/run/docker.sock").exists()
+            or settings.DOCKER_CLIENT_API != "tcp://127.0.0.1:38379"
+        )
+
+    @staticmethod
+    def restart() -> Tuple[bool, str]:
+        """
+        执行Docker重启操作
+        """
+        if not SystemUtils.is_docker():
+            return False, "非Docker环境，无法重启！"
+        try:
+            # 创建 Docker 客户端
+            client = docker.DockerClient(base_url=settings.DOCKER_CLIENT_API)
+            # 获取当前容器的 ID
+            container_id = None
+            with open("/proc/self/mountinfo", "r") as f:
+                data = f.read()
+                index_resolv_conf = data.find("resolv.conf")
+                if index_resolv_conf != -1:
+                    index_second_slash = data.rfind("/", 0, index_resolv_conf)
+                    index_first_slash = data.rfind("/", 0, index_second_slash) + 1
+                    container_id = data[index_first_slash:index_second_slash]
+                    if len(container_id) < 20:
+                        index_resolv_conf = data.find("/sys/fs/cgroup/devices")
+                        if index_resolv_conf != -1:
+                            index_second_slash = data.rfind(" ", 0, index_resolv_conf)
+                            index_first_slash = (
+                                data.rfind("/", 0, index_second_slash) + 1
+                            )
+                            container_id = data[index_first_slash:index_second_slash]
+            if not container_id:
+                return False, "获取容器ID失败！"
+            # 重启当前容器
+            client.containers.get(container_id.strip()).restart()
+            return True, ""
+        except Exception as err:
+            print(str(err))
+            return False, f"重启时发生错误：{str(err)}"

app/helper/wallpaper.py

@@ -0,0 +1,105 @@
+from typing import Optional, List
+
+from app.core.cache import cached
+from app.core.config import settings
+from app.utils.http import RequestUtils
+from app.utils.singleton import Singleton
+
+
+class WallpaperHelper(metaclass=Singleton):
+
+    def __init__(self):
+        self.req = RequestUtils(timeout=5)
+
+    @cached(maxsize=1, ttl=3600)
+    def get_bing_wallpaper(self) -> Optional[str]:
+        """
+        获取Bing每日壁纸
+        """
+        url = "https://cn.bing.com/HPImageArchive.aspx?format=js&idx=0&n=1"
+        resp = self.req.get_res(url)
+        if resp and resp.status_code == 200:
+            try:
+                result = resp.json()
+                if isinstance(result, dict):
+                    for image in result.get('images') or []:
+                        return f"https://cn.bing.com{image.get('url')}" if 'url' in image else ''
+            except Exception as err:
+                print(str(err))
+        return None
+
+    @cached(maxsize=1, ttl=3600)
+    def get_bing_wallpapers(self, num: int = 7) -> List[str]:
+        """
+        获取7天的Bing每日壁纸
+        """
+        url = f"https://cn.bing.com/HPImageArchive.aspx?format=js&idx=0&n={num}"
+        resp = self.req.get_res(url)
+        if resp and resp.status_code == 200:
+            try:
+                result = resp.json()
+                if isinstance(result, dict):
+                    return [f"https://cn.bing.com{image.get('url')}" for image in result.get('images') or []]
+            except Exception as err:
+                print(str(err))
+        return []
+
+    @cached(maxsize=1, ttl=3600)
+    def get_customize_wallpaper(self) -> Optional[str]:
+        """
+        获取自定义壁纸api壁纸
+        """
+        wallpaper_list = self.get_customize_wallpapers()
+        if wallpaper_list:
+            return wallpaper_list[0]
+        return None
+
+    @cached(maxsize=1, ttl=3600)
+    def get_customize_wallpapers(self) -> List[str]:
+        """
+        获取自定义壁纸api壁纸
+        """
+
+        def find_files_with_suffixes(obj, suffixes: List[str]) -> List[str]:
+            """
+            递归查找对象中所有包含特定后缀的文件，返回匹配的字符串列表
+            支持输入：字典、列表、字符串
+            """
+            _result = []
+
+            # 处理字符串
+            if isinstance(obj, str):
+                if obj.endswith(tuple(suffixes)):
+                    _result.append(obj)
+
+            # 处理字典
+            elif isinstance(obj, dict):
+                for value in obj.values():
+                    _result.extend(find_files_with_suffixes(value, suffixes))
+
+            # 处理列表
+            elif isinstance(obj, list):
+                for item in obj:
+                    _result.extend(find_files_with_suffixes(item, suffixes))
+
+            return _result
+
+        # 判断是否存在自定义壁纸api
+        if settings.CUSTOMIZE_WALLPAPER_API_URL:
+            wallpaper_list = []
+            resp = self.req.get_res(settings.CUSTOMIZE_WALLPAPER_API_URL)
+            if resp and resp.status_code == 200:
+                # 如果返回的是图片格式
+                content_type = resp.headers.get('Content-Type')
+                if content_type and content_type.lower() == 'image/jpeg':
+                    wallpaper_list.append(settings.CUSTOMIZE_WALLPAPER_API_URL)
+                else:
+                    try:
+                        result = resp.json()
+                        if isinstance(result, list) or isinstance(result, dict) or isinstance(result, str):
+                            wallpaper_list = find_files_with_suffixes(result, settings.SECURITY_IMAGE_SUFFIXES)
+                    except Exception as err:
+                        print(str(err))
+            return wallpaper_list
+        else:
+            return []

app/log.py

@@ -30,7 +30,7 @@ class LogConfigModel(BaseModel):
     # 备份的日志文件数量
     LOG_BACKUP_COUNT: int = 3
     # 控制台日志格式
-    LOG_CONSOLE_FORMAT: str = "%(leveltext)s%(message)s"
+    LOG_CONSOLE_FORMAT: str = "%(leveltext)s[%(name)s] %(asctime)s %(message)s"
     # 文件日志格式
     LOG_FILE_FORMAT: str = "【%(levelname)s】%(asctime)s - %(message)s"
 
@@ -189,6 +189,9 @@ class LoggerManager:
         file_handler.setFormatter(file_formatter)
         _logger.addHandler(file_handler)
 
+        # 禁止向父级log传递
+        _logger.propagate = False
+
         return _logger
 
     def update_loggers(self):

app/modules/filemanager/storages/alipan.py

@@ -435,6 +435,17 @@ class AliPan(StorageBase, metaclass=Singleton):
                 break
         return items
 
+    def _delay_get_item(self, path: Path) -> Optional[schemas.FileItem]:
+        """
+        自动延迟重试 get_item 模块
+        """
+        for _ in range(2):
+            time.sleep(2)
+            fileitem = self.get_item(path)
+            if fileitem:
+                return fileitem
+        return None
+
     def create_folder(self, parent_item: schemas.FileItem, name: str) -> Optional[schemas.FileItem]:
         """
         创建目录
@@ -457,7 +468,7 @@ class AliPan(StorageBase, metaclass=Singleton):
         # 缓存新目录
         new_path = Path(parent_item.path) / name
         self._id_cache[str(new_path)] = (resp.get("drive_id"), resp.get("file_id"))
-        return self.get_item(new_path)
+        return self._delay_get_item(new_path)
 
     @staticmethod
     def _calculate_pre_hash(file_path: Path):
@@ -676,7 +687,7 @@ class AliPan(StorageBase, metaclass=Singleton):
                                        chunk_size=chunk_size)
         if create_res.get('rapid_upload', False):
             logger.info(f"【阿里云盘】{target_name} 秒传完成！")
-            return self.get_item(target_path)
+            return self._delay_get_item(target_path)
 
         if create_res.get("exist", False):
             logger.info(f"【阿里云盘】{target_name} 已存在")
@@ -919,7 +930,7 @@ class AliPan(StorageBase, metaclass=Singleton):
             return False
         # 重命名
         new_path = Path(path) / fileitem.name
-        new_file = self.get_item(new_path)
+        new_file = self._delay_get_item(new_path)
         self.rename(new_file, new_name)
         # 更新缓存
         del self._id_cache[fileitem.path]

app/modules/filemanager/storages/u115.py

@@ -306,6 +306,17 @@ class U115Pan(StorageBase, metaclass=Singleton):
                     sha1.update(chunk)
         return sha1.hexdigest()
 
+    def _delay_get_item(self, path: Path) -> Optional[schemas.FileItem]:
+        """
+        自动延迟重试 get_item 模块
+        """
+        for _ in range(2):
+            time.sleep(2)
+            fileitem = self.get_item(path)
+            if fileitem:
+                return fileitem
+        return None
+
     def init_storage(self):
         pass
 
@@ -513,7 +524,32 @@ class U115Pan(StorageBase, metaclass=Singleton):
         # Step 3: 秒传
         if init_result.get("status") == 2:
             logger.info(f"【115】{target_name} 秒传成功")
-            return self.get_item(target_path)
+            file_id = init_result.get("file_id", None)
+            if file_id:
+                logger.debug(f"【115】{target_name} 使用秒传返回ID获取文件信息")
+                time.sleep(2)
+                info_resp = self._request_api(
+                    "GET",
+                    "/open/folder/get_info",
+                    "data",
+                    params={
+                        "file_id": int(file_id)
+                    }
+                )
+                if info_resp:
+                    return schemas.FileItem(
+                        storage=self.schema.value,
+                        fileid=str(info_resp["file_id"]),
+                        path=str(target_path) + ("/" if info_resp["file_category"] == "0" else ""),
+                        type="file" if info_resp["file_category"] == "1" else "dir",
+                        name=info_resp["file_name"],
+                        basename=Path(info_resp["file_name"]).stem,
+                        extension=Path(info_resp["file_name"]).suffix[1:] if info_resp["file_category"] == "1" else None,
+                        pickcode=info_resp["pick_code"],
+                        size=StringUtils.num_filesize(info_resp['size']) if info_resp["file_category"] == "1" else None,
+                        modify_time=info_resp["utime"]
+                    )
+            return self._delay_get_item(target_path)
 
         # Step 4: 获取上传凭证
         token_resp = self._request_api(
@@ -618,7 +654,7 @@ class U115Pan(StorageBase, metaclass=Singleton):
                 logger.error(f"【115】{target_name} 上传失败: {e.status}, 错误码: {e.code}, 详情: {e.message}")
                 return None
         # 返回结果
-        return self.get_item(target_path)
+        return self._delay_get_item(target_path)
 
     def download(self, fileitem: schemas.FileItem, path: Path = None) -> Optional[Path]:
         """
@@ -783,7 +819,7 @@ class U115Pan(StorageBase, metaclass=Singleton):
             return False
         if resp["state"]:
             new_path = Path(path) / fileitem.name
-            new_item = self.get_item(new_path)
+            new_item = self._delay_get_item(new_path)
             self.rename(new_item, new_name)
             # 更新缓存
             del self._id_cache[fileitem.path]
@@ -811,7 +847,7 @@ class U115Pan(StorageBase, metaclass=Singleton):
             return False
         if resp["state"]:
             new_path = Path(path) / fileitem.name
-            new_file = self.get_item(new_path)
+            new_file = self._delay_get_item(new_path)
             self.rename(new_file, new_name)
             # 更新缓存
             del self._id_cache[fileitem.path]

app/modules/filemanager/transhandler.py

@@ -0,0 +1,909 @@
+import re
+from pathlib import Path
+from threading import Lock
+from typing import Optional, List, Tuple
+
+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 MetaInfoPath
+from app.helper.message import TemplateHelper
+from app.log import logger
+from app.modules.filemanager.storages import StorageBase
+from app.schemas import TransferInfo, TmdbEpisode, TransferDirectoryConf, FileItem, TransferInterceptEventData
+from app.schemas.types import MediaType, ChainEventType
+from app.utils.system import SystemUtils
+from app.schemas import TransferRenameEventData
+
+lock = Lock()
+
+
+class TransHandler:
+    """
+    文件转移整理类
+    """
+
+    result: Optional[TransferInfo] = None
+    inner_lock: Lock = Lock()
+
+    def __init__(self):
+        self.__reset_result()
+
+    def __reset_result(self):
+        """
+        重置结果
+        """
+        self.result = TransferInfo()
+
+    def __set_result(self, **kwargs):
+        """
+        设置结果
+        """
+        with self.inner_lock:
+            # 设置值
+            for key, value in kwargs.items():
+                if hasattr(self.result, key):
+                    current_value = getattr(self.result, key)
+                    if current_value is None:
+                        current_value = value
+                    elif isinstance(current_value, list):
+                        if isinstance(value, list):
+                            current_value.extend(value)
+                        else:
+                            current_value.append(value)
+                    elif isinstance(current_value, dict):
+                        if isinstance(value, dict):
+                            current_value.update(value)
+                        else:
+                            current_value[key] = value
+                    elif isinstance(current_value, int):
+                        current_value += value
+                    else:
+                        current_value = value
+                    setattr(self.result, key, current_value)
+
+    def transfer_media(self,
+                       fileitem: FileItem,
+                       in_meta: MetaBase,
+                       mediainfo: MediaInfo,
+                       target_storage: str,
+                       target_path: Path,
+                       transfer_type: str,
+                       source_oper: StorageBase,
+                       target_oper: StorageBase,
+                       need_scrape: Optional[bool] = False,
+                       need_rename: Optional[bool] = True,
+                       need_notify: Optional[bool] = True,
+                       overwrite_mode: Optional[str] = None,
+                       episodes_info: List[TmdbEpisode] = None
+                       ) -> TransferInfo:
+        """
+        识别并整理一个文件或者一个目录下的所有文件
+        :param fileitem: 整理的文件对象，可能是一个文件也可以是一个目录
+        :param in_meta：预识别元数据
+        :param mediainfo: 媒体信息
+        :param target_storage: 目标存储
+        :param target_path: 目标路径
+        :param transfer_type: 文件整理方式
+        :param source_oper: 源存储操作对象
+        :param target_oper: 目标存储操作对象
+        :param need_scrape: 是否需要刮削
+        :param need_rename: 是否需要重命名
+        :param need_notify: 是否需要通知
+        :param overwrite_mode: 覆盖模式
+        :param episodes_info: 当前季的全部集信息
+        :return: TransferInfo、错误信息
+        """
+
+        # 重置结果
+        self.__reset_result()
+
+        # 重命名格式
+        rename_format = settings.TV_RENAME_FORMAT \
+            if mediainfo.type == MediaType.TV else settings.MOVIE_RENAME_FORMAT
+
+        # 判断是否为文件夹
+        if fileitem.type == "dir":
+            # 整理整个目录，一般为蓝光原盘
+            if need_rename:
+                new_path = self.get_rename_path(
+                    path=target_path,
+                    template_string=rename_format,
+                    rename_dict=self.get_naming_dict(meta=in_meta,
+                                                     mediainfo=mediainfo)
+                ).parent
+            else:
+                new_path = target_path / fileitem.name
+            # 整理目录
+            new_diritem, errmsg = self.__transfer_dir(fileitem=fileitem,
+                                                      mediainfo=mediainfo,
+                                                      source_oper=source_oper,
+                                                      target_oper=target_oper,
+                                                      target_storage=target_storage,
+                                                      target_path=new_path,
+                                                      transfer_type=transfer_type)
+            if not new_diritem:
+                logger.error(f"文件夹 {fileitem.path} 整理失败：{errmsg}")
+                self.__set_result(success=False,
+                                  message=errmsg,
+                                  fileitem=fileitem,
+                                  transfer_type=transfer_type,
+                                  need_notify=need_notify)
+                return self.result
+
+            logger.info(f"文件夹 {fileitem.path} 整理成功")
+            # 计算目录下所有文件大小
+            total_size = sum(file.stat().st_size for file in Path(fileitem.path).rglob('*') if file.is_file())
+            # 返回整理后的路径
+            self.__set_result(success=True,
+                              fileitem=fileitem,
+                              target_item=new_diritem,
+                              target_diritem=new_diritem,
+                              total_size=total_size,
+                              need_scrape=need_scrape,
+                              need_notify=need_notify,
+                              transfer_type=transfer_type)
+            return self.result
+        else:
+            # 整理单个文件
+            if mediainfo.type == MediaType.TV:
+                # 电视剧
+                if in_meta.begin_episode is None:
+                    logger.warn(f"文件 {fileitem.path} 整理失败：未识别到文件集数")
+                    self.__set_result(success=False,
+                                      message=f"未识别到文件集数",
+                                      fileitem=fileitem,
+                                      fail_list=[fileitem.path],
+                                      transfer_type=transfer_type,
+                                      need_notify=need_notify)
+                    return self.result
+
+                # 文件结束季为空
+                in_meta.end_season = None
+                # 文件总季数为1
+                if in_meta.total_season:
+                    in_meta.total_season = 1
+                # 文件不可能超过2集
+                if in_meta.total_episode > 2:
+                    in_meta.total_episode = 1
+                    in_meta.end_episode = None
+
+            # 目的文件名
+            if need_rename:
+                new_file = self.get_rename_path(
+                    path=target_path,
+                    template_string=rename_format,
+                    rename_dict=self.get_naming_dict(
+                        meta=in_meta,
+                        mediainfo=mediainfo,
+                        episodes_info=episodes_info,
+                        file_ext=f".{fileitem.extension}"
+                    )
+                )
+            else:
+                new_file = target_path / fileitem.name
+
+            # 判断是否要覆盖
+            overflag = False
+            # 计算重命名中的文件夹层级
+            rename_format_level = len(rename_format.split("/")) - 1
+            folder_path = new_file.parents[rename_format_level - 1]
+            # 目标目录
+            target_diritem = target_oper.get_folder(folder_path)
+            if not target_diritem:
+                logger.error(f"目标目录 {folder_path} 获取失败")
+                self.__set_result(success=False,
+                                  message=f"目标目录 {folder_path} 获取失败",
+                                  fileitem=fileitem,
+                                  fail_list=[fileitem.path],
+                                  transfer_type=transfer_type,
+                                  need_notify=need_notify)
+                return self.result
+            # 目标文件
+            target_item = target_oper.get_item(new_file)
+            if target_item:
+                # 目标文件已存在
+                target_file = new_file
+                if target_storage == "local" and new_file.is_symlink():
+                    target_file = new_file.readlink()
+                    if not target_file.exists():
+                        overflag = True
+                if not overflag:
+                    # 目标文件已存在
+                    logger.info(f"目的文件系统中已经存在同名文件 {target_file}，当前整理覆盖模式设置为 {overwrite_mode}")
+                    if overwrite_mode == 'always':
+                        # 总是覆盖同名文件
+                        overflag = True
+                    elif overwrite_mode == 'size':
+                        # 存在时大覆盖小
+                        if target_item.size < fileitem.size:
+                            logger.info(f"目标文件文件大小更小，将覆盖：{new_file}")
+                            overflag = True
+                        else:
+                            self.__set_result(success=False,
+                                              message=f"媒体库存在同名文件，且质量更好",
+                                              fileitem=fileitem,
+                                              target_item=target_item,
+                                              target_diritem=target_diritem,
+                                              fail_list=[fileitem.path],
+                                              transfer_type=transfer_type,
+                                              need_notify=need_notify)
+                            return self.result
+                    elif overwrite_mode == 'never':
+                        # 存在不覆盖
+                        self.__set_result(success=False,
+                                          message=f"媒体库存在同名文件，当前覆盖模式为不覆盖",
+                                          fileitem=fileitem,
+                                          target_item=target_item,
+                                          target_diritem=target_diritem,
+                                          fail_list=[fileitem.path],
+                                          transfer_type=transfer_type,
+                                          need_notify=need_notify)
+                        return self.result
+                    elif overwrite_mode == 'latest':
+                        # 仅保留最新版本
+                        logger.info(f"当前整理覆盖模式设置为仅保留最新版本，将覆盖：{new_file}")
+                        overflag = True
+            else:
+                if overwrite_mode == 'latest':
+                    # 文件不存在，但仅保留最新版本
+                    logger.info(f"当前整理覆盖模式设置为 {overwrite_mode}，仅保留最新版本，正在删除已有版本文件 ...")
+                    self.__delete_version_files(target_oper, new_file)
+            # 整理文件
+            new_item, err_msg = self.__transfer_file(fileitem=fileitem,
+                                                     mediainfo=mediainfo,
+                                                     target_storage=target_storage,
+                                                     target_file=new_file,
+                                                     transfer_type=transfer_type,
+                                                     over_flag=overflag,
+                                                     source_oper=source_oper,
+                                                     target_oper=target_oper)
+            if not new_item:
+                logger.error(f"文件 {fileitem.path} 整理失败：{err_msg}")
+                self.__set_result(success=False,
+                                  message=err_msg,
+                                  fileitem=fileitem,
+                                  fail_list=[fileitem.path],
+                                  transfer_type=transfer_type,
+                                  need_notify=need_notify)
+                return self.result
+
+            logger.info(f"文件 {fileitem.path} 整理成功")
+            self.__set_result(success=True,
+                              fileitem=fileitem,
+                              target_item=new_item,
+                              target_diritem=target_diritem,
+                              need_scrape=need_scrape,
+                              transfer_type=transfer_type,
+                              need_notify=need_notify)
+            return self.result
+
+    @staticmethod
+    def __transfer_command(fileitem: FileItem, target_storage: str,
+                           source_oper: StorageBase, target_oper: StorageBase,
+                           target_file: Path, transfer_type: str,
+                           ) -> Tuple[Optional[FileItem], str]:
+        """
+        处理单个文件
+        :param fileitem: 源文件
+        :param target_storage: 目标存储
+        :param source_oper: 源存储操作对象
+        :param target_oper: 目标存储操作对象
+        :param target_file: 目标文件路径
+        :param transfer_type: 整理方式
+        """
+
+        def __get_targetitem(_path: Path) -> FileItem:
+            """
+            获取文件信息
+            """
+            return FileItem(
+                storage=target_storage,
+                path=str(_path).replace("\\", "/"),
+                name=_path.name,
+                basename=_path.stem,
+                type="file",
+                size=_path.stat().st_size,
+                extension=_path.suffix.lstrip('.'),
+                modify_time=_path.stat().st_mtime
+            )
+
+        if (fileitem.storage != target_storage
+                and fileitem.storage != "local" and target_storage != "local"):
+            return None, f"不支持 {fileitem.storage} 到 {target_storage} 的文件整理"
+
+        # 加锁
+        with lock:
+            if fileitem.storage == "local" and target_storage == "local":
+                # 创建目录
+                if not target_file.parent.exists():
+                    target_file.parent.mkdir(parents=True)
+                # 本地到本地
+                if transfer_type == "copy":
+                    state = source_oper.copy(fileitem, target_file.parent, target_file.name)
+                elif transfer_type == "move":
+                    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:
+                    return None, f"{fileitem.path} {transfer_type} 失败"
+            elif fileitem.storage == "local" and target_storage != "local":
+                # 本地到网盘
+                filepath = Path(fileitem.path)
+                if not filepath.exists():
+                    return None, f"文件 {filepath} 不存在"
+                if transfer_type == "copy":
+                    # 复制
+                    # 根据目的路径创建文件夹
+                    target_fileitem = target_oper.get_folder(target_file.parent)
+                    if target_fileitem:
+                        # 上传文件
+                        new_item = target_oper.upload(target_fileitem, filepath, target_file.name)
+                        if new_item:
+                            return new_item, ""
+                        else:
+                            return None, f"{fileitem.path} 上传 {target_storage} 失败"
+                    else:
+                        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, target_file.name)
+                        if new_item:
+                            # 删除源文件
+                            source_oper.delete(fileitem)
+                            return new_item, ""
+                        else:
+                            return None, f"{fileitem.path} 上传 {target_storage} 失败"
+                    else:
+                        return None, f"【{target_storage}】{target_file.parent} 目录获取失败"
+            elif fileitem.storage != "local" and target_storage == "local":
+                # 网盘到本地
+                if target_file.exists():
+                    logger.warn(f"文件已存在：{target_file}")
+                    return __get_targetitem(target_file), ""
+                # 网盘到本地
+                if transfer_type in ["copy", "move"]:
+                    # 下载
+                    tmp_file = source_oper.download(fileitem=fileitem, path=target_file.parent)
+                    if tmp_file:
+                        # 创建目录
+                        if not target_file.parent.exists():
+                            target_file.parent.mkdir(parents=True)
+                        # 将tmp_file移动后target_file
+                        SystemUtils.move(tmp_file, target_file)
+                        if transfer_type == "move":
+                            # 删除源文件
+                            source_oper.delete(fileitem)
+                        return __get_targetitem(target_file), ""
+                    else:
+                        return None, f"{fileitem.path} {fileitem.storage} 下载失败"
+            elif fileitem.storage == target_storage:
+                # 同一网盘
+                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"【{target_storage}】{fileitem.path} 复制文件失败"
+                    else:
+                        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"不支持的整理方式：{transfer_type}"
+
+        return None, "未知错误"
+
+    def __transfer_other_files(self, fileitem: FileItem, target_storage: str,
+                               source_oper: StorageBase, target_oper: StorageBase,
+                               target_file: Path, transfer_type: str) -> Tuple[bool, str]:
+        """
+        根据文件名整理其他相关文件
+        :param fileitem: 源文件
+        :param target_storage: 目标存储
+        :param source_oper: 源存储操作对象
+        :param target_oper: 目标存储操作对象
+        :param target_file: 目标路径
+        :param transfer_type: 整理方式
+        """
+        # 整理字幕
+        state, errmsg = self.__transfer_subtitles(fileitem=fileitem,
+                                                  target_storage=target_storage,
+                                                  source_oper=source_oper,
+                                                  target_oper=target_oper,
+                                                  target_file=target_file,
+                                                  transfer_type=transfer_type)
+        if not state:
+            return False, errmsg
+        # 整理音轨文件
+        state, errmsg = self.__transfer_audio_track_files(fileitem=fileitem,
+                                                          target_storage=target_storage,
+                                                          source_oper=source_oper,
+                                                          target_oper=target_oper,
+                                                          target_file=target_file,
+                                                          transfer_type=transfer_type)
+
+        return state, errmsg
+
+    def __transfer_subtitles(self, fileitem: FileItem, target_storage: str,
+                             source_oper: StorageBase, target_oper: StorageBase,
+                             target_file: Path, transfer_type: str) -> Tuple[bool, str]:
+        """
+        根据文件名整理对应字幕文件
+        :param fileitem: 源文件
+        :param target_storage: 目标存储
+        :param source_oper: 源存储操作对象
+        :param target_oper: 目标存储操作对象
+        :param target_file: 目标路径
+        :param transfer_type: 整理方式
+        """
+        # 字幕正则式
+        _zhcn_sub_re = r"([.\[(](((zh[-_])?(cn|ch[si]|sg|sc))|zho?" \
+                       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|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|tc_jp" \
+                       r"|(?<![a-z0-9])big5(?![a-z0-9])"
+        _eng_sub_re = r"[.\[(]eng[.\])]"
+
+        # 比对文件名并整理字幕
+        org_path = Path(fileitem.path)
+        # 查找上级文件项
+        parent_item: FileItem = source_oper.get_parent(fileitem)
+        if not parent_item:
+            return False, f"{org_path} 上级目录获取失败"
+        # 字幕文件列表
+        file_list: List[FileItem] = source_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.info(f"{parent_item.path} 目录下没有找到字幕文件...")
+        else:
+            logger.info(f"字幕文件清单：{[f.name for f in file_list]}")
+            # 识别文件名
+            metainfo = MetaInfoPath(org_path)
+            for sub_item in file_list:
+                # 识别字幕文件名
+                sub_file_name = re.sub(_zhtw_sub_re,
+                                       ".",
+                                       re.sub(_zhcn_sub_re,
+                                              ".",
+                                              sub_item.name,
+                                              flags=re.I),
+                                       flags=re.I)
+                sub_file_name = re.sub(_eng_sub_re, ".", sub_file_name, flags=re.I)
+                sub_metainfo = MetaInfoPath(Path(sub_item.path))
+                # 匹配字幕文件名
+                if (org_path.stem == Path(sub_file_name).stem) or \
+                        (sub_metainfo.cn_name and sub_metainfo.cn_name == metainfo.cn_name) \
+                        or (sub_metainfo.en_name and sub_metainfo.en_name == metainfo.en_name):
+                    if metainfo.part and metainfo.part != sub_metainfo.part:
+                        continue
+                    if metainfo.season \
+                            and metainfo.season != sub_metainfo.season:
+                        continue
+                    if metainfo.episode \
+                            and metainfo.episode != sub_metainfo.episode:
+                        continue
+                    new_file_type = ""
+                    # 兼容jellyfin字幕识别(多重识别), emby则会识别最后一个后缀
+                    if re.search(_zhcn_sub_re, sub_item.name, re.I):
+                        new_file_type = ".chi.zh-cn"
+                    elif re.search(_zhtw_sub_re, sub_item.name,
+                                   re.I):
+                        new_file_type = ".zh-tw"
+                    elif re.search(_eng_sub_re, sub_item.name, re.I):
+                        new_file_type = ".eng"
+                    # 通过对比字幕文件大小  尽量整理所有存在的字幕
+                    file_ext = f".{sub_item.extension}"
+                    new_sub_tag_dict = {
+                        ".eng": ".英文",
+                        ".chi.zh-cn": ".简体中文",
+                        ".zh-tw": ".繁体中文"
+                    }
+                    new_sub_tag_list = [
+                        (".default" + new_file_type if (
+                                (settings.DEFAULT_SUB == "zh-cn" and new_file_type == ".chi.zh-cn") or
+                                (settings.DEFAULT_SUB == "zh-tw" and new_file_type == ".zh-tw") or
+                                (settings.DEFAULT_SUB == "eng" and new_file_type == ".eng")
+                        ) else new_file_type) if t == 0 else "%s%s(%s)" % (new_file_type,
+                                                                           new_sub_tag_dict.get(
+                                                                               new_file_type, ""
+                                                                           ),
+                                                                           t) for t in range(6)
+                    ]
+                    for new_sub_tag in new_sub_tag_list:
+                        new_file: Path = target_file.with_name(target_file.stem + new_sub_tag + file_ext)
+                        # 如果字幕文件不存在, 直接整理字幕, 并跳出循环
+                        try:
+                            logger.debug(f"正在处理字幕：{sub_item.name}")
+                            new_item, errmsg = self.__transfer_command(fileitem=sub_item,
+                                                                       target_storage=target_storage,
+                                                                       source_oper=source_oper,
+                                                                       target_oper=target_oper,
+                                                                       target_file=new_file,
+                                                                       transfer_type=transfer_type)
+                            if new_item:
+                                logger.info(f"字幕 {sub_item.name} 整理完成")
+                                self.__set_result(
+                                    subtitle_list=[sub_item.path],
+                                    subtitle_list_new=[new_item.path],
+                                )
+                                break
+                            else:
+                                logger.error(f"字幕 {sub_item.name} 整理失败：{errmsg}")
+                                return False, errmsg
+                        except Exception as error:
+                            logger.info(f"字幕 {new_file} 出错了,原因: {str(error)}")
+        return True, ""
+
+    def __transfer_audio_track_files(self, fileitem: FileItem, target_storage: str,
+                                     source_oper: StorageBase, target_oper: StorageBase,
+                                     target_file: Path, transfer_type: str) -> Tuple[bool, str]:
+        """
+        根据文件名整理对应音轨文件
+        :param fileitem: 源文件
+        :param target_storage: 目标存储
+        :param source_oper: 源存储操作对象
+        :param target_oper: 目标存储操作对象
+        :param target_file: 目标路径
+        :param transfer_type: 整理方式
+        """
+        org_path = Path(fileitem.path)
+        # 查找上级文件项
+        parent_item: FileItem = source_oper.get_parent(fileitem)
+        if not parent_item:
+            return False, f"{org_path} 上级目录获取失败"
+        file_list: List[FileItem] = source_oper.list(parent_item)
+        # 匹配音轨文件
+        pending_file_list: List[FileItem] = [file for file in file_list
+                                             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:
+            return True, f"{parent_item.path} 目录下没有找到匹配的音轨文件"
+        logger.debug("音轨文件清单：" + str(pending_file_list))
+        for track_file in pending_file_list:
+            track_ext = f".{track_file.extension}"
+            new_track_file = target_file.with_name(target_file.stem + track_ext)
+            try:
+                logger.info(f"正在整理音轨文件：{track_file} 到 {new_track_file}")
+                new_item, errmsg = self.__transfer_command(fileitem=track_file,
+                                                           target_storage=target_storage,
+                                                           source_oper=source_oper,
+                                                           target_oper=target_oper,
+                                                           target_file=new_track_file,
+                                                           transfer_type=transfer_type)
+                if new_item:
+                    logger.info(f"音轨文件 {org_path.name} 整理完成")
+                    self.__set_result(
+                        audio_list=[track_file.path],
+                        audio_list_new=[new_item.path],
+                    )
+                else:
+                    logger.error(f"音轨文件 {org_path.name} 整理失败：{errmsg}")
+            except Exception as error:
+                logger.error(f"音轨文件 {org_path.name} 整理失败：{str(error)}")
+        return True, ""
+
+    def __transfer_dir(self, fileitem: FileItem, mediainfo: MediaInfo,
+                       source_oper: StorageBase, target_oper: StorageBase,
+                       transfer_type: str, target_storage: str, target_path: Path) -> Tuple[Optional[FileItem], str]:
+        """
+        整理整个文件夹
+        :param fileitem: 源文件
+        :param mediainfo: 媒体信息
+        :param source_oper: 源存储操作对象
+        :param target_oper: 目标存储操作对象
+        :param transfer_type: 整理方式
+        :param target_storage: 目标存储
+        :param target_path: 目标路径
+        """
+        logger.info(f"正在整理目录：{fileitem.path} 到 {target_path}")
+        target_item = target_oper.get_folder(target_path)
+        if not target_item:
+            return None, f"获取目标目录失败：{target_path}"
+        event_data = TransferInterceptEventData(
+            fileitem=fileitem,
+            mediainfo=mediainfo,
+            target_storage=target_storage,
+            target_path=target_path,
+            transfer_type=transfer_type
+        )
+        event = eventmanager.send_event(ChainEventType.TransferIntercept, event_data)
+        if event and event.event_data:
+            event_data = event.event_data
+            # 如果事件被取消，跳过文件整理
+            if event_data.cancel:
+                logger.debug(
+                    f"Transfer dir canceled by event: {event_data.source},"
+                    f"Reason: {event_data.reason}")
+                return None, event_data.reason
+        # 处理所有文件
+        state, errmsg = self.__transfer_dir_files(fileitem=fileitem,
+                                                  target_storage=target_storage,
+                                                  source_oper=source_oper,
+                                                  target_oper=target_oper,
+                                                  target_path=target_path,
+                                                  transfer_type=transfer_type)
+        if state:
+            return target_item, errmsg
+        else:
+            return None, errmsg
+
+    def __transfer_dir_files(self, fileitem: FileItem, target_storage: str,
+                             source_oper: StorageBase, target_oper: StorageBase,
+                             transfer_type: str, target_path: Path) -> Tuple[bool, str]:
+        """
+        按目录结构整理目录下所有文件
+        :param fileitem: 源文件
+        :param target_storage: 目标存储
+        :param source_oper: 源存储操作对象
+        :param target_oper: 目标存储操作对象
+        :param target_path: 目标路径
+        :param transfer_type: 整理方式
+        """
+        file_list: List[FileItem] = source_oper.list(fileitem)
+        # 整理文件
+        for item in file_list:
+            if item.type == "dir":
+                # 递归整理目录
+                new_path = target_path / item.name
+                state, errmsg = self.__transfer_dir_files(fileitem=item,
+                                                          target_storage=target_storage,
+                                                          source_oper=source_oper,
+                                                          target_oper=target_oper,
+                                                          transfer_type=transfer_type,
+                                                          target_path=new_path)
+                if not state:
+                    return False, errmsg
+            else:
+                # 整理文件
+                new_file = target_path / item.name
+                new_item, errmsg = self.__transfer_command(fileitem=item,
+                                                           target_storage=target_storage,
+                                                           source_oper=source_oper,
+                                                           target_oper=target_oper,
+                                                           target_file=new_file,
+                                                           transfer_type=transfer_type)
+                if not new_item:
+                    return False, errmsg
+                self.__set_result(
+                    file_list=[item.path],
+                    file_list_new=[new_item.path],
+                )
+        # 返回成功
+        return True, ""
+
+    def __transfer_file(self, fileitem: FileItem, mediainfo: MediaInfo,
+                        source_oper: StorageBase, target_oper: StorageBase,
+                        target_storage: str, target_file: Path,
+                        transfer_type: str, over_flag: Optional[bool] = False) -> Tuple[Optional[FileItem], str]:
+        """
+        整理一个文件，同时处理其他相关文件
+        :param fileitem: 原文件
+        :param mediainfo: 媒体信息
+        :param source_oper: 源存储操作对象
+        :param target_oper: 目标存储操作对象
+        :param target_storage: 目标存储
+        :param target_file: 新文件
+        :param transfer_type: 整理方式
+        :param over_flag: 是否覆盖，为True时会先删除再整理
+        :param source_oper: 源存储操作对象
+        :param target_oper: 目标存储操作对象
+        """
+        logger.info(f"正在整理文件：【{fileitem.storage}】{fileitem.path} 到 【{target_storage}】{target_file}，"
+                    f"操作类型：{transfer_type}")
+        event_data = TransferInterceptEventData(
+            fileitem=fileitem,
+            mediainfo=mediainfo,
+            target_storage=target_storage,
+            target_path=target_file,
+            transfer_type=transfer_type,
+            options={
+                "over_flag": over_flag
+            }
+        )
+        event = eventmanager.send_event(ChainEventType.TransferIntercept, event_data)
+        if event and event.event_data:
+            event_data = event.event_data
+            # 如果事件被取消，跳过文件整理
+            if event_data.cancel:
+                logger.debug(
+                    f"Transfer file canceled by event: {event_data.source},"
+                    f"Reason: {event_data.reason}")
+                return None, event_data.reason
+        if target_storage == "local" and (target_file.exists() or target_file.is_symlink()):
+            if not over_flag:
+                logger.warn(f"文件已存在：{target_file}")
+                return None, f"{target_file} 已存在"
+            else:
+                logger.info(f"正在删除已存在的文件：{target_file}")
+                target_file.unlink()
+        new_item, errmsg = self.__transfer_command(fileitem=fileitem,
+                                                   target_storage=target_storage,
+                                                   source_oper=source_oper,
+                                                   target_oper=target_oper,
+                                                   target_file=target_file,
+                                                   transfer_type=transfer_type)
+        if new_item:
+            self.__set_result(
+                file_list=[fileitem.path],
+                file_list_new=[new_item.path],
+                file_count=1,
+                total_size=fileitem.size,
+            )
+            # 处理其他相关文件
+            self.__transfer_other_files(fileitem=fileitem,
+                                        target_storage=target_storage,
+                                        source_oper=source_oper,
+                                        target_oper=target_oper,
+                                        target_file=target_file,
+                                        transfer_type=transfer_type)
+            return new_item, errmsg
+
+        return None, errmsg
+
+    @staticmethod
+    def get_dest_path(mediainfo: MediaInfo, target_path: Path,
+                      need_type_folder: Optional[bool] = False, need_category_folder: Optional[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: Optional[bool] = None, need_category_folder: Optional[bool] = None) -> Path:
+        """
+        根据设置并装媒体库目录
+        :param mediainfo: 媒体信息
+        :param target_dir: 媒体库根目录
+        :param need_type_folder: 是否需要按媒体类型创建目录
+        :param need_category_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 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 need_category_folder and mediainfo.category:
+            # 二级自动分类
+            library_dir = library_dir / mediainfo.category
+        elif target_dir.media_category and need_category_folder:
+            # 二级手动分类
+            library_dir = library_dir / target_dir.media_category
+
+        return library_dir
+
+    @staticmethod
+    def get_naming_dict(meta: MetaBase, mediainfo: MediaInfo, file_ext: Optional[str] = None,
+                        episodes_info: List[TmdbEpisode] = None) -> dict:
+        """
+        根据媒体信息，返回Format字典
+        :param meta: 文件元数据
+        :param mediainfo: 识别的媒体信息
+        :param file_ext: 文件扩展名
+        :param episodes_info: 当前季的全部集信息
+        """
+        return TemplateHelper().builder.build(meta=meta, mediainfo=mediainfo,
+                                              file_extension=file_ext, episodes_info=episodes_info)
+
+    @staticmethod
+    def __delete_version_files(storage_oper: StorageBase, path: Path) -> bool:
+        """
+        删除目录下的所有版本文件
+        :param storage_oper: 存储操作对象
+        :param path: 目录路径
+        """
+        # 存储
+        if not storage_oper:
+            return False
+        # 识别文件中的季集信息
+        meta = MetaInfoPath(path)
+        season = meta.season
+        episode = meta.episode
+        logger.warn(f"正在删除目标目录中其它版本的文件：{path.parent}")
+        # 获取父目录
+        parent_item = storage_oper.get_item(path.parent)
+        if not parent_item:
+            logger.warn(f"目录 {path.parent} 不存在")
+            return False
+        # 检索媒体文件
+        media_files = storage_oper.list(parent_item)
+        if not media_files:
+            logger.info(f"目录 {path.parent} 中没有文件")
+            return False
+        # 删除文件
+        for media_file in media_files:
+            media_path = Path(media_file.path)
+            if media_path == path:
+                continue
+            if media_file.type != "file":
+                continue
+            if f".{media_file.extension.lower()}" not in settings.RMT_MEDIAEXT:
+                continue
+            # 识别文件中的季集信息
+            filemeta = MetaInfoPath(media_path)
+            # 相同季集的文件才删除
+            if filemeta.season != season or filemeta.episode != episode:
+                continue
+            logger.info(f"正在删除文件：{media_file.name}")
+            storage_oper.delete(media_file)
+        return True
+
+    @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
+        else:
+            return Path(render_str)

app/modules/filter/__init__.py

@@ -21,8 +21,8 @@ class FilterModule(_ModuleBase):
     rule_set: Dict[str, dict] = {
         # 蓝光原盘
         "BLU": {
-            "include": [r'Blu-?Ray.+VC-?1|Blu-?Ray.+AVC|UHD.+blu-?ray.+HEVC|MiniBD'],
-            "exclude": [r'[Hx].?264|[Hx].?265|WEB-?DL|WEB-?RIP|REMUX']
+            "include": [r'(?i)(\bBlu-?Ray\b.*\b(?:VC-?1|AVC|MPEG-?2)\b|\b(?:UHD|4K|2160p)\b(?:.*Blu-?Ray)?.*\b(?:HEVC|H\.?265)\b|\bBlu-?Ray\b.*\b(?:UHD|4K|2160p)\b.*\b(?:HEVC|H\.?265)\b|\b(?:COMPLETE|FULL)\b.*\b(?:(?:UHD|4K|2160p)\b.*)?Blu-?Ray\b|\b(BD25|BD50|BD66|BD100|BDMV|MiniBD)\b)'],
+            "exclude": [r'(?i)(\b[XH]\.?264\b|\b[XH]\.?265\b|\bWEB-?DL\b|\bWEB-?RIP\b|\bHDTV(?:RIP)?\b|\bREMUX\b|\bBDRip\b|\bBRRip\b|\bHDRip\b|\bENCODE\b|\b(?<!WEB-|HDTV)RIP\b)']
         },
         # 4K
         "4K": {

app/modules/themoviedb/category.py

@@ -115,11 +115,18 @@ class CategoryHelper(metaclass=Singleton):
             for attr, value in item.items():
                 if not value:
                     continue
-                info_value = tmdb_info.get(attr)
+                if attr == "release_year":
+                    # 发行年份
+                    info_value = tmdb_info.get("release_date") or tmdb_info.get("first_air_date")
+                    if info_value:
+                        info_value = str(info_value)[:4]
+                else:
+                    info_value = tmdb_info.get(attr)
                 if not info_value:
                     match_flag = False
                     continue
                 elif attr == "production_countries":
+                    # 制片国家
                     info_values = [str(val.get("iso_3166_1")).upper() for val in info_value]
                 else:
                     if isinstance(info_value, list):
@@ -128,7 +135,18 @@ class CategoryHelper(metaclass=Singleton):
                         info_values = [str(info_value).upper()]
 
                 if value.find(",") != -1:
+                    # , 分隔多个值
                     values = [str(val).upper() for val in value.split(",") if val]
+                elif value.find("-") != -1:
+                    # - 表示范围，仅限于数字
+                    value_begin = value.split("-")[0]
+                    value_end = value.split("-")[1]
+                    if value_begin.isdigit() and value_end.isdigit():
+                        # 数字范围
+                        values = [str(val) for val in range(int(value_begin), int(value_end) + 1)]
+                    else:
+                        # 字符串范围
+                        values = [str(value_begin), str(value_end)]
                 else:
                     values = [str(value).upper()]
 

app/modules/themoviedb/tmdbapi.py

@@ -1334,7 +1334,18 @@ class TmdbApi:
             return []
         try:
             logger.debug(f"正在获取剧集组：{group_id}...")
-            return self.tv.group_episodes(group_id) or []
+            group_seasons = self.tv.group_episodes(group_id) or []
+            return [
+                {
+                    **group_season,
+                    "episodes": [
+                        {**ep, "episode_number": idx}
+                        # 剧集组中每个季的episode_number从1开始
+                        for idx, ep in enumerate(group_season.get("episodes", []), start=1)
+                    ]
+                }
+                for group_season in group_seasons
+            ]
         except Exception as e:
             logger.error(str(e))
             return []
@@ -1348,9 +1359,6 @@ class TmdbApi:
             return {}
         for group_season in group_seasons:
             if group_season.get('order') == season:
-                # 剧集组中每个季的episode_number从1开始
-                for i, e in enumerate(group_season.get('episodes', []), start=1):
-                    e['episode_number'] = i
                 return group_season
         return {}
 

app/plugins/__init__.py

@@ -182,6 +182,22 @@ class _PluginBase(metaclass=ABCMeta):
         """
         pass
 
+    def get_actions(self) -> List[Dict[str, Any]]:
+        """
+        获取插件工作流动作
+        [{
+            "id": "动作ID",
+            "name": "动作名称",
+            "func": self.xxx,
+            "kwargs": {} # 需要附加传递的参数
+        }]
+
+        对实现函数的要求：
+        1、函数的第一个参数固定为 ActionContent 实例，如需要传递额外参数，在kwargs中定义
+        2、函数的返回：执行状态 True / False，更新后的 ActionContent 实例
+        """
+        pass
+
     @abstractmethod
     def stop_service(self):
         """

app/schemas/event.py

@@ -306,7 +306,7 @@ class MediaRecognizeConvertEventData(ChainEventData):
     convert_type: str = Field(..., description="转换类型（themoviedb/douban）")
 
     # 输出参数
-    media_dict: dict = Field(default=dict, description="转换后的媒体信息（TheMovieDb/豆瓣）")
+    media_dict: dict = Field(default_factory=dict, description="转换后的媒体信息（TheMovieDb/豆瓣）")
 
 
 class StorageOperSelectionEventData(ChainEventData):

app/schemas/file.py

@@ -5,7 +5,7 @@ from pydantic import BaseModel, Field
 
 class FileItem(BaseModel):
     # 存储类型
-    storage: Optional[str] = "local"
+    storage: Optional[str] = Field(default="local")
     # 类型 dir/file
     type: Optional[str] = None
     # 文件路径

app/schemas/transfer.py

@@ -115,15 +115,23 @@ class TransferInfo(BaseModel):
     # 整理方式
     transfer_type: Optional[str] = None
     # 处理文件数
-    file_count: Optional[int] = 0
+    file_count: Optional[int] = Field(default=0)
     # 处理文件清单
     file_list: Optional[list] = Field(default_factory=list)
     # 目标文件清单
     file_list_new: Optional[list] = Field(default_factory=list)
     # 总文件大小
-    total_size: Optional[float] = 0.0
+    total_size: Optional[int] = Field(default=0)
     # 失败清单
     fail_list: Optional[list] = Field(default_factory=list)
+    # 处理字幕文件清单
+    subtitle_list: Optional[list] = Field(default_factory=list)
+    # 目标字幕文件清单
+    subtitle_list_new: Optional[list] = Field(default_factory=list)
+    # 处理音频文件清单
+    audio_list: Optional[list] = Field(default_factory=list)
+    # 目标音频文件清单
+    audio_list_new: Optional[list] = Field(default_factory=list)
     # 错误信息
     message: Optional[str] = None
     # 是否需要刮削

app/schemas/types.py

@@ -141,6 +141,8 @@ class SystemConfigKey(Enum):
     UserInstalledPlugins = "UserInstalledPlugins"
     # 插件安装统计
     PluginInstallReport = "PluginInstallReport"
+    # 插件文件夹分组配置
+    PluginFolders = "PluginFolders"
     # 默认电影订阅规则
     DefaultMovieSubscribeConfig = "DefaultMovieSubscribeConfig"
     # 默认电视剧订阅规则

app/utils/string.py

@@ -908,3 +908,20 @@ class StringUtils:
         :return: 如果elem有效（非None且长度大于0），返回True；否则返回False
         """
         return elem is not None and len(elem) > 0
+
+    @staticmethod
+    def is_link(text: str) -> bool:
+        """
+        检查文件是否为链接地址，支持各类协议
+        :param text: 要检查的文本
+        :return: 如果URL有效，返回True；否则返回False
+        """
+        if not text:
+            return False
+        # 检查是否以http、https、ftp等协议开头
+        if re.match(r'^(http|https|ftp|ftps|sftp|ws|wss)://', text):
+            return True
+        # 检查是否为IP地址或域名
+        if re.match(r'^[a-zA-Z0-9.-]+(\.[a-zA-Z]{2,})?$', text):
+            return True
+        return False

app/utils/system.py

@@ -11,7 +11,6 @@ from glob import glob
 from pathlib import Path
 from typing import List, Optional, Tuple, Union
 
-import docker
 import psutil
 
 from app import schemas
@@ -439,47 +438,6 @@ class SystemUtils:
         """
         return [psutil.virtual_memory().used, int(psutil.virtual_memory().percent)]
 
-    @staticmethod
-    def can_restart() -> bool:
-        """
-        判断是否可以内部重启
-        """
-        return Path("/var/run/docker.sock").exists()
-
-    @staticmethod
-    def restart() -> Tuple[bool, str]:
-        """
-        执行Docker重启操作
-        """
-        if not SystemUtils.is_docker():
-            return False, "非Docker环境，无法重启！"
-        try:
-            # 创建 Docker 客户端
-            client = docker.DockerClient(base_url='tcp://127.0.0.1:38379')
-            # 获取当前容器的 ID
-            container_id = None
-            with open('/proc/self/mountinfo', 'r') as f:
-                data = f.read()
-                index_resolv_conf = data.find("resolv.conf")
-                if index_resolv_conf != -1:
-                    index_second_slash = data.rfind("/", 0, index_resolv_conf)
-                    index_first_slash = data.rfind("/", 0, index_second_slash) + 1
-                    container_id = data[index_first_slash:index_second_slash]
-                    if len(container_id) < 20:
-                        index_resolv_conf = data.find("/sys/fs/cgroup/devices")
-                        if index_resolv_conf != -1:
-                            index_second_slash = data.rfind(" ", 0, index_resolv_conf)
-                            index_first_slash = data.rfind("/", 0, index_second_slash) + 1
-                            container_id = data[index_first_slash:index_second_slash]
-            if not container_id:
-                return False, "获取容器ID失败！"
-            # 重启当前容器
-            client.containers.get(container_id.strip()).restart()
-            return True, ""
-        except Exception as err:
-            print(str(err))
-            return False, f"重启时发生错误：{str(err)}"
-
     @staticmethod
     def is_hardlink(src: Path, dest: Path) -> bool:
         """

app/utils/tokens.py

@@ -12,7 +12,7 @@ class Tokens:
         self.load_text(text)
 
     def load_text(self, text):
-        splitted_text = re.split(r"\.|\s+|\(|\)|\[|]|-|\+|【|】|/|～|;|&|\||#|_|「|」|~", text)
+        splitted_text = re.split(r"\.|\s+|\(|\)|\[|]|-|【|】|/|～|;|&|\||#|_|「|」|~", text)
         for sub_text in splitted_text:
             if sub_text:
                 self._tokens.append(sub_text)

app/utils/web.py

@@ -1,7 +1,3 @@
-from typing import Optional, List
-
-from app.core.cache import cached
-
 from app.utils.http import RequestUtils
 
 
@@ -73,38 +69,3 @@ class WebUtils:
         except Exception as err:
             print(str(err))
             return ""
-
-    @staticmethod
-    @cached(maxsize=1, ttl=3600)
-    def get_bing_wallpaper() -> Optional[str]:
-        """
-        获取Bing每日壁纸
-        """
-        url = "https://cn.bing.com/HPImageArchive.aspx?format=js&idx=0&n=1"
-        resp = RequestUtils(timeout=5).get_res(url)
-        if resp and resp.status_code == 200:
-            try:
-                result = resp.json()
-                if isinstance(result, dict):
-                    for image in result.get('images') or []:
-                        return f"https://cn.bing.com{image.get('url')}" if 'url' in image else ''
-            except Exception as err:
-                print(str(err))
-        return None
-
-    @staticmethod
-    @cached(maxsize=1, ttl=3600)
-    def get_bing_wallpapers(num: int = 7) -> List[str]:
-        """
-        获取7天的Bing每日壁纸
-        """
-        url = f"https://cn.bing.com/HPImageArchive.aspx?format=js&idx=0&n={num}"
-        resp = RequestUtils(timeout=5).get_res(url)
-        if resp and resp.status_code == 200:
-            try:
-                result = resp.json()
-                if isinstance(result, dict):
-                    return [f"https://cn.bing.com{image.get('url')}" for image in result.get('images') or []]
-            except Exception as err:
-                print(str(err))
-        return []

config/category.yaml

@@ -5,6 +5,7 @@
 #   `original_language` 语种，具体含义参考下方字典
 #   `production_countries` 国家或地区（电影）、`origin_country` 国家或地区（电视剧），具体含义参考下方字典
 #   `genre_ids` 内容类型，具体含义参考下方字典
+#   `release_year` 发行年份，格式：YYYY，电影实际对应`release_date`字段，电视剧实际对应`first_air_date`字段，支持范围设定，如：`YYYY-YYYY`
 #   themoviedb 详情API返回的其它一级字段
 # 4. 配置多项条件时需要同时满足，一个条件需要匹配多个值是使用`,`分隔
 

database/versions/89d24811e894_2_1_4.py

@@ -37,7 +37,7 @@ def upgrade() -> None:
     'text': '{% if site_name %}站点：{{ site_name }}{% endif %}'
             '{% if resource_term %}\\n质量：{{ resource_term }}{% endif %}'
             '{% if size %}\\n大小：{{ size }}{% endif %}'
-            '{% if title %}\\n种子：{{ title }}{% endif %}'
+            '{% if torrent_title %}\\n种子：{{ torrent_title }}{% endif %}'
             '{% if pubdate %}\\n发布时间：{{ pubdate }}{% endif %}'
             '{% if freedate %}\\n免费时间：{{ freedate }}{% endif %}'
             '{% if seeders %}\\n做种数：{{ seeders }}{% endif %}'

docker/Dockerfile

@@ -7,10 +7,7 @@ ENV LANG="C.UTF-8" \
     DISPLAY=:987 \
     PUID=0 \
     PGID=0 \
-    UMASK=000 \
-    PORT=3001 \
-    NGINX_PORT=3000 \
-    MOVIEPILOT_AUTO_UPDATE=release
+    UMASK=000
 WORKDIR "/app"
 RUN apt-get update -y \
     && apt-get upgrade -y \
@@ -87,5 +84,5 @@ RUN cp -f /app/docker/nginx.common.conf /etc/nginx/common.conf \
     && mv -f /tmp/MoviePilot-Resources-main/resources/* /app/app/helper/ \
     && rm -rf /tmp/*
 EXPOSE 3000
-VOLUME [ "/config" ]
+VOLUME [ "${CONFIG_DIR}" ]
 ENTRYPOINT [ "/entrypoint.sh" ]

docker/entrypoint.sh

@@ -20,6 +20,148 @@ function WARN() {
     echo -e "${WARN} ${1}"
 }
 
+# 校正设置目录
+CONFIG_DIR="${CONFIG_DIR:-/config}"
+
+# 记录非系统环境（docker容器表）提供的变量
+declare -ga VARS_SET_BY_SCRIPT=()
+
+# 环境变量补全
+# 优先级: 系统环境变量 -> .env 文件 (即使为空字符串) -> 预设默认值
+# 精准适配 Python 端 set_key (quote_mode="always", 单引号包裹, \' 转义)
+function load_config_from_app_env() {
+
+    local env_file="${CONFIG_DIR}/app.env"
+
+    # 定义 ["变量名"]="预设默认值"
+    # 禁止填入 CONFIG_DIR 变量，ACME_ENV_ 开头的变量暂时不处理，还是交由 cert.sh 处理
+    declare -A vars_and_default_values=(
+        # update.sh
+        ["PIP_PROXY"]=""
+        ["GITHUB_PROXY"]=""
+        ["PROXY_HOST"]=""
+        ["GITHUB_TOKEN"]=""
+        ["MOVIEPILOT_AUTO_UPDATE"]="release"
+
+        # cert
+        ["ENABLE_SSL"]="false"
+        ["SSL_DOMAIN"]=""
+        ["NGINX_PORT"]="3000"
+        ["PORT"]="3001"
+        ["NGINX_CLIENT_MAX_BODY_SIZE"]="10m"
+    )
+
+    INFO "开始加载配置 (配置文件: ${env_file})..."
+
+    shopt -s extglob
+
+    declare -A values_from_env_file
+    if [ -f "${env_file}" ]; then
+        INFO "检测到 ${env_file} 文件，尝试解析..."
+        while IFS= read -r line || [ -n "$line" ]; do
+            if [[ "$line" =~ ^[[:space:]]*# || -z "$line" ]]; then
+                continue
+            fi
+
+            local key_in_file value_raw_in_file
+            if [[ "$line" =~ ^[[:space:]]*([A-Za-z_][A-Za-z0-9_]*)[[:space:]]*=(.*) ]]; then
+                key_in_file="${BASH_REMATCH[1]}"
+                value_raw_in_file="${BASH_REMATCH[2]}"
+
+                if [[ -n "${vars_and_default_values[$key_in_file]+_}" ]]; then
+                    local temp_val_after_initial_trim
+                    temp_val_after_initial_trim="${value_raw_in_file#"${value_raw_in_file%%[![:space:]]*}"}"
+                    temp_val_after_initial_trim="${temp_val_after_initial_trim%"${temp_val_after_initial_trim##*[![:space:]]}"}"
+
+                    local val_before_quote_check="${temp_val_after_initial_trim}"
+                    if [[ ! ("${temp_val_after_initial_trim:0:1}" == "'" && "${temp_val_after_initial_trim: -1}" == "'") ]]; then
+                        if [[ "${temp_val_after_initial_trim}" =~ ^(.*)[[:space:]]+# ]]; then
+                            val_before_quote_check="${BASH_REMATCH[1]}"
+                            val_before_quote_check="${val_before_quote_check%%+([[:space:]])}"
+                        elif [[ "${temp_val_after_initial_trim:0:1}" == "#" ]]; then
+                            val_before_quote_check=""
+                        fi
+                    fi
+
+                    local parsed_value_from_file
+                    if [[ "${val_before_quote_check:0:1}" == "'" && "${val_before_quote_check: -1}" == "'" && ${#val_before_quote_check} -ge 2 ]]; then
+                        parsed_value_from_file="${val_before_quote_check:1:${#val_before_quote_check}-2}"
+                        parsed_value_from_file="${parsed_value_from_file//\\\'/__MP_PARSER_SQUOTE__}"
+                        parsed_value_from_file="${parsed_value_from_file//__MP_PARSER_SQUOTE__/\'}"
+                    elif [ -z "${val_before_quote_check}" ]; then
+                        parsed_value_from_file=""
+                    else
+                        WARN "位于 ${env_file} 中的键 ${key_in_file} 对应值 ${val_before_quote_check} 未按规范使用单引号包裹，将采用字面量解析。"
+                        parsed_value_from_file="${val_before_quote_check}"
+                    fi
+                    values_from_env_file["${key_in_file}"]="${parsed_value_from_file}"
+                fi
+            else
+                WARN "跳过 ${env_file} 中格式不正确的行: $line"
+            fi
+        done < <(sed -e '1s/^\xEF\xBB\xBF//' -e 's/\r$//g' "${env_file}")
+        INFO "${env_file} 解析完毕。"
+     else
+        INFO "${env_file} 文件不存在，跳过文件加载。"
+     fi
+
+    INFO "正在根据优先级确定并导出配置值..."
+    for var_name in "${!vars_and_default_values[@]}"; do
+        local fallback_value="${vars_and_default_values[$var_name]}"
+        local final_value
+        local value_source="未设置"
+        # 标志变量是否来自初始环境
+        local set_by_initial_env=false
+
+        # 检查变量是否在环境中已设置（可能为空）
+        if eval "[ -n \"\${${var_name}+x}\" ]"; then
+            # 获取其值
+            final_value="$(eval echo \"\$"${var_name}"\")"
+            value_source="系统环境变量"
+            set_by_initial_env=true
+        elif [[ -n "${values_from_env_file["${var_name}"]+_}" ]]; then
+            final_value="${values_from_env_file["${var_name}"]}"
+            value_source=".env 文件"
+        else
+            final_value="${fallback_value}"
+            value_source="内置默认值"
+        fi
+
+        # 不论来源如何，都导出变量，以便脚本的其余部分和子进程使用
+        # (例如 envsubst, mp_update.sh, cert.sh)
+        if declare -gx "${var_name}=${final_value}"; then
+            if [ -z "${final_value}" ]; then
+                 INFO "变量 ${var_name}, 值为空, 来源: ${value_source})。"
+            else
+                 INFO "变量 ${var_name}, 值: ${final_value} , (来源: ${value_source})。"
+            fi
+
+            # 如果变量不是来自初始环境变量，则记录下来以便稍后 unset
+            if ! ${set_by_initial_env}; then
+                # 检查是否已在数组中，避免重复添加
+                local found_in_script_vars=false
+                for item in "${VARS_SET_BY_SCRIPT[@]}"; do
+                    if [[ "$item" == "$var_name" ]]; then
+                        found_in_script_vars=true
+                        break
+                    fi
+                done
+                if ! ${found_in_script_vars}; then
+                    VARS_SET_BY_SCRIPT+=("${var_name}")
+                fi
+            fi
+        else
+            ERROR "导出变量 ${var_name} (值: '${final_value}', 来源: ${value_source}) 失败。"
+        fi
+    done
+
+    shopt -u extglob
+    INFO "配置加载流程执行完毕。"
+}
+
+# 使用env配置
+load_config_from_app_env
+
 # 生成HTTPS配置块
 if [ "${ENABLE_SSL}" = "true" ]; then
     export HTTPS_SERVER_CONF=$(cat <<EOF
@@ -32,8 +174,8 @@ if [ "${ENABLE_SSL}" = "true" ]; then
         server_name ${SSL_DOMAIN:-moviepilot};
 
         # SSL证书路径
-        ssl_certificate /config/certs/latest/fullchain.pem;
-        ssl_certificate_key /config/certs/latest/privkey.pem;
+        ssl_certificate ${CONFIG_DIR}/certs/latest/fullchain.pem;
+        ssl_certificate_key ${CONFIG_DIR}/certs/latest/privkey.pem;
 
         # SSL安全配置
         ssl_protocols TLSv1.2 TLSv1.3;
@@ -52,7 +194,6 @@ else
 fi
 
 # 使用 `envsubst` 将模板文件中的 ${NGINX_PORT} 替换为实际的环境变量值
-export NGINX_CLIENT_MAX_BODY_SIZE=${NGINX_CLIENT_MAX_BODY_SIZE:-10m}
 envsubst '${NGINX_PORT}${PORT}${NGINX_CLIENT_MAX_BODY_SIZE}${ENABLE_SSL}${HTTPS_SERVER_CONF}' < /etc/nginx/nginx.template.conf > /etc/nginx/nginx.conf
 # 自动更新
 cd /
@@ -66,7 +207,7 @@ chown -R moviepilot:moviepilot \
     "${HOME}" \
     /app \
     /public \
-    /config \
+    "${CONFIG_DIR}" \
     /var/lib/nginx \
     /var/log/nginx
 chown moviepilot:moviepilot /etc/hosts /tmp
@@ -92,6 +233,23 @@ if [ -S "/var/run/docker.sock" ]; then
 fi
 # 设置后端服务权限掩码
 umask "${UMASK}"
+
+# 清除非系统环境导入的变量，保证转移到 dumb-init 的时候，不会带入不必要的环境变量
+INFO "准备为 Python 应用清理的非系统环境导入的变量..."
+if [ ${#VARS_SET_BY_SCRIPT[@]} -gt 0 ]; then
+    for var_to_unset in "${VARS_SET_BY_SCRIPT[@]}"; do
+        # 再次确认变量确实存在于当前环境中（虽然理论上应该存在）
+        if eval "[ -n \"\${${var_to_unset}+x}\" ]"; then
+            INFO "取消设置环境变量: ${var_to_unset}"
+            unset "${var_to_unset}"
+        else
+            WARN "变量 ${var_to_unset} 已不存在，无需取消设置。"
+        fi
+    done
+else
+    INFO "没有由非系统环境导入的变量需要清理。"
+fi
+
 # 启动后端服务
 INFO "→ 启动后端服务..."
 exec dumb-init gosu moviepilot:moviepilot python3 app/main.py

tests/cases/meta.py

@@ -668,7 +668,7 @@ meta_cases = [{
         "restype": "UHD BluRay DoVi",
         "pix": "1080p",
         "video_codec": "X265",
-        "audio_codec": "DD 7.1"
+        "audio_codec": "DD+ 7.1"
     }
 }, {
     "title": "Childhood.In.A.Capsule.S01E16.2022.1080p.KKTV.WEB-DL.X264.AAC-ADWeb.mkv",
@@ -968,7 +968,7 @@ meta_cases = [{
         "year": "2023",
         "part": "",
         "season": "S02",
-        "episode": "E01-E08",
+        "episode": "",
         "restype": "WEB-DL",
         "pix": "2160p",
         "video_codec": "H265",
@@ -1016,7 +1016,7 @@ meta_cases = [{
         "year": "2019",
         "part": "",
         "season": "S01",
-        "episode": "E01-E36",
+        "episode": "",
         "restype": "WEB-DL",
         "pix": "2160p",
         "video_codec": "H265",
@@ -1037,4 +1037,84 @@ meta_cases = [{
         "video_codec": "",
         "audio_codec": ""
     }
+}, {
+    "path": "/movies/The Vampire Diaries (2009) [tmdbid=18165]/The.Vampire.Diaries.S01E01.1080p.mkv",
+    "target": {
+        "type": "电视剧",
+        "cn_name": "",
+        "en_name": "The Vampire Diaries",
+        "year": "2009",
+        "part": "",
+        "season": "S01",
+        "episode": "E01",
+        "restype": "",
+        "pix": "1080p",
+        "video_codec": "",
+        "audio_codec": "",
+        "tmdbid": 18165
+    }
+}, {
+    "path": "/movies/Inception (2010) [tmdbid-27205]/Inception.2010.1080p.mkv",
+    "target": {
+        "type": "未知",
+        "cn_name": "",
+        "en_name": "Inception",
+        "year": "2010",
+        "part": "",
+        "season": "",
+        "episode": "",
+        "restype": "",
+        "pix": "1080p",
+        "video_codec": "",
+        "audio_codec": "",
+        "tmdbid": 27205
+    }
+}, {
+    "path": "/movies/Breaking Bad (2008) [tmdb=1396]/Season 1/Breaking.Bad.S01E01.1080p.mkv",
+    "target": {
+        "type": "电视剧",
+        "cn_name": "",
+        "en_name": "Breaking Bad",
+        "year": "2008",
+        "part": "",
+        "season": "S01",
+        "episode": "E01",
+        "restype": "",
+        "pix": "1080p",
+        "video_codec": "",
+        "audio_codec": "",
+        "tmdbid": 1396
+    }
+}, {
+    "path": "/tv/Game of Thrones (2011) {tmdb=1399}/Season 1/Game.of.Thrones.S01E01.1080p.mkv",
+    "target": {
+        "type": "电视剧",
+        "cn_name": "",
+        "en_name": "Game Of Thrones",
+        "year": "2011",
+        "part": "",
+        "season": "S01",
+        "episode": "E01",
+        "restype": "",
+        "pix": "1080p",
+        "video_codec": "",
+        "audio_codec": "",
+        "tmdbid": 1399
+    }
+}, {
+    "path": "/movies/Avatar (2009) {tmdb-19995}/Avatar.2009.1080p.mkv",
+    "target": {
+        "type": "未知",
+        "cn_name": "",
+        "en_name": "Avatar",
+        "year": "2009",
+        "part": "",
+        "season": "",
+        "episode": "",
+        "restype": "",
+        "pix": "1080p",
+        "video_codec": "",
+        "audio_codec": "",
+        "tmdbid": 19995
+    }
 }]

tests/run.py

@@ -7,6 +7,7 @@ if __name__ == '__main__':
 
     # 测试名称识别
     suite.addTest(MetaInfoTest('test_metainfo'))
+    suite.addTest(MetaInfoTest('test_emby_format_ids'))
 
     # 运行测试
     runner = unittest.TextTestRunner()

tests/test_metainfo.py

@@ -32,4 +32,32 @@ class MetaInfoTest(TestCase):
                 "video_codec": meta_info.video_encode or "",
                 "audio_codec": meta_info.audio_encode or ""
             }
+
+            # 检查tmdbid
+            if info.get("target").get("tmdbid"):
+                target["tmdbid"] = meta_info.tmdbid
+
             self.assertEqual(target, info.get("target"))
+
+    def test_emby_format_ids(self):
+        """
+        测试Emby格式ID识别
+        """
+        # 测试文件路径
+        test_paths = [
+            # 文件名中包含tmdbid
+            ("/movies/The Vampire Diaries (2009) [tmdbid=18165]/The.Vampire.Diaries.S01E01.1080p.mkv", 18165),
+            # 目录名中包含tmdbid
+            ("/movies/Inception (2010) [tmdbid-27205]/Inception.2010.1080p.mkv", 27205),
+            # 父目录名中包含tmdbid
+            ("/movies/Breaking Bad (2008) [tmdb=1396]/Season 1/Breaking.Bad.S01E01.1080p.mkv", 1396),
+            # 祖父目录名中包含tmdbid
+            ("/tv/Game of Thrones (2011) {tmdb=1399}/Season 1/Game.of.Thrones.S01E01.1080p.mkv", 1399),
+            # 测试{tmdb-xxx}格式
+            ("/movies/Avatar (2009) {tmdb-19995}/Avatar.2009.1080p.mkv", 19995),
+        ]
+
+        for path_str, expected_tmdbid in test_paths:
+            meta = MetaInfoPath(Path(path_str))
+            self.assertEqual(meta.tmdbid, expected_tmdbid,
+                             f"路径 {path_str} 期望的tmdbid为 {expected_tmdbid}，实际识别为 {meta.tmdbid}")

tests/test_release_group.py

@@ -2,6 +2,7 @@ from unittest import TestCase
 from tests.cases.groups import release_group_cases
 from app.core.meta.releasegroup import ReleaseGroupsMatcher
 
+
 class MetaInfoTest(TestCase):
     def test_release_group(self):
         for info in release_group_cases:

version.py

@@ -1,2 +1,2 @@
-APP_VERSION = 'v2.4.7'
-FRONTEND_VERSION = 'v2.4.7'
+APP_VERSION = 'v2.5.0'
+FRONTEND_VERSION = 'v2.5.0'