chore: remove unused imports and fix function name conflicts (#5764)

- Remove unused imports in anthropic.py, tmdbv3api/__init__.py, tv.py, test files
- Rename conflicting function names in subscribe.py and webhook.py
- Clean up unused re-exports in tmdbv3api/__init__.py (15 unused exports)
- Apply consistent formatting across API endpoints

app/api/endpoints/subscribe.py

@@ -25,26 +25,36 @@ from app.schemas.types import MediaType, EventType, SystemConfigKey
 router = APIRouter()
 
 
-def start_subscribe_add(title: str, year: str,
-                        mtype: MediaType, tmdbid: int, season: int, username: str):
+def start_subscribe_add(
+    title: str, year: str, mtype: MediaType, tmdbid: int, season: int, username: str
+):
     """
     启动订阅任务
     """
-    SubscribeChain().add(title=title, year=year,
-                         mtype=mtype, tmdbid=tmdbid, season=season, username=username)
+    SubscribeChain().add(
+        title=title,
+        year=year,
+        mtype=mtype,
+        tmdbid=tmdbid,
+        season=season,
+        username=username,
+    )
 
 
 @router.get("/", summary="查询所有订阅", response_model=List[schemas.Subscribe])
 async def read_subscribes(
-        db: AsyncSession = Depends(get_async_db),
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    db: AsyncSession = Depends(get_async_db),
+    _: schemas.TokenPayload = Depends(verify_token),
+) -> Any:
     """
     查询所有订阅
     """
     return await Subscribe.async_list(db)
 
 
-@router.get("/list", summary="查询所有订阅（API_TOKEN）", response_model=List[schemas.Subscribe])
+@router.get(
+    "/list", summary="查询所有订阅（API_TOKEN）", response_model=List[schemas.Subscribe]
+)
 async def list_subscribes(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
     """
     查询所有订阅 API_TOKEN认证（?token=xxx）
@@ -54,9 +64,9 @@ async def list_subscribes(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
 
 @router.post("/", summary="新增订阅", response_model=schemas.Response)
 async def create_subscribe(
-        *,
-        subscribe_in: schemas.Subscribe,
-        current_user: User = Depends(get_current_active_user_async),
+    *,
+    subscribe_in: schemas.Subscribe,
+    current_user: User = Depends(get_current_active_user_async),
 ) -> schemas.Response:
     """
     新增订阅
@@ -82,21 +92,18 @@ async def create_subscribe(
     subscribe_dict = subscribe_in.model_dump()
     if subscribe_in.id:
         subscribe_dict.pop("id", None)
-    sid, message = await SubscribeChain().async_add(mtype=mtype,
-                                                    title=title,
-                                                    exist_ok=True,
-                                                    **subscribe_dict)
-    return schemas.Response(
-        success=bool(sid), message=message, data={"id": sid}
+    sid, message = await SubscribeChain().async_add(
+        mtype=mtype, title=title, exist_ok=True, **subscribe_dict
     )
+    return schemas.Response(success=bool(sid), message=message, data={"id": sid})
 
 
 @router.put("/", summary="更新订阅", response_model=schemas.Response)
 async def update_subscribe(
-        *,
-        subscribe_in: schemas.Subscribe,
-        db: AsyncSession = Depends(get_async_db),
-        _: schemas.TokenPayload = Depends(verify_token)
+    *,
+    subscribe_in: schemas.Subscribe,
+    db: AsyncSession = Depends(get_async_db),
+    _: schemas.TokenPayload = Depends(verify_token),
 ) -> Any:
     """
     更新订阅信息
@@ -115,9 +122,9 @@ async def update_subscribe(
     elif subscribe_in.total_episode:
         # 总集数增加时，缺失集数也要增加
         if subscribe_in.total_episode > (subscribe.total_episode or 0):
-            subscribe_dict["lack_episode"] = (subscribe.lack_episode
-                                              + (subscribe_in.total_episode
-                                                 - (subscribe.total_episode or 0)))
+            subscribe_dict["lack_episode"] = subscribe.lack_episode + (
+                subscribe_in.total_episode - (subscribe.total_episode or 0)
+            )
     # 是否手动修改过总集数
     if subscribe_in.total_episode != subscribe.total_episode:
         subscribe_dict["manual_total_episode"] = 1
@@ -126,20 +133,24 @@ async def update_subscribe(
     # 重新获取更新后的订阅数据
     updated_subscribe = await Subscribe.async_get(db, subscribe_in.id)
     # 发送订阅调整事件
-    await eventmanager.async_send_event(EventType.SubscribeModified, {
-        "subscribe_id": subscribe_in.id,
-        "old_subscribe_info": old_subscribe_dict,
-        "subscribe_info": updated_subscribe.to_dict() if updated_subscribe else {},
-    })
+    await eventmanager.async_send_event(
+        EventType.SubscribeModified,
+        {
+            "subscribe_id": subscribe_in.id,
+            "old_subscribe_info": old_subscribe_dict,
+            "subscribe_info": updated_subscribe.to_dict() if updated_subscribe else {},
+        },
+    )
     return schemas.Response(success=True)
 
 
 @router.put("/status/{subid}", summary="更新订阅状态", response_model=schemas.Response)
 async def update_subscribe_status(
-        subid: int,
-        state: str,
-        db: AsyncSession = Depends(get_async_db),
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    subid: int,
+    state: str,
+    db: AsyncSession = Depends(get_async_db),
+    _: schemas.TokenPayload = Depends(verify_token),
+) -> Any:
     """
     更新订阅状态
     """
@@ -150,27 +161,29 @@ async def update_subscribe_status(
     if state not in valid_states:
         return schemas.Response(success=False, message="无效的订阅状态")
     old_subscribe_dict = subscribe.to_dict()
-    await subscribe.async_update(db, {
-        "state": state
-    })
+    await subscribe.async_update(db, {"state": state})
     # 重新获取更新后的订阅数据
     updated_subscribe = await Subscribe.async_get(db, subid)
     # 发送订阅调整事件
-    await eventmanager.async_send_event(EventType.SubscribeModified, {
-        "subscribe_id": subid,
-        "old_subscribe_info": old_subscribe_dict,
-        "subscribe_info": updated_subscribe.to_dict() if updated_subscribe else {},
-    })
+    await eventmanager.async_send_event(
+        EventType.SubscribeModified,
+        {
+            "subscribe_id": subid,
+            "old_subscribe_info": old_subscribe_dict,
+            "subscribe_info": updated_subscribe.to_dict() if updated_subscribe else {},
+        },
+    )
     return schemas.Response(success=True)
 
 
 @router.get("/media/{mediaid}", summary="查询订阅", response_model=schemas.Subscribe)
 async def subscribe_mediaid(
-        mediaid: str,
-        season: Optional[int] = None,
-        title: Optional[str] = None,
-        db: AsyncSession = Depends(get_async_db),
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    mediaid: str,
+    season: Optional[int] = None,
+    title: Optional[str] = None,
+    db: AsyncSession = Depends(get_async_db),
+    _: schemas.TokenPayload = Depends(verify_token),
+) -> Any:
     """
     根据 TMDBID/豆瓣ID/BangumiId 查询订阅 tmdb:/douban:
     """
@@ -203,14 +216,15 @@ async def subscribe_mediaid(
         meta = MetaInfo(title)
         if season is not None:
             meta.begin_season = season
-        result = await Subscribe.async_get_by_title(db, title=meta.name, season=meta.begin_season)
+        result = await Subscribe.async_get_by_title(
+            db, title=meta.name, season=meta.begin_season
+        )
 
     return result if result else Subscribe()
 
 
 @router.get("/refresh", summary="刷新订阅", response_model=schemas.Response)
-def refresh_subscribes(
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def refresh_subscribes(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     刷新所有订阅
     """
@@ -220,9 +234,10 @@ def refresh_subscribes(
 
 @router.get("/reset/{subid}", summary="重置订阅", response_model=schemas.Response)
 async def reset_subscribes(
-        subid: int,
-        db: AsyncSession = Depends(get_async_db),
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    subid: int,
+    db: AsyncSession = Depends(get_async_db),
+    _: schemas.TokenPayload = Depends(verify_token),
+) -> Any:
     """
     重置订阅
     """
@@ -231,28 +246,35 @@ async def reset_subscribes(
         # 在更新之前获取旧数据
         old_subscribe_dict = subscribe.to_dict()
         # 更新订阅
-        await subscribe.async_update(db, {
-            "note": [],
-            "lack_episode": subscribe.total_episode,
-            "current_priority": None,
-            "episode_priority": {},
-            "state": "R"
-        })
+        await subscribe.async_update(
+            db,
+            {
+                "note": [],
+                "lack_episode": subscribe.total_episode,
+                "current_priority": None,
+                "episode_priority": {},
+                "state": "R",
+            },
+        )
         # 重新获取更新后的订阅数据
         updated_subscribe = await Subscribe.async_get(db, subid)
         # 发送订阅调整事件
-        await eventmanager.async_send_event(EventType.SubscribeModified, {
-            "subscribe_id": subid,
-            "old_subscribe_info": old_subscribe_dict,
-            "subscribe_info": updated_subscribe.to_dict() if updated_subscribe else {},
-        })
+        await eventmanager.async_send_event(
+            EventType.SubscribeModified,
+            {
+                "subscribe_id": subid,
+                "old_subscribe_info": old_subscribe_dict,
+                "subscribe_info": updated_subscribe.to_dict()
+                if updated_subscribe
+                else {},
+            },
+        )
         return schemas.Response(success=True)
     return schemas.Response(success=False, message="订阅不存在")
 
 
 @router.get("/check", summary="刷新订阅 TMDB 信息", response_model=schemas.Response)
-def check_subscribes(
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def check_subscribes(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     刷新订阅 TMDB 信息
     """
@@ -262,49 +284,44 @@ def check_subscribes(
 
 @router.get("/search", summary="搜索所有订阅", response_model=schemas.Response)
 async def search_subscribes(
-        background_tasks: BackgroundTasks,
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    background_tasks: BackgroundTasks, _: schemas.TokenPayload = Depends(verify_token)
+) -> Any:
     """
     搜索所有订阅
     """
     background_tasks.add_task(
         Scheduler().start,
         job_id="subscribe_search",
-        **{
-            "sid": None,
-            "state": 'R',
-            "manual": True
-        }
+        **{"sid": None, "state": "R", "manual": True},
     )
     return schemas.Response(success=True)
 
 
-@router.get("/search/{subscribe_id}", summary="搜索订阅", response_model=schemas.Response)
+@router.get(
+    "/search/{subscribe_id}", summary="搜索订阅", response_model=schemas.Response
+)
 async def search_subscribe(
-        subscribe_id: int,
-        background_tasks: BackgroundTasks,
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    subscribe_id: int,
+    background_tasks: BackgroundTasks,
+    _: schemas.TokenPayload = Depends(verify_token),
+) -> Any:
     """
     根据订阅编号搜索订阅
     """
     background_tasks.add_task(
         Scheduler().start,
         job_id="subscribe_search",
-        **{
-            "sid": subscribe_id,
-            "state": None,
-            "manual": True
-        }
+        **{"sid": subscribe_id, "state": None, "manual": True},
     )
     return schemas.Response(success=True)
 
 
 @router.delete("/media/{mediaid}", summary="删除订阅", response_model=schemas.Response)
 async def delete_subscribe_by_mediaid(
-        mediaid: str,
-        season: Optional[int] = None,
-        db: AsyncSession = Depends(get_async_db),
-        _: schemas.TokenPayload = Depends(verify_token)
+    mediaid: str,
+    season: Optional[int] = None,
+    db: AsyncSession = Depends(get_async_db),
+    _: schemas.TokenPayload = Depends(verify_token),
 ) -> Any:
     """
     根据TMDBID或豆瓣ID删除订阅 tmdb:/douban:
@@ -333,16 +350,21 @@ async def delete_subscribe_by_mediaid(
         subscribe_id = subscribe.id
         await Subscribe.async_delete(db, subscribe_id)
         # 发送事件
-        await eventmanager.async_send_event(EventType.SubscribeDeleted, {
-            "subscribe_id": subscribe_id,
-            "subscribe_info": subscribe_info
-        })
+        await eventmanager.async_send_event(
+            EventType.SubscribeDeleted,
+            {"subscribe_id": subscribe_id, "subscribe_info": subscribe_info},
+        )
     return schemas.Response(success=True)
 
 
-@router.post("/seerr", summary="OverSeerr/JellySeerr通知订阅", response_model=schemas.Response)
-async def seerr_subscribe(request: Request, background_tasks: BackgroundTasks,
-                          authorization: Annotated[str | None, Header()] = None) -> Any:
+@router.post(
+    "/seerr", summary="OverSeerr/JellySeerr通知订阅", response_model=schemas.Response
+)
+async def seerr_subscribe(
+    request: Request,
+    background_tasks: BackgroundTasks,
+    authorization: Annotated[str | None, Header()] = None,
+) -> Any:
     """
     Jellyseerr/Overseerr网络勾子通知订阅
     """
@@ -361,49 +383,66 @@ async def seerr_subscribe(request: Request, background_tasks: BackgroundTasks,
     if notification_type not in ["MEDIA_APPROVED", "MEDIA_AUTO_APPROVED"]:
         return schemas.Response(success=False, message="不支持的通知类型")
     subject = req_json.get("subject")
-    media_type = MediaType.MOVIE if req_json.get("media", {}).get("media_type") == "movie" else MediaType.TV
+    media_type = (
+        MediaType.MOVIE
+        if req_json.get("media", {}).get("media_type") == "movie"
+        else MediaType.TV
+    )
     tmdbId = req_json.get("media", {}).get("tmdbId")
     if not media_type or not tmdbId or not subject:
         return schemas.Response(success=False, message="请求参数不正确")
     user_name = req_json.get("request", {}).get("requestedBy_username")
     # 添加订阅
     if media_type == MediaType.MOVIE:
-        background_tasks.add_task(start_subscribe_add,
-                                  mtype=media_type,
-                                  tmdbid=tmdbId,
-                                  title=subject,
-                                  year="",
-                                  season=0,
-                                  username=user_name)
+        background_tasks.add_task(
+            start_subscribe_add,
+            mtype=media_type,
+            tmdbid=tmdbId,
+            title=subject,
+            year="",
+            season=0,
+            username=user_name,
+        )
     else:
         seasons = []
         for extra in req_json.get("extra", []):
             if extra.get("name") == "Requested Seasons":
-                seasons = [int(str(sea).strip()) for sea in extra.get("value").split(", ") if str(sea).isdigit()]
+                seasons = [
+                    int(str(sea).strip())
+                    for sea in extra.get("value").split(", ")
+                    if str(sea).isdigit()
+                ]
                 break
         for season in seasons:
-            background_tasks.add_task(start_subscribe_add,
-                                      mtype=media_type,
-                                      tmdbid=tmdbId,
-                                      title=subject,
-                                      year="",
-                                      season=season,
-                                      username=user_name)
+            background_tasks.add_task(
+                start_subscribe_add,
+                mtype=media_type,
+                tmdbid=tmdbId,
+                title=subject,
+                year="",
+                season=season,
+                username=user_name,
+            )
 
     return schemas.Response(success=True)
 
 
-@router.get("/history/{mtype}", summary="查询订阅历史", response_model=List[schemas.Subscribe])
+@router.get(
+    "/history/{mtype}", summary="查询订阅历史", response_model=List[schemas.Subscribe]
+)
 async def subscribe_history(
-        mtype: str,
-        page: Optional[int] = 1,
-        count: Optional[int] = 30,
-        db: AsyncSession = Depends(get_async_db),
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    mtype: str,
+    page: Optional[int] = 1,
+    count: Optional[int] = 30,
+    db: AsyncSession = Depends(get_async_db),
+    _: schemas.TokenPayload = Depends(verify_token),
+) -> Any:
     """
     查询电影/电视剧订阅历史
     """
-    histories = await SubscribeHistory.async_list_by_type(db, mtype=mtype, page=page, count=count)
+    histories = await SubscribeHistory.async_list_by_type(
+        db, mtype=mtype, page=page, count=count
+    )
     result = []
     for history in histories:
         history_item = schemas.Subscribe.model_validate(history, from_attributes=True)
@@ -414,11 +453,13 @@ async def subscribe_history(
     return result
 
 
-@router.delete("/history/{history_id}", summary="删除订阅历史", response_model=schemas.Response)
-async def delete_subscribe(
-        history_id: int,
-        db: AsyncSession = Depends(get_async_db),
-        _: schemas.TokenPayload = Depends(verify_token)
+@router.delete(
+    "/history/{history_id}", summary="删除订阅历史", response_model=schemas.Response
+)
+async def delete_subscribe_history(
+    history_id: int,
+    db: AsyncSession = Depends(get_async_db),
+    _: schemas.TokenPayload = Depends(verify_token),
 ) -> Any:
     """
     删除订阅历史
@@ -427,17 +468,22 @@ async def delete_subscribe(
     return schemas.Response(success=True)
 
 
-@router.get("/popular", summary="热门订阅（基于用户共享数据）", response_model=List[schemas.MediaInfo])
+@router.get(
+    "/popular",
+    summary="热门订阅（基于用户共享数据）",
+    response_model=List[schemas.MediaInfo],
+)
 async def popular_subscribes(
-        stype: str,
-        page: Optional[int] = 1,
-        count: Optional[int] = 30,
-        min_sub: Optional[int] = None,
-        genre_id: Optional[int] = None,
-        min_rating: Optional[float] = None,
-        max_rating: Optional[float] = None,
-        sort_type: Optional[str] = None,
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    stype: str,
+    page: Optional[int] = 1,
+    count: Optional[int] = 30,
+    min_sub: Optional[int] = None,
+    genre_id: Optional[int] = None,
+    min_rating: Optional[float] = None,
+    max_rating: Optional[float] = None,
+    sort_type: Optional[str] = None,
+    _: schemas.TokenPayload = Depends(verify_token),
+) -> Any:
     """
     查询热门订阅
     """
@@ -448,7 +494,7 @@ async def popular_subscribes(
         genre_id=genre_id,
         min_rating=min_rating,
         max_rating=max_rating,
-        sort_type=sort_type
+        sort_type=sort_type,
     )
     if subscribes:
         ret_medias = []
@@ -484,22 +530,30 @@ async def popular_subscribes(
     return []
 
 
-@router.get("/user/{username}", summary="用户订阅", response_model=List[schemas.Subscribe])
+@router.get(
+    "/user/{username}", summary="用户订阅", response_model=List[schemas.Subscribe]
+)
 async def user_subscribes(
-        username: str,
-        db: AsyncSession = Depends(get_async_db),
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    username: str,
+    db: AsyncSession = Depends(get_async_db),
+    _: schemas.TokenPayload = Depends(verify_token),
+) -> Any:
     """
     查询用户订阅
     """
     return await Subscribe.async_list_by_username(db, username)
 
 
-@router.get("/files/{subscribe_id}", summary="订阅相关文件信息", response_model=schemas.SubscrbieInfo)
+@router.get(
+    "/files/{subscribe_id}",
+    summary="订阅相关文件信息",
+    response_model=schemas.SubscrbieInfo,
+)
 def subscribe_files(
-        subscribe_id: int,
-        db: Session = Depends(get_db),
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    subscribe_id: int,
+    db: Session = Depends(get_db),
+    _: schemas.TokenPayload = Depends(verify_token),
+) -> Any:
     """
     订阅相关文件信息
     """
@@ -511,22 +565,24 @@ def subscribe_files(
 
 @router.post("/share", summary="分享订阅", response_model=schemas.Response)
 async def subscribe_share(
-        sub: schemas.SubscribeShare,
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    sub: schemas.SubscribeShare, _: schemas.TokenPayload = Depends(verify_token)
+) -> Any:
     """
     分享订阅
     """
-    state, errmsg = await SubscribeHelper().async_sub_share(subscribe_id=sub.subscribe_id,
-                                                            share_title=sub.share_title,
-                                                            share_comment=sub.share_comment,
-                                                            share_user=sub.share_user)
+    state, errmsg = await SubscribeHelper().async_sub_share(
+        subscribe_id=sub.subscribe_id,
+        share_title=sub.share_title,
+        share_comment=sub.share_comment,
+        share_user=sub.share_user,
+    )
     return schemas.Response(success=state, message=errmsg)
 
 
 @router.delete("/share/{share_id}", summary="删除分享", response_model=schemas.Response)
 async def subscribe_share_delete(
-        share_id: int,
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    share_id: int, _: schemas.TokenPayload = Depends(verify_token)
+) -> Any:
     """
     删除分享
     """
@@ -536,8 +592,9 @@ async def subscribe_share_delete(
 
 @router.post("/fork", summary="复用订阅", response_model=schemas.Response)
 async def subscribe_fork(
-        sub: schemas.SubscribeShare,
-        current_user: User = Depends(get_current_active_user_async)) -> Any:
+    sub: schemas.SubscribeShare,
+    current_user: User = Depends(get_current_active_user_async),
+) -> Any:
     """
     复用订阅
     """
@@ -546,8 +603,9 @@ async def subscribe_fork(
     for key in list(sub_dict.keys()):
         if not hasattr(schemas.Subscribe(), key):
             sub_dict.pop(key)
-    result = await create_subscribe(subscribe_in=schemas.Subscribe(**sub_dict),
-                                    current_user=current_user)
+    result = await create_subscribe(
+        subscribe_in=schemas.Subscribe(**sub_dict), current_user=current_user
+    )
     if result.success:
         await SubscribeHelper().async_sub_fork(share_id=sub.id)
     return result
@@ -563,42 +621,51 @@ async def followed_subscribers(_: schemas.TokenPayload = Depends(verify_token))
 
 @router.post("/follow", summary="Follow订阅分享人", response_model=schemas.Response)
 async def follow_subscriber(
-        share_uid: Optional[str] = None,
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    share_uid: Optional[str] = None, _: schemas.TokenPayload = Depends(verify_token)
+) -> Any:
     """
     Follow订阅分享人
     """
     subscribers = SystemConfigOper().get(SystemConfigKey.FollowSubscribers) or []
     if share_uid and share_uid not in subscribers:
         subscribers.append(share_uid)
-        await SystemConfigOper().async_set(SystemConfigKey.FollowSubscribers, subscribers)
+        await SystemConfigOper().async_set(
+            SystemConfigKey.FollowSubscribers, subscribers
+        )
     return schemas.Response(success=True)
 
 
-@router.delete("/follow", summary="取消Follow订阅分享人", response_model=schemas.Response)
+@router.delete(
+    "/follow", summary="取消Follow订阅分享人", response_model=schemas.Response
+)
 async def unfollow_subscriber(
-        share_uid: Optional[str] = None,
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    share_uid: Optional[str] = None, _: schemas.TokenPayload = Depends(verify_token)
+) -> Any:
     """
     取消Follow订阅分享人
     """
     subscribers = SystemConfigOper().get(SystemConfigKey.FollowSubscribers) or []
     if share_uid and share_uid in subscribers:
         subscribers.remove(share_uid)
-        await SystemConfigOper().async_set(SystemConfigKey.FollowSubscribers, subscribers)
+        await SystemConfigOper().async_set(
+            SystemConfigKey.FollowSubscribers, subscribers
+        )
     return schemas.Response(success=True)
 
 
-@router.get("/shares", summary="查询分享的订阅", response_model=List[schemas.SubscribeShare])
-async def popular_subscribes(
-        name: Optional[str] = None,
-        page: Optional[int] = 1,
-        count: Optional[int] = 30,
-        genre_id: Optional[int] = None,
-        min_rating: Optional[float] = None,
-        max_rating: Optional[float] = None,
-        sort_type: Optional[str] = None,
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+@router.get(
+    "/shares", summary="查询分享的订阅", response_model=List[schemas.SubscribeShare]
+)
+async def subscribe_shares(
+    name: Optional[str] = None,
+    page: Optional[int] = 1,
+    count: Optional[int] = 30,
+    genre_id: Optional[int] = None,
+    min_rating: Optional[float] = None,
+    max_rating: Optional[float] = None,
+    sort_type: Optional[str] = None,
+    _: schemas.TokenPayload = Depends(verify_token),
+) -> Any:
     """
     查询分享的订阅
     """
@@ -609,12 +676,18 @@ async def popular_subscribes(
         genre_id=genre_id,
         min_rating=min_rating,
         max_rating=max_rating,
-        sort_type=sort_type
+        sort_type=sort_type,
     )
 
 
-@router.get("/share/statistics", summary="查询订阅分享统计", response_model=List[schemas.SubscribeShareStatistics])
-async def subscribe_share_statistics(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+@router.get(
+    "/share/statistics",
+    summary="查询订阅分享统计",
+    response_model=List[schemas.SubscribeShareStatistics],
+)
+async def subscribe_share_statistics(
+    _: schemas.TokenPayload = Depends(verify_token),
+) -> Any:
     """
     查询订阅分享统计
     返回每个分享人分享的媒体数量以及总的复用人次
@@ -624,9 +697,10 @@ async def subscribe_share_statistics(_: schemas.TokenPayload = Depends(verify_to
 
 @router.get("/{subscribe_id}", summary="订阅详情", response_model=schemas.Subscribe)
 async def read_subscribe(
-        subscribe_id: int,
-        db: AsyncSession = Depends(get_async_db),
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    subscribe_id: int,
+    db: AsyncSession = Depends(get_async_db),
+    _: schemas.TokenPayload = Depends(verify_token),
+) -> Any:
     """
     根据订阅编号查询订阅信息
     """
@@ -637,9 +711,9 @@ async def read_subscribe(
 
 @router.delete("/{subscribe_id}", summary="删除订阅", response_model=schemas.Response)
 async def delete_subscribe(
-        subscribe_id: int,
-        db: AsyncSession = Depends(get_async_db),
-        _: schemas.TokenPayload = Depends(verify_token)
+    subscribe_id: int,
+    db: AsyncSession = Depends(get_async_db),
+    _: schemas.TokenPayload = Depends(verify_token),
 ) -> Any:
     """
     删除订阅信息
@@ -650,13 +724,12 @@ async def delete_subscribe(
         subscribe_info = subscribe.to_dict()
         await Subscribe.async_delete(db, subscribe_id)
         # 发送事件
-        await eventmanager.async_send_event(EventType.SubscribeDeleted, {
-            "subscribe_id": subscribe_id,
-            "subscribe_info": subscribe_info
-        })
+        await eventmanager.async_send_event(
+            EventType.SubscribeDeleted,
+            {"subscribe_id": subscribe_id, "subscribe_info": subscribe_info},
+        )
         # 统计订阅
-        SubscribeHelper().sub_done_async({
-            "tmdbid": subscribe.tmdbid,
-            "doubanid": subscribe.doubanid
-        })
+        SubscribeHelper().sub_done_async(
+            {"tmdbid": subscribe.tmdbid, "doubanid": subscribe.doubanid}
+        )
     return schemas.Response(success=True)