fonttools 4.56.0__py3-none-any.whl → 4.58.0__py3-none-any.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.58.0"
 
 __all__ = ["version", "log", "configLogger"]

fontTools/cffLib/__init__.py

@@ -1464,10 +1464,11 @@ class CharsetConverter(SimpleConverter):
                 if glyphName in allNames:
                     # make up a new glyphName that's unique
                     n = allNames[glyphName]
-                    while (glyphName + "#" + str(n)) in allNames:
+                    names = set(allNames) | set(charset)
+                    while (glyphName + "." + str(n)) in names:
                         n += 1
                     allNames[glyphName] = n + 1
-                    glyphName = glyphName + "#" + str(n)
+                    glyphName = glyphName + "." + str(n)
                 allNames[glyphName] = 1
                 newCharset.append(glyphName)
             charset = newCharset
@@ -1663,25 +1664,26 @@ class EncodingConverter(SimpleConverter):
             return "StandardEncoding"
         elif value == 1:
             return "ExpertEncoding"
+        # custom encoding at offset `value`
+        assert value > 1
+        file = parent.file
+        file.seek(value)
+        log.log(DEBUG, "loading Encoding at %s", value)
+        fmt = readCard8(file)
+        haveSupplement = bool(fmt & 0x80)
+        fmt = fmt & 0x7F
+
+        if fmt == 0:
+            encoding = parseEncoding0(parent.charset, file)
+        elif fmt == 1:
+            encoding = parseEncoding1(parent.charset, file)
         else:
-            assert value > 1
-            file = parent.file
-            file.seek(value)
-            log.log(DEBUG, "loading Encoding at %s", value)
-            fmt = readCard8(file)
-            haveSupplement = fmt & 0x80
-            if haveSupplement:
-                raise NotImplementedError("Encoding supplements are not yet supported")
-            fmt = fmt & 0x7F
-            if fmt == 0:
-                encoding = parseEncoding0(
-                    parent.charset, file, haveSupplement, parent.strings
-                )
-            elif fmt == 1:
-                encoding = parseEncoding1(
-                    parent.charset, file, haveSupplement, parent.strings
-                )
-            return encoding
+            raise ValueError(f"Unknown Encoding format: {fmt}")
+
+        if haveSupplement:
+            parseEncodingSupplement(file, encoding, parent.strings)
+
+        return encoding
 
     def write(self, parent, value):
         if value == "StandardEncoding":
@@ -1719,27 +1721,60 @@ class EncodingConverter(SimpleConverter):
         return encoding
 
 
-def parseEncoding0(charset, file, haveSupplement, strings):
+def readSID(file):
+    """Read a String ID (SID) — 2-byte unsigned integer."""
+    data = file.read(2)
+    if len(data) != 2:
+        raise EOFError("Unexpected end of file while reading SID")
+    return struct.unpack(">H", data)[0]  # big-endian uint16
+
+
+def parseEncodingSupplement(file, encoding, strings):
+    """
+    Parse the CFF Encoding supplement data:
+      - nSups: number of supplementary mappings
+      - each mapping: (code, SID) pair
+    and apply them to the `encoding` list in place.
+    """
+    nSups = readCard8(file)
+    for _ in range(nSups):
+        code = readCard8(file)
+        sid = readSID(file)
+        name = strings[sid]
+        encoding[code] = name
+
+
+def parseEncoding0(charset, file):
+    """
+    Format 0: simple list of codes.
+    After reading the base table, optionally parse the supplement.
+    """
     nCodes = readCard8(file)
     encoding = [".notdef"] * 256
     for glyphID in range(1, nCodes + 1):
         code = readCard8(file)
         if code != 0:
             encoding[code] = charset[glyphID]
+
     return encoding
 
 
-def parseEncoding1(charset, file, haveSupplement, strings):
+def parseEncoding1(charset, file):
+    """
+    Format 1: range-based encoding.
+    After reading the base ranges, optionally parse the supplement.
+    """
     nRanges = readCard8(file)
     encoding = [".notdef"] * 256
     glyphID = 1
-    for i in range(nRanges):
+    for _ in range(nRanges):
         code = readCard8(file)
         nLeft = readCard8(file)
-        for glyphID in range(glyphID, glyphID + nLeft + 1):
+        for _ in range(nLeft + 1):
             encoding[code] = charset[glyphID]
