easyrip 4.11.3__tar.gz → 4.13.0__tar.gz

{easyrip-4.11.3 → easyrip-4.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: easyrip
-Version: 4.11.3
+Version: 4.13.0
 Author: op200
 License-Expression: AGPL-3.0-or-later
 Project-URL: Homepage, https://github.com/op200/EasyRip

{easyrip-4.11.3 → easyrip-4.13.0}/easyrip/__init__.py

@@ -7,13 +7,7 @@ from .easyrip_main import (
     init,
     run_command,
 )
-from .easyrip_mlang import (
-    Global_lang_val,
-    Lang_tag,
-    Lang_tag_language,
-    Lang_tag_region,
-    Lang_tag_script,
-)
+from .easyrip_mlang import Global_lang_val, Lang_tag
 from .ripper.media_info import Media_info
 from .ripper.ripper import Ripper
 from .ripper.sub_and_font import Ass, Font, load_fonts
@@ -23,9 +17,6 @@ __all__ = [
     "Font",
     "Global_lang_val",
     "Lang_tag",
-    "Lang_tag_language",
-    "Lang_tag_region",
-    "Lang_tag_script",
     "Media_info",
     "Ripper",
     "check_env",

{easyrip-4.11.3 → easyrip-4.13.0}/easyrip/__main__.py

@@ -74,6 +74,7 @@ def run() -> NoReturn:
                                 in {
                                     *Cmd_type.cd.value.names,
                                     *Cmd_type.mediainfo.value.names,
+                                    *Cmd_type.assinfo.value.names,
                                     *Cmd_type.fontinfo.value.names,
                                 }
                                 else ()
@@ -98,6 +99,7 @@ def run() -> NoReturn:
                     *Opt_type._i.value.names,
                     *Opt_type._o_dir.value.names,
                     *Opt_type._o.value.names,
+                    *Opt_type._pipe.value.names,
                     *Opt_type._sub.value.names,
                     *Opt_type._only_mux_sub_path.value.names,
                     *Opt_type._soft_sub.value.names,
@@ -141,7 +143,7 @@ def run() -> NoReturn:
 
         try:
             if not run_command(command):
-                log.warning("Stop run command")
+                log.warning("Command run terminated")
         except KeyboardInterrupt:
             log.warning("Manually stop run command")
 

{easyrip-4.11.3 → easyrip-4.13.0}/easyrip/easyrip_command.py

@@ -18,7 +18,7 @@ from prompt_toolkit.document import Document
 
 from . import global_val
 from .easyrip_config.config_key import Config_key
-from .ripper.param import PRESET_OPT_NAME, Audio_codec, Preset_name
+from .ripper.param import Audio_codec, Muxer, Preset_name
 
 
 @final
@@ -268,7 +268,6 @@ class Cmd_type(enum.Enum):
             "Translate subtitle files\n"
             "e.g. 'translate zh-Hans zh-Hant' will translate all '*.zh-Hans.ass' files into zh-Hant"
         ),
-        childs=(Cmd_type_val(("-overwrite",)),),
     )
     mediainfo = Cmd_type_val(
         ("mediainfo",),
@@ -279,6 +278,15 @@ class Cmd_type(enum.Enum):
             Cmd_type_val(("cfd",)),
         ),
     )
+    assinfo = Cmd_type_val(
+        ("assinfo",),
+        param="<<path> | 'fd' | 'cfd'> [-use-libass-spec <0|1>] [-show-chars-len <0|1>]",
+        description="Get the ass info by the Ass class",
+        childs=(
+            Cmd_type_val(("fd",)),
+            Cmd_type_val(("cfd",)),
+        ),
+    )
     fontinfo = Cmd_type_val(
         ("fontinfo",),
         param="<<path> | 'fd' | 'cfd'>",
@@ -353,7 +361,8 @@ class Opt_type(enum.Enum):
         param="<string>",
         description=(
             "Setting preset\n"
-            "Preset name:\n"  # .
+            "\n"  # .
+            "Preset name:\n"
             f"{Preset_name.to_help_string('  ')}"
         ),
         childs=(Cmd_type_val(tuple(Preset_name._value2member_map_)),),
@@ -442,7 +451,7 @@ class Opt_type(enum.Enum):
             'e.g. "11\\{22}33" ->\n'
             '  "11\\33"   (VSFilter)\n'
             '  "11{22}33" (libass)\n'
-            "Default: 0"
+            "Default: 1"
         ),
         childs=(Cmd_type_val(("0", "1")),),
     )
