fonttools 4.56.0__cp38-cp38-win_amd64.whl → 4.57.0__cp38-cp38-win_amd64.whl

fontTools/__init__.py

@@ -3,6 +3,6 @@ from fontTools.misc.loggingTools import configLogger
 
 log = logging.getLogger(__name__)
 
-version = __version__ = "4.56.0"
+version = __version__ = "4.57.0"
 
 __all__ = ["version", "log", "configLogger"]

fontTools/config/__init__.py

@@ -73,3 +73,18 @@ Config.register_option(
     parse=Option.parse_optional_bool,
     validate=Option.validate_optional_bool,
 )
+
+Config.register_option(
+    name="fontTools.ttLib:OPTIMIZE_FONT_SPEED",
+    help=dedent(
+        """\
+        Enable optimizations that prioritize speed over file size. This
+        mainly affects how glyf table 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.
+        """
+    ),
+    default=False,
+    parse=Option.parse_optional_bool,
+    validate=Option.validate_optional_bool,
+)

fontTools/feaLib/ast.py

@@ -1828,15 +1828,16 @@ class BaseAxis(Statement):
     """An axis definition, being either a ``VertAxis.BaseTagList/BaseScriptList``
     pair or a ``HorizAxis.BaseTagList/BaseScriptList`` pair."""
 
-    def __init__(self, bases, scripts, vertical, location=None):
+    def __init__(self, bases, scripts, vertical, minmax=None, location=None):
         Statement.__init__(self, location)
         self.bases = bases  #: A list of baseline tag names as strings
         self.scripts = scripts  #: A list of script record tuplets (script tag, default baseline tag, base coordinate)
         self.vertical = vertical  #: Boolean; VertAxis if True, HorizAxis if False
+        self.minmax = []  #: A set of minmax record
 
     def build(self, builder):
         """Calls the builder object's ``set_base_axis`` callback."""
-        builder.set_base_axis(self.bases, self.scripts, self.vertical)
+        builder.set_base_axis(self.bases, self.scripts, self.vertical, self.minmax)
 
     def asFea(self, indent=""):
         direction = "Vert" if self.vertical else "Horiz"
@@ -1844,9 +1845,13 @@ class BaseAxis(Statement):
             "{} {} {}".format(a[0], a[1], " ".join(map(str, a[2])))
             for a in self.scripts
         ]
+        minmaxes = [
+            "\n{}Axis.MinMax {} {} {}, {};".format(direction, a[0], a[1], a[2], a[3])
+            for a in self.minmax
+        ]
         return "{}Axis.BaseTagList {};\n{}{}Axis.BaseScriptList {};".format(
             direction, " ".join(self.bases), indent, direction, ", ".join(scripts)
-        )
+        ) + "\n".join(minmaxes)
 
 
 class OS2Field(Statement):

fontTools/feaLib/builder.py

@@ -341,6 +341,7 @@ class Builder(object):
             table = self.font["head"] = newTable("head")
             table.decompile(b"\0" * 54, self.font)
             table.tableVersion = 1.0
+            table.magicNumber = 0x5F0F3CF5
             table.created = table.modified = 3406620153  # 2011-12-13 11:22:33
         table.fontRevision = self.fontRevision_
 
@@ -727,10 +728,16 @@ class Builder(object):
         result.table = base
         return result
 
+    def buildBASECoord(self, c):
+        coord = otTables.BaseCoord()
+        coord.Format = 1
+        coord.Coordinate = c
+        return coord
+
     def buildBASEAxis(self, axis):
         if not axis:
             return
-        bases, scripts = axis
+        bases, scripts, minmax = axis
         axis = otTables.Axis()
         axis.BaseTagList = otTables.BaseTagList()
         axis.BaseTagList.BaselineTag = bases
@@ -739,19 +746,35 @@ class Builder(object):
         axis.BaseScriptList.BaseScriptRecord = []
         axis.BaseScriptList.BaseScriptCount = len(scripts)
         for script in sorted(scripts):
+            minmax_for_script = [
+                record[1:] for record in minmax if record[0] == script[0]
+            ]
             record = otTables.BaseScriptRecord()
             record.BaseScriptTag = script[0]
             record.BaseScript = otTables.BaseScript()
-            record.BaseScript.BaseLangSysCount = 0
             record.BaseScript.BaseValues = otTables.BaseValues()
             record.BaseScript.BaseValues.DefaultIndex = bases.index(script[1])
             record.BaseScript.BaseValues.BaseCoord = []
             record.BaseScript.BaseValues.BaseCoordCount = len(script[2])
+            record.BaseScript.BaseLangSysRecord = []
+
             for c in script[2]:
-                coord = otTables.BaseCoord()
-                coord.Format = 1
-                coord.Coordinate = c
-                record.BaseScript.BaseValues.BaseCoord.append(coord)
+                record.BaseScript.BaseValues.BaseCoord.append(self.buildBASECoord(c))
+            for language, min_coord, max_coord in minmax_for_script:
+                minmax_record = otTables.MinMax()
+                minmax_record.MinCoord = self.buildBASECoord(min_coord)
+                minmax_record.MaxCoord = self.buildBASECoord(max_coord)
+                minmax_record.FeatMinMaxCount = 0
+                if language == "dflt":
+                    record.BaseScript.DefaultMinMax = minmax_record
+                else:
+                    lang_record = otTables.BaseLangSysRecord()
+                    lang_record.BaseLangSysTag = language
+                    lang_record.MinMax = minmax_record
+                    record.BaseScript.BaseLangSysRecord.append(lang_record)
+            record.BaseScript.BaseLangSysCount = len(
+                record.BaseScript.BaseLangSysRecord
+            )
             axis.BaseScriptList.BaseScriptRecord.append(record)
         return axis
 
@@ -1235,11 +1258,11 @@ class Builder(object):
     def add_cv_character(self, character, tag):
         self.cv_characters_[tag].append(character)
 
-    def set_base_axis(self, bases, scripts, vertical):
+    def set_base_axis(self, bases, scripts, vertical, minmax=[]):
         if vertical:
-            self.base_vert_axis_ = (bases, scripts)
+            self.base_vert_axis_ = (bases, scripts, minmax)
         else:
-            self.base_horiz_axis_ = (bases, scripts)
+            self.base_horiz_axis_ = (bases, scripts, minmax)
 
     def set_size_parameters(
         self, location, DesignSize, SubfamilyID, RangeStart, RangeEnd

fontTools/feaLib/parser.py

@@ -1286,6 +1286,19 @@ class Parser(object):
         n = match.group(0)[1:]
         return bytechr(int(n, 16)).decode(encoding)
 
+    def find_previous(self, statements, class_):
+        for previous in reversed(statements):
+            if isinstance(previous, self.ast.Comment):
+                continue
+            elif isinstance(previous, class_):
+                return previous
+            else:
+                # If we find something that doesn't match what we're looking
+                # for, and isn't a comment, fail
+                return None
+        # Out of statements to look at
+        return None
+
     def parse_table_BASE_(self, table):
         statements = table.statements
         while self.next_token_ != "}" or self.cur_comments_:
@@ -1306,6 +1319,19 @@ class Parser(object):
                         location=self.cur_token_location_,
                     )
                 )
+            elif self.is_cur_keyword_("HorizAxis.MinMax"):
+                base_script_list = self.find_previous(statements, ast.BaseAxis)
+                if base_script_list is None:
+                    raise FeatureLibError(
+                        "MinMax must be preceded by BaseScriptList",
+                        self.cur_token_location_,
+                    )
+                if base_script_list.vertical:
+                    raise FeatureLibError(
+                        "HorizAxis.MinMax must be preceded by HorizAxis statements",
+                        self.cur_token_location_,
+                    )
+                base_script_list.minmax.append(self.parse_base_minmax_())
             elif self.is_cur_keyword_("VertAxis.BaseTagList"):
                 vert_bases = self.parse_base_tag_list_()
             elif self.is_cur_keyword_("VertAxis.BaseScriptList"):
@@ -1318,6 +1344,19 @@ class Parser(object):
                         location=self.cur_token_location_,
                     )
                 )
+            elif self.is_cur_keyword_("VertAxis.MinMax"):
+                base_script_list = self.find_previous(statements, ast.BaseAxis)
+                if base_script_list is None:
+                    raise FeatureLibError(
+                        "MinMax must be preceded by BaseScriptList",
+                        self.cur_token_location_,
+                    )
+                if not base_script_list.vertical:
+                    raise FeatureLibError(
+                        "VertAxis.MinMax must be preceded by VertAxis statements",
+                        self.cur_token_location_,
+                    )
+                base_script_list.minmax.append(self.parse_base_minmax_())
             elif self.cur_token_ == ";":
                 continue
 
@@ -1587,6 +1626,25 @@ class Parser(object):
         coords = [self.expect_number_() for i in range(count)]
         return script_tag, base_tag, coords
 
+    def parse_base_minmax_(self):
+        script_tag = self.expect_script_tag_()
+        language = self.expect_language_tag_()
+        min_coord = self.expect_number_()
+        self.advance_lexer_()
+        if not (self.cur_token_type_ is Lexer.SYMBOL and self.cur_token_ == ","):
+            raise FeatureLibError(
+                "Expected a comma between min and max coordinates",
+                self.cur_token_location_,
+            )
+        max_coord = self.expect_number_()
+        if self.next_token_ == ",":  # feature tag...
+            raise FeatureLibError(
+                "Feature tags are not yet supported in BASE table",
+                self.cur_token_location_,
+            )
+
+        return script_tag, language, min_coord, max_coord
+
     def parse_device_(self):
         result = None
         self.expect_symbol_("<")

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/otlLib/optimize/gpos.py

@@ -53,12 +53,18 @@ def compact(font: TTFont, level: int) -> TTFont:
     #     are not grouped together first; instead each subtable is treated
     #     independently, so currently this step is:
     #     Split existing subtables into more smaller subtables
