add async api

app/api/endpoints/bangumi.py

@@ -11,63 +11,63 @@ router = APIRouter()
 
 
 @router.get("/credits/{bangumiid}", summary="查询Bangumi演职员表", response_model=List[schemas.MediaPerson])
-def bangumi_credits(bangumiid: int,
+async def bangumi_credits(bangumiid: int,
                           page: Optional[int] = 1,
                           count: Optional[int] = 20,
                           _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     查询Bangumi演职员表
     """
-    persons = BangumiChain().bangumi_credits(bangumiid)
+    persons = await BangumiChain().async_bangumi_credits(bangumiid)
     if persons:
         return persons[(page - 1) * count: page * count]
     return []
 
 
 @router.get("/recommend/{bangumiid}", summary="查询Bangumi推荐", response_model=List[schemas.MediaInfo])
-def bangumi_recommend(bangumiid: int,
+async def bangumi_recommend(bangumiid: int,
                             page: Optional[int] = 1,
                             count: Optional[int] = 20,
                             _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     查询Bangumi推荐
     """
-    medias = BangumiChain().bangumi_recommend(bangumiid)
+    medias = await BangumiChain().async_bangumi_recommend(bangumiid)
     if medias:
         return [media.to_dict() for media in medias[(page - 1) * count: page * count]]
     return []
 
 
 @router.get("/person/{person_id}", summary="人物详情", response_model=schemas.MediaPerson)
-def bangumi_person(person_id: int,
+async def bangumi_person(person_id: int,
                          _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据人物ID查询人物详情
     """
-    return BangumiChain().person_detail(person_id=person_id)
+    return await BangumiChain().async_person_detail(person_id=person_id)
 
 
 @router.get("/person/credits/{person_id}", summary="人物参演作品", response_model=List[schemas.MediaInfo])
-def bangumi_person_credits(person_id: int,
+async def bangumi_person_credits(person_id: int,
                                  page: Optional[int] = 1,
                                  count: Optional[int] = 20,
                                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据人物ID查询人物参演作品
     """
-    medias = BangumiChain().person_credits(person_id=person_id)
+    medias = await BangumiChain().async_person_credits(person_id=person_id)
     if medias:
         return [media.to_dict() for media in medias[(page - 1) * count: page * count]]
     return []
 
 
 @router.get("/{bangumiid}", summary="查询Bangumi详情", response_model=schemas.MediaInfo)
-def bangumi_info(bangumiid: int,
+async def bangumi_info(bangumiid: int,
                        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     查询Bangumi详情
     """
-    info = BangumiChain().bangumi_info(bangumiid)
+    info = await BangumiChain().async_bangumi_info(bangumiid)
     if info:
         return MediaInfo(bangumi_info=info).to_dict()
     else:

app/api/endpoints/douban.py

@@ -12,29 +12,29 @@ router = APIRouter()
 
 
 @router.get("/person/{person_id}", summary="人物详情", response_model=schemas.MediaPerson)
-def douban_person(person_id: int,
+async def douban_person(person_id: int,
                         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据人物ID查询人物详情
     """
-    return DoubanChain().person_detail(person_id=person_id)
+    return await DoubanChain().async_person_detail(person_id=person_id)
 
 
 @router.get("/person/credits/{person_id}", summary="人物参演作品", response_model=List[schemas.MediaInfo])
-def douban_person_credits(person_id: int,
+async def douban_person_credits(person_id: int,
                                 page: Optional[int] = 1,
                                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据人物ID查询人物参演作品
     """
-    medias = DoubanChain().person_credits(person_id=person_id, page=page)
+    medias = await DoubanChain().async_person_credits(person_id=person_id, page=page)
     if medias:
         return [media.to_dict() for media in medias]
     return []
 
 
 @router.get("/credits/{doubanid}/{type_name}", summary="豆瓣演员阵容", response_model=List[schemas.MediaPerson])
-def douban_credits(doubanid: str,
+async def douban_credits(doubanid: str,
                          type_name: str,
                          _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
@@ -42,14 +42,14 @@ def douban_credits(doubanid: str,
     """
     mediatype = MediaType(type_name)
     if mediatype == MediaType.MOVIE:
-        return DoubanChain().movie_credits(doubanid=doubanid)
+        return await DoubanChain().async_movie_credits(doubanid=doubanid)
     elif mediatype == MediaType.TV:
-        return DoubanChain().tv_credits(doubanid=doubanid)
+        return await DoubanChain().async_tv_credits(doubanid=doubanid)
     return []
 
 
 @router.get("/recommend/{doubanid}/{type_name}", summary="豆瓣推荐电影/电视剧", response_model=List[schemas.MediaInfo])
-def douban_recommend(doubanid: str,
+async def douban_recommend(doubanid: str,
                            type_name: str,
                            _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
@@ -57,9 +57,9 @@ def douban_recommend(doubanid: str,
     """
     mediatype = MediaType(type_name)
     if mediatype == MediaType.MOVIE:
-        medias = DoubanChain().movie_recommend(doubanid=doubanid)
+        medias = await DoubanChain().async_movie_recommend(doubanid=doubanid)
     elif mediatype == MediaType.TV:
-        medias = DoubanChain().tv_recommend(doubanid=doubanid)
+        medias = await DoubanChain().async_tv_recommend(doubanid=doubanid)
     else:
         return []
     if medias:
@@ -68,12 +68,12 @@ def douban_recommend(doubanid: str,
 
 
 @router.get("/{doubanid}", summary="查询豆瓣详情", response_model=schemas.MediaInfo)
-def douban_info(doubanid: str,
+async def douban_info(doubanid: str,
                       _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据豆瓣ID查询豆瓣媒体信息
     """
-    doubaninfo = DoubanChain().douban_info(doubanid=doubanid)
+    doubaninfo = await DoubanChain().async_douban_info(doubanid=doubanid)
     if doubaninfo:
         return MediaInfo(douban_info=doubaninfo).to_dict()
     else:

app/chain/__init__.py

@@ -394,6 +394,18 @@ class ChainBase(metaclass=ABCMeta):
         """
         return self.run_module("douban_info", doubanid=doubanid, mtype=mtype, raise_exception=raise_exception)
 
+    async def async_douban_info(self, doubanid: str, mtype: Optional[MediaType] = None,
+                                raise_exception: bool = False) -> Optional[dict]:
+        """
+        获取豆瓣信息（异步版本）
+        :param doubanid: 豆瓣ID
+        :param mtype: 媒体类型
+        :return: 豆瓣信息
+        :param raise_exception: 触发速率限制时是否抛出异常
+        """
+        return await self.run_module("async_douban_info", doubanid=doubanid, mtype=mtype,
+                                     raise_exception=raise_exception)
+
     def tvdb_info(self, tvdbid: int) -> Optional[dict]:
         """
         获取TVDB信息

app/chain/bangumi.py

@@ -57,3 +57,51 @@ class BangumiChain(ChainBase):
         :param person_id:  人物ID
         """
         return self.run_module("bangumi_person_credits", person_id=person_id)
+
+    async def async_calendar(self) -> Optional[List[MediaInfo]]:
+        """
+        获取Bangumi每日放送（异步版本）
+        """
+        return await self.run_module("async_bangumi_calendar")
+
+    async def async_discover(self, **kwargs) -> Optional[List[MediaInfo]]:
+        """
+        发现Bangumi番剧（异步版本）
+        """
+        return await self.run_module("async_bangumi_discover", **kwargs)
+
+    async def async_bangumi_info(self, bangumiid: int) -> Optional[dict]:
+        """
+        获取Bangumi信息（异步版本）
+        :param bangumiid: BangumiID
+        :return: Bangumi信息
+        """
+        return await self.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)
+
+    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)
+
+    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)
+
+    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)

app/chain/douban.py

@@ -111,3 +111,111 @@ class DoubanChain(ChainBase):
         :param doubanid:  豆瓣ID
         """
         return self.run_module("douban_tv_recommend", doubanid=doubanid)
+
+    async def async_person_detail(self, person_id: int) -> Optional[schemas.MediaPerson]:
+        """
+        根据人物ID查询豆瓣人物详情（异步版本）
+        :param person_id:  人物ID
+        """
+        return await self.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]:
+        """
+        根据人物ID查询人物参演作品（异步版本）
+        :param person_id:  人物ID
+        :param page:  页码
+        """
+        return await self.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]]:
+        """
+        获取豆瓣电影TOP250（异步版本）
+        :param page:  页码
+        :param count:  每页数量
+        """
+        return await self.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)
+
+    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)
+
+    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)
+
+    async def async_douban_discover(self, mtype: MediaType, sort: str, tags: str,
+                                    page: Optional[int] = 0, count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
+        """
+        发现豆瓣电影、剧集（异步版本）
+        :param mtype:  媒体类型
+        :param sort:  排序方式
+        :param tags:  标签
+        :param page:  页码
+        :param count:  数量
+        :return: 媒体信息列表
+        """
+        return await self.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)
+
+    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)
+
+    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)
+
+    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)
+
+    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)
+
+    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)
+
+    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)