From 8f548d8cf84769393d295a04ec7992552738bbc4 Mon Sep 17 00:00:00 2001 From: EstrellaXD Date: Fri, 19 May 2023 17:10:37 +0800 Subject: [PATCH] Refactor eps complete. Fix api bugs. Add new module to parse path problem --- src/module/api/download.py | 16 +-- src/module/core/sub_thread.py | 10 +- src/module/database/bangumi.py | 31 +++++- src/module/downloader/download_client.py | 44 +++----- src/module/downloader/path.py | 68 ++++++++++++ src/module/manager/__init__.py | 2 +- src/module/manager/collector.py | 55 ++++++++++ src/module/manager/eps_complete.py | 84 --------------- src/module/manager/renamer.py | 132 +++++++---------------- src/module/manager/repath.py | 35 ------ src/module/manager/torrent.py | 34 +++--- src/module/parser/title_parser.py | 3 +- src/module/rss/__init__.py | 5 +- src/module/rss/rss_analyser.py | 13 +-- src/module/searcher/plugin/mikan.py | 2 +- src/module/searcher/searcher.py | 17 ++- 16 files changed, 256 insertions(+), 295 deletions(-) create mode 100644 src/module/downloader/path.py create mode 100644 src/module/manager/collector.py delete mode 100644 src/module/manager/eps_complete.py delete mode 100644 src/module/manager/repath.py diff --git a/src/module/api/download.py b/src/module/api/download.py index 66b81b3f..6d90aeac 100644 --- a/src/module/api/download.py +++ b/src/module/api/download.py @@ -2,17 +2,17 @@ from .config import router from module.models.api import * from module.models import BangumiData -from module.manager import FullSeasonGet -from module.rss import RSSAnalyser +from module.manager import SeasonCollector +from module.rss import analyser def link_process(link): - return RSSAnalyser().rss_to_data(link, full_parse=False) + return analyser.rss_to_data(link, full_parse=False) @router.post("/api/v1/download/analysis", tags=["download"]) async def analysis(link: RssLink): - data = link_process(link) + data = link_process(link.rss_link) if data: return data[0] else: @@ -22,8 +22,8 @@ async def analysis(link: RssLink): @router.post("/api/v1/download/collection", tags=["download"]) async def download_collection(data: BangumiData): if data: - with FullSeasonGet() as season: - season.download_collection(data, data.rss_link) + with SeasonCollector() as collector: + collector.collect_season(data, data.rss_link[0]) return {"status": "Success"} else: return {"status": "Failed to parse link"} @@ -32,8 +32,8 @@ async def download_collection(data: BangumiData): @router.post("/api/v1/download/subscribe", tags=["download"]) async def subscribe(data: BangumiData): if data: - with FullSeasonGet() as season: - season.add_subscribe(data) + with SeasonCollector() as collector: + collector.subscribe_season(data) return {"status": "Success"} else: return {"status": "Failed to parse link"} diff --git a/src/module/core/sub_thread.py b/src/module/core/sub_thread.py index 79f877b8..9544b464 100644 --- a/src/module/core/sub_thread.py +++ b/src/module/core/sub_thread.py @@ -2,8 +2,8 @@ import threading from .status import ProgramStatus -from module.rss import RSSAnalyser, add_rules -from module.manager import Renamer, FullSeasonGet +from module.rss import analyser, add_rules +from module.manager import Renamer, eps_complete from module.conf import settings @@ -13,15 +13,13 @@ class RSSThread(ProgramStatus): self._rss_thread = threading.Thread( target=self.rss_loop, ) - self._rss_analyser = RSSAnalyser() def rss_loop(self): while not self.stop_event.is_set(): - self._rss_analyser.run() + analyser.run() add_rules() if settings.bangumi_manage.eps_complete: - with FullSeasonGet() as full_season_get: - full_season_get.eps_complete() + eps_complete() self.stop_event.wait(settings.program.rss_time) def rss_start(self): diff --git a/src/module/database/bangumi.py b/src/module/database/bangumi.py index 04538215..8c652c30 100644 --- a/src/module/database/bangumi.py +++ b/src/module/database/bangumi.py @@ -44,11 +44,18 @@ class BangumiDatabase(DataConnector): return [self.__db_to_data(x) for x in dict_data] def insert(self, data: BangumiData): - db_data = self.__data_to_db(data) - self._insert(db_data=db_data, table_name=self.__table_name) - logger.debug(f"Insert {data.official_title} into database.") + if self.__check_exist(data): + self.update_one(data) + else: + db_data = self.__data_to_db(data) + db_data["id"] = self.gen_id() + self._insert(db_data=db_data, table_name=self.__table_name) + logger.debug(f"Insert {data.official_title} into database.") def insert_list(self, data: list[BangumiData]): + _id = self.gen_id() + for i, item in enumerate(data): + item.id = _id + i data_list = [self.__data_to_db(x) for x in data] self._insert_list(data_list=data_list, table_name=self.__table_name) logger.debug(f"Insert {len(data)} bangumi into database.") @@ -208,3 +215,21 @@ class BangumiDatabase(DataConnector): if data is None: return 1 return data[0] + 1 + + def __check_exist(self, data: BangumiData): + self._cursor.execute( + """ + SELECT * FROM bangumi WHERE official_title = :official_title + """, + {"official_title": data.official_title}, + ) + values = self._cursor.fetchone() + if values is None: + return False + return True + + def __check_list_exist(self, data_list: list[BangumiData]): + for data in data_list: + if self.__check_exist(data): + return True + return False diff --git a/src/module/downloader/download_client.py b/src/module/downloader/download_client.py index 76dfcd92..4e61586b 100644 --- a/src/module/downloader/download_client.py +++ b/src/module/downloader/download_client.py @@ -1,20 +1,16 @@ -import re import logging +from .path import TorrentPath + from module.models import BangumiData from module.conf import settings - logger = logging.getLogger(__name__) -if ":\\" in settings.downloader.path: - import ntpath as path -else: - import os.path as path - -class DownloadClient: +class DownloadClient(TorrentPath): def __init__(self): + super().__init__() self.client = self.__getClient() self.authed = False @@ -62,41 +58,27 @@ class DownloadClient: logger.debug(e) if settings.downloader.path == "": prefs = self.client.get_app_prefs() - settings.downloader.path = path.join(prefs["save_path"], "Bangumi") + settings.downloader.path = self._join_path(prefs["save_path"], "Bangumi") - def set_rule(self, info: BangumiData): - official_name = f"{info.official_title}({info.year})" if info.year else info.official_title - raw_name, season, group = ( - info.title_raw, - info.season, - info.group_name, - ) + def set_rule(self, data: BangumiData): rule = { "enable": True, - "mustContain": raw_name, - "mustNotContain": "|".join(info.filter), + "mustContain": data.title_raw, + "mustNotContain": "|".join(data.filter), "useRegex": True, "episodeFilter": "", "smartFilter": False, "previouslyMatchedEpisodes": [], - "affectedFeeds": info.rss_link, + "affectedFeeds": data.rss_link, "ignoreDays": 0, "lastMatch": "", "addPaused": False, "assignedCategory": "Bangumi", - "savePath": str( - path.join( - settings.downloader.path, - re.sub(r"[:/.]", " ", official_name).strip(), - f"Season {season}", - ) - ), + "savePath": self._gen_save_path(data), } - rule_name = f"[{group}] {official_name}" \ - if settings.bangumi_manage.group_tag \ - else official_name - self.client.rss_set_rule(rule_name=f"{rule_name} S{season}", rule_def=rule) - logger.info(f"Add {official_name} Season {season} to auto download rules.") + rule_name = self._rule_name(data) + self.client.rss_set_rule(rule_name=rule_name, rule_def=rule) + logger.info(f"Add {data.official_title} Season {data.season} to auto download rules.") def add_collection_feed(self, rss_link, item_path): self.client.rss_add_feed(url=rss_link, item_path=item_path) diff --git a/src/module/downloader/path.py b/src/module/downloader/path.py new file mode 100644 index 00000000..6db55a80 --- /dev/null +++ b/src/module/downloader/path.py @@ -0,0 +1,68 @@ +import re +import logging + +from module.conf import settings +from module.models import BangumiData + +if ":\\" in settings.downloader.path: + import ntpath as path +else: + import os.path as path + +logger = logging.getLogger(__name__) + + +class TorrentPath: + def __init__(self): + self.download_path = settings.downloader.path + + @staticmethod + def check_files(info): + media_list = [] + subtitle_list = [] + for f in info.files: + file_name = f.name + suffix = path.splitext(file_name)[-1] + if suffix.lower() in [".mp4", ".mkv"]: + media_list.append(file_name) + elif suffix.lower() in [".ass", ".srt"]: + subtitle_list.append(file_name) + return media_list, subtitle_list + + def _path_to_bangumi(self, save_path): + # Split save path and download path + save_parts = save_path.split(path.sep) + download_parts = self.download_path.split(path.sep) + # Get bangumi name and season + bangumi_name = "" + season = 1 + for part in save_parts: + if re.match(r"S\d+|[Ss]eason \d+", part): + season = int(re.findall(r"\d+", part)[0]) + elif part not in download_parts: + bangumi_name = part + return bangumi_name, season + + @staticmethod + def _file_depth(path): + return len(path.split(path.sep)) + + @staticmethod + def is_ep(self, path): + return self._file_depth(path) <= 2 + + def _gen_save_path(self, data: BangumiData): + folder = f"{data.official_title}({data.year})" if data.year else data.official_title + save_path = path.join(self.download_path, folder, f"Season {data.season}") + return save_path + + @staticmethod + def _rule_name(data: BangumiData): + rule_name = f"[{data.group_name}] {data.official_title} S{data.season}" \ + if settings.bangumi_manage.group_tag \ + else f"{data.official_title} S{data.season}" + return rule_name + + @staticmethod + def _join_path(*args): + return path.join(*args) diff --git a/src/module/manager/__init__.py b/src/module/manager/__init__.py index 8c0a8561..43c2ce58 100644 --- a/src/module/manager/__init__.py +++ b/src/module/manager/__init__.py @@ -1,3 +1,3 @@ -from .eps_complete import FullSeasonGet +from .collector import SeasonCollector, eps_complete from .renamer import Renamer from .torrent import TorrentManager diff --git a/src/module/manager/collector.py b/src/module/manager/collector.py new file mode 100644 index 00000000..bbbf9b72 --- /dev/null +++ b/src/module/manager/collector.py @@ -0,0 +1,55 @@ +import logging + +from module.downloader import DownloadClient +from module.models import BangumiData +from module.database import BangumiDatabase +from module.searcher import SearchTorrent + +logger = logging.getLogger(__name__) + + +class SeasonCollector(DownloadClient): + def add_season_torrents(self, data: BangumiData, torrents): + for torrent in torrents: + download_info = { + "url": torrent.torrent_link, + "save_path": self._gen_save_path(data), + } + self.add_torrent(download_info) + + def collect_season(self, data: BangumiData, link: str = None): + logger.info(f"Start collecting {data.official_title} Season {data.season}...") + with SearchTorrent() as st: + if not link: + torrents = st.search_season(data) + else: + torrents = st.get_torrents(link) + self.add_season_torrents(data, torrents) + logger.info("Completed!") + + def subscribe_season(self, data: BangumiData): + data.added = True + data.eps_collect = True + with BangumiDatabase() as db: + db.insert(data) + self.add_rss_feed(data.rss_link[0], item_path=data.official_title) + self.set_rule(data) + + +def eps_complete(): + with BangumiDatabase() as bd: + datas = bd.not_complete() + if datas: + logger.info("Start collecting full season...") + for data in datas: + if not data.eps_collect: + with SeasonCollector() as sc: + sc.collect_season(data) + data.eps_collect = True + bd.update_list(datas) + + +if __name__ == '__main__': + from module.conf import setup_logger + setup_logger() + eps_complete() \ No newline at end of file diff --git a/src/module/manager/eps_complete.py b/src/module/manager/eps_complete.py deleted file mode 100644 index d3e2fc5b..00000000 --- a/src/module/manager/eps_complete.py +++ /dev/null @@ -1,84 +0,0 @@ -import os.path -import re -import logging - -from module.network import RequestContent -from module.downloader import DownloadClient -from module.models import BangumiData -from module.database import BangumiDatabase -from module.searcher import SearchTorrent -from module.conf import settings - -logger = logging.getLogger(__name__) -SEARCH_KEY = [ - "group_name", - "title_raw", - "season_raw", - "subtitle", - "source", - "dpi", -] - - -class FullSeasonGet(DownloadClient): - def init_search_str(self, data: BangumiData): - str_list = [] - for key in SEARCH_KEY: - data_dict = data.dict() - if data_dict[key] is not None: - str_list.append(data_dict[key]) - return str_list - - def get_season_torrents(self, data: BangumiData): - keywords = self.init_search_str(data) - with SearchTorrent() as st: - torrents = st.search_torrents(keywords) - return [torrent for torrent in torrents if data.title_raw in torrent.name] - - def collect_season(self, data: BangumiData, torrents): - official_title = f"{data.official_title}({data.year})" if data.year else data.official_title - for torrent in torrents: - download_info = { - "url": torrent.torrent_link, - "save_path": os.path.join( - settings.downloader.path, official_title, f"Season {data.season}" - ), - } - self.add_torrent(download_info) - - def download_season(self, data: BangumiData): - logger.info(f"Start collecting {data.official_title} Season {data.season}...") - torrents = self.get_season_torrents(data) - self.collect_season(data, torrents) - logger.info("Completed!") - data.eps_collect = True - - def eps_complete(self): - with BangumiDatabase() as bd: - datas = bd.not_complete() - if datas: - logger.info("Start collecting full season...") - for data in datas: - if not data.eps_collect: - self.download_season(data) - bd.update_list(datas) - - def download_collection( - self, data: BangumiData, link - ): - with RequestContent() as req: - torrents = req.get_torrents(link) - logger.info(f"Starting download {data.official_title} Season {data.season}...") - self.collect_season(data, torrents) - logger.info("Completed!") - - def add_subscribe(self, data: BangumiData): - self.add_rss_feed(data.rss_link, item_path=data.official_title) - self.set_rule(data) - - -if __name__ == '__main__': - from module.conf import setup_logger - setup_logger() - with FullSeasonGet() as full_season_get: - full_season_get.eps_complete() \ No newline at end of file diff --git a/src/module/manager/renamer.py b/src/module/manager/renamer.py index ad7a1b9b..86e49fff 100644 --- a/src/module/manager/renamer.py +++ b/src/module/manager/renamer.py @@ -1,20 +1,13 @@ -import re import logging -from pathlib import PurePath, PureWindowsPath - from module.downloader import DownloadClient from module.parser import TitleParser from module.network import PostNotification from module.models import SubtitleFile, EpisodeFile, Notification -from module.conf import settings, PLATFORM +from module.conf import settings from module.database import BangumiDatabase -if PLATFORM == "Windows": - import ntpath as path -else: - import os.path as path logger = logging.getLogger(__name__) @@ -22,7 +15,7 @@ logger = logging.getLogger(__name__) class Renamer(DownloadClient): def __init__(self): super().__init__() - self._renamer = TitleParser() + self._parser = TitleParser() @staticmethod def print_result(torrent_count, rename_count): @@ -32,24 +25,6 @@ class Renamer(DownloadClient): ) logger.debug(f"Checked {torrent_count} files") - def rename_info(self, category="Bangumi"): - recent_info = self.get_torrent_info(category=category) - torrent_count = len(recent_info) - return recent_info, torrent_count - - @staticmethod - def check_files(info): - media_list = [] - subtitle_list = [] - for f in info.files: - file_name = f.name - suffix = path.splitext(file_name)[-1] - if suffix.lower() in [".mp4", ".mkv"]: - media_list.append(file_name) - elif suffix.lower() in [".ass", ".srt"]: - subtitle_list.append(file_name) - return media_list, subtitle_list - @staticmethod def gen_path(file_info: EpisodeFile | SubtitleFile, bangumi_name: str, method: str) -> str: season = f"0{file_info.season}" if file_info.season < 10 else file_info.season @@ -91,8 +66,9 @@ class Renamer(DownloadClient): method: str, season: int, _hash: str, + **kwargs ): - ep = self._renamer.torrent_parser( + ep = self._parser.torrent_parser( torrent_name=torrent_name, torrent_path=media_path, season=season, @@ -111,17 +87,16 @@ class Renamer(DownloadClient): def rename_collection( self, - info, media_list: list[str], bangumi_name: str, season: int, method: str, + _hash: str, + **kwargs ): - _hash = info.hash for media_path in media_list: - path_len = len(media_path.split(path.sep)) - if path_len <= 2: - ep = self._renamer.torrent_parser( + if self.is_ep(media_path): + ep = self._parser.torrent_parser( torrent_path=media_path, season=season, ) @@ -146,10 +121,11 @@ class Renamer(DownloadClient): season: int, method: str, _hash, + **kwargs ): method = "subtitle_" + method for subtitle_path in subtitle_list: - sub = self._renamer.torrent_parser( + sub = self._parser.torrent_parser( torrent_path=subtitle_path, torrent_name=torrent_name, season=season, @@ -164,78 +140,42 @@ class Renamer(DownloadClient): if not renamed: logger.warning(f"{subtitle_path} rename failed") - @staticmethod - def get_season_info(save_path: str, download_path: str): - # Split save path and download path - save_parts = save_path.split(path.sep) - download_parts = download_path.split(path.sep) - # Get bangumi name and season - bangumi_name = "" - season = 1 - for part in save_parts: - if re.match(r"S\d+|[Ss]eason \d+", part): - season = int(re.findall(r"\d+", part)[0]) - elif part not in download_parts: - bangumi_name = part - return bangumi_name, season - - @staticmethod - def get_file_name(file_path: str): - # Check windows or linux path - path_parts = ( - PurePath(file_path).parts - if PurePath(file_path).name != file_path - else PureWindowsPath(file_path).parts - ) - # Get file name - file_name = path_parts[-1] - return file_name - def rename(self): # Get torrent info logger.debug("Start rename process.") - download_path = settings.downloader.path rename_method = settings.bangumi_manage.rename_method - recent_info, torrent_count = self.rename_info() - for info in recent_info: + torrents_info = self.get_torrent_info() + for info in torrents_info: media_list, subtitle_list = self.check_files(info) - bangumi_name, season = self.get_season_info(info.save_path, download_path) + bangumi_name, season = self._path_to_bangumi(info.save_path) + kwargs = { + "torrent_name": info.name, + "bangumi_name": bangumi_name, + "method": rename_method, + "season": season, + "_hash": info.hash, + } + # Rename single media file if len(media_list) == 1: - self.rename_file( - media_path=media_list[0], - torrent_name=info.name, - method=rename_method, - bangumi_name=bangumi_name, - season=season, - _hash=info.hash, - ) + self.rename_file(media_path=media_list[0], **kwargs) + # Rename subtitle file if len(subtitle_list) > 0: - self.rename_subtitles( - subtitle_list=subtitle_list, - torrent_name=info.name, - bangumi_name=bangumi_name, - season=season, - method=rename_method, - _hash=info.hash, - ) + self.rename_subtitles(subtitle_list=subtitle_list, **kwargs) + # Rename collection elif len(media_list) > 1: logger.info("Start rename collection") - self.rename_collection( - info=info, - media_list=media_list, - bangumi_name=bangumi_name, - season=season, - method=rename_method, - ) + self.rename_collection(media_list=media_list, **kwargs) if len(subtitle_list) > 0: - self.rename_subtitles( - subtitle_list=subtitle_list, - torrent_name=info.name, - bangumi_name=bangumi_name, - season=season, - method=rename_method, - _hash=info.hash, - ) + self.rename_subtitles(subtitle_list=subtitle_list,**kwargs) + self.set_category(info.hash, "BangumiCollection") else: logger.warning(f"{info.name} has no media file") logger.debug("Rename process finished.") + + +if __name__ == '__main__': + from module.conf import setup_logger + settings.log.debug_enable = True + setup_logger() + with Renamer() as renamer: + renamer.rename() diff --git a/src/module/manager/repath.py b/src/module/manager/repath.py deleted file mode 100644 index ce6b245e..00000000 --- a/src/module/manager/repath.py +++ /dev/null @@ -1,35 +0,0 @@ -import logging - -from module.downloader import DownloadClient -from module.conf import settings -from module.models import BangumiData - -logger = logging.getLogger(__name__) - - -def __gen_path(data: BangumiData): - download_path = settings.downloader.path - if ":\\" in download_path: - import ntpath as path - else: - import os.path as path - folder = f"{data.official_title}({data.year})" if data.year else data.official_title - path = path.join(download_path, folder, f"Season {data.season}") - return path - - -def match_torrents_list(title_raw: str) -> list: - with DownloadClient() as client: - torrents = client.get_torrent_info() - return [torrent.hash for torrent in torrents if title_raw in torrent.name] - - -def set_new_path(data: BangumiData): - with DownloadClient() as client: - # set download rule - client.set_rule(data) - # set torrent path - match_list = match_torrents_list(data.title_raw) - path = __gen_path(data) - client.move_torrent(match_list, path) - diff --git a/src/module/manager/torrent.py b/src/module/manager/torrent.py index 3d90d291..b6872823 100644 --- a/src/module/manager/torrent.py +++ b/src/module/manager/torrent.py @@ -4,41 +4,35 @@ from module.downloader import DownloadClient from module.conf import settings from module.models import BangumiData + logger = logging.getLogger(__name__) class TorrentManager(DownloadClient): - @staticmethod - def __gen_path(data: BangumiData): - download_path = settings.downloader.path - if ":\\" in download_path: - import ntpath as path - else: - import os.path as path - folder = f"{data.official_title}({data.year})" if data.year else data.official_title - path = path.join(download_path, folder, f"Season {data.season}") - return path - - @staticmethod - def __match_torrents_list(title_raw: str) -> list: - with DownloadClient() as client: - torrents = client.get_torrent_info() - return [torrent.hash for torrent in torrents if title_raw in torrent.name] + def __match_torrents_list(self, data: BangumiData) -> list: + torrents = self.get_torrent_info() + matched_list = [] + for torrent in torrents: + save_path = torrent.save_path + bangumi_name, season = self._path_to_bangumi(save_path) + if data.official_title in bangumi_name and data.season == season: + matched_list.append(torrent.hash) + return matched_list def delete_bangumi(self, data: BangumiData): - hash_list = self.__match_torrents_list(data.title_raw) + hash_list = self.__match_torrents_list(data) self.delete_torrent(hash_list) def delete_rule(self, data: BangumiData): rule_name = f"{data.official_title}({data.year})" if data.year else data.title_raw if settings.bangumi_manage.group_tag: - rule_name = f"[{data.group_name}] {rule_name}" if settings.bangumi_manage.group_tag else rule_name + rule_name = f"[{data.group_name}] {rule_name}" self.remove_rule(rule_name) def set_new_path(self, data: BangumiData): # set download rule self.set_rule(data) # set torrent path - match_list = self.__match_torrents_list(data.title_raw) - path = self.__gen_path(data) + match_list = self.__match_torrents_list(data) + path = self._gen_save_path(data) self.move_torrent(match_list, path) diff --git a/src/module/parser/title_parser.py b/src/module/parser/title_parser.py index ea239352..bb5e37b9 100644 --- a/src/module/parser/title_parser.py +++ b/src/module/parser/title_parser.py @@ -39,7 +39,7 @@ class TitleParser: return official_title, tmdb_season, year @staticmethod - def raw_parser(raw: str, rss_link: str, _id: int = 0) -> BangumiData: + def raw_parser(raw: str, rss_link: str) -> BangumiData: language = settings.rss_parser.language try: episode = raw_parser(raw) @@ -52,7 +52,6 @@ class TitleParser: official_title = titles[language] if titles[language] else titles["zh"] _season = episode.season data = BangumiData( - id=_id, official_title=official_title, title_raw=title_raw, season=_season, diff --git a/src/module/rss/__init__.py b/src/module/rss/__init__.py index ba5f1ec0..220d4319 100644 --- a/src/module/rss/__init__.py +++ b/src/module/rss/__init__.py @@ -1,2 +1,5 @@ from .rss_analyser import RSSAnalyser -from .add_rules import add_rules \ No newline at end of file +from .add_rules import add_rules + + +analyser = RSSAnalyser() \ No newline at end of file diff --git a/src/module/rss/rss_analyser.py b/src/module/rss/rss_analyser.py index 2e491795..a2e59845 100644 --- a/src/module/rss/rss_analyser.py +++ b/src/module/rss/rss_analyser.py @@ -1,3 +1,4 @@ +import re import logging from module.network import RequestContent @@ -29,6 +30,7 @@ class RSSAnalyser: data.season = season else: pass + data.official_title = re.sub(r"[/:.\\]", " ", data.official_title) @staticmethod def get_rss_torrents(rss_link: str, full_parse: bool = True) -> list: @@ -39,11 +41,11 @@ class RSSAnalyser: rss_torrents = req.get_torrents(rss_link, "\\d+-\\d+") return rss_torrents - def get_new_data_list(self, torrents: list, rss_link: str, _id: int, full_parse: bool = True) -> list: + def new_bangumi_list(self, torrents: list, rss_link: str, full_parse: bool = True) -> list: new_data = [] for torrent in torrents: data = self._title_analyser.raw_parser( - raw=torrent.name, rss_link=rss_link, _id=_id + raw=torrent.name, rss_link=rss_link ) if data and data.title_raw not in [i.title_raw for i in new_data]: try: @@ -55,7 +57,6 @@ class RSSAnalyser: if not full_parse: return [data] new_data.append(data) - _id += 1 logger.debug(f"New title found: {data.official_title}") return new_data @@ -66,10 +67,10 @@ class RSSAnalyser: if not torrents_to_add: logger.debug("No new title found.") return [] - _id = database.gen_id() # New List - new_data = self.get_new_data_list(torrents_to_add, rss_link, _id, full_parse) - database.insert_list(new_data) + new_data = self.new_bangumi_list(torrents_to_add, rss_link, full_parse) + if full_parse: + database.insert_list(new_data) return new_data def run(self, rss_link: str = settings.rss_link): diff --git a/src/module/searcher/plugin/mikan.py b/src/module/searcher/plugin/mikan.py index 72e651f3..28384501 100644 --- a/src/module/searcher/plugin/mikan.py +++ b/src/module/searcher/plugin/mikan.py @@ -6,7 +6,7 @@ from module.conf import settings def mikan_url(keywords: list[str]): keyword = "+".join(keywords) search_str = re.sub(r"[\W_ ]", "+", keyword) - url = f"{settings.rss_parser.custom_url}/RSS/Search?searchstr={'%20'.join(search_str)}" + url = f"{settings.rss_parser.custom_url}/RSS/Search?searchstr={search_str}" if "://" not in url: url = f"https://{url}" return url diff --git a/src/module/searcher/searcher.py b/src/module/searcher/searcher.py index e4225c37..bd653425 100644 --- a/src/module/searcher/searcher.py +++ b/src/module/searcher/searcher.py @@ -1,8 +1,23 @@ from .plugin import search_url from module.network import RequestContent +from module.models import BangumiData + +SEARCH_KEY = [ + "group_name", + "title_raw", + "season_raw", + "subtitle", + "source", + "dpi", +] class SearchTorrent(RequestContent): def search_torrents(self, keywords: list[str], site: str = "mikan") -> list: url = search_url(site, keywords) - return self.get_torrents(url) \ No newline at end of file + return self.get_torrents(url) + + def search_season(self, data: BangumiData): + keywords = [getattr(data, key) for key in SEARCH_KEY if getattr(data, key)] + torrents = self.search_torrents(keywords) + return [torrent for torrent in torrents if data.title_raw in torrent.name] \ No newline at end of file