fonttools 4.60.2__cp311-cp311-win32.whl

fontTools/ttLib/tables/otTraverse.py

@@ -0,0 +1,163 @@
+"""Methods for traversing trees of otData-driven OpenType tables."""
+
+from collections import deque
+from typing import Callable, Deque, Iterable, List, Optional, Tuple
+from .otBase import BaseTable
+
+
+__all__ = [
+    "bfs_base_table",
+    "dfs_base_table",
+    "SubTablePath",
+]
+
+
+class SubTablePath(Tuple[BaseTable.SubTableEntry, ...]):
+    def __str__(self) -> str:
+        path_parts = []
+        for entry in self:
+            path_part = entry.name
+            if entry.index is not None:
+                path_part += f"[{entry.index}]"
+            path_parts.append(path_part)
+        return ".".join(path_parts)
+
+
+# Given f(current frontier, new entries) add new entries to frontier
+AddToFrontierFn = Callable[[Deque[SubTablePath], List[SubTablePath]], None]
+
+
+def dfs_base_table(
+    root: BaseTable,
+    root_accessor: Optional[str] = None,
+    skip_root: bool = False,
+    predicate: Optional[Callable[[SubTablePath], bool]] = None,
+    iter_subtables_fn: Optional[
+        Callable[[BaseTable], Iterable[BaseTable.SubTableEntry]]
+    ] = None,
+) -> Iterable[SubTablePath]:
+    """Depth-first search tree of BaseTables.
+
+    Args:
+        root (BaseTable): the root of the tree.
+        root_accessor (Optional[str]): attribute name for the root table, if any (mostly
+            useful for debugging).
+        skip_root (Optional[bool]): if True, the root itself is not visited, only its
+            children.
+        predicate (Optional[Callable[[SubTablePath], bool]]): function to filter out
+            paths. If True, the path is yielded and its subtables are added to the
+            queue. If False, the path is skipped and its subtables are not traversed.
+        iter_subtables_fn (Optional[Callable[[BaseTable], Iterable[BaseTable.SubTableEntry]]]):
+            function to iterate over subtables of a table. If None, the default
+            BaseTable.iterSubTables() is used.
+
+    Yields:
+        SubTablePath: tuples of BaseTable.SubTableEntry(name, table, index) namedtuples
+        for each of the nodes in the tree. The last entry in a path is the current
+        subtable, whereas preceding ones refer to its parent tables all the way up to
+        the root.
+    """
+    yield from _traverse_ot_data(
+        root,
+        root_accessor,
+        skip_root,
+        predicate,
+        lambda frontier, new: frontier.extendleft(reversed(new)),
+        iter_subtables_fn,
+    )
+
+
+def bfs_base_table(
+    root: BaseTable,
+    root_accessor: Optional[str] = None,
+    skip_root: bool = False,
+    predicate: Optional[Callable[[SubTablePath], bool]] = None,
+    iter_subtables_fn: Optional[
+        Callable[[BaseTable], Iterable[BaseTable.SubTableEntry]]
+    ] = None,
+) -> Iterable[SubTablePath]:
+    """Breadth-first search tree of BaseTables.
+
+    Args:
+        root
+            the root of the tree.
+        root_accessor (Optional[str]): attribute name for the root table, if any (mostly
+            useful for debugging).
+        skip_root (Optional[bool]): if True, the root itself is not visited, only its
+            children.
+        predicate (Optional[Callable[[SubTablePath], bool]]): function to filter out
+            paths. If True, the path is yielded and its subtables are added to the
+            queue. If False, the path is skipped and its subtables are not traversed.
+        iter_subtables_fn (Optional[Callable[[BaseTable], Iterable[BaseTable.SubTableEntry]]]):
+            function to iterate over subtables of a table. If None, the default
+            BaseTable.iterSubTables() is used.
+
+    Yields:
+        SubTablePath: tuples of BaseTable.SubTableEntry(name, table, index) namedtuples
+        for each of the nodes in the tree. The last entry in a path is the current
+        subtable, whereas preceding ones refer to its parent tables all the way up to
+        the root.
+    """
+    yield from _traverse_ot_data(
+        root,
+        root_accessor,
+        skip_root,
+        predicate,
+        lambda frontier, new: frontier.extend(new),
+        iter_subtables_fn,
+    )
+
+
+def _traverse_ot_data(
+    root: BaseTable,
+    root_accessor: Optional[str],
+    skip_root: bool,
+    predicate: Optional[Callable[[SubTablePath], bool]],
+    add_to_frontier_fn: AddToFrontierFn,
+    iter_subtables_fn: Optional[
+        Callable[[BaseTable], Iterable[BaseTable.SubTableEntry]]
+    ] = None,
+) -> Iterable[SubTablePath]:
+    # no visited because general otData cannot cycle (forward-offset only)
+    if root_accessor is None:
+        root_accessor = type(root).__name__
+
+    if predicate is None:
+
+        def predicate(path):
+            return True
+
+    if iter_subtables_fn is None:
+
+        def iter_subtables_fn(table):
+            return table.iterSubTables()
+
+    frontier: Deque[SubTablePath] = deque()
+
+    root_entry = BaseTable.SubTableEntry(root_accessor, root)
+    if not skip_root:
+        frontier.append((root_entry,))
+    else:
+        add_to_frontier_fn(
+            frontier,
+            [
+                (root_entry, subtable_entry)
+                for subtable_entry in iter_subtables_fn(root)
+            ],
+        )
+
+    while frontier:
+        # path is (value, attr_name) tuples. attr_name is attr of parent to get value
+        path = frontier.popleft()
+        current = path[-1].value
+
+        if not predicate(path):
+            continue
+
+        yield SubTablePath(path)
+
+        new_entries = [
+            path + (subtable_entry,) for subtable_entry in iter_subtables_fn(current)
+        ]
+
+        add_to_frontier_fn(frontier, new_entries)

fontTools/ttLib/tables/sbixGlyph.py

@@ -0,0 +1,149 @@
+from fontTools.misc import sstruct
+from fontTools.misc.textTools import readHex, safeEval
+import struct
+
+
+sbixGlyphHeaderFormat = """
+	>
+	originOffsetX: h	# The x-value of the point in the glyph relative to its
+						# lower-left corner which corresponds to the origin of
+						# the glyph on the screen, that is the point on the
+						# baseline at the left edge of the glyph.
+	originOffsetY: h	# The y-value of the point in the glyph relative to its
+						# lower-left corner which corresponds to the origin of
+						# the glyph on the screen, that is the point on the
+						# baseline at the left edge of the glyph.
+	graphicType:  4s	# e.g. "png "
+"""
+
+sbixGlyphHeaderFormatSize = sstruct.calcsize(sbixGlyphHeaderFormat)
+
+
+class Glyph(object):
+    def __init__(
+        self,
+        glyphName=None,
+        referenceGlyphName=None,
+        originOffsetX=0,
+        originOffsetY=0,
+        graphicType=None,
+        imageData=None,
+        rawdata=None,
+        gid=0,
+    ):
+        self.gid = gid
+        self.glyphName = glyphName
+        self.referenceGlyphName = referenceGlyphName
+        self.originOffsetX = originOffsetX
+        self.originOffsetY = originOffsetY
+        self.rawdata = rawdata
+        self.graphicType = graphicType
+        self.imageData = imageData
+
+        # fix self.graphicType if it is null terminated or too short
+        if self.graphicType is not None:
+            if self.graphicType[-1] == "\0":
+                self.graphicType = self.graphicType[:-1]
+            if len(self.graphicType) > 4:
+                from fontTools import ttLib
+
+                raise ttLib.TTLibError(
+                    "Glyph.graphicType must not be longer than 4 characters."
+                )
+            elif len(self.graphicType) < 4:
+                # pad with spaces
+                self.graphicType += "    "[: (4 - len(self.graphicType))]
+
+    def is_reference_type(self):
+        """Returns True if this glyph is a reference to another glyph's image data."""
+        return self.graphicType == "dupe" or self.graphicType == "flip"
+
+    def decompile(self, ttFont):
+        self.glyphName = ttFont.getGlyphName(self.gid)
+        if self.rawdata is None:
+            from fontTools import ttLib
+
+            raise ttLib.TTLibError("No table data to decompile")
+        if len(self.rawdata) > 0:
+            if len(self.rawdata) < sbixGlyphHeaderFormatSize:
+                from fontTools import ttLib
+
+                # print "Glyph %i header too short: Expected %x, got %x." % (self.gid, sbixGlyphHeaderFormatSize, len(self.rawdata))
+                raise ttLib.TTLibError("Glyph header too short.")
+
+            sstruct.unpack(
+                sbixGlyphHeaderFormat, self.rawdata[:sbixGlyphHeaderFormatSize], self
+            )
+
+            if self.is_reference_type():
+                # this glyph is a reference to another glyph's image data
+                (gid,) = struct.unpack(">H", self.rawdata[sbixGlyphHeaderFormatSize:])
+                self.referenceGlyphName = ttFont.getGlyphName(gid)
+            else:
+                self.imageData = self.rawdata[sbixGlyphHeaderFormatSize:]
+                self.referenceGlyphName = None
+        # clean up
+        del self.rawdata
+        del self.gid
+
+    def compile(self, ttFont):
+        if self.glyphName is None:
+            from fontTools import ttLib
+
+            raise ttLib.TTLibError("Can't compile Glyph without glyph name")
+            # TODO: if ttFont has no maxp, cmap etc., ignore glyph names and compile by index?
+            # (needed if you just want to compile the sbix table on its own)
+        self.gid = struct.pack(">H", ttFont.getGlyphID(self.glyphName))
+        if self.graphicType is None:
+            rawdata = b""
+        else:
+            rawdata = sstruct.pack(sbixGlyphHeaderFormat, self)
+            if self.is_reference_type():
+                rawdata += struct.pack(">H", ttFont.getGlyphID(self.referenceGlyphName))
+            else:
+                assert self.imageData is not None
+                rawdata += self.imageData
+        self.rawdata = rawdata
+
+    def toXML(self, xmlWriter, ttFont):
+        if self.graphicType is None:
+            # TODO: ignore empty glyphs?
+            # a glyph data entry is required for each glyph,
+            # but empty ones can be calculated at compile time
+            xmlWriter.simpletag("glyph", name=self.glyphName)
+            xmlWriter.newline()
+            return
+        xmlWriter.begintag(
+            "glyph",
+            graphicType=self.graphicType,
+            name=self.glyphName,
+            originOffsetX=self.originOffsetX,
+            originOffsetY=self.originOffsetY,
+        )
+        xmlWriter.newline()
+        if self.is_reference_type():
+            # this glyph is a reference to another glyph id.
+            xmlWriter.simpletag("ref", glyphname=self.referenceGlyphName)
+        else:
+            xmlWriter.begintag("hexdata")
+            xmlWriter.newline()
+            xmlWriter.dumphex(self.imageData)
+            xmlWriter.endtag("hexdata")
+        xmlWriter.newline()
+        xmlWriter.endtag("glyph")
+        xmlWriter.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name == "ref":
+            # this glyph i.e. a reference to another glyph's image data.
+            # in this case imageData contains the glyph id of the reference glyph
+            # get glyph id from glyphname
+            glyphname = safeEval("'''" + attrs["glyphname"] + "'''")
+            self.imageData = struct.pack(">H", ttFont.getGlyphID(glyphname))
+            self.referenceGlyphName = glyphname
+        elif name == "hexdata":
+            self.imageData = readHex(content)
+        else:
+            from fontTools import ttLib
+
+            raise ttLib.TTLibError("can't handle '%s' element" % name)

fontTools/ttLib/tables/sbixStrike.py

@@ -0,0 +1,177 @@
+from fontTools.misc import sstruct
+from fontTools.misc.textTools import safeEval
+from .sbixGlyph import Glyph
+import struct
+
+sbixStrikeHeaderFormat = """
+	>
+	ppem:          H	# The PPEM for which this strike was designed (e.g., 9,
+						# 12, 24)
+	resolution:    H	# The screen resolution (in dpi) for which this strike
+						# was designed (e.g., 72)
+"""
+
+sbixGlyphDataOffsetFormat = """
+	>
+	glyphDataOffset:   L	# Offset from the beginning of the strike data record
+							# to data for the individual glyph
+"""
+
+sbixStrikeHeaderFormatSize = sstruct.calcsize(sbixStrikeHeaderFormat)
+sbixGlyphDataOffsetFormatSize = sstruct.calcsize(sbixGlyphDataOffsetFormat)
+
+
+class Strike(object):
+    def __init__(self, rawdata=None, ppem=0, resolution=72):
+        self.data = rawdata
+        self.ppem = ppem
+        self.resolution = resolution
+        self.glyphs = {}
+
+    def decompile(self, ttFont):
+        if self.data is None:
+            from fontTools import ttLib
+
+            raise ttLib.TTLibError
+        if len(self.data) < sbixStrikeHeaderFormatSize:
+            from fontTools import ttLib
+
+            raise (
+                ttLib.TTLibError,
+                "Strike header too short: Expected %x, got %x.",
+            ) % (sbixStrikeHeaderFormatSize, len(self.data))
+
+        # read Strike header from raw data
+        sstruct.unpack(
+            sbixStrikeHeaderFormat, self.data[:sbixStrikeHeaderFormatSize], self
+        )
+
+        # calculate number of glyphs
+        (firstGlyphDataOffset,) = struct.unpack(
+            ">L",
+            self.data[
+                sbixStrikeHeaderFormatSize : sbixStrikeHeaderFormatSize
+                + sbixGlyphDataOffsetFormatSize
+            ],
+        )
+        self.numGlyphs = (
+            firstGlyphDataOffset - sbixStrikeHeaderFormatSize
+        ) // sbixGlyphDataOffsetFormatSize - 1
+        # ^ -1 because there's one more offset than glyphs
+
+        # build offset list for single glyph data offsets
+        self.glyphDataOffsets = []
+        for i in range(
+            self.numGlyphs + 1
+        ):  # + 1 because there's one more offset than glyphs
+            start = i * sbixGlyphDataOffsetFormatSize + sbixStrikeHeaderFormatSize
+            (current_offset,) = struct.unpack(
+                ">L", self.data[start : start + sbixGlyphDataOffsetFormatSize]
+            )
+            self.glyphDataOffsets.append(current_offset)
+
+        # iterate through offset list and slice raw data into glyph data records
+        for i in range(self.numGlyphs):
+            current_glyph = Glyph(
+                rawdata=self.data[
+                    self.glyphDataOffsets[i] : self.glyphDataOffsets[i + 1]
+                ],
+                gid=i,
+            )
+            current_glyph.decompile(ttFont)
+            self.glyphs[current_glyph.glyphName] = current_glyph
+        del self.glyphDataOffsets
+        del self.numGlyphs
+        del self.data
+
+    def compile(self, ttFont):
+        self.glyphDataOffsets = b""
+        self.bitmapData = b""
+
+        glyphOrder = ttFont.getGlyphOrder()
+
+        # first glyph starts right after the header
+        currentGlyphDataOffset = (
+            sbixStrikeHeaderFormatSize
+            + sbixGlyphDataOffsetFormatSize * (len(glyphOrder) + 1)
+        )
+        for glyphName in glyphOrder:
+            if glyphName in self.glyphs:
+                # we have glyph data for this glyph
+                current_glyph = self.glyphs[glyphName]
+            else:
+                # must add empty glyph data record for this glyph
+                current_glyph = Glyph(glyphName=glyphName)
+            current_glyph.compile(ttFont)
+            current_glyph.glyphDataOffset = currentGlyphDataOffset
+            self.bitmapData += current_glyph.rawdata
+            currentGlyphDataOffset += len(current_glyph.rawdata)
+            self.glyphDataOffsets += sstruct.pack(
+                sbixGlyphDataOffsetFormat, current_glyph
+            )
+
+        # add last "offset", really the end address of the last glyph data record
+        dummy = Glyph()
+        dummy.glyphDataOffset = currentGlyphDataOffset
+        self.glyphDataOffsets += sstruct.pack(sbixGlyphDataOffsetFormat, dummy)
+
+        # pack header
+        self.data = sstruct.pack(sbixStrikeHeaderFormat, self)
+        # add offsets and image data after header
+        self.data += self.glyphDataOffsets + self.bitmapData
+
+    def toXML(self, xmlWriter, ttFont):
+        xmlWriter.begintag("strike")
+        xmlWriter.newline()
+        xmlWriter.simpletag("ppem", value=self.ppem)
+        xmlWriter.newline()
+        xmlWriter.simpletag("resolution", value=self.resolution)
+        xmlWriter.newline()
+        glyphOrder = ttFont.getGlyphOrder()
+        for glyphName in glyphOrder:
+            if glyphName in self.glyphs:
+                self.glyphs[glyphName].toXML(xmlWriter, ttFont)
+                # TODO: what if there are more glyph data records than (glyf table) glyphs?
+        xmlWriter.endtag("strike")
+        xmlWriter.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name in ["ppem", "resolution"]:
+            setattr(self, name, safeEval(attrs["value"]))
+        elif name == "glyph":
+            if "graphicType" in attrs:
+                myFormat = safeEval("'''" + attrs["graphicType"] + "'''")
+            else:
+                myFormat = None
+            if "glyphname" in attrs:
+                myGlyphName = safeEval("'''" + attrs["glyphname"] + "'''")
+            elif "name" in attrs:
+                myGlyphName = safeEval("'''" + attrs["name"] + "'''")
+            else:
+                from fontTools import ttLib
+
+                raise ttLib.TTLibError("Glyph must have a glyph name.")
+            if "originOffsetX" in attrs:
+                myOffsetX = safeEval(attrs["originOffsetX"])
+            else:
+                myOffsetX = 0
+            if "originOffsetY" in attrs:
+                myOffsetY = safeEval(attrs["originOffsetY"])
+            else:
+                myOffsetY = 0
+            current_glyph = Glyph(
+                glyphName=myGlyphName,
+                graphicType=myFormat,
+                originOffsetX=myOffsetX,
+                originOffsetY=myOffsetY,
+            )
+            for element in content:
+                if isinstance(element, tuple):
+                    name, attrs, content = element
+                    current_glyph.fromXML(name, attrs, content, ttFont)
+                    current_glyph.compile(ttFont)
+            self.glyphs[current_glyph.glyphName] = current_glyph
+        else:
+            from fontTools import ttLib
+
+            raise ttLib.TTLibError("can't handle '%s' element" % name)

