Update test

重写rename，更容易修改

src/module/manager/renamer.py

@@ -48,7 +48,7 @@ class Renamer:
         suffix = os.path.splitext(media_path)[-1]
         compare_name = media_path.split(os.path.sep)[-1]
         folder_name, season = self.get_folder_and_season(info.save_path)
-        new_path = self._renamer.download_parser(old_name, folder_name, season, suffix)
+        new_path = self._renamer.torrent_parser(old_name, folder_name, season, suffix)
         if compare_name != new_path:
             try:
                 self.client.rename_torrent_file(_hash=info.hash, old_path=media_path, new_path=new_path)
@@ -68,7 +68,7 @@ class Renamer:
             if path_len <= 2:
                 suffix = os.path.splitext(media_path)[-1]
                 old_name = media_path.split(os.path.sep)[-1]
-                new_name = self._renamer.download_parser(old_name, folder_name, season, suffix)
+                new_name = self._renamer.torrent_parser(old_name, folder_name, season, suffix)
                 if old_name != new_name:
                     try:
                         self.client.rename_torrent_file(_hash=_hash, old_path=media_path, new_path=new_name)
@@ -80,13 +80,18 @@ class Renamer:
                         self.delete_bad_torrent(info)
         self.client.set_category(category="BangumiCollection", hashes=_hash)
 
-    def rename_subtitles(self, subtitle_list: list[str], media_old_name, media_new_name, _hash):
-        for subtitle_file in subtitle_list:
-            if re.search(media_old_name, subtitle_file) is not None:
-                subtitle_lang = subtitle_file.split(".")[-2]
-                new_subtitle_name = f"{media_new_name}.{subtitle_lang}.ass"
-                self.client.rename_torrent_file(_hash, subtitle_file, new_subtitle_name)
-                logger.info(f"Rename subtitles for {media_old_name} to {media_new_name}")
+    def rename_subtitles(self, subtitle_list: list[str], _hash):
+        for subtitle_path in subtitle_list:
+            suffix = os.path.splitext(subtitle_path)[-1]
+            old_name = subtitle_path.split(os.path.sep)[-1]
+            new_name = self._renamer.torrent_parser(old_name, suffix)
+            if old_name != new_name:
+                try:
+                    self.client.rename_torrent_file(_hash=_hash, old_path=subtitle_path, new_path=new_name)
+                except Exception as e:
+                    logger.warning(f"{old_name} rename failed")
+                    logger.warning(f"Suffix: {suffix}")
+                    logger.debug(e)
 
     def delete_bad_torrent(self, info):
         if settings.bangumi_manage.remove_bad_torrent:
@@ -137,4 +142,3 @@ if __name__ == '__main__':
     client = DownloadClient()
     rn = Renamer(client)
     rn.rename()
-

src/module/models/torrent.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel, Field
+
+
+class TorrentInfo(BaseModel):
+    name: str = Field(...)
+    link: str = Field(...)
+
+
+class FileSet(BaseModel):
+    media_path: str = Field(...)
+    sc_subtitle: str | None = Field(None)
+    tc_subtitle: str | None = Field(None)

src/module/parser/analyser/__init__.py

@@ -1,4 +1,4 @@
 from .raw_parser import raw_parser
-from .rename_parser import DownloadParser
+from .rename_parser import torrent_parser
 from .tmdb_parser import TMDBMatcher
 

src/module/parser/analyser/rename_parser.py

@@ -2,10 +2,8 @@ import re
 import logging
 from dataclasses import dataclass
 
-
 logger = logging.getLogger(__name__)
 
-
 @dataclass
 class DownloadInfo:
     name: str
@@ -26,91 +24,91 @@ RULES = [
 ]
 
 
