# woff2

class fontTools.ttLib.woff2.WOFF2DirectoryEntry
  decodeData(rawData)
  encodeData(data)
  fromFile(file)
  fromString(data)
  loadData(file)
  saveData(file, data)
  toString()
  property transformVersion

    Return bits 6-7 of table entry’s flags, which indicate the preprocessing transformation version number (between 0 and 3).

  property transformed

    Return True if the table has any transformation, else return False.

class fontTools.ttLib.woff2.WOFF2FlavorData(reader=None, data=None, transformedTables=None)
  Flavor = 'woff2'

class fontTools.ttLib.woff2.WOFF2GlyfTable(tag=None)

  Decoder/Encoder for WOFF2 ‘glyf’ table transform.

  closure_glyphs(s)
  compile(ttFont)
  decompile(data, ttFont)
  dependencies = []
  ensureDecompiled(recurse=False)
  fromXML(name, attrs, content, ttFont)
  get(glyphName, default=None)
  getCoordinatesAndControls(glyphName, ttFont, defaultVerticalOrigin=None)

    Old public name for self._getCoordinatesAndControls(). See: https://github.com/fonttools/fonttools/pull/2266

  getGlyphID(glyphName)

    Returns the ID of the glyph with the given name.

    Raises a `ValueError` if the glyph is not found in the font.

  getGlyphName(glyphID)

    Returns the name for the glyph with the given ID.

    Raises a `KeyError` if the glyph name is not found in the font.

  getPhantomPoints(glyphName, ttFont, defaultVerticalOrigin=None)

    Old public name for self._getPhantomPoints(). See: https://github.com/fonttools/fonttools/pull/2266

  has_key(glyphName)
  keys()
  merge(m, tables)
  mergeMap = {'glyphOrder': <function sumLists>, 'glyphs': <function sumDicts>, 'tableTag': <function equal>}
  padding = 1
  prune_post_subset(font, options)
  prune_pre_subset(font, options)
  reconstruct(data, ttFont)

    Decompile transformed ‘glyf’ data.

  removeHinting()

    Removes TrueType hints from all glyphs in the glyphset.

    See `Glyph.removeHinting()`.

  setCoordinates(glyphName, ttFont)

    Old public name for self._setCoordinates(). See: https://github.com/fonttools/fonttools/pull/2266

  setGlyphOrder(glyphOrder)

    Sets the glyph order

    Parameters

      glyphOrder ([str]) – List of glyph names in order.

  subStreams = ('nContourStream', 'nPointsStream', 'flagStream', 'glyphStream', 'compositeStream', 'bboxStream', 'instructionStream')
  subset_glyphs(s)
  toXML(writer, ttFont, splitGlyphs=False)
  transform(ttFont)

    Return transformed ‘glyf’ data

class fontTools.ttLib.woff2.WOFF2HmtxTable(tag=None)
  advanceName = 'width'
  compile(ttFont)
  decompile(data, ttFont)
  dependencies = []
  fromXML(name, attrs, content, ttFont)
  headerTag = 'hhea'
  longMetricFormat = 'Hh'
  merge(m, tables)
  mergeMap = {'metrics': <function sumDicts>, 'tableTag': <function equal>}
  numberOfMetricsName = 'numberOfHMetrics'
  reconstruct(data, ttFont)
  sideBearingName = 'lsb'
  subset_glyphs(s)
  toXML(writer, ttFont)
  transform(ttFont)

class fontTools.ttLib.woff2.WOFF2LocaTable(tag=None)

  Same as parent class. The only difference is that it attempts to preserve the ‘indexFormat’ as encoded in the WOFF2 glyf table.

  compile(ttFont)
  decompile(data, ttFont)
  dependencies = ['glyf']
  fromXML(name, attrs, content, ttFont)
  merge(m, tables)
  mergeMap = {'*': <function recalculate>, 'tableTag': <function equal>}
  set(locations)
  toXML(writer, ttFont)

class fontTools.ttLib.woff2.WOFF2Reader(*args, **kwargs)
  close()
  flavor = 'woff2'
  has_key(tag)
  keys()
  reconstructTable(tag)

    Reconstruct table named ‘tag’ from transformed data.

