Add mkvfontvalidator

Close #49

Breaking changes:
- Mkvpropedit.delete_fonts_of_mkv have been renamed Mkvpropedit.delete_all_fonts_of_mkv
- Mkvpropedit.path have been renamed Mkvpropedit.PROGRAM_PATH

Author: moi15moi

examples/collect_font_and_mux_them.py

@@ -47,7 +47,7 @@ def main():
 
 
     # If the mkv already contains font, you can remove them
-    Mkvpropedit.delete_fonts_of_mkv(mkv_path)
+    Mkvpropedit.delete_all_fonts_of_mkv(mkv_path)
 
     Mkvpropedit.merge_fonts_into_mkv(fonts_file_found, mkv_path)
 

font_collector/__init__.py

@@ -3,10 +3,10 @@
 # Packages
 from .ass import *
 from .font import *
+from .mkvtoolnix import *
 from .system_lang import *
 # Files
 from .exceptions import *
-from .mkvpropedit import *
 from ._version import __version__
 from fontTools.misc.loggingTools import configLogger
 

font_collector/__main__.py

@@ -5,15 +5,14 @@
 
 from . import _handler
 from .ass.ass_document import AssDocument
+from .collect_fonts import collect_subtitle_fonts
 from .font import (
     FontCollection,
     FontFile,
     FontLoader,
-    FontSelectionStrategyLibass,
-    VariableFontFace,
-    font_weight_to_name
+    FontSelectionStrategyLibass
 )
-from .mkvpropedit import Mkvpropedit
+from .mkvtoolnix.mkvpropedit import Mkvpropedit
 from .parse_arguments import parse_arguments
 
 _logger = logging.getLogger(__name__)
@@ -50,61 +49,12 @@ def main() -> None:
         for ass_path in ass_files_path:
             subtitle = AssDocument.from_file(ass_path)
             _logger.info(f"Loaded successfully {ass_path}")
-            used_styles = subtitle.get_used_style(collect_draw_fonts)
 
-            nbr_font_not_found = 0
-
-            for style, usage_data in used_styles.items():
-
-                font_result = font_collection.get_used_font_by_style(style, font_strategy)
-
-                # Did not found the font
-                if font_result is None:
-                    nbr_font_not_found += 1
-                    _logger.error(
-                        f"Could not find font '{style.fontname}'\n"
-                        f"Used on lines: {' '.join(str(line) for line in usage_data.ordered_lines)}"
-                    )
-                else:
-                    log_msg = ""
-                    if font_result.need_faux_bold:
-                        log_msg = f"Faux bold used for '{style.fontname}' (requested weight {style.weight}-{(font_weight_to_name(style.weight))}, got {font_result.font_face.weight}-{(font_weight_to_name(font_result.font_face.weight))})."
-                    elif font_result.mismatch_bold:
-                        log_msg = f"Mismatched weight for '{style.fontname}' (requested weight {style.weight}-{(font_weight_to_name(style.weight))}, got {font_result.font_face.weight}-{(font_weight_to_name(font_result.font_face.weight))})."
-                    if font_result.mismatch_italic:
-                        log_msg = f"Mismatched italic for '{style.fontname}' (requested {'non-' if style.italic else ''}italic, got {'non-' if font_result.font_face.is_italic else ''}italic)."
-
-                    if log_msg:
-                        _logger.warning(
-                            f"{log_msg}\n"
-                            f"Used on lines: {' '.join(str(line) for line in usage_data.ordered_lines)}"
-                        )
-
-
-                    missing_glyphs = font_result.font_face.get_missing_glyphs(usage_data.characters_used)
-                    if len(missing_glyphs) > 0:
-                        _logger.warning(f"'{style.fontname}' is missing the following glyphs used: {missing_glyphs}")
-
-
-                    if font_result.font_face.font_file is None:
-                        raise ValueError(f"This font_face \"{font_result.font_face}\" isn't linked to any FontFile.")
-
-                    if convert_variable_to_collection and isinstance(font_result.font_face, VariableFontFace):
-                        font_name = font_result.font_face.get_best_family_prefix_from_lang().value
-                        font_filename = output_directory.joinpath(f"{font_name}.ttc")
-                        generated_font_file = font_result.font_face.variable_font_to_collection(font_filename)
-                        fonts_file_found.add(generated_font_file)
-                    else:
-                        fonts_file_found.add(font_result.font_face.font_file)
-
-            if nbr_font_not_found == 0:
-                _logger.info(f"All font(s) found")
-            else:
-                _logger.error(f"{nbr_font_not_found} font(s) could not be found.")
+            fonts_file_found.update(collect_subtitle_fonts(subtitle, font_collection, font_strategy, collect_draw_fonts, convert_variable_to_collection, output_directory))
 
         if mkv_path is not None:
             if delete_fonts:
-                Mkvpropedit.delete_fonts_of_mkv(mkv_path)
+                Mkvpropedit.delete_all_fonts_of_mkv(mkv_path)
             Mkvpropedit.merge_fonts_into_mkv(fonts_file_found, mkv_path)
         else:
             if not output_directory.is_dir():

font_collector/collect_fonts.py

@@ -0,0 +1,98 @@
+import logging
+from pathlib import Path
+from typing import Optional
+
+from .ass.ass_document import AssDocument
+from .font import (
+    FontCollection,
+    FontFile,
+    FontSelectionStrategy,
+    VariableFontFace,
+    font_weight_to_name
+)
+
+_logger = logging.getLogger(__name__)
+
+
+def collect_subtitle_fonts(
+        subtitle: AssDocument, 
+        font_collection: FontCollection, 
+        font_strategy: FontSelectionStrategy, 
+        collect_draw_fonts: bool, 
+        convert_variable_to_collection: bool = False, 
+        output_variable_font_directory: Optional[Path] = None
+    ) -> set[FontFile]:
+    """
+    Collect the fonts used in a given subtitle (ASS) document.
+
+    Args:
+        subtitle (AssDocument): The ASS subtitle document to be analyzed.
+        font_collection (FontCollection): The collection of available fonts that will be used to match against the subtitle's styles.
+        font_strategy (FontSelectionStrategy): The strategy used to select the best matching font for each style.
+        collect_draw_fonts (bool): Whether to include fonts used in ASS drawing commands (`\\pN` commands).
+        convert_variable_to_collection (bool): If True, variable fonts found in the subtitle will be converted into
+            a TrueType Collection (TTC) file and written to the specified output directory.
+        output_variable_font_directory (Optional[Path]): The directory where converted variable fonts will be saved, if applicable.
+            Required when `convert_variable_to_collection` is True.
+
+    Returns:
+        A set of `FontFile` objects representing all fonts used by the ASS document.
+    """
+    fonts_file_found: set[FontFile] = set()
+
+    used_styles = subtitle.get_used_style(collect_draw_fonts)
+
+    nbr_font_not_found = 0
+
+    for style, usage_data in used_styles.items():
+
+        font_result = font_collection.get_used_font_by_style(style, font_strategy)
+
+        # Did not found the font
+        if font_result is None:
+            nbr_font_not_found += 1
+            _logger.error(
+                f"Could not find font '{style.fontname}'\n"
+                f"Used on lines: {' '.join(str(line) for line in usage_data.ordered_lines)}"
+            )
+        else:
+            log_msg = ""
+            if font_result.need_faux_bold:
+                log_msg = f"Faux bold used for '{style.fontname}' (requested weight {style.weight}-{(font_weight_to_name(style.weight))}, got {font_result.font_face.weight}-{(font_weight_to_name(font_result.font_face.weight))})."
+            elif font_result.mismatch_bold:
+                log_msg = f"Mismatched weight for '{style.fontname}' (requested weight {style.weight}-{(font_weight_to_name(style.weight))}, got {font_result.font_face.weight}-{(font_weight_to_name(font_result.font_face.weight))})."
+            if font_result.mismatch_italic:
+                log_msg = f"Mismatched italic for '{style.fontname}' (requested {'non-' if style.italic else ''}italic, got {'non-' if font_result.font_face.is_italic else ''}italic)."
+
+            if log_msg:
+                _logger.warning(
+                    f"{log_msg}\n"
+                    f"Used on lines: {' '.join(str(line) for line in usage_data.ordered_lines)}"
+                )
+
+
+            missing_glyphs = font_result.font_face.get_missing_glyphs(usage_data.characters_used)
+            if len(missing_glyphs) > 0:
+                _logger.warning(f"'{style.fontname}' is missing the following glyphs used: {missing_glyphs}")
+
+
+            if font_result.font_face.font_file is None:
+                raise ValueError(f"This font_face \"{font_result.font_face}\" isn't linked to any FontFile.")
+
+            if convert_variable_to_collection and isinstance(font_result.font_face, VariableFontFace):
+                if output_variable_font_directory is None:
+                    raise ValueError("When ``convert_variable_to_collection`` is True, you must provide a value for ``output_variable_font_directory``.")
+                font_name = font_result.font_face.get_best_family_prefix_from_lang().value
+                font_filename = output_variable_font_directory.joinpath(f"{font_name}.ttc")
+                generated_font_file = font_result.font_face.variable_font_to_collection(font_filename)
+                fonts_file_found.add(generated_font_file)
+            else:
+                fonts_file_found.add(font_result.font_face.font_file)
+
+    if nbr_font_not_found == 0:
+        _logger.info(f"All font(s) found")
+    else:
+        _logger.error(f"{nbr_font_not_found} font(s) could not be found.")
+    
+    return fonts_file_found
+

font_collector/mkvfontvalidator.py

@@ -0,0 +1,123 @@
+import logging
+from argparse import ArgumentParser
+from datetime import datetime
+from pathlib import Path
+from sys import argv
+from tempfile import TemporaryDirectory
+from typing import Optional
+
+from . import _handler
+from .ass.ass_document import AssDocument
+from .collect_fonts import collect_subtitle_fonts
+from .font import (
+    FontCollection,
+    FontFile,
+    FontLoader,
+    FontSelectionStrategyLibass
+)
+from .mkvtoolnix import MKVExtract, MKVFontFile, Mkvpropedit
+
+_logger = logging.getLogger(__name__)
+
+
+def main() -> None:
+    start_time = datetime.now().strftime("%Y-%m-%d--%H-%M-%S")
+    default_log_path = Path.cwd().joinpath(f"{start_time}_mkvfontvalidator.log")
+
+    parser = ArgumentParser(
+        description="MKV font validator for Advanced SubStation Alpha file."
+    )
+    parser.add_argument(
+        "-mkv",
+        type=Path,
+        help="""
+    The video file to be verified. Must be a Matroska file.
+    """,
+    )
+    parser.add_argument(
+        "-mkvpropedit",
+        type=Path,
+        help="""
+    Path to mkvpropedit.exe if not in variable environments.
+    """,
+    )
+    parser.add_argument(
+        "--need-draw-fonts",
+        action="store_true",
+        help="""
+        If specified, FontCollector will report a error if a font used in a draw isn't muxed to the mkv. For more detail when this is usefull, see: https://github.com/libass/libass/issues/617
+    """,
+    )
+    parser.add_argument(
+        "--delete-fonts-not-used",
+        "-d",
+        action="store_true",
+        help="""
+        If specified, FontCollector will remove the fonts that aren't used by the subtitle(s) of the mkv file.
+    """,
+    )
+    parser.add_argument(
+        "--logging",
+        "-log",
+        type=Path,
+        nargs="?",
+        const=default_log_path,
+        default=None,
+        help="""
+    Destination path of log. If it isn't specified, it will be YYYY-MM-DD--HH-MM-SS_mkvfontvalidator.log.
+    """,
+    )
+
+    args = parser.parse_args()
+
+    mkv_path: Path = args.mkv
+    need_draw_fonts: bool = args.need_draw_fonts
+    delete_fonts_not_used: bool = args.delete_fonts_not_used
+    logging_file_path: Optional[Path] = args.logging
+
+    if args.mkvpropedit:
+        Mkvpropedit.PROGRAM_PATH = args.mkvpropedit
+    
+    if logging_file_path:
+        file_handler = logging.FileHandler(logging_file_path, mode="a", encoding="utf-8")
+        file_handler.setLevel(_handler.level)
+        file_handler.setFormatter(_handler.formatter)
+        root_logger = logging.getLogger()
+        root_logger.addHandler(file_handler)
+        _logger.info(f"{Path.cwd()}>{' '.join(argv)}")
+
+    try:
+        with TemporaryDirectory() as tmp_dir:
+
+            mkv_ass_files = MKVExtract.get_mkv_ass_files(mkv_path, Path(tmp_dir))
+            mkv_font_files = MKVExtract.get_mkv_font_files(mkv_path, Path(tmp_dir))
+
+            fonts_file_found: set[FontFile] = set()
+            additional_fonts = FontLoader.load_additional_fonts([f.filename for f in mkv_font_files])
+            font_collection = FontCollection(use_system_font=False, additional_fonts=additional_fonts)
+            font_strategy = FontSelectionStrategyLibass()
+
+            for mkv_ass_file in mkv_ass_files:
+                subtitle = AssDocument.from_file(mkv_ass_file.filename)
+                _logger.info(f"Loaded successfully the .ass stream at index {mkv_ass_file.mkv_id}")
+
+                fonts_file_found.update(collect_subtitle_fonts(subtitle, font_collection, font_strategy, need_draw_fonts, False, None))
+
+            font_not_used: list[MKVFontFile] = []
+            for mkv_font_file in mkv_font_files:
+                if not any(mkv_font_file.filename.samefile(font_file.filename) for font_file in fonts_file_found):
+                    font_not_used.append(mkv_font_file)
+
+                    if not delete_fonts_not_used:
+                        _logger.warning(f"You can remove the font at the id {mkv_font_file.mkv_id} named \"{mkv_font_file.mkv_font_filename}\". It is not used by any .ass file.")
+
+            if delete_fonts_not_used and font_not_used:
+                Mkvpropedit.delete_fonts_of_mkv(mkv_path, [mkv_font.mkv_id for mkv_font in font_not_used])
+                _logger.warning(f'Successfully deleted {", ".join([f"{mkv_font.mkv_id}-{mkv_font.mkv_font_filename}" for mkv_font in font_not_used])} of the mkv "{mkv_path}"')
+
+    except Exception as e:
+        _logger.error("An unexpected error occured", exc_info=True)
+
+
+if __name__ == "__main__":
+    main()