-class DownloadParser:
-    def __init__(self):
-        self.method_dict = {
-            "normal": self.rename_normal,
-            "pn": self.rename_pn,
-            "advance": self.rename_advance,
-            "no_season_pn": self.rename_no_season_pn,
-            "none": self.rename_none
-        }
+def rename_init(name, folder_name, season, suffix) -> DownloadInfo:
+    n = re.split(r"[\[\]()【】（）]", name)
+    suffix = suffix if suffix else n[-1]
+    if len(n) > 1:
+        file_name = name.replace(f"[{n[1]}]", "")
+    else:
+        file_name = name
+    if season < 10:
+        season = f"0{season}"
+    return DownloadInfo(name, season, suffix, file_name, folder_name)
 
 
-    @staticmethod
-    def rename_init(name, folder_name, season, suffix) -> DownloadInfo:
-        n = re.split(r"[\[\]()【】（）]", name)
-        suffix = suffix if suffix else n[-1]
-        if len(n) > 1:
-            file_name = name.replace(f"[{n[1]}]", "")
-        else:
-            file_name = name
-        if season < 10:
-            season = f"0{season}"
-        return DownloadInfo(name, season, suffix, file_name, folder_name)
+def rename_normal(info: DownloadInfo):
+    for rule in RULES:
+        match_obj = re.match(rule, info.name, re.I)
+        if match_obj is not None:
+            title = re.sub(r"([Ss]|Season )\d{1,3}", "", match_obj.group(1)).strip()
+            new_name = f"{title} S{info.season}E{match_obj.group(2)}{match_obj.group(3)}"
+            return new_name
 
-    def rename_normal(self, info: DownloadInfo):
-        for rule in RULES:
-            match_obj = re.match(rule, info.name, re.I)
-            if match_obj is not None:
-                title = re.sub(r"([Ss]|Season )\d{1,3}", "", match_obj.group(1)).strip()
-                new_name = f"{title} S{info.season}E{match_obj.group(2)}{match_obj.group(3)}"
-                return new_name
 
-    def rename_pn(self, info: DownloadInfo):
-        for rule in RULES:
-            match_obj = re.match(rule, info.file_name, re.I)
-            if match_obj is not None:
-                title = re.sub(r"([Ss]|Season )\d{1,3}", "", match_obj.group(1)).strip()
-                title = title if title != "" else info.folder_name
-                new_name = re.sub(
-                    r"[\[\]]",
-                    "",
-                    f"{title} S{info.season}E{match_obj.group(2)}{info.suffix}",
-                )
-                return new_name
+def rename_pn(info: DownloadInfo):
+    for rule in RULES:
+        match_obj = re.match(rule, info.file_name, re.I)
+        if match_obj is not None:
+            title = re.sub(r"([Ss]|Season )\d{1,3}", "", match_obj.group(1)).strip()
+            title = title if title != "" else info.folder_name
+            new_name = re.sub(
+                r"[\[\]]",
+                "",
+                f"{title} S{info.season}E{match_obj.group(2)}{info.suffix}",
+            )
+            return new_name
 
-    def rename_advance(self, info: DownloadInfo):
-        for rule in RULES:
-            match_obj = re.match(rule, info.file_name, re.I)
-            if match_obj is not None:
-                new_name = re.sub(
-                    r"[\[\]]",
-                    "",
-                    f"{info.folder_name} S{info.season}E{match_obj.group(2)}{info.suffix}",
-                )
-                return new_name
 
-    def rename_no_season_pn(self, info: DownloadInfo):
-        for rule in RULES:
-            match_obj = re.match(rule, info.file_name, re.I)
-            if match_obj is not None:
-                title = match_obj.group(1).strip()
-                new_name = re.sub(
-                    r"[\[\]]",
-                    "",
-                    f"{title} E{match_obj.group(2)}{info.suffix}",
-                )
-                return new_name
+def rename_advance(info: DownloadInfo):
+    for rule in RULES:
+        match_obj = re.match(rule, info.file_name, re.I)
+        if match_obj is not None:
+            new_name = re.sub(
+                r"[\[\]]",
+                "",
+                f"{info.folder_name} S{info.season}E{match_obj.group(2)}{info.suffix}",
+            )
+            return new_name
 
-    @staticmethod
-    def rename_none(info: DownloadInfo):
-        return info.name
 
