fonttools 4.60.2__cp311-cp311-win32.whl

fontTools/ttLib/tables/S_I_N_G_.py

@@ -0,0 +1,99 @@
+from fontTools.misc import sstruct
+from fontTools.misc.textTools import bytechr, byteord, tobytes, tostr, safeEval
+from . import DefaultTable
+
+SINGFormat = """
+		>	# big endian
+		tableVersionMajor:	H
+		tableVersionMinor: 	H
+		glyphletVersion:	H
+		permissions:		h
+		mainGID:			H
+		unitsPerEm:			H
+		vertAdvance:		h
+		vertOrigin:			h
+		uniqueName:			28s
+		METAMD5:			16s
+		nameLength:			1s
+"""
+# baseGlyphName is a byte string which follows the record above.
+
+
+class table_S_I_N_G_(DefaultTable.DefaultTable):
+    """Glyphlets SING table
+
+    The ``SING`` table is used by Adobe's SING Glyphlets.
+
+    See also https://web.archive.org/web/20080627183635/http://www.adobe.com/devnet/opentype/gdk/topic.html
+    """
+
+    dependencies = []
+
+    def decompile(self, data, ttFont):
+        dummy, rest = sstruct.unpack2(SINGFormat, data, self)
+        self.uniqueName = self.decompileUniqueName(self.uniqueName)
+        self.nameLength = byteord(self.nameLength)
+        assert len(rest) == self.nameLength
+        self.baseGlyphName = tostr(rest)
+
+        rawMETAMD5 = self.METAMD5
+        self.METAMD5 = "[" + hex(byteord(self.METAMD5[0]))
+        for char in rawMETAMD5[1:]:
+            self.METAMD5 = self.METAMD5 + ", " + hex(byteord(char))
+        self.METAMD5 = self.METAMD5 + "]"
+
+    def decompileUniqueName(self, data):
+        name = ""
+        for char in data:
+            val = byteord(char)
+            if val == 0:
+                break
+            if (val > 31) or (val < 128):
+                name += chr(val)
+            else:
+                octString = oct(val)
+                if len(octString) > 3:
+                    octString = octString[1:]  # chop off that leading zero.
+                elif len(octString) < 3:
+                    octString.zfill(3)
+                name += "\\" + octString
+        return name
+
+    def compile(self, ttFont):
+        d = self.__dict__.copy()
+        d["nameLength"] = bytechr(len(self.baseGlyphName))
+        d["uniqueName"] = self.compilecompileUniqueName(self.uniqueName, 28)
+        METAMD5List = eval(self.METAMD5)
+        d["METAMD5"] = b""
+        for val in METAMD5List:
+            d["METAMD5"] += bytechr(val)
+        assert len(d["METAMD5"]) == 16, "Failed to pack 16 byte MD5 hash in SING table"
+        data = sstruct.pack(SINGFormat, d)
+        data = data + tobytes(self.baseGlyphName)
+        return data
+
+    def compilecompileUniqueName(self, name, length):
+        nameLen = len(name)
+        if length <= nameLen:
+            name = name[: length - 1] + "\000"
+        else:
+            name += (nameLen - length) * "\000"
+        return name
+
+    def toXML(self, writer, ttFont):
+        writer.comment("Most of this table will be recalculated by the compiler")
+        writer.newline()
+        formatstring, names, fixes = sstruct.getformat(SINGFormat)
+        for name in names:
+            value = getattr(self, name)
+            writer.simpletag(name, value=value)
+            writer.newline()
+        writer.simpletag("baseGlyphName", value=self.baseGlyphName)
+        writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        value = attrs["value"]
+        if name in ["uniqueName", "METAMD5", "baseGlyphName"]:
+            setattr(self, name, value)
+        else:
+            setattr(self, name, safeEval(value))

fontTools/ttLib/tables/S_T_A_T_.py

@@ -0,0 +1,15 @@
+from .otBase import BaseTTXConverter
+
+
+class table_S_T_A_T_(BaseTTXConverter):
+    """Style Attributes table
+
+    The ``STAT`` table records stylistic or typeface-design attributes that
+    differentiate the individual fonts within a font family from one another.
+    Those attributes can be used to assist users when navigating the style
+    variations of a variable font or a family of static fonts.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/stat
+    """
+
+    pass