class fontTools.ttLib.woff2.WOFF2Writer(*args, **kwargs)
  close()

    All tags must have been specified. Now write the table data and directory.

  flavor = 'woff2'
  reordersTables()
  setEntry(tag, entry)
  transformTable(tag)

    Return transformed table data, or None if some pre-conditions aren’t met – in which case, the non-transformed table data will be used.

  writeMasterChecksum()

    Write checkSumAdjustment to the transformBuffer.

fontTools.ttLib.woff2.base128Size(n)

  Return the length in bytes of a UIntBase128-encoded sequence with value n.

      >>> base128Size(0)
      1
      >>> base128Size(24567)
      3
      >>> base128Size(2**32-1)
      5

fontTools.ttLib.woff2.compress(input_file, output_file, transform_tables=None)

  Compress OpenType font to WOFF2.

  Parameters

    - input_file – a file path, file or file-like object (open in binary mode) containing an OpenType font (either CFF- or TrueType-flavored).

    - output_file – a file path, file or file-like object where to save the compressed WOFF2 font.

    - transform_tables – Optional[Iterable[str]]: a set of table tags for which to enable preprocessing transformations. By default, only ‘glyf’ and ‘loca’ tables are transformed. An empty set means disable all transformations.

fontTools.ttLib.woff2.decompress(input_file, output_file)

  Decompress WOFF2 font to OpenType font.

  Parameters

    - input_file – a file path, file or file-like object (open in binary mode) containing a compressed WOFF2 font.

    - output_file – a file path, file or file-like object where to save the decompressed OpenType font.

fontTools.ttLib.woff2.getKnownTagIndex(tag)

  Return index of ‘tag’ in woff2KnownTags list. Return 63 if not found.

fontTools.ttLib.woff2.main(args=None)

  Compress and decompress WOFF2 fonts

fontTools.ttLib.woff2.pack255UShort(value)

  Encode unsigned integer in range 0 to 65535 (inclusive) to a bytestring using 255UInt16 variable-length encoding.

      >>> pack255UShort(252) == b'\xfc'
      True
      >>> pack255UShort(506) == b'\xfe\x00'
      True
      >>> pack255UShort(762) == b'\xfd\x02\xfa'
      True

fontTools.ttLib.woff2.packBase128(n)

  Encode unsigned integer in range 0 to 2**32-1 (inclusive) to a string of bytes using UIntBase128 variable-length encoding. Produce the shortest possible encoding.

      >>> packBase128(63) == b"\x3f"
      True
      >>> packBase128(2**32-1) == b'\x8f\xff\xff\xff\x7f'
      True

fontTools.ttLib.woff2.unpack255UShort(data)

  Read one to three bytes from 255UInt16-encoded input string, and return a tuple containing the decoded integer plus any leftover data.

      >>> unpack255UShort(bytechr(252))[0]
      252

  Note that some numbers (e.g. 506) can have multiple encodings: >>> unpack255UShort(struct.pack(“BB”, 254, 0))[0] 506 >>> unpack255UShort(struct.pack(“BB”, 255, 253))[0] 506 >>> unpack255UShort(struct.pack(“BBB”, 253, 1, 250))[0] 506

fontTools.ttLib.woff2.unpackBase128(data)

  Read one to five bytes from UIntBase128-encoded input string, and return a tuple containing the decoded integer plus any leftover data.

      >>> unpackBase128(b'\x3f\x00\x00') == (63, b"\x00\x00")
      True
      >>> unpackBase128(b'\x8f\xff\xff\xff\x7f')[0] == 4294967295
      True
      >>> unpackBase128(b'\x80\x80\x3f')
      Traceback (most recent call last):
        File "<stdin>", line 1, in ?
      TTLibError: UIntBase128 value must not start with leading zeros
      >>> unpackBase128(b'\x8f\xff\xff\xff\xff\x7f')[0]
      Traceback (most recent call last):
        File "<stdin>", line 1, in ?
      TTLibError: UIntBase128-encoded sequence is longer than 5 bytes
      >>> unpackBase128(b'\x90\x80\x80\x80\x00')[0]
      Traceback (most recent call last):
        File "<stdin>", line 1, in ?
      TTLibError: UIntBase128 value exceeds 2**32-1