-    def download_rename(
-            self,
-            name: str,
-            folder_name,
-            season,
-            suffix,
-            method
-    ):
-        rename_info = self.rename_init(name, folder_name, season, suffix)
-        return self.method_dict[method.lower()](rename_info)
+def rename_no_season_pn(info: DownloadInfo):
+    for rule in RULES:
+        match_obj = re.match(rule, info.file_name, re.I)
+        if match_obj is not None:
+            title = match_obj.group(1).strip()
+            new_name = re.sub(
+                r"[\[\]]",
+                "",
+                f"{title} E{match_obj.group(2)}{info.suffix}",
+            )
+            return new_name
+
+
+def rename_none(info: DownloadInfo):
+    return info.name
+
+
+METHODS = {
+    "normal": rename_normal,
+    "pn": rename_pn,
+    "advance": rename_advance,
+    "no_season_pn": rename_no_season_pn,
+    "none": rename_none
+}
+
+
+def torrent_parser(
+        file_name: str,
+        folder_name: str,
+        season: int,
+        suffix: str,
+        method: str = "pn",
+):
+    info = rename_init(file_name, folder_name, season, suffix)
+    return METHODS[method.lower()](info)
 
 
 if __name__ == "__main__":
     name = "[Lilith-Raws] Tate no Yuusha no Nariagari S02 - 02 [Baha][WEB-DL][1080p][AVC AAC][CHT][MP4]"
-    rename = DownloadParser()
-    new_name = rename.download_rename(name, "异世界舅舅（2022）", 1, ".mp4", "normal")
+    new_name = torrent_parser(name, "异世界舅舅（2022）", 2, ".mp4", "advance")
     print(new_name)

src/module/parser/title_parser.py

@@ -1,6 +1,6 @@
 import logging
 
-from .analyser import raw_parser, DownloadParser, TMDBMatcher
+from .analyser import raw_parser, torrent_parser, TMDBMatcher
 
 from module.conf import settings
 from module.models import BangumiData
@@ -11,18 +11,17 @@ LANGUAGE = settings.rss_parser.language
 
 class TitleParser:
     def __init__(self):
-        self._download_parser = DownloadParser()
         self._tmdb_parser = TMDBMatcher()
 
-    def download_parser(
-            self,
+    @staticmethod
+    def torrent_parser(
             download_raw: str,
             folder_name: str | None = None,
             season: int | None = None,
             suffix: str | None = None,
             method: str = settings.bangumi_manage.rename_method
     ):
-        return self._download_parser.download_rename(download_raw, folder_name, season, suffix, method)
+        return torrent_parser(download_raw, folder_name, season, suffix, method)
 
     def tmdb_parser(self, title: str, season: int):
 

src/test/__init__.py

@@ -1 +0,0 @@
-import module

src/test/test_torrent_parser.py

@@ -0,0 +1,24 @@
+from module.parser.analyser import torrent_parser
+
+
+def test_torrent_parser():
+    file_name = "[Lilith-Raws] Boku no Kokoro no Yabai Yatsu - 01 [Baha][WEB-DL][1080p][AVC AAC][CHT][MP4].mp4"
+    folder_name = "我内心的糟糕念头(2023)"
+    season = 1
+    suffix = ".mp4"
+    assert torrent_parser(file_name, folder_name, season, suffix, "pn") == "Boku no Kokoro no Yabai Yatsu S01E01.mp4"
+    assert torrent_parser(file_name, folder_name, season, suffix, "advance") == "我内心的糟糕念头(2023) S01E01.mp4"
+
+    file_name = "[Sakurato] Tonikaku Kawaii S2 [01][AVC-8bit 1080p AAC][CHS].mp4"
+    folder_name = "总之就是非常可爱(2021)"
+    season = 2
+    suffix = ".mp4"
+    assert torrent_parser(file_name, folder_name, season, suffix, "pn") == "Tonikaku Kawaii S02E01.mp4"
+    assert torrent_parser(file_name, folder_name, season, suffix, "advance") == "总之就是非常可爱(2021) S02E01.mp4"
+
+    file_name = "[SweetSub&LoliHouse] Heavenly Delusion - 01 [WebRip 1080p HEVC-10bit AAC ASSx2].mkv"
+    folder_name = "天国大魔境(2023)"
+    season = 1
+    suffix = ".mkv"
+    assert torrent_parser(file_name, folder_name, season, suffix, "pn") == "Heavenly Delusion S01E01.mkv"
+    assert torrent_parser(file_name, folder_name, season, suffix, "advance") == "天国大魔境(2023) S01E01.mkv"