@@ -486,7 +495,8 @@ class Opt_type(enum.Enum):
         param="<string>",
         description=(
             "Setting audio encoder\n"
-            "Audio encoder:\n"  # .
+            "\n"  # .
+            "Audio encoder:\n"
             f"{Audio_codec.to_help_string('  ')}"
         ),
         childs=(Cmd_type_val(tuple(Audio_codec._value2member_map_)),),
@@ -501,11 +511,11 @@ class Opt_type(enum.Enum):
         param="<string>",
         description=(
             "Setting muxer\n"
-            " \n"  # .
+            "\n"  # .
             "Muxer:\n"
-            "  mp4\n"
-            "  mkv\n"
+            f"{Audio_codec.to_help_string('  ')}"
         ),
+        childs=(Cmd_type_val(tuple(Muxer._value2member_map_)),),
     )
     _r = _fps = Cmd_type_val(
         ("-r", "-fps"),
@@ -789,8 +799,10 @@ class OptCompleter(Completer):
             _preset_name = None
             if _preset in Preset_name._member_map_:
                 _preset_name = Preset_name[_preset]
-            if _preset_name is not None and _preset_name in PRESET_OPT_NAME:
-                add_set: set[str] = {f"-{n}" for n in PRESET_OPT_NAME[_preset_name]}
+            if _preset_name is not None:
+                add_set: set[str] = {
+                    f"-{n}" for n in _preset_name.get_param_name_set(set())
+                }
                 add_comp_words |= add_set
                 add_comp_meta_dict |= dict.fromkeys(add_set, f"{_preset} param")
 
@@ -859,7 +871,13 @@ class OptCompleter(Completer):
 
             yield from merge_completers(
                 (
-                    _nested_dict_to_nc(new_nd),
+                    merge_completers(
+                        (
+                            _nested_dict_to_nc(new_nd),
+                            FuzzyCompleter(_nested_dict_to_nc(new_nd), WORD=True),
+                        ),
+                        deduplicate=True,
+                    ),
                     FuzzyCompleter(
                         WordCompleter(
                             words=tuple(opt_tree_pos_list[-1]),

{easyrip-4.11.3 → easyrip-4.13.0}/easyrip/easyrip_main.py

@@ -30,16 +30,14 @@ from .easyrip_log import log
 from .easyrip_mlang import (
     Global_lang_val,
     Lang_tag,
-    Lang_tag_language,
     get_system_language,
     gettext,
     translate_subtitles,
 )
 from .easyrip_prompt import easyrip_prompt
 from .ripper.media_info import Media_info
-from .ripper.param import DEFAULT_PRESET_PARAMS, PRESET_OPT_NAME
 from .ripper.ripper import Ripper
-from .ripper.sub_and_font import load_fonts
+from .ripper.sub_and_font import Ass, load_fonts
 from .utils import change_title, check_ver, read_text
 
 __all__ = ["init", "run_command"]
@@ -307,6 +305,10 @@ def run_ripper_list(
             except Exception as e:
                 log.error(e, deep=True)
                 log.warning("Stop run Ripper")
+            except KeyboardInterrupt:
+                log.warning("Manually stop run and clear Ripper list")
+                Ripper.ripper_list.clear()
+                raise
 
         with ThreadPoolExecutor() as executor:
             for ripper in Ripper.ripper_list:
@@ -324,6 +326,10 @@ def run_ripper_list(
             except Exception as e:
                 log.error(e, deep=True)
                 log.warning("Stop run Ripper")
+            except KeyboardInterrupt:
+                log.warning("Manually stop run and clear Ripper list")
+                Ripper.ripper_list.clear()
+                raise
             sleep(0.5)
 
     if log.warning_num > warning_num:
@@ -419,40 +425,41 @@ def run_command(command: Iterable[str] | str) -> bool:
                             log.send(_want_doc_cmd_type.value.to_doc(), is_format=False)
                         elif cmd_list[2] in Ripper.Preset_name._value2member_map_:
                             _preset = Ripper.Preset_name(cmd_list[2])
-                            if (
-                                _preset in DEFAULT_PRESET_PARAMS
-                                or _preset in PRESET_OPT_NAME
-                            ):
-                                if _preset in PRESET_OPT_NAME:
-                                    log.send(
-                                        "Params that can be directly used:\n{}",
-                                        textwrap.indent(
-                                            "\n".join(
-                                                f"-{n}"
-                                                for n in PRESET_OPT_NAME[_preset]
-                                            ),
-                                            prefix="  ",
-                                        ),
-                                    )
-                                if _preset in DEFAULT_PRESET_PARAMS:
-                                    _default_params = DEFAULT_PRESET_PARAMS[_preset]
-                                    max_name_len = (
-                                        max(len(str(n)) for n in _default_params) + 1
-                                    )
-                                    log.send(
-                                        "Default val:\n{}",
-                                        textwrap.indent(
-                                            "\n".join(
-                                                f"{f'-{n}':>{max_name_len}}  {v}"
-                                                for n, v in _default_params.items()
-                                            ),
-                                            prefix="  ",
-                                        ),
-                                    )
-                            else:
+                            _param_default_dict = _preset.get_param_default_dict()
+                            _param_name_set = _preset.get_param_name_set()
+                            if not any((_param_default_dict, _param_name_set)):
                                 log.send(
                                     "The preset '{}' has no separate help", cmd_list[2]
                                 )
+                            if _param_name_set:
+                                log.send(
+                                    "Params that can be directly used:\n{}",
+                                    textwrap.indent(
+                                        "\n".join(f"-{n}" for n in _param_name_set),
+                                        prefix="  ",
+                                    ),
+                                )
+                            if _param_default_dict:
+                                max_name_len = (
+                                    max(len(str(n)) for n in _param_default_dict) + 1
+                                )
+                                log.send(
+                                    "Default val:\n{}",
+                                    textwrap.indent(
+                                        "\n".join(
+                                            f"{f'-{n}':>{max_name_len}}  {v}"
+                                            for n, v in _param_default_dict.items()
+                                        ),
+                                        prefix="  ",
+                                    ),
+                                )
+                                log.send(
+                                    "  FFmpeg format:\n    {}",
+                                    ":".join(
+                                        f"{n}={v}"
+                                        for n, v in _param_default_dict.items()
+                                    ),
+                                )
                         else:
                             log.error("'{}' is not a member of preset", cmd_list[2])
 
@@ -495,8 +502,8 @@ def run_command(command: Iterable[str] | str) -> bool:
         case Cmd_type.exit:
             sys.exit(0)
 
-        case Cmd_type.cd | Cmd_type.mediainfo | Cmd_type.fontinfo:
-            _path_tuple: tuple[str, ...] | None = None
+        case Cmd_type.cd | Cmd_type.mediainfo | Cmd_type.assinfo | Cmd_type.fontinfo:
+            _path_tuple: Iterable[str] | None = None
 
             match cmd_list[1]:
                 case "fd" | "cfd" as fd_param:
@@ -528,6 +535,46 @@ def run_command(command: Iterable[str] | str) -> bool:
                 case Cmd_type.mediainfo:
                     for _path in _path_tuple:
                         log.send(f"{_path}: {Media_info.from_path(_path)}")
+                case Cmd_type.assinfo:
+                    USE_LIBASS_SPEC_OPT_NAME = "-use-libass-spec"
+                    use_libass_spec: bool = True
+                    SHOW_CHARS_LEN_OPT_NAME = "-show-chars-len"
+                    show_chars_len: bool = False
+                    is_use_opt: bool = False
+                    for i, s in tuple(enumerate(cmd_list))[2:]:
+                        if s == USE_LIBASS_SPEC_OPT_NAME:
+                            use_libass_spec = cmd_list[i + 1] != "0"
+                            is_use_opt = True
+                        if s == SHOW_CHARS_LEN_OPT_NAME:
+                            show_chars_len = cmd_list[i + 1] != "0"
+                            is_use_opt = True
+                    if is_use_opt:
+                        _path_tuple = cmd_list[1:2]
+                    log.send(
+                        "  ".join(
+                            (
+                                f"{USE_LIBASS_SPEC_OPT_NAME} {1 if use_libass_spec else 0}",
+                                f"{SHOW_CHARS_LEN_OPT_NAME} {1 if show_chars_len else 0}",
+                            )
+                        )
+                    )
+                    for _path in _path_tuple:
+                        try:
+                            ass = Ass(_path)
+                        except Exception as e:
+                            log.error(e)
+                            return False
+
+                        log.send(_path)
+                        for font_sign, ss in ass.get_font_info(
+                            use_libass_spec=use_libass_spec,
+                        ).items():
+                            show_chars_len_log_str = ""
+                            if show_chars_len:
+                                show_chars_len_log_str = f": {len(ss)}"
+                            log.send(
+                                f"  ( {font_sign[0]} / {font_sign[1].name} ){show_chars_len_log_str}"
+                            )
                 case Cmd_type.fontinfo:
                     for _font in itertools.chain.from_iterable(
                         load_fonts(_path) for _path in _path_tuple
@@ -1156,7 +1203,7 @@ def init(is_first_run: bool = False) -> None:
 
         if (
             lang_tag := Lang_tag.from_str(file.stem[5:])
-        ).language is not Lang_tag_language.Unknown:
+        ).language is not Lang_tag.Language.Unknown:
             easyrip_mlang.all_supported_lang_map[lang_tag] = lang_map
 
             log.debug("Loading \"{}\" as '{}' language successfully", file, lang_tag)

{easyrip-4.11.3 → easyrip-4.13.0}/easyrip/easyrip_mlang/__init__.py

@@ -1,22 +1,13 @@
 import locale
 
 from . import lang_en, lang_zh_Hans_CN
-from .global_lang_val import (
-    Global_lang_val,
-    Lang_tag,
-    Lang_tag_language,
-    Lang_tag_region,
-    Lang_tag_script,
-    Lang_tag_val,
-)
+from .global_lang_val import Global_lang_val, Lang_tag
+from .lang_tag_val import Lang_tag_val
 from .translator import translate_subtitles
 
 __all__ = [
     "Global_lang_val",
     "Lang_tag",
-    "Lang_tag_language",
-    "Lang_tag_region",
-    "Lang_tag_script",
     "Lang_tag_val",
     "Mlang_exception",
     "get_system_language",

easyrip-4.13.0/easyrip/easyrip_mlang/global_lang_val.py

@@ -0,0 +1,160 @@
+import enum
+from collections.abc import Iterable
+from dataclasses import dataclass
+from typing import Self, final
+
+
+@final
+@dataclass(slots=True, kw_only=True)
+class Lang_tag:
+    from .lang_tag_val import Lang_tag_language as Language
+    from .lang_tag_val import Lang_tag_region as Region
+    from .lang_tag_val import Lang_tag_script as Script
+
+    language: Language = Language.Unknown
+    script: Script = Script.Unknown
+    region: Region = Region.Unknown
+
+    class Match_priority(enum.Enum):
+        script = enum.auto()
+        region = enum.auto()
+
+    def match(
+        self,
+        target_tags: Iterable[Self],
+        *,
+        is_incomplete_match: bool = True,
+        priority: Match_priority = Match_priority.script,
+        is_allow_mismatch_language: bool = False,
+    ) -> Self | None:
+        """启用不完整匹配时，找到最匹配的第一项"""
+        target_tags_tuple = tuple(target_tags)
+        del target_tags
+
+        matching_tags_tuple = tuple(
+            tag for tag in target_tags_tuple if tag.language is self.language
+        )
+        if not matching_tags_tuple:
+            if is_allow_mismatch_language:
+                matching_tags_tuple = target_tags_tuple
+            else:
+                return None
+
+        if self in matching_tags_tuple:
+            return self
+        if not is_incomplete_match:
+            return None
+
+        same_region_tuple = tuple(
+            tag for tag in matching_tags_tuple if tag.region is self.region
+        )
+
+        same_script_tuple = tuple(
+            tag for tag in matching_tags_tuple if tag.script is self.script
+        )
+
+        if priority_same_tuple := (
+            same_script_tuple + same_region_tuple
+            if priority is self.__class__.Match_priority.script
+            else same_region_tuple + same_script_tuple
+        ):
+            return priority_same_tuple[0]
+
+        return matching_tags_tuple[0]
+
+    @classmethod
+    def from_str(
+        cls,
+        str_tag: str,
+    ) -> Self:
+        """
+        输入语言标签字符串，输出标签对象
+
+        e.g. zh-Hans-CN -> Self(Language.zh, Script.Hans, Region.CN)
+        """
+        from ..easyrip_mlang import gettext
+
+        str_tag_list = str_tag.split("-")
+
+        language: Lang_tag.Language = cls.Language.from_name(str_tag_list[0])
+        script: Lang_tag.Script = cls.Script.Unknown
+        region: Lang_tag.Region = cls.Region.Unknown
+
+        for i, s in enumerate(str_tag_list[1:]):
+            if s in cls.Script._member_map_:
+                if i != 0:
+                    raise ValueError(
+                        gettext("The input language tag string format is illegal")
+                    )
+                script = cls.Script[s]
+            elif s in cls.Region._member_map_:
+                region = cls.Region[s]
+
+        return cls(
+            language=language,
+            script=script,
+            region=region,
+        )
+
+    def __str__(self) -> str:
+        """返回语言标签字符串"""
+        if self.language == self.__class__.Language.Unknown:
+            raise Exception("The Language is Unknown")
+
+        res_str: str = self.language.name
+        if self.script != self.__class__.Script.Unknown:
+            res_str += f"-{self.script.name}"
+        if self.region != self.__class__.Region.Unknown:
+            res_str += f"-{self.region.name}"
+
+        return res_str
+
+    def __hash__(self) -> int:
+        return hash((self.language, self.script, self.region))
+
+
+class Global_lang_val:
+    gettext_target_lang: Lang_tag = Lang_tag()
+
+    @staticmethod
+    def language_tag_to_local_str(language_tag: str) -> str:
+        from ..easyrip_mlang import gettext
+
+        tag_list = language_tag.split("-")
+        tag_list_len = len(tag_list)
+
+        if tag_list_len == 0:
+            raise Exception(gettext("The input language tag string format is illegal"))
+
+        res_str_list: list[str] = [
+            _local_name
+            if (_org_name := tag_list[0]) in Lang_tag.Language._member_map_
+            and (_local_name := Lang_tag.Language[_org_name].value.local_name)
+            else _org_name
+        ]
+
+        if tag_list_len >= 2:
+            _org_name = tag_list[1]
+
+            if _org_name in Lang_tag.Script.__members__:
+                _local_name = Lang_tag.Script[_org_name].value.local_name
+            elif _org_name in Lang_tag.Region._member_map_:
+                _local_name = Lang_tag.Region[_org_name].value.local_name
+            else:
+                _local_name = _org_name
+
+            res_str_list.append(_local_name)
+
+        if tag_list_len >= 3:
+            _org_name = tag_list[2]
+
+            if _org_name in Lang_tag.Region._member_map_:
+                _local_name = Lang_tag.Region[_org_name].value.local_name
+            else:
+                _local_name = _org_name
+
+            res_str_list.append(_local_name)
+
+        return (" - " if any(" " in s for s in res_str_list) else "-").join(
+            res_str_list
+        )

easyrip-4.13.0/easyrip/easyrip_mlang/lang_en.py

@@ -0,0 +1,5 @@
+from .global_lang_val import Lang_tag
+
+LANG_TAG = Lang_tag(language=Lang_tag.Language.en)
+
+LANG_MAP: dict[str, str] = {}