easyrip 3.13.2__py3-none-any.whl → 4.9.1__py3-none-any.whl

easyrip/ripper/{font_subset → sub_and_font}/subset.py

@@ -1,11 +1,14 @@
 import re
+from collections.abc import Iterable
 from io import BytesIO
 from pathlib import Path
-from typing import Iterable
+from typing import Final
+
+import fontTools
 
 from ... import global_val
 from ...easyrip_log import log
-from ...utils import get_base62_time
+from ...utils import get_base62_time, non_ascii_str_len
 from .ass import (
     Ass,
     Attach_type,
@@ -14,14 +17,13 @@ from .ass import (
     Event_type,
     Script_info_data,
 )
-from .font import Font, Font_type, get_font_path_from_registry, load_fonts, subset_font
+from .font import Font, Font_type, load_fonts, load_windows_fonts, subset_font
 
 
 def _bold_italic_to_font_type(bold: bool | int, italic: bool | int) -> Font_type:
     if bold:
         return Font_type.Bold_Italic if italic else Font_type.Bold
-    else:
-        return Font_type.Italic if italic else Font_type.Regular
+    return Font_type.Italic if italic else Font_type.Regular
 
 
 def subset(
@@ -36,6 +38,8 @@ def subset(
     drop_unkow_data: bool = True,
     strict: bool = False,
 ) -> bool:
+    DEFAULT_STYLE_NAME = "Default"
+
     return_res: bool = True
 
     subset_sub_dict: dict[str, tuple[Path, Ass]] = {}
@@ -65,7 +69,12 @@ def subset(
 
     family__affix: dict[str, str] = {}
 
-    def get_font_new_name(org_name: str):
+    def get_font_new_name(org_name: str) -> str:
+        """
+        输入字体名，返回子集化后的字体名
+
+        注意: 用这个函数生成子集化字体名，任何需要子集化的字体名都需要经过这个函数
+        """
         if org_name not in family__affix:
             family__affix[org_name] = f"__subset_{get_base62_time()}__"
         return family__affix[org_name] + org_name
@@ -79,14 +88,18 @@ def subset(
         # Styles
         style__font_sign: dict[str, tuple[str, Font_type]] = {}
         for style in path_and_sub.styles.data:
+            _is_vertical: bool = style.Fontname[0] == "@"
+            _font_name: str = style.Fontname[1:] if _is_vertical else style.Fontname
             # 获取
             style__font_sign[style.Name] = (
-                style.Fontname,
+                _font_name,
                 _bold_italic_to_font_type(style.Bold, style.Italic),
             )
 
             # 修改
-            style.Fontname = get_font_new_name(style.Fontname)
+            style.Fontname = (
+                f"{'@' if _is_vertical else ''}{get_font_new_name(_font_name)}"
+            )
 
         # Events
         for event in path_and_sub.events.data:
@@ -97,19 +110,20 @@ def subset(
 
             # 获取每行的默认字体
             if event.Style not in style__font_sign:
-                if "Default" in style__font_sign:
+                if DEFAULT_STYLE_NAME in style__font_sign:
                     log.warning(
-                        "The style {} not in Styles. Defaulting to the style 'Default'",
+                        "The style '{}' not in Styles. Defaulting to the style '{}'",
                         event.Style,
+                        DEFAULT_STYLE_NAME,
                     )
-                    default_font_sign = style__font_sign["Default"]
+                    default_font_sign = style__font_sign[DEFAULT_STYLE_NAME]
                     return_res = not strict
                 else:
-                    log.error(
-                        "The style {} and the style 'Default' not in Styles. Defaulting to the font 'Arial'",
+                    log.warning(
+                        "The style '{}' and the style 'Default' not in Styles. Defaulting to no font",
                         event.Style,
                     )
-                    default_font_sign = ("Arial", Font_type.Regular)
+                    default_font_sign = ("", Font_type.Regular)
                     return_res = not strict
             else:
                 default_font_sign = style__font_sign[event.Style]
@@ -119,28 +133,40 @@ def subset(
             current_font_sign: tuple[str, Font_type] = default_font_sign
             for is_tag, text in Event_data.parse_text(event.Text, use_libass_spec):
                 if is_tag:
+                    tag_fn_org: str | None = None
                     tag_fn: str | None = None
                     tag_bold: str | None = None
                     tag_italic: str | None = None
 
                     for tag, value in re.findall(
-                        r"\\\s*(fn@|fn|b(?![a-zA-Z])|i(?![a-zA-Z])|r)([^\\}]*)", text
+                        r"\\\s*(fn|b(?![a-zA-Z])|i(?![a-zA-Z])|r)([^\\}]*)", text
                     ):
+                        assert isinstance(tag, str) and isinstance(value, str)
+
+                        proc_value = value.strip()
+                        if proc_value.startswith("("):
+                            proc_value = proc_value[1:]
+                            if (_index := proc_value.find(")")) != -1:
+                                proc_value = proc_value[:_index]
+                            proc_value = proc_value.strip()
+
                         match tag:
-                            case "fn@" | "fn":
-                                tag_fn = value
+                            case "fn":
+                                tag_fn_org, tag_fn = value, proc_value
                             case "b":
-                                tag_bold = value
+                                tag_bold = proc_value
                             case "i":
-                                tag_italic = value
+                                tag_italic = proc_value
                             case "r":
-                                if value in style__font_sign:
-                                    current_font_sign = style__font_sign[value]
+                                r_value = proc_value if "(" in value else value.rstrip()
+                                if r_value in style__font_sign:
+                                    current_font_sign = style__font_sign[r_value]
                                 else:
+                                    # 空为还原样式, 非样式表内样式名效果同空, 但发出不规范警告
                                     current_font_sign = default_font_sign
-                                    if value != "":
+                                    if r_value != "":
                                         log.warning(
-                                            "The \\r style '{}' not in Styles", value
+                                            "The \\r style '{}' not in Styles", r_value
                                         )
 
                     new_fontname: str = current_font_sign[0]
@@ -149,23 +175,21 @@ def subset(
                     new_bold, new_italic = current_font_sign[1].value
 
                     if tag_fn is not None:
-                        match _tag_fn := tag_fn.strip():
+                        match tag_fn:
                             case "":
                                 new_fontname = default_font_sign[0]
                             case _:
-                                new_fontname = _tag_fn
+                                _is_vertical: bool = tag_fn.startswith("@")
+                                new_fontname = tag_fn[1:] if _is_vertical else tag_fn
 
                                 # 修改
                                 text = text.replace(
-                                    f"\\fn{tag_fn}",
-                                    f"\\fn{get_font_new_name(new_fontname)}",
-                                ).replace(
-                                    f"\\fn@{tag_fn}",
-                                    f"\\fn@{get_font_new_name(new_fontname)}",
+                                    f"\\fn{tag_fn_org}",
+                                    f"\\fn{'@' if _is_vertical else ''}{get_font_new_name(new_fontname)}",
                                 )
 
                     if tag_bold is not None:
-                        match tag_bold.strip():
+                        match tag_bold:
                             case "":
                                 new_bold = default_font_sign[1].value[0]
                             case "0":
@@ -174,15 +198,15 @@ def subset(
                                 new_bold = True
                             case _:
                                 log.error(
-                                    "Undefined behavior: {} in line {} in file {}",
-                                    "\\b",
-                                    event.Text,
+                                    "Illegal format: '{}' in file \"{}\" in line: {}",
+                                    f"\\b{tag_bold}",
                                     _ass_path,
+                                    event.Text,
                                 )
                                 return_res = not strict
 
                     if tag_italic is not None:
-                        match tag_italic.strip():
+                        match tag_italic:
                             case "":
                                 new_italic = default_font_sign[1].value[1]
                             case "0":
@@ -191,10 +215,10 @@ def subset(
                                 new_italic = True
                             case _:
                                 log.error(
-                                    "Undefined behavior: {} in line {} in file {}",
-                                    "\\i",
-                                    event.Text,
+                                    "Illegal format: '{}' in file \"{}\" in line: {}",
+                                    f"\\i{tag_italic}",
                                     _ass_path,
+                                    event.Text,
                                 )
                                 return_res = not strict
 
@@ -203,7 +227,7 @@ def subset(
                         Font_type((new_bold, new_italic)),
                     )
 
-                else:
+                elif current_font_sign[0]:  # 空字符串为不使用字体
                     add_text = re.sub(r"\\[nN]", "", text).replace("\\h", "\u00a0")
 
                     if current_font_sign not in font_sign__subset_str:
@@ -225,13 +249,12 @@ def subset(
             event.Text = new_text
 
         # 修改子集化后的字幕
+        family__affix_k_max_na_len: int = max(
+            map(non_ascii_str_len, family__affix.keys())
+        )
         path_and_sub.script_info.data = [
             Script_info_data(
-                raw_str=f"; ---------- Font Subset by {global_val.PROJECT_TITLE} ----------"
-            ),
-            *(
-                Script_info_data(raw_str=f'Font Subset Mapping: "{v}{k}"   ->   "{k}"')
-                for k, v in family__affix.items()
+                raw_str=f"Font Subset Info: {global_val.PROJECT_TITLE} & {fontTools.__name__} v{fontTools.__version__}"
             ),
             Script_info_data(
                 raw_str=f"Font Subset Setting: {
@@ -248,34 +271,32 @@ def subset(
                     )
                 }"
             ),
-            Script_info_data(
-                raw_str=f"; ---------- {'Font Subset End':^{len(global_val.PROJECT_TITLE) + 20}} ----------"
+            *(
+                Script_info_data(
+                    raw_str=f'Font Subset Mapping: {f'"{k}"':<{2 + family__affix_k_max_na_len - (non_ascii_str_len(k) - len(k))}}   -->   "{v}{k}"'
+                )
+                for k, v in family__affix.items()
             ),
         ] + path_and_sub.script_info.data
         subset_sub_dict[_ass_path_abs] = (output_dir / _ass_path.name, path_and_sub)
 
     # 加载 Font
-    fonts: list[Font] = []
+    fonts: Final[list[Font]] = []
     for _path in font_path_list:
-        fonts += load_fonts(_path)
+        fonts.extend(load_fonts(_path, strict=strict))
+    if use_win_font:
+        fonts.extend(load_windows_fonts(strict=strict))
 
     font_sign__font: dict[tuple[str, Font_type], Font] = {}
+    family_lower__family = {}  # 存储小写 family 用于判断 ASS 的大小写不敏感语法
     for _font in fonts:
         for family in _font.familys:
-            if family not in font_sign__font:
-                font_sign__font[(family, _font.font_type)] = _font
+            family_lower__family[family.lower()] = family
+            font_sign__font[(family, _font.font_type)] = _font
 
     # 子集化映射
     font__subset_str: dict[Font, dict[str, str]] = {}
     for key, val in font_sign__subset_str.items():
-        if key not in font_sign__font and use_win_font:
-            # 从系统获取
-            for _path in get_font_path_from_registry(key[0]):
-                for _font in load_fonts(_path):
-                    for _family in _font.familys:
-                        if _family not in font_sign__font:
-                            font_sign__font[(_family, _font.font_type)] = _font
-
         _k: tuple[str, Font_type] = key
         if key not in font_sign__font:
             if strict:
@@ -287,40 +308,53 @@ def subset(
             _font = None
             match key[1]:
                 case Font_type.Regular:
-                    if (_k := (key[0], Font_type.Bold)) in font_sign__font:
-                        _font = font_sign__font[_k]
-                    elif (_k := (key[0], Font_type.Bold_Italic)) in font_sign__font:
-                        _font = font_sign__font[_k]
-                    elif (_k := (key[0], Font_type.Italic)) in font_sign__font:
+                    if (
+                        (_k := (key[0], Font_type.Bold)) in font_sign__font
+                        or (_k := (key[0], Font_type.Italic)) in font_sign__font
+                        or (_k := (key[0], Font_type.Bold_Italic)) in font_sign__font
+                    ):
                         _font = font_sign__font[_k]
 
                 case Font_type.Bold:
-                    if (_k := (key[0], Font_type.Bold_Italic)) in font_sign__font:
-                        _font = font_sign__font[_k]
-                    elif (_k := (key[0], Font_type.Regular)) in font_sign__font:
-                        _font = font_sign__font[_k]
-                    elif (_k := (key[0], Font_type.Italic)) in font_sign__font:
+                    if (
+                        (_k := (key[0], Font_type.Regular)) in font_sign__font
+                        or (_k := (key[0], Font_type.Bold_Italic)) in font_sign__font
+                        or (_k := (key[0], Font_type.Italic)) in font_sign__font
+                    ):
                         _font = font_sign__font[_k]
 
                 case Font_type.Italic:
-                    if (_k := (key[0], Font_type.Regular)) in font_sign__font:
-                        _font = font_sign__font[_k]
-                    elif (_k := (key[0], Font_type.Bold)) in font_sign__font:
+                    if (
+                        (_k := (key[0], Font_type.Regular)) in font_sign__font
+                        or (_k := (key[0], Font_type.Bold_Italic)) in font_sign__font
+                        or (_k := (key[0], Font_type.Bold)) in font_sign__font
+                    ):
                         _font = font_sign__font[_k]
 
                 case Font_type.Bold_Italic:
-                    if (_k := (key[0], Font_type.Bold)) in font_sign__font:
-                        _font = font_sign__font[_k]
-                    elif (_k := (key[0], Font_type.Regular)) in font_sign__font:
+                    if (
+                        (_k := (key[0], Font_type.Bold)) in font_sign__font
+                        or (_k := (key[0], Font_type.Italic)) in font_sign__font
+                        or (_k := (key[0], Font_type.Regular)) in font_sign__font
+                    ):
                         _font = font_sign__font[_k]
 
             # 模糊字重也找不到字体
             if _font is None:
-                log.error(
-                    "{} not found. Skip it",
-                    f"( {key[0]} / {key[1].name} )",
-                    deep=strict,
-                )
+                _want_font_sign_str = f"( {key[0]} / {key[1].name} )"
+                if (_f_low := key[0].lower()) in family_lower__family:
+                    log.error(
+                        "{} not found. Skip it. Perhaps you want the {}",
+                        _want_font_sign_str,
+                        f"'{family_lower__family[_f_low]}'",
+                        deep=strict,
+                    )
+                else:
+                    log.error(
+                        "{} not found. Skip it",
+                        _want_font_sign_str,
+                        deep=strict,
+                    )
                 return_res = False
                 continue
 
@@ -353,6 +387,10 @@ def subset(
             f"( {key[0]} / {key[1].name} ){mapping_res}",
             deep=(strict and bool(mapping_res)),
         )
+        log.debug(
+            f"{_font.pathname}: {_font.familys} {_font.font_type.name}",
+            is_format=False,
+        )
 
     # 子集化字体
     for key, val in font__subset_str.items():
@@ -368,8 +406,7 @@ def subset(
                 _suffix = "otf" if key.font.sfntVersion == "OTTO" else "ttf"
                 break
         else:
-            # return_res = False
-            raise RuntimeError("No font name")
+            raise AssertionError("No font name")
 
         if font_in_sub:
             for org_path_abs, s in val.items():
@@ -423,4 +460,8 @@ def subset(
                 )
             )
 
+    # 释放文件占用
+    for font in font_sign__font.values():
+        font.__del__()
+
     return return_res

easyrip/utils.py

@@ -1,4 +1,5 @@
 import codecs
+import ctypes
 import os
 import re
 import string
@@ -6,30 +7,49 @@ import sys
 import time
 from itertools import zip_longest
 from pathlib import Path
+from typing import Any, Final, TypeGuard, get_args, get_origin
 
-from .easyrip_log import log
+from Crypto.Cipher import AES as CryptoAES
+from Crypto.Util.Padding import pad, unpad
 
 BASE62 = string.digits + string.ascii_letters
 
 
-def change_title(title: str):
+class AES:
+    @staticmethod
+    def encrypt(plaintext: bytes, key: bytes) -> bytes:
+        cipher = CryptoAES.new(key, CryptoAES.MODE_CBC)  # 使用 CBC 模式
+        ciphertext = cipher.encrypt(pad(plaintext, CryptoAES.block_size))  # 加密并填充
+        return bytes(cipher.iv) + ciphertext  # 返回 IV 和密文
+
+    @staticmethod
+    def decrypt(ciphertext: bytes, key: bytes) -> bytes:
+        iv = ciphertext[:16]  # 提取 IV
+        cipher = CryptoAES.new(key, CryptoAES.MODE_CBC, iv=iv)
+        return unpad(
+            cipher.decrypt(ciphertext[16:]), CryptoAES.block_size
+        )  # 解密并去除填充
+
+
+def change_title(title: str) -> None:
     if os.name == "nt":
-        os.system(f"title {title}")
+        # os.system(f"title {title}")
+        ctypes.windll.kernel32.SetConsoleTitleW(title)
     elif os.name == "posix":
         sys.stdout.write(f"\x1b]2;{title}\x07")
         sys.stdout.flush()
 
 
 def check_ver(new_ver_str: str, old_ver_str: str) -> bool:
-    new_ver = [v for v in re.sub(r"^\D*(\d.*\d)\D*$", r"\1", new_ver_str).split(".")]
-    new_ver_add_num = [v for v in str(new_ver[-1]).split("+")]
+    new_ver = list(re.sub(r"^\D*(\d.*\d)\D*$", r"\1", new_ver_str).split("."))
+    new_ver_add_num = list(str(new_ver[-1]).split("+"))
     new_ver = (
         [int(v) for v in (*new_ver[:-1], new_ver_add_num[0])],
         [int(v) for v in new_ver_add_num[1:]],
     )
 
-    old_ver = [v for v in re.sub(r"^\D*(\d.*\d)\D*$", r"\1", old_ver_str).split(".")]
-    old_ver_add_num = [v for v in str(old_ver[-1]).split("+")]
+    old_ver = list(re.sub(r"^\D*(\d.*\d)\D*$", r"\1", old_ver_str).split("."))
+    old_ver_add_num = list(str(old_ver[-1]).split("+"))
     old_ver = (
         [int(v) for v in (*old_ver[:-1], old_ver_add_num[0])],
         [int(v) for v in old_ver_add_num[1:]],
@@ -39,7 +59,7 @@ def check_ver(new_ver_str: str, old_ver_str: str) -> bool:
         for new, old in zip_longest(new_ver[i], old_ver[i], fillvalue=0):
             if new > old:
                 return True
-            elif new < old:
+            if new < old:
                 break
         else:
             continue
@@ -50,7 +70,7 @@ def check_ver(new_ver_str: str, old_ver_str: str) -> bool:
 def int_to_base62(num: int) -> str:
     if num == 0:
         return "0"
-    s = list[str]()
+    s: list[str] = []
     while num > 0:
         num, rem = divmod(num, 62)
         s.append(BASE62[rem])
@@ -62,29 +82,27 @@ def get_base62_time() -> str:
 
 
 def read_text(path: Path) -> str:
+    from .easyrip_log import log
+
     data = path.read_bytes()
 
     if data.startswith(codecs.BOM_UTF8):
         return data.decode("utf-8-sig")
-    elif data.startswith(codecs.BOM_UTF16_LE):
-        return data.decode("utf-16-le")
-    elif data.startswith(codecs.BOM_UTF16_BE):
-        return data.decode("utf-16-be")
-    elif data.startswith(codecs.BOM_UTF32_LE):
-        return data.decode("utf-32-le")
-    elif data.startswith(codecs.BOM_UTF32_BE):
-        return data.decode("utf-32-be")
-    else:
-        log.warning("Can not find the BOM from {}. Defaulting to UTF-8", path)
-        return data.decode("utf-8")
+    if data.startswith((codecs.BOM_UTF16_LE, codecs.BOM_UTF16_BE)):
+        return data.decode("utf-16")
+    if data.startswith((codecs.BOM_UTF32_LE, codecs.BOM_UTF32_BE)):
+        return data.decode("utf-32")
+
+    log.warning("Can not find the BOM from {}. Defaulting to UTF-8", path)
+    return data.decode("utf-8")
 
 
 def uuencode_ssa(data: bytes) -> str:
-    encoded = list[str]()
-    line = list[str]()
+    encoded: list[str] = []
+    line: list[str] = []
     line_count: int = 0
 
-    def append_chars(chars: list[str]):
+    def append_chars(chars: list[str]) -> None:
         nonlocal line, line_count
         for c in chars:
             line.append(c)
@@ -141,14 +159,14 @@ def uuencode_ssa(data: bytes) -> str:
 
 def uudecode_ssa(s: str) -> bytes:
     # 合并所有行并移除可能的空行
-    chars = []
+    chars: list[str] = []
     for line in s.splitlines():
         if line:  # 跳过空行
             chars.extend(line)
 
-    decoded = bytearray()
-    i = 0
-    n = len(chars)
+    decoded: Final[bytearray] = bytearray()
+    i: int = 0
+    n: int = len(chars)
 
     # 处理完整4字符组
     while i + 3 < n:
@@ -184,3 +202,87 @@ def uudecode_ssa(s: str) -> bytes:
 
 def time_str_to_sec(s: str) -> float:
     return sum(float(t) * 60**i for i, t in enumerate(s.split(":")[::-1]))
+
+
+def non_ascii_str_len(s: str) -> int:
+    """非 ASCII 字符算作 2 宽度"""
+    return sum(2 - int(ord(c) < 256) for c in s)
+
+
+def type_match[T](val: Any, t: type[T]) -> TypeGuard[T]:
+    """
+    检查值是否匹配给定的类型（支持泛型）
+
+    支持的类型包括：
+    - 基本类型: int, str, list, dict, tuple, set
+    - 泛型类型: list[str], dict[str, int], tuple[int, ...]
+    - 联合类型: int | str, Union[int, str]
+    - 可选类型: Optional[str]
+    - 嵌套泛型: list[list[str]], dict[str, list[int]]
+
+    Args:
+        val: 要检查的值
+        t: 目标类型，可以是普通类型或泛型
+
+    Returns:
+        bool: 值是否匹配目标类型
+
+    """
+    t_org = get_origin(t)
+
+    # 如果不是泛型类型，直接使用 isinstance
+    if t_org is None:
+        return isinstance(val, t)
+
+    # 首先检查是否是 b_org 的实例
+    if not isinstance(val, t_org):
+        return False
+
+    # 获取类型参数
+    args = get_args(t)
+    if not args:  # 没有类型参数，如 List
+        return True
+
+    # 根据不同的原始类型进行检查
+    if t_org is list:
+        # list[T] 检查
+        if len(args) == 1:
+            elem_type = args[0]
+            return all(type_match(item, elem_type) for item in val)
+
+    elif t_org is tuple:
+        # tuple[T1, T2, ...] 或 tuple[T, ...] 检查
+        if len(args) == 2 and args[1] is ...:  # 可变长度元组
+            elem_type = args[0]
+            return all(type_match(item, elem_type) for item in val)
+        # 固定长度元组
+        if len(val) != len(args):
+            return False
+        return all(type_match(item, t) for item, t in zip(val, args, strict=False))
+
+    elif t_org is dict:
+        # dict[K, V] 检查
+        if len(args) == 2:
+            key_type, value_type = args
+            return all(
+                type_match(k, key_type) and type_match(v, value_type)
+                for k, v in val.items()
+            )
+
+    elif t_org is set:
+        # set[T] 检查
+        if len(args) == 1:
+            elem_type = args[0]
+            return all(type_match(item, elem_type) for item in val)
+
+    elif t_org is frozenset:
+        # frozenset[T] 检查
+        if len(args) == 1:
+            elem_type = args[0]
+            return all(type_match(item, elem_type) for item in val)
+
+    elif hasattr(t_org, "__name__") and t_org.__name__ == "Union":
+        # Union[T1, T2, ...] 或 T1 | T2 检查
+        return any(type_match(val, t) for t in args)
+
+    return True