Support new AFDKO variable layout syntax

Doc/source/ttx.rst

@@ -35,14 +35,14 @@ The TTX file format
 
 The following tables are currently supported::
 
-    BASE, CBDT, CBLC, CFF, CFF2, COLR, CPAL, DSIG, EBDT, EBLC, FFTM,
-    Feat, GDEF, GMAP, GPKG, GPOS, GSUB, Glat, Gloc, HVAR, JSTF, LTSH,
-    MATH, META, MVAR, OS/2, SING, STAT, SVG, Silf, Sill, TSI0, TSI1,
-    TSI2, TSI3, TSI5, TSIB, TSIC, TSID, TSIJ, TSIP, TSIS, TSIV, TTFA,
-    VDMX, VORG, VVAR, ankr, avar, bsln, cidg, cmap, cvar, cvt, feat,
-    fpgm, fvar, gasp, gcid, glyf, gvar, hdmx, head, hhea, hmtx, kern,
-    lcar, loca, ltag, maxp, meta, mort, morx, name, opbd, post, prep,
-    prop, sbix, trak, vhea and vmtx
+    BASE, CBDT, CBLC, CFF, CFF2, COLR, CPAL, DSIG, Debg, EBDT, EBLC,
+    FFTM, Feat, GDEF, GMAP, GPKG, GPOS, GSUB, Glat, Gloc, HVAR, JSTF,
+    LTSH, MATH, META, MVAR, OS/2, SING, STAT, SVG, Silf, Sill, TSI0,
+    TSI1, TSI2, TSI3, TSI5, TSIB, TSIC, TSID, TSIJ, TSIP, TSIS, TSIV,
+    TTFA, VDMX, VORG, VVAR, ankr, avar, bsln, cidg, cmap, cvar, cvt,
+    feat, fpgm, fvar, gasp, gcid, glyf, gvar, hdmx, head, hhea, hmtx,
+    kern, lcar, loca, ltag, maxp, meta, mort, morx, name, opbd, post,
+    prep, prop, sbix, trak, vhea and vmtx
 
 .. end table list
 

Doc/source/varLib/index.rst

@@ -1,6 +1,94 @@
-######
-varLib
-######
+##################################
+varLib: OpenType Variation Support
+##################################
+
+The ``fontTools.varLib`` package contains a number of classes and routines
+for handling, building and interpolating variable font data. These routines
+rely on a common set of concepts, many of which are equivalent to concepts
+in the OpenType Specification, but some of which are unique to ``varLib``.
+
+Terminology
+-----------
+
+axis
+   "A designer-determined variable in a font face design that can be used to
+   derive multiple, variant designs within a family." (OpenType Specification)
+   An axis has a minimum value, a maximum value and a default value.
+
+designspace
+   The n-dimensional space formed by the font's axes. (OpenType Specification
+   calls this the "design-variation space")
+
+scalar
+   A value which is able to be varied at different points in the designspace:
+   for example, the horizontal advance width of the glyph "a" is a scalar.
+   However, see also *support scalar* below.
+
+default location
+   A point in the designspace whose coordinates are the default value of
+   all axes.
+
+location
+   A point in the designspace, specified as a set of coordinates on one or
+   more axes. In the context of ``varLib``, a location is a dictionary with
+   the keys being the axis tags and the values being the coordinates on the
+   respective axis. A ``varLib`` location dictionary may be "sparse", in the
+   sense that axes defined in the font may be omitted from the location's
+   coordinates, in which case the default value of the axis is assumed.
+   For example, given a font having a ``wght`` axis ranging from 200-1000
+   with default 400, and a ``wdth`` axis ranging 100-300 with default 150,
+   the location ``{"wdth": 200}`` represents the point ``wght=400,wdth=200``.
+
+master
+   The value of a scalar at a given location. **Note that this is a
+   considerably more general concept than the usual type design sense of
+   the term "master".**
+
+normalized location
+   While the range of an axis is determined by its minimum and maximum values
+   as set by the designer, locations are specified internally to the font binary
+   in the range -1 to 1, with 0 being the default, -1 being the minimum and
+   1 being the maximum. A normalized location is one which is scaled to the
+   range (-1,1) on all of its axes. Note that as the range from minimum to
+   default and from default to maximum on a given axis may differ (for
+   example, given ``wght min=200 default=500 max=1000``, the difference
+   between a normalized location -1 of a normalized location of 0 represents a
+   difference of 300 units while the difference between a normalized location
+   of 0 and a normalized location of 1 represents a difference of 700 units),
+   a location is scaled by a different factor depending on whether it is above
+   or below the axis' default value.
+
+support
+   While designers tend to think in terms of masters - that is, a precise
+   location having a particular value - OpenType Variations specifies the
+   variation of scalars in terms of deltas which are themselves composed of
+   the combined contributions of a set of triangular regions, each having
+   a contribution value of 0 at its minimum value, rising linearly to its
+   full contribution at the *peak* and falling linearly to zero from the
+   peak to the maximum value. The OpenType Specification calls these "regions",
+   while ``varLib`` calls them "supports" (a mathematical term used in real
+   analysis) and expresses them as a dictionary mapping each axis tag to a
+   tuple ``(min, peak, max)``.
+
+box
+   ``varLib`` uses the term "box" to denote the minimum and maximum "corners" of
+   a support, ignoring its peak value.
+
+delta
+   The term "delta" is used in OpenType Variations in two senses. In the
+   more general sense, a delta is the difference between a scalar at a
+   given location and its value at the default location. Additionally, inside
+   the font, variation data is stored as a mapping between supports and deltas.
+   The delta (in the first sense) is computed by summing the product of the
+   delta of each support by a factor representing the support's contribution
+   at this location (see "support scalar" below).
+
+support scalar
+   When interpolating a set of variation data, the support scalar represents
+   the scalar multiplier of the support's contribution at this location. For
+   example, the support scalar will be 1 at the support's peak location, and
+   0 below its minimum or above its maximum.
+
 
 .. toctree::
    :maxdepth: 2

Lib/fontTools/__init__.py

@@ -1,9 +1,8 @@
-from fontTools.misc.py23 import *
 import logging
 from fontTools.misc.loggingTools import configLogger
 
 log = logging.getLogger(__name__)
 
-version = __version__ = "4.21.2.dev0"
+version = __version__ = "4.24.4.dev0"
 
 __all__ = ["version", "log", "configLogger"]

Lib/fontTools/afmLib.py

@@ -46,7 +46,6 @@
 """
 
 
-from fontTools.misc.py23 import *
 import re
 
 # every single line starts with a "word"

Lib/fontTools/agl.py

@@ -26,7 +26,7 @@
 doesn't include any (e.g. format 3.0 post tables).
 """
 
-from fontTools.misc.py23 import *
+from fontTools.misc.py23 import tostr
 import re
 
 
@@ -5140,7 +5140,7 @@ def _glyphComponentToUnicode(component, isZapfDingbats):
 	# to the corresponding character in that list.
 	uchars = LEGACY_AGL2UV.get(component)
 	if uchars:
-		return "".join(map(unichr, uchars))
+		return "".join(map(chr, uchars))
 
 	# Otherwise, if the component is of the form "uni" (U+0075,
 	# U+006E, and U+0069) followed by a sequence of uppercase
@@ -5210,7 +5210,7 @@ def _uniToUnicode(component):
 	if any(c >= 0xD800 and c <= 0xDFFF for c in chars):
 		# The AGL specification explicitly excluded surrogate pairs.
 		return None
-	return ''.join([unichr(c) for c in chars])
+	return ''.join([chr(c) for c in chars])
 
 
 _re_u = re.compile("^u([0-9A-F]{4,6})$")
@@ -5228,5 +5228,5 @@ def _uToUnicode(component):
 		return None
 	if ((value >= 0x0000 and value <= 0xD7FF) or
 	    (value >= 0xE000 and value <= 0x10FFFF)):
-		return unichr(value)
+		return chr(value)
 	return None

Lib/fontTools/cffLib/__init__.py

@@ -11,7 +11,7 @@
 
 """
 
-from fontTools.misc.py23 import *
+from fontTools.misc.py23 import bytechr, byteord, bytesjoin, tobytes, tostr
 from fontTools.misc import sstruct
 from fontTools.misc import psCharStrings
 from fontTools.misc.arrayTools import unionRect, intRect
@@ -20,6 +20,7 @@
 from fontTools.ttLib.tables.otBase import OTTableWriter
 from fontTools.ttLib.tables.otBase import OTTableReader
 from fontTools.ttLib.tables import otTables as ot
+from io import BytesIO
 import struct
 import logging
 import re
@@ -118,7 +119,7 @@ def __getitem__(self, nameOrIndex):
 		"""
 		if hasattr(nameOrIndex, "__index__"):
 			index = nameOrIndex.__index__()
-		elif isinstance(nameOrIndex, basestring):
+		elif isinstance(nameOrIndex, str):
 			name = nameOrIndex
 			try:
 				index = self.fontNames.index(name)
@@ -261,7 +262,7 @@ def fromXML(self, name, attrs, content, otFont=None):
 				self.topDictIndex = TopDictIndex(None, cff2GetGlyphOrder, None)
 			self.topDictIndex.append(topDict)
 			for element in content:
-				if isinstance(element, basestring):
+				if isinstance(element, str):
 					continue
 				name, attrs, content = element
 				topDict.fromXML(name, attrs, content)
@@ -277,7 +278,7 @@ def fromXML(self, name, attrs, content, otFont=None):
 			if not hasattr(self, "GlobalSubrs"):
 				self.GlobalSubrs = GlobalSubrsIndex()
 			for element in content:
-				if isinstance(element, basestring):
+				if isinstance(element, str):
 					continue
 				name, attrs, content = element
 				subr = subrCharStringClass()
@@ -879,7 +880,7 @@ def fromXML(self, name, attrs, content):
 			return
 		fontDict = FontDict()
 		for element in content:
-			if isinstance(element, basestring):
+			if isinstance(element, str):
 				continue
 			name, attrs, content = element
 			fontDict.fromXML(name, attrs, content)
@@ -1106,7 +1107,7 @@ def toXML(self, xmlWriter):
 
 	def fromXML(self, name, attrs, content):
 		for element in content:
-			if isinstance(element, basestring):
+			if isinstance(element, str):
 				continue
 			name, attrs, content = element
 			if name != "CharString":
@@ -1245,7 +1246,7 @@ def write(self, parent, value):
 		return tobytes(value, encoding='ascii')
 
 	def xmlWrite(self, xmlWriter, name, value):
-		xmlWriter.simpletag(name, value=tounicode(value, encoding="ascii"))
+		xmlWriter.simpletag(name, value=tostr(value, encoding="ascii"))
 		xmlWriter.newline()
 
 	def xmlRead(self, name, attrs, content, parent):
@@ -1261,7 +1262,7 @@ def write(self, parent, value):
 		return tobytes(value, encoding='latin1')
 
 	def xmlWrite(self, xmlWriter, name, value):
-		value = tounicode(value, encoding="latin1")
+		value = tostr(value, encoding="latin1")
 		if name in ['Notice', 'Copyright']:
 			value = re.sub(r"[\r\n]\s+", " ", value)
 		xmlWriter.simpletag(name, value=value)
@@ -1282,7 +1283,7 @@ def parseNum(s):
 def parseBlendList(s):
 	valueList = []
 	for element in s:
-		if isinstance(element, basestring):
+		if isinstance(element, str):
 			continue
 		name, attrs, content = element
 		blendList = attrs["value"].split()
@@ -1358,7 +1359,7 @@ def xmlWrite(self, xmlWriter, name, value):
 	def xmlRead(self, name, attrs, content, parent):
 		ob = self.getClass()()
 		for element in content:
-			if isinstance(element, basestring):
+			if isinstance(element, str):
 				continue
 			name, attrs, content = element
 			ob.fromXML(name, attrs, content)
@@ -1650,7 +1651,7 @@ def parseCharset(numGlyphs, file, strings, isCID, fmt):
 class EncodingCompiler(object):
 
 	def __init__(self, strings, encoding, parent):
-		assert not isinstance(encoding, basestring)
+		assert not isinstance(encoding, str)
 		data0 = packEncoding0(parent.dictObj.charset, encoding, parent.strings)
 		data1 = packEncoding1(parent.dictObj.charset, encoding, parent.strings)
 		if len(data0) < len(data1):
@@ -1721,7 +1722,7 @@ def xmlRead(self, name, attrs, content, parent):
 			return attrs["name"]
 		encoding = [".notdef"] * 256
 		for element in content:
-			if isinstance(element, basestring):
+			if isinstance(element, str):
 				continue
 			name, attrs, content = element
 			code = safeEval(attrs["code"])
@@ -1833,7 +1834,7 @@ def write(self, parent, value):
 	def xmlRead(self, name, attrs, content, parent):
 		fdArray = FDArrayIndex()
 		for element in content:
-			if isinstance(element, basestring):
+			if isinstance(element, str):
 				continue
 			name, attrs, content = element
 			fdArray.fromXML(name, attrs, content)
@@ -2105,6 +2106,8 @@ def xmlRead(self, name, attrs, content, parent):
 	(11,		'StdVW',		'number',	None,	None),
 	((12, 12),	'StemSnapH',		'delta',	None,	None),
 	((12, 13),	'StemSnapV',		'delta',	None,	None),
+	((12, 17),	'LanguageGroup',	'number',	0,	None),
+	((12, 18),	'ExpansionFactor',	'number',	0.06,	None),
 	(19,		'Subrs',		'number',	None,	SubrsConverter()),
 ]
 
@@ -2332,7 +2335,7 @@ def getChildren(self, strings):
 					self.rawDict["charset"] = charsetCode
 			if hasattr(self.dictObj, "Encoding") and self.dictObj.Encoding:
 				encoding = self.dictObj.Encoding
-				if not isinstance(encoding, basestring):
+				if not isinstance(encoding, str):
 					children.append(EncodingCompiler(strings, encoding, self))
 		else:
 			if hasattr(self.dictObj, "VarStore"):

Lib/fontTools/cffLib/specializer.py

@@ -13,12 +13,11 @@
 
 """
 
-from fontTools.misc.py23 import *
 from fontTools.cffLib import maxStackLimit
 
 
 def stringToProgram(string):
-	if isinstance(string, basestring):
+	if isinstance(string, str):
 		string = string.split()
 	program = []
 	for token in string:
@@ -70,7 +69,7 @@ def programToCommands(program, getNumRegions=None):
 	it = iter(program)
 
 	for token in it:
-		if not isinstance(token, basestring):
+		if not isinstance(token, str):
 			stack.append(token)
 			continue
 

Lib/fontTools/cffLib/width.py

@@ -7,11 +7,10 @@
 This module determines the optimum ``defaultWidthX`` and ``nominalWidthX``
 values for a font, when provided with a list of glyph widths."""
 
-from fontTools.misc.py23 import *
-from fontTools.ttLib import TTFont, getTableClass
+from fontTools.ttLib import TTFont
 from collections import defaultdict
 from operator import add
-from functools import partial, reduce
+from functools import reduce
 
 
 class missingdict(dict):