fonttools 4.56.0__py3-none-any.whl → 4.58.0__py3-none-any.whl

fontTools/ttLib/tables/_g_v_a_r.py

@@ -3,6 +3,7 @@ from functools import partial
 from fontTools.misc import sstruct
 from fontTools.misc.textTools import safeEval
 from fontTools.misc.lazyTools import LazyDict
+from fontTools.ttLib import OPTIMIZE_FONT_SPEED
 from fontTools.ttLib.tables.TupleVariation import TupleVariation
 from . import DefaultTable
 import array
@@ -23,19 +24,24 @@ log = logging.getLogger(__name__)
 # FreeType2 source code for parsing 'gvar':
 # http://git.savannah.gnu.org/cgit/freetype/freetype2.git/tree/src/truetype/ttgxvar.c
 
-GVAR_HEADER_FORMAT = """
+GVAR_HEADER_FORMAT_HEAD = """
 	> # big endian
 	version:			H
 	reserved:			H
 	axisCount:			H
 	sharedTupleCount:		H
 	offsetToSharedTuples:		I
-	glyphCount:			H
+"""
+# In between the HEAD and TAIL lies the glyphCount, which is
+# of different size: 2 bytes for gvar, and 3 bytes for GVAR.
+GVAR_HEADER_FORMAT_TAIL = """
+	> # big endian
 	flags:				H
 	offsetToGlyphVariationData:	I
 """
 
-GVAR_HEADER_SIZE = sstruct.calcsize(GVAR_HEADER_FORMAT)
+GVAR_HEADER_SIZE_HEAD = sstruct.calcsize(GVAR_HEADER_FORMAT_HEAD)
+GVAR_HEADER_SIZE_TAIL = sstruct.calcsize(GVAR_HEADER_FORMAT_TAIL)
 
 
 class table__g_v_a_r(DefaultTable.DefaultTable):
@@ -50,6 +56,7 @@ class table__g_v_a_r(DefaultTable.DefaultTable):
     """
 
     dependencies = ["fvar", "glyf"]
+    gid_size = 2
 
     def __init__(self, tag=None):
         DefaultTable.DefaultTable.__init__(self, tag)
@@ -57,6 +64,7 @@ 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())
@@ -72,28 +80,33 @@ class table__g_v_a_r(DefaultTable.DefaultTable):
         offsets.append(offset)
         compiledOffsets, tableFormat = self.compileOffsets_(offsets)
 
+        GVAR_HEADER_SIZE = GVAR_HEADER_SIZE_HEAD + self.gid_size + GVAR_HEADER_SIZE_TAIL
         header = {}
         header["version"] = self.version
         header["reserved"] = self.reserved
         header["axisCount"] = len(axisTags)
         header["sharedTupleCount"] = len(sharedTuples)
         header["offsetToSharedTuples"] = GVAR_HEADER_SIZE + len(compiledOffsets)
-        header["glyphCount"] = len(compiledGlyphs)
         header["flags"] = tableFormat
         header["offsetToGlyphVariationData"] = (
             header["offsetToSharedTuples"] + sharedTupleSize
         )
-        compiledHeader = sstruct.pack(GVAR_HEADER_FORMAT, header)
 
-        result = [compiledHeader, compiledOffsets]
+        result = [
+            sstruct.pack(GVAR_HEADER_FORMAT_HEAD, header),
+            len(compiledGlyphs).to_bytes(self.gid_size, "big"),
+            sstruct.pack(GVAR_HEADER_FORMAT_TAIL, header),
+        ]
+
+        result.append(compiledOffsets)
         result.extend(sharedTuples)
         result.extend(compiledGlyphs)
         return b"".join(result)
 
     def compileGlyphs_(self, ttFont, axisTags, sharedCoordIndices):
+        optimizeSpeed = ttFont.cfg[OPTIMIZE_FONT_SPEED]
         result = []
         glyf = ttFont["glyf"]
-        optimizeSize = getattr(self, "optimizeSize", True)
         for glyphName in ttFont.getGlyphOrder():
             variations = self.variations.get(glyphName, [])
             if not variations:
@@ -102,11 +115,12 @@ class table__g_v_a_r(DefaultTable.DefaultTable):
             pointCountUnused = 0  # pointCount is actually unused by compileGlyph
             result.append(
                 compileGlyph_(
+                    self.gid_size,
                     variations,
                     pointCountUnused,
                     axisTags,
                     sharedCoordIndices,
-                    optimizeSize=optimizeSize,
+                    optimizeSize=not optimizeSpeed,
                 )
             )
         return result
@@ -114,7 +128,19 @@ class table__g_v_a_r(DefaultTable.DefaultTable):
     def decompile(self, data, ttFont):
         axisTags = [axis.axisTag for axis in ttFont["fvar"].axes]
         glyphs = ttFont.getGlyphOrder()
-        sstruct.unpack(GVAR_HEADER_FORMAT, data[0:GVAR_HEADER_SIZE], self)
+
+        # Parse the header
+        GVAR_HEADER_SIZE = GVAR_HEADER_SIZE_HEAD + self.gid_size + GVAR_HEADER_SIZE_TAIL
+        sstruct.unpack(GVAR_HEADER_FORMAT_HEAD, data[:GVAR_HEADER_SIZE_HEAD], self)
+        self.glyphCount = int.from_bytes(
+            data[GVAR_HEADER_SIZE_HEAD : GVAR_HEADER_SIZE_HEAD + self.gid_size], "big"
+        )
+        sstruct.unpack(
+            GVAR_HEADER_FORMAT_TAIL,
+            data[GVAR_HEADER_SIZE_HEAD + self.gid_size : GVAR_HEADER_SIZE],
+            self,
+        )
+
         assert len(glyphs) == self.glyphCount
         assert len(axisTags) == self.axisCount
         sharedCoords = tv.decompileSharedTuples(
@@ -144,7 +170,7 @@ class table__g_v_a_r(DefaultTable.DefaultTable):
                 glyph = glyf[glyphName]
                 numPointsInGlyph = self.getNumPoints_(glyph)
                 return decompileGlyph_(
-                    numPointsInGlyph, sharedCoords, axisTags, gvarData
+                    self.gid_size, numPointsInGlyph, sharedCoords, axisTags, gvarData
                 )
 
             return read_item
@@ -262,23 +288,42 @@ class table__g_v_a_r(DefaultTable.DefaultTable):
 
 
 def compileGlyph_(
-    variations, pointCount, axisTags, sharedCoordIndices, *, optimizeSize=True
+    dataOffsetSize,
+    variations,
+    pointCount,
+    axisTags,
+    sharedCoordIndices,
+    *,
+    optimizeSize=True,
 ):
+    assert dataOffsetSize in (2, 3)
     tupleVariationCount, tuples, data = tv.compileTupleVariationStore(
         variations, pointCount, axisTags, sharedCoordIndices, optimizeSize=optimizeSize
     )
     if tupleVariationCount == 0:
         return b""
-    result = [struct.pack(">HH", tupleVariationCount, 4 + len(tuples)), tuples, data]
-    if (len(tuples) + len(data)) % 2 != 0:
+
+    offsetToData = 2 + dataOffsetSize + len(tuples)
+
+    result = [
+        tupleVariationCount.to_bytes(2, "big"),
+        offsetToData.to_bytes(dataOffsetSize, "big"),
+        tuples,
+        data,
+    ]
+    if (offsetToData + len(data)) % 2 != 0:
         result.append(b"\0")  # padding
     return b"".join(result)
 
 
-def decompileGlyph_(pointCount, sharedTuples, axisTags, data):
-    if len(data) < 4:
+def decompileGlyph_(dataOffsetSize, pointCount, sharedTuples, axisTags, data):
+    assert dataOffsetSize in (2, 3)
+    if len(data) < 2 + dataOffsetSize:
         return []
-    tupleVariationCount, offsetToData = struct.unpack(">HH", data[:4])
+
+    tupleVariationCount = int.from_bytes(data[:2], "big")
+    offsetToData = int.from_bytes(data[2 : 2 + dataOffsetSize], "big")
+
     dataPos = offsetToData
     return tv.decompileTupleVariationStore(
         "gvar",
@@ -287,6 +332,6 @@ def decompileGlyph_(pointCount, sharedTuples, axisTags, data):
         pointCount,
         sharedTuples,
         data,
-        4,
+        2 + dataOffsetSize,
         offsetToData,
     )

fontTools/ttLib/tables/_p_o_s_t.py

@@ -122,13 +122,16 @@ class table__p_o_s_t(DefaultTable.DefaultTable):
             glyphName = psName = self.glyphOrder[i]
             if glyphName == "":
                 glyphName = "glyph%.5d" % i
+
             if glyphName in allNames:
                 # make up a new glyphName that's unique
                 n = allNames[glyphName]
-                while (glyphName + "#" + str(n)) in allNames:
+                # check if the exists in any of the seen names or later ones
+                names = set(allNames.keys()) | set(self.glyphOrder)
+                while (glyphName + "." + str(n)) in names:
                     n += 1
                 allNames[glyphName] = n + 1
-                glyphName = glyphName + "#" + str(n)
+                glyphName = glyphName + "." + str(n)
 
             self.glyphOrder[i] = glyphName
             allNames[glyphName] = 1

fontTools/ttLib/tables/otBase.py

@@ -398,6 +398,7 @@ class OTTableWriter(object):
         self.localState = localState
         self.tableTag = tableTag
         self.parent = None
+        self.name = "<none>"
 
     def __setitem__(self, name, value):
         state = self.localState.copy() if self.localState else dict()

fontTools/ttLib/tables/otConverters.py

@@ -10,7 +10,7 @@ from fontTools.ttLib.tables.TupleVariation import TupleVariation
 from fontTools.misc.roundTools import nearestMultipleShortestRepr, otRound
 from fontTools.misc.textTools import bytesjoin, tobytes, tostr, pad, safeEval
 from fontTools.misc.lazyTools import LazyList
-from fontTools.ttLib import getSearchRange
+from fontTools.ttLib import OPTIMIZE_FONT_SPEED, getSearchRange
 from .otBase import (
     CountReference,
     FormatSwitchingBaseTable,
@@ -1810,7 +1810,10 @@ class TupleValues:
         return TupleVariation.decompileDeltas_(None, data)[0]
 
     def write(self, writer, font, tableDict, values, repeatIndex=None):
-        return bytes(TupleVariation.compileDeltaValues_(values))
+        optimizeSpeed = font.cfg[OPTIMIZE_FONT_SPEED]
+        return bytes(
+            TupleVariation.compileDeltaValues_(values, optimizeSize=not optimizeSpeed)
+        )
 
     def xmlRead(self, attrs, content, font):
         return safeEval(attrs["value"])

fontTools/ttLib/tables/otTables.py

@@ -11,6 +11,7 @@ from functools import reduce
 from math import radians
 import itertools
 from collections import defaultdict, namedtuple
+from fontTools.ttLib import OPTIMIZE_FONT_SPEED
 from fontTools.ttLib.tables.TupleVariation import TupleVariation
 from fontTools.ttLib.tables.otTraverse import dfs_base_table
 from fontTools.misc.arrayTools import quantizeRect
@@ -236,6 +237,8 @@ class VarComponent:
         return data[i:]
 
     def compile(self, font):
+        optimizeSpeed = font.cfg[OPTIMIZE_FONT_SPEED]
+
         data = []
 
         flags = self.flags
@@ -259,7 +262,8 @@ class VarComponent:
             data.append(_write_uint32var(self.axisIndicesIndex))
             data.append(
                 TupleVariation.compileDeltaValues_(
-                    [fl2fi(v, 14) for v in self.axisValues]
+                    [fl2fi(v, 14) for v in self.axisValues],
+                    optimizeSize=not optimizeSpeed,
                 )
             )
         else:

fontTools/ttLib/ttFont.py

@@ -593,10 +593,8 @@ class TTFont(object):
         # temporary cmap and by the real cmap in case we don't find a unicode
         # cmap.
         numGlyphs = int(self["maxp"].numGlyphs)
-        glyphOrder = [None] * numGlyphs
+        glyphOrder = ["glyph%.5d" % i for i in range(numGlyphs)]
         glyphOrder[0] = ".notdef"
-        for i in range(1, numGlyphs):
-            glyphOrder[i] = "glyph%.5d" % i
         # Set the glyph order, so the cmap parser has something
         # to work with (so we don't get called recursively).
         self.glyphOrder = glyphOrder
@@ -606,7 +604,7 @@ class TTFont(object):
         # this naming table will usually not cover all glyphs in the font.
         # If the font has no Unicode cmap table, reversecmap will be empty.
         if "cmap" in self:
-            reversecmap = self["cmap"].buildReversed()
+            reversecmap = self["cmap"].buildReversedMin()
         else:
             reversecmap = {}
         useCount = {}
@@ -616,7 +614,7 @@ class TTFont(object):
                 # If a font maps both U+0041 LATIN CAPITAL LETTER A and
                 # U+0391 GREEK CAPITAL LETTER ALPHA to the same glyph,
                 # we prefer naming the glyph as "A".
-                glyphName = self._makeGlyphName(min(reversecmap[tempName]))
+                glyphName = self._makeGlyphName(reversecmap[tempName])
                 numUses = useCount[glyphName] = useCount.get(glyphName, 0) + 1
                 if numUses > 1:
                     glyphName = "%s.alt%d" % (glyphName, numUses - 1)

fontTools/ttLib/ttGlyphSet.py

@@ -104,16 +104,6 @@ class _TTGlyphSetGlyf(_TTGlyphSet):
         return _TTGlyphGlyf(self, glyphName, recalcBounds=self.recalcBounds)
 
 
-class _TTGlyphSetGlyf(_TTGlyphSet):
-    def __init__(self, font, location, recalcBounds=True):
-        self.glyfTable = font["glyf"]
-        super().__init__(font, location, self.glyfTable, recalcBounds=recalcBounds)
-        self.gvarTable = font.get("gvar")
-
-    def __getitem__(self, glyphName):
-        return _TTGlyphGlyf(self, glyphName, recalcBounds=self.recalcBounds)
-
-
 class _TTGlyphSetCFF(_TTGlyphSet):
     def __init__(self, font, location):
         tableTag = "CFF2" if "CFF2" in font else "CFF "

fontTools/ttx.py

@@ -101,9 +101,15 @@ Compile options
 --with-zopfli
              Use Zopfli instead of Zlib to compress WOFF. The Python
              extension is available at https://pypi.python.org/pypi/zopfli
+--optimize-font-speed
+             Enable optimizations that prioritize speed over file size.
+             This mainly affects how glyf t able and gvar / VARC tables are
+             compiled. The produced fonts will be larger, but rendering
+             performance will be improved with HarfBuzz and other text
+             layout engines.
 """
 
-from fontTools.ttLib import TTFont, TTLibError
+from fontTools.ttLib import OPTIMIZE_FONT_SPEED, TTFont, TTLibError
 from fontTools.misc.macCreatorType import getMacCreatorAndType
 from fontTools.unicode import setUnicodeData
 from fontTools.misc.textTools import Tag, tostr
@@ -141,6 +147,7 @@ class Options(object):
     recalcTimestamp = None
     flavor = None
     useZopfli = False
+    optimizeFontSpeed = False
 
     def __init__(self, rawOptions, numFiles):
         self.onlyTables = []
@@ -229,6 +236,8 @@ class Options(object):
                 self.flavor = value
             elif option == "--with-zopfli":
                 self.useZopfli = True
+            elif option == "--optimize-font-speed":
+                self.optimizeFontSpeed = True
         if self.verbose and self.quiet:
             raise getopt.GetoptError("-q and -v options are mutually exclusive")
         if self.verbose:
@@ -324,6 +333,8 @@ def ttCompile(input, output, options):
         recalcBBoxes=options.recalcBBoxes,
         recalcTimestamp=options.recalcTimestamp,
     )
+    if options.optimizeFontSpeed:
+        ttf.cfg[OPTIMIZE_FONT_SPEED] = options.optimizeFontSpeed
     ttf.importXML(input)
 
     if options.recalcTimestamp is None and "head" in ttf and input is not sys.stdin:
@@ -386,6 +397,7 @@ def parseOptions(args):
             "version",
             "with-zopfli",
             "newline=",
+            "optimize-font-speed",
         ],
     )
 

fontTools/ufoLib/__init__.py

@@ -204,7 +204,7 @@ class UFOReader(_UFOBaseIO):
     """Read the various components of a .ufo.
 
     Attributes:
-        path: An `os.PathLike` object pointing to the .ufo.
+        path: An :class:`os.PathLike` object pointing to the .ufo.
         validate: A boolean indicating if the data read should be
           validated. Defaults to `True`.
 
@@ -891,7 +891,7 @@ class UFOWriter(UFOReader):
     """Write the various components of a .ufo.
 
     Attributes:
-        path: An `os.PathLike` object pointing to the .ufo.
+        path: An :class:`os.PathLike` object pointing to the .ufo.
         formatVersion: the UFO format version as a tuple of integers (major, minor),
             or as a single integer for the major digit only (minor is implied to be 0).
             By default, the latest formatVersion will be used; currently it is 3.0,

fontTools/ufoLib/converters.py

@@ -1,11 +1,33 @@
 """
-Conversion functions.
+Functions for converting UFO1 or UFO2 files into UFO3 format.
+
+Currently provides functionality for converting kerning rules
+and kerning groups. Conversion is only supported _from_ UFO1
+or UFO2, and _to_ UFO3.
 """
 
 # adapted from the UFO spec
 
 
 def convertUFO1OrUFO2KerningToUFO3Kerning(kerning, groups, glyphSet=()):
+    """Convert kerning data in UFO1 or UFO2 syntax into UFO3 syntax.
+
+    Args:
+      kerning:
+          A dictionary containing the kerning rules defined in
+          the UFO font, as used in :class:`.UFOReader` objects.
+      groups:
+          A dictionary containing the groups defined in the UFO
+          font, as used in :class:`.UFOReader` objects.
+      glyphSet:
+        Optional; a set of glyph objects to skip (default: None).
+
+    Returns:
+      1. A dictionary representing the converted kerning data.
+      2. A copy of the groups dictionary, with all groups renamed to UFO3 syntax.
+      3. A dictionary containing the mapping of old group names to new group names.
+
+    """
     # gather known kerning groups based on the prefixes
     firstReferencedGroups, secondReferencedGroups = findKnownKerningGroups(groups)
     # Make lists of groups referenced in kerning pairs.
@@ -63,35 +85,54 @@ def convertUFO1OrUFO2KerningToUFO3Kerning(kerning, groups, glyphSet=()):
 
 
 def findKnownKerningGroups(groups):
-    """
-    This will find kerning groups with known prefixes.
-    In some cases not all kerning groups will be referenced
-    by the kerning pairs. The algorithm for locating groups
-    in convertUFO1OrUFO2KerningToUFO3Kerning will miss these
-    unreferenced groups. By scanning for known prefixes
+    """Find all kerning groups in a UFO1 or UFO2 font that use known prefixes.
+
+    In some cases, not all kerning groups will be referenced
+    by the kerning pairs in a UFO. The algorithm for locating
+    groups in :func:`convertUFO1OrUFO2KerningToUFO3Kerning` will
+    miss these unreferenced groups. By scanning for known prefixes,
     this function will catch all of the prefixed groups.
 
-    These are the prefixes and sides that are handled:
+    The prefixes and sides by this function are:
+
     @MMK_L_ - side 1
     @MMK_R_ - side 2
 
-    >>> testGroups = {
-    ...     "@MMK_L_1" : None,
-    ...     "@MMK_L_2" : None,
-    ...     "@MMK_L_3" : None,
-    ...     "@MMK_R_1" : None,
-    ...     "@MMK_R_2" : None,
-    ...     "@MMK_R_3" : None,
-    ...     "@MMK_l_1" : None,
-    ...     "@MMK_r_1" : None,
-    ...     "@MMK_X_1" : None,
-    ...     "foo" : None,
-    ... }
-    >>> first, second = findKnownKerningGroups(testGroups)
-    >>> sorted(first) == ['@MMK_L_1', '@MMK_L_2', '@MMK_L_3']
-    True
-    >>> sorted(second) == ['@MMK_R_1', '@MMK_R_2', '@MMK_R_3']
-    True
+    as defined in the UFO1 specification.
+
+    Args:
+        groups:
+          A dictionary containing the groups defined in the UFO
+          font, as read by :class:`.UFOReader`.
+
+    Returns:
+        Two sets; the first containing the names of all
+        first-side kerning groups identified in the ``groups``
+        dictionary, and the second containing the names of all
+        second-side kerning groups identified.
+
+        "First-side" and "second-side" are with respect to the
+        writing direction of the script.
+
+        Example::
+
+          >>> testGroups = {
+          ...     "@MMK_L_1" : None,
+          ...     "@MMK_L_2" : None,
+          ...     "@MMK_L_3" : None,
+          ...     "@MMK_R_1" : None,
+          ...     "@MMK_R_2" : None,
+          ...     "@MMK_R_3" : None,
+          ...     "@MMK_l_1" : None,
+          ...     "@MMK_r_1" : None,
+          ...     "@MMK_X_1" : None,
+          ...     "foo" : None,
+          ... }
+          >>> first, second = findKnownKerningGroups(testGroups)
+          >>> sorted(first) == ['@MMK_L_1', '@MMK_L_2', '@MMK_L_3']
+          True
+          >>> sorted(second) == ['@MMK_R_1', '@MMK_R_2', '@MMK_R_3']
+          True
     """
     knownFirstGroupPrefixes = ["@MMK_L_"]
     knownSecondGroupPrefixes = ["@MMK_R_"]
@@ -110,6 +151,27 @@ def findKnownKerningGroups(groups):
 
 
 def makeUniqueGroupName(name, groupNames, counter=0):
+    """Make a kerning group name that will be unique within the set of group names.
+
+    If the requested kerning group name already exists within the set, this
+    will return a new name by adding an incremented counter to the end
+    of the requested name.
+
+    Args:
+        name:
+          The requested kerning group name.
+        groupNames:
+          A list of the existing kerning group names.
+        counter:
+          Optional; a counter of group names already seen (default: 0). If
+          :attr:`.counter` is not provided, the function will recurse,
+          incrementing the value of :attr:`.counter` until it finds the
+          first unused ``name+counter`` combination, and return that result.
+
+    Returns:
+        A unique kerning group name composed of the requested name suffixed
+        by the smallest available integer counter.
+    """
     # Add a number to the name if the counter is higher than zero.
     newName = name
     if counter > 0:
@@ -123,6 +185,8 @@ def makeUniqueGroupName(name, groupNames, counter=0):
 
 def test():
     """
+    Tests for :func:`.convertUFO1OrUFO2KerningToUFO3Kerning`.
+
     No known prefixes.
 
     >>> testKerning = {

fontTools/ufoLib/errors.py

@@ -10,6 +10,14 @@ class UnsupportedUFOFormat(UFOLibError):
 
 
 class GlifLibError(UFOLibError):
+    """An error raised by glifLib.
+
+    This class is a loose backport of PEP 678, adding a :attr:`.note`
+    attribute that can hold additional context for errors encountered.
+
+    It will be maintained until only Python 3.11-and-later are supported.
+    """
+
     def _add_note(self, note: str) -> None:
         # Loose backport of PEP 678 until we only support Python 3.11+, used for
         # adding additional context to errors.

fontTools/ufoLib/etree.py

@@ -1,5 +1,5 @@
 """DEPRECATED - This module is kept here only as a backward compatibility shim
-for the old ufoLib.etree module, which was moved to fontTools.misc.etree.
+for the old ufoLib.etree module, which was moved to :mod:`fontTools.misc.etree`.
 Please use the latter instead.
 """