mirror of
https://github.com/jxxghp/MoviePilot.git
synced 2026-11-22 03:43:45 +08:00
411 lines
15 KiB
Python
411 lines
15 KiB
Python
"""媒体原生路由与同步异步识别回退 owner。"""
|
|
|
|
from copy import deepcopy
|
|
from dataclasses import dataclass
|
|
from enum import Enum
|
|
from typing import Any, Mapping, Optional, cast
|
|
|
|
from app.chain.base import ChainBase
|
|
from app.chain.media.contract import _MediaOwnerBase
|
|
from app.domain.context import (
|
|
MediaInfo,
|
|
)
|
|
from app.domain.media import is_music_media_source
|
|
from app.domain.meta.metabase import MetaBase
|
|
from app.domain.meta.metamusic import MetaMusic
|
|
from app.runtime.cache import async_fresh, fresh
|
|
from app.runtime.log import logger
|
|
from app.schemas.types import (
|
|
MUSIC_ENTITY_RECORDING,
|
|
ChainEventType,
|
|
MediaSource,
|
|
MediaType,
|
|
)
|
|
|
|
|
|
class _NativeRecognitionAction(Enum):
|
|
"""标识媒体识别入口下一步需要执行的真实 I/O 动作。"""
|
|
|
|
MUSIC = "music"
|
|
VIDEO = "video"
|
|
NONE = "none"
|
|
|
|
|
|
@dataclass(frozen=True, slots=True)
|
|
class _NativeRecognitionPlan:
|
|
"""冻结同步与异步原生识别入口共用的路由和调用参数。"""
|
|
|
|
action: _NativeRecognitionAction
|
|
kwargs: Mapping[str, Any]
|
|
refresh_cache: bool = False
|
|
|
|
|
|
@dataclass(frozen=True, slots=True)
|
|
class _MetaRecognitionRequest:
|
|
"""冻结一次按标题识别所需的元数据、副本和来源决策。"""
|
|
|
|
title: str
|
|
metainfo: MetaBase
|
|
share_meta: MetaBase
|
|
mtype: Optional[MediaType]
|
|
media_source: Optional[MediaSource]
|
|
episode_group: Optional[str]
|
|
music_type: Optional[str]
|
|
is_music: bool
|
|
|
|
@property
|
|
def plugin_event(self) -> ChainEventType:
|
|
"""返回与媒体类型匹配的辅助识别事件。"""
|
|
return (
|
|
ChainEventType.MusicNameRecognize
|
|
if self.is_music
|
|
else ChainEventType.NameRecognize
|
|
)
|
|
|
|
|
|
class MediaRecognitionOwner(_MediaOwnerBase):
|
|
"""媒体原生路由与同步异步识别回退 owner。"""
|
|
|
|
def _native_recognition_plan(
|
|
self,
|
|
module_kwargs: Mapping[str, Any],
|
|
cache: bool,
|
|
) -> _NativeRecognitionPlan:
|
|
"""把媒体类型、显式来源和默认来源归并为唯一原生识别计划。"""
|
|
meta = module_kwargs.get("meta")
|
|
mtype = module_kwargs.get("mtype")
|
|
media_source = module_kwargs.get("media_source")
|
|
if (
|
|
isinstance(meta, MetaMusic)
|
|
or mtype == MediaType.MUSIC
|
|
or is_music_media_source(media_source)
|
|
):
|
|
if media_source:
|
|
recognize_kwargs: dict[str, Any] = {
|
|
"media_source": media_source,
|
|
"meta": meta if isinstance(meta, MetaMusic) else None,
|
|
"media_id": module_kwargs.get("media_id"),
|
|
"cache": cache,
|
|
}
|
|
if "music_type" in module_kwargs:
|
|
recognize_kwargs["music_type"] = module_kwargs["music_type"]
|
|
return _NativeRecognitionPlan(
|
|
action=_NativeRecognitionAction.MUSIC,
|
|
kwargs=recognize_kwargs,
|
|
refresh_cache=not cache,
|
|
)
|
|
if isinstance(meta, MetaMusic):
|
|
return _NativeRecognitionPlan(
|
|
action=_NativeRecognitionAction.MUSIC,
|
|
kwargs={
|
|
"media_source": self._music_primary_source,
|
|
"meta": meta,
|
|
"cache": cache,
|
|
"music_type": MUSIC_ENTITY_RECORDING,
|
|
},
|
|
)
|
|
return _NativeRecognitionPlan(
|
|
action=_NativeRecognitionAction.NONE,
|
|
kwargs={},
|
|
)
|
|
video_kwargs = dict(module_kwargs)
|
|
if not media_source and isinstance(meta, MetaBase):
|
|
video_kwargs["media_source"] = self._video_primary_source
|
|
return _NativeRecognitionPlan(
|
|
action=_NativeRecognitionAction.VIDEO,
|
|
kwargs=video_kwargs,
|
|
)
|
|
|
|
def _run_native_media_recognize(
|
|
self,
|
|
module_kwargs: dict[str, Any],
|
|
cache: bool,
|
|
) -> Optional[MediaInfo]:
|
|
"""统一同步媒体识别路由,未指定来源时影视和音乐只使用各自主数据源。"""
|
|
plan = MediaRecognitionOwner._native_recognition_plan(
|
|
self, module_kwargs, cache
|
|
)
|
|
if plan.action is _NativeRecognitionAction.NONE:
|
|
return None
|
|
if plan.action is _NativeRecognitionAction.MUSIC:
|
|
with fresh(plan.refresh_cache):
|
|
return cast(
|
|
Optional[MediaInfo],
|
|
self.recognize_music_from_source(**plan.kwargs),
|
|
)
|
|
return ChainBase._run_native_media_recognize(
|
|
cast(ChainBase, self), dict(plan.kwargs), cache
|
|
)
|
|
|
|
async def _async_run_native_media_recognize(
|
|
self,
|
|
module_kwargs: dict[str, Any],
|
|
cache: bool,
|
|
) -> Optional[MediaInfo]:
|
|
"""统一异步媒体识别路由,未指定来源时影视和音乐只使用各自主数据源。"""
|
|
plan = MediaRecognitionOwner._native_recognition_plan(
|
|
self, module_kwargs, cache
|
|
)
|
|
if plan.action is _NativeRecognitionAction.NONE:
|
|
return None
|
|
if plan.action is _NativeRecognitionAction.MUSIC:
|
|
async with async_fresh(plan.refresh_cache):
|
|
return cast(
|
|
Optional[MediaInfo],
|
|
await self.async_recognize_music_from_source(**plan.kwargs),
|
|
)
|
|
return await ChainBase._async_run_native_media_recognize(
|
|
cast(ChainBase, self), dict(plan.kwargs), cache
|
|
)
|
|
|
|
@staticmethod
|
|
def _meta_recognition_request(
|
|
metainfo: MetaBase,
|
|
*,
|
|
mtype: Optional[MediaType],
|
|
media_source: Optional[MediaSource],
|
|
episode_group: Optional[str],
|
|
music_type: Optional[str],
|
|
) -> _MetaRecognitionRequest:
|
|
"""为同步与异步标题识别冻结相同的元数据副本和来源语义。"""
|
|
return _MetaRecognitionRequest(
|
|
title=metainfo.title,
|
|
metainfo=metainfo,
|
|
share_meta=deepcopy(metainfo),
|
|
mtype=mtype,
|
|
media_source=media_source,
|
|
episode_group=episode_group,
|
|
music_type=music_type,
|
|
is_music=mtype == MediaType.MUSIC or isinstance(metainfo, MetaMusic),
|
|
)
|
|
|
|
@staticmethod
|
|
def _has_remote_identity(result: Optional[MediaInfo]) -> bool:
|
|
"""音乐识别仅在取得远端来源身份后视为完整命中。"""
|
|
return bool(result and result.media_source)
|
|
|
|
@staticmethod
|
|
def _accepted_recognition(
|
|
request: _MetaRecognitionRequest,
|
|
mediainfo: Optional[MediaInfo],
|
|
) -> Optional[MediaInfo]:
|
|
"""统一识别结果的空值判定与成功日志,图片补充留给各 I/O 外壳。"""
|
|
if not mediainfo:
|
|
return None
|
|
logger.info(
|
|
f"{request.title} 识别到媒体信息:"
|
|
f"{mediainfo.type.value} {mediainfo.title_year}"
|
|
)
|
|
return mediainfo
|
|
|
|
def recognize_by_meta(
|
|
self,
|
|
metainfo: MetaBase,
|
|
media_source: Optional[MediaSource] = None,
|
|
episode_group: Optional[str] = None,
|
|
obtain_images: bool = False,
|
|
mtype: Optional[MediaType] = None,
|
|
music_type: Optional[str] = None,
|
|
) -> Optional[MediaInfo]:
|
|
"""
|
|
根据主副标题识别媒体信息
|
|
|
|
:param metainfo: 标题解析元数据
|
|
:param media_source: 请求级识别数据源
|
|
:param episode_group: 剧集组
|
|
:param obtain_images: 是否补充图片
|
|
:param mtype: 上游已确定的媒体类型
|
|
:param music_type: 音乐实体类型,用于约束显式音乐身份及插件结果
|
|
"""
|
|
mediainfo = self._recognize_with_fallback_by_meta(
|
|
metainfo=metainfo,
|
|
mtype=mtype,
|
|
media_source=media_source,
|
|
episode_group=episode_group,
|
|
obtain_images=obtain_images,
|
|
music_type=music_type,
|
|
)
|
|
if not mediainfo:
|
|
logger.warn(f"{metainfo.title} 未识别到媒体信息")
|
|
return mediainfo
|
|
|
|
def _recognize_with_fallback_by_meta(
|
|
self,
|
|
metainfo: MetaBase,
|
|
mtype: Optional[MediaType] = None,
|
|
media_source: Optional[MediaSource] = None,
|
|
episode_group: Optional[str] = None,
|
|
obtain_images: bool = False,
|
|
music_type: Optional[str] = None,
|
|
) -> Optional[MediaInfo]:
|
|
"""
|
|
根据标题识别媒体信息,必要时回退到辅助识别。
|
|
|
|
:param metainfo: 标题解析元数据
|
|
:param mtype: 上游已确定的媒体类型
|
|
:param media_source: 请求级识别数据源
|
|
:param episode_group: 剧集组
|
|
:param obtain_images: 是否补充图片
|
|
:param music_type: 音乐实体类型,用于约束显式音乐身份及插件结果
|
|
:return: 统一媒体信息
|
|
"""
|
|
if not metainfo:
|
|
return None
|
|
request = MediaRecognitionOwner._meta_recognition_request(
|
|
metainfo,
|
|
mtype=mtype,
|
|
media_source=media_source,
|
|
episode_group=episode_group,
|
|
music_type=music_type,
|
|
)
|
|
|
|
def native_recognize() -> Optional[MediaInfo]:
|
|
"""使用请求级数据源执行原生识别。"""
|
|
return self.recognize_media(
|
|
meta=request.metainfo,
|
|
mtype=request.mtype,
|
|
media_source=request.media_source,
|
|
share_meta=request.share_meta,
|
|
episode_group=request.episode_group,
|
|
music_type=request.music_type,
|
|
)
|
|
|
|
def plugin_recognize() -> Optional[MediaInfo]:
|
|
"""执行辅助识别并保持请求级数据源约束。"""
|
|
if request.is_music and not isinstance(request.metainfo, MetaMusic):
|
|
return None
|
|
return self.recognize_help(
|
|
title=request.title,
|
|
org_meta=request.metainfo,
|
|
share_meta=request.share_meta,
|
|
media_source=request.media_source,
|
|
episode_group=request.episode_group,
|
|
music_type=request.music_type,
|
|
)
|
|
|
|
# 按 config 中设置的识别顺序识别,影视与音乐共用同一选择流程
|
|
mediainfo = self.select_recognize_source(
|
|
log_name=request.title,
|
|
log_context=request.title,
|
|
native_fn=native_recognize,
|
|
plugin_fn=plugin_recognize,
|
|
is_recognized=(
|
|
MediaRecognitionOwner._has_remote_identity
|
|
if request.is_music
|
|
else None
|
|
),
|
|
plugin_event=request.plugin_event,
|
|
)
|
|
mediainfo = MediaRecognitionOwner._accepted_recognition(request, mediainfo)
|
|
if mediainfo is None:
|
|
return None
|
|
if obtain_images:
|
|
self.obtain_images(mediainfo=mediainfo)
|
|
return mediainfo
|
|
|
|
async def async_recognize_by_meta(
|
|
self,
|
|
metainfo: MetaBase,
|
|
media_source: Optional[MediaSource] = None,
|
|
episode_group: Optional[str] = None,
|
|
obtain_images: bool = False,
|
|
mtype: Optional[MediaType] = None,
|
|
music_type: Optional[str] = None,
|
|
) -> Optional[MediaInfo]:
|
|
"""
|
|
根据主副标题识别媒体信息(异步版本)
|
|
|
|
:param metainfo: 标题解析元数据
|
|
:param media_source: 请求级识别数据源
|
|
:param episode_group: 剧集组
|
|
:param obtain_images: 是否补充图片
|
|
:param mtype: 上游已确定的媒体类型
|
|
:param music_type: 音乐实体类型,用于约束显式音乐身份及插件结果
|
|
:return: 统一媒体信息
|
|
"""
|
|
mediainfo = await self._async_recognize_with_fallback_by_meta(
|
|
metainfo=metainfo,
|
|
mtype=mtype,
|
|
media_source=media_source,
|
|
episode_group=episode_group,
|
|
obtain_images=obtain_images,
|
|
music_type=music_type,
|
|
)
|
|
if not mediainfo:
|
|
logger.warn(f"{metainfo.title} 未识别到媒体信息")
|
|
return mediainfo
|
|
|
|
async def _async_recognize_with_fallback_by_meta(
|
|
self,
|
|
metainfo: MetaBase,
|
|
mtype: Optional[MediaType] = None,
|
|
media_source: Optional[MediaSource] = None,
|
|
episode_group: Optional[str] = None,
|
|
obtain_images: bool = False,
|
|
music_type: Optional[str] = None,
|
|
) -> Optional[MediaInfo]:
|
|
"""
|
|
异步根据标题识别媒体信息,必要时回退到辅助识别。
|
|
|
|
:param metainfo: 标题解析元数据
|
|
:param mtype: 上游已确定的媒体类型
|
|
:param media_source: 请求级识别数据源
|
|
:param episode_group: 剧集组
|
|
:param obtain_images: 是否补充图片
|
|
:param music_type: 音乐实体类型,用于约束显式音乐身份及插件结果
|
|
:return: 统一媒体信息
|
|
"""
|
|
if not metainfo:
|
|
return None
|
|
request = MediaRecognitionOwner._meta_recognition_request(
|
|
metainfo,
|
|
mtype=mtype,
|
|
media_source=media_source,
|
|
episode_group=episode_group,
|
|
music_type=music_type,
|
|
)
|
|
|
|
async def native_recognize() -> Optional[MediaInfo]:
|
|
"""异步使用请求级数据源执行原生识别。"""
|
|
return await self.async_recognize_media(
|
|
meta=request.metainfo,
|
|
mtype=request.mtype,
|
|
media_source=request.media_source,
|
|
share_meta=request.share_meta,
|
|
episode_group=request.episode_group,
|
|
music_type=request.music_type,
|
|
)
|
|
|
|
async def plugin_recognize() -> Optional[MediaInfo]:
|
|
"""异步执行辅助识别并保持请求级数据源约束。"""
|
|
if request.is_music and not isinstance(request.metainfo, MetaMusic):
|
|
return None
|
|
return await self.async_recognize_help(
|
|
title=request.title,
|
|
org_meta=request.metainfo,
|
|
share_meta=request.share_meta,
|
|
media_source=request.media_source,
|
|
episode_group=request.episode_group,
|
|
music_type=request.music_type,
|
|
)
|
|
|
|
# 按 config 中设置的识别顺序识别,影视与音乐共用同一选择流程
|
|
mediainfo = await self.async_select_recognize_source(
|
|
log_name=request.title,
|
|
log_context=request.title,
|
|
native_fn=native_recognize,
|
|
plugin_fn=plugin_recognize,
|
|
is_recognized=(
|
|
MediaRecognitionOwner._has_remote_identity
|
|
if request.is_music
|
|
else None
|
|
),
|
|
plugin_event=request.plugin_event,
|
|
)
|
|
mediainfo = MediaRecognitionOwner._accepted_recognition(request, mediainfo)
|
|
if mediainfo is None:
|
|
return None
|
|
if obtain_images:
|
|
await self.async_obtain_images(mediainfo=mediainfo)
|
|
return mediainfo
|