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

easyrip/ripper/sub_and_font/__init__.py

@@ -0,0 +1,10 @@
+from .ass import Ass
+from .font import Font
+from .subset import load_fonts, subset
+
+__all__ = [
+    "Ass",
+    "Font",
+    "load_fonts",
+    "subset",
+]

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

@@ -5,6 +5,7 @@ from dataclasses import dataclass, field
 from pathlib import Path
 
 from ...easyrip_log import log
+from ...easyrip_mlang import Mlang_exception
 from ...utils import read_text, uudecode_ssa, uuencode_ssa
 
 
@@ -39,13 +40,13 @@ class Style_fmt_it(enum.Enum):
 #     Data = "Dialogue"
 
 
-@dataclass(slots=True)
+@dataclass(slots=True, kw_only=True)
 class Script_info_data:
     # type: Script_info_type
     raw_str: str
 
 
-@dataclass(slots=True)
+@dataclass(slots=True, kw_only=True)
 class Script_info:
     data: list[Script_info_data] = field(default_factory=list[Script_info_data])
 
@@ -58,7 +59,7 @@ class Script_info:
         )
 
 
-@dataclass(slots=True)
+@dataclass(slots=True, kw_only=True)
 class Style_data:
     Name: str
     Fontname: str
@@ -112,7 +113,7 @@ DEFAULT_STYLE_FMT_ORDER = (
 )
 
 
-@dataclass(slots=True)
+@dataclass(slots=True, kw_only=True)
 class Styles:
     fmt_order: tuple[
         Style_fmt_it,
@@ -168,14 +169,14 @@ class Styles:
     )
     data: list[Style_data] = field(default_factory=list[Style_data])
 
-    def flush_fmt_order_index(self):
+    def flush_fmt_order_index(self) -> None:
         for it in self.fmt_order:
             if index := next(
                 (i for i, v in enumerate(DEFAULT_STYLE_FMT_ORDER) if v == it), None
             ):
                 self.fmt_index[it] = index
             else:
-                raise Ass_generation_failed(
+                raise Ass_generate_error(
                     f"Style Format flush order index err: can not find {it}"
                 )
 
@@ -236,7 +237,7 @@ class Styles:
                 Encoding=int(style_tuple[self.fmt_index[Style_fmt_it.Encoding]]),
             )
         except ValueError as e:
-            raise Ass_generation_failed(e)
+            raise Ass_generate_error from e
 
         return res
 
