fonttools 4.56.0__cp310-cp310-win32.whl → 4.58.0__cp310-cp310-win32.whl

fontTools/misc/etree.py

@@ -56,21 +56,7 @@ except ImportError:
         from xml.etree.ElementTree import *
     _have_lxml = False
 
-    import sys
-
-    # dict is always ordered in python >= 3.6 and on pypy
-    PY36 = sys.version_info >= (3, 6)
-    try:
-        import __pypy__
-    except ImportError:
-        __pypy__ = None
-    _dict_is_ordered = bool(PY36 or __pypy__)
-    del PY36, __pypy__
-
-    if _dict_is_ordered:
-        _Attrib = dict
-    else:
-        from collections import OrderedDict as _Attrib
+    _Attrib = dict
 
     if isinstance(Element, type):
         _Element = Element
@@ -221,18 +207,9 @@ except ImportError:
     # characters, the surrogate blocks, FFFE, and FFFF:
     #   Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]
     # Here we reversed the pattern to match only the invalid characters.
-    # For the 'narrow' python builds supporting only UCS-2, which represent
-    # characters beyond BMP as UTF-16 surrogate pairs, we need to pass through
-    # the surrogate block. I haven't found a more elegant solution...
-    UCS2 = sys.maxunicode < 0x10FFFF
-    if UCS2:
-        _invalid_xml_string = re.compile(
-            "[\u0000-\u0008\u000B-\u000C\u000E-\u001F\uFFFE-\uFFFF]"
-        )
-    else:
-        _invalid_xml_string = re.compile(
-            "[\u0000-\u0008\u000B-\u000C\u000E-\u001F\uD800-\uDFFF\uFFFE-\uFFFF]"
-        )
+    _invalid_xml_string = re.compile(
+        "[\u0000-\u0008\u000B-\u000C\u000E-\u001F\uD800-\uDFFF\uFFFE-\uFFFF]"
+    )
 
     def _tounicode(s):
         """Test if a string is valid user input and decode it to unicode string

fontTools/misc/testTools.py

@@ -46,7 +46,8 @@ def parseXmlInto(font, parseInto, xmlSnippet):
     parsed_xml = [e for e in parseXML(xmlSnippet.strip()) if not isinstance(e, str)]
     for name, attrs, content in parsed_xml:
         parseInto.fromXML(name, attrs, content, font)
-    parseInto.populateDefaults()
+    if hasattr(parseInto, "populateDefaults"):
+        parseInto.populateDefaults()
     return parseInto
 
 

fontTools/mtiLib/__init__.py

@@ -1,5 +1,3 @@
-#!/usr/bin/python
-
 # FontDame-to-FontTools for OpenType Layout tables
 #
 # Source language spec is available at:

fontTools/otlLib/builder.py

@@ -1,6 +1,8 @@
+from __future__ import annotations
+
 from collections import namedtuple, OrderedDict
 import itertools
-import os
+from typing import Dict, Union
 from fontTools.misc.fixedTools import fixedToFloat
 from fontTools.misc.roundTools import otRound
 from fontTools import ttLib
@@ -10,15 +12,15 @@ from fontTools.ttLib.tables.otBase import (
     valueRecordFormatDict,
     OTLOffsetOverflowError,
     OTTableWriter,
-    CountReference,
 )
-from fontTools.ttLib.tables import otBase
+from fontTools.ttLib.ttFont import TTFont
 from fontTools.feaLib.ast import STATNameStatement
 from fontTools.otlLib.optimize.gpos import (
     _compression_level_from_env,
     compact_lookup,
 )
 from fontTools.otlLib.error import OpenTypeLibError
+from fontTools.misc.loggingTools import deprecateFunction
 from functools import reduce
 import logging
 import copy
@@ -73,7 +75,7 @@ LOOKUP_FLAG_IGNORE_MARKS = 0x0008
 LOOKUP_FLAG_USE_MARK_FILTERING_SET = 0x0010
 
 
-def buildLookup(subtables, flags=0, markFilterSet=None):
+def buildLookup(subtables, flags=0, markFilterSet=None, table=None, extension=False):
     """Turns a collection of rules into a lookup.
 
     A Lookup (as defined in the `OpenType Spec <https://docs.microsoft.com/en-gb/typography/opentype/spec/chapter2#lookupTbl>`__)
