move NameRecognize to ChainEventType

app/chain/media.py

@@ -1,5 +1,3 @@
-import copy
-import time
 from pathlib import Path
 from threading import Lock
 from typing import Optional, List, Tuple, Union
@@ -13,7 +11,7 @@ from app.core.event import eventmanager, Event
 from app.core.meta import MetaBase
 from app.core.metainfo import MetaInfo, MetaInfoPath
 from app.log import logger
-from app.schemas.types import EventType, MediaType
+from app.schemas.types import EventType, MediaType, ChainEventType
 from app.utils.http import RequestUtils
 from app.utils.singleton import Singleton
 from app.utils.string import StringUtils
@@ -25,10 +23,6 @@ class MediaChain(ChainBase, metaclass=Singleton):
     """
     媒体信息处理链，单例运行
     """
-    # 临时识别标题
-    recognize_title: Optional[str] = None
-    # 临时识别结果 {title, name, year, season, episode}
-    recognize_temp: Optional[dict] = None
 
     def __init__(self):
         super().__init__()
@@ -54,7 +48,7 @@ class MediaChain(ChainBase, metaclass=Singleton):
         mediainfo: MediaInfo = self.recognize_media(meta=metainfo)
         if not mediainfo:
             # 尝试使用辅助识别，如果有注册响应事件的话
-            if eventmanager.check(EventType.NameRecognize):
+            if eventmanager.check(ChainEventType.NameRecognize):
                 logger.info(f'请求辅助识别，标题：{title} ...')
                 mediainfo = self.recognize_help(title=title, org_meta=metainfo)
             if not mediainfo:
@@ -73,83 +67,47 @@ class MediaChain(ChainBase, metaclass=Singleton):
         :param title: 标题
         :param org_meta: 原始元数据
         """
-        with recognize_lock:
+        # 发送请求事件，等待结果
-            self.recognize_temp = None
+        result: Event = eventmanager.send_event(
-            self.recognize_title = title
+            ChainEventType.NameRecognize,
-
-        # 发送请求事件
-        eventmanager.send_event(
-            EventType.NameRecognize,
             {
                 'title': title,
             }
         )
-        # 每0.5秒循环一次，等待结果，直到10秒后超时
+        if not result:
-        for i in range(20):
+            return None
-            if self.recognize_temp is not None:
+        # 获取返回事件数据
-                break
+        event_data = result.event_data or {}
-            time.sleep(0.5)
+        logger.info(f'获取到辅助识别结果：{event_data}')
-        # 加锁
+        # 处理数据格式
-        with recognize_lock:
+        title, year, season_number, episode_number = None, None, None, None
-            mediainfo = None
+        if event_data.get("name"):
-            if not self.recognize_temp or self.recognize_title != title:
+            title = str(event_data["name"]).split("/")[0].strip().replace(".", " ")
-                # 没有识别结果或者识别标题已改变
+        if event_data.get("year"):
-                return None
+            year = str(event_data["year"]).split("/")[0].strip()
-            # 有识别结果
+        if event_data.get("season") and str(event_data["season"]).isdigit():
-            meta_dict = copy.deepcopy(self.recognize_temp)
+            season_number = int(event_data["season"])
-        logger.info(f'获取到辅助识别结果：{meta_dict}')
+        if event_data.get("episode") and str(event_data["episode"]).isdigit():
-        if meta_dict.get("name") == org_meta.name and meta_dict.get("year") == org_meta.year:
+            episode_number = int(event_data["episode"])
-            logger.info(f'辅助识别结果与原始识别结果一致')
+        if not title:
-        else:
+            return None
-            logger.info(f'辅助识别结果与原始识别结果不一致，重新匹配媒体信息 ...')
+        if title == 'Unknown':
-            org_meta.name = meta_dict.get("name")
+            return None
-            org_meta.year = meta_dict.get("year")
+        if not str(year).isdigit():
-            org_meta.begin_season = meta_dict.get("season")
+            year = None
-            org_meta.begin_episode = meta_dict.get("episode")
+        # 结果赋值
-            if org_meta.begin_season or org_meta.begin_episode:
+        if title == org_meta.name and year == org_meta.year:
-                org_meta.type = MediaType.TV
+            logger.info(f'辅助识别与原始识别结果一致，无需重新识别媒体信息')
-            # 重新识别
+            return None
-            mediainfo = self.recognize_media(meta=org_meta)
+        logger.info(f'辅助识别结果与原始识别结果不一致，重新匹配媒体信息 ...')
-        return mediainfo
+        org_meta.name = title
-
+        org_meta.year = year
-    @eventmanager.register(EventType.NameRecognizeResult)
+        org_meta.begin_season = season_number
-    def recognize_result(self, event: Event):
+        org_meta.begin_episode = episode_number
-        """
+        if org_meta.begin_season or org_meta.begin_episode:
-        监控识别结果事件，获取辅助识别结果，结果格式：{title, name, year, season, episode}
+            org_meta.type = MediaType.TV
-        """
+        # 重新识别
-        if not event:
+        return self.recognize_media(meta=org_meta)
-            return
-        event_data = event.event_data or {}
-        # 加锁
-        with recognize_lock:
-            # 不是原标题的结果不要
-            if event_data.get("title") != self.recognize_title:
-                return
-            # 标志收到返回
-            self.recognize_temp = {}
-            # 处理数据格式
-            file_title, file_year, season_number, episode_number = None, None, None, None
-            if event_data.get("name"):
-                file_title = str(event_data["name"]).split("/")[0].strip().replace(".", " ")
-            if event_data.get("year"):
-                file_year = str(event_data["year"]).split("/")[0].strip()
-            if event_data.get("season") and str(event_data["season"]).isdigit():
-                season_number = int(event_data["season"])
-            if event_data.get("episode") and str(event_data["episode"]).isdigit():
-                episode_number = int(event_data["episode"])
-            if not file_title:
-                return
-            if file_title == 'Unknown':
-                return
-            if not str(file_year).isdigit():
-                file_year = None
-            # 结果赋值
-            self.recognize_temp = {
-                "name": file_title,
-                "year": file_year,
-                "season": season_number,
-                "episode": episode_number
-            }
 
     def recognize_by_path(self, path: str) -> Optional[Context]:
         """
@@ -163,7 +121,7 @@ class MediaChain(ChainBase, metaclass=Singleton):
         mediainfo = self.recognize_media(meta=file_meta)
         if not mediainfo:
             # 尝试使用辅助识别，如果有注册响应事件的话
-            if eventmanager.check(EventType.NameRecognize):
+            if eventmanager.check(ChainEventType.NameRecognize):
                 logger.info(f'请求辅助识别，标题：{file_path.name} ...')
                 mediainfo = self.recognize_help(title=path, org_meta=file_meta)
             if not mediainfo:

app/schemas/types.py

@@ -44,10 +44,6 @@ class EventType(Enum):
     WebhookMessage = "webhook.message"
     # 发送消息通知
     NoticeMessage = "notice.message"
-    # 名称识别请求
-    NameRecognize = "name.recognize"
-    # 名称识别结果
-    NameRecognizeResult = "name.recognize.result"
     # 订阅已添加
     SubscribeAdded = "subscribe.added"
     # 订阅已完成
@@ -62,7 +58,8 @@ class EventType(Enum):
 
 # 同步链式事件
 class ChainEventType(Enum):
-    pass
+    # 名称识别请求
+    NameRecognize = "name.recognize"
 
 
 # 系统配置Key字典