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

fontTools/ttLib/reorderGlyphs.py

@@ -275,10 +275,11 @@ def reorderGlyphs(font: ttLib.TTFont, new_glyph_order: List[str]):
                 for reorder in _REORDER_RULES.get(reorder_key, []):
                     reorder.apply(font, value)
 
-    if "CFF " in font:
-        cff_table = font["CFF "]
-        charstrings = cff_table.cff.topDictIndex[0].CharStrings.charStrings
-        cff_table.cff.topDictIndex[0].charset = new_glyph_order
-        cff_table.cff.topDictIndex[0].CharStrings.charStrings = {
-            k: charstrings.get(k) for k in new_glyph_order
-        }
+    for tag in ["CFF ", "CFF2"]:
+        if tag in font:
+            cff_table = font[tag]
+            charstrings = cff_table.cff.topDictIndex[0].CharStrings.charStrings
+            cff_table.cff.topDictIndex[0].charset = new_glyph_order
+            cff_table.cff.topDictIndex[0].CharStrings.charStrings = {
+                k: charstrings.get(k) for k in new_glyph_order
+            }

fontTools/ttLib/sfnt.py

@@ -13,6 +13,9 @@ classes, since whenever the number of tables changes or whenever
 a table's length changes you need to rewrite the whole file anyway.
 """
 
+from __future__ import annotations
+
+from collections.abc import KeysView
 from io import BytesIO
 from types import SimpleNamespace
 from fontTools.misc.textTools import Tag
@@ -84,7 +87,7 @@ class SFNTReader(object):
 
         if self.sfntVersion not in ("\x00\x01\x00\x00", "OTTO", "true"):
             raise TTLibError("Not a TrueType or OpenType font (bad sfntVersion)")
-        tables = {}
+        tables: dict[Tag, DirectoryEntry] = {}
         for i in range(self.numTables):
             entry = self.DirectoryEntry()
             entry.fromFile(self.file)
@@ -96,15 +99,15 @@ class SFNTReader(object):
         if self.flavor == "woff":
             self.flavorData = WOFFFlavorData(self)
 
-    def has_key(self, tag):
+    def has_key(self, tag: str | bytes) -> bool:
         return tag in self.tables
 
     __contains__ = has_key
 
-    def keys(self):
+    def keys(self) -> KeysView[Tag]:
         return self.tables.keys()
 
-    def __getitem__(self, tag):
+    def __getitem__(self, tag: str | bytes) -> bytes:
         """Fetch the raw table data."""
         entry = self.tables[Tag(tag)]
         data = entry.loadData(self.file)
@@ -122,10 +125,10 @@ class SFNTReader(object):
                 log.warning("bad checksum for '%s' table", tag)
         return data
 
-    def __delitem__(self, tag):
+    def __delitem__(self, tag: str | bytes) -> None:
         del self.tables[Tag(tag)]
 
-    def close(self):
+    def close(self) -> None:
         self.file.close()
 
     # We define custom __getstate__ and __setstate__ to make SFNTReader pickle-able
@@ -375,10 +378,9 @@ class SFNTWriter(object):
 
     def _calcMasterChecksum(self, directory):
         # 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)
 
         if self.DirectoryEntry != SFNTDirectoryEntry:
             # Create a SFNT directory for checksum calculation purposes

fontTools/ttLib/tables/D__e_b_g.py

@@ -1,9 +1,15 @@
 import json
+from textwrap import indent
 
 from . import DefaultTable
+from fontTools.misc.textTools import tostr
 
 
 class table_D__e_b_g(DefaultTable.DefaultTable):
+    def __init__(self, tag=None):
+        DefaultTable.DefaultTable.__init__(self, tag)
+        self.data = {}
+
     def decompile(self, data, ttFont):
         self.data = json.loads(data)
 
@@ -11,7 +17,19 @@ class table_D__e_b_g(DefaultTable.DefaultTable):
         return json.dumps(self.data).encode("utf-8")
 
     def toXML(self, writer, ttFont):
-        writer.writecdata(json.dumps(self.data, indent=2))
+        # make sure json indentation inside CDATA block matches XMLWriter's
+        data = json.dumps(self.data, indent=len(writer.indentwhite))
+        prefix = tostr(writer.indentwhite) * (writer.indentlevel + 1)
+        # but don't indent the first json line so it's adjacent to `<![CDATA[{`
+        cdata = indent(data, prefix, lambda ln: ln != "{\n")
+
+        writer.begintag("json")
+        writer.newline()
+        writer.writecdata(cdata)
+        writer.newline()
+        writer.endtag("json")
+        writer.newline()
 
     def fromXML(self, name, attrs, content, ttFont):
-        self.data = json.loads(content)
+        if name == "json":
+            self.data = json.loads("".join(content))

fontTools/ttLib/tables/G_V_A_R_.py

@@ -0,0 +1,5 @@
+from ._g_v_a_r import table__g_v_a_r
+
+
+class table_G_V_A_R_(table__g_v_a_r):
+    gid_size = 3

fontTools/ttLib/tables/S__i_l_f.py

@@ -948,7 +948,7 @@ class Pass(object):
         writer.newline()
         writer.begintag("rules")
         writer.newline()
-        for i in range(len(self.actions)):
+        for i, action in enumerate(self.actions):
             writer.begintag(
                 "rule",
                 index=i,
@@ -958,7 +958,7 @@ class Pass(object):
             writer.newline()
             if len(self.ruleConstraints[i]):
                 writecode("constraint", writer, self.ruleConstraints[i])
-            writecode("action", writer, self.actions[i])
+            writecode("action", writer, action)
             writer.endtag("rule")
             writer.newline()
         writer.endtag("rules")

fontTools/ttLib/tables/T_S_I__0.py

@@ -1,4 +1,4 @@
-""" TSI{0,1,2,3,5} are private tables used by Microsoft Visual TrueType (VTT)
+"""TSI{0,1,2,3,5} are private tables used by Microsoft Visual TrueType (VTT)
 tool to store its hinting source data.
 
 TSI0 is the index table containing the lengths and offsets for the glyph
@@ -8,9 +8,13 @@ in the TSI1 table.
 See also https://learn.microsoft.com/en-us/typography/tools/vtt/tsi-tables
 """
 
-from . import DefaultTable
+import logging
 import struct
 
+from . import DefaultTable
+
+log = logging.getLogger(__name__)
+
 tsi0Format = ">HHL"
 
 
@@ -25,7 +29,14 @@ class table_T_S_I__0(DefaultTable.DefaultTable):
         numGlyphs = ttFont["maxp"].numGlyphs
         indices = []
         size = struct.calcsize(tsi0Format)
-        for i in range(numGlyphs + 5):
+        numEntries = len(data) // size
+        if numEntries != numGlyphs + 5:
+            diff = numEntries - numGlyphs - 5
+            log.warning(
+                "Number of glyphPrograms differs from the number of glyphs in the font "
+                f"by {abs(diff)} ({numEntries - 5} programs vs. {numGlyphs} glyphs)."
+            )
+        for _ in range(numEntries):
             glyphID, textLength, textOffset = fixlongs(
                 *struct.unpack(tsi0Format, data[:size])
             )

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

@@ -1,4 +1,4 @@
-""" TSI{0,1,2,3,5} are private tables used by Microsoft Visual TrueType (VTT)
+"""TSI{0,1,2,3,5} are private tables used by Microsoft Visual TrueType (VTT)
 tool to store its hinting source data.
 
 TSI5 contains the VTT character groups.
@@ -6,29 +6,40 @@ TSI5 contains the VTT character groups.
 See also https://learn.microsoft.com/en-us/typography/tools/vtt/tsi-tables
 """
 
+import array
+import logging
+import sys
+
 from fontTools.misc.textTools import safeEval
+
 from . import DefaultTable
-import sys
-import array
+
+log = logging.getLogger(__name__)
 
 
 class table_T_S_I__5(DefaultTable.DefaultTable):
     def decompile(self, data, ttFont):
         numGlyphs = ttFont["maxp"].numGlyphs
-        assert len(data) == 2 * numGlyphs
         a = array.array("H")
         a.frombytes(data)
         if sys.byteorder != "big":
             a.byteswap()
         self.glyphGrouping = {}
-        for i in range(numGlyphs):
+        numEntries = len(data) // 2
+        if numEntries != numGlyphs:
+            diff = numEntries - numGlyphs
+            log.warning(
+                "Number of entries differs from the number of glyphs in the font "
+                f"by {abs(diff)} ({numEntries} entries vs. {numGlyphs} glyphs)."
+            )
+        for i in range(numEntries):
             self.glyphGrouping[ttFont.getGlyphName(i)] = a[i]
 
     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/__init__.py

@@ -23,6 +23,7 @@ def _moduleFinderHint():
     from . import G_P_K_G_
     from . import G_P_O_S_
     from . import G_S_U_B_
+    from . import G_V_A_R_
     from . import G__l_a_t
     from . import G__l_o_c
     from . import H_V_A_R_

fontTools/ttLib/tables/_a_v_a_r.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+from typing import Mapping, TYPE_CHECKING
 from fontTools.misc import sstruct
 from fontTools.misc.fixedTools import (
     fixedToFloat as fi2fl,
@@ -20,6 +23,9 @@ log = logging.getLogger(__name__)
 
 from .otBase import BaseTTXConverter
 
+if TYPE_CHECKING:
+    from ..ttFont import TTFont
+
 
 class table__a_v_a_r(BaseTTXConverter):
     """Axis Variations table
@@ -143,8 +149,9 @@ class table__a_v_a_r(BaseTTXConverter):
         else:
             super().fromXML(name, attrs, content, ttFont)
 
-    def renormalizeLocation(self, location, font):
-
+    def renormalizeLocation(
+        self, location: Mapping[str, float], font: TTFont, dropZeroes: bool = True
+    ) -> dict[str, float]:
         majorVersion = getattr(self, "majorVersion", 1)
 
         if majorVersion not in (1, 2):
@@ -185,7 +192,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/_c_m_a_p.py

@@ -141,6 +141,17 @@ class table__c_m_a_p(DefaultTable.DefaultTable):
                     result.setdefault(name, set()).add(codepoint)
         return result
 
+    def buildReversedMin(self):
+        result = {}
+        for subtable in self.tables:
+            if subtable.isUnicode():
+                for codepoint, name in subtable.cmap.items():
+                    if name in result:
+                        result[name] = min(result[name], codepoint)
+                    else:
+                        result[name] = codepoint
+        return result
+
     def decompile(self, data, ttFont):
         tableVersion, numSubTables = struct.unpack(">HH", data[:4])
         self.tableVersion = int(tableVersion)
@@ -387,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):
@@ -1162,13 +1173,15 @@ class cmap_format_12_or_13(CmapSubtable):
         charCodes = []
         gids = []
         pos = 0
+        groups = array.array("I", data[: self.nGroups * 12])
+        if sys.byteorder != "big":
+            groups.byteswap()
         for i in range(self.nGroups):
-            startCharCode, endCharCode, glyphID = struct.unpack(
-                ">LLL", data[pos : pos + 12]
-            )
-            pos += 12
+            startCharCode = groups[i * 3]
+            endCharCode = groups[i * 3 + 1]
+            glyphID = groups[i * 3 + 2]
             lenGroup = 1 + endCharCode - startCharCode
-            charCodes.extend(list(range(startCharCode, endCharCode + 1)))
+            charCodes.extend(range(startCharCode, endCharCode + 1))
             gids.extend(self._computeGIDs(glyphID, lenGroup))
         self.data = data = None
         self.cmap = _make_map(self.ttFont, charCodes, gids)
@@ -1299,7 +1312,7 @@ class cmap_format_12(cmap_format_12_or_13):
         cmap_format_12_or_13.__init__(self, format)
 
     def _computeGIDs(self, startingGlyph, numberOfGlyphs):
-        return list(range(startingGlyph, startingGlyph + numberOfGlyphs))
+        return range(startingGlyph, startingGlyph + numberOfGlyphs)
 
     def _IsInSameRun(self, glyphID, lastGlyphID, charCode, lastCharCode):
         return (glyphID == 1 + lastGlyphID) and (charCode == 1 + lastCharCode)

fontTools/ttLib/tables/_c_v_t.py

@@ -21,14 +21,15 @@ class table__c_v_t(DefaultTable.DefaultTable):
         self.values = values
 
     def compile(self, ttFont):
+        if not hasattr(self, "values"):
+            return b""
         values = self.values[:]
         if sys.byteorder != "big":
             values.byteswap()
         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/_f_p_g_m.py

@@ -20,7 +20,9 @@ class table__f_p_g_m(DefaultTable.DefaultTable):
         self.program = program
 
     def compile(self, ttFont):
-        return self.program.getBytecode()
+        if hasattr(self, "program"):
+            return self.program.getBytecode()
+        return b""
 
     def toXML(self, writer, ttFont):
         self.program.toXML(writer, ttFont)

fontTools/ttLib/tables/_g_l_y_f.py

@@ -134,6 +134,8 @@ class table__g_l_y_f(DefaultTable.DefaultTable):
             glyph.expand(self)
 
     def compile(self, ttFont):
+        optimizeSpeed = ttFont.cfg[ttLib.OPTIMIZE_FONT_SPEED]
+
         self.axisTags = (
             [axis.axisTag for axis in ttFont["fvar"].axes] if "fvar" in ttFont else []
         )
@@ -148,7 +150,12 @@ class table__g_l_y_f(DefaultTable.DefaultTable):
         boundsDone = set()
         for glyphName in self.glyphOrder:
             glyph = self.glyphs[glyphName]
-            glyphData = glyph.compile(self, recalcBBoxes, boundsDone=boundsDone)
+            glyphData = glyph.compile(
+                self,
+                recalcBBoxes,
+                boundsDone=boundsDone,
+                optimizeSize=not optimizeSpeed,
+            )
             if padding > 1:
                 glyphData = pad(glyphData, size=padding)
             locations.append(currentLocation)
@@ -714,7 +721,7 @@ class Glyph(object):
             self.decompileCoordinates(data)
 
     def compile(
-        self, glyfTable, recalcBBoxes=True, *, boundsDone=None, optimizeSize=None
+        self, glyfTable, recalcBBoxes=True, *, boundsDone=None, optimizeSize=True
     ):
         if hasattr(self, "data"):
             if recalcBBoxes:
@@ -732,8 +739,6 @@ class Glyph(object):
         if self.isComposite():
             data = data + self.compileComponents(glyfTable)
         else:
-            if optimizeSize is None:
-                optimizeSize = getattr(glyfTable, "optimizeSize", True)
             data = data + self.compileCoordinates(optimizeSize=optimizeSize)
         return data
 
@@ -969,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()
@@ -1187,7 +1191,7 @@ class Glyph(object):
         ):
             return
         try:
-            coords, endPts, flags = self.getCoordinates(glyfTable)
+            coords, endPts, flags = self.getCoordinates(glyfTable, round=otRound)
             self.xMin, self.yMin, self.xMax, self.yMax = coords.calcIntBounds()
         except NotImplementedError:
             pass
@@ -1206,9 +1210,7 @@ class Glyph(object):
         Return True if bounds were calculated, False otherwise.
         """
         for compo in self.components:
-            if hasattr(compo, "firstPt") or hasattr(compo, "transform"):
-                return False
-            if not float(compo.x).is_integer() or not float(compo.y).is_integer():
+            if not compo._hasOnlyIntegerTranslate():
                 return False
 
         # All components are untransformed and have an integer x/y translate
@@ -1222,7 +1224,7 @@ class Glyph(object):
                 if boundsDone is not None:
                     boundsDone.add(glyphName)
             # empty components shouldn't update the bounds of the parent glyph
-            if g.numberOfContours == 0:
+            if g.yMin == g.yMax and g.xMin == g.xMax:
                 continue
 
             x, y = compo.x, compo.y
@@ -1241,7 +1243,7 @@ class Glyph(object):
         else:
             return self.numberOfContours == -1
 
-    def getCoordinates(self, glyfTable):
+    def getCoordinates(self, glyfTable, *, round=noRound):
         """Return the coordinates, end points and flags
 
         This method returns three values: A :py:class:`GlyphCoordinates` object,
@@ -1267,13 +1269,23 @@ class Glyph(object):
             for compo in self.components:
                 g = glyfTable[compo.glyphName]
                 try:
-                    coordinates, endPts, flags = g.getCoordinates(glyfTable)
+                    coordinates, endPts, flags = g.getCoordinates(
+                        glyfTable, round=round
+                    )
                 except RecursionError:
                     raise ttLib.TTLibError(
                         "glyph '%s' contains a recursive component reference"
                         % compo.glyphName
                     )
                 coordinates = GlyphCoordinates(coordinates)
+                # if asked to round e.g. while computing bboxes, it's important we
+                # do it immediately before a component transform is applied to a
+                # simple glyph's coordinates in case these might still contain floats;
+                # however, if the referenced component glyph is another composite, we
+                # must not round here but only at the end, after all the nested
+                # transforms have been applied, or else rounding errors will compound.
+                if round is not noRound and g.numberOfContours > 0:
+                    coordinates.toInt(round=round)
                 if hasattr(compo, "firstPt"):
                     # component uses two reference points: we apply the transform _before_
                     # computing the offset between the points
@@ -1930,6 +1942,18 @@ class GlyphComponent(object):
         result = self.__eq__(other)
         return result if result is NotImplemented else not result
 
+    def _hasOnlyIntegerTranslate(self):
+        """Return True if it's a 'simple' component.
+
+        That is, it has no anchor points and no transform other than integer translate.
+        """
+        return (
+            not hasattr(self, "firstPt")
+            and not hasattr(self, "transform")
+            and float(self.x).is_integer()
+            and float(self.y).is_integer()
+        )
+
 
 class GlyphCoordinates(object):
     """A list of glyph coordinates.
@@ -2012,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
@@ -2143,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):
@@ -2189,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
 
@@ -2213,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