easyrip 4.3.3__tar.gz → 4.5.0__tar.gz

{easyrip-4.3.3 → easyrip-4.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: easyrip
-Version: 4.3.3
+Version: 4.5.0
 Author: op200
 License-Expression: AGPL-3.0-or-later
 Project-URL: Homepage, https://github.com/op200/EasyRip
@@ -21,8 +21,8 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: prompt-toolkit>=3.0.52
-Requires-Dist: fonttools>=4.61.0
-Requires-Dist: pycryptodome>=3.21.0
+Requires-Dist: fonttools>=4.61.1
+Requires-Dist: pycryptodome>=3.23.0
 Dynamic: license-file
 
 # Easy Rip

{easyrip-4.3.3 → easyrip-4.5.0}/easyrip/__init__.py

@@ -14,10 +14,13 @@ from .easyrip_mlang import (
     Lang_tag_region,
     Lang_tag_script,
 )
-from .ripper import Ass, Media_info, Ripper
+from .ripper.media_info import Media_info
+from .ripper.ripper import Ripper
+from .ripper.sub_and_font import Ass, Font, load_fonts
 
 __all__ = [
     "Ass",
+    "Font",
     "Global_lang_val",
     "Lang_tag",
     "Lang_tag_language",
@@ -30,6 +33,7 @@ __all__ = [
     "gettext",
     "global_val",
     "init",
+    "load_fonts",
     "log",
     "run_command",
 ]

{easyrip-4.3.3 → easyrip-4.5.0}/easyrip/__main__.py

@@ -64,6 +64,7 @@ def run() -> NoReturn:
                                 in {
                                     *Cmd_type.cd.value.names,
                                     *Cmd_type.mediainfo.value.names,
+                                    *Cmd_type.fontinfo.value.names,
                                 }
                                 else ()
                             ),

{easyrip-4.3.3 → easyrip-4.5.0}/easyrip/easyrip_command.py

@@ -19,6 +19,7 @@ from prompt_toolkit.document import Document
 
 from . import global_val
 from .easyrip_config.config_key import Config_key
+from .ripper.param import Audio_codec, Preset_name
 
 
 @final
@@ -279,6 +280,15 @@ class Cmd_type(enum.Enum):
             Cmd_type_val(("cfd",)),
         ),
     )
+    fontinfo = Cmd_type_val(
+        ("fontinfo",),
+        param="<<path> | 'fd' | 'cfd'>",
+        description="Get the font info by the Font class",
+        childs=(
+            Cmd_type_val(("fd",)),
+            Cmd_type_val(("cfd",)),
+        ),
+    )
     Option = Cmd_type_val(
         ("Option",),
         param="...",
@@ -344,48 +354,10 @@ class Opt_type(enum.Enum):
         param="<string>",
         description=(
             "Setting preset\n"
-            "Preset name:\n"
-            "  custom\n"
-            "  subset\n"
-            "  copy\n"
-            "  flac\n"
-            "  x264fast x264slow\n"
-            "  x265fast4 x265fast3 x265fast2 x265fast x265slow x265full\n"
-            "  svtav1\n"
-            "  vvenc\n"
-            "  h264_qsv h264_nvenc h264_amf\n"
-            "  hevc_qsv hevc_nvenc hevc_amf\n"
-            "  av1_qsv av1_nvenc av1_amf"
-        ),
-        childs=(
-            Cmd_type_val(
-                (
-                    "custom",
-                    "subset",
-                    "copy",
-                    "flac",
-                    "x264fast",
-                    "x264slow",
-                    "x265fast4",
-                    "x265fast3",
-                    "x265fast2",
-                    "x265fast",
-                    "x265slow",
-                    "x265full",
-                    "svtav1",
-                    "vvenc",
-                    "h264_qsv",
-                    "h264_nvenc",
-                    "h264_amf",
-                    "hevc_qsv",
-                    "hevc_nvenc",
-                    "hevc_amf",
-                    "av1_qsv",
-                    "av1_nvenc",
-                    "av1_amf",
-                )
-            ),
+            "Preset name:\n"  # .
+            f"{Preset_name.to_help_string('  ')}"
         ),
+        childs=(Cmd_type_val(tuple(Preset_name._value2member_map_)),),
     )
     _pipe = Cmd_type_val(
         ("-pipe",),
@@ -515,11 +487,8 @@ class Opt_type(enum.Enum):
         param="<string>",
         description=(
             "Setting audio encoder\n"
-            " \n"  # .
-            "Audio encoder:\n"
-            "  copy\n"
-            "  libopus\n"
-            "  flac"
+            "Audio encoder:\n"  # .
+            f"{Audio_codec.to_help_string('  ')}"
         ),
         childs=(Cmd_type_val(("copy", "libopus", "flac")),),
     )

{easyrip-4.3.3 → easyrip-4.5.0}/easyrip/easyrip_main.py

@@ -34,8 +34,9 @@ from .easyrip_mlang import (
     translate_subtitles,
 )
 from .easyrip_prompt import easyrip_prompt
-from .ripper import Media_info, Ripper
-from .ripper.ripper import DEFAULT_PRESET_PARAMS
+from .ripper.media_info import Media_info
+from .ripper.ripper import DEFAULT_PRESET_PARAMS, Ripper
+from .ripper.sub_and_font import load_fonts
 from .utils import change_title, check_ver, read_text
 
 __all__ = ["init", "run_command"]
@@ -433,8 +434,8 @@ def run_command(command: Iterable[str] | str) -> bool:
                     case Opt_type._preset:
                         if not cmd_list[2]:
                             log.send(_want_doc_cmd_type.value.to_doc(), is_format=False)
-                        elif cmd_list[2] in Ripper.PresetName._value2member_map_:
-                            _preset = Ripper.PresetName(cmd_list[2])
+                        elif cmd_list[2] in Ripper.Preset_name._value2member_map_:
+                            _preset = Ripper.Preset_name(cmd_list[2])
                             if _preset in DEFAULT_PRESET_PARAMS:
                                 log.send(
                                     json.dumps(
@@ -488,7 +489,7 @@ def run_command(command: Iterable[str] | str) -> bool:
         case Cmd_type.exit:
             sys.exit(0)
 
-        case Cmd_type.cd | Cmd_type.mediainfo:
+        case Cmd_type.cd | Cmd_type.mediainfo | Cmd_type.fontinfo:
             _path_tuple: tuple[str, ...] | None = None
 
             match cmd_list[1]:
@@ -521,6 +522,13 @@ 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.fontinfo:
+                    for _font in itertools.chain.from_iterable(
+                        load_fonts(_path) for _path in _path_tuple
+                    ):
+                        log.send(
+                            f"{_font.pathname}: {_font.familys} / {_font.font_type.name}"
+                        )
 
         case Cmd_type.dir:
             files = os.listdir(os.getcwd())
@@ -781,7 +789,7 @@ def run_command(command: Iterable[str] | str) -> bool:
             input_pathname_org_list: list[str] = []
             output_basename: str | None = None
             output_dir: str | None = None
-            preset_name: str | Ripper.PresetName | None = None
+            preset_name: str | Ripper.Preset_name | None = None
             option_map: dict[str, str] = {}
             is_run: bool = False
             web_server_params = None
@@ -882,19 +890,19 @@ def run_command(command: Iterable[str] | str) -> bool:
             if not preset_name:
                 log.warning("Missing '-preset' option, set to default value 'custom'")
                 preset_name = "custom"
-            if preset_name not in Ripper.PresetName._value2member_map_:
+            if preset_name not in Ripper.Preset_name._value2member_map_:
                 log.error("'{}' is not a member of preset", preset_name)
                 return False
 
-            preset_name = Ripper.PresetName(preset_name)
+            preset_name = Ripper.Preset_name(preset_name)
 
             if (
-                preset_name is Ripper.PresetName.custom
+                preset_name is Ripper.Preset_name.custom
                 and easyrip_web.http_server.Event.is_run_command
             ):
                 log.error(
                     "Disable the use of '{}' on the web",
-                    f"-preset {Ripper.PresetName.custom}",
+                    f"-preset {Ripper.Preset_name.custom}",
                 )
                 return False
 

{easyrip-4.3.3 → easyrip-4.5.0}/easyrip/global_val.py

@@ -3,7 +3,7 @@ import sys
 from pathlib import Path
 
 PROJECT_NAME = "Easy Rip"
-PROJECT_VERSION = "4.3.3"
+PROJECT_VERSION = "4.5.0"
 PROJECT_TITLE = f"{PROJECT_NAME} v{PROJECT_VERSION}"
 PROJECT_URL = "https://github.com/op200/EasyRip"
 PROJECT_RELEASE_API = "https://api.github.com/repos/op200/EasyRip/releases/latest"

easyrip-4.5.0/easyrip/ripper/param.py

@@ -0,0 +1,462 @@
+import enum
+import textwrap
+from functools import reduce
+from typing import Final, LiteralString
+
+
+class Preset_name(enum.Enum):
+    custom = "custom"
+
+    subset = "subset"
+
+    flac = "flac"
+
+    copy = "copy"
+
+    x264 = "x264"
+    x264fast = "x264fast"
+    x264slow = "x264slow"
+
+    x265 = "x265"
+    x265fast4 = "x265fast4"
+    x265fast3 = "x265fast3"
+    x265fast2 = "x265fast2"
+    x265fast = "x265fast"
+    x265slow = "x265slow"
+    x265full = "x265full"
+
+    svtav1 = "svtav1"
+
+    vvenc = "vvenc"
+
+    h264_amf = "h264_amf"
+    h264_nvenc = "h264_nvenc"
+    h264_qsv = "h264_qsv"
+
+    hevc_amf = "hevc_amf"
+    hevc_nvenc = "hevc_nvenc"
+    hevc_qsv = "hevc_qsv"
+
+    av1_amf = "av1_amf"
+    av1_nvenc = "av1_nvenc"
+    av1_qsv = "av1_qsv"
+
+    @classmethod
+    def _missing_(cls, value: object):
+        from ..easyrip_log import log
+
+        DEFAULT = cls.custom
+        log.error(
+            "'{}' is not a valid '{}', set to default value '{}'. Valid options are: {}",
+            value,
+            cls.__name__,
+            DEFAULT.name,
+            list(cls.__members__.values()),
+        )
+        return DEFAULT
+
+    @classmethod
+    def to_help_string(cls, prefix: str = ""):
+        return textwrap.indent(
+            reduce(
+                lambda acc,
+                add: f"{acc}{' ' if add.startswith(acc.split()[-1][:4]) else '\n'}{add}",
+                tuple[str](cls._value2member_map_),
+            ),
+            prefix=prefix,
+        )
+
+
+class Audio_codec(enum.Enum):
+    copy = "copy"
+    libopus = "libopus"
+    flac = "flac"
+
+    # 别名
+    opus = libopus
+
+    @classmethod
+    def _missing_(cls, value: object):
+        from ..easyrip_log import log
+
+        DEFAULT = cls.copy
+        log.error(
+            "'{}' is not a valid '{}', set to default value '{}'. Valid options are: {}",
+            value,
+            cls.__name__,
+            DEFAULT.name,
+            list(cls.__members__.values()),
+        )
+        return DEFAULT
+
+    @classmethod
+    def to_help_string(cls, prefix: str = ""):
+        return textwrap.indent(
+            reduce(
+                lambda acc,
+                add: f"{acc}{' ' if add.endswith(acc.split()[-1][-4:]) else '\n'}{add}",
+                tuple[str](cls._member_map_),
+            ),
+            prefix=prefix,
+        )
+
+
+class Muxer(enum.Enum):
+    mp4 = "mp4"
+    mkv = "mkv"
+
+    @classmethod
+    def _missing_(cls, value: object):
+        from ..easyrip_log import log
+
+        DEFAULT = cls.mkv
+        log.error(
+            "'{}' is not a valid '{}', set to default value '{}'. Valid options are: {}",
+            value,
+            cls.__name__,
+            DEFAULT.name,
+            list(cls.__members__.values()),
+        )
+        return DEFAULT
+
+
+_DEFAULT_X265_PARAMS: Final[dict[LiteralString, LiteralString]] = {
+    "crf": "20",
+    "qpmin": "6",
+    "qpmax": "32",
+    "rd": "3",
+    "psy-rd": "2",
+    "rdoq-level": "0",
+    "psy-rdoq": "0",
+    "qcomp": "0.68",
+    "keyint": "250",
+    "min-keyint": "2",
+    "deblock": "0,0",
+    "me": "umh",
+    "merange": "57",
+    "hme": "1",
+    "hme-search": "hex,hex,hex",
+    "hme-range": "16,57,92",
+    "aq-mode": "2",
+    "aq-strength": "1",
+    "tu-intra-depth": "1",
+    "tu-inter-depth": "1",
+    "limit-tu": "0",
+    "bframes": "16",
+    "ref": "8",
+    "subme": "2",
+    "open-gop": "1",
+    "gop-lookahead": "0",
+    "rc-lookahead": "20",
+    "rect": "0",
+    "amp": "0",
+    "cbqpoffs": "0",
+    "crqpoffs": "0",
+    "ipratio": "1.4",
+    "pbratio": "1.3",
+    "early-skip": "1",
+    "ctu": "64",
+    "min-cu-size": "8",
+    "max-tu-size": "32",
+    "level-idc": "0",
+    "sao": "0",
+    "weightb": "1",
+    "info": "1",
+}
+
+X265_PARAMS_NAME: Final[tuple[LiteralString, ...]] = (
+    "crf",
+    "qpmin",
+    "qpmax",
+    "psy-rd",
+    "rd",
+    "rdoq-level",
+    "psy-rdoq",
+    "qcomp",
+    "keyint",
+    "min-keyint",
+    "deblock",
+    "me",
+    "merange",
+    "hme",
+    "hme-search",
+    "hme-range",
+    "aq-mode",
+    "aq-strength",
+    "tu-intra-depth",
+    "tu-inter-depth",
+    "limit-tu",
+    "bframes",
+    "ref",
+    "subme",
+    "open-gop",
+    "gop-lookahead",
+    "rc-lookahead",
+    "rect",
+    "amp",
+    "cbqpoffs",
+    "crqpoffs",
+    "ipratio",
+    "pbratio",
+    "early-skip",
+    "ctu",
+    "min-cu-size",
+    "max-tu-size",
+    "level-idc",
+    "sao",
+)
+
+X264_PARAMS_NAME: Final[tuple[LiteralString, ...]] = (
+    "threads",
+    "crf",
+    "psy-rd",
+    "qcomp",
+    "keyint",
+    "deblock",
+    "qpmin",
+    "qpmax",
+    "bframes",
+    "ref",
+    "subme",
+    "me",
+    "merange",
+    "aq-mode",
+    "rc-lookahead",
+    "min-keyint",
+    "trellis",
+    "fast-pskip",
+)
+
+DEFAULT_PRESET_PARAMS: Final[dict[Preset_name, dict[LiteralString, LiteralString]]] = {
+    Preset_name.x264fast: {
+        "threads": "auto",
+        "crf": "20",
+        "psy-rd": "0.6,0.15",
+        "qcomp": "0.66",
+        "keyint": "250",
+        "deblock": "0,0",
+        "qpmin": "8",
+        "qpmax": "32",
+        "bframes": "8",
+        "ref": "4",
+        "subme": "5",
+        "me": "hex",
+        "merange": "16",
+        "aq-mode": "1",
+        "rc-lookahead": "60",
+        "min-keyint": "2",
+        "trellis": "1",
+        "fast-pskip": "1",
+        "weightb": "1",
+    },
+    Preset_name.x264slow: {
+        "threads": "auto",
+        "crf": "21",
+        "psy-rd": "0.6,0.15",
+        "qcomp": "0.66",
+        "keyint": "250",
+        "deblock": "-1,-1",
+        "qpmin": "8",
+        "qpmax": "32",
+        "bframes": "16",
+        "ref": "8",
+        "subme": "7",
+        "me": "umh",
+        "merange": "24",
+        "aq-mode": "3",
+        "rc-lookahead": "120",
+        "min-keyint": "2",
+        "trellis": "2",
+        "fast-pskip": "0",
+        "weightb": "1",
+    },
+    Preset_name.x265fast4: _DEFAULT_X265_PARAMS
+    | dict[LiteralString, LiteralString](
+        {
+            "crf": "18",
+            "qpmin": "12",
+            "qpmax": "28",
+            "rd": "2",
+            "rdoq-level": "1",
+            "me": "hex",
+            "merange": "57",
+            "hme-search": "hex,hex,hex",
+            "hme-range": "16,32,48",
+            "aq-mode": "1",
+            "tu-intra-depth": "1",
+            "tu-inter-depth": "1",
+            "limit-tu": "4",
+            "bframes": "8",
+            "ref": "6",
+            "subme": "3",
+            "open-gop": "0",
+            "gop-lookahead": "0",
+            "rc-lookahead": "48",
+            "cbqpoffs": "-1",
+            "crqpoffs": "-1",
+            "pbratio": "1.28",
+        }
+    ),
+    Preset_name.x265fast3: _DEFAULT_X265_PARAMS
+    | dict[LiteralString, LiteralString](
+        {
+            "crf": "18",
+            "qpmin": "12",
+            "qpmax": "28",
+            "rdoq-level": "1",
+            "deblock": "-0.5,-0.5",
+            "me": "hex",
+            "merange": "57",
+            "hme-search": "hex,hex,hex",
+            "hme-range": "16,32,57",
+            "aq-mode": "3",
+            "tu-intra-depth": "2",
+            "tu-inter-depth": "2",
+            "limit-tu": "4",
+            "bframes": "12",
+            "ref": "6",
+            "subme": "3",
+            "open-gop": "0",
+            "gop-lookahead": "0",
+            "rc-lookahead": "120",
+            "cbqpoffs": "-1",
+            "crqpoffs": "-1",
+            "pbratio": "1.27",
+        }
+    ),
+    Preset_name.x265fast2: _DEFAULT_X265_PARAMS
+    | dict[LiteralString, LiteralString](
+        {
+            "crf": "18",
+            "qpmin": "12",
+            "qpmax": "28",
+            "rdoq-level": "2",
+            "deblock": "-1,-1",
+            "me": "hex",
+            "merange": "57",
+            "hme-search": "hex,hex,hex",
+            "hme-range": "16,57,92",
+            "aq-mode": "3",
+            "tu-intra-depth": "3",
+            "tu-inter-depth": "2",
+            "limit-tu": "4",
+            "ref": "6",
+            "subme": "4",
+            "open-gop": "0",
+            "gop-lookahead": "0",
+            "rc-lookahead": "192",
+            "cbqpoffs": "-1",
+            "crqpoffs": "-1",
+            "pbratio": "1.25",
+        }
+    ),
+    Preset_name.x265fast: _DEFAULT_X265_PARAMS
+    | dict[LiteralString, LiteralString](
+        {
+            "crf": "18",
+            "qpmin": "12",
+            "qpmax": "28",
+            "psy-rd": "1.8",
+            "rdoq-level": "2",
+            "psy-rdoq": "0.4",
+            "keyint": "312",
+            "deblock": "-1,-1",
+            "me": "umh",
+            "merange": "57",
+            "hme-search": "umh,hex,hex",
+            "hme-range": "16,57,92",
+            "aq-mode": "4",
+            "tu-intra-depth": "4",
+            "tu-inter-depth": "3",
+            "limit-tu": "4",
+            "subme": "5",
+            "gop-lookahead": "8",
+            "rc-lookahead": "216",
+            "cbqpoffs": "-2",
+            "crqpoffs": "-2",
+            "pbratio": "1.2",
+        }
+    ),
+    Preset_name.x265slow: _DEFAULT_X265_PARAMS
+    | dict[LiteralString, LiteralString](
+        {
+            "crf": "17.5",
+            "qpmin": "12",
+            "qpmax": "28",
+            "rd": "5",
+            "psy-rd": "1.8",
+            "rdoq-level": "2",
+            "psy-rdoq": "0.4",
+            "qcomp": "0.7",
+            "keyint": "312",
+            "deblock": "-1,-1",
+            "me": "umh",
+            "merange": "57",
+            "hme-search": "umh,hex,hex",
+            "hme-range": "16,57,184",
+            "aq-mode": "4",
+            "aq-strength": "1",
+            "tu-intra-depth": "4",
+            "tu-inter-depth": "3",
+            "limit-tu": "2",
+            "subme": "6",
+            "gop-lookahead": "14",
+            "rc-lookahead": "250",
+            "rect": "1",
+            "min-keyint": "2",
+            "cbqpoffs": "-2",
+            "crqpoffs": "-2",
+            "pbratio": "1.2",
+            "early-skip": "0",
+        }
+    ),
+    Preset_name.x265full: _DEFAULT_X265_PARAMS
+    | dict[LiteralString, LiteralString](
+        {
+            "crf": "17",
+            "qpmin": "3",
+            "qpmax": "21.5",
+            "psy-rd": "2.2",
+            "rd": "5",
+            "rdoq-level": "2",
+            "psy-rdoq": "1.6",
+            "qcomp": "0.72",
+            "keyint": "266",
+            "min-keyint": "2",
+            "deblock": "-1,-1",
+            "me": "umh",
+            "merange": "160",
+            "hme-search": "full,umh,hex",
+            "hme-range": "16,92,320",
+            "aq-mode": "4",
+            "aq-strength": "1.2",
+            "tu-intra-depth": "4",
+            "tu-inter-depth": "4",
+            "limit-tu": "2",
+            "subme": "7",
+            "open-gop": "1",
+            "gop-lookahead": "14",
+            "rc-lookahead": "250",
+            "rect": "1",
+            "amp": "1",
+            "cbqpoffs": "-3",
+            "crqpoffs": "-3",
+            "ipratio": "1.43",
+            "pbratio": "1.2",
+            "early-skip": "0",
+        }
+    ),
+}
+
+SUBTITLE_SUFFIX_SET: Final[set[LiteralString]] = {
+    ".srt",
+    ".ass",
+    ".ssa",
+    ".sup",
+    ".idx",
+}
+FONT_SUFFIX_SET: Final[set[LiteralString]] = {
+    ".otf",
+    ".ttf",
+    ".ttc",
+}