fonttools 4.55.4__cp313-cp313-musllinux_1_2_aarch64.whl → 4.61.1__cp313-cp313-musllinux_1_2_aarch64.whl

fontTools/varLib/models.py

@@ -1,5 +1,7 @@
 """Variation fonts interpolation models."""
 
+from __future__ import annotations
+
 __all__ = [
     "normalizeValue",
     "normalizeLocation",
@@ -8,10 +10,15 @@ __all__ = [
     "VariationModel",
 ]
 
+from typing import TYPE_CHECKING
 from fontTools.misc.roundTools import noRound
 from .errors import VariationModelError
 
 
+if TYPE_CHECKING:
+    from typing import Mapping, Sequence
+
+
 def nonNone(lst):
     return [l for l in lst if l is not None]
 
@@ -44,7 +51,9 @@ def subList(truth, lst):
     return [l for l, t in zip(lst, truth) if t]
 
 
-def normalizeValue(v, triple, extrapolate=False):
+def normalizeValue(
+    v: float, triple: Sequence[float], extrapolate: bool = False
+) -> float:
     """Normalizes value based on a min/default/max triple.
 
     >>> normalizeValue(400, (100, 400, 900))
@@ -75,7 +84,13 @@ def normalizeValue(v, triple, extrapolate=False):
         return (v - default) / (upper - default)
 
 
-def normalizeLocation(location, axes, extrapolate=False, *, validate=False):
+def normalizeLocation(
+    location: Mapping[str, float],
+    axes: Mapping[str, tuple[float, float, float]],
+    extrapolate: bool = False,
+    *,
+    validate: bool = False,
+) -> dict[str, float]:
     """Normalizes location based on axis min/default/max values from axes.
 
     >>> axes = {"wght": (100, 400, 900)}

fontTools/varLib/mutator.py

@@ -4,9 +4,16 @@ Instantiate a variation font.  Run, eg:
 .. code-block:: sh
 
     $ fonttools varLib.mutator ./NotoSansArabic-VF.ttf wght=140 wdth=85
+
+.. warning::
+   ``fontTools.varLib.mutator`` is deprecated in favor of :mod:`fontTools.varLib.instancer`
+   which provides equivalent full instancing and also supports partial instancing.
+   Please migrate CLI usage to ``fonttools varLib.instancer`` and API usage to
+   :func:`fontTools.varLib.instancer.instantiateVariableFont`.
 """
 
 from fontTools.misc.fixedTools import floatToFixedToFloat, floatToFixed
+from fontTools.misc.loggingTools import deprecateFunction
 from fontTools.misc.roundTools import otRound
 from fontTools.pens.boundsPen import BoundsPen
 from fontTools.ttLib import TTFont, newTable
@@ -159,6 +166,10 @@ def interpolate_cff2_metrics(varfont, topDict, glyphOrder, loc):
             hmtx[gname] = tuple(entry)
 
 
+@deprecateFunction(
+    "use fontTools.varLib.instancer.instantiateVariableFont instead "
+    "for either full or partial instancing",
+)
 def instantiateVariableFont(varfont, location, inplace=False, overlap=True):
     """Generate a static instance from a variable TTFont and a dictionary
     defining the desired location along the variable font's axes.

fontTools/varLib/varStore.py

@@ -41,7 +41,7 @@ class OnlineVarStoreBuilder(object):
     def setSupports(self, supports):
         self._model = None
         self._supports = list(supports)
-        if not self._supports[0]:
+        if self._supports and not self._supports[0]:
             del self._supports[0]  # Drop base master support
         self._cache = None
         self._data = None
@@ -412,25 +412,6 @@ class _Encoding(object):
     def extend(self, lst):
         self.items.update(lst)
 
-    def get_room(self):
-        """Maximum number of bytes that can be added to characteristic
-        while still being beneficial to merge it into another one."""
-        count = len(self.items)
-        return max(0, (self.overhead - 1) // count - self.width)
-
-    room = property(get_room)
-
-    def get_gain(self):
-        """Maximum possible byte gain from merging this into another
-        characteristic."""
-        count = len(self.items)
-        return max(0, self.overhead - count)
-
-    gain = property(get_gain)
-
-    def gain_sort_key(self):
-        return self.gain, self.chars
-
     def width_sort_key(self):
         return self.width, self.chars
 
@@ -534,13 +515,9 @@ def VarStore_optimize(self, use_NO_VARIATION_INDEX=True, quantization=1):
     # of the old encoding is completely eliminated. However, each row
     # now would require more bytes to encode, to the tune of one byte
     # per characteristic bit that is active in the new encoding but not
-    # in the old one. The number of bits that can be added to an encoding
-    # while still beneficial to merge it into another encoding is called
-    # the "room" for that encoding.
+    # in the old one.
     #
-    # The "gain" of an encodings is the maximum number of bytes we can
-    # save by merging it into another encoding. The "gain" of merging
-    # two encodings is how many bytes we save by doing so.
+    # The "gain" of merging two encodings is how many bytes we save by doing so.
     #
     # High-level algorithm:
     #
@@ -554,7 +531,11 @@ def VarStore_optimize(self, use_NO_VARIATION_INDEX=True, quantization=1):
     #
     # - Put all encodings into a "todo" list.
     #
-    # - Sort todo list by decreasing gain (for stability).
+    # - Sort todo list (for stability) by width_sort_key(), which is a tuple
+    #   of the following items:
+    #   * The "width" of the encoding.
+    #   * The characteristic bitmap of the encoding, with higher-numbered
+    #     columns compared first.
     #
     # - Make a priority-queue of the gain from combining each two
     #   encodings in the todo list. The priority queue is sorted by
@@ -575,16 +556,7 @@ def VarStore_optimize(self, use_NO_VARIATION_INDEX=True, quantization=1):
     #
     # The output is then sorted for stability, in the following way:
     # - The VarRegionList of the input is kept intact.
-    # - All encodings are sorted before the main algorithm, by
-    #   gain_key_sort(), which is a tuple of the following items:
-    #   * The gain of the encoding.
-    #   * The characteristic bitmap of the encoding, with higher-numbered
-    #     columns compared first.
-    # - The VarData is sorted by width_sort_key(), which is a tuple
-    #   of the following items:
-    #   * The "width" of the encoding.
-    #   * The characteristic bitmap of the encoding, with higher-numbered
-    #     columns compared first.
+    # - The VarData is sorted by the same width_sort_key() used at the beginning.
     # - Within each VarData, the items are sorted as vectors of numbers.
     #
     # Finally, each VarData is optimized to remove the empty columns and
@@ -626,7 +598,7 @@ def VarStore_optimize(self, use_NO_VARIATION_INDEX=True, quantization=1):
             front_mapping[(major << 16) + minor] = row
 
     # Prepare for the main algorithm.
-    todo = sorted(encodings.values(), key=_Encoding.gain_sort_key)
+    todo = sorted(encodings.values(), key=_Encoding.width_sort_key)
     del encodings
 
     # Repeatedly pick two best encodings to combine, and combine them.

fontTools/voltLib/__main__.py

@@ -0,0 +1,206 @@
+import argparse
+import logging
+import sys
+from io import StringIO
+from pathlib import Path
+
+from fontTools import configLogger
+from fontTools.feaLib.builder import addOpenTypeFeaturesFromString
+from fontTools.feaLib.error import FeatureLibError
+from fontTools.feaLib.lexer import Lexer
+from fontTools.misc.cliTools import makeOutputFileName
+from fontTools.ttLib import TTFont, TTLibError
+from fontTools.voltLib.parser import Parser
+from fontTools.voltLib.voltToFea import TABLES, VoltToFea
+
+log = logging.getLogger("fontTools.feaLib")
+
+SUPPORTED_TABLES = TABLES + ["cmap"]
+
+
+def invalid_fea_glyph_name(name):
+    """Check if the glyph name is valid according to FEA syntax."""
+    if name[0] not in Lexer.CHAR_NAME_START_:
+        return True
+    if any(c not in Lexer.CHAR_NAME_CONTINUATION_ for c in name[1:]):
+        return True
+    return False
+
+
+def sanitize_glyph_name(name):
+    """Sanitize the glyph name to ensure it is valid according to FEA syntax."""
+    sanitized = ""
+    for i, c in enumerate(name):
+        if i == 0 and c not in Lexer.CHAR_NAME_START_:
+            sanitized += "a" + c
+        elif c not in Lexer.CHAR_NAME_CONTINUATION_:
+            sanitized += "_"
+        else:
+            sanitized += c
+
+    return sanitized
+
+
+def main(args=None):
+    """Build tables from a MS VOLT project into an OTF font"""
+    parser = argparse.ArgumentParser(
+        description="Use fontTools to compile MS VOLT projects."
+    )
+    parser.add_argument(
+        "input",
+        metavar="INPUT",
+        help="Path to the input font/VTP file to process",
+        type=Path,
+    )
+    parser.add_argument(
+        "-f",
+        "--font",
+        metavar="INPUT_FONT",
+        help="Path to the input font (if INPUT is a VTP file)",
+        type=Path,
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        dest="output",
+        metavar="OUTPUT",
+        help="Path to the output font.",
+        type=Path,
+    )
+    parser.add_argument(
+        "-t",
+        "--tables",
+        metavar="TABLE_TAG",
+        choices=SUPPORTED_TABLES,
+        nargs="+",
+        help="Specify the table(s) to be built.",
+    )
+    parser.add_argument(
+        "-F",
+        "--debug-feature-file",
+        help="Write the generated feature file to disk.",
+        action="store_true",
+    )
+    parser.add_argument(
+        "--ship",
+        help="Remove source VOLT tables from output font.",
+        action="store_true",
+    )
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        help="Increase the logger verbosity. Multiple -v options are allowed.",
+        action="count",
+        default=0,
+    )
+    parser.add_argument(
+        "-T",
+        "--traceback",
+        help="show traceback for exceptions.",
+        action="store_true",
+    )
+    options = parser.parse_args(args)
+
+    levels = ["WARNING", "INFO", "DEBUG"]
+    configLogger(level=levels[min(len(levels) - 1, options.verbose)])
+
+    output_font = options.output or Path(
+        makeOutputFileName(options.font or options.input)
+    )
+    log.info(f"Compiling MS VOLT to '{output_font}'")
+
+    file_or_path = options.input
+    font = None
+
+    # If the input is a font file, extract the VOLT data from the "TSIV" table
+    try:
+        font = TTFont(file_or_path)
+        if "TSIV" in font:
+            file_or_path = StringIO(font["TSIV"].data.decode("utf-8"))
+        else:
+            log.error('"TSIV" table is missing')
+            return 1
+    except TTLibError:
+        pass
+
+    # If input is not a font file, the font must be provided
+    if font is None:
+        if not options.font:
+            log.error("Please provide an input font")
+            return 1
+        font = TTFont(options.font)
+
+    # FEA syntax does not allow some glyph names that VOLT accepts, so if we
+    # found such glyph name we will temporarily rename such glyphs.
+    glyphOrder = font.getGlyphOrder()
+    tempGlyphOrder = None
+    if any(invalid_fea_glyph_name(n) for n in glyphOrder):
+        tempGlyphOrder = []
+        for n in glyphOrder:
+            if invalid_fea_glyph_name(n):
+                n = sanitize_glyph_name(n)
+                existing = set(tempGlyphOrder) | set(glyphOrder)
+                while n in existing:
+                    n = "a" + n
+            tempGlyphOrder.append(n)
+        font.setGlyphOrder(tempGlyphOrder)
+
+    doc = Parser(file_or_path).parse()
+
+    log.info("Converting VTP data to FEA")
+    converter = VoltToFea(doc, font)
+    try:
+        fea = converter.convert(options.tables, ignore_unsupported_settings=True)
+    except NotImplementedError as e:
+        if options.traceback:
+            raise
+        location = getattr(e.args[0], "location", None)
+        message = f'"{e}" is not supported'
+        if location:
+            path, line, column = location
+            log.error(f"{path}:{line}:{column}: {message}")
+        else:
+            log.error(message)
+        return 1
+
+    fea_filename = options.input
+    if options.debug_feature_file:
+        fea_filename = output_font.with_suffix(".fea")
+        log.info(f"Writing FEA to '{fea_filename}'")
+        with open(fea_filename, "w") as fp:
+            fp.write(fea)
+
+    log.info("Compiling FEA to OpenType tables")
+    try:
+        addOpenTypeFeaturesFromString(
+            font,
+            fea,
+            filename=fea_filename,
+            tables=options.tables,
+        )
+    except FeatureLibError as e:
+        if options.traceback:
+            raise
+        log.error(e)
+        return 1
+
+    if options.ship:
+        for tag in ["TSIV", "TSIS", "TSIP", "TSID"]:
+            if tag in font:
+                del font[tag]
+
+    # Restore original glyph names.
+    if tempGlyphOrder:
+        import io
+
+        f = io.BytesIO()
+        font.save(f)
+        font = TTFont(f)
+        font.setGlyphOrder(glyphOrder)
+        font["post"].extraNames = []
+
+    font.save(output_font)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

fontTools/voltLib/ast.py

@@ -317,6 +317,10 @@ class SubstitutionLigatureDefinition(SubstitutionDefinition):
     pass
 
 
+class SubstitutionAlternateDefinition(SubstitutionDefinition):
+    pass
+
+
 class SubstitutionReverseChainingSingleDefinition(SubstitutionDefinition):
     pass
 

fontTools/voltLib/parser.py

@@ -313,19 +313,27 @@ class Parser(object):
         self.expect_keyword_("END_SUBSTITUTION")
         max_src = max([len(cov) for cov in src])
         max_dest = max([len(cov) for cov in dest])
+
         # many to many or mixed is invalid
-        if (max_src > 1 and max_dest > 1) or (
-            reversal and (max_src > 1 or max_dest > 1)
-        ):
+        if max_src > 1 and max_dest > 1:
             raise VoltLibError("Invalid substitution type", location)
+
         mapping = dict(zip(tuple(src), tuple(dest)))
         if max_src == 1 and max_dest == 1:
-            if reversal:
-                sub = ast.SubstitutionReverseChainingSingleDefinition(
-                    mapping, location=location
-                )
+            # Alternate substitutions are represented by adding multiple
+            # substitutions for the same glyph, so we detect that here
+            glyphs = [x.glyphSet() for cov in src for x in cov]  # flatten src
+            if len(set(glyphs)) != len(glyphs):  # src has duplicates
+                sub = ast.SubstitutionAlternateDefinition(mapping, location=location)
             else:
-                sub = ast.SubstitutionSingleDefinition(mapping, location=location)
+                if reversal:
+                    # Reversal is valid only for single glyph substitutions
+                    # and VOLT ignores it otherwise.
+                    sub = ast.SubstitutionReverseChainingSingleDefinition(
+                        mapping, location=location
+                    )
+                else:
+                    sub = ast.SubstitutionSingleDefinition(mapping, location=location)
         elif max_src == 1 and max_dest > 1:
             sub = ast.SubstitutionMultipleDefinition(mapping, location=location)
         elif max_src > 1 and max_dest == 1: