vttcompilepy 0.0.1.6__zip → 0.0.1.8__zip

vttcompilepy-0.0.1.8/tests/test_vttcompile.py

@@ -0,0 +1,163 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+import vttcompilepy as vtt
+from fontTools.ttLib import TTFont
+from pathlib import Path
+import pytest
+
+TESTDATA = Path(__file__).parent / "data"
+IN_SELAWIK = TESTDATA / "Selawik-variable.ttf"
+
+@pytest.fixture
+def original_font():
+    return TTFont(IN_SELAWIK)
+
+@pytest.fixture
+def compiled_font_file():
+    compiler = vtt.Compiler(IN_SELAWIK)
+    compiler.compile_all()
+    out_compiled = TESTDATA / "out_c1.ttf"
+    compiler.save_font(out_compiled, vtt.StripLevel.STRIP_NOTHING)
+    return TTFont(out_compiled)
+
+@pytest.fixture
+def compiled_font_file_str():
+    in_selawik_str = str(IN_SELAWIK)
+    compiler = vtt.Compiler(in_selawik_str)
+    compiler.compile_all()
+    out_compiled_str = str(TESTDATA / "out_c2.ttf")
+    compiler.save_font(out_compiled_str, vtt.StripLevel.STRIP_NOTHING)
+    return TTFont(out_compiled_str)
+
+@pytest.fixture
+def compiled_font_mem():
+    tt = TTFont(IN_SELAWIK)
+    compiler = vtt.Compiler(tt)
+    compiler.compile_all()
+    tt1 = compiler.get_ttfont(vtt.StripLevel.STRIP_NOTHING)
+    return tt1
+
+@pytest.fixture
+def compiled_font_file_mem():
+    compiler = vtt.Compiler(IN_SELAWIK)
+    compiler.compile_all()
+    tt1 = compiler.get_ttfont(vtt.StripLevel.STRIP_NOTHING)
+    return tt1
+
+@pytest.fixture
+def compiled_font_mem_file():
+    tt = TTFont(IN_SELAWIK)
+    compiler = vtt.Compiler(tt)
+    compiler.compile_all()
+    out_compiled = TESTDATA / "out_c3.ttf"
+    compiler.save_font(out_compiled, vtt.StripLevel.STRIP_NOTHING)
+    return TTFont(out_compiled)
+
+@pytest.fixture
+def compiled_stripped_font_file():
+    compiler = vtt.Compiler(IN_SELAWIK)
+    compiler.compile_all()
+    out_compiled_stripped = TESTDATA / "out_c_s1.ttf"
+    compiler.save_font(out_compiled_stripped, vtt.StripLevel.STRIP_SOURCE)
+    return TTFont(out_compiled_stripped)
+
+@pytest.fixture
+def compiled_stripped_font_mem():
+    tt = TTFont(IN_SELAWIK)
+    compiler = vtt.Compiler(tt)
+    compiler.compile_all()
+    tt1 = compiler.get_ttfont(vtt.StripLevel.STRIP_SOURCE)
+    return tt1
+
+@pytest.fixture
+def compiled_source_from_bin_font_file():
+    compiler = vtt.Compiler(IN_SELAWIK)
+    compiler.import_source_from_binary()
+    out_import = TESTDATA / "out_c_c4i.ttf"
+    compiler.save_font(out_import, vtt.StripLevel.STRIP_NOTHING)
+    compiler.compile_all()
+    out_import_compiled = TESTDATA / "out_c_c4.ttf"
+    compiler.save_font(out_import_compiled, vtt.StripLevel.STRIP_NOTHING)
+    return TTFont(out_import_compiled)
+
+
+@pytest.fixture
+def compiled_source_from_bin_font_mem():
+    tt = TTFont(IN_SELAWIK)
+    compiler = vtt.Compiler(tt)
+    compiler.import_source_from_binary()
+    compiler.compile_all()
+    tt1 = compiler.get_ttfont(vtt.StripLevel.STRIP_NOTHING)
+    return tt1
+
+
+def compare_fonts(ttorig, ttcomp) -> None:
+   assert ttorig['maxp'].numGlyphs == ttcomp['maxp'].numGlyphs
+   assert ttorig['maxp'] == ttcomp['maxp']
+   assert ttorig['fpgm'] == ttcomp['fpgm']
+   assert ttorig['prep'] == ttcomp['prep']
+
+   glyf_orig = ttorig['glyf']
+   glyf_comp = ttcomp['glyf']
+
+   for glyph1 in ttorig.glyphOrder:
+       print(glyph1)
+       assert glyf_orig[glyph1].isComposite() == glyf_comp[glyph1].isComposite()
+       assert glyf_orig[glyph1].getCoordinates(glyf_orig) == glyf_comp[glyph1].getCoordinates(glyf_comp)
+       assert glyf_orig[glyph1].getComponentNames(glyf_orig) == glyf_comp[glyph1].getComponentNames(glyf_comp)
+       assert hasattr(glyf_orig[glyph1],'program') == hasattr(glyf_comp[glyph1],'program') 
+       haveInstructions = hasattr(glyf_orig[glyph1], "program")
+       if haveInstructions:
+           #orig_codes = glyf_orig[glyph1].program.getBytecode()
+           orig_assembly = glyf_orig[glyph1].program.getAssembly()
+           print(orig_assembly)
+           #comp_codes = glyf_comp[glyph1].program.getBytecode()
+           comp_assembly = glyf_comp[glyph1].program.getAssembly()
+           print(comp_assembly)
+           assert orig_assembly == comp_assembly
+
+def check_stripped(ttorig, ttstrip) -> None:
+    assert("TSI0" in ttorig)
+    assert("TSI0" not in ttstrip)
+
+    assert("TSI1" in ttorig)
+    assert("TSI1" not in ttstrip)
+
+    assert("TSI2" in ttorig)
+    assert("TSI2" not in ttstrip)
+
+    assert("TSI3" in ttorig)
+    assert("TSI3" not in ttstrip)
+
+    assert("TSI5" in ttorig)
+    assert("TSI5" not in ttstrip)
+
+
+def test_compiled_file_file_path(original_font, tmp_path: Path, compiled_font_file):
+   compare_fonts(original_font, compiled_font_file)  
+
+def test_compiled_file_file_str(original_font, tmp_path: Path, compiled_font_file_str):
+   compare_fonts(original_font, compiled_font_file_str)  
+
+def test_stripped_file_file(original_font, tmp_path: Path, compiled_stripped_font_file):
+    check_stripped(original_font, compiled_stripped_font_file)
+
+def test_compiled_file_mem(original_font, compiled_font_file_mem):
+   compare_fonts(original_font, compiled_font_file_mem)  
+
+def test_compiled_mem_file(original_font, compiled_font_mem_file):
+   compare_fonts(original_font, compiled_font_mem_file)  
+
+def test_compile_mem_mem(original_font, compiled_font_mem):
+    compare_fonts(original_font, compiled_font_mem)
+
+def test_stripped_mem_mem(original_font, compiled_stripped_font_mem):
+    check_stripped(original_font, compiled_stripped_font_mem)
+
+def test_import_source_from_binary_file(original_font, compiled_source_from_bin_font_file):
+    compare_fonts(original_font, compiled_source_from_bin_font_file)
+
+def test_import_source_from_binary_mem(original_font, compiled_source_from_bin_font_mem):
+    compare_fonts(original_font, compiled_source_from_bin_font_mem)
+    