@@ -98,6 +100,8 @@ def buildLookup(subtables, flags=0, markFilterSet=None):
             lookup. If a mark filtering set is provided,
             `LOOKUP_FLAG_USE_MARK_FILTERING_SET` will be set on the lookup's
             flags.
+        table (str): The name of the table this lookup belongs to, e.g. "GPOS" or "GSUB".
+        extension (bool): ``True`` if this is an extension lookup, ``False`` otherwise.
 
     Returns:
         An ``otTables.Lookup`` object or ``None`` if there are no subtables
@@ -113,8 +117,21 @@ def buildLookup(subtables, flags=0, markFilterSet=None):
     ), "all subtables must have the same LookupType; got %s" % repr(
         [t.LookupType for t in subtables]
     )
+
+    if extension:
+        assert table in ("GPOS", "GSUB")
+        lookupType = 7 if table == "GSUB" else 9
+        extSubTableClass = ot.lookupTypes[table][lookupType]
+        for i, st in enumerate(subtables):
+            subtables[i] = extSubTableClass()
+            subtables[i].Format = 1
+            subtables[i].ExtSubTable = st
+            subtables[i].ExtensionLookupType = st.LookupType
+    else:
+        lookupType = subtables[0].LookupType
+
     self = ot.Lookup()
-    self.LookupType = subtables[0].LookupType
+    self.LookupType = lookupType
     self.LookupFlag = flags
     self.SubTable = subtables
     self.SubTableCount = len(self.SubTable)
@@ -133,7 +150,7 @@ def buildLookup(subtables, flags=0, markFilterSet=None):
 class LookupBuilder(object):
     SUBTABLE_BREAK_ = "SUBTABLE_BREAK"
 
-    def __init__(self, font, location, table, lookup_type):
+    def __init__(self, font, location, table, lookup_type, extension=False):
         self.font = font
         self.glyphMap = font.getReverseGlyphMap()
         self.location = location
@@ -141,6 +158,7 @@ class LookupBuilder(object):
         self.lookupflag = 0
         self.markFilterSet = None
         self.lookup_index = None  # assigned when making final tables
+        self.extension = extension
         assert table in ("GPOS", "GSUB")
 
     def equals(self, other):
@@ -149,6 +167,7 @@ class LookupBuilder(object):
             and self.table == other.table
             and self.lookupflag == other.lookupflag
             and self.markFilterSet == other.markFilterSet
+            and self.extension == other.extension
         )
 
     def inferGlyphClasses(self):
@@ -160,7 +179,13 @@ class LookupBuilder(object):
         return {}
 
     def buildLookup_(self, subtables):
-        return buildLookup(subtables, self.lookupflag, self.markFilterSet)
+        return buildLookup(
+            subtables,
+            self.lookupflag,
+            self.markFilterSet,
+            self.table,
+            self.extension,
+        )
 
     def buildMarkClasses_(self, marks):
         """{"cedilla": ("BOTTOM", ast.Anchor), ...} --> {"BOTTOM":0, "TOP":1}
@@ -949,8 +974,20 @@ class CursivePosBuilder(LookupBuilder):
             An ``otTables.Lookup`` object representing the cursive
             positioning lookup.
         """
-        st = buildCursivePosSubtable(self.attachments, self.glyphMap)
-        return self.buildLookup_([st])
+        attachments = [{}]
+        for key in self.attachments:
+            if key[0] == self.SUBTABLE_BREAK_:
+                attachments.append({})
+            else:
+                attachments[-1][key] = self.attachments[key]
+        subtables = [buildCursivePosSubtable(s, self.glyphMap) for s in attachments]
+        return self.buildLookup_(subtables)
+
+    def add_subtable_break(self, location):
+        self.attachments[(self.SUBTABLE_BREAK_, location)] = (
+            self.SUBTABLE_BREAK_,
+            self.SUBTABLE_BREAK_,
+        )
 
 
 class MarkBasePosBuilder(LookupBuilder):
@@ -985,17 +1022,25 @@ class MarkBasePosBuilder(LookupBuilder):
         LookupBuilder.__init__(self, font, location, "GPOS", 4)
         self.marks = {}  # glyphName -> (markClassName, anchor)
         self.bases = {}  # glyphName -> {markClassName: anchor}
+        self.subtables_ = []
+
+    def get_subtables_(self):
+        subtables_ = self.subtables_
+        if self.bases or self.marks:
+            subtables_.append((self.marks, self.bases))
+        return subtables_
 
     def equals(self, other):
         return (
             LookupBuilder.equals(self, other)
-            and self.marks == other.marks
-            and self.bases == other.bases
+            and self.get_subtables_() == other.get_subtables_()
         )
 
     def inferGlyphClasses(self):