@@ -248,16 +249,14 @@ class Styles:
                 *(
                     "Style: "
                     + ",".join(
-                        (
-                            str(
-                                v
-                                if type(v := getattr(style, k.value)) is not float
-                                else int(v)
-                                if v == int(v)
-                                else v
-                            )
-                            for k in self.fmt_order
+                        str(
+                            v
+                            if type(v := getattr(style, k.value)) is not float
+                            else int(v)
+                            if v == int(v)
+                            else v
                         )
+                        for k in self.fmt_order
                     )
                     for style in self.data
                 ),
@@ -277,13 +276,17 @@ class Event_fmt_it(enum.Enum):
     Effect = "Effect"
     Text = "Text"
 
+    # 兼容旧版和不规范格式
+    Marked = Layer
+    Actor = Name
+
 
 class Event_type(enum.Enum):
     Dialogue = "Dialogue"
     Comment = "Comment"
 
 
-@dataclass(slots=True)
+@dataclass(slots=True, kw_only=True)
 class Event_data:
     type: Event_type
 
@@ -300,69 +303,40 @@ class Event_data:
 
     @staticmethod
     def parse_text(text: str, use_libass_spec: bool) -> list[tuple[bool, str]]:
-        if not use_libass_spec:
-            # 模式1: 不处理转义字符
-            result: list[tuple[bool, str]] = []
-            current = list[str]()  # 当前累积的字符
-            in_tag = False  # 是否在标签内
-
-            for char in text:
-                if in_tag is False:
-                    if char == "{":
-                        # 开始新标签，先保存当前累积的普通文本
-                        if current:
-                            result.append((False, "".join(current)))
-                            current = []
-                        current.append(char)
-                        in_tag = True
-                    else:
-                        current.append(char)  # 普通文本
-                else:
-                    current.append(char)  # 标签内容
-                    if char == "}":
-                        # 标签结束
-                        result.append((True, "".join(current)))
-                        current = []
-                        in_tag = False
+        result: list[tuple[bool, str]] = []
 
-            # 处理剩余部分
-            if current:
-                result.append((False, "".join(current)))
-            return result
-
-        else:
+        if use_libass_spec:
             # 模式2: 处理转义字符（libass规范）
-            result = []
-            current = list[str]()  # 当前累积的字符
-            in_tag = False  # 是否在标签内
-            escape_next = False  # 下一个字符是否转义
+            current: list[str] = []  # 当前累积的字符
+            is_in_tag = False  # 是否在标签内
+            is_escape_next = False  # 下一个字符是否转义
 
             for char in text:
-                if escape_next:
+                if is_escape_next:
                     # 处理转义字符（任何字符直接作为普通字符）
                     current.append(char)
-                    escape_next = False
+                    is_escape_next = False
                 elif char == "\\":
                     # 标记下一个字符为转义
                     current.append(char)
-                    escape_next = True
+                    is_escape_next = True
                 elif char == "{":
-                    if not in_tag:
+                    if not is_in_tag:
                         # 开始新标签（非转义的{）
                         if current:
                             result.append((False, "".join(current)))
                             current = []
                         current.append(char)
-                        in_tag = True
+                        is_in_tag = True
                     else:
                         current.append(char)  # 标签内的{
                 elif char == "}":
-                    if in_tag:
+                    if is_in_tag:
                         # 非转义的}结束标签
                         current.append(char)
                         result.append((True, "".join(current)))
                         current = []
-                        in_tag = False
+                        is_in_tag = False
                     else:
                         current.append(char)  # 普通文本的}
                 else:
@@ -373,6 +347,34 @@ class Event_data:
                 result.append((False, "".join(current)))
             return result
 
+        # 模式1: 不处理转义字符
+        current: list[str] = []  # 当前累积的字符
+        is_in_tag = False  # 是否在标签内
+
+        for char in text:
+            if is_in_tag is False:
+                if char == "{":
+                    # 开始新标签，先保存当前累积的普通文本
+                    if current:
+                        result.append((False, "".join(current)))
+                        current = []
+                    current.append(char)
+                    is_in_tag = True
+                else:
+                    current.append(char)  # 普通文本
+            else:
+                current.append(char)  # 标签内容
+                if char == "}":
+                    # 标签结束
+                    result.append((True, "".join(current)))
+                    current = []
+                    is_in_tag = False
+
+        # 处理剩余部分
+        if current:
+            result.append((False, "".join(current)))
+        return result
+
 
 DEFAULT_EVENT_FMT_ORDER = (
     Event_fmt_it.Layer,
@@ -388,7 +390,7 @@ DEFAULT_EVENT_FMT_ORDER = (
 )
 
 
-@dataclass(slots=True)
+@dataclass(slots=True, kw_only=True)
 class Events:
     fmt_order: tuple[
         Event_fmt_it,
@@ -418,14 +420,14 @@ class Events:
     )
     data: list[Event_data] = field(default_factory=list[Event_data])
 
-    def flush_fmt_order_index(self):
+    def flush_fmt_order_index(self) -> None:
         for it in self.fmt_order:
             if index := next(
                 (i for i, v in enumerate(DEFAULT_EVENT_FMT_ORDER) if v == it), None
             ):
                 self.fmt_index[it] = index
             else:
-                raise Ass_generation_failed(
+                raise Ass_generate_error(
                     f"Event Format flush order index err: can not find {it}"
                 )
 
@@ -460,7 +462,7 @@ class Events:
                 Text=event_tuple[self.fmt_index[Event_fmt_it.Text]],
             )
         except ValueError as e:
-            raise Ass_generation_failed(e)
+            raise Ass_generate_error from e
 
         return res
 
@@ -505,7 +507,7 @@ class Attach_type(enum.Enum):
     Graphics = "Graphics"
 
 
-@dataclass(slots=True)
+@dataclass(slots=True, kw_only=True)
 class Attachment_data:
     type: Attach_type
     name: str
@@ -536,7 +538,7 @@ class Attachment_data:
             self.org_data = new_data
 
 
-@dataclass(slots=True)
+@dataclass(slots=True, kw_only=True)
 class Attachments:
     data: list[Attachment_data] = field(default_factory=list[Attachment_data])
 
@@ -569,7 +571,7 @@ class Attachments:
         return res[1:] if len(res) else ""  # 去除头部的 \n
 
 
-@dataclass(slots=True)
+@dataclass(slots=True, kw_only=True)
 class Unknown_data:
     head: str
     data: list[str] = field(default_factory=list[str])
@@ -583,15 +585,15 @@ class Unknown_data:
         )
 
 
-class Ass_generation_failed(Exception):
+class Ass_generate_error(Mlang_exception):
     pass
 
 
 class Ass:
-    def __init__(self, path: str | Path):
+    def __init__(self, path: str | Path) -> None:
         path = Path(path)
         if not path.is_file():
-            log.error("Not a file: {}", path)
+            raise Ass_generate_error("Not a file: {}", path)
 
         self.script_info: Script_info = Script_info()
         self.styles: Styles = Styles()
@@ -630,22 +632,34 @@ class Ass:
                     case _:
                         if bool(re.search(r"[a-z]", head)):
                             state = State.unknown
-                            new_unknown_data = Unknown_data(head)
+                            new_unknown_data = Unknown_data(head=head)
 
             elif line.startswith("Format:"):
-                formats_generator = (v.strip() for v in line[7:].split(","))
+                formats_tuple = tuple(map(str.strip, line[7:].split(",")))
                 match state:
                     case State.styles:
-                        format_order = tuple(Style_fmt_it(v) for v in formats_generator)
+                        format_order = tuple(map(Style_fmt_it, formats_tuple))
                         if len(format_order) != 23:
-                            raise Ass_generation_failed("Style Format len != 23")
+                            raise Ass_generate_error("Style Format len != 23")
 
                         self.styles.fmt_order = format_order
 
                     case State.events:
-                        format_order = tuple(Event_fmt_it(v) for v in formats_generator)
+                        try:
+                            format_order = tuple(
+                                map(Event_fmt_it.__getitem__, formats_tuple)
+                            )
+                        except ValueError as e:
+                            raise Ass_generate_error from e
+
                         if len(format_order) != 10:
-                            raise Ass_generation_failed("Event Format != 10")
+                            raise Ass_generate_error("Event Format len != 10")
+
+                        if "Marked" in formats_tuple:
+                            log.error(
+                                "The ASS Events Format version too old: {}",
+                                "It used 'Marked' instead of 'Layer'. 'Marked' has been replaced with 'Layer', which will result in irreversible info loss",
+                            )
 
                         self.events.fmt_order = format_order
 
@@ -659,7 +673,7 @@ class Ass:
                             log.warning("Skip a Style line (illegal format): {}", line)
                             continue
 
-                        style_tuple = tuple(v.strip() for v in line[6:].split(","))
+                        style_tuple = tuple(map(str.strip, line[6:].split(",")))
                         if len(style_tuple) != 23:
                             log.warning(
                                 "Skip a Style line (Style Format len != 23): {}", line
@@ -709,9 +723,9 @@ class Ass:
                             continue
 
                         event_tuple = tuple(
-                            v.strip()
-                            for v in line.split(":", maxsplit=1)[1].split(
-                                ",", maxsplit=9
+                            map(
+                                str.strip,
+                                line.split(":", maxsplit=1)[1].split(",", maxsplit=9),
                             )
                         )
                         if len(event_tuple) != 10:
@@ -726,12 +740,9 @@ class Ass:
 
                     case State.unknown:
                         if new_unknown_data is None:
-                            log.error(
-                                "Unknown error occurred when read line: {}",
-                                line,
-                                deep=True,
+                            raise Ass_generate_error(
+                                "Unknown error occurred when read line: {}", line
                             )
-                            raise Ass_generation_failed()
                         new_unknown_data.data.append(line)
 
         if new_unknown_data is not None:
@@ -758,4 +769,4 @@ class Ass:
                 for data in (() if drop_unkow_data else self.unknown_data)
             ),
         )
-        return "\n\n".join(v for v in generator if v) + "\n"
+        return "\n\n".join(filter(bool, generator)) + "\n"

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

@@ -1,6 +1,6 @@
 import enum
+import itertools
 import os
-import winreg
 from copy import deepcopy
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -12,6 +12,11 @@ from fontTools.ttLib.tables._n_a_m_e import NameRecord, makeName, table__n_a_m_e
 from fontTools.ttLib.ttFont import TTLibError
 
 from ...easyrip_log import log
+from ...easyrip_mlang import Mlang_exception
+
+
+class Font_error(Mlang_exception):
+    pass
 
 
 class Font_type(enum.Enum):
@@ -31,33 +36,37 @@ class Font:
     def __hash__(self) -> int:
         return hash(self.pathname)
 
-    def __del__(self):
+    def __del__(self) -> None:
         self.font.close()
 
 
-def load_fonts(path: str | Path, lazy: bool = True) -> list[Font]:
+def load_fonts(
+    path: str | Path,
+    *,
+    lazy: bool = True,
+    strict: bool = False,
+) -> list[Font]:
+    """strict: Skip UnicodeDecodeError font file"""
     if isinstance(path, str):
         path = Path(path)
 
-    res_font_list: Final = list[Font]()
+    res_font_list: Final[list[Font]] = []
 
     for file in path.iterdir() if path.is_dir() else (path,):
         if not (
             file.is_file()
-            and ((suffix := file.suffix.lower()) in {".ttf", ".otf", ".ttc"})
+            and (suffix := file.suffix.lower()) in {".ttf", ".otf", ".ttc"}
         ):
             continue
 
         try:
-            if suffix == ".ttc":
-                fonts: list[TTFont] = [
-                    font for font in TTCollection(file=file, lazy=lazy)
-                ]
-            else:
-                fonts = [TTFont(file=file, lazy=lazy)]
-
-            for font in fonts:
-                table_name: table__n_a_m_e | None = font.get("name")  # type: ignore
+            for font in (
+                list[TTFont](TTCollection(file=file, lazy=lazy))
+                if suffix == ".ttc"
+                else [TTFont(file=file, lazy=lazy)]
+            ):
+                skip_this_font: bool = False
+                table_name: table__n_a_m_e | None = font.get("name")
 
                 if table_name is None:
                     log.warning(f"No 'name' table found in font {file}")
@@ -74,14 +83,16 @@ def load_fonts(path: str | Path, lazy: bool = True) -> list[Font]:
                     if name_id not in {1, 2}:
                         continue
 
-                    name_str: str = record.toUnicode()
-                    if not isinstance(name_str, str):
-                        log.warning(
-                            f"Unexpected type for name string in font {file}: {type(name_str)}"
-                        )
+                    try:
+                        name_str: str = record.toUnicode()
+                    except UnicodeDecodeError as e:
+                        error_text = f"Unicode decode error in font \"{file}\": {e}: '{record.toUnicode('replace')}'. Skip this {'font' if strict else 'name record'}."
+                        if strict:
+                            log.error(error_text, is_format=False)
+                            skip_this_font = True
+                            break
+                        log.warning(error_text, is_format=False)
                         continue
-                    else:
-                        name_str = str(name_str)
 
                     match name_id:
                         case 1:  # Font Family Name
@@ -99,6 +110,9 @@ def load_fonts(path: str | Path, lazy: bool = True) -> list[Font]:
                                     case "italic" | "oblique":
                                         is_italic = True
 
+                if skip_this_font:
+                    continue
+
                 if not res_font.familys:
                     log.warning(f"Font {file} has no family names. Skip this font")
                     continue
@@ -106,7 +120,7 @@ def load_fonts(path: str | Path, lazy: bool = True) -> list[Font]:
                 if is_regular:
                     if is_bold or is_italic:
                         log.error(
-                            "Font {} is Regular but Bold={} and Italic={}. Skip this font",
+                            'Font "{}" is Regular but Bold={} and Italic={}. Skip this font',
                             file,
                             is_bold,
                             is_italic,
@@ -120,70 +134,52 @@ def load_fonts(path: str | Path, lazy: bool = True) -> list[Font]:
                 else:
                     res_font.font_type = Font_type.Regular
                     log.warning(
-                        f"Font {file} does not have an English subfamily name. Defaulting to Regular"
+                        f'Font "{file}" does not have an English subfamily name. Defaulting to Regular'
                     )
 
                 res_font_list.append(res_font)
 
         except TTLibError as e:
-            log.warning(f'Error loading font file "{file}": {e}')
-        except UnicodeDecodeError as e:
-            log.warning(f"Unicode decode error for font {file}: {e}")
+            log.error(f'Failed to load font file "{file}": {e}')
         except Exception as e:
-            log.error(f"Unexpected error for font {file}: {e}")
+            log.error(f'Unexpected error when load font "{file}": {e}')
 
     return res_font_list
 
 
-def get_font_path_from_registry(font_name: str) -> list[str]:
-    """
-    通过Windows注册表获取字体文件路径
-    :param font_name: 字体名称（如"Arial"）
-    :return: 字体文件完整路径，如果找不到返回None
-    """
-    res: Final = list[str]()
-    try:
-        # 打开字体注册表键
-        with winreg.OpenKey(
-            winreg.HKEY_LOCAL_MACHINE,
-            r"SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts",
-        ) as key:
-            i = 0
-            while True:
-                try:
-                    # 枚举所有字体值
-                    value_name, value_data, _ = winreg.EnumValue(key, i)
-                    i += 1
-
-                    # 检查字体名称是否匹配（去掉可能的"(TrueType)"等后缀）
-                    if value_name.startswith(font_name):
-                        # 获取字体文件路径
-                        fonts_dir = os.path.join(os.environ["SystemRoot"], "Fonts")
-                        font_path = os.path.join(fonts_dir, value_data)
-
-                        # 检查文件是否存在
-                        if os.path.isfile(font_path):
-                            res.append(font_path)
-                except OSError:
-                    # 没有更多条目时退出循环
-                    break
-    except Exception as e:
-        log.warning("Error accessing registry: {}", e)
+def load_windows_fonts(
+    *,
+    lazy: bool = True,
+    strict: bool = False,
+) -> list[Font]:
+    paths: tuple[str, ...] = (
+        os.path.join(os.environ["SYSTEMROOT"], "Fonts"),
+        os.path.join(os.environ["LOCALAPPDATA"], "Microsoft/Windows/Fonts"),
+    )
 
-    return res
+    return list(
+        itertools.chain.from_iterable(
+            load_fonts(path, lazy=lazy, strict=strict) for path in paths
+        )
+    )
 
 
-def subset_font(font: Font, subset_str: str, afffix: str) -> tuple[TTFont, bool]:
+def subset_font(font: Font, subset_str: str, affix: str) -> tuple[TTFont, bool]:
     subset_font = deepcopy(font.font)
 
     # 检查哪些字符不存在于字体中
-    cmap = subset_font.getBestCmap()
-    available_chars = set(chr(key) for key in cmap.keys())
+    try:
+        cmap = subset_font.getBestCmap()
+        if cmap is None:
+            raise Exception("cmap is None")
+        available_chars = set(map(chr, cmap))
+    except Exception as e:
+        raise Font_error("Can not read best cmap from '{}'", font.pathname) from e
     input_chars = set(subset_str)
     missing_chars = input_chars - available_chars
 
     if missing_chars:
-        # 将缺失字符按Unicode码点排序
+        # 将缺失字符按 Unicode 码点排序
         sorted_missing = sorted(missing_chars, key=lambda c: ord(c))
         missing_info = ", ".join(f"'{c}' (U+{ord(c):04X})" for c in sorted_missing)
         log.warning(
@@ -194,17 +190,8 @@ def subset_font(font: Font, subset_str: str, afffix: str) -> tuple[TTFont, bool]
 
     # 创建子集化选项
     options = subset.Options()
-    options.drop_tables = ["DSIG", "PCLT", "EBDT", "EBSC"]  # 不移除任何可能有用的表
     options.hinting = True  # 保留 hinting
     options.name_IDs = []  # 不保留 name 表记录
-    options.no_subset_tables = subset.Options._no_subset_tables_default + [
-        "BASE",
-        "mort",
-    ]
-    # options.drop_tables = []
-    options.name_legacy = True
-    # options.retain_gids = True
-    options.layout_features = ["*"]
 
     # 创建子集化器
     subsetter = subset.Subsetter(options=options)
@@ -216,10 +203,15 @@ def subset_font(font: Font, subset_str: str, afffix: str) -> tuple[TTFont, bool]
     subsetter.subset(subset_font)
 
     # 修改 Name Record
-    affix_ascii = afffix.encode("ascii")
-    affix_utf16be = afffix.encode("utf-16-be")
-    table_name: table__n_a_m_e = font.font.get("name")  # type: ignore
-    subset_table_name: table__n_a_m_e = subset_font.get("name")  # type: ignore
+    affix_ascii = affix.encode("ascii")
+    affix_utf16be = affix.encode("utf-16-be")
+    table_name: table__n_a_m_e | None = font.font.get("name")
+    subset_table_name: table__n_a_m_e | None = subset_font.get("name")
+
+    # 这两个都是复制的，所以不可能是 None
+    assert table_name is not None
+    assert subset_table_name is not None
+
     subset_table_name.names = list[NameRecord]()  # 重写 name table
     for record in table_name.names:
         name_id = int(record.nameID)
@@ -244,4 +236,5 @@ def subset_font(font: Font, subset_str: str, afffix: str) -> tuple[TTFont, bool]
             )
         )
 
+    subset_font.close()
     return subset_font, not missing_chars