christiangeorgelucas/font-tools

import io

from gen.messages_pb2 import ConvertFontFormatRequest, ConvertFontFormatResponse
from gen.axiom_context import AxiomContext

from nodes._common import load_font, make_error, detect_format

# target_format value -> fontTools TTFont.flavor value. "ttf"/"otf"/"sfnt"
# are all aliases for the plain (uncompressed) SFNT container -- the
# source's own outline format (TrueType glyf-based vs. CFF-based OpenType)
# is preserved either way; this package doesn't convert outline formats,
# only the outer container.
_TARGET_FLAVORS = {
    "ttf": None,
    "otf": None,
    "sfnt": None,
    "woff": "woff",
    "woff2": "woff2",
}


def convert_font_format(ax: AxiomContext, input: ConvertFontFormatRequest) -> ConvertFontFormatResponse:
    """Convert a font between SFNT (TTF/OTF), WOFF, and WOFF2 container
    formats, preserving every table's content -- only the outer container
    and compression change. Useful for producing a web-deployable WOFF2
    from a desktop TTF, or unwrapping a WOFF/WOFF2 back to raw SFNT for
    tools (like this package's other nodes) that expect it.
    """
    loaded, font_error = load_font(input.font)
    if font_error is not None:
        return ConvertFontFormatResponse(error=font_error)

    target = input.target_format.strip().lower()
    if target not in _TARGET_FLAVORS:
        return ConvertFontFormatResponse(
            error=make_error(
                "INVALID_ARGUMENT",
                f"unsupported target_format '{input.target_format}' -- must be one of "
                f"{sorted(set(_TARGET_FLAVORS) - {'sfnt', 'otf'})}",
            )
        )

    source_format = detect_format(loaded.raw_data)

    try:
        loaded.ttfont.flavor = _TARGET_FLAVORS[target]
        out = io.BytesIO()
        loaded.ttfont.save(out)
        converted = out.getvalue()
    except Exception as exc:
        return ConvertFontFormatResponse(
            error=make_error("CONVERSION_FAILED", f"could not convert to '{target}': {exc}")
        )

    return ConvertFontFormatResponse(
        converted_font_data=converted,
        source_format=source_format,
        target_format=target,
        original_size_bytes=len(loaded.raw_data),
        converted_size_bytes=len(converted),
    )

from gen.messages_pb2 import GetGlyphNamesRequest, GetGlyphNamesResponse
from gen.axiom_context import AxiomContext

from nodes._common import load_font, make_error


def get_glyph_names(ax: AxiomContext, input: GetGlyphNamesRequest) -> GetGlyphNamesResponse:
    """List the font's complete glyph order: every glyph index's name, from
    its 'post' table (or synthesized "glyphNNNNN" placeholders for a CFF
    font with post format 3.0, which declares no per-glyph names).
    post_format reports which format was actually present.
    """
    loaded, font_error = load_font(input.font)
    if font_error is not None:
        return GetGlyphNamesResponse(error=font_error)

    try:
        names = list(loaded.ttfont.getGlyphOrder())
        post_format = "unknown"
        if "post" in loaded.ttfont:
            post_format = f"{float(loaded.ttfont['post'].formatType):.1f}"
    except Exception as exc:
        return GetGlyphNamesResponse(
            error=make_error("INVALID_FONT", f"could not read glyph order: {exc}")
        )

    return GetGlyphNamesResponse(glyph_names=names, post_format=post_format)

from gen.messages_pb2 import GetHeadTableRequest, GetHeadTableResponse, HeadInfo
from gen.axiom_context import AxiomContext

from nodes._common import load_font, make_error, mac_datetime_to_rfc3339