-        result = {glyph: 1 for glyph in self.bases}
-        result.update({glyph: 3 for glyph in self.marks})
+        result = {}
+        for marks, bases in self.get_subtables_():
+            result.update({glyph: 1 for glyph in bases})
+            result.update({glyph: 3 for glyph in marks})
         return result
 
     def build(self):
@@ -1005,26 +1050,33 @@ class MarkBasePosBuilder(LookupBuilder):
             An ``otTables.Lookup`` object representing the mark-to-base
             positioning lookup.
         """
-        markClasses = self.buildMarkClasses_(self.marks)
-        marks = {}
-        for mark, (mc, anchor) in self.marks.items():
-            if mc not in markClasses:
-                raise ValueError(
-                    "Mark class %s not found for mark glyph %s" % (mc, mark)
-                )
-            marks[mark] = (markClasses[mc], anchor)
-        bases = {}
-        for glyph, anchors in self.bases.items():
-            bases[glyph] = {}
-            for mc, anchor in anchors.items():
+        subtables = []
+        for subtable in self.get_subtables_():
+            markClasses = self.buildMarkClasses_(subtable[0])
+            marks = {}
+            for mark, (mc, anchor) in subtable[0].items():
                 if mc not in markClasses:
                     raise ValueError(
-                        "Mark class %s not found for base glyph %s" % (mc, glyph)
+                        "Mark class %s not found for mark glyph %s" % (mc, mark)
                     )
-                bases[glyph][markClasses[mc]] = anchor
-        subtables = buildMarkBasePos(marks, bases, self.glyphMap)
+                marks[mark] = (markClasses[mc], anchor)
+            bases = {}
+            for glyph, anchors in subtable[1].items():
+                bases[glyph] = {}
+                for mc, anchor in anchors.items():
+                    if mc not in markClasses:
+                        raise ValueError(
+                            "Mark class %s not found for base glyph %s" % (mc, glyph)
+                        )
+                    bases[glyph][markClasses[mc]] = anchor
+            subtables.append(buildMarkBasePosSubtable(marks, bases, self.glyphMap))
         return self.buildLookup_(subtables)
 
+    def add_subtable_break(self, location):
+        self.subtables_.append((self.marks, self.bases))
+        self.marks = {}
+        self.bases = {}
+
 
 class MarkLigPosBuilder(LookupBuilder):
     """Builds a Mark-To-Ligature Positioning (GPOS5) lookup.
@@ -1061,17 +1113,25 @@ class MarkLigPosBuilder(LookupBuilder):
         LookupBuilder.__init__(self, font, location, "GPOS", 5)
         self.marks = {}  # glyphName -> (markClassName, anchor)
         self.ligatures = {}  # glyphName -> [{markClassName: anchor}, ...]
+        self.subtables_ = []
+
+    def get_subtables_(self):
+        subtables_ = self.subtables_
+        if self.ligatures or self.marks:
+            subtables_.append((self.marks, self.ligatures))
+        return subtables_
 
     def equals(self, other):
         return (
             LookupBuilder.equals(self, other)
-            and self.marks == other.marks
-            and self.ligatures == other.ligatures
+            and self.get_subtables_() == other.get_subtables_()
         )
 
     def inferGlyphClasses(self):
-        result = {glyph: 2 for glyph in self.ligatures}
-        result.update({glyph: 3 for glyph in self.marks})
+        result = {}
+        for marks, ligatures in self.get_subtables_():
+            result.update({glyph: 2 for glyph in ligatures})
+            result.update({glyph: 3 for glyph in marks})
         return result
 
     def build(self):
@@ -1081,18 +1141,26 @@ class MarkLigPosBuilder(LookupBuilder):
             An ``otTables.Lookup`` object representing the mark-to-ligature
             positioning lookup.
         """
-        markClasses = self.buildMarkClasses_(self.marks)
-        marks = {
-            mark: (markClasses[mc], anchor) for mark, (mc, anchor) in self.marks.items()
-        }
-        ligs = {}
-        for lig, components in self.ligatures.items():
-            ligs[lig] = []
-            for c in components:
-                ligs[lig].append({markClasses[mc]: a for mc, a in c.items()})
-        subtables = buildMarkLigPos(marks, ligs, self.glyphMap)
+        subtables = []
+        for subtable in self.get_subtables_():
+            markClasses = self.buildMarkClasses_(subtable[0])
+            marks = {
+                mark: (markClasses[mc], anchor)
+                for mark, (mc, anchor) in subtable[0].items()
+            }
+            ligs = {}
+            for lig, components in subtable[1].items():
+                ligs[lig] = []
+                for c in components:
+                    ligs[lig].append({markClasses[mc]: a for mc, a in c.items()})
+            subtables.append(buildMarkLigPosSubtable(marks, ligs, self.glyphMap))
         return self.buildLookup_(subtables)
 
+    def add_subtable_break(self, location):
+        self.subtables_.append((self.marks, self.ligatures))
+        self.marks = {}
+        self.ligatures = {}
+
 
 class MarkMarkPosBuilder(LookupBuilder):
     """Builds a Mark-To-Mark Positioning (GPOS6) lookup.
@@ -1125,17 +1193,25 @@ class MarkMarkPosBuilder(LookupBuilder):
         LookupBuilder.__init__(self, font, location, "GPOS", 6)
         self.marks = {}  # glyphName -> (markClassName, anchor)
         self.baseMarks = {}  # glyphName -> {markClassName: anchor}
+        self.subtables_ = []
+
+    def get_subtables_(self):
+        subtables_ = self.subtables_
+        if self.baseMarks or self.marks:
+            subtables_.append((self.marks, self.baseMarks))
+        return subtables_
 
     def equals(self, other):
         return (
             LookupBuilder.equals(self, other)
-            and self.marks == other.marks
-            and self.baseMarks == other.baseMarks
+            and self.get_subtables_() == other.get_subtables_()
         )
 
     def inferGlyphClasses(self):
-        result = {glyph: 3 for glyph in self.baseMarks}
-        result.update({glyph: 3 for glyph in self.marks})
+        result = {}
+        for marks, baseMarks in self.get_subtables_():
+            result.update({glyph: 3 for glyph in baseMarks})
+            result.update({glyph: 3 for glyph in marks})
         return result
 
     def build(self):
@@ -1145,25 +1221,34 @@ class MarkMarkPosBuilder(LookupBuilder):
             An ``otTables.Lookup`` object representing the mark-to-mark
             positioning lookup.
         """
-        markClasses = self.buildMarkClasses_(self.marks)
-        markClassList = sorted(markClasses.keys(), key=markClasses.get)
-        marks = {
-            mark: (markClasses[mc], anchor) for mark, (mc, anchor) in self.marks.items()
-        }
+        subtables = []
+        for subtable in self.get_subtables_():
+            markClasses = self.buildMarkClasses_(subtable[0])
+            markClassList = sorted(markClasses.keys(), key=markClasses.get)
+            marks = {
+                mark: (markClasses[mc], anchor)
+                for mark, (mc, anchor) in subtable[0].items()
+            }
+
+            st = ot.MarkMarkPos()
+            st.Format = 1
+            st.ClassCount = len(markClasses)
+            st.Mark1Coverage = buildCoverage(marks, self.glyphMap)
+            st.Mark2Coverage = buildCoverage(subtable[1], self.glyphMap)
+            st.Mark1Array = buildMarkArray(marks, self.glyphMap)
+            st.Mark2Array = ot.Mark2Array()
+            st.Mark2Array.Mark2Count = len(st.Mark2Coverage.glyphs)
+            st.Mark2Array.Mark2Record = []
+            for base in st.Mark2Coverage.glyphs:
+                anchors = [subtable[1][base].get(mc) for mc in markClassList]
+                st.Mark2Array.Mark2Record.append(buildMark2Record(anchors))
+            subtables.append(st)
+        return self.buildLookup_(subtables)
 
-        st = ot.MarkMarkPos()
-        st.Format = 1
-        st.ClassCount = len(markClasses)
-        st.Mark1Coverage = buildCoverage(marks, self.glyphMap)
-        st.Mark2Coverage = buildCoverage(self.baseMarks, self.glyphMap)
-        st.Mark1Array = buildMarkArray(marks, self.glyphMap)
-        st.Mark2Array = ot.Mark2Array()
-        st.Mark2Array.Mark2Count = len(st.Mark2Coverage.glyphs)
-        st.Mark2Array.Mark2Record = []
-        for base in st.Mark2Coverage.glyphs:
-            anchors = [self.baseMarks[base].get(mc) for mc in markClassList]
-            st.Mark2Array.Mark2Record.append(buildMark2Record(anchors))
-        return self.buildLookup_([st])
+    def add_subtable_break(self, location):
+        self.subtables_.append((self.marks, self.baseMarks))
+        self.marks = {}
+        self.baseMarks = {}
 
 
 class ReverseChainSingleSubstBuilder(LookupBuilder):
@@ -1484,6 +1569,8 @@ class SinglePosBuilder(LookupBuilder):
             otValueRection: A ``otTables.ValueRecord`` used to position the
                 glyph.
         """
+        if otValueRecord is None:
+            otValueRecord = ValueRecord()
         if not self.can_add(glyph, otValueRecord):
             otherLoc = self.locations[glyph]
             raise OpenTypeLibError(
@@ -1900,53 +1987,15 @@ def buildMarkArray(marks, glyphMap):
     return self
 
 
+@deprecateFunction(
+    "use buildMarkBasePosSubtable() instead", category=DeprecationWarning
+)
 def buildMarkBasePos(marks, bases, glyphMap):
     """Build a list of MarkBasePos (GPOS4) subtables.
 
-    This routine turns a set of marks and bases into a list of mark-to-base
-    positioning subtables. Currently the list will contain a single subtable
-    containing all marks and bases, although at a later date it may return the
-    optimal list of subtables subsetting the marks and bases into groups which
-    save space. See :func:`buildMarkBasePosSubtable` below.
-
-    Note that if you are implementing a layout compiler, you may find it more
-    flexible to use
-    :py:class:`fontTools.otlLib.lookupBuilders.MarkBasePosBuilder` instead.
-
-    Example::
-
-        # a1, a2, a3, a4, a5 = buildAnchor(500, 100), ...
-
-        marks = {"acute": (0, a1), "grave": (0, a1), "cedilla": (1, a2)}
-        bases = {"a": {0: a3, 1: a5}, "b": {0: a4, 1: a5}}
-        markbaseposes = buildMarkBasePos(marks, bases, font.getReverseGlyphMap())
-
-    Args:
-        marks (dict): A dictionary mapping anchors to glyphs; the keys being
-            glyph names, and the values being a tuple of mark class number and
-            an ``otTables.Anchor`` object representing the mark's attachment
-            point. (See :func:`buildMarkArray`.)
-        bases (dict): A dictionary mapping anchors to glyphs; the keys being
-            glyph names, and the values being dictionaries mapping mark class ID
-            to the appropriate ``otTables.Anchor`` object used for attaching marks
-            of that class. (See :func:`buildBaseArray`.)
-        glyphMap: a glyph name to ID map, typically returned from
-            ``font.getReverseGlyphMap()``.
-
-    Returns:
-        A list of ``otTables.MarkBasePos`` objects.
+    .. deprecated:: 4.58.0
+           Use :func:`buildMarkBasePosSubtable` instead.
     """
-    # TODO: Consider emitting multiple subtables to save space.
-    # Partition the marks and bases into disjoint subsets, so that
-    # MarkBasePos rules would only access glyphs from a single
-    # subset. This would likely lead to smaller mark/base
-    # matrices, so we might be able to omit many of the empty
-    # anchor tables that we currently produce. Of course, this
-    # would only work if the MarkBasePos rules of real-world fonts
-    # allow partitioning into multiple subsets. We should find out
-    # whether this is the case; if so, implement the optimization.
-    # On the other hand, a very large number of subtables could
-    # slow down layout engines; so this would need profiling.
     return [buildMarkBasePosSubtable(marks, bases, glyphMap)]
 
 
@@ -1954,7 +2003,15 @@ def buildMarkBasePosSubtable(marks, bases, glyphMap):
     """Build a single MarkBasePos (GPOS4) subtable.
 
     This builds a mark-to-base lookup subtable containing all of the referenced
-    marks and bases. See :func:`buildMarkBasePos`.
+    marks and bases.
+
+    Example::
+
+        # a1, a2, a3, a4, a5 = buildAnchor(500, 100), ...
+
+        marks = {"acute": (0, a1), "grave": (0, a1), "cedilla": (1, a2)}
+        bases = {"a": {0: a3, 1: a5}, "b": {0: a4, 1: a5}}
+        markbaseposes = [buildMarkBasePosSubtable(marks, bases, font.getReverseGlyphMap())]
 
     Args:
         marks (dict): A dictionary mapping anchors to glyphs; the keys being
@@ -1981,14 +2038,21 @@ def buildMarkBasePosSubtable(marks, bases, glyphMap):
     return self
 
 
+@deprecateFunction("use buildMarkLigPosSubtable() instead", category=DeprecationWarning)
 def buildMarkLigPos(marks, ligs, glyphMap):
     """Build a list of MarkLigPos (GPOS5) subtables.
 
-    This routine turns a set of marks and ligatures into a list of mark-to-ligature
-    positioning subtables. Currently the list will contain a single subtable
-    containing all marks and ligatures, although at a later date it may return
-    the optimal list of subtables subsetting the marks and ligatures into groups
-    which save space. See :func:`buildMarkLigPosSubtable` below.
+    .. deprecated:: 4.58.0
+       Use :func:`buildMarkLigPosSubtable` instead.
+    """
+    return [buildMarkLigPosSubtable(marks, ligs, glyphMap)]
+
+
+def buildMarkLigPosSubtable(marks, ligs, glyphMap):
+    """Build a single MarkLigPos (GPOS5) subtable.
+
+    This builds a mark-to-base lookup subtable containing all of the referenced
+    marks and bases.
 
     Note that if you are implementing a layout compiler, you may find it more
     flexible to use
@@ -2009,37 +2073,9 @@ def buildMarkLigPos(marks, ligs, glyphMap):
                 ],
         #   "c_t": [{...}, {...}]
         }
-        markligposes = buildMarkLigPos(marks, ligs,
+        markligpose = buildMarkLigPosSubtable(marks, ligs,
             font.getReverseGlyphMap())
 
-    Args:
-        marks (dict): A dictionary mapping anchors to glyphs; the keys being
-            glyph names, and the values being a tuple of mark class number and
-            an ``otTables.Anchor`` object representing the mark's attachment
-            point. (See :func:`buildMarkArray`.)
-        ligs (dict): A mapping of ligature names to an array of dictionaries:
-            for each component glyph in the ligature, an dictionary mapping
-            mark class IDs to anchors. (See :func:`buildLigatureArray`.)
-        glyphMap: a glyph name to ID map, typically returned from
-            ``font.getReverseGlyphMap()``.
-
-    Returns:
-        A list of ``otTables.MarkLigPos`` objects.
-
-    """
-    # TODO: Consider splitting into multiple subtables to save space,
-    # as with MarkBasePos, this would be a trade-off that would need
-    # profiling. And, depending on how typical fonts are structured,
-    # it might not be worth doing at all.
-    return [buildMarkLigPosSubtable(marks, ligs, glyphMap)]
-
-
-def buildMarkLigPosSubtable(marks, ligs, glyphMap):
-    """Build a single MarkLigPos (GPOS5) subtable.
-
-    This builds a mark-to-base lookup subtable containing all of the referenced
-    marks and bases. See :func:`buildMarkLigPos`.
-
     Args:
         marks (dict): A dictionary mapping anchors to glyphs; the keys being
             glyph names, and the values being a tuple of mark class number and
@@ -2706,10 +2742,18 @@ class ClassDefBuilder(object):
 AXIS_VALUE_NEGATIVE_INFINITY = fixedToFloat(-0x80000000, 16)
 AXIS_VALUE_POSITIVE_INFINITY = fixedToFloat(0x7FFFFFFF, 16)
 
+STATName = Union[int, str, Dict[str, str]]
+"""A raw name ID, English name, or multilingual name."""
+
 
 def buildStatTable(
-    ttFont, axes, locations=None, elidedFallbackName=2, windowsNames=True, macNames=True
-):
+    ttFont: TTFont,
+    axes,
+    locations=None,
+    elidedFallbackName: Union[STATName, STATNameStatement] = 2,
+    windowsNames: bool = True,
+    macNames: bool = True,
+) -> None:
     """Add a 'STAT' table to 'ttFont'.
 
     'axes' is a list of dictionaries describing axes and their
@@ -2900,7 +2944,13 @@ def _buildAxisValuesFormat4(locations, axes, ttFont, windowsNames=True, macNames
     return axisValues
 
 
-def _addName(ttFont, value, minNameID=0, windows=True, mac=True):
+def _addName(
+    ttFont: TTFont,
+    value: Union[STATName, STATNameStatement],
+    minNameID: int = 0,
+    windows: bool = True,
+    mac: bool = True,
+) -> int:
     nameTable = ttFont["name"]
     if isinstance(value, int):
         # Already a nameID