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/media.py

@@ -20,10 +20,14 @@ from app.schemas.types import ChainEventType
 router = APIRouter()
 
 
-@router.get("/recognize", summary="识别媒体信息（种子）", response_model=schemas.Context)
-async def recognize(title: str,
-                    subtitle: Optional[str] = None,
-                    _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+@router.get(
+    "/recognize", summary="识别媒体信息（种子）", response_model=schemas.Context
+)
+async def recognize(
+    title: str,
+    subtitle: Optional[str] = None,
+    _: schemas.TokenPayload = Depends(verify_token),
+) -> Any:
     """
     根据标题、副标题识别媒体信息
     """
@@ -35,11 +39,16 @@ async def recognize(title: str,
     return schemas.Context()
 
 
-@router.get("/recognize2", summary="识别种子媒体信息（API_TOKEN）", response_model=schemas.Context)
-async def recognize2(_: Annotated[str, Depends(verify_apitoken)],
-                     title: str,
-                     subtitle: Optional[str] = None
-                     ) -> Any:
+@router.get(
+    "/recognize2",
+    summary="识别种子媒体信息（API_TOKEN）",
+    response_model=schemas.Context,
+)
+async def recognize2(
+    _: Annotated[str, Depends(verify_apitoken)],
+    title: str,
+    subtitle: Optional[str] = None,
+) -> Any:
     """
     根据标题、副标题识别媒体信息 API_TOKEN认证（?token=xxx）
     """
@@ -47,9 +56,12 @@ async def recognize2(_: Annotated[str, Depends(verify_apitoken)],
     return await recognize(title, subtitle)
 
 
-@router.get("/recognize_file", summary="识别媒体信息（文件）", response_model=schemas.Context)
-async def recognize_file(path: str,
-                         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+@router.get(
+    "/recognize_file", summary="识别媒体信息（文件）", response_model=schemas.Context
+)
+async def recognize_file(
+    path: str, _: schemas.TokenPayload = Depends(verify_token)
+) -> Any:
     """
     根据文件路径识别媒体信息
     """
@@ -60,9 +72,14 @@ async def recognize_file(path: str,
     return schemas.Context()
 
 
-@router.get("/recognize_file2", summary="识别文件媒体信息（API_TOKEN）", response_model=schemas.Context)
-async def recognize_file2(path: str,
-                          _: Annotated[str, Depends(verify_apitoken)]) -> Any:
+@router.get(
+    "/recognize_file2",
+    summary="识别文件媒体信息（API_TOKEN）",
+    response_model=schemas.Context,
+)
+async def recognize_file2(
+    path: str, _: Annotated[str, Depends(verify_apitoken)]
+) -> Any:
     """
     根据文件路径识别媒体信息 API_TOKEN认证（?token=xxx）
     """
@@ -71,11 +88,13 @@ async def recognize_file2(path: str,
 
 
 @router.get("/search", summary="搜索媒体/人物信息", response_model=List[dict])
-async def search(title: str,
-                 type: Optional[str] = "media",
-                 page: int = 1,
-                 count: int = 8,
-                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+async def search(
+    title: str,
+    type: Optional[str] = "media",
+    page: int = 1,
+    count: int = 8,
+    _: schemas.TokenPayload = Depends(verify_token),
+) -> Any:
     """
     模糊搜索媒体/人物信息列表 media：媒体信息，person：人物信息
     """
@@ -94,7 +113,9 @@ async def search(title: str,
         result = [media.to_dict() for media in medias] if medias else []
     elif type == "collection":
         collections = await media_chain.async_search_collections(name=title)
-        result = [collection.to_dict() for collection in collections] if collections else []
+        result = (
+            [collection.to_dict() for collection in collections] if collections else []
+        )
     else:  # person
         persons = await media_chain.async_search_persons(name=title)
         result = [person.model_dump() for person in persons] if persons else []
@@ -103,17 +124,21 @@ async def search(title: str,
         return []
 
     # 排序和分页
-    setting_order = settings.SEARCH_SOURCE.split(',') if settings.SEARCH_SOURCE else []
+    setting_order = settings.SEARCH_SOURCE.split(",") if settings.SEARCH_SOURCE else []
     sort_order = {source: index for index, source in enumerate(setting_order)}
 
     sorted_result = sorted(result, key=lambda x: sort_order.get(__get_source(x), 4))
-    return sorted_result[(page - 1) * count:page * count]
+    return sorted_result[(page - 1) * count : page * count]
 
 
-@router.post("/scrape/{storage}", summary="刮削媒体信息", response_model=schemas.Response)
-def scrape(fileitem: schemas.FileItem,
-           storage: Optional[str] = "local",
-           _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+@router.post(
+    "/scrape/{storage}", summary="刮削媒体信息", response_model=schemas.Response
+)
+def scrape(
+    fileitem: schemas.FileItem,
+    storage: Optional[str] = "local",
+    _: schemas.TokenPayload = Depends(verify_token),
+) -> Any:
     """
     刮削媒体信息
     """
@@ -132,12 +157,14 @@ def scrape(fileitem: schemas.FileItem,
         fileitem=fileitem,
         meta=context.meta_info,
         mediainfo=context.media_info,
-        overwrite=True
+        overwrite=True,
     )
     return schemas.Response(success=True, message=f"{fileitem.path} 刮削完成")
 
 
-@router.get("/category/config", summary="获取分类策略配置", response_model=schemas.Response)
+@router.get(
+    "/category/config", summary="获取分类策略配置", response_model=schemas.Response
+)
 def get_category_config(_: User = Depends(get_current_active_user)):
     """
     获取分类策略配置
@@ -146,8 +173,12 @@ def get_category_config(_: User = Depends(get_current_active_user)):
     return schemas.Response(success=True, data=config.model_dump())
 
 
-@router.post("/category/config", summary="保存分类策略配置", response_model=schemas.Response)
-def save_category_config(config: CategoryConfig, _: User = Depends(get_current_active_superuser)):
+@router.post(
+    "/category/config", summary="保存分类策略配置", response_model=schemas.Response
+)
+def save_category_config(
+    config: CategoryConfig, _: User = Depends(get_current_active_superuser)
+):
     """
     保存分类策略配置
     """
@@ -165,8 +196,14 @@ async def category(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
     return MediaChain().media_category() or {}
 
 
-@router.get("/group/seasons/{episode_group}", summary="查询剧集组季信息", response_model=List[schemas.MediaSeason])
-async def group_seasons(episode_group: str, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+@router.get(
+    "/group/seasons/{episode_group}",
+    summary="查询剧集组季信息",
+    response_model=List[schemas.MediaSeason],
+)
+async def group_seasons(
+    episode_group: str, _: schemas.TokenPayload = Depends(verify_token)
+) -> Any:
     """
     查询剧集组季信息（themoviedb）
     """
@@ -178,18 +215,24 @@ async def groups(tmdbid: int, _: schemas.TokenPayload = Depends(verify_token)) -
     """
     查询媒体剧集组列表（themoviedb）
     """
-    mediainfo = await MediaChain().async_recognize_media(tmdbid=tmdbid, mtype=MediaType.TV)
+    mediainfo = await MediaChain().async_recognize_media(
+        tmdbid=tmdbid, mtype=MediaType.TV
+    )
     if not mediainfo:
         return []
     return mediainfo.episode_groups
 
 
-@router.get("/seasons", summary="查询媒体季信息", response_model=List[schemas.MediaSeason])
-async def seasons(mediaid: Optional[str] = None,
-                  title: Optional[str] = None,
-                  year: str = None,
-                  season: int = None,
-                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+@router.get(
+    "/seasons", summary="查询媒体季信息", response_model=List[schemas.MediaSeason]
+)
+async def seasons(
+    mediaid: Optional[str] = None,
+    title: Optional[str] = None,
+    year: str = None,
+    season: int = None,
+    _: schemas.TokenPayload = Depends(verify_token),
+) -> Any:
     """
     查询媒体季信息
     """
@@ -212,28 +255,39 @@ async def seasons(mediaid: Optional[str] = None,
         )
         if mediainfo:
             if settings.RECOGNIZE_SOURCE == "themoviedb":
-                seasons_info = await TmdbChain().async_tmdb_seasons(tmdbid=mediainfo.tmdb_id)
+                seasons_info = await TmdbChain().async_tmdb_seasons(
+                    tmdbid=mediainfo.tmdb_id
+                )
                 if seasons_info:
                     if season is not None:
-                        return [sea for sea in seasons_info if sea.season_number == season]
+                        return [
+                            sea for sea in seasons_info if sea.season_number == season
+                        ]
                     return seasons_info
             else:
                 sea = season if season is not None else 1
-                return [schemas.MediaSeason(
-                    season_number=sea,
-                    poster_path=mediainfo.poster_path,
-                    name=f"第 {sea} 季",
-                    air_date=mediainfo.release_date,
-                    overview=mediainfo.overview,
-                    vote_average=mediainfo.vote_average,
-                    episode_count=mediainfo.number_of_episodes
-                )]
+                return [
+                    schemas.MediaSeason(
+                        season_number=sea,
+                        poster_path=mediainfo.poster_path,
+                        name=f"第 {sea} 季",
+                        air_date=mediainfo.release_date,
+                        overview=mediainfo.overview,
+                        vote_average=mediainfo.vote_average,
+                        episode_count=mediainfo.number_of_episodes,
+                    )
+                ]
     return []
 
 
 @router.get("/{mediaid}", summary="查询媒体详情", response_model=schemas.MediaInfo)
-async def detail(mediaid: str, type_name: str, title: Optional[str] = None, year: str = None,
-                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+async def detail(
+    mediaid: str,
+    type_name: str,
+    title: Optional[str] = None,
+    year: str = None,
+    _: schemas.TokenPayload = Depends(verify_token),
+) -> Any:
     """
     根据媒体ID查询themoviedb或豆瓣媒体信息，type_name: 电影/电视剧
     """
@@ -241,26 +295,37 @@ async def detail(mediaid: str, type_name: str, title: Optional[str] = None, year
     mediainfo = None
     mediachain = MediaChain()
     if mediaid.startswith("tmdb:"):
-        mediainfo = await mediachain.async_recognize_media(tmdbid=int(mediaid[5:]), mtype=mtype)
+        mediainfo = await mediachain.async_recognize_media(
+            tmdbid=int(mediaid[5:]), mtype=mtype
+        )
     elif mediaid.startswith("douban:"):
-        mediainfo = await mediachain.async_recognize_media(doubanid=mediaid[7:], mtype=mtype)
+        mediainfo = await mediachain.async_recognize_media(
+            doubanid=mediaid[7:], mtype=mtype
+        )
     elif mediaid.startswith("bangumi:"):
-        mediainfo = await mediachain.async_recognize_media(bangumiid=int(mediaid[8:]), mtype=mtype)
+        mediainfo = await mediachain.async_recognize_media(
+            bangumiid=int(mediaid[8:]), mtype=mtype
+        )
     else:
         # 广播事件解析媒体信息
         event_data = MediaRecognizeConvertEventData(
-            mediaid=mediaid,
-            convert_type=settings.RECOGNIZE_SOURCE
+            mediaid=mediaid, convert_type=settings.RECOGNIZE_SOURCE
+        )
+        event = await eventmanager.async_send_event(
+            ChainEventType.MediaRecognizeConvert, event_data
         )
-        event = await eventmanager.async_send_event(ChainEventType.MediaRecognizeConvert, event_data)
         # 使用事件返回的上下文数据
         if event and event.event_data and event.event_data.media_dict:
             event_data: MediaRecognizeConvertEventData = event.event_data
             new_id = event_data.media_dict.get("id")
             if event_data.convert_type == "themoviedb":
-                mediainfo = await mediachain.async_recognize_media(tmdbid=new_id, mtype=mtype)
+                mediainfo = await mediachain.async_recognize_media(
+                    tmdbid=new_id, mtype=mtype
+                )
             elif event_data.convert_type == "douban":
-                mediainfo = await mediachain.async_recognize_media(doubanid=new_id, mtype=mtype)
+                mediainfo = await mediachain.async_recognize_media(
+                    doubanid=new_id, mtype=mtype
+                )
         elif title:
             # 使用名称识别兜底
             meta = MetaInfo(title)