fonttools 4.58.5__cp311-cp311-musllinux_1_2_aarch64.whl → 4.59.1__cp311-cp311-musllinux_1_2_aarch64.whl

fontTools/ttLib/tables/T_S_I__1.py

@@ -91,12 +91,11 @@ class table_T_S_I__1(LogMixin, DefaultTable.DefaultTable):
         glyphNames = ttFont.getGlyphOrder()
 
         indices = []
-        for i in range(len(glyphNames)):
+        for i, name in enumerate(glyphNames):
             if len(data) % 2:
                 data = (
                     data + b"\015"
                 )  # align on 2-byte boundaries, fill with return chars. Yum.
-            name = glyphNames[i]
             if name in self.glyphPrograms:
                 text = tobytes(self.glyphPrograms[name], encoding="utf-8")
             else:
@@ -108,13 +107,11 @@ class table_T_S_I__1(LogMixin, DefaultTable.DefaultTable):
             data = data + text
 
         extra_indices = []
-        codes = sorted(self.extras.items())
-        for i in range(len(codes)):
+        for code, name in sorted(self.extras.items()):
             if len(data) % 2:
                 data = (
                     data + b"\015"
                 )  # align on 2-byte boundaries, fill with return chars.
-            code, name = codes[i]
             if name in self.extraPrograms:
                 text = tobytes(self.extraPrograms[name], encoding="utf-8")
             else:

fontTools/ttLib/tables/T_S_I__5.py

@@ -38,8 +38,8 @@ class table_T_S_I__5(DefaultTable.DefaultTable):
     def compile(self, ttFont):
         glyphNames = ttFont.getGlyphOrder()
         a = array.array("H")
-        for i in range(len(glyphNames)):
-            a.append(self.glyphGrouping.get(glyphNames[i], 0))
+        for glyphName in glyphNames:
+            a.append(self.glyphGrouping.get(glyphName, 0))
         if sys.byteorder != "big":
             a.byteswap()
         return a.tobytes()

fontTools/ttLib/tables/_c_m_a_p.py

@@ -398,7 +398,7 @@ class cmap_format_0(CmapSubtable):
         assert 262 == self.length, "Format 0 cmap subtable not 262 bytes"
         gids = array.array("B")
         gids.frombytes(self.data)
-        charCodes = list(range(len(gids)))
+        charCodes = range(len(gids))
         self.cmap = _make_map(self.ttFont, charCodes, gids)
 
     def compile(self, ttFont):

fontTools/ttLib/tables/_c_v_t.py

@@ -29,8 +29,7 @@ class table__c_v_t(DefaultTable.DefaultTable):
         return values.tobytes()
 
     def toXML(self, writer, ttFont):
-        for i in range(len(self.values)):
-            value = self.values[i]
+        for i, value in enumerate(self.values):
             writer.simpletag("cv", value=value, index=i)
             writer.newline()
 

fontTools/ttLib/tables/_g_l_y_f.py

@@ -974,11 +974,10 @@ class Glyph(object):
         lastcomponent = len(self.components) - 1
         more = 1
         haveInstructions = 0
-        for i in range(len(self.components)):
+        for i, compo in enumerate(self.components):
             if i == lastcomponent:
                 haveInstructions = hasattr(self, "program")
                 more = 0
-            compo = self.components[i]
             data = data + compo.compile(more, haveInstructions, glyfTable)
         if haveInstructions:
             instructions = self.program.getBytecode()
@@ -2037,8 +2036,8 @@ class GlyphCoordinates(object):
         if round is noRound:
             return
         a = self._a
-        for i in range(len(a)):
-            a[i] = round(a[i])
+        for i, value in enumerate(a):
+            a[i] = round(value)
 
     def calcBounds(self):
         a = self._a