-            code = code + 1
-        glyphID = glyphID + 1
+            code += 1
+            glyphID += 1
+
     return encoding
 
 

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/designspaceLib/statNames.py

@@ -12,14 +12,13 @@ instance:
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Dict, Optional, Tuple, Union
+from typing import Dict, Literal, Optional, Tuple, Union
 import logging
 
 from fontTools.designspaceLib import (
     AxisDescriptor,
     AxisLabelDescriptor,
     DesignSpaceDocument,
-    DesignSpaceDocumentError,
     DiscreteAxisDescriptor,
     SimpleLocationDict,
     SourceDescriptor,
@@ -27,9 +26,13 @@ from fontTools.designspaceLib import (
 
 LOGGER = logging.getLogger(__name__)
 
-# TODO(Python 3.8): use Literal
-# RibbiStyleName = Union[Literal["regular"], Literal["bold"], Literal["italic"], Literal["bold italic"]]
-RibbiStyle = str
+RibbiStyleName = Union[
+    Literal["regular"],
+    Literal["bold"],
+    Literal["italic"],
+    Literal["bold italic"],
+]
+
 BOLD_ITALIC_TO_RIBBI_STYLE = {
     (False, False): "regular",
     (False, True): "italic",
@@ -46,7 +49,7 @@ class StatNames:
     styleNames: Dict[str, str]
     postScriptFontName: Optional[str]
     styleMapFamilyNames: Dict[str, str]
-    styleMapStyleName: Optional[RibbiStyle]
+    styleMapStyleName: Optional[RibbiStyleName]
 
 
 def getStatNames(
@@ -61,6 +64,10 @@ def getStatNames(
     localized names will be empty (family and style names), or the name will be
     None (PostScript name).
 
+    Note: this method does not consider info attached to the instance, like
+    family name. The user needs to override all names on an instance that STAT
+    information would compute differently than desired.
+
     .. versionadded:: 5.0
     """
     familyNames: Dict[str, str] = {}
@@ -201,7 +208,7 @@ def _getAxisLabelsForUserLocation(
 
 def _getRibbiStyle(
     self: DesignSpaceDocument, userLocation: SimpleLocationDict
-) -> Tuple[RibbiStyle, SimpleLocationDict]:
+) -> Tuple[RibbiStyleName, SimpleLocationDict]:
     """Compute the RIBBI style name of the given user location,
     return the location of the matching Regular in the RIBBI group.
 

fontTools/feaLib/ast.py

@@ -337,6 +337,76 @@ class AnonymousBlock(Statement):
         return res
 
 
+def _upgrade_mixed_subst_statements(statements):
+    # https://github.com/fonttools/fonttools/issues/612
+    # A multiple substitution may have a single destination, in which case
+    # it will look just like a single substitution. So if there are both
+    # multiple and single substitutions, upgrade all the single ones to
+    # multiple substitutions. Similarly, a ligature substitution may have a
+    # single source glyph, so if there are both ligature and single
+    # substitutions, upgrade all the single ones to ligature substitutions.
+
+    has_single = False
+    has_multiple = False
+    has_ligature = False
+    for s in statements:
+        if isinstance(s, SingleSubstStatement):
+            has_single = not any([s.prefix, s.suffix, s.forceChain])
+        elif isinstance(s, MultipleSubstStatement):
+            has_multiple = not any([s.prefix, s.suffix, s.forceChain])
+        elif isinstance(s, LigatureSubstStatement):
+            has_ligature = not any([s.prefix, s.suffix, s.forceChain])
+
+    to_multiple = False
+    to_ligature = False
+
+    # If we have mixed single and multiple substitutions,
+    # upgrade all single substitutions to multiple substitutions.
+    if has_single and has_multiple and not has_ligature:
+        to_multiple = True
+
+    # If we have mixed single and ligature substitutions,
+    # upgrade all single substitutions to ligature substitutions.
+    elif has_single and has_ligature and not has_multiple:
+        to_ligature = True
+
+    if to_multiple or to_ligature:
+        ret = []
+        for s in statements:
+            if isinstance(s, SingleSubstStatement):
+                glyphs = s.glyphs[0].glyphSet()
+                replacements = s.replacements[0].glyphSet()
+                if len(replacements) == 1:
+                    replacements *= len(glyphs)
+                for glyph, replacement in zip(glyphs, replacements):
+                    if to_multiple:
+                        ret.append(
+                            MultipleSubstStatement(
+                                s.prefix,
+                                glyph,
+                                s.suffix,
+                                [replacement],
+                                s.forceChain,
+                                location=s.location,
+                            )
+                        )
+                    elif to_ligature:
+                        ret.append(
+                            LigatureSubstStatement(
+                                s.prefix,
+                                [GlyphName(glyph)],
+                                s.suffix,
+                                replacement,
+                                s.forceChain,
+                                location=s.location,
+                            )
+                        )
+            else:
+                ret.append(s)
+        return ret
+    return statements
+
+
 class Block(Statement):
     """A block of statements: feature, lookup, etc."""
 
@@ -348,7 +418,8 @@ class Block(Statement):
         """When handed a 'builder' object of comparable interface to
         :class:`fontTools.feaLib.builder`, walks the statements in this
         block, calling the builder callbacks."""
-        for s in self.statements:
+        statements = _upgrade_mixed_subst_statements(self.statements)
+        for s in statements:
             s.build(builder)
 
     def asFea(self, indent=""):
@@ -382,8 +453,7 @@ class FeatureBlock(Block):
     def build(self, builder):
         """Call the ``start_feature`` callback on the builder object, visit
         all the statements in this feature, and then call ``end_feature``."""
-        # TODO(sascha): Handle use_extension.
-        builder.start_feature(self.location, self.name)
+        builder.start_feature(self.location, self.name, self.use_extension)
         # language exclude_dflt statements modify builder.features_
         # limit them to this block with temporary builder.features_
         features = builder.features_
@@ -433,8 +503,7 @@ class LookupBlock(Block):
         self.name, self.use_extension = name, use_extension
 
     def build(self, builder):
-        # TODO(sascha): Handle use_extension.
-        builder.start_lookup_block(self.location, self.name)
+        builder.start_lookup_block(self.location, self.name, self.use_extension)
         Block.build(self, builder)
         builder.end_lookup_block()
 
@@ -753,7 +822,7 @@ class ChainContextPosStatement(Statement):
             if len(self.suffix):
                 res += " " + " ".join(map(asFea, self.suffix))
         else:
-            res += " ".join(map(asFea, self.glyph))
+            res += " ".join(map(asFea, self.glyphs))
         res += ";"
         return res
 
@@ -811,7 +880,7 @@ class ChainContextSubstStatement(Statement):
             if len(self.suffix):
                 res += " " + " ".join(map(asFea, self.suffix))
         else:
-            res += " ".join(map(asFea, self.glyph))
+            res += " ".join(map(asFea, self.glyphs))
         res += ";"
         return res
 
@@ -1512,7 +1581,9 @@ class SinglePosStatement(Statement):
                 res += " ".join(map(asFea, self.prefix)) + " "
             res += " ".join(
                 [
-                    asFea(x[0]) + "'" + ((" " + x[1].asFea()) if x[1] else "")
+                    asFea(x[0])
+                    + "'"
+                    + ((" " + x[1].asFea()) if x[1] is not None else "")
                     for x in self.pos
                 ]
             )
@@ -1520,7 +1591,10 @@ class SinglePosStatement(Statement):
                 res += " " + " ".join(map(asFea, self.suffix))
         else:
             res += " ".join(
-                [asFea(x[0]) + " " + (x[1].asFea() if x[1] else "") for x in self.pos]
+                [
+                    asFea(x[0]) + " " + (x[1].asFea() if x[1] is not None else "")
+                    for x in self.pos
+                ]
             )
         res += ";"
         return res
@@ -1828,15 +1902,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 +1919,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):
@@ -2098,7 +2177,7 @@ class VariationBlock(Block):
     def build(self, builder):
         """Call the ``start_feature`` callback on the builder object, visit
         all the statements in this feature, and then call ``end_feature``."""
-        builder.start_feature(self.location, self.name)
+        builder.start_feature(self.location, self.name, self.use_extension)
         if (
             self.conditionset != "NULL"
             and self.conditionset not in builder.conditionsets_

fontTools/feaLib/builder.py

@@ -126,6 +126,7 @@ class Builder(object):
         self.script_ = None
         self.lookupflag_ = 0
         self.lookupflag_markFilterSet_ = None
+        self.use_extension_ = False
         self.language_systems = set()
         self.seen_non_DFLT_script_ = False
         self.named_lookups_ = {}
@@ -141,6 +142,7 @@ class Builder(object):
         self.aalt_features_ = []  # [(location, featureName)*], for 'aalt'
         self.aalt_location_ = None
         self.aalt_alternates_ = {}
+        self.aalt_use_extension_ = False
         # for 'featureNames'
         self.featureNames_ = set()
         self.featureNames_ids_ = {}
@@ -247,6 +249,7 @@ class Builder(object):
         result = builder_class(self.font, location)
         result.lookupflag = self.lookupflag_
         result.markFilterSet = self.lookupflag_markFilterSet_
+        result.extension = self.use_extension_
         self.lookups_.append(result)
         return result
 
@@ -272,6 +275,7 @@ class Builder(object):
         self.cur_lookup_ = builder_class(self.font, location)
         self.cur_lookup_.lookupflag = self.lookupflag_
         self.cur_lookup_.markFilterSet = self.lookupflag_markFilterSet_
+        self.cur_lookup_.extension = self.use_extension_
         self.lookups_.append(self.cur_lookup_)
         if self.cur_lookup_name_:
             # We are starting a lookup rule inside a named lookup block.
@@ -323,7 +327,7 @@ class Builder(object):
         }
         old_lookups = self.lookups_
         self.lookups_ = []
-        self.start_feature(self.aalt_location_, "aalt")
+        self.start_feature(self.aalt_location_, "aalt", self.aalt_use_extension_)
         if single:
             single_lookup = self.get_lookup_(location, SingleSubstBuilder)
             single_lookup.mapping = single
@@ -341,6 +345,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 +732,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 +750,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
 
@@ -1031,15 +1058,22 @@ class Builder(object):
         else:
             return frozenset({("DFLT", "dflt")})
 
-    def start_feature(self, location, name):
+    def start_feature(self, location, name, use_extension=False):
+        if use_extension and name != "aalt":
+            raise FeatureLibError(
+                "'useExtension' keyword for feature blocks is allowed only for 'aalt' feature",
+                location,
+            )
         self.language_systems = self.get_default_language_systems_()
         self.script_ = "DFLT"
         self.cur_lookup_ = None
         self.cur_feature_name_ = name
         self.lookupflag_ = 0
         self.lookupflag_markFilterSet_ = None
+        self.use_extension_ = use_extension
         if name == "aalt":
             self.aalt_location_ = location
+            self.aalt_use_extension_ = use_extension
 
     def end_feature(self):
         assert self.cur_feature_name_ is not None
@@ -1048,8 +1082,9 @@ class Builder(object):
         self.cur_lookup_ = None
         self.lookupflag_ = 0
         self.lookupflag_markFilterSet_ = None
+        self.use_extension_ = False
 
-    def start_lookup_block(self, location, name):
+    def start_lookup_block(self, location, name, use_extension=False):
         if name in self.named_lookups_:
             raise FeatureLibError(
                 'Lookup "%s" has already been defined' % name, location
@@ -1063,6 +1098,7 @@ class Builder(object):
         self.cur_lookup_name_ = name
         self.named_lookups_[name] = None
         self.cur_lookup_ = None
+        self.use_extension_ = use_extension
         if self.cur_feature_name_ is None:
             self.lookupflag_ = 0
             self.lookupflag_markFilterSet_ = None
@@ -1071,6 +1107,7 @@ class Builder(object):
         assert self.cur_lookup_name_ is not None
         self.cur_lookup_name_ = None
         self.cur_lookup_ = None
+        self.use_extension_ = False
         if self.cur_feature_name_ is None:
             self.lookupflag_ = 0
             self.lookupflag_markFilterSet_ = None
@@ -1235,11 +1272,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
@@ -1448,7 +1485,9 @@ class Builder(object):
         lookup = self.get_lookup_(location, PairPosBuilder)
         v1 = self.makeOpenTypeValueRecord(location, value1, pairPosContext=True)
         v2 = self.makeOpenTypeValueRecord(location, value2, pairPosContext=True)
-        lookup.addClassPair(location, glyphclass1, v1, glyphclass2, v2)
+        cls1 = tuple(sorted(set(glyphclass1)))
+        cls2 = tuple(sorted(set(glyphclass2)))
+        lookup.addClassPair(location, cls1, v1, cls2, v2)
 
     def add_specific_pair_pos(self, location, glyph1, value1, glyph2, value2):
         if not glyph1 or not glyph2: