596 lines
23 KiB
Python
596 lines
23 KiB
Python
from pathlib import Path
|
||
from typing import Optional, List, Tuple, Union, Dict
|
||
|
||
import cn2an
|
||
|
||
from app import schemas
|
||
from app.core.config import settings
|
||
from app.core.context import MediaInfo
|
||
from app.core.meta import MetaBase
|
||
from app.log import logger
|
||
from app.modules import _ModuleBase
|
||
from app.modules.themoviedb.category import CategoryHelper
|
||
from app.modules.themoviedb.scraper import TmdbScraper
|
||
from app.modules.themoviedb.tmdb_cache import TmdbCache
|
||
from app.modules.themoviedb.tmdbapi import TmdbApi
|
||
from app.schemas import MediaPerson
|
||
from app.schemas.types import MediaType, MediaImageType
|
||
from app.utils.http import RequestUtils
|
||
from app.utils.system import SystemUtils
|
||
|
||
|
||
class TheMovieDbModule(_ModuleBase):
|
||
"""
|
||
TMDB媒体信息匹配
|
||
"""
|
||
|
||
# 元数据缓存
|
||
cache: TmdbCache = None
|
||
# TMDB
|
||
tmdb: TmdbApi = None
|
||
# 二级分类
|
||
category: CategoryHelper = None
|
||
# 刮削器
|
||
scraper: TmdbScraper = None
|
||
|
||
def init_module(self) -> None:
|
||
self.cache = TmdbCache()
|
||
self.tmdb = TmdbApi()
|
||
self.category = CategoryHelper()
|
||
self.scraper = TmdbScraper(self.tmdb)
|
||
|
||
@staticmethod
|
||
def get_name() -> str:
|
||
return "TheMovieDb"
|
||
|
||
def stop(self):
|
||
self.cache.save()
|
||
self.tmdb.close()
|
||
|
||
def test(self) -> Tuple[bool, str]:
|
||
"""
|
||
测试模块连接性
|
||
"""
|
||
ret = RequestUtils(proxies=settings.PROXY).get_res(
|
||
f"https://{settings.TMDB_API_DOMAIN}/3/movie/550?api_key={settings.TMDB_API_KEY}")
|
||
if ret and ret.status_code == 200:
|
||
return True, ""
|
||
elif ret:
|
||
return False, f"无法连接 {settings.TMDB_API_DOMAIN}，错误码：{ret.status_code}"
|
||
return False, f"{settings.TMDB_API_DOMAIN} 网络连接失败"
|
||
|
||
def init_setting(self) -> Tuple[str, Union[str, bool]]:
|
||
pass
|
||
|
||
def recognize_media(self, meta: MetaBase = None,
|
||
mtype: MediaType = None,
|
||
tmdbid: int = None,
|
||
cache: bool = True,
|
||
**kwargs) -> Optional[MediaInfo]:
|
||
"""
|
||
识别媒体信息
|
||
:param meta: 识别的元数据
|
||
:param mtype: 识别的媒体类型，与tmdbid配套
|
||
:param tmdbid: tmdbid
|
||
:param cache: 是否使用缓存
|
||
:return: 识别的媒体信息，包括剧集信息
|
||
"""
|
||
if not tmdbid and not meta:
|
||
return None
|
||
|
||
if meta and not tmdbid \
|
||
and settings.RECOGNIZE_SOURCE != "themoviedb":
|
||
return None
|
||
|
||
if not meta:
|
||
# 未提供元数据时，直接使用tmdbid查询，不使用缓存
|
||
cache_info = {}
|
||
elif not meta.name:
|
||
logger.warn("识别媒体信息时未提供元数据名称")
|
||
return None
|
||
else:
|
||
# 读取缓存
|
||
if mtype:
|
||
meta.type = mtype
|
||
if tmdbid:
|
||
meta.tmdbid = tmdbid
|
||
cache_info = self.cache.get(meta)
|
||
|
||
# 识别匹配
|
||
if not cache_info or not cache:
|
||
# 缓存没有或者强制不使用缓存
|
||
if tmdbid:
|
||
# 直接查询详情
|
||
info = self.tmdb.get_info(mtype=mtype, tmdbid=tmdbid)
|
||
elif meta:
|
||
info = {}
|
||
# 使用中英文名分别识别，去重去空，但要保持顺序
|
||
names = list(dict.fromkeys([k for k in [meta.cn_name, meta.en_name] if k]))
|
||
for name in names:
|
||
if meta.begin_season:
|
||
logger.info(f"正在识别 {name} 第{meta.begin_season}季 ...")
|
||
else:
|
||
logger.info(f"正在识别 {name} ...")
|
||
if meta.type == MediaType.UNKNOWN and not meta.year:
|
||
info = self.tmdb.match_multi(name)
|
||
else:
|
||
if meta.type == MediaType.TV:
|
||
# 确定是电视
|
||
info = self.tmdb.match(name=name,
|
||
year=meta.year,
|
||
mtype=meta.type,
|
||
season_year=meta.year,
|
||
season_number=meta.begin_season)
|
||
if not info:
|
||
# 去掉年份再查一次
|
||
info = self.tmdb.match(name=name,
|
||
mtype=meta.type)
|
||
else:
|
||
# 有年份先按电影查
|
||
info = self.tmdb.match(name=name,
|
||
year=meta.year,
|
||
mtype=MediaType.MOVIE)
|
||
# 没有再按电视剧查
|
||
if not info:
|
||
info = self.tmdb.match(name=name,
|
||
year=meta.year,
|
||
mtype=MediaType.TV)
|
||
if not info:
|
||
# 去掉年份和类型再查一次
|
||
info = self.tmdb.match_multi(name=name)
|
||
|
||
if not info:
|
||
# 从网站查询
|
||
info = self.tmdb.match_web(name=name,
|
||
mtype=meta.type)
|
||
if info:
|
||
# 查到就退出
|
||
break
|
||
# 补充全量信息
|
||
if info and not info.get("genres"):
|
||
info = self.tmdb.get_info(mtype=info.get("media_type"),
|
||
tmdbid=info.get("id"))
|
||
else:
|
||
logger.error("识别媒体信息时未提供元数据或tmdbid")
|
||
return None
|
||
|
||
# 保存到缓存
|
||
if meta:
|
||
self.cache.update(meta, info)
|
||
else:
|
||
# 使用缓存信息
|
||
if cache_info.get("title"):
|
||
logger.info(f"{meta.name} 使用TMDB识别缓存：{cache_info.get('title')}")
|
||
info = self.tmdb.get_info(mtype=cache_info.get("type"),
|
||
tmdbid=cache_info.get("id"))
|
||
else:
|
||
logger.info(f"{meta.name} 使用TMDB识别缓存：无法识别")
|
||
info = None
|
||
|
||
if info:
|
||
# 确定二级分类
|
||
if info.get('media_type') == MediaType.TV:
|
||
cat = self.category.get_tv_category(info)
|
||
else:
|
||
cat = self.category.get_movie_category(info)
|
||
# 赋值TMDB信息并返回
|
||
mediainfo = MediaInfo(tmdb_info=info)
|
||
mediainfo.set_category(cat)
|
||
if meta:
|
||
logger.info(f"{meta.name} TMDB识别结果：{mediainfo.type.value} "
|
||
f"{mediainfo.title_year} "
|
||
f"{mediainfo.tmdb_id}")
|
||
else:
|
||
logger.info(f"{tmdbid} TMDB识别结果：{mediainfo.type.value} "
|
||
f"{mediainfo.title_year}")
|
||
|
||
# 补充剧集年份
|
||
if mediainfo.type == MediaType.TV:
|
||
episode_years = self.tmdb.get_tv_episode_years(info.get("id"))
|
||
if episode_years:
|
||
mediainfo.season_years = episode_years
|
||
return mediainfo
|
||
else:
|
||
logger.info(f"{meta.name if meta else tmdbid} 未匹配到TMDB媒体信息")
|
||
|
||
return None
|
||
|
||
def match_tmdbinfo(self, name: str, mtype: MediaType = None,
|
||
year: str = None, season: int = None) -> dict:
|
||
"""
|
||
搜索和匹配TMDB信息
|
||
:param name: 名称
|
||
:param mtype: 类型
|
||
:param year: 年份
|
||
:param season: 季号
|
||
"""
|
||
# 搜索
|
||
logger.info(f"开始使用 名称：{name} 年份：{year} 匹配TMDB信息 ...")
|
||
info = self.tmdb.match(name=name,
|
||
year=year,
|
||
mtype=mtype,
|
||
season_year=year,
|
||
season_number=season)
|
||
if info and not info.get("genres"):
|
||
info = self.tmdb.get_info(mtype=info.get("media_type"),
|
||
tmdbid=info.get("id"))
|
||
return info
|
||
|
||
def tmdb_info(self, tmdbid: int, mtype: MediaType, season: int = None) -> Optional[dict]:
|
||
"""
|
||
获取TMDB信息
|
||
:param tmdbid: int
|
||
:param mtype: 媒体类型
|
||
:param season: 季号
|
||
:return: TVDB信息
|
||
"""
|
||
if not season:
|
||
return self.tmdb.get_info(mtype=mtype, tmdbid=tmdbid)
|
||
else:
|
||
return self.tmdb.get_tv_season_detail(tmdbid=tmdbid, season=season)
|
||
|
||
def media_category(self) -> Optional[Dict[str, list]]:
|
||
"""
|
||
获取媒体分类
|
||
:return: 获取二级分类配置字典项，需包括电影、电视剧
|
||
"""
|
||
return {
|
||
MediaType.MOVIE.value: list(self.category.movie_categorys),
|
||
MediaType.TV.value: list(self.category.tv_categorys)
|
||
}
|
||
|
||
def search_medias(self, meta: MetaBase) -> Optional[List[MediaInfo]]:
|
||
"""
|
||
搜索媒体信息
|
||
:param meta: 识别的元数据
|
||
:reutrn: 媒体信息列表
|
||
"""
|
||
if settings.SEARCH_SOURCE and "themoviedb" not in settings.SEARCH_SOURCE:
|
||
return None
|
||
if not meta.name:
|
||
return []
|
||
if meta.type == MediaType.UNKNOWN and not meta.year:
|
||
results = self.tmdb.search_multiis(meta.name)
|
||
else:
|
||
if meta.type == MediaType.UNKNOWN:
|
||
results = self.tmdb.search_movies(meta.name, meta.year)
|
||
results.extend(self.tmdb.search_tvs(meta.name, meta.year))
|
||
# 组合结果的情况下要排序
|
||
results = sorted(
|
||
results,
|
||
key=lambda x: x.get("release_date") or x.get("first_air_date") or "0000-00-00",
|
||
reverse=True
|
||
)
|
||
elif meta.type == MediaType.MOVIE:
|
||
results = self.tmdb.search_movies(meta.name, meta.year)
|
||
else:
|
||
results = self.tmdb.search_tvs(meta.name, meta.year)
|
||
# 将搜索词中的季写入标题中
|
||
if results:
|
||
medias = [MediaInfo(tmdb_info=info) for info in results]
|
||
if meta.begin_season:
|
||
# 小写数据转大写
|
||
season_str = cn2an.an2cn(meta.begin_season, "low")
|
||
for media in medias:
|
||
if media.type == MediaType.TV:
|
||
media.title = f"{media.title} 第{season_str}季"
|
||
media.season = meta.begin_season
|
||
return medias
|
||
return []
|
||
|
||
def search_persons(self, name: str) -> Optional[List[MediaPerson]]:
|
||
"""
|
||
搜索人物信息
|
||
"""
|
||
if not name:
|
||
return []
|
||
results = self.tmdb.search_persons(name)
|
||
if results:
|
||
return [MediaPerson(source='themoviedb', **person) for person in results]
|
||
return []
|
||
|
||
def scrape_metadata(self, path: Path, mediainfo: MediaInfo, transfer_type: str,
|
||
metainfo: MetaBase = None, force_nfo: bool = False, force_img: bool = False) -> None:
|
||
"""
|
||
刮削元数据
|
||
:param path: 媒体文件路径
|
||
:param mediainfo: 识别的媒体信息
|
||
:param metainfo: 源文件的识别元数据
|
||
:param transfer_type: 转移类型
|
||
:param force_nfo: 强制刮削nfo
|
||
:param force_img: 强制刮削图片
|
||
:return: 成功或失败
|
||
"""
|
||
if settings.SCRAP_SOURCE != "themoviedb":
|
||
return None
|
||
|
||
if SystemUtils.is_bluray_dir(path):
|
||
# 蓝光原盘
|
||
logger.info(f"开始刮削蓝光原盘：{path} ...")
|
||
scrape_path = path / path.name
|
||
self.scraper.gen_scraper_files(mediainfo=mediainfo,
|
||
file_path=scrape_path,
|
||
transfer_type=transfer_type,
|
||
metainfo=metainfo,
|
||
force_nfo=force_nfo,
|
||
force_img=force_img)
|
||
elif path.is_file():
|
||
# 单个文件
|
||
logger.info(f"开始刮削媒体库文件：{path} ...")
|
||
self.scraper.gen_scraper_files(mediainfo=mediainfo,
|
||
file_path=path,
|
||
transfer_type=transfer_type,
|
||
metainfo=metainfo,
|
||
force_nfo=force_nfo,
|
||
force_img=force_img)
|
||
else:
|
||
# 目录下的所有文件
|
||
logger.info(f"开始刮削目录：{path} ...")
|
||
for file in SystemUtils.list_files(path, settings.RMT_MEDIAEXT):
|
||
if not file:
|
||
continue
|
||
self.scraper.gen_scraper_files(mediainfo=mediainfo,
|
||
file_path=file,
|
||
transfer_type=transfer_type,
|
||
force_nfo=force_nfo,
|
||
force_img=force_img)
|
||
logger.info(f"{path} 刮削完成")
|
||
|
||
def metadata_nfo(self, meta: MetaBase, mediainfo: MediaInfo,
|
||
season: int = None, episode: int = None) -> Optional[str]:
|
||
"""
|
||
获取NFO文件内容文本
|
||
:param meta: 元数据
|
||
:param mediainfo: 媒体信息
|
||
:param season: 季号
|
||
:param episode: 集号
|
||
"""
|
||
if settings.SCRAP_SOURCE != "themoviedb":
|
||
return None
|
||
return self.scraper.get_metadata_nfo(meta=meta, mediainfo=mediainfo, season=season, episode=episode)
|
||
|
||
def metadata_img(self, mediainfo: MediaInfo, season: int = None) -> Optional[dict]:
|
||
"""
|
||
获取图片名称和url
|
||
:param mediainfo: 媒体信息
|
||
:param season: 季号
|
||
"""
|
||
if settings.SCRAP_SOURCE != "themoviedb":
|
||
return None
|
||
return self.scraper.get_metadata_img(mediainfo=mediainfo, season=season)
|
||
|
||
def tmdb_discover(self, mtype: MediaType, sort_by: str, with_genres: str, with_original_language: str,
|
||
page: int = 1) -> Optional[List[MediaInfo]]:
|
||
"""
|
||
:param mtype: 媒体类型
|
||
:param sort_by: 排序方式
|
||
:param with_genres: 类型
|
||
:param with_original_language: 语言
|
||
:param page: 页码
|
||
:return: 媒体信息列表
|
||
"""
|
||
if mtype == MediaType.MOVIE:
|
||
infos = self.tmdb.discover_movies(sort_by=sort_by,
|
||
with_genres=with_genres,
|
||
with_original_language=with_original_language,
|
||
page=page)
|
||
elif mtype == MediaType.TV:
|
||
infos = self.tmdb.discover_tvs(sort_by=sort_by,
|
||
with_genres=with_genres,
|
||
with_original_language=with_original_language,
|
||
page=page)
|
||
else:
|
||
return []
|
||
if infos:
|
||
return [MediaInfo(tmdb_info=info) for info in infos]
|
||
return []
|
||
|
||
def tmdb_trending(self, page: int = 1) -> List[MediaInfo]:
|
||
"""
|
||
TMDB流行趋势
|
||
:param page: 第几页
|
||
:return: TMDB信息列表
|
||
"""
|
||
trending = self.tmdb.trending.all_week(page=page)
|
||
if trending:
|
||
return [MediaInfo(tmdb_info=info) for info in trending]
|
||
return []
|
||
|
||
def tmdb_seasons(self, tmdbid: int) -> List[schemas.TmdbSeason]:
|
||
"""
|
||
根据TMDBID查询themoviedb所有季信息
|
||
:param tmdbid: TMDBID
|
||
"""
|
||
tmdb_info = self.tmdb.get_info(tmdbid=tmdbid, mtype=MediaType.TV)
|
||
if not tmdb_info:
|
||
return []
|
||
return [schemas.TmdbSeason(**season)
|
||
for season in tmdb_info.get("seasons", []) if season.get("season_number")]
|
||
|
||
def tmdb_episodes(self, tmdbid: int, season: int) -> List[schemas.TmdbEpisode]:
|
||
"""
|
||
根据TMDBID查询某季的所有信信息
|
||
:param tmdbid: TMDBID
|
||
:param season: 季
|
||
"""
|
||
season_info = self.tmdb.get_tv_season_detail(tmdbid=tmdbid, season=season)
|
||
if not season_info or not season_info.get("episodes"):
|
||
return []
|
||
return [schemas.TmdbEpisode(**episode) for episode in season_info.get("episodes")]
|
||
|
||
def scheduler_job(self) -> None:
|
||
"""
|
||
定时任务，每10分钟调用一次
|
||
"""
|
||
self.cache.save()
|
||
|
||
def obtain_images(self, mediainfo: MediaInfo) -> Optional[MediaInfo]:
|
||
"""
|
||
补充抓取媒体信息图片
|
||
:param mediainfo: 识别的媒体信息
|
||
:return: 更新后的媒体信息
|
||
"""
|
||
if settings.RECOGNIZE_SOURCE != "themoviedb":
|
||
return None
|
||
if not mediainfo.tmdb_id:
|
||
return mediainfo
|
||
if mediainfo.logo_path \
|
||
and mediainfo.poster_path \
|
||
and mediainfo.backdrop_path:
|
||
# 没有图片缺失
|
||
return mediainfo
|
||
# 调用TMDB图片接口
|
||
if mediainfo.type == MediaType.MOVIE:
|
||
images = self.tmdb.get_movie_images(mediainfo.tmdb_id)
|
||
else:
|
||
images = self.tmdb.get_tv_images(mediainfo.tmdb_id)
|
||
if not images:
|
||
return mediainfo
|
||
if isinstance(images, list):
|
||
images = images[0]
|
||
# 背景图
|
||
if not mediainfo.backdrop_path:
|
||
backdrops = images.get("backdrops")
|
||
if backdrops:
|
||
backdrops = sorted(backdrops, key=lambda x: x.get("vote_average"), reverse=True)
|
||
mediainfo.backdrop_path = backdrops[0].get("file_path")
|
||
# 标志
|
||
if not mediainfo.logo_path:
|
||
logos = images.get("logos")
|
||
if logos:
|
||
logos = sorted(logos, key=lambda x: x.get("vote_average"), reverse=True)
|
||
mediainfo.logo_path = logos[0].get("file_path")
|
||
# 海报
|
||
if not mediainfo.poster_path:
|
||
posters = images.get("posters")
|
||
if posters:
|
||
posters = sorted(posters, key=lambda x: x.get("vote_average"), reverse=True)
|
||
mediainfo.poster_path = posters[0].get("file_path")
|
||
return mediainfo
|
||
|
||
def obtain_specific_image(self, mediaid: Union[str, int], mtype: MediaType,
|
||
image_type: MediaImageType, image_prefix: str = "w500",
|
||
season: int = None, episode: int = None) -> Optional[str]:
|
||
"""
|
||
获取指定媒体信息图片，返回图片地址
|
||
:param mediaid: 媒体ID
|
||
:param mtype: 媒体类型
|
||
:param image_type: 图片类型
|
||
:param image_prefix: 图片前缀
|
||
:param season: 季
|
||
:param episode: 集
|
||
"""
|
||
if not str(mediaid).isdigit():
|
||
return None
|
||
# 图片相对路径
|
||
image_path = None
|
||
image_prefix = image_prefix or "w500"
|
||
if season is None and not episode:
|
||
tmdbinfo = self.tmdb.get_info(mtype=mtype, tmdbid=int(mediaid))
|
||
if tmdbinfo:
|
||
image_path = tmdbinfo.get(image_type.value)
|
||
elif season is not None and episode:
|
||
episodeinfo = self.tmdb.get_tv_episode_detail(tmdbid=int(mediaid), season=season, episode=episode)
|
||
if episodeinfo:
|
||
image_path = episodeinfo.get("still_path")
|
||
elif season is not None:
|
||
seasoninfo = self.tmdb.get_tv_season_detail(tmdbid=int(mediaid), season=season)
|
||
if seasoninfo:
|
||
image_path = seasoninfo.get(image_type.value)
|
||
|
||
if image_path:
|
||
return f"https://{settings.TMDB_IMAGE_DOMAIN}/t/p/{image_prefix}{image_path}"
|
||
return None
|
||
|
||
def tmdb_movie_similar(self, tmdbid: int) -> List[MediaInfo]:
|
||
"""
|
||
根据TMDBID查询类似电影
|
||
:param tmdbid: TMDBID
|
||
"""
|
||
similar = self.tmdb.get_movie_similar(tmdbid=tmdbid)
|
||
if similar:
|
||
return [MediaInfo(tmdb_info=info) for info in similar]
|
||
return []
|
||
|
||
def tmdb_tv_similar(self, tmdbid: int) -> List[MediaInfo]:
|
||
"""
|
||
根据TMDBID查询类似电视剧
|
||
:param tmdbid: TMDBID
|
||
"""
|
||
similar = self.tmdb.get_tv_similar(tmdbid=tmdbid)
|
||
if similar:
|
||
return [MediaInfo(tmdb_info=info) for info in similar]
|
||
return []
|
||
|
||
def tmdb_movie_recommend(self, tmdbid: int) -> List[MediaInfo]:
|
||
"""
|
||
根据TMDBID查询推荐电影
|
||
:param tmdbid: TMDBID
|
||
"""
|
||
recommend = self.tmdb.get_movie_recommend(tmdbid=tmdbid)
|
||
if recommend:
|
||
return [MediaInfo(tmdb_info=info) for info in recommend]
|
||
return []
|
||
|
||
def tmdb_tv_recommend(self, tmdbid: int) -> List[MediaInfo]:
|
||
"""
|
||
根据TMDBID查询推荐电视剧
|
||
:param tmdbid: TMDBID
|
||
"""
|
||
recommend = self.tmdb.get_tv_recommend(tmdbid=tmdbid)
|
||
if recommend:
|
||
return [MediaInfo(tmdb_info=info) for info in recommend]
|
||
return []
|
||
|
||
def tmdb_movie_credits(self, tmdbid: int, page: int = 1) -> List[schemas.MediaPerson]:
|
||
"""
|
||
根据TMDBID查询电影演职员表
|
||
:param tmdbid: TMDBID
|
||
:param page: 页码
|
||
"""
|
||
credit_infos = self.tmdb.get_movie_credits(tmdbid=tmdbid, page=page)
|
||
if credit_infos:
|
||
return [schemas.MediaPerson(source="themoviedb", **info) for info in credit_infos]
|
||
return []
|
||
|
||
def tmdb_tv_credits(self, tmdbid: int, page: int = 1) -> List[schemas.MediaPerson]:
|
||
"""
|
||
根据TMDBID查询电视剧演职员表
|
||
:param tmdbid: TMDBID
|
||
:param page: 页码
|
||
"""
|
||
credit_infos = self.tmdb.get_tv_credits(tmdbid=tmdbid, page=page)
|
||
if credit_infos:
|
||
return [schemas.MediaPerson(source="themoviedb", **info) for info in credit_infos]
|
||
return []
|
||
|
||
def tmdb_person_detail(self, person_id: int) -> schemas.MediaPerson:
|
||
"""
|
||
根据TMDBID查询人物详情
|
||
:param person_id: 人物ID
|
||
"""
|
||
detail = self.tmdb.get_person_detail(person_id=person_id)
|
||
if detail:
|
||
return schemas.MediaPerson(source="themoviedb", **detail)
|
||
return schemas.MediaPerson()
|
||
|
||
def tmdb_person_credits(self, person_id: int, page: int = 1) -> List[MediaInfo]:
|
||
"""
|
||
根据TMDBID查询人物参演作品
|
||
:param person_id: 人物ID
|
||
:param page: 页码
|
||
"""
|
||
infos = self.tmdb.get_person_credits(person_id=person_id, page=page)
|
||
if infos:
|
||
return [MediaInfo(tmdb_info=tmdbinfo) for tmdbinfo in infos]
|
||
return []
|
||
|
||
def clear_cache(self):
|
||
"""
|
||
清除缓存
|
||
"""
|
||
logger.info("开始清除TMDB缓存 ...")
|
||
self.tmdb.clear_cache()
|
||
self.cache.clear()
|
||
logger.info("TMDB缓存清除完成")
|