@@ -2168,8 +2167,8 @@ class GlyphCoordinates(object):
         """
         r = self.copy()
         a = r._a
-        for i in range(len(a)):
-            a[i] = -a[i]
+        for i, value in enumerate(a):
+            a[i] = -value
         return r
 
     def __round__(self, *, round=otRound):
@@ -2214,8 +2213,8 @@ class GlyphCoordinates(object):
             other = other._a
             a = self._a
             assert len(a) == len(other)
-            for i in range(len(a)):
-                a[i] += other[i]
+            for i, value in enumerate(other):
+                a[i] += value
             return self
         return NotImplemented
 
@@ -2238,8 +2237,8 @@ class GlyphCoordinates(object):
             other = other._a
             a = self._a
             assert len(a) == len(other)
-            for i in range(len(a)):
-                a[i] -= other[i]
+            for i, value in enumerate(other):
+                a[i] -= value
             return self
         return NotImplemented
 

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_d_m_x.py

@@ -65,8 +65,8 @@ class table__h_d_m_x(DefaultTable.DefaultTable):
         items = sorted(self.hdmx.items())
         for ppem, widths in items:
             data = data + bytechr(ppem) + bytechr(max(widths.values()))
-            for glyphID in range(len(glyphOrder)):
-                width = widths[glyphOrder[glyphID]]
+            for glyphName in glyphOrder:
+                width = widths[glyphName]
                 data = data + bytechr(width)
             data = data + pad
         return data
@@ -123,5 +123,5 @@ class table__h_d_m_x(DefaultTable.DefaultTable):
                 glyphName = safeEval('"""' + glyphName + '"""')
             line = list(map(int, line[1:]))
             assert len(line) == len(ppems), "illegal hdmx format"
-            for i in range(len(ppems)):
-                hdmx[ppems[i]][glyphName] = line[i]
+            for i, ppem in enumerate(ppems):
+                hdmx[ppem][glyphName] = line[i]

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

@@ -46,8 +46,8 @@ class table__l_o_c_a(DefaultTable.DefaultTable):
             max_location = 0
         if max_location < 0x20000 and all(l % 2 == 0 for l in self.locations):
             locations = array.array("H")
-            for i in range(len(self.locations)):
-                locations.append(self.locations[i] // 2)
+            for location in self.locations:
+                locations.append(location // 2)
             ttFont["head"].indexToLocFormat = 0
         else:
             locations = array.array("I", self.locations)

fontTools/ttLib/tables/_p_o_s_t.py

@@ -174,10 +174,9 @@ class table__p_o_s_t(DefaultTable.DefaultTable):
         extraNames = self.extraNames = [
             n for n in self.extraNames if n not in standardGlyphOrder
         ]
-        for i in range(len(extraNames)):
-            extraDict[extraNames[i]] = i
-        for glyphID in range(numGlyphs):
-            glyphName = glyphOrder[glyphID]
+        for i, name in enumerate(extraNames):
+            extraDict[name] = i
+        for glyphName in glyphOrder:
             if glyphName in self.mapping:
                 psName = self.mapping[glyphName]
             else:

fontTools/ttLib/tables/otBase.py

@@ -500,8 +500,7 @@ class OTTableWriter(object):
             internedTables = {}
 
         items = self.items
-        for i in range(len(items)):
-            item = items[i]
+        for i, item in enumerate(items):
             if hasattr(item, "getCountData"):
                 items[i] = item.getCountData()
             elif hasattr(item, "subWriter"):
@@ -1130,8 +1129,7 @@ class BaseTable(object):
         for conv in self.getConverters():
             if conv.repeat:
                 value = getattr(self, conv.name, [])
-                for i in range(len(value)):
-                    item = value[i]
+                for i, item in enumerate(value):
                     conv.xmlWrite(xmlWriter, font, item, conv.name, [("index", i)])
             else:
                 if conv.aux and not eval(conv.aux, None, vars(self)):

fontTools/ttLib/tables/otTables.py

@@ -990,8 +990,7 @@ class Coverage(FormatSwitchingBaseTable):
             if brokenOrder or len(ranges) * 3 < len(glyphs):  # 3 words vs. 1 word
                 # Format 2 is more compact
                 index = 0
-                for i in range(len(ranges)):
-                    start, end = ranges[i]
+                for i, (start, end) in enumerate(ranges):
                     r = RangeRecord()
                     r.StartID = start
                     r.Start = font.getGlyphName(start)
@@ -1404,8 +1403,7 @@ class ClassDef(FormatSwitchingBaseTable):
             glyphCount = endGlyph - startGlyph + 1
             if len(ranges) * 3 < glyphCount + 1:
                 # Format 2 is more compact
-                for i in range(len(ranges)):
-                    cls, start, startName, end, endName = ranges[i]
+                for i, (cls, start, startName, end, endName) in enumerate(ranges):
                     rec = ClassRangeRecord()
                     rec.Start = startName
                     rec.End = endName
@@ -1463,8 +1461,7 @@ class AlternateSubst(FormatSwitchingBaseTable):
         if alternates is None:
             alternates = self.alternates = {}
         items = list(alternates.items())
-        for i in range(len(items)):
-            glyphName, set = items[i]
+        for i, (glyphName, set) in enumerate(items):
             items[i] = font.getGlyphID(glyphName), glyphName, set
         items.sort()
         cov = Coverage()
@@ -1520,8 +1517,8 @@ class LigatureSubst(FormatSwitchingBaseTable):
             input = _getGlyphsFromCoverageTable(rawTable["Coverage"])
             ligSets = rawTable["LigatureSet"]
             assert len(input) == len(ligSets)
-            for i in range(len(input)):
-                ligatures[input[i]] = ligSets[i].Ligature
+            for i, inp in enumerate(input):
+                ligatures[inp] = ligSets[i].Ligature
         else:
             assert 0, "unknown format: %s" % self.Format
         self.ligatures = ligatures
@@ -1577,8 +1574,7 @@ class LigatureSubst(FormatSwitchingBaseTable):
             ligatures = newLigatures
 
         items = list(ligatures.items())
-        for i in range(len(items)):
-            glyphName, set = items[i]
+        for i, (glyphName, set) in enumerate(items):
             items[i] = font.getGlyphID(glyphName), glyphName, set
         items.sort()
         cov = Coverage()
@@ -2279,8 +2275,7 @@ def fixLookupOverFlows(ttf, overflowRecord):
         lookup = lookups[lookupIndex]
         if lookup.LookupType != extType:
             lookup.LookupType = extType
-            for si in range(len(lookup.SubTable)):
-                subTable = lookup.SubTable[si]
+            for si, subTable in enumerate(lookup.SubTable):
                 extSubTableClass = lookupTypes[overflowRecord.tableType][extType]
                 extSubTable = extSubTableClass()
                 extSubTable.Format = 1

fontTools/ttLib/tables/sbixStrike.py

@@ -128,9 +128,9 @@ class Strike(object):
         xmlWriter.simpletag("resolution", value=self.resolution)
         xmlWriter.newline()
         glyphOrder = ttFont.getGlyphOrder()
-        for i in range(len(glyphOrder)):
-            if glyphOrder[i] in self.glyphs:
-                self.glyphs[glyphOrder[i]].toXML(xmlWriter, ttFont)
+        for glyphName in glyphOrder:
+            if glyphName in self.glyphs:
+                self.glyphs[glyphName].toXML(xmlWriter, ttFont)
                 # TODO: what if there are more glyph data records than (glyf table) glyphs?
         xmlWriter.endtag("strike")
         xmlWriter.newline()

fontTools/ttLib/ttFont.py

@@ -259,9 +259,8 @@ class TTFont(object):
                 "head"
             ]  # make sure 'head' is loaded so the recalculation is actually done
 
-        tags = list(self.keys())
-        if "GlyphOrder" in tags:
-            tags.remove("GlyphOrder")
+        tags = self.keys()
+        tags.pop(0)  # skip GlyphOrder tag
         numTables = len(tags)
         # write to a temporary stream to allow saving to unseekable streams
         writer = SFNTWriter(
@@ -307,14 +306,9 @@ class TTFont(object):
         self.disassembleInstructions = disassembleInstructions
         self.bitmapGlyphDataFormat = bitmapGlyphDataFormat
         if not tables:
-            tables = list(self.keys())
-            if "GlyphOrder" not in tables:
-                tables = ["GlyphOrder"] + tables
+            tables = self.keys()
             if skipTables:
-                for tag in skipTables:
-                    if tag in tables:
-                        tables.remove(tag)
-        numTables = len(tables)
+                tables = [tag for tag in tables if tag not in skipTables]
 
         if writeVersion:
             from fontTools import version
@@ -337,8 +331,7 @@ class TTFont(object):
         else:
             path, ext = os.path.splitext(writer.filename)
 
-        for i in range(numTables):
-            tag = tables[i]
+        for tag in tables:
             if splitTables:
                 tablePath = path + "." + tagToIdentifier(tag) + ext
                 tableWriter = xmlWriter.XMLWriter(
@@ -608,8 +601,7 @@ class TTFont(object):
         else:
             reversecmap = {}
         useCount = {}
-        for i in range(numGlyphs):
-            tempName = glyphOrder[i]
+        for i, tempName in enumerate(glyphOrder):
             if tempName in reversecmap:
                 # If a font maps both U+0041 LATIN CAPITAL LETTER A and
                 # U+0391 GREEK CAPITAL LETTER ALPHA to the same glyph,
@@ -866,8 +858,7 @@ class GlyphOrder(object):
             "The 'id' attribute is only for humans; " "it is ignored when parsed."
         )
         writer.newline()
-        for i in range(len(glyphOrder)):
-            glyphName = glyphOrder[i]
+        for i, glyphName in enumerate(glyphOrder):
             writer.simpletag("GlyphID", id=i, name=glyphName)
             writer.newline()
 

fontTools/ttLib/woff2.py

@@ -394,10 +394,9 @@ class WOFF2Writer(SFNTWriter):
 
     def _calcMasterChecksum(self):
         """Calculate checkSumAdjustment."""
-        tags = list(self.tables.keys())
         checksums = []
-        for i in range(len(tags)):
-            checksums.append(self.tables[tags[i]].checkSum)
+        for tag in self.tables.keys():
+            checksums.append(self.tables[tag].checkSum)
 
         # Create a SFNT directory for checksum calculation purposes
         self.searchRange, self.entrySelector, self.rangeShift = getSearchRange(
@@ -642,10 +641,10 @@ woff2OverlapSimpleBitmapFlag = 0x0001
 
 def getKnownTagIndex(tag):
     """Return index of 'tag' in woff2KnownTags list. Return 63 if not found."""
-    for i in range(len(woff2KnownTags)):
-        if tag == woff2KnownTags[i]:
-            return i
-    return woff2UnknownTagIndex
+    try:
+        return woff2KnownTags.index(tag)
+    except ValueError:
+        return woff2UnknownTagIndex
 
 
 class WOFF2DirectoryEntry(DirectoryEntry):
@@ -747,8 +746,8 @@ class WOFF2LocaTable(getTableClass("loca")):
                         "indexFormat is 0 but local offsets not multiples of 2"
                     )
                 locations = array.array("H")
-                for i in range(len(self.locations)):
-                    locations.append(self.locations[i] // 2)
+                for location in self.locations:
+                    locations.append(location // 2)
             else:
                 locations = array.array("I", self.locations)
             if sys.byteorder != "big":
@@ -1026,11 +1025,10 @@ class WOFF2GlyfTable(getTableClass("glyf")):
         lastcomponent = len(glyph.components) - 1
         more = 1
         haveInstructions = 0
-        for i in range(len(glyph.components)):
+        for i, component in enumerate(glyph.components):
             if i == lastcomponent:
                 haveInstructions = hasattr(glyph, "program")
                 more = 0
-            component = glyph.components[i]
             self.compositeStream += component.compile(more, haveInstructions, self)
         if haveInstructions:
             self._encodeInstructions(glyph)
@@ -1078,9 +1076,8 @@ class WOFF2GlyfTable(getTableClass("glyf")):
 
         flags = array.array("B")
         triplets = array.array("B")
-        for i in range(len(coordinates)):
+        for i, (x, y) in enumerate(coordinates):
             onCurve = glyph.flags[i] & _g_l_y_f.flagOnCurve
-            x, y = coordinates[i]
             absX = abs(x)
             absY = abs(y)
             onCurveBit = 0 if onCurve else 128

fontTools/ufoLib/__init__.py

@@ -32,30 +32,27 @@ Value conversion functions are available for converting
 - :func:`.convertFontInfoValueForAttributeFromVersion3ToVersion2`
 """
 
-import os
-from copy import deepcopy
-from os import fsdecode
+import enum
 import logging
+import os
 import zipfile
-import enum
 from collections import OrderedDict
-import fs
-import fs.base
-import fs.subfs
-import fs.errors
-import fs.copy
-import fs.osfs
-import fs.zipfs
-import fs.tempfs
-import fs.tools
+from copy import deepcopy
+from os import fsdecode
+
+from fontTools.misc import filesystem as fs
 from fontTools.misc import plistlib
-from fontTools.ufoLib.validators import *
-from fontTools.ufoLib.filenames import userNameToFileName
 from fontTools.ufoLib.converters import convertUFO1OrUFO2KerningToUFO3Kerning
 from fontTools.ufoLib.errors import UFOLibError
-from fontTools.ufoLib.utils import numberTypes, _VersionTupleEnumMixin
+from fontTools.ufoLib.filenames import userNameToFileName
+from fontTools.ufoLib.utils import _VersionTupleEnumMixin, numberTypes
+from fontTools.ufoLib.validators import *
+
+# client code can check this to see if the upstream `fs` package is being used
+haveFS = fs._haveFS
 
 __all__ = [
+    "haveFS",
     "makeUFOPath",
     "UFOLibError",
     "UFOReader",
@@ -184,7 +181,7 @@ class _UFOBaseIO:
                 return
             self.fs.writebytes(fileName, data)
         else:
-            with self.fs.openbin(fileName, mode="w") as fp:
+            with self.fs.open(fileName, mode="wb") as fp:
                 try:
                     plistlib.dump(obj, fp)
                 except Exception as e:
@@ -412,7 +409,7 @@ class UFOReader(_UFOBaseIO):
         path = fsdecode(path)
         try:
             if encoding is None:
-                return self.fs.openbin(path)
+                return self.fs.open(path, mode="rb")
             else:
                 return self.fs.open(path, mode="r", encoding=encoding)
         except fs.errors.ResourceNotFound:
@@ -818,7 +815,7 @@ class UFOReader(_UFOBaseIO):
                 # systems often have hidden directories
                 continue
             if validate:
-                with imagesFS.openbin(path.name) as fp:
+                with imagesFS.open(path.name, "rb") as fp:
                     valid, error = pngValidator(fileObj=fp)
                 if valid:
                     result.append(path.name)
@@ -984,18 +981,16 @@ class UFOWriter(UFOReader):
                             % len(rootDirs)
                         )
                     else:
-                        # 'ClosingSubFS' ensures that the parent filesystem is closed
-                        # when its root subdirectory is closed
-                        self.fs = parentFS.opendir(
-                            rootDirs[0], factory=fs.subfs.ClosingSubFS
-                        )
+                        rootDir = rootDirs[0]
                 else:
                     # if the output zip file didn't exist, we create the root folder;
                     # we name it the same as input 'path', but with '.ufo' extension
                     rootDir = os.path.splitext(os.path.basename(path))[0] + ".ufo"
                     parentFS = fs.zipfs.ZipFS(path, write=True, encoding="utf-8")
                     parentFS.makedir(rootDir)
-                    self.fs = parentFS.opendir(rootDir, factory=fs.subfs.ClosingSubFS)
+                # 'ClosingSubFS' ensures that the parent filesystem is closed
+                # when its root subdirectory is closed
+                self.fs = parentFS.opendir(rootDir, factory=fs.subfs.ClosingSubFS)
             else:
                 self.fs = fs.osfs.OSFS(path, create=True)
             self._fileStructure = structure

fontTools/ufoLib/glifLib.py

@@ -3,7 +3,7 @@ Generic module for reading and writing the .glif format.
 
 More info about the .glif format (GLyphInterchangeFormat) can be found here:
 
-	http://unifiedfontobject.org
+        http://unifiedfontobject.org
 
 The main class in this module is :class:`GlyphSet`. It manages a set of .glif files
 in a folder. It offers two ways to read glyph data, and one way to write
@@ -12,33 +12,28 @@ glyph data. See the class doc string for details.
 
 from __future__ import annotations
 
-import logging
 import enum
-from warnings import warn
+import logging
 from collections import OrderedDict
-import fs
-import fs.base
-import fs.errors
-import fs.osfs
-import fs.path
+from warnings import warn
+
+import fontTools.misc.filesystem as fs
+from fontTools.misc import etree, plistlib
 from fontTools.misc.textTools import tobytes
-from fontTools.misc import plistlib
 from fontTools.pens.pointPen import AbstractPointPen, PointToSegmentPen
+from fontTools.ufoLib import UFOFormatVersion, _UFOBaseIO
 from fontTools.ufoLib.errors import GlifLibError
 from fontTools.ufoLib.filenames import userNameToFileName
+from fontTools.ufoLib.utils import _VersionTupleEnumMixin, numberTypes
 from fontTools.ufoLib.validators import (
-    genericTypeValidator,
+    anchorsValidator,
     colorValidator,
+    genericTypeValidator,
+    glyphLibValidator,
     guidelinesValidator,
-    anchorsValidator,
     identifierValidator,
     imageValidator,
-    glyphLibValidator,
 )
-from fontTools.misc import etree
-from fontTools.ufoLib import _UFOBaseIO, UFOFormatVersion
-from fontTools.ufoLib.utils import numberTypes, _VersionTupleEnumMixin
-
 
 __all__ = [
     "GlyphSet",
@@ -206,7 +201,7 @@ class GlyphSet(_UFOBaseIO):
         # 'dirName' is kept for backward compatibility only, but it's DEPRECATED
         # as it's not guaranteed that it maps to an existing OSFS directory.
         # Client could use the FS api via the `self.fs` attribute instead.
-        self.dirName = fs.path.parts(path)[-1]
+        self.dirName = fs.path.basename(path)
         self.fs = filesystem
         # if glyphSet contains no 'contents.plist', we consider it empty
         self._havePreviousFile = filesystem.exists(CONTENTS_FILENAME)

fontTools/ufoLib/validators.py

@@ -1,14 +1,12 @@
 """Various low level data validators."""
 
 import calendar
+from collections.abc import Mapping
 from io import open
-import fs.base
-import fs.osfs
 
-from collections.abc import Mapping
+import fontTools.misc.filesystem as fs
 from fontTools.ufoLib.utils import numberTypes
 
-
 # -------
 # Generic
 # -------

fontTools/unicodedata/__init__.py

@@ -197,6 +197,8 @@ RTL_SCRIPTS = {
     "Yezi",  # Yezidi
     # Unicode-14.0 additions
     "Ougr",  # Old Uyghur
+    # Unicode-16.0 additions
+    "Gara",  # Garay
 }
 
 

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

@@ -56,7 +56,7 @@ def add_HVAR(font):
 def add_VVAR(font):
     if "VVAR" in font:
         del font["VVAR"]
-    getAdvanceMetrics = partial(_get_advance_metrics, font, axisTags, HVAR_FIELDS)
+    getAdvanceMetrics = partial(_get_advance_metrics, font, axisTags, VVAR_FIELDS)
     axisTags = [axis.axisTag for axis in font["fvar"].axes]
     _add_VHVAR(font, axisTags, VVAR_FIELDS, getAdvanceMetrics)