-    gpos = font["GPOS"]
+    gpos = font.get("GPOS")
+
+    # If the font does not contain a GPOS table, there is nothing to do.
+    if gpos is None:
+        return font
+
     for lookup in gpos.table.LookupList.Lookup:
         if lookup.LookupType == 2:
             compact_lookup(font, level, lookup)
         elif lookup.LookupType == 9 and lookup.SubTable[0].ExtensionLookupType == 2:
             compact_ext_lookup(font, level, lookup)
+
     return font
 
 

fontTools/ttLib/__init__.py

@@ -1,5 +1,6 @@
 """fontTools.ttLib -- a package for dealing with TrueType fonts."""
 
+from fontTools.config import OPTIONS
 from fontTools.misc.loggingTools import deprecateFunction
 import logging
 
@@ -7,6 +8,9 @@ import logging
 log = logging.getLogger(__name__)
 
 
+OPTIMIZE_FONT_SPEED = OPTIONS["fontTools.ttLib:OPTIMIZE_FONT_SPEED"]
+
+
 class TTLibError(Exception):
     pass
 

fontTools/ttLib/__main__.py

@@ -1,5 +1,5 @@
 import sys
-from fontTools.ttLib import TTLibError, TTLibFileIsCollectionError
+from fontTools.ttLib import OPTIMIZE_FONT_SPEED, TTLibError, TTLibFileIsCollectionError
 from fontTools.ttLib.ttFont import *
 from fontTools.ttLib.ttCollection import TTCollection
 
@@ -51,7 +51,7 @@ def main(args=None):
     )
     parser.add_argument("font", metavar="font", nargs="*", help="Font file.")
     parser.add_argument(
-        "-t", "--table", metavar="table", nargs="*", help="Tables to decompile."
+        "-t", "--table", metavar="table", action="append", help="Tables to decompile."
     )
     parser.add_argument(
         "-o", "--output", metavar="FILE", default=None, help="Output file."
@@ -71,27 +71,66 @@ def main(args=None):
         default=None,
         help="Flavor of output font. 'woff' or 'woff2'.",
     )
+    parser.add_argument(
+        "--no-recalc-timestamp",
+        dest="recalcTimestamp",
+        action="store_false",
+        help="Keep the original font 'modified' timestamp.",
+    )
+    parser.add_argument(
+        "-b",
+        dest="recalcBBoxes",
+        action="store_false",
+        help="Don't recalc glyph bounding boxes: use the values in the original font.",
+    )
+    parser.add_argument(
+        "--optimize-font-speed",
+        action="store_true",
+        help=(
+            "Enable optimizations that prioritize speed over file size. This "
+            "mainly affects how glyf table and gvar / VARC tables are compiled."
+        ),
+    )
     options = parser.parse_args(args)
 
     fontNumber = int(options.y) if options.y is not None else None
     outFile = options.output
     lazy = options.lazy
     flavor = options.flavor
-    tables = options.table if options.table is not None else ["*"]
+    tables = options.table
+    recalcBBoxes = options.recalcBBoxes
+    recalcTimestamp = options.recalcTimestamp
+    optimizeFontSpeed = options.optimize_font_speed
 
     fonts = []
     for f in options.font:
         try:
-            font = TTFont(f, fontNumber=fontNumber, lazy=lazy)
+            font = TTFont(
+                f,
+                recalcBBoxes=recalcBBoxes,
+                recalcTimestamp=recalcTimestamp,
+                fontNumber=fontNumber,
+                lazy=lazy,
+            )
+            if optimizeFontSpeed:
+                font.cfg[OPTIMIZE_FONT_SPEED] = optimizeFontSpeed
             fonts.append(font)
         except TTLibFileIsCollectionError:
             collection = TTCollection(f, lazy=lazy)
             fonts.extend(collection.fonts)
 
-    if lazy is False:
-        for font in fonts:
-            for table in tables if "*" not in tables else font.keys():
-                font[table]  # Decompiles
+    if tables is None:
+        if lazy is False:
+            tables = ["*"]
+        elif optimizeFontSpeed:
+            tables = {"glyf", "gvar", "VARC"}.intersection(font.keys())
+        else:
+            tables = []
+    for font in fonts:
+        if "GlyphOrder" in tables:
+            font.getGlyphOrder()
+        for table in tables if "*" not in tables else font.keys():
+            font[table]  # Decompiles
 
     if outFile is not None:
         if len(fonts) == 1:

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/_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)
@@ -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/_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
 

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
@@ -57,6 +58,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())
@@ -91,9 +93,9 @@ class table__g_v_a_r(DefaultTable.DefaultTable):
         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:
@@ -106,7 +108,7 @@ class table__g_v_a_r(DefaultTable.DefaultTable):
                     pointCountUnused,
                     axisTags,
                     sharedCoordIndices,
-                    optimizeSize=optimizeSize,
+                    optimizeSize=not optimizeSpeed,
                 )
             )
         return result

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 "