Upgrade fonttools to 4.44.0 am: 02cec46c7a

Original change: https://android-review.googlesource.com/c/platform/external/fonttools/+/2826690

Change-Id: I89c63a7cd9a99a6ce4c767f36b786f7b5abae2a9
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>

1 files changed, 72 insertions, 56 deletions

diff --git a/Lib/fontTools/ttLib/tables/G__l_a_t.py b/Lib/fontTools/ttLib/tables/G__l_a_t.py
index a4e8e38f..f1dfdaa0 100644
--- a/Lib/fontTools/ttLib/tables/G__l_a_t.py
+++ b/Lib/fontTools/ttLib/tables/G__l_a_t.py
@@ -1,6 +1,7 @@
 from fontTools.misc import sstruct
 from fontTools.misc.fixedTools import floatToFixedToStr
 from fontTools.misc.textTools import safeEval
+
 # from itertools import *
 from functools import partial
 from . import DefaultTable
@@ -51,16 +52,19 @@ Glat_format_3_subbox_entry = """
     diagPosMax:     B    # Defines maximum positively-sloped diagonal (da)
 """
 
-class _Object() :
+
+class _Object:
     pass
 
-class _Dict(dict) :
+
+class _Dict(dict):
     pass
 
+
 class table_G__l_a_t(DefaultTable.DefaultTable):
-    '''
+    """
     Support Graphite Glat tables
-    '''
+    """
 
     def __init__(self, tag=None):
         DefaultTable.DefaultTable.__init__(self, tag)
@@ -70,31 +74,31 @@ class table_G__l_a_t(DefaultTable.DefaultTable):
         sstruct.unpack2(Glat_format_0, data, self)
         self.version = float(floatToFixedToStr(self.version, precisionBits=16))
         if self.version <= 1.9:
-            decoder = partial(self.decompileAttributes12,fmt=Glat_format_1_entry)
-        elif self.version <= 2.9:   
-            decoder = partial(self.decompileAttributes12,fmt=Glat_format_23_entry)
+            decoder = partial(self.decompileAttributes12, fmt=Glat_format_1_entry)
+        elif self.version <= 2.9:
+            decoder = partial(self.decompileAttributes12, fmt=Glat_format_23_entry)
         elif self.version >= 3.0:
             (data, self.scheme) = grUtils.decompress(data)
             sstruct.unpack2(Glat_format_3, data, self)
             self.hasOctaboxes = (self.compression & 1) == 1
             decoder = self.decompileAttributes3
-        
-        gloc = ttFont['Gloc']
+
+        gloc = ttFont["Gloc"]
         self.attributes = {}
         count = 0
-        for s,e in zip(gloc,gloc[1:]):
+        for s, e in zip(gloc, gloc[1:]):
             self.attributes[ttFont.getGlyphName(count)] = decoder(data[s:e])
             count += 1
-    
+
     def decompileAttributes12(self, data, fmt):
         attributes = _Dict()
         while len(data) > 3:
             e, data = sstruct.unpack2(fmt, data, _Object())
-            keys = range(e.attNum, e.attNum+e.num)
-            if len(data) >= 2 * e.num :
-                vals = struct.unpack_from(('>%dh' % e.num), data)
-                attributes.update(zip(keys,vals))
-                data = data[2*e.num:]
+            keys = range(e.attNum, e.attNum + e.num)
+            if len(data) >= 2 * e.num:
+                vals = struct.unpack_from((">%dh" % e.num), data)
+                attributes.update(zip(keys, vals))
+                data = data[2 * e.num :]
         return attributes
 
     def decompileAttributes3(self, data):
@@ -103,9 +107,10 @@ class table_G__l_a_t(DefaultTable.DefaultTable):
             numsub = bin(o.subboxBitmap).count("1")
             o.subboxes = []
             for b in range(numsub):
-                if len(data) >= 8 :
-                    subbox, data = sstruct.unpack2(Glat_format_3_subbox_entry,
-                                                    data, _Object())
+                if len(data) >= 8:
+                    subbox, data = sstruct.unpack2(
+                        Glat_format_3_subbox_entry, data, _Object()
+                    )
                     o.subboxes.append(subbox)
         attrs = self.decompileAttributes12(data, Glat_format_23_entry)
         if self.hasOctaboxes:
@@ -128,7 +133,7 @@ class table_G__l_a_t(DefaultTable.DefaultTable):
             glocs.append(len(data))
             data += encoder(self.attributes[ttFont.getGlyphName(n)])
         glocs.append(len(data))
-        ttFont['Gloc'].set(glocs)
+        ttFont["Gloc"].set(glocs)
 
         if self.version >= 3.0:
             data = grUtils.compress(self.scheme, data)
@@ -137,82 +142,93 @@ class table_G__l_a_t(DefaultTable.DefaultTable):
     def compileAttributes12(self, attrs, fmt):
         data = b""
         for e in grUtils.entries(attrs):
-            data += sstruct.pack(fmt, {'attNum' : e[0], 'num' : e[1]}) + \
-                    struct.pack(('>%dh' % len(e[2])), *e[2])
+            data += sstruct.pack(fmt, {"attNum": e[0], "num": e[1]}) + struct.pack(
+                (">%dh" % len(e[2])), *e[2]
+            )
         return data
-    
+
     def compileAttributes3(self, attrs):
         if self.hasOctaboxes:
             o = attrs.octabox
             data = sstruct.pack(Glat_format_3_octabox_metrics, o)
             numsub = bin(o.subboxBitmap).count("1")
-            for b in range(numsub) :
+            for b in range(numsub):
                 data += sstruct.pack(Glat_format_3_subbox_entry, o.subboxes[b])
         else:
             data = ""
         return data + self.compileAttributes12(attrs, Glat_format_23_entry)
 
     def toXML(self, writer, ttFont):
-        writer.simpletag('version', version=self.version, compressionScheme=self.scheme)
+        writer.simpletag("version", version=self.version, compressionScheme=self.scheme)
         writer.newline()
-        for n, a in sorted(self.attributes.items(), key=lambda x:ttFont.getGlyphID(x[0])):
-            writer.begintag('glyph', name=n)
+        for n, a in sorted(
+            self.attributes.items(), key=lambda x: ttFont.getGlyphID(x[0])
+        ):
+            writer.begintag("glyph", name=n)
             writer.newline()
-            if hasattr(a, 'octabox'):
+            if hasattr(a, "octabox"):
                 o = a.octabox
-                formatstring, names, fixes = sstruct.getformat(Glat_format_3_octabox_metrics)
+                formatstring, names, fixes = sstruct.getformat(
+                    Glat_format_3_octabox_metrics
+                )
                 vals = {}
                 for k in names:
-                    if k == 'subboxBitmap': continue
-                    vals[k] = "{:.3f}%".format(getattr(o, k) * 100. / 255)
-                vals['bitmap'] = "{:0X}".format(o.subboxBitmap)
-                writer.begintag('octaboxes', **vals)
+                    if k == "subboxBitmap":
+                        continue
+                    vals[k] = "{:.3f}%".format(getattr(o, k) * 100.0 / 255)
+                vals["bitmap"] = "{:0X}".format(o.subboxBitmap)
+                writer.begintag("octaboxes", **vals)
                 writer.newline()
-                formatstring, names, fixes = sstruct.getformat(Glat_format_3_subbox_entry)
+                formatstring, names, fixes = sstruct.getformat(
+                    Glat_format_3_subbox_entry
+                )
                 for s in o.subboxes:
                     vals = {}
                     for k in names:
-                        vals[k] = "{:.3f}%".format(getattr(s, k) * 100. / 255)
-                    writer.simpletag('octabox', **vals)
+                        vals[k] = "{:.3f}%".format(getattr(s, k) * 100.0 / 255)
+                    writer.simpletag("octabox", **vals)
                     writer.newline()
-                writer.endtag('octaboxes')
+                writer.endtag("octaboxes")
                 writer.newline()
             for k, v in sorted(a.items()):
-                writer.simpletag('attribute', index=k, value=v)
+                writer.simpletag("attribute", index=k, value=v)
                 writer.newline()
-            writer.endtag('glyph')
+            writer.endtag("glyph")
             writer.newline()
 
     def fromXML(self, name, attrs, content, ttFont):
-        if name == 'version' :
-            self.version = float(safeEval(attrs['version']))
-            self.scheme = int(safeEval(attrs['compressionScheme']))
-        if name != 'glyph' : return
-        if not hasattr(self, 'attributes'):
+        if name == "version":
+            self.version = float(safeEval(attrs["version"]))
+            self.scheme = int(safeEval(attrs["compressionScheme"]))
+        if name != "glyph":
+            return
+        if not hasattr(self, "attributes"):
             self.attributes = {}
-        gname = attrs['name']
+        gname = attrs["name"]
         attributes = _Dict()
         for element in content:
-            if not isinstance(element, tuple): continue
+            if not isinstance(element, tuple):
+                continue
             tag, attrs, subcontent = element
-            if tag == 'attribute' :
-                k = int(safeEval(attrs['index']))
-                v = int(safeEval(attrs['value']))
-                attributes[k]=v
-            elif tag == 'octaboxes':
+            if tag == "attribute":
+                k = int(safeEval(attrs["index"]))
+                v = int(safeEval(attrs["value"]))
+                attributes[k] = v
+            elif tag == "octaboxes":
                 self.hasOctaboxes = True
                 o = _Object()
-                o.subboxBitmap = int(attrs['bitmap'], 16)
+                o.subboxBitmap = int(attrs["bitmap"], 16)
                 o.subboxes = []
-                del attrs['bitmap']
+                del attrs["bitmap"]
                 for k, v in attrs.items():
-                    setattr(o, k, int(float(v[:-1]) * 255. / 100. + 0.5))
+                    setattr(o, k, int(float(v[:-1]) * 255.0 / 100.0 + 0.5))
                 for element in subcontent:
-                    if not isinstance(element, tuple): continue
+                    if not isinstance(element, tuple):
+                        continue
                     (tag, attrs, subcontent) = element
                     so = _Object()
                     for k, v in attrs.items():
-                        setattr(so, k, int(float(v[:-1]) * 255. / 100. + 0.5))
+                        setattr(so, k, int(float(v[:-1]) * 255.0 / 100.0 + 0.5))
                     o.subboxes.append(so)
                 attributes.octabox = o
         self.attributes[gname] = attributes