feat：媒体查询协程处理

app/chain/__init__.py

@@ -332,6 +332,39 @@ class ChainBase(metaclass=ABCMeta):
                                tmdbid=tmdbid, doubanid=doubanid, bangumiid=bangumiid,
                                episode_group=episode_group, cache=cache)
 
+    async def async_recognize_media(self, meta: MetaBase = None,
+                                    mtype: Optional[MediaType] = None,
+                                    tmdbid: Optional[int] = None,
+                                    doubanid: Optional[str] = None,
+                                    bangumiid: Optional[int] = None,
+                                    episode_group: Optional[str] = None,
+                                    cache: bool = True) -> Optional[MediaInfo]:
+        """
+        识别媒体信息，不含Fanart图片（异步版本）
+        :param meta:     识别的元数据
+        :param mtype:    识别的媒体类型，与tmdbid配套
+        :param tmdbid:   tmdbid
+        :param doubanid: 豆瓣ID
+        :param bangumiid: BangumiID
+        :param episode_group: 剧集组
+        :param cache:    是否使用缓存
+        :return: 识别的媒体信息，包括剧集信息
+        """
+        # 识别用名中含指定信息情形
+        if not mtype and meta and meta.type in [MediaType.TV, MediaType.MOVIE]:
+            mtype = meta.type
+        if not tmdbid and hasattr(meta, "tmdbid"):
+            tmdbid = meta.tmdbid
+        if not doubanid and hasattr(meta, "doubanid"):
+            doubanid = meta.doubanid
+        # 有tmdbid时不使用其它ID
+        if tmdbid:
+            doubanid = None
+            bangumiid = None
+        return await self.async_run_module("async_recognize_media", meta=meta, mtype=mtype,
+                                           tmdbid=tmdbid, doubanid=doubanid, bangumiid=bangumiid,
+                                           episode_group=episode_group, cache=cache)
+
     def match_doubaninfo(self, name: str, imdbid: Optional[str] = None,
                          mtype: Optional[MediaType] = None, year: Optional[str] = None, season: Optional[int] = None,
                          raise_exception: bool = False) -> Optional[dict]:
@@ -347,6 +380,22 @@ class ChainBase(metaclass=ABCMeta):
         return self.run_module("match_doubaninfo", name=name, imdbid=imdbid,
                                mtype=mtype, year=year, season=season, raise_exception=raise_exception)
 
+    async def async_match_doubaninfo(self, name: str, imdbid: Optional[str] = None,
+                                     mtype: Optional[MediaType] = None, year: Optional[str] = None,
+                                     season: Optional[int] = None,
+                                     raise_exception: bool = False) -> Optional[dict]:
+        """
+        搜索和匹配豆瓣信息（异步版本）
+        :param name: 标题
+        :param imdbid: imdbid
+        :param mtype: 类型
+        :param year: 年份
+        :param season: 季
+        :param raise_exception: 触发速率限制时是否抛出异常
+        """
+        return await self.async_run_module("async_match_doubaninfo", name=name, imdbid=imdbid,
+                                           mtype=mtype, year=year, season=season, raise_exception=raise_exception)
+
     def match_tmdbinfo(self, name: str, mtype: Optional[MediaType] = None,
                        year: Optional[str] = None, season: Optional[int] = None) -> Optional[dict]:
         """
@@ -359,6 +408,18 @@ class ChainBase(metaclass=ABCMeta):
         return self.run_module("match_tmdbinfo", name=name,
                                mtype=mtype, year=year, season=season)
 
+    async def async_match_tmdbinfo(self, name: str, mtype: Optional[MediaType] = None,
+                                   year: Optional[str] = None, season: Optional[int] = None) -> Optional[dict]:
+        """
+        搜索和匹配TMDB信息（异步版本）
+        :param name: 标题
+        :param mtype: 类型
+        :param year: 年份
+        :param season: 季
+        """
+        return await self.async_run_module("async_match_tmdbinfo", name=name,
+                                           mtype=mtype, year=year, season=season)
+
     def obtain_images(self, mediainfo: MediaInfo) -> Optional[MediaInfo]:
         """
         补充抓取媒体信息图片
