v2.2.2

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

app/api/endpoints/media.py

@@ -72,7 +72,7 @@ def search(title: str,
     """
     模糊搜索媒体/人物信息列表 media：媒体信息，person：人物信息
     """
-    def __get_source(obj: Union[dict, schemas.MediaPerson]):
+    def __get_source(obj: Union[schemas.MediaInfo, schemas.MediaPerson, dict]):
         """
         获取对象属性
         """
@@ -85,6 +85,8 @@ def search(title: str,
         _, medias = MediaChain().search(title=title)
         if medias:
             result = [media.to_dict() for media in medias]
+    elif type == "collection":
+        result = MediaChain().search_collections(name=title)
     else:
         result = MediaChain().search_persons(name=title)
     if result:

app/api/endpoints/subscribe.py

@@ -122,6 +122,11 @@ def update_subscribe(
     if subscribe_in.total_episode != subscribe.total_episode:
         subscribe_dict["manual_total_episode"] = 1
     subscribe.update(db, subscribe_dict)
+    # 发送订阅调整事件
+    eventmanager.send_event(EventType.SubscribeModified, {
+        "subscribe_id": subscribe.id,
+        "subscribe_info": subscribe_dict,
+    })
     return schemas.Response(success=True)
 
 
@@ -462,6 +467,17 @@ def subscribe_share(
     return schemas.Response(success=state, message=errmsg)
 
 
+@router.delete("/share/{share_id}", summary="删除分享", response_model=schemas.Response)
+def subscribe_share_delete(
+        share_id: int,
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    删除分享
+    """
+    state, errmsg = SubscribeHelper().share_delete(share_id=share_id)
+    return schemas.Response(success=state, message=errmsg)
+
+
 @router.post("/fork", summary="复用订阅", response_model=schemas.Response)
 def subscribe_fork(
         sub: schemas.SubscribeShare,

app/api/endpoints/system.py

@@ -174,6 +174,10 @@ def get_global_setting():
         exclude={"SECRET_KEY", "RESOURCE_SECRET_KEY", "API_TOKEN", "TMDB_API_KEY", "TVDB_API_KEY", "FANART_API_KEY",
                  "COOKIECLOUD_KEY", "COOKIECLOUD_PASSWORD", "GITHUB_TOKEN", "REPO_GITHUB_TOKEN"}
     )
+    # 追加用户唯一ID
+    info.update({
+        "USER_UNIQUE_ID": SystemUtils.generate_user_unique_id()
+    })
     return schemas.Response(success=True,
                             data=info)
 

app/api/endpoints/tmdb.py

@@ -60,6 +60,20 @@ def tmdb_recommend(tmdbid: int,
     return []
 
 
+@router.get("/collection/{collection_id}", summary="系列合集详情", response_model=List[schemas.MediaInfo])
+def tmdb_collection(collection_id: int,
+                    page: int = 1,
+                    count: int = 20,
+                    _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    根据合集ID查询合集详情
+    """
+    medias = TmdbChain().tmdb_collection(collection_id=collection_id)
+    if medias:
+        return [media.to_dict() for media in medias][(page - 1) * count:page * count]
+    return []
+
+
 @router.get("/credits/{tmdbid}/{type_name}", summary="演员阵容", response_model=List[schemas.MediaPerson])
 def tmdb_credits(tmdbid: int,
                  type_name: str,

app/chain/__init__.py

@@ -301,6 +301,13 @@ class ChainBase(metaclass=ABCMeta):
         """
         return self.run_module("search_persons", name=name)
 
+    def search_collections(self, name: str) -> Optional[List[MediaInfo]]:
+        """
+        搜索集合信息
+        :param name:  集合名称
+        """
+        return self.run_module("search_collections", name=name)
+
     def search_torrents(self, site: CommentedMap,
                         keywords: List[str],
                         mtype: MediaType = None,
@@ -326,19 +333,16 @@ class ChainBase(metaclass=ABCMeta):
 
     def filter_torrents(self, rule_groups: List[str],
                         torrent_list: List[TorrentInfo],
-                        season_episodes: Dict[int, list] = None,
                         mediainfo: MediaInfo = None) -> List[TorrentInfo]:
         """
         过滤种子资源
         :param rule_groups:  过滤规则组名称列表
         :param torrent_list:  资源列表
-        :param season_episodes:  季集数过滤 {season:[episodes]}
         :param mediainfo:  识别的媒体信息
         :return: 过滤后的资源列表，添加资源优先级
         """
         return self.run_module("filter_torrents", rule_groups=rule_groups,
-                               torrent_list=torrent_list, season_episodes=season_episodes,
-                               mediainfo=mediainfo)
+                               torrent_list=torrent_list, mediainfo=mediainfo)
 
     def download(self, content: Union[Path, str], download_dir: Path, cookie: str,
                  episodes: Set[int] = None, category: str = None,

app/chain/search.py

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

app/chain/site.py

@@ -1,6 +1,7 @@
 import base64
 import re
 from datetime import datetime
+from time import time
 from typing import Optional, Tuple, Union, Dict
 from urllib.parse import urljoin
 
@@ -88,7 +89,7 @@ class SiteChain(ChainBase):
                     ))
             # 低分享率警告
             if userdata.ratio and float(userdata.ratio) < 1 and not bool(
-                    re.search(r"(贵宾|VIP?)", userdata.user_level, re.IGNORECASE)):
+                    re.search(r"(贵宾|VIP?)", userdata.user_level or "", re.IGNORECASE)):
                 self.post_message(Notification(
                     mtype=NotificationType.SiteMessage,
                     title=f"【站点分享率低预警】",
@@ -172,27 +173,37 @@ class SiteChain(ChainBase):
             "Content-Type": "application/json",
             "User-Agent": user_agent,
             "Accept": "application/json, text/plain, */*",
-            "Authorization": site.token
+            "Authorization": site.token,
+            "x-api-key": site.apikey,
+            "ts": str(int(time()))
         }
         res = RequestUtils(
             headers=headers,
             proxies=settings.PROXY if site.proxy else None,
             timeout=site.timeout or 15
         ).post_res(url=url)
+        state = False
+        message = "鉴权已过期或无效"
         if res and res.status_code == 200:
-            user_info = res.json()
-            if user_info and user_info.get("data"):
+            user_info = res.json() or {}
+            if user_info.get("data"):
                 # 更新最后访问时间
+                del headers["x-api-key"]
                 res = RequestUtils(headers=headers,
                                    timeout=site.timeout or 15,
                                    proxies=settings.PROXY if site.proxy else None,
                                    referer=f"{site.url}index"
                                    ).post_res(url=f"https://api.{domain}/api/member/updateLastBrowse")
-                if res:
-                    return True, "连接成功"
-                else:
-                    return True, f"连接成功，但更新状态失败"
-        return False, "鉴权已过期或无效"
+                state = True
+                message = "连接成功，但更新状态失败"
+                if res and res.status_code == 200:
+                    update_info = res.json() or {}
+                    if "code" in update_info and int(update_info["code"]) == 0:
+                        message = "连接成功"
+            elif user_info.get("message"):
+                # 使用馒头的错误提示
+                message = user_info.get("message")
+        return state, message
 
     @staticmethod
     def __yema_test(site: Site) -> Tuple[bool, str]:

app/chain/subscribe.py

@@ -6,8 +6,6 @@ import time
 from datetime import datetime
 from typing import Dict, List, Optional, Union, Tuple
 
-from cachetools import TTLCache
-
 from app.chain import ChainBase
 from app.chain.download import DownloadChain
 from app.chain.media import MediaChain
@@ -386,7 +384,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                     self.message.put('没有找到订阅！', title="订阅搜索", role="system")
             logger.debug(f"search Lock released at {datetime.now()}")
 
-    def update_subscribe_priority(self, subscribe: Subscribe, meta: MetaInfo,
+    def update_subscribe_priority(self, subscribe: Subscribe, meta: MetaBase,
                                   mediainfo: MediaInfo, downloads: List[Context]):
         """
         更新订阅已下载资源的优先级
@@ -409,7 +407,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
             # 正在洗版，更新资源优先级
             logger.info(f'{mediainfo.title_year} 正在洗版，更新资源优先级为 {priority}')
 
-    def finish_subscribe_or_not(self, subscribe: Subscribe, meta: MetaInfo, mediainfo: MediaInfo,
+    def finish_subscribe_or_not(self, subscribe: Subscribe, meta: MetaBase, mediainfo: MediaInfo,
                                 downloads: List[Context] = None,
                                 lefts: Dict[Union[int | str], Dict[int, NotExistMediaInfo]] = None,
                                 force: bool = False):
@@ -509,9 +507,6 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
             logger.warn('没有缓存资源，无法匹配订阅')
             return
 
-        # 记录重新识别过的种子
-        _recognize_cached = TTLCache(maxsize=1024, ttl=6 * 3600)
-
         with self._rlock:
             logger.debug(f"match lock acquired at {datetime.now()}")
             # 所有订阅
@@ -552,6 +547,12 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                 if exist_flag:
                     continue
 
+                # 订阅识别词
+                if subscribe.custom_words:
+                    custom_words_list = subscribe.custom_words.split("\n")
+                else:
+                    custom_words_list = None
+
                 # 遍历缓存种子
                 _match_context = []
                 for domain, contexts in torrents.items():
@@ -573,8 +574,8 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                             continue
 
                         # 有自定义识别词时，需要判断是否需要重新识别
-                        if subscribe.custom_words:
-                            custom_words_list = subscribe.custom_words.split("\n")
+                        apply_words = None
+                        if custom_words_list:
                             _, apply_words = WordsMatcher().prepare(torrent_info.title,
                                                                     custom_words=custom_words_list)
                             if apply_words:
@@ -589,30 +590,28 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                         # 先判断是否有没识别的种子，否则重新识别
                         if not torrent_mediainfo \
                                 or (not torrent_mediainfo.tmdb_id and not torrent_mediainfo.douban_id):
-                            # 避免重复处理
-                            _cache_key = f"{torrent_meta.org_string}_{torrent_info.description}"
-                            if not _recognize_cached.get(_cache_key):
-                                _recognize_cached[_cache_key] = True
-                                # 重新识别媒体信息
-                                torrent_mediainfo = self.recognize_media(meta=torrent_meta)
-                                if torrent_mediainfo:
-                                    # 更新种子缓存
+                            # 重新识别媒体信息
+                            torrent_mediainfo = self.recognize_media(meta=torrent_meta)
+                            if torrent_mediainfo:
+                                # 更新种子缓存
+                                if not apply_words:
                                     context.media_info = torrent_mediainfo
-                                if not torrent_mediainfo:
-                                    # 通过标题匹配兜底
-                                    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
+                            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
+                                    # 更新种子缓存
+                                    if not apply_words:
                                         context.media_info = mediainfo
-                                    else:
-                                        continue
+                                else:
+                                    continue
 
                         # 直接比对媒体信息
                         if torrent_mediainfo and (torrent_mediainfo.tmdb_id or torrent_mediainfo.douban_id):
@@ -1146,16 +1145,17 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
         # 默认过滤规则
         default_rule = self.systemconfig.get(SystemConfigKey.SubscribeDefaultParams) or {}
         return {
-            "include": subscribe.include or default_rule.get("include"),
-            "exclude": subscribe.exclude or default_rule.get("exclude"),
-            "quality": subscribe.quality or default_rule.get("quality"),
-            "resolution": subscribe.resolution or default_rule.get("resolution"),
-            "effect": subscribe.effect or default_rule.get("effect"),
-            "tv_size": default_rule.get("tv_size"),
-            "movie_size": default_rule.get("movie_size"),
-            "min_seeders": default_rule.get("min_seeders"),
-            "min_seeders_time": default_rule.get("min_seeders_time"),
-        }
+            key: value for key, value in {
+                "include": subscribe.include or default_rule.get("include"),
+                "exclude": subscribe.exclude or default_rule.get("exclude"),
+                "quality": subscribe.quality or default_rule.get("quality"),
+                "resolution": subscribe.resolution or default_rule.get("resolution"),
+                "effect": subscribe.effect or default_rule.get("effect"),
+                "tv_size": default_rule.get("tv_size"),
+                "movie_size": default_rule.get("movie_size"),
+                "min_seeders": default_rule.get("min_seeders"),
+                "min_seeders_time": default_rule.get("min_seeders_time"),
+            }.items() if value is not None}
 
     def subscribe_files_info(self, subscribe: Subscribe) -> Optional[SubscrbieInfo]:
         """
@@ -1267,7 +1267,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
         subscribe_info.episodes = episodes
         return subscribe_info
 
-    def check_and_handle_existing_media(self, subscribe: Subscribe, meta: MetaInfo,
+    def check_and_handle_existing_media(self, subscribe: Subscribe, meta: MetaBase,
                                         mediainfo: MediaInfo, mediakey: str):
         """
         检查媒体是否已经存在，并根据情况执行相应的操作

app/chain/tmdb.py

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

app/chain/transfer.py

@@ -545,8 +545,6 @@ class TransferChain(ChainBase, metaclass=Singleton):
                     task = item.task
                     if not task:
                         continue
-                    # 正在处理
-                    self.jobview.running_task(task)
                     # 文件信息
                     fileitem = task.fileitem
                     # 开始新队列
@@ -692,6 +690,9 @@ class TransferChain(ChainBase, metaclass=Singleton):
                                                                          src_path=Path(task.fileitem.path),
                                                                          target_storage=task.target_storage)
 
+            # 正在处理
+            self.jobview.running_task(task)
+
             # 执行整理
             transferinfo: TransferInfo = self.transfer(fileitem=task.fileitem,
                                                        meta=task.meta,
@@ -983,23 +984,7 @@ class TransferChain(ChainBase, metaclass=Singleton):
             logger.warn(f"{fileitem.path} 没有找到可整理的媒体文件")
             return False, f"{fileitem.name} 没有找到可整理的媒体文件"
 
-        # 总数量
-        total_num = len(file_items)
-        # 已处理数量
-        processed_num = 0
-        # 失败数量
-        fail_num = 0
-
-        logger.info(f"正在计划整理 {total_num} 个文件...")
-
-        # 启动进度
-        if not background:
-            self.progress.start(ProgressKey.FileTransfer)
-            __process_msg = f"开始整理，共 {total_num} 个文件 ..."
-            logger.info(__process_msg)
-            self.progress.update(value=0,
-                                 text=__process_msg,
-                                 key=ProgressKey.FileTransfer)
+        logger.info(f"正在计划整理 {len(file_items)} 个文件...")
 
         # 整理所有文件
         transfer_tasks: List[TransferTask] = []
@@ -1013,7 +998,6 @@ class TransferChain(ChainBase, metaclass=Singleton):
                     or file_item.path.find('/.') != -1 \
                     or file_item.path.find('/@eaDir') != -1:
                 logger.debug(f"{file_item.path} 是回收站或隐藏的文件")
-                fail_num += 1
                 continue
 
             # 整理屏蔽词不处理
@@ -1027,7 +1011,6 @@ class TransferChain(ChainBase, metaclass=Singleton):
                         is_blocked = True
                         break
             if is_blocked:
-                fail_num += 1
                 continue
 
             # 整理成功的不再处理
@@ -1038,7 +1021,6 @@ class TransferChain(ChainBase, metaclass=Singleton):
                         all_success = False
                     logger.info(f"{file_item.path} 已整理过，如需重新处理，请删除整理记录。")
                     err_msgs.append(f"{file_item.name} 已整理过")
-                    fail_num += 1
                     continue
 
             if not meta:
@@ -1055,7 +1037,6 @@ class TransferChain(ChainBase, metaclass=Singleton):
                 all_success = False
                 logger.error(f"{file_path.name} 无法识别有效信息")
                 err_msgs.append(f"{file_path.name} 无法识别有效信息")
-                fail_num += 1
                 continue
 
             # 自定义识别
@@ -1105,14 +1086,28 @@ class TransferChain(ChainBase, metaclass=Singleton):
             if background:
                 self.put_to_queue(task=transfer_task)
                 logger.info(f"{file_path.name} 已添加到整理队列")
-                processed_num += 1
             else:
                 # 加入列表
                 self.__put_to_jobview(transfer_task)
                 transfer_tasks.append(transfer_task)
 
         # 实时整理
-        if not background:
+        if transfer_tasks:
+            # 总数量
+            total_num = len(transfer_tasks)
+            # 已处理数量
+            processed_num = 0
+            # 失败数量
+            fail_num = 0
+
+            # 启动进度
+            self.progress.start(ProgressKey.FileTransfer)
+            __process_msg = f"开始整理，共 {total_num} 个文件 ..."
+            logger.info(__process_msg)
+            self.progress.update(value=0,
+                                 text=__process_msg,
+                                 key=ProgressKey.FileTransfer)
+
             for transfer_task in transfer_tasks:
                 if global_vars.is_system_stopped:
                     break

app/core/context.py

@@ -178,6 +178,8 @@ class MediaInfo:
     douban_id: str = None
     # Bangumi ID
     bangumi_id: int = None
+    # 合集ID
+    collection_id: int = None
     # 媒体原语种
     original_language: str = None
     # 媒体原发行标题
@@ -397,6 +399,8 @@ class MediaInfo:
         if info.get("external_ids"):
             self.tvdb_id = info.get("external_ids", {}).get("tvdb_id")
             self.imdb_id = info.get("external_ids", {}).get("imdb_id")
+        # 合集ID
+        self.collection_id = info.get('collection_id')
         # 评分
         self.vote_average = round(float(info.get('vote_average')), 1) if info.get('vote_average') else 0
         # 描述

app/helper/subscribe.py

@@ -9,6 +9,7 @@ from app.db.systemconfig_oper import SystemConfigOper
 from app.schemas.types import SystemConfigKey
 from app.utils.http import RequestUtils
 from app.utils.singleton import Singleton
+from app.utils.system import SystemUtils
 
 
 class SubscribeHelper(metaclass=Singleton):
@@ -34,6 +35,7 @@ class SubscribeHelper(metaclass=Singleton):
 
     def __init__(self):
         self.systemconfig = SystemConfigOper()
+        self.share_user_id = SystemUtils.generate_user_unique_id()
         if settings.SUBSCRIBE_STATISTIC_SHARE:
             if not self.systemconfig.get(SystemConfigKey.SubscribeReport):
                 if self.sub_report():
@@ -133,6 +135,7 @@ class SubscribeHelper(metaclass=Singleton):
                                                 "share_title": share_title,
                                                 "share_comment": share_comment,
                                                 "share_user": share_user,
+                                                "share_uid": self.share_user_id,
                                                 **subscribe_dict
                                             })
         if res is None:
@@ -144,6 +147,24 @@ class SubscribeHelper(metaclass=Singleton):
         else:
             return False, res.json().get("message")
 
+    def share_delete(self, share_id: int) -> Tuple[bool, str]:
+        """
+        删除分享
+        """
+        if not settings.SUBSCRIBE_STATISTIC_SHARE:
+            return False, "当前没有开启订阅数据共享功能"
+        res = RequestUtils(proxies=settings.PROXY,
+                           timeout=5).delete_res(f"{self._sub_share}/{share_id}",
+                                                 params={"share_uid": self.share_user_id})
+        if res is None:
+            return False, "连接MoviePilot服务器失败"
+        if res.ok:
+            # 清除 get_shares 的缓存，以便实时看到结果
+            self._shares_cache.clear()
+            return True, ""
+        else:
+            return False, res.json().get("message")
+
     def sub_fork(self, share_id: int) -> Tuple[bool, str]:
         """
         复用分享的订阅

app/helper/torrent.py

@@ -9,6 +9,7 @@ from torrentool.api import Torrent
 
 from app.core.config import settings
 from app.core.context import Context, TorrentInfo, MediaInfo
+from app.core.meta import MetaBase
 from app.core.metainfo import MetaInfo
 from app.db.site_oper import SiteOper
 from app.db.systemconfig_oper import SystemConfigOper
@@ -445,3 +446,38 @@ class TorrentHelper(metaclass=Singleton):
                 return False
 
         return True
+
+    @staticmethod
+    def match_season_episodes(torrent: TorrentInfo, meta: MetaBase, season_episodes: Dict[int, list]) -> bool:
+        """
+        判断种子是否匹配季集数
+        :param torrent: 种子信息
+        :param meta: 种子元数据
+        :param season_episodes: 季集数 {season:[episodes]}
+        """
+        # 匹配季
+        seasons = season_episodes.keys()
+        # 种子季
+        torrent_seasons = meta.season_list
+        if not torrent_seasons:
+            # 按第一季处理
+            torrent_seasons = [1]
+        # 种子集
+        torrent_episodes = meta.episode_list
+        if not set(torrent_seasons).issubset(set(seasons)):
+            # 种子季不在过滤季中
+            logger.debug(
+                f"种子 {torrent.site_name} - {torrent.title} 包含季 {torrent_seasons} 不是需要的季 {list(seasons)}")
+            return False
+        if not torrent_episodes:
+            # 整季按匹配处理
+            return True
+        if len(torrent_seasons) == 1:
+            need_episodes = season_episodes.get(torrent_seasons[0])
+            if need_episodes \
+                    and not set(torrent_episodes).intersection(set(need_episodes)):
+                # 单季集没有交集的不要
+                logger.debug(f"种子 {torrent.site_name} - {torrent.title} "
+                             f"集 {torrent_episodes} 没有需要的集：{need_episodes}")
+                return False
+        return True

app/modules/filter/__init__.py

@@ -192,13 +192,11 @@ class FilterModule(_ModuleBase):
 
     def filter_torrents(self, rule_groups: List[str],
                         torrent_list: List[TorrentInfo],
-                        season_episodes: Dict[int, list] = None,
                         mediainfo: MediaInfo = None) -> List[TorrentInfo]:
         """
         过滤种子资源
         :param rule_groups:  过滤规则组名称列表
         :param torrent_list:  资源列表
-        :param season_episodes:  季集数过滤 {season:[episodes]}
         :param mediainfo:  媒体信息
         :return: 过滤后的资源列表，添加资源优先级
         """
@@ -215,24 +213,18 @@ class FilterModule(_ModuleBase):
                 torrent_list = self.__filter_torrents(
                     rule_string=group.rule_string,
                     rule_name=group.name,
-                    torrent_list=torrent_list,
-                    season_episodes=season_episodes
-                )
+                    torrent_list=torrent_list
+                    )
         return torrent_list
 
     def __filter_torrents(self, rule_string: str, rule_name: str,
-                          torrent_list: List[TorrentInfo],
-                          season_episodes: Dict[int, list]) -> List[TorrentInfo]:
+                          torrent_list: List[TorrentInfo]) -> List[TorrentInfo]:
         """
         过滤种子
         """
         # 返回种子列表
         ret_torrents = []
         for torrent in torrent_list:
-            # 季集数过滤
-            if season_episodes \
-                    and not self.__match_season_episodes(torrent, season_episodes):
-                continue
             # 能命中优先级的才返回
             if not self.__get_order(torrent, rule_string):
                 logger.debug(f"种子 {torrent.site_name} - {torrent.title} {torrent.description} "
@@ -242,39 +234,6 @@ class FilterModule(_ModuleBase):
 
         return ret_torrents
 
-    @staticmethod
-    def __match_season_episodes(torrent: TorrentInfo, season_episodes: Dict[int, list]):
-        """
-        判断种子是否匹配季集数
-        """
-        # 匹配季
-        seasons = season_episodes.keys()
-        meta = MetaInfo(title=torrent.title, subtitle=torrent.description)
-        # 种子季
-        torrent_seasons = meta.season_list
-        if not torrent_seasons:
-            # 按第一季处理
-            torrent_seasons = [1]
-        # 种子集
-        torrent_episodes = meta.episode_list
-        if not set(torrent_seasons).issubset(set(seasons)):
-            # 种子季不在过滤季中
-            logger.debug(
-                f"种子 {torrent.site_name} - {torrent.title} 包含季 {torrent_seasons} 不是需要的季 {list(seasons)}")
-            return False
-        if not torrent_episodes:
-            # 整季按匹配处理
-            return True
-        if len(torrent_seasons) == 1:
-            need_episodes = season_episodes.get(torrent_seasons[0])
-            if need_episodes \
-                    and not set(torrent_episodes).intersection(set(need_episodes)):
-                # 单季集没有交集的不要
-                logger.debug(f"种子 {torrent.site_name} - {torrent.title} "
-                             f"集 {torrent_episodes} 没有需要的集：{need_episodes}")
-                return False
-        return True
-
     def __get_order(self, torrent: TorrentInfo, rule_str: str) -> Optional[TorrentInfo]:
         """
         获取种子匹配的规则优先级，值越大越优先，未匹配时返回None

app/modules/indexer/parser/nexus_php.py

@@ -43,7 +43,7 @@ class NexusPhpSiteUserInfo(SiteParserBase):
             message_text = message_labels[0].xpath("string(.)")
 
             logger.debug(f"{self._site_name} 消息原始信息 {message_text}")
-            message_unread_match = re.findall(r"[^Date](信息箱\s*|\(|你有\xa0)(\d+)", message_text)
+            message_unread_match = re.findall(r"[^Date](信息箱\s*|\((?![^)]*:)|你有\xa0)(\d+)", message_text)
 
             if message_unread_match and len(message_unread_match[-1]) == 2:
                 self.message_unread = StringUtils.str_int(message_unread_match[-1][1])

app/modules/themoviedb/__init__.py

@@ -311,6 +311,27 @@ class TheMovieDbModule(_ModuleBase):
             return [MediaPerson(source='themoviedb', **person) for person in results]
         return []
 
+    def search_collections(self, name: str) -> Optional[List[MediaInfo]]:
+        """
+        搜索集合信息
+        """
+        if not name:
+            return []
+        results = self.tmdb.search_collections(name)
+        if results:
+            return [MediaInfo(tmdb_info=info) for info in results]
+        return []
+
+    def tmdb_collection(self, collection_id: int) -> Optional[List[MediaInfo]]:
+        """
+        根据合集ID查询集合
+        :param collection_id:  合集ID
+        """
+        results = self.tmdb.get_collection(collection_id)
+        if results:
+            return [MediaInfo(tmdb_info=info) for info in results]
+        return []
+
     def metadata_nfo(self, meta: MetaBase, mediainfo: MediaInfo,
                      season: int = None, episode: int = None) -> Optional[str]:
         """

app/modules/themoviedb/tmdbapi.py

@@ -11,7 +11,7 @@ from app.log import logger
 from app.schemas.types import MediaType
 from app.utils.http import RequestUtils
 from app.utils.string import StringUtils
-from .tmdbv3api import TMDb, Search, Movie, TV, Season, Episode, Discover, Trending, Person
+from .tmdbv3api import TMDb, Search, Movie, TV, Season, Episode, Discover, Trending, Person, Collection
 from .tmdbv3api.exceptions import TMDbException
 
 
@@ -44,6 +44,7 @@ class TmdbApi:
         self.discover = Discover()
         self.trending = Trending()
         self.person = Person()
+        self.collection = Collection()
 
     def search_multiis(self, title: str) -> List[dict]:
         """
@@ -101,6 +102,32 @@ class TmdbApi:
             return []
         return self.search.people(term=name) or []
 
+    def search_collections(self, name: str) -> List[dict]:
+        """
+        查询模糊匹配的所有合集TMDB信息
+        """
+        if not name:
+            return []
+        collections = self.search.collections(term=name) or []
+        for collection in collections:
+            collection['media_type'] = MediaType.COLLECTION
+            collection['collection_id'] = collection.get("id")
+        return collections
+
+    def get_collection(self, collection_id: int) -> List[dict]:
+        """
+        根据合集ID查询合集详情
+        """
+        if not collection_id:
+            return []
+        try:
+            return self.collection.details(collection_id=collection_id)
+        except TMDbException as err:
+            logger.error(f"连接TMDB出错：{str(err)}")
+        except Exception as e:
+            logger.error(f"连接TMDB出错：{str(e)}")
+        return []
+
     @staticmethod
     def __compare_names(file_name: str, tmdb_names: list) -> bool:
         """

app/schemas/context.py

@@ -67,7 +67,7 @@ class MediaInfo(BaseModel):
     """
     # 来源：themoviedb、douban、bangumi
     source: Optional[str] = None
-    # 类型 电影、电视剧
+    # 类型 电影、电视剧、合集
     type: Optional[str] = None
     # 媒体标题
     title: Optional[str] = None
@@ -79,6 +79,8 @@ class MediaInfo(BaseModel):
     title_year: Optional[str] = None
     # 当前指定季，如有
     season: Optional[int] = None
+    # 合集等id
+    collection_id: Optional[int] = None
     # TMDB ID
     tmdb_id: Optional[int] = None
     # IMDB ID

app/schemas/subscribe.py

@@ -88,6 +88,8 @@ class SubscribeShare(BaseModel):
     share_comment: Optional[str] = None
     # 分享人
     share_user: Optional[str] = None
+    # 分享人唯一ID
+    share_uid: Optional[str] = None
     # 订阅名称
     name: Optional[str] = None
     # 订阅年份
@@ -127,6 +129,8 @@ class SubscribeShare(BaseModel):
     custom_words: Optional[str] = None
     # 自定义媒体类别
     media_category: Optional[str] = None
+    # 复用人次
+    count: Optional[int] = 0
 
 
 class SubscribeDownloadFileInfo(BaseModel):

app/schemas/transfer.py

@@ -48,8 +48,8 @@ class TransferTask(BaseModel):
     """
     文件整理任务
     """
-    fileitem: FileItem = None
-    meta: Any = None
+    fileitem: FileItem
+    meta: Optional[Any] = None
     mediainfo: Optional[Any] = None
     target_directory: Optional[TransferDirectoryConf] = None
     target_storage: Optional[str] = None

app/schemas/types.py

@@ -5,6 +5,7 @@ from enum import Enum
 class MediaType(Enum):
     MOVIE = '电影'
     TV = '电视剧'
+    COLLECTION = '系列'
     UNKNOWN = '未知'
 
 
@@ -48,6 +49,8 @@ class EventType(Enum):
     NoticeMessage = "notice.message"
     # 订阅已添加
     SubscribeAdded = "subscribe.added"
+    # 订阅已调整
+    SubscribeModified = "subscribe.modified"
     # 订阅已删除
     SubscribeDeleted = "subscribe.deleted"
     # 订阅已完成

app/utils/http.py

@@ -207,6 +207,32 @@ class RequestUtils:
                             raise_exception=raise_exception,
                             **kwargs)
 
+    def delete_res(self,
+                   url: str,
+                   data: Any = None,
+                   params: dict = None,
+                   allow_redirects: bool = True,
+                   raise_exception: bool = False,
+                   **kwargs) -> Optional[Response]:
+        """
+        发送DELETE请求并返回响应对象
+        :param url: 请求的URL
+        :param data: 请求的数据
+        :param params: 请求的参数
+        :param allow_redirects: 是否允许重定向
+        :param raise_exception: 是否在发生异常时抛出异常，否则默认拦截异常返回None
+        :param kwargs: 其他请求参数，如headers, cookies, proxies等
+        :return: HTTP响应对象，若发生RequestException则返回None
+        :raises: requests.exceptions.RequestException 仅raise_exception为True时会抛出
+        """
+        return self.request(method="delete",
+                            url=url,
+                            data=data,
+                            params=params,
+                            allow_redirects=allow_redirects,
+                            raise_exception=raise_exception,
+                            **kwargs)
+
     @staticmethod
     def cookie_parse(cookies_str: str, array: bool = False) -> Union[list, dict]:
         """

app/utils/system.py

@@ -1,10 +1,12 @@
 import datetime
+import hashlib
 import os
 import platform
 import re
 import shutil
 import subprocess
 import sys
+import uuid
 from glob import glob
 from pathlib import Path
 from typing import List, Optional, Tuple, Union
@@ -556,3 +558,45 @@ class SystemUtils:
             # 确保是空文件夹
             if folder.is_dir() and not any(folder.iterdir()):
                 folder.rmdir()
+
+    @staticmethod
+    def generate_user_unique_id():
+        """
+        根据优先级依次尝试生成稳定唯一ID：
+        1. 文件系统唯一标识符。
+        2. MAC 地址。
+        3. 主机名。
+        """
+
+        def get_filesystem_unique_id():
+            """
+            获取文件系统的唯一标识符。
+            使用根目录的设备号和 inode。
+            """
+            try:
+                stat_info = os.stat("/")
+                fs_id = f"{stat_info.st_dev}-{stat_info.st_ino}"
+                return hashlib.sha256(fs_id.encode("utf-8")).hexdigest()
+            except Exception as e:
+                print(str(e))
+                return None
+
+        def get_mac_address_id():
+            """
+            获取设备的 MAC 地址并生成唯一标识符。
+            """
+            try:
+                mac_address = uuid.getnode()
+                if (mac_address >> 40) % 2:  # 检查是否是虚拟MAC地址
+                    raise ValueError("MAC地址可能是虚拟地址")
+                mac_str = f"{mac_address:012x}"
+                return hashlib.sha256(mac_str.encode("utf-8")).hexdigest()
+            except Exception as e:
+                print(str(e))
+                return None
+
+        for method in [get_filesystem_unique_id, get_mac_address_id]:
+            unique_id = method()
+            if unique_id:
+                return unique_id
+        return None

version.py

@@ -1,2 +1,2 @@
-APP_VERSION = 'v2.2.0'
-FRONTEND_VERSION = 'v2.2.0'
+APP_VERSION = 'v2.2.2'
+FRONTEND_VERSION = 'v2.2.2'