import copy from typing import Any, List, Optional, Tuple from app.application.torrent import TorrentHelper from app.application.subscription.contract import ( build_subscribe_meta, subscribe_media_key, ) from app.chain.download import DownloadChain from app.chain.media import MediaChain from app.chain.search import SearchChain from app.application.chain.data import SubscribePortProxy as SubscribeOper from app.application.configuration import get_configured_system_config from app.domain.context import Context, MediaInfo, MusicInfo from app.domain.media import MUSIC_SUBSCRIBABLE_TYPES from app.domain.meta.metamusic import MetaMusic from app.runtime.log import logger from app.schemas.types import ( MUSIC_ENTITY_ALBUM, MUSIC_ENTITY_RECORDING, MediaType, SystemConfigKey, ) Subscribe = Any def _normalize_music_total_tracks(value: Any) -> Optional[int]: """将专辑曲目总数归一为正整数，无效或未知值返回 None。""" try: total_tracks = int(value or 0) except (TypeError, ValueError): return None return total_tracks if total_tracks > 0 else None class MusicSubscribeMixin: """ 音乐订阅功能域 mixin：单曲/专辑目标识别、实体快照同步、候选筛选、 择优下载与完成推进。 该域方法通过 self 复用 SubscribeChain 主体的 get_sub_sites / get_params / filter_torrents / check_and_handle_existing_media / finish_subscribe_or_not / get_subscribe_source_keyword 等编排能力，因此仅作为 mixin 混入 SubscribeChain， 不独立成链。订阅元数据与媒体键由 Application 共享契约提供，避免 mixin 与 SubscribeChain 主体形成双向模块依赖。 """ @staticmethod def _validate_music_subscribe_target( mediainfo: MediaInfo, requested_music_type: Optional[str] = None, ) -> Optional[str]: """校验音乐订阅实体一致性，并确保专辑具备可验证的曲目总数。""" if mediainfo.type != MediaType.MUSIC: return "识别结果不是音乐" music_type = getattr(mediainfo, "music_type", None) if requested_music_type and requested_music_type not in MUSIC_SUBSCRIBABLE_TYPES: return "音乐订阅仅支持单曲或专辑" if music_type not in MUSIC_SUBSCRIBABLE_TYPES: return "音乐订阅仅支持单曲或专辑" if requested_music_type and requested_music_type != music_type: return f"音乐订阅类型不匹配：请求 {requested_music_type}，识别为 {music_type}" if music_type == MUSIC_ENTITY_ALBUM \ and _normalize_music_total_tracks(getattr(mediainfo, "total_tracks", None)) is None: return "专辑总曲目数未知，无法校验整张专辑资源" return None @staticmethod def _ensure_music_subscribe_entity( subscribe: Subscribe, mediainfo: Optional[MusicInfo], ) -> Optional[MusicInfo]: """保持已持久化的单曲/专辑实体边界，拒绝远端详情把订阅类型改写。""" if not mediainfo: return None expected_type = getattr(subscribe, "music_type", None) actual_type = getattr(mediainfo, "music_type", None) if expected_type and expected_type not in MUSIC_SUBSCRIBABLE_TYPES: logger.warning(f"音乐订阅 {subscribe.name} 的实体类型无效：{expected_type}") return None if actual_type not in MUSIC_SUBSCRIBABLE_TYPES: logger.warning( f"音乐订阅 {subscribe.name} 识别为不可订阅实体：{actual_type}" ) if expected_type in MUSIC_SUBSCRIBABLE_TYPES: return MusicSubscribeMixin._music_info_from_subscribe(subscribe) return None if expected_type and actual_type != expected_type: logger.warning( f"音乐订阅 {subscribe.name} 实体不匹配：" f"订阅为 {expected_type}，远端识别为 {actual_type}，使用订阅快照" ) return MusicSubscribeMixin._music_info_from_subscribe(subscribe) if actual_type == MUSIC_ENTITY_ALBUM: remote_total = _normalize_music_total_tracks(getattr(mediainfo, "total_tracks", None)) stored_total = _normalize_music_total_tracks(getattr(subscribe, "total_tracks", None)) resolved_total = remote_total or stored_total if resolved_total is not None and mediainfo.total_tracks != resolved_total: # 识别模块结果可能来自共享缓存，补齐订阅快照时不得原地修改。 mediainfo = copy.copy(mediainfo) mediainfo.total_tracks = resolved_total return mediainfo @staticmethod def _recognize_music_subscribe(subscribe: Subscribe) -> Optional[MusicInfo]: """按订阅身份恢复音乐目标，远端暂不可用时使用已持久化的稳定快照。""" if subscribe.media_source and subscribe.media_id: # 与影视共用统一识别入口，按媒体源和原生 ID 恢复音乐详情 mediainfo = MediaChain().recognize_media( media_source=subscribe.media_source, media_id=str(subscribe.media_id), mtype=MediaType.MUSIC, music_type=getattr(subscribe, "music_type", None), ) if mediainfo: return MusicSubscribeMixin._ensure_music_subscribe_entity(subscribe, mediainfo) if getattr(subscribe, "music_type", None) in {MUSIC_ENTITY_RECORDING, MUSIC_ENTITY_ALBUM}: return MusicSubscribeMixin._music_info_from_subscribe(subscribe) # 旧订阅没有保存实体类型时不能猜测为单曲，否则可能误把专辑按单曲完成。 return None if getattr(subscribe, "music_type", None) == MUSIC_ENTITY_ALBUM: # 缺少远端 ID 的专辑不能退化为单曲识别，使用已保存专辑快照更可靠。 return MusicSubscribeMixin._music_info_from_subscribe(subscribe) # 旧订阅没有实体类型时只允许走 Recording 识别，不能从全局混合搜索中猜成专辑或艺术家。 mediainfo = MediaChain().recognize_media( meta=build_subscribe_meta(subscribe), mtype=MediaType.MUSIC, media_source=subscribe.media_source, music_type=MUSIC_ENTITY_RECORDING, ) return MusicSubscribeMixin._ensure_music_subscribe_entity(subscribe, mediainfo) @staticmethod async def _async_recognize_music_subscribe(subscribe: Subscribe) -> Optional[MusicInfo]: """异步按订阅身份恢复音乐目标，远端暂不可用时使用已持久化的稳定快照。""" if subscribe.media_source and subscribe.media_id: # 与影视共用统一识别入口，按媒体源和原生 ID 恢复音乐详情 mediainfo = await MediaChain().async_recognize_media( media_source=subscribe.media_source, media_id=str(subscribe.media_id), mtype=MediaType.MUSIC, music_type=getattr(subscribe, "music_type", None), ) if mediainfo: return MusicSubscribeMixin._ensure_music_subscribe_entity(subscribe, mediainfo) if getattr(subscribe, "music_type", None) in {MUSIC_ENTITY_RECORDING, MUSIC_ENTITY_ALBUM}: return MusicSubscribeMixin._music_info_from_subscribe(subscribe) return None if getattr(subscribe, "music_type", None) == MUSIC_ENTITY_ALBUM: return MusicSubscribeMixin._music_info_from_subscribe(subscribe) mediainfo = await MediaChain().async_recognize_media( meta=build_subscribe_meta(subscribe), mtype=MediaType.MUSIC, media_source=subscribe.media_source, music_type=MUSIC_ENTITY_RECORDING, ) return MusicSubscribeMixin._ensure_music_subscribe_entity(subscribe, mediainfo) @staticmethod def _music_info_from_subscribe(subscribe: Subscribe) -> MusicInfo: """从订阅行恢复不依赖远端请求的最小音乐目标，保留专辑完成判断所需字段。""" year_text = str(subscribe.year or "")[:4] music_type = getattr(subscribe, "music_type", None) # 音乐订阅的 description 由标准 MusicInfo.overview 生成，首段固定为艺术家。 artist_text = str(getattr(subscribe, "description", None) or "") \ .split(" · ", maxsplit=1)[0].strip() artists = [ artist.strip() for artist in artist_text.split(" / ") if artist.strip() ] return MusicInfo( media_source=subscribe.media_source, media_id=str(subscribe.media_id) if subscribe.media_id is not None else None, music_type=music_type, title=subscribe.name, artists=artists, album=subscribe.name if music_type == MUSIC_ENTITY_ALBUM else None, year=int(year_text) if year_text.isdigit() else None, total_tracks=getattr(subscribe, "total_tracks", None) if music_type == MUSIC_ENTITY_ALBUM else None, cover_url=getattr(subscribe, "poster", None) or getattr(subscribe, "backdrop", None), ) @staticmethod def _sync_music_subscribe_target(subscribe: Subscribe, mediainfo: MusicInfo) -> None: """把远端识别得到的专辑类型和总曲目数同步到订阅，供搜索失败与完成历史复用。""" update_data = {} if mediainfo.music_type and getattr(subscribe, "music_type", None) != mediainfo.music_type: update_data["music_type"] = mediainfo.music_type if mediainfo.music_type == MUSIC_ENTITY_ALBUM: # 远端详情可能暂时不返回曲目数；已确认的订阅快照不能因此被清空。 total_tracks = _normalize_music_total_tracks(mediainfo.total_tracks) \ or _normalize_music_total_tracks(getattr(subscribe, "total_tracks", None)) else: total_tracks = None if getattr(subscribe, "total_tracks", None) != total_tracks: update_data["total_tracks"] = total_tracks if not update_data: return SubscribeOper().update(subscribe.id, update_data) for key, value in update_data.items(): setattr(subscribe, key, value) @staticmethod def _is_music_download_complete( subscribe: Subscribe, mediainfo: MusicInfo, downloads: Optional[List[Context]], ) -> bool: """判断音乐下载是否满足订阅完成条件；专辑必须由下载层确认整专曲目覆盖。""" if not downloads: return False music_type = getattr(subscribe, "music_type", None) or mediainfo.music_type if music_type != MUSIC_ENTITY_ALBUM: return True return any(context.confirmed_full_coverage for context in downloads) def _prepare_music_subscribe( self, subscribe: Subscribe, ) -> Optional[Tuple[MusicInfo, MetaMusic]]: """识别音乐订阅目标、同步实体快照，并在搜索前处理已完整入库的目标。""" mediainfo = self._recognize_music_subscribe(subscribe) if not mediainfo: logger.warning( f"未识别到音乐订阅目标：{subscribe.name}，" f"媒体源：{subscribe.media_source}，媒体ID：{subscribe.media_id}" ) return None validation_error = self._validate_music_subscribe_target( mediainfo, getattr(subscribe, "music_type", None), ) if validation_error: logger.warning(f"音乐订阅 {subscribe.name} 无法继续：{validation_error}") return None self._sync_music_subscribe_target(subscribe, mediainfo) meta = MetaMusic.from_music_info(mediainfo) exists, _ = self.check_and_handle_existing_media( subscribe=subscribe, meta=meta, mediainfo=mediainfo, mediakey=subscribe_media_key(subscribe), ) if exists: return None return mediainfo, meta def _filter_music_subscribe_contexts( self, subscribe: Subscribe, mediainfo: MusicInfo, contexts: List[Context], ) -> List[Context]: """按站点、音乐实体、订阅参数和优先级规则筛选并绑定下载上下文。""" sites = self.get_sub_sites(subscribe) default_rule_key = SystemConfigKey.BestVersionFilterRuleGroups \ if subscribe.best_version else SystemConfigKey.SubscribeFilterRuleGroups rule_groups = subscribe.filter_groups or get_configured_system_config().get(default_rule_key) or [] torrent_helper = TorrentHelper() matched: List[Context] = [] for source_context in contexts or []: source_torrent = source_context.torrent_info if not source_torrent or source_torrent.category not in (MediaType.MUSIC, MediaType.MUSIC.value): continue # 过滤模块会就地写入 pri_order；RSS 缓存会被多个订阅复用，必须隔离候选副本。 torrent = copy.copy(source_torrent) if sites and torrent.site not in sites: continue if not SearchChain.matches_music_resource( mediainfo, torrent.title, torrent.description, ): continue if not torrent_helper.filter_torrent(torrent, self.get_params(subscribe)): continue filtered = self.filter_torrents( rule_groups=rule_groups, torrent_list=[torrent], mediainfo=mediainfo, ) if filtered is not None: if not filtered: continue torrent = filtered[0] context = copy.copy(source_context) context.torrent_info = torrent meta = MetaMusic.from_music_info(mediainfo) meta.org_string = torrent.title meta.apply_audio_quality(f"{torrent.title} {torrent.description or ''}", overwrite=True) if subscribe.best_version: # 用户规则组可用格式、码率等内置规则定义洗版顺序；未命中规则 # 优先级时再回退到规范化音质分数，确保零配置也能自动升级。 music_priority = torrent.pri_order or meta.audio_quality_score if music_priority <= (subscribe.current_priority or 0): logger.info( f"{torrent.title} 音质优先级 {music_priority} " f"未高于当前版本 {subscribe.current_priority or 0}" ) continue torrent.pri_order = music_priority context.meta_info = meta context.media_info = mediainfo context.match_source = str(mediainfo.media_source or "title") context.candidate_recognized = False context.media_info_is_target = True if subscribe.media_category: context.media_info.category = subscribe.media_category matched.append(context) return matched def _download_music_subscribe( self, subscribe: Subscribe, mediainfo: MusicInfo, contexts: List[Context], ) -> None: """批量择优下载音乐候选，并按单曲或整专完成语义推进订阅。""" if not contexts: return downloads, _ = DownloadChain().batch_download( contexts=contexts, username=subscribe.username, save_path=subscribe.save_path, downloader=subscribe.downloader, source=self.get_subscribe_source_keyword(subscribe), custom_words=subscribe.custom_words, ) successful = [ context for context in downloads or [] if context and context.meta_info and context.torrent_info ] quality_downloads = successful if getattr(subscribe, "music_type", None) == MUSIC_ENTITY_ALBUM: quality_downloads = [ context for context in successful if context.confirmed_full_coverage ] if subscribe.best_version and quality_downloads: best_context = max(quality_downloads, key=lambda item: item.torrent_info.pri_order) best_meta = best_context.meta_info quality_data = { "current_priority": best_context.torrent_info.pri_order, "current_audio_format": best_meta.audio_format, "current_bitrate": best_meta.bitrate, "current_bit_depth": best_meta.bit_depth, "current_sample_rate": best_meta.sample_rate, } SubscribeOper().update(subscribe.id, quality_data) for key, value in quality_data.items(): setattr(subscribe, key, value) current_subscribe = SubscribeOper().get(subscribe.id) if current_subscribe: self.finish_subscribe_or_not( subscribe=current_subscribe, meta=MetaMusic.from_music_info(mediainfo), mediainfo=mediainfo, downloads=downloads, ) def _search_music_subscribe(self, subscribe: Subscribe) -> None: """复用站点标题搜索、订阅过滤和批量下载完成单个音乐订阅。""" target = self._prepare_music_subscribe(subscribe) if not target: return mediainfo, _ = target sites = self.get_sub_sites(subscribe) default_rule_key = SystemConfigKey.BestVersionFilterRuleGroups \ if subscribe.best_version else SystemConfigKey.SubscribeFilterRuleGroups rule_groups = subscribe.filter_groups or get_configured_system_config().get(default_rule_key) or [] keywords = [subscribe.keyword] if subscribe.keyword else SearchChain.music_site_keywords(mediainfo) if not keywords: keywords = [subscribe.name] searchchain = SearchChain() contexts: List[Context] = [] for keyword in keywords: contexts = searchchain.search_by_title( title=keyword, sites=sites, mtype=MediaType.MUSIC, rule_groups=rule_groups, ) contexts = self._filter_music_subscribe_contexts( subscribe=subscribe, mediainfo=mediainfo, contexts=contexts, ) if contexts: break if not contexts: logger.warning(f"音乐订阅 {subscribe.keyword or subscribe.name} 未搜索到符合条件的资源") return self._download_music_subscribe(subscribe, mediainfo, contexts) def _match_music_subscribe( self, subscribe: Subscribe, contexts: List[Context], ) -> None: """直接匹配本轮 RSS 缓存中的音乐资源，避免再次调用站点搜索接口。""" target = self._prepare_music_subscribe(subscribe) if not target: return mediainfo, _ = target matched = self._filter_music_subscribe_contexts( subscribe=subscribe, mediainfo=mediainfo, contexts=contexts, ) if not matched: logger.info(f"音乐订阅 {subscribe.name} 未匹配到符合条件的 RSS 资源") return self._download_music_subscribe(subscribe, mediainfo, matched)