vttcompilepy-0.0.1.8/vttcompilepy/quit_to_glyphs.py

@@ -0,0 +1,115 @@
+import sys
+from fontTools.ttLib import TTFont
+import vttcompilepy as vtt
+import argparse
+
+
+def add_quit_to_glyph_program(
+    font_path, output_path, compile, start_index, end_index, remove, iterate
+):
+    try:
+        # Load the font
+        font = TTFont(font_path)
+
+        # Access the TSI3 table (if it exists)
+        if "TSI3" in font:
+            tsi3_table = font["TSI3"]
+            glyph_set = font.getGlyphSet()
+            num_glyphs = len(glyph_set)
+            if end_index is None:
+                end_index = num_glyphs - 1
+            glyph_ids = list(range(start_index, end_index + 1))
+            glyph_names = font.getGlyphNameMany(glyph_ids)
+            added = 0
+            removed = 0
+
+            for glyph_name, glyph_id in zip(glyph_names, glyph_ids):
+                if glyph_name not in tsi3_table.glyphPrograms:
+                    print(f"{glyph_name} id = {glyph_id} does not have a glyph program")
+                    continue
+                if iterate:
+                    try:
+                        print(f"Iterate - trying {glyph_name} id = {glyph_id}")
+                        compiler = vtt.Compiler(font)
+                        compiler.compile_glyph_range(glyph_id, glyph_id)
+
+                    except Exception:
+                        # If compilation fails, add quit()
+                        # Check if the glyph program already starts with "quit()"
+                        if not tsi3_table.glyphPrograms[glyph_name].startswith(
+                            "quit()"
+                        ):
+                            tsi3_table.glyphPrograms[glyph_name] = (
+                                "quit() \n" + tsi3_table.glyphPrograms[glyph_name]
+                            )
+                            print(f"Added quit() to {glyph_name} id = {glyph_id}")
+                            added += 1
+
+                # Add or remove "quit()" to/from the beginning of each glyphProgram
+                elif remove:
+                    # Check if the glyph program contains "quit()"
+                    if "quit()" in tsi3_table.glyphPrograms[glyph_name]:
+                        tsi3_table.glyphPrograms[glyph_name] = tsi3_table.glyphPrograms[
+                            glyph_name
+                        ].replace("quit()", "")
+                        print(f"Removed quit() from {glyph_name} id = {glyph_id}")
+                        removed += 1
+                else:
+                    # Check if the glyph program already starts with "quit()"
+                    if not tsi3_table.glyphPrograms[glyph_name].startswith("quit()"):
+                        tsi3_table.glyphPrograms[glyph_name] = (
+                            "quit() \n" + tsi3_table.glyphPrograms[glyph_name]
+                        )
+                        print(f"Added quit() to {glyph_name} id = {glyph_id}")
+                        added += 1
+
+            if compile or iterate:
+                # Compile the font
+                compiler = vtt.Compiler(font)
+                compiler.compile_all()
+                font = compiler.get_ttfont(vtt.StripLevel.STRIP_NOTHING)
+                print("Font compiled")
+
+            # Save the modified font to the output path
+            font.save(output_path)
+
+            print(f"Modified font saved to {output_path}")
+            print(f"Added quit() to {added} glyphs")
+            print(f"Removed quit() from {removed} glyphs")
+        else:
+            print("The font does not have a TSI3 table")
+
+    except Exception as e:
+        print(f"Error: {e}")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Add or remove quit to/from glyph program."
+    )
+    parser.add_argument("input_font_path", help="The path to the input font file.")
+    parser.add_argument("output_font_path", help="The path to the output font file.")
+    parser.add_argument("--compile", action="store_true", help="Compile the font.")
+    parser.add_argument("--start", type=int, default=0, help="Start glyph index.")
+    parser.add_argument("--end", type=int, default=None, help="End glyph index.")
+    parser.add_argument(
+        "--remove", action="store_true", help="Remove quit() from glyph program."
+    )
+    parser.add_argument(
+        "--iterate", action="store_true", help="Only add quit() to glyphs that need it."
+    )
+    args = parser.parse_args()
+
+    add_quit_to_glyph_program(
+        args.input_font_path,
+        args.output_font_path,
+        args.compile,
+        args.start,
+        args.end,
+        args.remove,
+        args.iterate,
+    )
+
+
+if __name__ == "__main__":
+    main()