@@ -367,6 +428,14 @@ class ChainBase(metaclass=ABCMeta):
         """
         return self.run_module("obtain_images", mediainfo=mediainfo)
 
+    async def async_obtain_images(self, mediainfo: MediaInfo) -> Optional[MediaInfo]:
+        """
+        补充抓取媒体信息图片（异步版本）
+        :param mediainfo:  识别的媒体信息
+        :return: 更新后的媒体信息
+        """
+        return await self.async_run_module("async_obtain_images", mediainfo=mediainfo)
+
     def obtain_specific_image(self, mediaid: Union[str, int], mtype: MediaType,
                               image_type: MediaImageType, image_prefix: Optional[str] = None,
                               season: Optional[int] = None, episode: Optional[int] = None) -> Optional[str]:
@@ -403,7 +472,7 @@ class ChainBase(metaclass=ABCMeta):
         :return: 豆瓣信息
         :param raise_exception: 触发速率限制时是否抛出异常
         """
-        return await self.run_module("async_douban_info", doubanid=doubanid, mtype=mtype,
+        return await self.async_run_module("async_douban_info", doubanid=doubanid, mtype=mtype,
                                      raise_exception=raise_exception)
 
     def tvdb_info(self, tvdbid: int) -> Optional[dict]:
@@ -424,6 +493,16 @@ class ChainBase(metaclass=ABCMeta):
         """
         return self.run_module("tmdb_info", tmdbid=tmdbid, mtype=mtype, season=season)
 
+    async def async_tmdb_info(self, tmdbid: int, mtype: MediaType, season: Optional[int] = None) -> Optional[dict]:
+        """
+        获取TMDB信息（异步版本）
+        :param tmdbid: int
+        :param mtype:  媒体类型
+        :param season: 季
+        :return: TVDB信息
+        """
+        return await self.async_run_module("async_tmdb_info", tmdbid=tmdbid, mtype=mtype, season=season)
+
     def bangumi_info(self, bangumiid: int) -> Optional[dict]:
         """
         获取Bangumi信息
@@ -432,6 +511,14 @@ class ChainBase(metaclass=ABCMeta):
         """
         return self.run_module("bangumi_info", bangumiid=bangumiid)
 
+    async def async_bangumi_info(self, bangumiid: int) -> Optional[dict]:
+        """
+        获取Bangumi信息（异步版本）
+        :param bangumiid: int
+        :return: Bangumi信息
+        """
+        return await self.async_run_module("async_bangumi_info", bangumiid=bangumiid)
+
     def message_parser(self, source: str, body: Any, form: Any,
                        args: Any) -> Optional[CommingMessage]:
         """
@@ -465,6 +552,14 @@ class ChainBase(metaclass=ABCMeta):
         """
         return self.run_module("search_medias", meta=meta)
 
+    async def async_search_medias(self, meta: MetaBase) -> Optional[List[MediaInfo]]:
+        """
+        搜索媒体信息（异步版本）
+        :param meta:  识别的元数据
+        :reutrn: 媒体信息列表
+        """
+        return await self.async_run_module("async_search_medias", meta=meta)
+
     def search_persons(self, name: str) -> Optional[List[MediaPerson]]:
         """
         搜索人物信息
@@ -472,6 +567,13 @@ class ChainBase(metaclass=ABCMeta):
         """
         return self.run_module("search_persons", name=name)
 
+    async def async_search_persons(self, name: str) -> Optional[List[MediaPerson]]:
+        """
+        搜索人物信息（异步版本）
+        :param name:  人物名称
+        """
+        return await self.async_run_module("async_search_persons", name=name)
+
     def search_collections(self, name: str) -> Optional[List[MediaInfo]]:
         """
         搜索集合信息
@@ -479,6 +581,13 @@ class ChainBase(metaclass=ABCMeta):
         """
         return self.run_module("search_collections", name=name)
 
+    async def async_search_collections(self, name: str) -> Optional[List[MediaInfo]]:
+        """
+        搜索集合信息（异步版本）
+        :param name:  集合名称
+        """
+        return await self.async_run_module("async_search_collections", name=name)
+
     def search_torrents(self, site: dict,
                         keywords: List[str],
                         mtype: Optional[MediaType] = None,

app/chain/bangumi.py

@@ -62,13 +62,13 @@ class BangumiChain(ChainBase):
         """
         获取Bangumi每日放送（异步版本）
         """
-        return await self.run_module("async_bangumi_calendar")
+        return await self.async_run_module("async_bangumi_calendar")
 
     async def async_discover(self, **kwargs) -> Optional[List[MediaInfo]]:
         """
         发现Bangumi番剧（异步版本）
         """
-        return await self.run_module("async_bangumi_discover", **kwargs)
+        return await self.async_run_module("async_bangumi_discover", **kwargs)
 
     async def async_bangumi_info(self, bangumiid: int) -> Optional[dict]:
         """
@@ -76,32 +76,32 @@ class BangumiChain(ChainBase):
         :param bangumiid: BangumiID
         :return: Bangumi信息
         """
-        return await self.run_module("async_bangumi_info", bangumiid=bangumiid)
+        return await self.async_run_module("async_bangumi_info", bangumiid=bangumiid)
 
     async def async_bangumi_credits(self, bangumiid: int) -> List[schemas.MediaPerson]:
         """
         根据BangumiID查询电影演职员表（异步版本）
         :param bangumiid:  BangumiID
         """
-        return await self.run_module("async_bangumi_credits", bangumiid=bangumiid)
+        return await self.async_run_module("async_bangumi_credits", bangumiid=bangumiid)
 
     async def async_bangumi_recommend(self, bangumiid: int) -> Optional[List[MediaInfo]]:
         """
         根据BangumiID查询推荐电影（异步版本）
         :param bangumiid:  BangumiID
         """
-        return await self.run_module("async_bangumi_recommend", bangumiid=bangumiid)
+        return await self.async_run_module("async_bangumi_recommend", bangumiid=bangumiid)
 
     async def async_person_detail(self, person_id: int) -> Optional[schemas.MediaPerson]:
         """
         根据人物ID查询Bangumi人物详情（异步版本）
         :param person_id:  人物ID
         """
-        return await self.run_module("async_bangumi_person_detail", person_id=person_id)
+        return await self.async_run_module("async_bangumi_person_detail", person_id=person_id)
 
     async def async_person_credits(self, person_id: int) -> Optional[List[MediaInfo]]:
         """
         根据人物ID查询人物参演作品（异步版本）
         :param person_id:  人物ID
         """
-        return await self.run_module("async_bangumi_person_credits", person_id=person_id)
+        return await self.async_run_module("async_bangumi_person_credits", person_id=person_id)

app/chain/douban.py

@@ -117,7 +117,7 @@ class DoubanChain(ChainBase):
         根据人物ID查询豆瓣人物详情（异步版本）
         :param person_id:  人物ID
         """
-        return await self.run_module("async_douban_person_detail", person_id=person_id)
+        return await self.async_run_module("async_douban_person_detail", person_id=person_id)
 
     async def async_person_credits(self, person_id: int, page: Optional[int] = 1) -> List[MediaInfo]:
         """
@@ -125,7 +125,7 @@ class DoubanChain(ChainBase):
         :param person_id:  人物ID
         :param page:  页码
         """
-        return await self.run_module("async_douban_person_credits", person_id=person_id, page=page)
+        return await self.async_run_module("async_douban_person_credits", person_id=person_id, page=page)
 
     async def async_movie_top250(self, page: Optional[int] = 1,
                                  count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
@@ -134,28 +134,28 @@ class DoubanChain(ChainBase):
         :param page:  页码
         :param count:  每页数量
         """
-        return await self.run_module("async_movie_top250", page=page, count=count)
+        return await self.async_run_module("async_movie_top250", page=page, count=count)
 
     async def async_movie_showing(self, page: Optional[int] = 1,
                                   count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
         """
         获取正在上映的电影（异步版本）
         """
-        return await self.run_module("async_movie_showing", page=page, count=count)
+        return await self.async_run_module("async_movie_showing", page=page, count=count)
 
     async def async_tv_weekly_chinese(self, page: Optional[int] = 1,
                                       count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
         """
         获取本周中国剧集榜（异步版本）
         """
-        return await self.run_module("async_tv_weekly_chinese", page=page, count=count)
+        return await self.async_run_module("async_tv_weekly_chinese", page=page, count=count)
 
     async def async_tv_weekly_global(self, page: Optional[int] = 1,
                                      count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
         """
         获取本周全球剧集榜（异步版本）
         """
-        return await self.run_module("async_tv_weekly_global", page=page, count=count)
+        return await self.async_run_module("async_tv_weekly_global", page=page, count=count)
 
     async def async_douban_discover(self, mtype: MediaType, sort: str, tags: str,
                                     page: Optional[int] = 0, count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
@@ -168,54 +168,54 @@ class DoubanChain(ChainBase):
         :param count:  数量
         :return: 媒体信息列表
         """
-        return await self.run_module("async_douban_discover", mtype=mtype, sort=sort, tags=tags,
-                                     page=page, count=count)
+        return await self.async_run_module("async_douban_discover", mtype=mtype, sort=sort, tags=tags,
+                                           page=page, count=count)
 
     async def async_tv_animation(self, page: Optional[int] = 1,
                                  count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
         """
         获取动画剧集（异步版本）
         """
-        return await self.run_module("async_tv_animation", page=page, count=count)
+        return await self.async_run_module("async_tv_animation", page=page, count=count)
 
     async def async_movie_hot(self, page: Optional[int] = 1,
                               count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
         """
         获取热门电影（异步版本）
         """
-        return await self.run_module("async_movie_hot", page=page, count=count)
+        return await self.async_run_module("async_movie_hot", page=page, count=count)
 
     async def async_tv_hot(self, page: Optional[int] = 1,
                            count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
         """
         获取热门剧集（异步版本）
         """
-        return await self.run_module("async_tv_hot", page=page, count=count)
+        return await self.async_run_module("async_tv_hot", page=page, count=count)
 
     async def async_movie_credits(self, doubanid: str) -> Optional[List[schemas.MediaPerson]]:
         """
         根据TMDBID查询电影演职人员（异步版本）
         :param doubanid:  豆瓣ID
         """
-        return await self.run_module("async_douban_movie_credits", doubanid=doubanid)
+        return await self.async_run_module("async_douban_movie_credits", doubanid=doubanid)
 
     async def async_tv_credits(self, doubanid: str) -> Optional[List[schemas.MediaPerson]]:
         """
         根据TMDBID查询电视剧演职人员（异步版本）
         :param doubanid:  豆瓣ID
         """
-        return await self.run_module("async_douban_tv_credits", doubanid=doubanid)
+        return await self.async_run_module("async_douban_tv_credits", doubanid=doubanid)
 
     async def async_movie_recommend(self, doubanid: str) -> List[MediaInfo]:
         """
         根据豆瓣ID查询推荐电影（异步版本）
         :param doubanid:  豆瓣ID
         """
-        return await self.run_module("async_douban_movie_recommend", doubanid=doubanid)
+        return await self.async_run_module("async_douban_movie_recommend", doubanid=doubanid)
 
     async def async_tv_recommend(self, doubanid: str) -> List[MediaInfo]:
         """
         根据豆瓣ID查询推荐电视剧（异步版本）
         :param doubanid:  豆瓣ID
         """
-        return await self.run_module("async_douban_tv_recommend", doubanid=doubanid)
+        return await self.async_run_module("async_douban_tv_recommend", doubanid=doubanid)

app/chain/media.py

@@ -763,3 +763,129 @@ class MediaChain(ChainBase):
                                 else:
                                     logger.info(f"电视剧图片刮削已关闭，跳过：{image_name}")
         logger.info(f"{filepath.name} 刮削完成")
+
+    async def async_recognize_by_meta(self, metainfo: MetaBase,
+                                      episode_group: Optional[str] = None) -> Optional[MediaInfo]:
+        """
+        根据主副标题识别媒体信息（异步版本）
+        """
+        title = metainfo.title
+        # 识别媒体信息
+        mediainfo: MediaInfo = await self.async_recognize_media(meta=metainfo, episode_group=episode_group)
+        if not mediainfo:
+            # 尝试使用辅助识别，如果有注册响应事件的话
+            if eventmanager.check(ChainEventType.NameRecognize):
+                logger.info(f'请求辅助识别，标题：{title} ...')
+                mediainfo = await self.async_recognize_help(title=title, org_meta=metainfo)
+            if not mediainfo:
+                logger.warn(f'{title} 未识别到媒体信息')
+                return None
+        # 识别成功
+        logger.info(f'{title} 识别到媒体信息：{mediainfo.type.value} {mediainfo.title_year}')
+        # 更新媒体图片
+        await self.async_obtain_images(mediainfo=mediainfo)
+        # 返回上下文
+        return mediainfo
+
+    async def async_recognize_help(self, title: str, org_meta: MetaBase) -> Optional[MediaInfo]:
+        """
+        请求辅助识别，返回媒体信息（异步版本）
+        :param title: 标题
+        :param org_meta: 原始元数据
+        """
+        # 发送请求事件，等待结果
+        result: Event = eventmanager.send_event(
+            ChainEventType.NameRecognize,
+            {
+                'title': title,
+            }
+        )
+        if not result:
+            return None
+        # 获取返回事件数据
+        event_data = result.event_data or {}
+        logger.info(f'获取到辅助识别结果：{event_data}')
+        # 处理数据格式
+        title, year, season_number, episode_number = None, None, None, None
+        if event_data.get("name"):
+            title = str(event_data["name"]).split("/")[0].strip().replace(".", " ")
+        if event_data.get("year"):
+            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 title:
+            return None
+        if title == 'Unknown':
+            return None
+        if not str(year).isdigit():
+            year = None
+        # 结果赋值
+        if title == org_meta.name and year == org_meta.year:
+            logger.info(f'辅助识别与原始识别结果一致，无需重新识别媒体信息')
+            return None
+        logger.info(f'辅助识别结果与原始识别结果不一致，重新匹配媒体信息 ...')
+        org_meta.name = title
+        org_meta.year = year
+        org_meta.begin_season = season_number
+        org_meta.begin_episode = episode_number
+        if org_meta.begin_season or org_meta.begin_episode:
+            org_meta.type = MediaType.TV
+        # 重新识别
+        return await self.async_recognize_media(meta=org_meta)
+
+    async def async_recognize_by_path(self, path: str, episode_group: Optional[str] = None) -> Optional[Context]:
+        """
+        根据文件路径识别媒体信息（异步版本）
+        """
+        logger.info(f'开始识别媒体信息，文件：{path} ...')
+        file_path = Path(path)
+        # 元数据
+        file_meta = MetaInfoPath(file_path)
+        # 识别媒体信息
+        mediainfo = await self.async_recognize_media(meta=file_meta, episode_group=episode_group)
+        if not mediainfo:
+            # 尝试使用辅助识别，如果有注册响应事件的话
+            if eventmanager.check(ChainEventType.NameRecognize):
+                logger.info(f'请求辅助识别，标题：{file_path.name} ...')
+                mediainfo = await self.async_recognize_help(title=path, org_meta=file_meta)
+            if not mediainfo:
+                logger.warn(f'{path} 未识别到媒体信息')
+                return Context(meta_info=file_meta)
+        logger.info(f'{path} 识别到媒体信息：{mediainfo.type.value} {mediainfo.title_year}')
+        # 更新媒体图片
+        await self.async_obtain_images(mediainfo=mediainfo)
+        # 返回上下文
+        return Context(meta_info=file_meta, media_info=mediainfo)
+
+    async def async_search(self, title: str) -> Tuple[Optional[MetaBase], List[MediaInfo]]:
+        """
+        搜索媒体/人物信息（异步版本）
+        :param title: 搜索内容
+        :return: 识别元数据，媒体信息列表
+        """
+        # 提取要素
+        mtype, key_word, season_num, episode_num, year, content = StringUtils.get_keyword(title)
+        # 识别
+        meta = MetaInfo(content)
+        if not meta.name:
+            meta.cn_name = content
+        # 合并信息
+        if mtype:
+            meta.type = mtype
+        if season_num:
+            meta.begin_season = season_num
+        if episode_num:
+            meta.begin_episode = episode_num
+        if year:
+            meta.year = year
+        # 开始搜索
+        logger.info(f"开始搜索媒体信息：{meta.name}")
+        medias: Optional[List[MediaInfo]] = await self.async_search_medias(meta=meta)
+        if not medias:
+            logger.warn(f"{meta.name} 没有找到对应的媒体信息！")
+            return meta, []
+        logger.info(f"{content} 搜索到 {len(medias)} 条相关媒体信息")
+        # 识别的元数据，媒体信息列表
+        return meta, medias

app/chain/tmdb.py

@@ -189,16 +189,16 @@ class TmdbChain(ChainBase):
         :param page:  页码
         :return: 媒体信息列表
         """
-        return await self.run_module("async_tmdb_discover", mtype=mtype,
-                                     sort_by=sort_by,
-                                     with_genres=with_genres,
-                                     with_original_language=with_original_language,
-                                     with_keywords=with_keywords,
-                                     with_watch_providers=with_watch_providers,
-                                     vote_average=vote_average,
-                                     vote_count=vote_count,
-                                     release_date=release_date,
-                                     page=page)
+        return await self.async_run_module("async_tmdb_discover", mtype=mtype,
+                                           sort_by=sort_by,
+                                           with_genres=with_genres,
+                                           with_original_language=with_original_language,
+                                           with_keywords=with_keywords,
+                                           with_watch_providers=with_watch_providers,
+                                           vote_average=vote_average,
+                                           vote_count=vote_count,
+                                           release_date=release_date,
+                                           page=page)
 
     async def async_tmdb_trending(self, page: Optional[int] = 1) -> Optional[List[MediaInfo]]:
         """
@@ -206,28 +206,28 @@ class TmdbChain(ChainBase):
         :param page: 第几页
         :return: TMDB信息列表
         """
-        return await self.run_module("async_tmdb_trending", page=page)
+        return await self.async_run_module("async_tmdb_trending", page=page)
 
     async def async_tmdb_collection(self, collection_id: int) -> Optional[List[MediaInfo]]:
         """
         根据合集ID查询集合（异步版本）
         :param collection_id:  合集ID
         """
-        return await self.run_module("async_tmdb_collection", collection_id=collection_id)
+        return await self.async_run_module("async_tmdb_collection", collection_id=collection_id)
 
     async def async_tmdb_seasons(self, tmdbid: int) -> List[schemas.TmdbSeason]:
         """
         根据TMDBID查询themoviedb所有季信息（异步版本）
         :param tmdbid:  TMDBID
         """
-        return await self.run_module("async_tmdb_seasons", tmdbid=tmdbid)
+        return await self.async_run_module("async_tmdb_seasons", tmdbid=tmdbid)
 
     async def async_tmdb_group_seasons(self, group_id: str) -> List[schemas.TmdbSeason]:
         """
         根据剧集组ID查询themoviedb所有季集信息（异步版本）
         :param group_id: 剧集组ID
         """
-        return await self.run_module("async_tmdb_group_seasons", group_id=group_id)
+        return await self.async_run_module("async_tmdb_group_seasons", group_id=group_id)
 
     async def async_tmdb_episodes(self, tmdbid: int, season: int,
                                   episode_group: Optional[str] = None) -> List[schemas.TmdbEpisode]:
@@ -237,35 +237,36 @@ class TmdbChain(ChainBase):
         :param season:  季
         :param episode_group:  剧集组
         """
-        return await self.run_module("async_tmdb_episodes", tmdbid=tmdbid, season=season, episode_group=episode_group)
+        return await self.async_run_module("async_tmdb_episodes", tmdbid=tmdbid, season=season,
+                                           episode_group=episode_group)
 
     async def async_movie_similar(self, tmdbid: int) -> Optional[List[MediaInfo]]:
         """
         根据TMDBID查询类似电影（异步版本）
         :param tmdbid:  TMDBID
         """
-        return await self.run_module("async_tmdb_movie_similar", tmdbid=tmdbid)
+        return await self.async_run_module("async_tmdb_movie_similar", tmdbid=tmdbid)
 
     async def async_tv_similar(self, tmdbid: int) -> Optional[List[MediaInfo]]:
         """
         根据TMDBID查询类似电视剧（异步版本）
         :param tmdbid:  TMDBID
         """
-        return await self.run_module("async_tmdb_tv_similar", tmdbid=tmdbid)
+        return await self.async_run_module("async_tmdb_tv_similar", tmdbid=tmdbid)
 
     async def async_movie_recommend(self, tmdbid: int) -> Optional[List[MediaInfo]]:
         """
         根据TMDBID查询推荐电影（异步版本）
         :param tmdbid:  TMDBID
         """
-        return await self.run_module("async_tmdb_movie_recommend", tmdbid=tmdbid)
+        return await self.async_run_module("async_tmdb_movie_recommend", tmdbid=tmdbid)
 
     async def async_tv_recommend(self, tmdbid: int) -> Optional[List[MediaInfo]]:
         """
         根据TMDBID查询推荐电视剧（异步版本）
         :param tmdbid:  TMDBID
         """
-        return await self.run_module("async_tmdb_tv_recommend", tmdbid=tmdbid)
+        return await self.async_run_module("async_tmdb_tv_recommend", tmdbid=tmdbid)
 
     async def async_movie_credits(self, tmdbid: int, page: Optional[int] = 1) -> Optional[List[schemas.MediaPerson]]:
         """
@@ -273,7 +274,7 @@ class TmdbChain(ChainBase):
         :param tmdbid:  TMDBID
         :param page:  页码
         """
-        return await self.run_module("async_tmdb_movie_credits", tmdbid=tmdbid, page=page)
+        return await self.async_run_module("async_tmdb_movie_credits", tmdbid=tmdbid, page=page)
 
     async def async_tv_credits(self, tmdbid: int, page: Optional[int] = 1) -> Optional[List[schemas.MediaPerson]]:
         """
@@ -281,14 +282,14 @@ class TmdbChain(ChainBase):
         :param tmdbid:  TMDBID
         :param page:  页码
         """
-        return await self.run_module("async_tmdb_tv_credits", tmdbid=tmdbid, page=page)
+        return await self.async_run_module("async_tmdb_tv_credits", tmdbid=tmdbid, page=page)
 
     async def async_person_detail(self, person_id: int) -> Optional[schemas.MediaPerson]:
         """
         根据TMDBID查询演职员详情（异步版本）
         :param person_id:  人物ID
         """
-        return await self.run_module("async_tmdb_person_detail", person_id=person_id)
+        return await self.async_run_module("async_tmdb_person_detail", person_id=person_id)
 
     async def async_person_credits(self, person_id: int, page: Optional[int] = 1) -> Optional[List[MediaInfo]]:
         """
@@ -296,7 +297,7 @@ class TmdbChain(ChainBase):
         :param person_id:  人物ID
         :param page:  页码
         """
-        return await self.run_module("async_tmdb_person_credits", person_id=person_id, page=page)
+        return await self.async_run_module("async_tmdb_person_credits", person_id=person_id, page=page)
 
     async def async_get_random_wallpager(self) -> Optional[str]:
         """