fonttools 4.59.1__cp314-cp314t-musllinux_1_2_aarch64.whl → 4.59.2__cp314-cp314t-musllinux_1_2_aarch64.whl

fontTools/cu2qu/cu2qu.py

@@ -37,7 +37,7 @@ NAN = float("NaN")
 @cython.cfunc
 @cython.inline
 @cython.returns(cython.double)
-@cython.locals(v1=cython.complex, v2=cython.complex)
+@cython.locals(v1=cython.complex, v2=cython.complex, result=cython.double)
 def dot(v1, v2):
     """Return the dot product of two vectors.
 
@@ -48,7 +48,16 @@ def dot(v1, v2):
     Returns:
         double: Dot product.
     """
-    return (v1 * v2.conjugate()).real
+    result = (v1 * v2.conjugate()).real
+    # When vectors are perpendicular (i.e. dot product is 0), the above expression may
+    # yield slightly different results when running in pure Python vs C/Cython,
+    # both of which are correct within IEEE-754 floating-point precision.
+    # It's probably due to the different order of operations and roundings in each
+    # implementation. Because we are using the result in a denominator and catching
+    # ZeroDivisionError (see `calc_intersect`), it's best to normalize the result here.
+    if abs(result) < 1e-15:
+        result = 0.0
+    return result
 
 
 @cython.cfunc
@@ -273,6 +282,12 @@ def calc_intersect(a, b, c, d):
     try:
         h = dot(p, a - c) / dot(p, cd)
     except ZeroDivisionError:
+        # if 3 or 4 points are equal, we do have an intersection despite the zero-div:
+        # return one of the off-curves so that the algorithm can attempt a one-curve
+        # solution if it's within tolerance:
+        # https://github.com/linebender/kurbo/pull/484
+        if b == c and (a == b or c == d):
+            return b
         return complex(NAN, NAN)
     return c + cd * h
 

fontTools/feaLib/builder.py

@@ -32,6 +32,7 @@ from fontTools.otlLib.builder import (
     AnySubstBuilder,
 )
 from fontTools.otlLib.error import OpenTypeLibError
+from fontTools.varLib.errors import VarLibError
 from fontTools.varLib.varStore import OnlineVarStoreBuilder
 from fontTools.varLib.builder import buildVarDevTable
 from fontTools.varLib.featureVars import addFeatureVariationsRaw
@@ -1728,9 +1729,14 @@ class Builder(object):
         if not varscalar.does_vary:
             return varscalar.default, None
 
-        default, index = varscalar.add_to_variation_store(
-            self.varstorebuilder, self.model_cache, self.font.get("avar")
-        )
+        try:
+            default, index = varscalar.add_to_variation_store(
+                self.varstorebuilder, self.model_cache, self.font.get("avar")
+            )
+        except VarLibError as e:
+            raise FeatureLibError(
+                "Failed to compute deltas for variable scalar", location
+            ) from e
 
         device = None
         if index is not None and index != 0xFFFFFFFF:

fontTools/feaLib/parser.py

@@ -2198,7 +2198,7 @@ class Parser(object):
                 raise FeatureLibError(
                     "Expected an equals sign", self.cur_token_location_
                 )
-            value = self.expect_number_()
+            value = self.expect_integer_or_float_()
             location[axis] = value
             if self.next_token_type_ is Lexer.NAME and self.next_token_[0] == ":":
                 # Lexer has just read the value as a glyph name. We'll correct it later
@@ -2230,6 +2230,16 @@ class Parser(object):
             "Expected a floating-point number", self.cur_token_location_
         )
 
+    def expect_integer_or_float_(self):
+        if self.next_token_type_ == Lexer.FLOAT:
+            return self.expect_float_()
+        elif self.next_token_type_ is Lexer.NUMBER:
+            return self.expect_number_()
+        else:
+            raise FeatureLibError(
+                "Expected an integer or floating-point number", self.cur_token_location_
+            )
+
     def expect_decipoint_(self):
         if self.next_token_type_ == Lexer.FLOAT:
             return self.expect_float_()

fontTools/feaLib/variableScalar.py

@@ -17,7 +17,12 @@ class VariableScalar:
     def __repr__(self):
         items = []
         for location, value in self.values.items():
-            loc = ",".join(["%s=%i" % (ax, loc) for ax, loc in location])
+            loc = ",".join(
+                [
+                    f"{ax}={int(coord) if float(coord).is_integer() else coord}"
+                    for ax, coord in location
+                ]
+            )
             items.append("%s:%i" % (loc, value))
         return "(" + (" ".join(items)) + ")"
 

fontTools/misc/textTools.py

@@ -1,5 +1,7 @@
 """fontTools.misc.textTools.py -- miscellaneous routines."""
 
+from __future__ import annotations
+
 import ast
 import string
 
@@ -118,14 +120,14 @@ def pad(data, size):
     return data
 
 
-def tostr(s, encoding="ascii", errors="strict"):
+def tostr(s: str | bytes, encoding: str = "ascii", errors: str = "strict") -> str:
     if not isinstance(s, str):
         return s.decode(encoding, errors)
     else:
         return s
 
 
-def tobytes(s, encoding="ascii", errors="strict"):
+def tobytes(s: str | bytes, encoding: str = "ascii", errors: str = "strict") -> bytes:
     if isinstance(s, str):
         return s.encode(encoding, errors)
     else:

fontTools/subset/__init__.py

@@ -1530,6 +1530,7 @@ def subset_glyphs(self, s):
         if self.MarkFilteringSet not in s.used_mark_sets:
             self.MarkFilteringSet = None
             self.LookupFlag &= ~0x10
+            self.LookupFlag |= 0x8
         else:
             self.MarkFilteringSet = s.used_mark_sets.index(self.MarkFilteringSet)
     return bool(self.SubTableCount)

fontTools/ttLib/tables/_a_v_a_r.py

@@ -143,7 +143,7 @@ class table__a_v_a_r(BaseTTXConverter):
         else:
             super().fromXML(name, attrs, content, ttFont)
 
-    def renormalizeLocation(self, location, font):
+    def renormalizeLocation(self, location, font, dropZeroes=True):
 
         majorVersion = getattr(self, "majorVersion", 1)
 
@@ -185,7 +185,9 @@ class table__a_v_a_r(BaseTTXConverter):
             out.append(v)
 
         mappedLocation = {
-            axis.axisTag: fi2fl(v, 14) for v, axis in zip(out, axes) if v != 0
+            axis.axisTag: fi2fl(v, 14)
+            for v, axis in zip(out, axes)
+            if v != 0 or not dropZeroes
         }
 
         return mappedLocation

fontTools/ttLib/tables/_n_a_m_e.py

@@ -1,4 +1,6 @@
 # -*- coding: utf-8 -*-
+from __future__ import annotations
+
 from fontTools.misc import sstruct
 from fontTools.misc.textTools import (
     bytechr,
@@ -63,7 +65,7 @@ class table__n_a_m_e(DefaultTable.DefaultTable):
             )
         stringData = data[stringOffset:]
         data = data[6:]
-        self.names = []
+        self.names: list[NameRecord] = []
         for i in range(n):
             if len(data) < 12:
                 log.error("skipping malformed name record #%d", i)
@@ -112,7 +114,9 @@ class table__n_a_m_e(DefaultTable.DefaultTable):
         self.names.append(name)
         name.fromXML(name, attrs, content, ttFont)
 
-    def getName(self, nameID, platformID, platEncID, langID=None):
+    def getName(
+        self, nameID: int, platformID: int, platEncID: int, langID: int | None = None
+    ) -> "NameRecord | None":
         for namerecord in self.names:
             if (
                 namerecord.nameID == nameID
@@ -123,8 +127,9 @@ class table__n_a_m_e(DefaultTable.DefaultTable):
                     return namerecord
         return None  # not found
 
-    def getDebugName(self, nameID):
-        englishName = someName = None
+    def getDebugName(self, nameID: int) -> str | None:
+        englishName: str | None = None
+        someName: str | None = None
         for name in self.names:
             if name.nameID != nameID:
                 continue
@@ -513,7 +518,7 @@ class NameRecord(object):
             self.platformID == 3 and self.platEncID in [0, 1, 10]
         )
 
-    def toUnicode(self, errors="strict"):
+    def toUnicode(self, errors: str = "strict") -> str:
         """
         If self.string is a Unicode string, return it; otherwise try decoding the
         bytes in self.string to a Unicode string using the encoding of this
@@ -533,7 +538,7 @@ class NameRecord(object):
         and saving it back will not change them.
         """
 
-        def isascii(b):
+        def isascii(b: int) -> bool:
             return (b >= 0x20 and b <= 0x7E) or b in [0x09, 0x0A, 0x0D]
 
         encoding = self.getEncoding()

fontTools/varLib/__init__.py

@@ -30,7 +30,11 @@ from fontTools.misc.fixedTools import floatToFixed as fl2fi
 from fontTools.misc.textTools import Tag, tostr
 from fontTools.ttLib import TTFont, newTable
 from fontTools.ttLib.tables._f_v_a_r import Axis, NamedInstance
-from fontTools.ttLib.tables._g_l_y_f import GlyphCoordinates, dropImpliedOnCurvePoints
+from fontTools.ttLib.tables._g_l_y_f import (
+    GlyphCoordinates,
+    dropImpliedOnCurvePoints,
+    USE_MY_METRICS,
+)
 from fontTools.ttLib.tables.ttProgram import Program
 from fontTools.ttLib.tables.TupleVariation import TupleVariation
 from fontTools.ttLib.tables import otTables as ot
@@ -489,6 +493,77 @@ def _merge_TTHinting(font, masterModel, master_ttfs):
         cvar.variations = variations
 
 
+def _has_inconsistent_use_my_metrics_flag(
+    master_glyf, glyph_name, flagged_components, expected_num_components
+) -> bool:
+    master_glyph = master_glyf.get(glyph_name)
+    # 'sparse' glyph master doesn't contribute. Besides when components don't match
+    # the VF build is going to fail anyway, so be lenient here.
+    if (
+        master_glyph is not None
+        and master_glyph.isComposite()
+        and len(master_glyph.components) == expected_num_components
+    ):
+        for i, base_glyph in flagged_components:
+            comp = master_glyph.components[i]
+            if comp.glyphName != base_glyph:
+                break
+            if not (comp.flags & USE_MY_METRICS):
+                return True
+    return False
+
+
+def _unset_inconsistent_use_my_metrics_flags(vf, master_fonts):
+    """Clear USE_MY_METRICS on composite components if inconsistent across masters.
+
+    If a composite glyph's component has USE_MY_METRICS set differently among
+    the masters, the flag is removed from the variable font's glyf table so that
+    advance widths are not determined by that single component's phantom points.
+    """
+    glyf = vf["glyf"]
+    master_glyfs = [m["glyf"] for m in master_fonts if "glyf" in m]
+    if not master_glyfs:
+        # Should not happen: at least the base master (as copied into vf) has glyf
+        return
+
+    for glyph_name in glyf.keys():
+        glyph = glyf[glyph_name]
+        if not glyph.isComposite():
+            continue
+
+        # collect indices of component(s) that carry the USE_MY_METRICS flag.
+        # This is supposed to be 1 component per composite, but you never know.
+        flagged_components = [
+            (i, comp.glyphName)
+            for i, comp in enumerate(glyph.components)
+            if (comp.flags & USE_MY_METRICS)
+        ]
+        if not flagged_components:
+            # Nothing to fix
+            continue
+
+        # Verify that for all master glyf tables that contribute this glyph, the
+        # corresponding component (same glyphName and index) also carries USE_MY_METRICS
+        # and unset the flag if not.
+        expected_num_components = len(glyph.components)
+        if any(
+            _has_inconsistent_use_my_metrics_flag(
+                master_glyf, glyph_name, flagged_components, expected_num_components
+            )
+            for master_glyf in master_glyfs
+        ):
+            comp_names = [name for _, name in flagged_components]
+            log.info(
+                "Composite glyph '%s' has inconsistent USE_MY_METRICS flags across "
+                "masters; clearing the flag on component%s %s",
+                glyph_name,
+                "s" if len(comp_names) > 1 else "",
+                comp_names if len(comp_names) > 1 else comp_names[0],
+            )
+            for i, _ in flagged_components:
+                glyph.components[i].flags &= ~USE_MY_METRICS
+
+
 _MetricsFields = namedtuple(
     "_MetricsFields",
     [
@@ -1205,6 +1280,10 @@ def build(
     if "DSIG" in vf:
         del vf["DSIG"]
 
+    # Clear USE_MY_METRICS composite flags if set inconsistently across masters.
+    if "glyf" in vf:
+        _unset_inconsistent_use_my_metrics_flags(vf, master_fonts)
+
     # TODO append masters as named-instances as well; needs .designspace change.
     fvar = _add_fvar(vf, ds.axes, ds.instances)
     if "STAT" not in exclude:

fontTools/varLib/instancer/__init__.py

@@ -1,4 +1,4 @@
-""" Partially instantiate a variable font.
+"""Partially instantiate a variable font.
 
 The module exports an `instantiateVariableFont` function and CLI that allow to
 create full instances (i.e. static fonts) from variable fonts, as well as "partial"
@@ -36,7 +36,7 @@ If the input location specifies all the axes, the resulting instance is no longe
 'variable' (same as using fontools varLib.mutator):
 .. code-block:: pycon
 
-    >>>    
+    >>>
     >> instance = instancer.instantiateVariableFont(
     ...     varfont, {"wght": 700, "wdth": 67.5}
     ... )
@@ -56,8 +56,10 @@ From the console script, this is equivalent to passing `wght=drop` as input.
 
 This module is similar to fontTools.varLib.mutator, which it's intended to supersede.
 Note that, unlike varLib.mutator, when an axis is not mentioned in the input
-location, the varLib.instancer will keep the axis and the corresponding deltas,
-whereas mutator implicitly drops the axis at its default coordinate.
+location, by default the varLib.instancer will keep the axis and the corresponding
+deltas, whereas mutator implicitly drops the axis at its default coordinate.
+To obtain the same behavior as mutator, pass the `static=True` parameter or
+the `--static` CLI option.
 
 The module supports all the following "levels" of instancing, which can of
 course be combined:
@@ -72,7 +74,7 @@ L1
 L2
     dropping one or more axes while pinning them at non-default locations;
     .. code-block:: pycon
-    
+
         >>>
         >> font = instancer.instantiateVariableFont(varfont, {"wght": 700})
 
@@ -81,22 +83,18 @@ L3
     a new minimum or maximum, potentially -- though not necessarily -- dropping
     entire regions of variations that fall completely outside this new range.
     .. code-block:: pycon
-    
+
         >>>
         >> font = instancer.instantiateVariableFont(varfont, {"wght": (100, 300)})
 
 L4
     moving the default location of an axis, by specifying (min,defalt,max) values:
     .. code-block:: pycon
-    
+
         >>>
         >> font = instancer.instantiateVariableFont(varfont, {"wght": (100, 300, 700)})
 
-Currently only TrueType-flavored variable fonts (i.e. containing 'glyf' table)
-are supported, but support for CFF2 variable fonts will be added soon.
-
-The discussion and implementation of these features are tracked at
-https://github.com/fonttools/fonttools/issues/1537
+Both TrueType-flavored (glyf+gvar) variable and CFF2 variable fonts are supported.
 """
 
 from fontTools.misc.fixedTools import (
@@ -435,7 +433,27 @@ class AxisLimits(_BaseAxisLimits):
 
         avarSegments = {}
         if usingAvar and "avar" in varfont:
-            avarSegments = varfont["avar"].segments
+            avar = varfont["avar"]
+            avarSegments = avar.segments
+
+            if getattr(avar, "majorVersion", 1) >= 2 and avar.table.VarStore:
+                pinnedAxes = set(self.pinnedLocation())
+                if not pinnedAxes.issuperset(avarSegments):
+                    raise NotImplementedError(
+                        "Partial-instancing avar2 table is not supported"
+                    )
+
+                # TODO: Merge this with the main codepath.
+
+                # Full instancing of avar2 font. Use avar table to normalize location and return.
+                location = self.pinnedLocation()
+                location = {
+                    tag: normalize(value, axes[tag], avarSegments.get(tag, None))
+                    for tag, value in location.items()
+                }
+                return NormalizedAxisLimits(
+                    **avar.renormalizeLocation(location, varfont, dropZeroes=False)
+                )
 
         normalizedLimits = {}
 
@@ -1122,7 +1140,8 @@ def _instantiateVHVAR(varfont, axisLimits, tableFields, *, round=round):
                     varIdx = advMapping.mapping[glyphName]
                 else:
                     varIdx = varfont.getGlyphID(glyphName)
-                metrics[glyphName] = (advanceWidth + round(defaultDeltas[varIdx]), sb)
+                delta = round(defaultDeltas[varIdx])
+                metrics[glyphName] = (max(0, advanceWidth + delta), sb)
 
             if (
                 tableTag == "VVAR"
@@ -1384,7 +1403,6 @@ def _isValidAvarSegmentMap(axisTag, segmentMap):
 
 
 def downgradeCFF2ToCFF(varfont):
-
     # Save these properties
     recalcTimestamp = varfont.recalcTimestamp
     recalcBBoxes = varfont.recalcBBoxes
@@ -1433,8 +1451,6 @@ def instantiateAvar(varfont, axisLimits):
     # 'axisLimits' dict must contain user-space (non-normalized) coordinates.
 
     avar = varfont["avar"]
-    if getattr(avar, "majorVersion", 1) >= 2 and avar.table.VarStore:
-        raise NotImplementedError("avar table with VarStore is not supported")
 
     segments = avar.segments
 
@@ -1445,6 +1461,9 @@ def instantiateAvar(varfont, axisLimits):
         del varfont["avar"]
         return
 
+    if getattr(avar, "majorVersion", 1) >= 2 and avar.table.VarStore:
+        raise NotImplementedError("avar table with VarStore is not supported")
+
     log.info("Instantiating avar table")
     for axis in pinnedAxes:
         if axis in segments:
@@ -1646,6 +1665,7 @@ def instantiateVariableFont(
     updateFontNames=False,
     *,
     downgradeCFF2=False,
+    static=False,
 ):
     """Instantiate variable font, either fully or partially.
 
@@ -1689,12 +1709,23 @@ def instantiateVariableFont(
             software that does not support CFF2. Defaults to False. Note that this
             operation also removes overlaps within glyph shapes, as CFF does not support
             overlaps but CFF2 does.
+        static (bool): if True, generate a full instance (static font) instead of a partial
+            instance (variable font).
     """
     # 'overlap' used to be bool and is now enum; for backward compat keep accepting bool
     overlap = OverlapMode(int(overlap))
 
     sanityCheckVariableTables(varfont)
 
+    if static:
+        unspecified = []
+        for axis in varfont["fvar"].axes:
+            if axis.axisTag not in axisLimits:
+                axisLimits[axis.axisTag] = None
+                unspecified.append(axis.axisTag)
+        if unspecified:
+            log.info("Pinning unspecified axes to default: %s", unspecified)
+
     axisLimits = AxisLimits(axisLimits).limitAxesAndPopulateDefaults(varfont)
 
     log.info("Restricted limits: %s", axisLimits)
@@ -1886,6 +1917,12 @@ def parseArgs(args):
         default=None,
         help="Output instance TTF file (default: INPUT-instance.ttf).",
     )
+    parser.add_argument(
+        "--static",
+        dest="static",
+        action="store_true",
+        help="Make a static font: pin unspecified axes to their default location.",
+    )
     parser.add_argument(
         "--no-optimize",
         dest="optimize",
@@ -1983,7 +2020,7 @@ def main(args=None):
         recalcBBoxes=options.recalc_bounds,
     )
 
-    isFullInstance = {
+    isFullInstance = options.static or {
         axisTag
         for axisTag, limit in axisLimits.items()
         if limit is None or limit[0] == limit[2]
@@ -1997,6 +2034,7 @@ def main(args=None):
         overlap=options.overlap,
         updateFontNames=options.update_name_table,
         downgradeCFF2=options.downgrade_cff2,
+        static=options.static,
     )
 
     suffix = "-instance" if isFullInstance else "-partial"

{fonttools-4.59.1.dist-info → fonttools-4.59.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fonttools
-Version: 4.59.1
+Version: 4.59.2
 Summary: Tools to manipulate font files
 Home-page: http://github.com/fonttools/fonttools
 Author: Just van Rossum
@@ -388,6 +388,20 @@ Have fun!
 Changelog
 ~~~~~~~~~
 
+4.59.2 (released 2025-08-27)
+----------------------------
+
+- [varLib] Clear ``USE_MY_METRICS`` component flags when inconsistent across masters (#3912).
+- [varLib.instancer] Avoid negative advance width/height values when instatiating HVAR/VVAR,
+  (unlikely in well-behaved fonts) (#3918).
+- [subset] Fix shaping behaviour when pruning empty mark sets (#3915, harfbuzz/harfbuzz#5499).
+- [cu2qu] Fixed ``dot()`` product of perpendicular vectors not always returning exactly 0.0
+  in all Python implementations (#3911)
+- [varLib.instancer] Implemented fully-instantiating ``avar2`` fonts (#3909).
+- [feaLib] Allow float values in ``VariableScalar``'s axis locations (#3906, #3907).
+- [cu2qu] Handle special case in ``calc_intersect`` for degenerate cubic curves where 3 to 4
+  control points are equal (#3904).
+
 4.59.1 (released 2025-08-14)
 ----------------------------