fonttools 4.59.0__cp313-cp313-musllinux_1_2_aarch64.whl → 4.59.2__cp313-cp313-musllinux_1_2_aarch64.whl

fontTools/ttLib/tables/_g_v_a_r.py

@@ -64,7 +64,6 @@ class table__g_v_a_r(DefaultTable.DefaultTable):
         self.variations = {}
 
     def compile(self, ttFont):
-
         axisTags = [axis.axisTag for axis in ttFont["fvar"].axes]
         sharedTuples = tv.compileSharedTuples(
             axisTags, itertools.chain(*self.variations.values())
@@ -141,8 +140,12 @@ class table__g_v_a_r(DefaultTable.DefaultTable):
             self,
         )
 
-        assert len(glyphs) == self.glyphCount
-        assert len(axisTags) == self.axisCount
+        assert len(glyphs) == self.glyphCount, (len(glyphs), self.glyphCount)
+        assert len(axisTags) == self.axisCount, (
+            len(axisTags),
+            self.axisCount,
+            axisTags,
+        )
         sharedCoords = tv.decompileSharedTuples(
             axisTags, self.sharedTupleCount, data, self.offsetToSharedTuples
         )

fontTools/ttLib/tables/_h_m_t_x.py

@@ -40,15 +40,19 @@ class table__h_m_t_x(DefaultTable.DefaultTable):
                 % (self.headerTag, self.numberOfMetricsName)
             )
             numberOfMetrics = numGlyphs
-        if len(data) < 4 * numberOfMetrics:
-            raise ttLib.TTLibError("not enough '%s' table data" % self.tableTag)
+        numberOfSideBearings = numGlyphs - numberOfMetrics
+        tableSize = 4 * numberOfMetrics + 2 * numberOfSideBearings
+        if len(data) < tableSize:
+            raise ttLib.TTLibError(
+                f"not enough '{self.tableTag}' table data: "
+                f"expected {tableSize} bytes, got {len(data)}"
+            )
         # Note: advanceWidth is unsigned, but some font editors might
         # read/write as signed. We can't be sure whether it was a mistake
         # or not, so we read as unsigned but also issue a warning...
         metricsFmt = ">" + self.longMetricFormat * numberOfMetrics
         metrics = struct.unpack(metricsFmt, data[: 4 * numberOfMetrics])
         data = data[4 * numberOfMetrics :]
-        numberOfSideBearings = numGlyphs - numberOfMetrics
         sideBearings = array.array("h", data[: 2 * numberOfSideBearings])
         data = data[2 * numberOfSideBearings :]
 

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/featureVars.py

@@ -95,6 +95,14 @@ def addFeatureVariations(font, conditionalSubstitutions, featureTag="rvrn"):
 
     addFeatureVariationsRaw(font, font["GSUB"].table, conditionsAndLookups, featureTags)
 
+    # Update OS/2.usMaxContext in case the font didn't have features before, but
+    # does now, if the OS/2 table exists. The table may be required, but
+    # fontTools needs to be able to deal with non-standard fonts. Since feature
+    # variations are always 1:1 mappings, we can set the value to at least 1
+    # instead of recomputing it with `otlLib.maxContextCalc.maxCtxFont()`.
+    if (os2 := font.get("OS/2")) is not None:
+        os2.usMaxContext = max(1, os2.usMaxContext)
+
 
 def _existingVariableFeatures(table):
     existingFeatureVarsTags = set()

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 (
@@ -120,6 +118,7 @@ from fontTools.cffLib.specializer import (
     specializeCommands,
     generalizeCommands,
 )
+from fontTools.cffLib.CFF2ToCFF import convertCFF2ToCFF
 from fontTools.varLib import builder
 from fontTools.varLib.mvar import MVAR_ENTRIES
 from fontTools.varLib.merger import MutatorMerger
@@ -136,6 +135,7 @@ from enum import IntEnum
 import logging
 import os
 import re
+import io
 from typing import Dict, Iterable, Mapping, Optional, Sequence, Tuple, Union
 import warnings
 
@@ -433,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 = {}
 
@@ -643,7 +663,11 @@ def instantiateCFF2(
     # the Private dicts.
     #
     # Then prune unused things and possibly drop the VarStore if it's empty.
-    # In which case, downgrade to CFF table if requested.
+    #
+    # If the downgrade parameter is True, no actual downgrading is done, but
+    # the function returns True if the VarStore was empty after instantiation,
+    # and hence a downgrade to CFF is possible. In all other cases it returns
+    # False.
 
     log.info("Instantiating CFF2 table")
 
@@ -882,9 +906,9 @@ def instantiateCFF2(
             del private.vstore
 
         if downgrade:
-            from fontTools.cffLib.CFF2ToCFF import convertCFF2ToCFF
+            return True
 
-            convertCFF2ToCFF(varfont)
+    return False
 
 
 def _instantiateGvarGlyph(
@@ -1116,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"
@@ -1377,12 +1402,55 @@ def _isValidAvarSegmentMap(axisTag, segmentMap):
     return True
 
 
+def downgradeCFF2ToCFF(varfont):
+    # Save these properties
+    recalcTimestamp = varfont.recalcTimestamp
+    recalcBBoxes = varfont.recalcBBoxes
+
+    # Disable them
+    varfont.recalcTimestamp = False
+    varfont.recalcBBoxes = False
+
+    # Save to memory, reload, downgrade and save again, reload.
+    # We do this dance because the convertCFF2ToCFF changes glyph
+    # names, so following save would fail if any other table was
+    # loaded and referencing glyph names.
+    #
+    # The second save+load is unfortunate but also necessary.
+
+    stream = io.BytesIO()
+    log.info("Saving CFF2 font to memory for downgrade")
+    varfont.save(stream)
+    stream.seek(0)
+    varfont = TTFont(stream, recalcTimestamp=False, recalcBBoxes=False)
+
+    convertCFF2ToCFF(varfont)
+
+    stream = io.BytesIO()
+    log.info("Saving downgraded CFF font to memory")
+    varfont.save(stream)
+    stream.seek(0)
+    varfont = TTFont(stream, recalcTimestamp=False, recalcBBoxes=False)
+
+    # Uncomment, to see test all tables can be loaded. This fails without
+    # the extra save+load above.
+    """
+    for tag in varfont.keys():
+        print("Loading", tag)
+        varfont[tag]
+    """
+
+    # Restore them
+    varfont.recalcTimestamp = recalcTimestamp
+    varfont.recalcBBoxes = recalcBBoxes
+
+    return varfont
+
+
 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
 
@@ -1393,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:
@@ -1594,6 +1665,7 @@ def instantiateVariableFont(
     updateFontNames=False,
     *,
     downgradeCFF2=False,
+    static=False,
 ):
     """Instantiate variable font, either fully or partially.
 
@@ -1637,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)
@@ -1665,7 +1748,9 @@ def instantiateVariableFont(
         instantiateVARC(varfont, normalizedLimits)
 
     if "CFF2" in varfont:
-        instantiateCFF2(varfont, normalizedLimits, downgrade=downgradeCFF2)
+        downgradeCFF2 = instantiateCFF2(
+            varfont, normalizedLimits, downgrade=downgradeCFF2
+        )
 
     if "gvar" in varfont:
         instantiateGvar(varfont, normalizedLimits, optimize=optimize)
@@ -1720,6 +1805,12 @@ def instantiateVariableFont(
         # name table has been updated.
         setRibbiBits(varfont)
 
+    if downgradeCFF2:
+        origVarfont = varfont
+        varfont = downgradeCFF2ToCFF(varfont)
+        if inplace:
+            origVarfont.__dict__ = varfont.__dict__.copy()
+
     return varfont
 
 
@@ -1826,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",
@@ -1923,13 +2020,13 @@ 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]
     }.issuperset(axis.axisTag for axis in varfont["fvar"].axes)
 
-    instantiateVariableFont(
+    varfont = instantiateVariableFont(
         varfont,
         axisLimits,
         inplace=True,
@@ -1937,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/varLib/iup.c

@@ -1,4 +1,4 @@
-/* Generated by Cython 3.1.2 */
+/* Generated by Cython 3.1.3 */
 
 /* BEGIN: Cython Metadata
 {
@@ -26,8 +26,8 @@ END: Cython Metadata */
 #elif PY_VERSION_HEX < 0x03080000
     #error Cython requires Python 3.8+.
 #else
-#define __PYX_ABI_VERSION "3_1_2"
-#define CYTHON_HEX_VERSION 0x030102F0
+#define __PYX_ABI_VERSION "3_1_3"
+#define CYTHON_HEX_VERSION 0x030103F0
 #define CYTHON_FUTURE_DIVISION 1
 /* CModulePreamble */
 #include <stddef.h>
@@ -390,6 +390,9 @@ END: Cython Metadata */
     enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) };
   #endif
 #endif
+#ifndef CYTHON_LOCK_AND_GIL_DEADLOCK_AVOIDANCE_TIME
+  #define CYTHON_LOCK_AND_GIL_DEADLOCK_AVOIDANCE_TIME 100
+#endif
 #ifndef __has_attribute
   #define __has_attribute(x) 0
 #endif
@@ -2141,7 +2144,7 @@ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected);
 static PyObject *__Pyx_PyLong_AbsNeg(PyObject *num);
 #define __Pyx_PyNumber_Absolute(x)\
     ((likely(PyLong_CheckExact(x))) ?\
-         (likely(__Pyx_PyLong_IsNonNeg(x)) ? (Py_INCREF(x), (x)) : __Pyx_PyLong_AbsNeg(x)) :\
+         (likely(__Pyx_PyLong_IsNonNeg(x)) ? __Pyx_NewRef(x) : __Pyx_PyLong_AbsNeg(x)) :\
          PyNumber_Absolute(x))
 #else
 #define __Pyx_PyNumber_Absolute(x)  PyNumber_Absolute(x)
@@ -14329,7 +14332,7 @@ static PyObject *__Pyx_PyLong_AbsNeg(PyObject *n) {
         PyObject *copy = _PyLong_Copy((PyLongObject*)n);
         if (likely(copy)) {
             #if PY_VERSION_HEX >= 0x030C00A7
-            ((PyLongObject*)copy)->long_value.lv_tag = ((PyLongObject*)copy)->long_value.lv_tag & ~_PyLong_SIGN_MASK;
+            ((PyLongObject*)copy)->long_value.lv_tag ^= ((PyLongObject*)copy)->long_value.lv_tag & _PyLong_SIGN_MASK;
             #else
             __Pyx_SET_SIZE(copy, -Py_SIZE(copy));
             #endif
@@ -14942,6 +14945,7 @@ static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject
                     changed = 1;
                 }
 #endif  // CYTHON_METH_FASTCALL
+#if !CYTHON_COMPILING_IN_PYPY
                 else if (strcmp(memb->name, "__module__") == 0) {
                     PyObject *descr;
                     assert(memb->type == T_OBJECT);
@@ -14956,11 +14960,13 @@ static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject
                     }
                     changed = 1;
                 }
+#endif  // !CYTHON_COMPILING_IN_PYPY
             }
             memb++;
         }
     }
 #endif  // !CYTHON_COMPILING_IN_LIMITED_API
+#if !CYTHON_COMPILING_IN_PYPY
     slot = spec->slots;
     while (slot && slot->slot && slot->slot != Py_tp_getset)
         slot++;
@@ -14992,6 +14998,7 @@ static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject
             ++getset;
         }
     }
+#endif  // !CYTHON_COMPILING_IN_PYPY
     if (changed)
         PyType_Modified(type);
 #endif  // PY_VERSION_HEX > 0x030900B1
@@ -15090,6 +15097,13 @@ try_unpack:
 
 /* PyObjectCallMethod0 */
 static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) {
+#if CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000))
+    PyObject *args[1] = {obj};
+    (void) __Pyx_PyObject_GetMethod;
+    (void) __Pyx_PyObject_CallOneArg;
+    (void) __Pyx_PyObject_CallNoArg;
+    return PyObject_VectorcallMethod(method_name, args, 1 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
+#else
     PyObject *method = NULL, *result = NULL;
     int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method);
     if (likely(is_method)) {
@@ -15102,6 +15116,7 @@ static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name
     Py_DECREF(method);
 bad:
     return result;
+#endif
 }
 
 /* ValidateBasesTuple */
@@ -15489,7 +15504,7 @@ bad:
 }
 
 /* CommonTypesMetaclass */
-PyObject* __pyx_CommonTypesMetaclass_get_module(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED void* context) {
+static PyObject* __pyx_CommonTypesMetaclass_get_module(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED void* context) {
     return PyUnicode_FromString(__PYX_ABI_MODULE_NAME);
 }
 static PyGetSetDef __pyx_CommonTypesMetaclass_getset[] = {
@@ -17939,7 +17954,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyOb
 }
 
 /* PyObjectCallMethod1 */
-#if !(CYTHON_VECTORCALL && __PYX_LIMITED_VERSION_HEX >= 0x030C0000)
+#if !(CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000)))
 static PyObject* __Pyx__PyObject_CallMethod1(PyObject* method, PyObject* arg) {
     PyObject *result = __Pyx_PyObject_CallOneArg(method, arg);
     Py_DECREF(method);
@@ -17947,7 +17962,7 @@ static PyObject* __Pyx__PyObject_CallMethod1(PyObject* method, PyObject* arg) {
 }
 #endif
 static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) {
-#if CYTHON_VECTORCALL && __PYX_LIMITED_VERSION_HEX >= 0x030C0000
+#if CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000))
     PyObject *args[2] = {obj, arg};
     (void) __Pyx_PyObject_GetMethod;
     (void) __Pyx_PyObject_CallOneArg;

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.