vfbLib 0.8.0__py3-none-any.whl

vfbLib/__init__.py

@@ -0,0 +1 @@
+GLYPH_CONSTANT = (1, 9, 7, 1)

vfbLib/cmdline.py

@@ -0,0 +1,214 @@
+import codecs
+import json
+import logging
+from argparse import ArgumentParser
+from pathlib import Path
+
+from vfbLib.ufo.builder import VfbToUfoBuilder
+from vfbLib.version import build_date
+from vfbLib.vfb.vfb import Vfb
+
+logger = logging.getLogger(__name__)
+
+
+def vfb2json():
+    parser = ArgumentParser(
+        description=(
+            f"VFB2JSON Converter\nCopyright (c) 2024 by LucasFonts\nBuild {build_date}"
+        )
+    )
+    parser.add_argument(
+        "-d",
+        "--no-decompile",
+        action="store_true",
+        default=False,
+        help="don't decompile data, output binary in JSON",
+    )
+    parser.add_argument(
+        "--header",
+        action="store_true",
+        default=False,
+        help="only read the VFB header, not the actual data",
+    )
+    parser.add_argument(
+        "-m",
+        "--minimal",
+        action="store_true",
+        default=False,
+        help="parse only minimal amount of data",
+    )
+    parser.add_argument(
+        "-p",
+        "--path",
+        type=str,
+        nargs=1,
+        help="output folder",
+    )
+    parser.add_argument(
+        "-u",
+        "--unicode-strings",
+        action="store_true",
+        default=False,
+        help="interpret name table strings as Unicode instead of Windows-1252",
+    )
+    parser.add_argument(
+        "inputpath",
+        type=str,
+        nargs=1,
+        help="input file path (.vfb)",
+    )
+    args = parser.parse_args()
+    if args:
+        vfb_path = Path(args.inputpath[0])
+        print(parser.description)
+        print(f"Reading file {vfb_path} ...")
+        vfb = Vfb(
+            vfb_path,
+            only_header=args.header,
+            minimal=args.minimal,
+            unicode_strings=args.unicode_strings,
+        )
+        if not args.no_decompile:
+            vfb.decompile()
+        suffix = ".vfb.json"
+        if args.path:
+            out_path = (Path(args.path[0]) / vfb_path.name).with_suffix(suffix)
+        else:
+            out_path = vfb_path.with_suffix(suffix)
+        with codecs.open(str(out_path), "wb", "utf-8") as f:
+            json.dump(vfb.as_dict(), f, ensure_ascii=False, indent=4)
+    else:
+        parser.print_help()
+
+
+def vfb2ufo():
+    parser = ArgumentParser(
+        description=(
+            f"VFB3UFO Converter\nCopyright (c) 2024 by LucasFonts\nBuild {build_date}"
+        )
+    )
+    parser.add_argument(
+        "-p",
+        "--path",
+        type=str,
+        nargs=1,
+        help="output folder",
+    )
+    parser.add_argument(
+        "-fo",
+        "--force-overwrite",
+        action="store_true",
+        default=False,
+        help="force overwrite",
+    )
+    parser.add_argument(
+        "-g",
+        "--keep-groups",
+        action="store_true",
+        default=False,
+        help="don't move non-kerning groups from groups.plist to feature code",
+    )
+    parser.add_argument(
+        "-k",
+        "--add-kerning-groups",
+        action="store_true",
+        default=False,
+        help="add kerning groups to feature code",
+    )
+    parser.add_argument(
+        "-ttx",
+        "--ttx",
+        action="store_true",
+        default=False,
+        help="convert binary OpenType Layout data using TTX-like format",
+    )
+    parser.add_argument(
+        "-64",
+        "--base64",
+        action="store_true",
+        default=False,
+        help="write GLIF lib 'data' section using base64 (recommended)",
+    )
+    parser.add_argument(
+        "-s",
+        "--silent",
+        action="store_true",
+        default=False,
+        help="no display (silent mode)",
+    )
+    parser.add_argument(
+        "-nops",
+        "--no-postscript-hints",
+        action="store_true",
+        default=False,
+        help="Don't output PostScript hinting",
+    )
+    parser.add_argument(
+        "-z",
+        "--zip",
+        action="store_true",
+        default=False,
+        help="write UFOZ (compressed UFO)",
+    )
+    parser.add_argument(
+        "inputpath",
+        type=str,
+        nargs=1,
+        help="input file path (.vfb)",
+    )
+    parser.add_argument(
+        "outputpath",
+        type=str,
+        nargs="?",
+        help="output file path (.ufo[z])",
+    )
+    parser.add_argument(
+        "-m",
+        "--minimal",
+        action="store_true",
+        default=False,
+        help="parse only minimal amount of data, drop missing glyphs from groups, etc.",
+    )
+    parser.add_argument(
+        "-u",
+        "--unicode-strings",
+        action="store_true",
+        default=False,
+        help="interpret name table strings as Unicode instead of Windows-1252",
+    )
+    args = parser.parse_args()
+    if args:
+        vfb_path = Path(args.inputpath[0])
+        if not args.silent:
+            print(parser.description)
+            print(f"Reading file {vfb_path} ...")
+        vfb = Vfb(
+            vfb_path,
+            minimal=args.minimal,
+            drop_keys={"Encoding", "Encoding Mac"},
+            unicode_strings=args.unicode_strings,
+        )
+        suffix = ".ufo"
+        if args.zip:
+            suffix += "z"
+        if args.path:
+            out_path = (Path(args.path[0]) / vfb_path.name).with_suffix(suffix)
+        else:
+            out_path = vfb_path.with_suffix(suffix)
+        vfb.decompile()
+        builder = VfbToUfoBuilder(
+            vfb,
+            minimal=args.minimal,
+            base64=args.base64,
+            pshints=not args.no_postscript_hints,
+            add_kerning_groups=args.add_kerning_groups,
+            move_groups=not args.keep_groups,
+        )
+        builder.write(
+            out_path,
+            overwrite=args.force_overwrite,
+            silent=args.silent,
+            ufoz=args.zip,
+        )
+    else:
+        parser.print_help()

vfbLib/compilers/base.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+from io import BytesIO
+from struct import pack
+from typing import TYPE_CHECKING, Any
+
+from fontTools.misc.textTools import hexStr
+
+from vfbLib.compilers.value import write_value, write_value_long
+from vfbLib.helpers import uint8, uint16  # , uint32
+
+if TYPE_CHECKING:
+    from io import BufferedWriter
+
+
+# Compilers for VFB entries
+
+
+class StreamWriter:
+    """
+    Base compiler class that writes values to the output stream.
+    This is the parent class for the general BaseCompiler, from which all other
+    compilers inherit, but it may be subclassed directly if more flexibility is needed.
+    """
+
+    def __init__(self) -> None:
+        self.encoding = "cp1252"
+        self.stream: BufferedWriter | BytesIO = BytesIO()
+
+    def write_bytes(self, value: bytes) -> None:
+        """
+        Write binary data to the stream.
+
+        Args:
+            value (bytes): The data.
+        """
+        self.stream.write(value)
+
+    def write_double(self, value: float) -> None:
+        raise NotImplementedError
+
+    def write_doubles(self, values: list[float]) -> None:
+        """Write several doubles to the stream.
+
+        Args:
+            values (list[float]): _description_
+        """
+        raise NotImplementedError
+
+    def write_float(self, value: float, fmt: str = "d") -> None:
+        """
+        Write a float value to the stream.
+        """
+        encoded = pack(fmt, value)
+        self.stream.write(encoded)
+
+    def write_floats(self, values: list[float]) -> None:
+        raise NotImplementedError
+
+    def write_int16(self, value: int) -> None:
+        raise NotImplementedError
+
+    def write_int32(self, value: int) -> None:
+        raise NotImplementedError
+
+    def write_str(self, value: str, pad: int = 0) -> None:
+        # XXX: Pad with 0 bytes to given length
+        self.stream.write(value.encode(self.encoding))
+
+    def write_uint8(self, value: int) -> None:
+        """
+        Write a uint8 value to the stream.
+        """
+        self.stream.write(value.to_bytes(uint8, byteorder="little", signed=False))
+
+    def write_uint16(self, value: int) -> None:
+        self.stream.write(value.to_bytes(uint16, byteorder="little", signed=False))
+
+    def write_uint32(self, value: int) -> None:
+        raise NotImplementedError
+
+    def write_value(self, value: int, shortest=True) -> None:
+        """
+        Encode and write an int value to the stream. Optionally don't apply the length
+        encoding optimization.
+
+        Args:
+            value (int): The value to write to the stream.
+            shortest (bool, optional): Whether to write the shortest possible
+                representation. Defaults to True.
+        """
+        if shortest:
+            write_value(value, self.stream)
+        else:
+            write_value_long(value, self.stream)
+
+
+class BaseCompiler(StreamWriter):
+    """
+    Base class to compile vfb data.
+    """
+
+    def compile(self, data: Any, master_count: int = 0) -> bytes:
+        """
+        Compile the JSON-like main data structure and return the compiled binary data.
+
+        Args:
+            data (Any): The main data structure.
+            master_count (int, optional): The number of masters. Defaults to 0.
+
+        Returns:
+            bytes: The compiled binary data.
+        """
+        self.master_count = master_count
+        self.stream = BytesIO()
+        self._compile(data)
+        return self.stream.getvalue()
+
+    def compile_hex(self, data: Any, master_count: int = 0) -> str:
+        """
+        Compile the data given into a hex string format, e.g. "8c 8d 89 8b". Used for
+        testing.
+
+        Args:
+            data (Any): The input data
+            master_count (int, optional): Number of masters. Defaults to 0.
+
+        Returns:
+            str: The hex string
+        """
+        b = self.compile(data, master_count)
+        return hexStr(b)
+
+    def _compile(self, data: Any) -> None:
+        raise NotImplementedError
+
+    @classmethod
+    def merge(cls, masters_data: list[Any], data: Any) -> None:
+        """
+        Merge the data of additional masters into the main data structure. This operates
+        on the uncompiled JSON-like data structure.
+
+        Args:
+            masters_data (List[Any]): The additional masters data as a list with one
+                entry per master.
+            data (Any): The main data structure.
+        """
+        # Must be implemented for compilers that need it, e.g. the GlyphCompiler.
+        pass
+
+
+class GlyphEncodingCompiler(BaseCompiler):
+    def _compile(self, data: Any) -> None:
+        gid, name = data
+        self.write_uint16(gid)
+        self.write_str(name)  # XXX: Does it have to be cp1252?

vfbLib/compilers/binary.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from typing import Any
+
+from fontTools.misc.textTools import deHexStr
+
+from vfbLib.compilers.base import BaseCompiler
+
+
+class BinaryTableCompiler(BaseCompiler):
+    """
+    A compiler that compiles binary table data.
+    """
+
+    def _compile(self, data: Any) -> None:
+        self.write_str(data["tag"])  # FIXME: Add padding here?
+        self.stream.write(deHexStr(data["data"]))

vfbLib/compilers/glyph.py

@@ -0,0 +1,239 @@
+import logging
+from io import BytesIO
+from math import radians, tan
+from struct import pack
+from typing import Any
+
+from vfbLib import GLYPH_CONSTANT
+from vfbLib.compilers.base import BaseCompiler, StreamWriter
+from vfbLib.parsers.glyph import PathCommand
+from vfbLib.truetype import TT_COMMAND_CONSTANTS, TT_COMMANDS
+
+logger = logging.getLogger(__name__)
+
+
+class GlyphCompiler(BaseCompiler):
+    @classmethod
+    def merge(cls, masters_data: list[Any], data: Any) -> None:
+        num_masters = len(masters_data)
+        if num_masters < 2:
+            return
+
+        for m in range(1, num_masters):
+            master_data = masters_data[m]
+            # See if there is any data to merge
+            if "nodes" in master_data:
+                assert "nodes" in data
+                for i, tgt in enumerate(data["nodes"]):
+                    src = master_data["nodes"][i]
+                    for key in ("type", "flags"):
+                        assert src[key] == tgt[key]
+                    tgt["points"][m] = src["points"][m]
+
+            if "components" in master_data:
+                assert "components" in data
+                for i, tgt in enumerate(data["components"]):
+                    src = master_data["components"][i]
+                    for key in ("gid",):
+                        assert src[key] == tgt[key]
+                    tgt["offsetX"][m] = src["offsetX"][m]
+                    tgt["offsetY"][m] = src["offsetY"][m]
+                    tgt["scaleX"][m] = src["scaleX"][m]
+                    tgt["scaleY"][m] = src["scaleY"][m]
+
+    def _compile_binary(self, data):
+        # Imported binary data 8-)
+        if not (imported := data.get("imported")):  # noqa: F841
+            return
+
+        logger.warning("Compiling imported binary data is not supported.")
+        return
+
+        self.write_uint8(9)
+
+    def _compile_components(self, data):
+        # Components
+        if not (components := data.get("components")):
+            return
+
+        self.write_uint8(5)
+        self.write_value(len(components))
+        for component in components:
+            self.write_value(component["gid"])
+            for i in range(self.num_masters):
+                self.write_value(component["offsetX"][i])
+                self.write_value(component["offsetY"][i])
+                self.write_float(component["scaleX"][i])
+                self.write_float(component["scaleY"][i])
+
+    def _compile_glyph_name(self, data):
+        # Glyph name
+        if not (name := data.get("name")):
+            return
+
+        glyph_name = name.encode("cp1252")
+        glyph_name_length = len(glyph_name)
+        self.write_uint8(1)
+        self.write_value(glyph_name_length)
+        self.write_bytes(glyph_name)
+        logger.debug(f"Compiling glyph '{name}'")
+
+    def _compile_guides(self, data):
+        # Guidelines
+        # TODO: Reuse for global guides
+        if not (guides := data.get("guides")):
+            return
+
+        self.write_uint8(4)
+        for direction in ("h", "v"):
+            direction_guides = guides.get(direction)
+            if direction_guides is None:
+                self.write_value(0)
+                continue
+
+            self.write_value(len(direction_guides[0]))  # first master
+            for m in range(self.num_masters):
+                for guide in direction_guides[m]:
+                    pos = guide["pos"]
+                    angle = round(tan(radians(guide["angle"])) * 10000)
+                    self.write_value(pos)
+                    self.write_value(angle)
+
+    def _compile_hints(self, data):
+        # PostScript hints
+        # To minimize diffs, we always write out hint, but it is not necessary
+        hints = data.get("hints", {})
+        # We could skip empty hinting:
+        # if not (hints := data.get("hints")):
+        #     return
+
+        self.write_uint8(3)
+        for direction in ("h", "v"):
+            if direction_hints := hints.get(direction):
+                self.write_value(len(direction_hints))
+                for mm_hint in direction_hints:
+                    for i in range(self.num_masters):
+                        hint = mm_hint[i]
+                        self.write_value(hint["pos"])
+                        self.write_value(hint["width"])
+            else:
+                self.write_value(0)
+
+        if not (hintmasks := hints.get("hintmasks")):  # noqa: F841
+            self.write_value(0)
+            return
+
+        self.write_value(len(hintmasks))
+        for k, v in hintmasks:
+            key = {
+                "h": 0x01,
+                "v": 0x02,
+                "r": 0xFF,
+            }[k]
+            self.write_uint8(key)
+            self.write_value(v)
+
+    def _compile_instructions(self, data):
+        # TrueType instructions
+        if not (tth := data.get("tth")):
+            return
+
+        self.write_uint8(0x0A)
+        instructions = InstructionsCompiler().compile(tth)
+        self.write_value(len(instructions))
+        self.stream.write(instructions)
+
+    def _compile_kerning(self, data):
+        # Kerning
+        if not (kerning := data.get("kerning")):
+            return
+
+        self.write_uint8(6)
+        self.write_value(len(kerning))
+        for gid, values in kerning.items():
+            self.write_value(gid)
+            for value in values:
+                self.write_value(value)
+
+    def _compile_metrics(self, data):
+        # Metrics
+        if not (metrics := data.get("metrics")):
+            return
+
+        self.write_uint8(2)
+        for i in range(self.num_masters):
+            x, y = metrics[i]
+            self.write_value(x)
+            self.write_value(y)
+
+    def _compile_outlines(self, data):
+        # Outlines
+        # A minimal outlines structure is always written:
+        self.write_uint8(8)
+        self.write_value(self.num_masters)  # Number of masters
+
+        if not (nodes := data.get("nodes")):
+            # 0 nodes with 0 values
+            self.write_value(0)
+            self.write_value(0)
+            return
+
+        outlines, num_values = OutlinesCompiler().compile(nodes, self.num_masters)
+        self.write_value(num_values)
+        self.stream.write(outlines)
+
+    def _compile(self, data: Any) -> None:
+        # Constants?
+        self.write_bytes(pack("<4B", *GLYPH_CONSTANT))
+        self.num_masters = data["num_masters"]
+
+        self._compile_glyph_name(data)
+        self._compile_outlines(data)
+        self._compile_metrics(data)
+        self._compile_hints(data)
+        self._compile_guides(data)
+        self._compile_components(data)
+        self._compile_kerning(data)
+        self._compile_binary(data)
+        self._compile_instructions(data)
+        self.write_uint8(15)  # End of glyph
+
+
+class InstructionsCompiler(BaseCompiler):
+    def _compile(self, data: Any) -> None:
+        self.write_value(len(data))
+        for cmd in data:
+            command_id = TT_COMMAND_CONSTANTS[cmd["cmd"]]
+            self.write_uint8(command_id)
+            params = cmd["params"]
+            for param_name in TT_COMMANDS[command_id]["params"]:
+                self.write_value(params[param_name])
+        for _ in range(3):
+            self.write_value(0)
+
+
+class OutlinesCompiler(StreamWriter):
+    def compile(self, data: Any, num_masters: int) -> tuple[bytes, int]:
+        self.num_masters = num_masters
+        self.stream = BytesIO()
+        num_values = self._compile(data)
+        return self.stream.getvalue(), num_values
+
+    def _compile(self, data: Any) -> int:
+        self.write_value(len(data))  # Number of nodes, may be 0
+        num_values = 0
+        ref_coords = [[0, 0] for _ in range(self.num_masters)]
+        for node in data:
+            type_flags = node.get("flags", 0) * 16 + PathCommand[node["type"]].value
+            self.write_uint8(type_flags)
+            num_values += 1
+            for j in range(len(node["points"][0])):
+                for i in range(self.num_masters):
+                    x, y = node["points"][i][j]
+                    refx, refy = ref_coords[i]
+                    # Coordinates are written relatively to the previous coords
+                    self.write_value(x - refx)
+                    self.write_value(y - refy)
+                    num_values += 2
+                    ref_coords[i] = [x, y]
+        return 2 * num_values