fontTools/ttLib/tables/S_V_G_.py

@@ -0,0 +1,223 @@
+"""Compiles/decompiles SVG table.
+
+https://docs.microsoft.com/en-us/typography/opentype/spec/svg
+
+The XML format is:
+
+.. code-block:: xml
+
+	<SVG>
+		<svgDoc endGlyphID="1" startGlyphID="1">
+			<![CDATA[ <complete SVG doc> ]]
+		</svgDoc>
+	...
+		<svgDoc endGlyphID="n" startGlyphID="m">
+			<![CDATA[ <complete SVG doc> ]]
+		</svgDoc>
+	</SVG>
+"""
+
+from fontTools.misc.textTools import bytesjoin, safeEval, strjoin, tobytes, tostr
+from fontTools.misc import sstruct
+from . import DefaultTable
+from collections.abc import Sequence
+from dataclasses import dataclass, astuple
+from io import BytesIO
+import struct
+import logging
+
+
+log = logging.getLogger(__name__)
+
+
+SVG_format_0 = """
+	>   # big endian
+	version:                  H
+	offsetToSVGDocIndex:      L
+	reserved:                 L
+"""
+
+SVG_format_0Size = sstruct.calcsize(SVG_format_0)
+
+doc_index_entry_format_0 = """
+	>   # big endian
+	startGlyphID:             H
+	endGlyphID:               H
+	svgDocOffset:             L
+	svgDocLength:             L
+"""
+
+doc_index_entry_format_0Size = sstruct.calcsize(doc_index_entry_format_0)
+
+
+class table_S_V_G_(DefaultTable.DefaultTable):
+    """Scalable Vector Graphics table
+
+    The ``SVG`` table contains representations for glyphs in the SVG
+    image format.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/stat
+    """
+
+    def decompile(self, data, ttFont):
+        self.docList = []
+        # Version 0 is the standardized version of the table; and current.
+        # https://www.microsoft.com/typography/otspec/svg.htm
+        sstruct.unpack(SVG_format_0, data[:SVG_format_0Size], self)
+        if self.version != 0:
+            log.warning(
+                "Unknown SVG table version '%s'. Decompiling as version 0.",
+                self.version,
+            )
+        # read in SVG Documents Index
+        # data starts with the first entry of the entry list.
+        pos = subTableStart = self.offsetToSVGDocIndex
+        self.numEntries = struct.unpack(">H", data[pos : pos + 2])[0]
+        pos += 2
+        if self.numEntries > 0:
+            data2 = data[pos:]
+            entries = []
+            for i in range(self.numEntries):
+                record_data = data2[
+                    i
+                    * doc_index_entry_format_0Size : (i + 1)
+                    * doc_index_entry_format_0Size
+                ]
+                docIndexEntry = sstruct.unpack(
+                    doc_index_entry_format_0, record_data, DocumentIndexEntry()
+                )
+                entries.append(docIndexEntry)
+
+            for entry in entries:
+                start = entry.svgDocOffset + subTableStart
+                end = start + entry.svgDocLength
+                doc = data[start:end]
+                compressed = False
+                if doc.startswith(b"\x1f\x8b"):
+                    import gzip
+
+                    bytesIO = BytesIO(doc)
+                    with gzip.GzipFile(None, "r", fileobj=bytesIO) as gunzipper:
+                        doc = gunzipper.read()
+                    del bytesIO
+                    compressed = True
+                doc = tostr(doc, "utf_8")
+                self.docList.append(
+                    SVGDocument(doc, entry.startGlyphID, entry.endGlyphID, compressed)
+                )
+
+    def compile(self, ttFont):
+        version = 0
+        offsetToSVGDocIndex = (
+            SVG_format_0Size  # I start the SVGDocIndex right after the header.
+        )
+        # get SGVDoc info.
+        docList = []
+        entryList = []
+        numEntries = len(self.docList)
+        datum = struct.pack(">H", numEntries)
+        entryList.append(datum)
+        curOffset = len(datum) + doc_index_entry_format_0Size * numEntries
+        seenDocs = {}
+        allCompressed = getattr(self, "compressed", False)
+        for i, doc in enumerate(self.docList):
+            if isinstance(doc, (list, tuple)):
+                doc = SVGDocument(*doc)
+                self.docList[i] = doc
+            docBytes = tobytes(doc.data, encoding="utf_8")
+            if (allCompressed or doc.compressed) and not docBytes.startswith(
+                b"\x1f\x8b"
+            ):
+                import gzip
+
+                bytesIO = BytesIO()
+                # mtime=0 strips the useless timestamp and makes gzip output reproducible;
+                # equivalent to `gzip -n`
+                with gzip.GzipFile(None, "w", fileobj=bytesIO, mtime=0) as gzipper:
+                    gzipper.write(docBytes)
+                gzipped = bytesIO.getvalue()
+                if len(gzipped) < len(docBytes):
+                    docBytes = gzipped
+                del gzipped, bytesIO
+            docLength = len(docBytes)
+            if docBytes in seenDocs:
+                docOffset = seenDocs[docBytes]
+            else:
+                docOffset = curOffset
+                curOffset += docLength
+                seenDocs[docBytes] = docOffset
+                docList.append(docBytes)
+            entry = struct.pack(
+                ">HHLL", doc.startGlyphID, doc.endGlyphID, docOffset, docLength
+            )
+            entryList.append(entry)
+        entryList.extend(docList)
+        svgDocData = bytesjoin(entryList)
+
+        reserved = 0
+        header = struct.pack(">HLL", version, offsetToSVGDocIndex, reserved)
+        data = [header, svgDocData]
+        data = bytesjoin(data)
+        return data
+
+    def toXML(self, writer, ttFont):
+        for i, doc in enumerate(self.docList):
+            if isinstance(doc, (list, tuple)):
+                doc = SVGDocument(*doc)
+                self.docList[i] = doc
+            attrs = {"startGlyphID": doc.startGlyphID, "endGlyphID": doc.endGlyphID}
+            if doc.compressed:
+                attrs["compressed"] = 1
+            writer.begintag("svgDoc", **attrs)
+            writer.newline()
+            writer.writecdata(doc.data)
+            writer.newline()
+            writer.endtag("svgDoc")
+            writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name == "svgDoc":
+            if not hasattr(self, "docList"):
+                self.docList = []
+            doc = strjoin(content)
+            doc = doc.strip()
+            startGID = int(attrs["startGlyphID"])
+            endGID = int(attrs["endGlyphID"])
+            compressed = bool(safeEval(attrs.get("compressed", "0")))
+            self.docList.append(SVGDocument(doc, startGID, endGID, compressed))
+        else:
+            log.warning("Unknown %s %s", name, content)
+
+
+class DocumentIndexEntry(object):
+    def __init__(self):
+        self.startGlyphID = None  # USHORT
+        self.endGlyphID = None  # USHORT
+        self.svgDocOffset = None  # ULONG
+        self.svgDocLength = None  # ULONG
+
+    def __repr__(self):
+        return (
+            "startGlyphID: %s, endGlyphID: %s, svgDocOffset: %s, svgDocLength: %s"
+            % (self.startGlyphID, self.endGlyphID, self.svgDocOffset, self.svgDocLength)
+        )
+
+
+@dataclass
+class SVGDocument(Sequence):
+    data: str
+    startGlyphID: int
+    endGlyphID: int
+    compressed: bool = False
+
+    # Previously, the SVG table's docList attribute contained a lists of 3 items:
+    # [doc, startGlyphID, endGlyphID]; later, we added a `compressed` attribute.
+    # For backward compatibility with code that depends of them being sequences of
+    # fixed length=3, we subclass the Sequence abstract base class and pretend only
+    # the first three items are present. 'compressed' is only accessible via named
+    # attribute lookup like regular dataclasses: i.e. `doc.compressed`, not `doc[3]`
+    def __getitem__(self, index):
+        return astuple(self)[:3][index]
+
+    def __len__(self):
+        return 3