fontTools/ttLib/tables/table_API_readme.txt

@@ -0,0 +1,91 @@
+This folder is a subpackage of ttLib. Each module here is a 
+specialized TT/OT table converter: they can convert raw data 
+to Python objects and vice versa. Usually you don't need to 
+use the modules directly: they are imported and used 
+automatically when needed by ttLib.
+
+If you are writing you own table converter the following is 
+important.
+
+The modules here have pretty strange names: this is due to the 
+fact that we need to map TT table tags (which are case sensitive) 
+to filenames (which on Mac and Win aren't case sensitive) as well 
+as to Python identifiers. The latter means it can only contain 
+[A-Za-z0-9_] and cannot start with a number. 
+
+ttLib provides functions to expand a tag into the format used here:
+
+>>> from fontTools import ttLib
+>>> ttLib.tagToIdentifier("FOO ")
+'F_O_O_'
+>>> ttLib.tagToIdentifier("cvt ")
+'_c_v_t'
+>>> ttLib.tagToIdentifier("OS/2")
+'O_S_2f_2'
+>>> ttLib.tagToIdentifier("glyf")
+'_g_l_y_f'
+>>> 
+
+And vice versa:
+
+>>> ttLib.identifierToTag("F_O_O_")
+'FOO '
+>>> ttLib.identifierToTag("_c_v_t")
+'cvt '
+>>> ttLib.identifierToTag("O_S_2f_2")
+'OS/2'
+>>> ttLib.identifierToTag("_g_l_y_f")
+'glyf'
+>>> 
+
+Eg. the 'glyf' table converter lives in a Python file called:
+
+	_g_l_y_f.py
+
+The converter itself is a class, named "table_" + expandedtag. Eg:
+
+	class table__g_l_y_f:
+		etc.
+
+Note that if you _do_ need to use such modules or classes manually, 
+there are two convenient API functions that let you find them by tag:
+
+>>> ttLib.getTableModule('glyf')
+<module 'ttLib.tables._g_l_y_f'>
+>>> ttLib.getTableClass('glyf')
+<class ttLib.tables._g_l_y_f.table__g_l_y_f at 645f400>
+>>> 
+
+You must subclass from DefaultTable.DefaultTable. It provides some default
+behavior, as well as a constructor method (__init__) that you don't need to 
+override.
+
+Your converter should minimally provide two methods:
+
+class table_F_O_O_(DefaultTable.DefaultTable): # converter for table 'FOO '
+	
+	def decompile(self, data, ttFont):
+		# 'data' is the raw table data. Unpack it into a
+		# Python data structure.
+		# 'ttFont' is a ttLib.TTfile instance, enabling you to
+		# refer to other tables. Do ***not*** keep a reference to
+		# it: it will cause a circular reference (ttFont saves 
+		# a reference to us), and that means we'll be leaking 
+		# memory. If you need to use it in other methods, just 
+		# pass it around as a method argument.
+	
+	def compile(self, ttFont):
+		# Return the raw data, as converted from the Python
+		# data structure. 
+		# Again, 'ttFont' is there so you can access other tables.
+		# Same warning applies.
+
+If you want to support TTX import/export as well, you need to provide two
+additional methods:
+
+	def toXML(self, writer, ttFont):
+		# XXX
+	
+	def fromXML(self, (name, attrs, content), ttFont):
+		# XXX
+