def get_head_table(ax: AxiomContext, input: GetHeadTableRequest) -> GetHeadTableResponse:
    """Read the font's 'head' table: units-per-em (the design-grid scale),
    font revision, creation/modification timestamps, the font's overall
    glyph bounding box, decoded macStyle bold/italic flags, and which
    loca-table format (short/long offsets) the font uses internally.
    """
    loaded, font_error = load_font(input.font)
    if font_error is not None:
        return GetHeadTableResponse(error=font_error)

    try:
        head = loaded.ttfont["head"]
        mac_style = int(head.macStyle)
        info = HeadInfo(
            units_per_em=int(head.unitsPerEm),
            font_revision=f"{float(head.fontRevision):.4f}".rstrip("0").rstrip("."),
            created=mac_datetime_to_rfc3339(head.created),
            modified=mac_datetime_to_rfc3339(head.modified),
            x_min=int(head.xMin),
            y_min=int(head.yMin),
            x_max=int(head.xMax),
            y_max=int(head.yMax),
            style_bold=bool(mac_style & 0x1),
            style_italic=bool(mac_style & 0x2),
            index_to_loc_format=int(head.indexToLocFormat),
        )
    except Exception as exc:
        return GetHeadTableResponse(
            error=make_error("INVALID_FONT", f"could not read 'head' table: {exc}")
        )

    return GetHeadTableResponse(head=info)

from gen.messages_pb2 import GetHheaTableRequest, GetHheaTableResponse, HheaInfo
from gen.axiom_context import AxiomContext

from nodes._common import load_font, make_error


def get_hhea_table(ax: AxiomContext, input: GetHheaTableRequest) -> GetHheaTableResponse:
    """Read the font's 'hhea' table: the horizontal-layout metrics
    (ascender, descender, line gap, advance-width max, side bearings,
    caret slope, hMetrics count) some renderers use for default line
    layout when OS/2 typo metrics aren't preferred.
    """
    loaded, font_error = load_font(input.font)
    if font_error is not None:
        return GetHheaTableResponse(error=font_error)

    try:
        hhea = loaded.ttfont["hhea"]
        info = HheaInfo(
            ascender=int(hhea.ascender),
            descender=int(hhea.descender),
            line_gap=int(hhea.lineGap),
            advance_width_max=int(hhea.advanceWidthMax),
            min_left_side_bearing=int(hhea.minLeftSideBearing),
            min_right_side_bearing=int(hhea.minRightSideBearing),
            x_max_extent=int(hhea.xMaxExtent),
            caret_slope_rise=int(hhea.caretSlopeRise),
            caret_slope_run=int(hhea.caretSlopeRun),
            caret_offset=int(hhea.caretOffset),
            number_of_h_metrics=int(hhea.numberOfHMetrics),
        )
    except Exception as exc:
        return GetHheaTableResponse(
            error=make_error("INVALID_FONT", f"could not read 'hhea' table: {exc}")
        )

    return GetHheaTableResponse(hhea=info)

from gen.messages_pb2 import GetKerningPairsRequest, GetKerningPairsResponse, KerningPair
from gen.axiom_context import AxiomContext

from nodes._common import load_font, make_error


def get_kerning_pairs(ax: AxiomContext, input: GetKerningPairsRequest) -> GetKerningPairsResponse:
    """Read legacy pair-kerning adjustments from the font's old-style
    'kern' table (format-0 subtables). Most current fonts use GPOS
    kerning instead and have no 'kern' table -- that's reported as an
    empty list, not an error.
    """
    loaded, font_error = load_font(input.font)
    if font_error is not None:
        return GetKerningPairsResponse(error=font_error)

    if "kern" not in loaded.ttfont:
        return GetKerningPairsResponse(pairs=[])

    try:
        kern = loaded.ttfont["kern"]
        pairs = []
        for subtable in getattr(kern, "kernTables", []):
            kern_table = getattr(subtable, "kernTable", None)
            if not kern_table:
                continue
            for (left, right), value in kern_table.items():
                pairs.append(
                    KerningPair(left_glyph=str(left), right_glyph=str(right), value=int(value))
                )
    except Exception as exc:
        return GetKerningPairsResponse(
            error=make_error("INVALID_FONT", f"could not read 'kern' table: {exc}")
        )

    return GetKerningPairsResponse(pairs=pairs)

from gen.messages_pb2 import GetOS2MetricsRequest, GetOS2MetricsResponse, OS2Info
from gen.axiom_context import AxiomContext

from nodes._common import load_font, make_error

_ITALIC = 0x0001
_BOLD = 0x0020
_REGULAR = 0x0040

_PANOSE_FIELDS = (
    "bFamilyType",
    "bSerifStyle",
    "bWeight",
    "bProportion",
    "bContrast",
    "bStrokeVariation",
    "bArmStyle",
    "bLetterForm",
    "bMidline",
    "bXHeight",
)


def get_os2_metrics(ax: AxiomContext, input: GetOS2MetricsRequest) -> GetOS2MetricsResponse:
    """Read the font's 'OS/2' table: weight/width classification,
    embedding-permission bits (fsType, for web-font licensing checks),
    typographic and Windows ascent/descent metrics, x-height/cap-height,
    PANOSE classification, vendor ID, and decoded fsSelection
    bold/italic/regular flags. Fields introduced in later OS/2 versions
    are zero when the font's table version predates them (version is
    reported so callers can tell).
    """
    loaded, font_error = load_font(input.font)
    if font_error is not None:
        return GetOS2MetricsResponse(error=font_error)

    if "OS/2" not in loaded.ttfont:
        return GetOS2MetricsResponse(
            error=make_error("TABLE_NOT_FOUND", "font has no 'OS/2' table")
        )

    try:
        os2 = loaded.ttfont["OS/2"]
        fs_selection = int(os2.fsSelection)
        panose = [int(getattr(os2.panose, f, 0)) for f in _PANOSE_FIELDS]
        info = OS2Info(
            version=int(os2.version),
            weight_class=int(os2.usWeightClass),
            width_class=int(os2.usWidthClass),
            fs_type=int(os2.fsType),
            s_typo_ascender=int(os2.sTypoAscender),
            s_typo_descender=int(os2.sTypoDescender),
            s_typo_line_gap=int(os2.sTypoLineGap),
            us_win_ascent=int(os2.usWinAscent),
            us_win_descent=int(os2.usWinDescent),
            # sxHeight/sCapHeight only exist on OS/2 version >= 2.
            s_x_height=int(getattr(os2, "sxHeight", 0)),
            s_cap_height=int(getattr(os2, "sCapHeight", 0)),
            panose=panose,
            ach_vend_id=str(os2.achVendID).strip(),
            selection_italic=bool(fs_selection & _ITALIC),
            selection_bold=bool(fs_selection & _BOLD),
            selection_regular=bool(fs_selection & _REGULAR),
        )
    except Exception as exc:
        return GetOS2MetricsResponse(
            error=make_error("INVALID_FONT", f"could not read 'OS/2' table: {exc}")
        )

    return GetOS2MetricsResponse(os2=info)

import io

from fontTools.varLib.instancer import instantiateVariableFont

from gen.messages_pb2 import InstantiateVariableFontRequest, InstantiateVariableFontResponse
from gen.axiom_context import AxiomContext

from nodes._common import load_font, make_error


def instantiate_variable_font(ax: AxiomContext, input: InstantiateVariableFontRequest) -> InstantiateVariableFontResponse:
    """Pin an OpenType Variable Font's design axes (e.g. wght, wdth, opsz)
    to specific coordinates, producing a standalone static font with the
    variable 'fvar'/'gvar'/'avar' tables removed and glyph outlines
    resolved at that exact point in the design space. Any axis left
    unspecified is pinned at the font's own declared default.
    """
    loaded, font_error = load_font(input.font)
    if font_error is not None:
        return InstantiateVariableFontResponse(error=font_error)

    if "fvar" not in loaded.ttfont:
        return InstantiateVariableFontResponse(
            error=make_error("TABLE_NOT_FOUND", "font has no 'fvar' table -- not a variable font")
        )

    fvar = loaded.ttfont["fvar"]
    axis_defaults = {axis.axisTag: axis.defaultValue for axis in fvar.axes}

    axis_limits = dict(axis_defaults)
    for coord in input.coordinates:
        if coord.tag not in axis_defaults:
            return InstantiateVariableFontResponse(
                error=make_error(
                    "INVALID_ARGUMENT",
                    f"'{coord.tag}' is not an axis of this font -- known axes: "
                    f"{sorted(axis_defaults)}",
                )
            )
        axis_limits[coord.tag] = coord.value

    try:
        instantiateVariableFont(loaded.ttfont, axis_limits, inplace=True)
        out = io.BytesIO()
        loaded.ttfont.save(out)
        instance_bytes = out.getvalue()
    except Exception as exc:
        return InstantiateVariableFontResponse(
            error=make_error("INSTANCING_FAILED", f"could not instantiate variable font: {exc}")
        )

    return InstantiateVariableFontResponse(
        instance_font_data=instance_bytes,
        instance_size_bytes=len(instance_bytes),
    )

from gen.messages_pb2 import (
    ListCmapSubtablesRequest,
    ListCmapSubtablesResponse,
    CmapSubtableInfo,
)
from gen.axiom_context import AxiomContext

from nodes._common import load_font, make_error


def list_cmap_subtables(ax: AxiomContext, input: ListCmapSubtablesRequest) -> ListCmapSubtablesResponse:
    """Enumerate every subtable in the font's 'cmap' table: platform ID,
    encoding ID, subtable format, and how many codepoint-to-glyph mappings
    it declares. Answers "which character encodings does this font
    actually support" without decoding every mapping.
    """
    loaded, font_error = load_font(input.font)
    if font_error is not None:
        return ListCmapSubtablesResponse(error=font_error)

    try:
        cmap = loaded.ttfont["cmap"]
        subtables = [
            CmapSubtableInfo(
                platform_id=int(st.platformID),
                encoding_id=int(st.platEncID),
                format=int(st.format),
                num_mappings=len(st.cmap),
            )
            for st in cmap.tables
        ]
    except Exception as exc:
        return ListCmapSubtablesResponse(
            error=make_error("INVALID_FONT", f"could not read 'cmap' table: {exc}")
        )

    return ListCmapSubtablesResponse(subtables=subtables)

from gen.messages_pb2 import ListTablesRequest, ListTablesResponse, TableEntry
from gen.axiom_context import AxiomContext

from nodes._common import load_font, detect_format, make_error


def list_tables(ax: AxiomContext, input: ListTablesRequest) -> ListTablesResponse:
    """List every table in a font's SFNT table directory (tag, byte length,
    checksum) plus the container's decoded format label (truetype,
    opentype-cff, woff, or woff2). The fastest way to answer "what tables
    does this font actually contain."
    """
    loaded, font_error = load_font(input.font)
    if font_error is not None:
        return ListTablesResponse(error=font_error)

    try:
        entries = []
        for tag, directory_entry in loaded.ttfont.reader.tables.items():
            entries.append(
                TableEntry(
                    tag=str(tag),
                    length=int(directory_entry.length),
                    # WOFF2 directory entries don't record a per-table
                    # checksum (only plain SFNT/WOFF do) -- 0 in that case.
                    checksum=int(getattr(directory_entry, "checkSum", 0)) & 0xFFFFFFFF,
                )
            )
        entries.sort(key=lambda e: e.tag)
    except Exception as exc:
        return ListTablesResponse(
            error=make_error("INVALID_FONT", f"could not read table directory: {exc}")
        )

    return ListTablesResponse(
        tables=entries,
        format=detect_format(loaded.raw_data),
    )