easyrip 4.11.3__py3-none-any.whl → 4.13.0__py3-none-any.whl

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/__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/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/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/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/easyrip_mlang/global_lang_val.py

@@ -4,154 +4,16 @@ from dataclasses import dataclass
 from typing import Self, final
 
 
-@final
-@dataclass(slots=True, init=False, eq=False)
-class Lang_tag_val:
-    en_name: str
-    _local_name: str | None
-
-    @property
-    def local_name(self) -> str:
-        return self.en_name if self._local_name is None else self._local_name
-
-    @local_name.setter
-    def local_name(self, val: str | None) -> None:
-        if val is not None and len(val) == 0:
-            raise ValueError("The length of the name cannot be 0")
-
-        self._local_name = val
-
-    def __init__(self, *, en_name: str, local_name: str | None = None) -> None:
-        if len(en_name) == 0:
-            raise ValueError("The length of the name cannot be 0")
-
-        self.en_name = en_name
-        self.local_name = local_name
-
-    def __str__(self) -> str:
-        return f"{self.__class__.__name__}(en_name={self.en_name}, local_name={self._local_name})"
-
-    def __eq__(self, other: object) -> bool:
-        if isinstance(other, Lang_tag_val):
-            return self.en_name == other.en_name
-        return False
-
-    def __hash__(self) -> int:
-        return hash(self.en_name)
-
-
-class Lang_tag_language(enum.Enum):
-    Unknown = Lang_tag_val(en_name="Unknown")
-
-    # ISO 639-1
-    en = Lang_tag_val(en_name="English", local_name="English")
-    zh = Lang_tag_val(en_name="Chinese", local_name="中文")
-    fr = Lang_tag_val(en_name="French", local_name="Français")
-    de = Lang_tag_val(en_name="German", local_name="Deutsch")
-    es = Lang_tag_val(en_name="Spanish", local_name="Español")
-    it = Lang_tag_val(en_name="Italian", local_name="Italiano")
-    ja = Lang_tag_val(en_name="Japanese", local_name="日本語")
-    ko = Lang_tag_val(en_name="Korean", local_name="한국어")
-    ru = Lang_tag_val(en_name="Russian", local_name="Русский")
-    ar = Lang_tag_val(en_name="Arabic", local_name="العربية")
-
-    # ISO 639-2
-    eng = en
-    zho = chi = zh
-    fra = fre = fr
-    deu = ger = de
-    spa = es
-    ita = it
-    jpn = ja
-    kor = ko
-    rus = ru
-    ara = ar
-
-    # ISO 639-3
-    # 与 p2 重叠的放在 p2
-    cdo = Lang_tag_val(en_name="Min Dong Chinese", local_name="闽东语")
-    cjy = Lang_tag_val(en_name="Jinyu Chinese", local_name="晋语")
-    cmn = Lang_tag_val(en_name="Mandarin Chinese", local_name="普通话")
-    cnp = Lang_tag_val(en_name="Northern Ping Chinese", local_name="北平语")
-    wuu = Lang_tag_val(en_name="Wu Chinese", local_name="吴语")
-    yue = Lang_tag_val(en_name="Yue Chinese", local_name="粤语")
-    hak = Lang_tag_val(en_name="Hakka Chinese", local_name="客家话")
-    nan = Lang_tag_val(en_name="Min Nan Chinese", local_name="闽南语")
-    och = Lang_tag_val(en_name="Old Chinese", local_name="古汉语")
-
-    @classmethod
-    def _missing_(cls, value: object):
-        return cls.Unknown
-
-    @classmethod
-    def from_name(cls, name: str):
-        try:
-            return cls[name]
-        except KeyError:
-            return cls.Unknown
-
-
-class Lang_tag_script(enum.Enum):
-    Unknown = Lang_tag_val(en_name="Unknown")
-
-    Hans = Lang_tag_val(en_name="Simplified Chinese", local_name="简体")
-    Hant = Lang_tag_val(en_name="Traditional Chinese", local_name="繁體")
-    Latn = Lang_tag_val(en_name="Latin", local_name="Latina")
-    Cyrl = Lang_tag_val(en_name="Cyrillic", local_name="Кириллица")
-    Arab = Lang_tag_val(en_name="Arabic", local_name="العربية")
-
-    @classmethod
-    def _missing_(cls, value: object):
-        return cls.Unknown
-
-    @classmethod
-    def from_name(cls, name: str):
-        try:
-            return cls[name]
-        except KeyError:
-            return cls.Unknown
-
-
-class Lang_tag_region(enum.Enum):
-    Unknown = Lang_tag_val(en_name="Unknown")
-
-    US = Lang_tag_val(en_name="United States", local_name="United States")
-    GB = Lang_tag_val(en_name="United Kingdom", local_name="United Kingdom")
-    AU = Lang_tag_val(en_name="Australia", local_name="Australia")
-    CA = Lang_tag_val(en_name="Canada", local_name="Canada")
-    NZ = Lang_tag_val(en_name="New Zealand", local_name="New Zealand")
-    IE = Lang_tag_val(en_name="Ireland", local_name="Éire")
-    ZA = Lang_tag_val(en_name="South Africa", local_name="South Africa")
-    JM = Lang_tag_val(en_name="Jamaica", local_name="Jamaica")
-    TT = Lang_tag_val(en_name="Caribbean", local_name="Caribbean")
-    BZ = Lang_tag_val(en_name="Belize", local_name="Belize")
-    PH = Lang_tag_val(en_name="Philippines", local_name="Pilipinas")
-    IN = Lang_tag_val(en_name="India", local_name="भारत")
-    MY = Lang_tag_val(en_name="Malaysia", local_name="Malaysia")
-    SG = Lang_tag_val(en_name="Singapore", local_name="Singapura")
-    MO = Lang_tag_val(en_name="Macau SAR", local_name="澳門")
-    HK = Lang_tag_val(en_name="Hong Kong SAR", local_name="香港")
-    TW = Lang_tag_val(en_name="Taiwan", local_name="台灣")
-    CN = Lang_tag_val(en_name="China", local_name="中国大陆")
-
-    @classmethod
-    def _missing_(cls, value: object):
-        return cls.Unknown
-
-    @classmethod
-    def from_name(cls, name: str):
-        try:
-            return cls[name]
-        except KeyError:
-            return cls.Unknown
-
-
 @final
 @dataclass(slots=True, kw_only=True)
 class Lang_tag:
-    language: Lang_tag_language = Lang_tag_language.Unknown
-    script: Lang_tag_script = Lang_tag_script.Unknown
-    region: Lang_tag_region = Lang_tag_region.Unknown
+    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()
@@ -193,7 +55,7 @@ class Lang_tag:
 
         if priority_same_tuple := (
             same_script_tuple + same_region_tuple
-            if priority is Lang_tag.Match_priority.script
+            if priority is self.__class__.Match_priority.script
             else same_region_tuple + same_script_tuple
         ):
             return priority_same_tuple[0]
@@ -214,19 +76,19 @@ class Lang_tag:
 
         str_tag_list = str_tag.split("-")
 
-        language = Lang_tag_language.from_name(str_tag_list[0])
-        script: Lang_tag_script = Lang_tag_script.Unknown
-        region: Lang_tag_region = Lang_tag_region.Unknown
+        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 Lang_tag_script._member_map_:
+            if s in cls.Script._member_map_:
                 if i != 0:
                     raise ValueError(
                         gettext("The input language tag string format is illegal")
                     )
-                script = Lang_tag_script[s]
-            elif s in Lang_tag_region._member_map_:
-                region = Lang_tag_region[s]
+                script = cls.Script[s]
+            elif s in cls.Region._member_map_:
+                region = cls.Region[s]
 
         return cls(
             language=language,
@@ -236,13 +98,13 @@ class Lang_tag:
 
     def __str__(self) -> str:
         """返回语言标签字符串"""
-        if self.language == Lang_tag_language.Unknown:
+        if self.language == self.__class__.Language.Unknown:
             raise Exception("The Language is Unknown")
 
         res_str: str = self.language.name
-        if self.script != Lang_tag_script.Unknown:
+        if self.script != self.__class__.Script.Unknown:
             res_str += f"-{self.script.name}"
-        if self.region != Lang_tag_region.Unknown:
+        if self.region != self.__class__.Region.Unknown:
             res_str += f"-{self.region.name}"
 
         return res_str
@@ -266,18 +128,18 @@ class Global_lang_val:
 
         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)
+            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
+            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
 
@@ -286,8 +148,8 @@ class Global_lang_val:
         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
+            if _org_name in Lang_tag.Region._member_map_:
+                _local_name = Lang_tag.Region[_org_name].value.local_name
             else:
                 _local_name = _org_name
 

easyrip/easyrip_mlang/lang_en.py

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