vfbLib/compilers/header.py

@@ -0,0 +1,41 @@
+import logging
+from io import BytesIO
+from typing import Any
+
+from fontTools.misc.textTools import deHexStr
+
+from vfbLib.compilers.base import StreamWriter
+
+logger = logging.getLogger(__name__)
+
+
+class VfbHeaderCompiler(StreamWriter):
+    encoding = "cp1252"
+
+    def compile(self, data: Any) -> bytes:
+        self.stream = BytesIO()
+        self._compile(data)
+        return self.stream.getvalue()
+
+    def _compile(self, data: Any) -> None:
+        self.write_uint8(data["header0"])
+        self.write_str(data["filetype"])
+        self.write_uint16(data["header1"])
+        self.write_uint16(data["header2"])
+        self.write_bytes(deHexStr(data["reserved"]))
+        self.write_uint16(data["header3"])
+        self.write_uint16(data["header4"])
+        self.write_uint16(data["header5"])
+        self.write_uint16(data["header6"])
+        self.write_uint16(data["header7"])
+        # > FL3 additions
+        self.write_uint16(data["header8"])
+        for i in range(9, 12):
+            d = data[f"header{i}"]
+            assert len(d) == 1
+            k, v = tuple(d.items())[0]
+            self.write_uint8(int(k))
+            self.write_value(v)
+        self.write_uint8(data["header12"])
+        self.write_uint16(data["header13"])
+        self.write_uint16(data["header14"])

vfbLib/compilers/numeric.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from typing import Any
+
+from vfbLib.compilers.base import BaseCompiler
+
+
+class Int16Compiler(BaseCompiler):
+    """
+    A compiler that compiles UInt16 data.
+    """
+
+    def _compile(self, data: Any) -> None:
+        self.write_uint16(data)