Add files using upload-large-folder tool

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/__init__.py

@@ -0,0 +1,8 @@
+import logging
+from fontTools.misc.loggingTools import configLogger
+
+log = logging.getLogger(__name__)
+
+version = __version__ = "4.60.1"
+
+__all__ = ["version", "log", "configLogger"]

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/__main__.py

@@ -0,0 +1,35 @@
+import sys
+
+
+def main(args=None):
+    if args is None:
+        args = sys.argv[1:]
+
+    # TODO Handle library-wide options. Eg.:
+    # --unicodedata
+    # --verbose / other logging stuff
+
+    # TODO Allow a way to run arbitrary modules? Useful for setting
+    # library-wide options and calling another library. Eg.:
+    #
+    #   $ fonttools --unicodedata=... fontmake ...
+    #
+    # This allows for a git-like command where thirdparty commands
+    # can be added.  Should we just try importing the fonttools
+    # module first and try without if it fails?
+
+    if len(sys.argv) < 2:
+        sys.argv.append("help")
+    if sys.argv[1] == "-h" or sys.argv[1] == "--help":
+        sys.argv[1] = "help"
+    mod = "fontTools." + sys.argv[1]
+    sys.argv[1] = sys.argv[0] + " " + sys.argv[1]
+    del sys.argv[0]
+
+    import runpy
+
+    runpy.run_module(mod, run_name="__main__")
+
+
+if __name__ == "__main__":
+    sys.exit(main())

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/afmLib.py

@@ -0,0 +1,439 @@
+"""Module for reading and writing AFM (Adobe Font Metrics) files.
+
+Note that this has been designed to read in AFM files generated by Fontographer
+and has not been tested on many other files. In particular, it does not
+implement the whole Adobe AFM specification [#f1]_ but, it should read most
+"common" AFM files.
+
+Here is an example of using `afmLib` to read, modify and write an AFM file:
+
+	>>> from fontTools.afmLib import AFM
+	>>> f = AFM("Tests/afmLib/data/TestAFM.afm")
+	>>>
+	>>> # Accessing a pair gets you the kern value
+	>>> f[("V","A")]
+	-60
+	>>>
+	>>> # Accessing a glyph name gets you metrics
+	>>> f["A"]
+	(65, 668, (8, -25, 660, 666))
+	>>> # (charnum, width, bounding box)
+	>>>
+	>>> # Accessing an attribute gets you metadata
+	>>> f.FontName
+	'TestFont-Regular'
+	>>> f.FamilyName
+	'TestFont'
+	>>> f.Weight
+	'Regular'
+	>>> f.XHeight
+	500
+	>>> f.Ascender
+	750
+	>>>
+	>>> # Attributes and items can also be set
+	>>> f[("A","V")] = -150 # Tighten kerning
+	>>> f.FontName = "TestFont Squished"
+	>>>
+	>>> # And the font written out again (remove the # in front)
+	>>> #f.write("testfont-squished.afm")
+
+.. rubric:: Footnotes
+
+.. [#f1] `Adobe Technote 5004 <https://www.adobe.com/content/dam/acom/en/devnet/font/pdfs/5004.AFM_Spec.pdf>`_,
+   Adobe Font Metrics File Format Specification.
+
+"""
+
+import re
+
+# every single line starts with a "word"
+identifierRE = re.compile(r"^([A-Za-z]+).*")
+
+# regular expression to parse char lines
+charRE = re.compile(
+    r"(-?\d+)"  # charnum
+    r"\s*;\s*WX\s+"  # ; WX
+    r"(-?\d+)"  # width
+    r"\s*;\s*N\s+"  # ; N
+    r"([.A-Za-z0-9_]+)"  # charname
+    r"\s*;\s*B\s+"  # ; B
+    r"(-?\d+)"  # left
+    r"\s+"
+    r"(-?\d+)"  # bottom
+    r"\s+"
+    r"(-?\d+)"  # right
+    r"\s+"
+    r"(-?\d+)"  # top
+    r"\s*;\s*"  # ;
+)
+
+# regular expression to parse kerning lines
+kernRE = re.compile(
+    r"([.A-Za-z0-9_]+)"  # leftchar
+    r"\s+"
+    r"([.A-Za-z0-9_]+)"  # rightchar
+    r"\s+"
+    r"(-?\d+)"  # value
+    r"\s*"
+)
+
+# regular expressions to parse composite info lines of the form:
+# Aacute 2 ; PCC A 0 0 ; PCC acute 182 211 ;
+compositeRE = re.compile(
+    r"([.A-Za-z0-9_]+)"  # char name
+    r"\s+"
+    r"(\d+)"  # number of parts
+    r"\s*;\s*"
+)
+componentRE = re.compile(
+    r"PCC\s+"  # PPC
+    r"([.A-Za-z0-9_]+)"  # base char name
+    r"\s+"
+    r"(-?\d+)"  # x offset
+    r"\s+"
+    r"(-?\d+)"  # y offset
+    r"\s*;\s*"
+)
+
+preferredAttributeOrder = [
+    "FontName",
+    "FullName",
+    "FamilyName",
+    "Weight",
+    "ItalicAngle",
+    "IsFixedPitch",
+    "FontBBox",
+    "UnderlinePosition",
+    "UnderlineThickness",
+    "Version",
+    "Notice",
+    "EncodingScheme",
+    "CapHeight",
+    "XHeight",
+    "Ascender",
+    "Descender",
+]
+
+
+class error(Exception):
+    pass
+
+
+class AFM(object):
+    _attrs = None
+
+    _keywords = [
+        "StartFontMetrics",
+        "EndFontMetrics",
+        "StartCharMetrics",
+        "EndCharMetrics",
+        "StartKernData",
+        "StartKernPairs",
+        "EndKernPairs",
+        "EndKernData",
+        "StartComposites",
+        "EndComposites",
+    ]
+
+    def __init__(self, path=None):
+        """AFM file reader.
+
+        Instantiating an object with a path name will cause the file to be opened,
+        read, and parsed. Alternatively the path can be left unspecified, and a
+        file can be parsed later with the :meth:`read` method."""
+        self._attrs = {}
+        self._chars = {}
+        self._kerning = {}
+        self._index = {}
+        self._comments = []
+        self._composites = {}
+        if path is not None:
+            self.read(path)
+
+    def read(self, path):
+        """Opens, reads and parses a file."""
+        lines = readlines(path)
+        for line in lines:
+            if not line.strip():
+                continue
+            m = identifierRE.match(line)
+            if m is None:
+                raise error("syntax error in AFM file: " + repr(line))
+
+            pos = m.regs[1][1]
+            word = line[:pos]
+            rest = line[pos:].strip()
+            if word in self._keywords:
+                continue
+            if word == "C":
+                self.parsechar(rest)
+            elif word == "KPX":
+                self.parsekernpair(rest)
+            elif word == "CC":
+                self.parsecomposite(rest)
+            else:
+                self.parseattr(word, rest)
+
+    def parsechar(self, rest):
+        m = charRE.match(rest)
+        if m is None:
+            raise error("syntax error in AFM file: " + repr(rest))
+        things = []
+        for fr, to in m.regs[1:]:
+            things.append(rest[fr:to])
+        charname = things[2]
+        del things[2]
+        charnum, width, l, b, r, t = (int(thing) for thing in things)
+        self._chars[charname] = charnum, width, (l, b, r, t)
+
+    def parsekernpair(self, rest):
+        m = kernRE.match(rest)
+        if m is None:
+            raise error("syntax error in AFM file: " + repr(rest))
+        things = []
+        for fr, to in m.regs[1:]:
+            things.append(rest[fr:to])
+        leftchar, rightchar, value = things
+        value = int(value)
+        self._kerning[(leftchar, rightchar)] = value
+
+    def parseattr(self, word, rest):
+        if word == "FontBBox":
+            l, b, r, t = [int(thing) for thing in rest.split()]
+            self._attrs[word] = l, b, r, t
+        elif word == "Comment":
+            self._comments.append(rest)
+        else:
+            try:
+                value = int(rest)
+            except (ValueError, OverflowError):
+                self._attrs[word] = rest
+            else:
+                self._attrs[word] = value
+
+    def parsecomposite(self, rest):
+        m = compositeRE.match(rest)
+        if m is None:
+            raise error("syntax error in AFM file: " + repr(rest))
+        charname = m.group(1)
+        ncomponents = int(m.group(2))
+        rest = rest[m.regs[0][1] :]
+        components = []
+        while True:
+            m = componentRE.match(rest)
+            if m is None:
+                raise error("syntax error in AFM file: " + repr(rest))
+            basechar = m.group(1)
+            xoffset = int(m.group(2))
+            yoffset = int(m.group(3))
+            components.append((basechar, xoffset, yoffset))
+            rest = rest[m.regs[0][1] :]
+            if not rest:
+                break
+        assert len(components) == ncomponents
+        self._composites[charname] = components
+
+    def write(self, path, sep="\r"):
+        """Writes out an AFM font to the given path."""
+        import time
+
+        lines = [
+            "StartFontMetrics 2.0",
+            "Comment Generated by afmLib; at %s"
+            % (time.strftime("%m/%d/%Y %H:%M:%S", time.localtime(time.time()))),
+        ]
+
+        # write comments, assuming (possibly wrongly!) they should
+        # all appear at the top
+        for comment in self._comments:
+            lines.append("Comment " + comment)
+
+        # write attributes, first the ones we know about, in
+        # a preferred order
+        attrs = self._attrs
+        for attr in preferredAttributeOrder:
+            if attr in attrs:
+                value = attrs[attr]
+                if attr == "FontBBox":
+                    value = "%s %s %s %s" % value
+                lines.append(attr + " " + str(value))
+        # then write the attributes we don't know about,
+        # in alphabetical order
+        items = sorted(attrs.items())
+        for attr, value in items:
+            if attr in preferredAttributeOrder:
+                continue
+            lines.append(attr + " " + str(value))
+
+        # write char metrics
+        lines.append("StartCharMetrics " + repr(len(self._chars)))
+        items = [
+            (charnum, (charname, width, box))
+            for charname, (charnum, width, box) in self._chars.items()
+        ]
+
+        def myKey(a):
+            """Custom key function to make sure unencoded chars (-1)
+            end up at the end of the list after sorting."""
+            if a[0] == -1:
+                a = (0xFFFF,) + a[1:]  # 0xffff is an arbitrary large number
+            return a
+
+        items.sort(key=myKey)
+
+        for charnum, (charname, width, (l, b, r, t)) in items:
+            lines.append(
+                "C %d ; WX %d ; N %s ; B %d %d %d %d ;"
+                % (charnum, width, charname, l, b, r, t)
+            )
+        lines.append("EndCharMetrics")
+
+        # write kerning info
+        lines.append("StartKernData")
+        lines.append("StartKernPairs " + repr(len(self._kerning)))
+        items = sorted(self._kerning.items())
+        for (leftchar, rightchar), value in items:
+            lines.append("KPX %s %s %d" % (leftchar, rightchar, value))
+        lines.append("EndKernPairs")
+        lines.append("EndKernData")
+
+        if self._composites:
+            composites = sorted(self._composites.items())
+            lines.append("StartComposites %s" % len(self._composites))
+            for charname, components in composites:
+                line = "CC %s %s ;" % (charname, len(components))
+                for basechar, xoffset, yoffset in components:
+                    line = line + " PCC %s %s %s ;" % (basechar, xoffset, yoffset)
+                lines.append(line)
+            lines.append("EndComposites")
+
+        lines.append("EndFontMetrics")
+
+        writelines(path, lines, sep)
+
+    def has_kernpair(self, pair):
+        """Returns `True` if the given glyph pair (specified as a tuple) exists
+        in the kerning dictionary."""
+        return pair in self._kerning
+
+    def kernpairs(self):
+        """Returns a list of all kern pairs in the kerning dictionary."""
+        return list(self._kerning.keys())
+
+    def has_char(self, char):
+        """Returns `True` if the given glyph exists in the font."""
+        return char in self._chars
+
+    def chars(self):
+        """Returns a list of all glyph names in the font."""
+        return list(self._chars.keys())
+
+    def comments(self):
+        """Returns all comments from the file."""
+        return self._comments
+
+    def addComment(self, comment):
+        """Adds a new comment to the file."""
+        self._comments.append(comment)
+
+    def addComposite(self, glyphName, components):
+        """Specifies that the glyph `glyphName` is made up of the given components.
+        The components list should be of the following form::
+
+                [
+                        (glyphname, xOffset, yOffset),
+                        ...
+                ]
+
+        """
+        self._composites[glyphName] = components
+
+    def __getattr__(self, attr):
+        if attr in self._attrs:
+            return self._attrs[attr]
+        else:
+            raise AttributeError(attr)
+
+    def __setattr__(self, attr, value):
+        # all attrs *not* starting with "_" are consider to be AFM keywords
+        if attr[:1] == "_":
+            self.__dict__[attr] = value
+        else:
+            self._attrs[attr] = value
+
+    def __delattr__(self, attr):
+        # all attrs *not* starting with "_" are consider to be AFM keywords
+        if attr[:1] == "_":
+            try:
+                del self.__dict__[attr]
+            except KeyError:
+                raise AttributeError(attr)
+        else:
+            try:
+                del self._attrs[attr]
+            except KeyError:
+                raise AttributeError(attr)
+
+    def __getitem__(self, key):
+        if isinstance(key, tuple):
+            # key is a tuple, return the kernpair
+            return self._kerning[key]
+        else:
+            # return the metrics instead
+            return self._chars[key]
+
+    def __setitem__(self, key, value):
+        if isinstance(key, tuple):
+            # key is a tuple, set kernpair
+            self._kerning[key] = value
+        else:
+            # set char metrics
+            self._chars[key] = value
+
+    def __delitem__(self, key):
+        if isinstance(key, tuple):
+            # key is a tuple, del kernpair
+            del self._kerning[key]
+        else:
+            # del char metrics
+            del self._chars[key]
+
+    def __repr__(self):
+        if hasattr(self, "FullName"):
+            return "<AFM object for %s>" % self.FullName
+        else:
+            return "<AFM object at %x>" % id(self)
+
+
+def readlines(path):
+    with open(path, "r", encoding="ascii") as f:
+        data = f.read()
+    return data.splitlines()
+
+
+def writelines(path, lines, sep="\r"):
+    with open(path, "w", encoding="ascii", newline=sep) as f:
+        f.write("\n".join(lines) + "\n")
+
+
+if __name__ == "__main__":
+    import EasyDialogs
+
+    path = EasyDialogs.AskFileForOpen()
+    if path:
+        afm = AFM(path)
+        char = "A"
+        if afm.has_char(char):
+            print(afm[char])  # print charnum, width and boundingbox
+        pair = ("A", "V")
+        if afm.has_kernpair(pair):
+            print(afm[pair])  # print kerning value for pair
+        print(afm.Version)  # various other afm entries have become attributes
+        print(afm.Weight)
+        # afm.comments() returns a list of all Comment lines found in the AFM
+        print(afm.comments())
+        # print afm.chars()
+        # print afm.kernpairs()
+        print(afm)
+        afm.write(path + ".muck")

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/annotations.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Iterable, Optional, TypeVar, Union
+from collections.abc import Callable, Sequence
+from fontTools.misc.filesystem._base import FS
+from os import PathLike
+from xml.etree.ElementTree import Element as ElementTreeElement
+
+if TYPE_CHECKING:
+    from fontTools.ufoLib import UFOFormatVersion
+    from fontTools.ufoLib.glifLib import GLIFFormatVersion
+    from lxml.etree import _Element as LxmlElement
+
+
+T = TypeVar("T")  # Generic type
+K = TypeVar("K")  # Generic dict key type
+V = TypeVar("V")  # Generic dict value type
+
+GlyphNameToFileNameFunc = Optional[Callable[[str, set[str]], str]]
+ElementType = Union[ElementTreeElement, "LxmlElement"]
+FormatVersion = Union[int, tuple[int, int]]
+FormatVersions = Optional[Iterable[FormatVersion]]
+GLIFFormatVersionInput = Optional[Union[int, tuple[int, int], "GLIFFormatVersion"]]
+UFOFormatVersionInput = Optional[Union[int, tuple[int, int], "UFOFormatVersion"]]
+IntFloat = Union[int, float]
+KerningPair = tuple[str, str]
+KerningDict = dict[KerningPair, IntFloat]
+KerningGroups = dict[str, Sequence[str]]
+KerningNested = dict[str, dict[str, IntFloat]]
+PathStr = Union[str, PathLike[str]]
+PathOrFS = Union[PathStr, FS]

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/colorLib/builder.py

@@ -0,0 +1,664 @@
+"""
+colorLib.builder: Build COLR/CPAL tables from scratch
+
+"""
+
+import collections
+import copy
+import enum
+from functools import partial
+from math import ceil, log
+from typing import (
+    Any,
+    Dict,
+    Generator,
+    Iterable,
+    List,
+    Mapping,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+)
+from fontTools.misc.arrayTools import intRect
+from fontTools.misc.fixedTools import fixedToFloat
+from fontTools.misc.treeTools import build_n_ary_tree
+from fontTools.ttLib.tables import C_O_L_R_
+from fontTools.ttLib.tables import C_P_A_L_
+from fontTools.ttLib.tables import _n_a_m_e
+from fontTools.ttLib.tables import otTables as ot
+from fontTools.ttLib.tables.otTables import ExtendMode, CompositeMode
+from .errors import ColorLibError
+from .geometry import round_start_circle_stable_containment
+from .table_builder import BuildCallback, TableBuilder
+
+
+# TODO move type aliases to colorLib.types?
+T = TypeVar("T")
+_Kwargs = Mapping[str, Any]
+_PaintInput = Union[int, _Kwargs, ot.Paint, Tuple[str, "_PaintInput"]]
+_PaintInputList = Sequence[_PaintInput]
+_ColorGlyphsDict = Dict[str, Union[_PaintInputList, _PaintInput]]
+_ColorGlyphsV0Dict = Dict[str, Sequence[Tuple[str, int]]]
+_ClipBoxInput = Union[
+    Tuple[int, int, int, int, int],  # format 1, variable
+    Tuple[int, int, int, int],  # format 0, non-variable
+    ot.ClipBox,
+]
+
+
+MAX_PAINT_COLR_LAYER_COUNT = 255
+_DEFAULT_ALPHA = 1.0
+_MAX_REUSE_LEN = 32
+
+
+def _beforeBuildPaintRadialGradient(paint, source):
+    x0 = source["x0"]
+    y0 = source["y0"]
+    r0 = source["r0"]
+    x1 = source["x1"]
+    y1 = source["y1"]
+    r1 = source["r1"]
+
+    # TODO apparently no builder_test confirms this works (?)
+
+    # avoid abrupt change after rounding when c0 is near c1's perimeter
+    c = round_start_circle_stable_containment((x0, y0), r0, (x1, y1), r1)
+    x0, y0 = c.centre
+    r0 = c.radius
+
+    # update source to ensure paint is built with corrected values
+    source["x0"] = x0
+    source["y0"] = y0
+    source["r0"] = r0
+    source["x1"] = x1
+    source["y1"] = y1
+    source["r1"] = r1
+
+    return paint, source
+
+
+def _defaultColorStop():
+    colorStop = ot.ColorStop()
+    colorStop.Alpha = _DEFAULT_ALPHA
+    return colorStop
+
+
+def _defaultVarColorStop():
+    colorStop = ot.VarColorStop()
+    colorStop.Alpha = _DEFAULT_ALPHA
+    return colorStop
+
+
+def _defaultColorLine():
+    colorLine = ot.ColorLine()
+    colorLine.Extend = ExtendMode.PAD
+    return colorLine
+
+
+def _defaultVarColorLine():
+    colorLine = ot.VarColorLine()
+    colorLine.Extend = ExtendMode.PAD
+    return colorLine
+
+
+def _defaultPaintSolid():
+    paint = ot.Paint()
+    paint.Alpha = _DEFAULT_ALPHA
+    return paint
+
+
+def _buildPaintCallbacks():
+    return {
+        (
+            BuildCallback.BEFORE_BUILD,
+            ot.Paint,
+            ot.PaintFormat.PaintRadialGradient,
+        ): _beforeBuildPaintRadialGradient,
+        (
+            BuildCallback.BEFORE_BUILD,
+            ot.Paint,
+            ot.PaintFormat.PaintVarRadialGradient,
+        ): _beforeBuildPaintRadialGradient,
+        (BuildCallback.CREATE_DEFAULT, ot.ColorStop): _defaultColorStop,
+        (BuildCallback.CREATE_DEFAULT, ot.VarColorStop): _defaultVarColorStop,
+        (BuildCallback.CREATE_DEFAULT, ot.ColorLine): _defaultColorLine,
+        (BuildCallback.CREATE_DEFAULT, ot.VarColorLine): _defaultVarColorLine,
+        (
+            BuildCallback.CREATE_DEFAULT,
+            ot.Paint,
+            ot.PaintFormat.PaintSolid,
+        ): _defaultPaintSolid,
+        (
+            BuildCallback.CREATE_DEFAULT,
+            ot.Paint,
+            ot.PaintFormat.PaintVarSolid,
+        ): _defaultPaintSolid,
+    }
+
+
+def populateCOLRv0(
+    table: ot.COLR,
+    colorGlyphsV0: _ColorGlyphsV0Dict,
+    glyphMap: Optional[Mapping[str, int]] = None,
+):
+    """Build v0 color layers and add to existing COLR table.
+
+    Args:
+        table: a raw ``otTables.COLR()`` object (not ttLib's ``table_C_O_L_R_``).
+        colorGlyphsV0: map of base glyph names to lists of (layer glyph names,
+            color palette index) tuples. Can be empty.
+        glyphMap: a map from glyph names to glyph indices, as returned from
+            ``TTFont.getReverseGlyphMap()``, to optionally sort base records by GID.
+    """
+    if glyphMap is not None:
+        colorGlyphItems = sorted(
+            colorGlyphsV0.items(), key=lambda item: glyphMap[item[0]]
+        )
+    else:
+        colorGlyphItems = colorGlyphsV0.items()
+    baseGlyphRecords = []
+    layerRecords = []
+    for baseGlyph, layers in colorGlyphItems:
+        baseRec = ot.BaseGlyphRecord()
+        baseRec.BaseGlyph = baseGlyph
+        baseRec.FirstLayerIndex = len(layerRecords)
+        baseRec.NumLayers = len(layers)
+        baseGlyphRecords.append(baseRec)
+
+        for layerGlyph, paletteIndex in layers:
+            layerRec = ot.LayerRecord()
+            layerRec.LayerGlyph = layerGlyph
+            layerRec.PaletteIndex = paletteIndex
+            layerRecords.append(layerRec)
+
+    table.BaseGlyphRecordArray = table.LayerRecordArray = None
+    if baseGlyphRecords:
+        table.BaseGlyphRecordArray = ot.BaseGlyphRecordArray()
+        table.BaseGlyphRecordArray.BaseGlyphRecord = baseGlyphRecords
+    if layerRecords:
+        table.LayerRecordArray = ot.LayerRecordArray()
+        table.LayerRecordArray.LayerRecord = layerRecords
+    table.BaseGlyphRecordCount = len(baseGlyphRecords)
+    table.LayerRecordCount = len(layerRecords)
+
+
+def buildCOLR(
+    colorGlyphs: _ColorGlyphsDict,
+    version: Optional[int] = None,
+    *,
+    glyphMap: Optional[Mapping[str, int]] = None,
+    varStore: Optional[ot.VarStore] = None,
+    varIndexMap: Optional[ot.DeltaSetIndexMap] = None,
+    clipBoxes: Optional[Dict[str, _ClipBoxInput]] = None,
+    allowLayerReuse: bool = True,
+) -> C_O_L_R_.table_C_O_L_R_:
+    """Build COLR table from color layers mapping.
+
+    Args:
+
+        colorGlyphs: map of base glyph name to, either list of (layer glyph name,
+            color palette index) tuples for COLRv0; or a single ``Paint`` (dict) or
+            list of ``Paint`` for COLRv1.
+        version: the version of COLR table. If None, the version is determined
+            by the presence of COLRv1 paints or variation data (varStore), which
+            require version 1; otherwise, if all base glyphs use only simple color
+            layers, version 0 is used.
+        glyphMap: a map from glyph names to glyph indices, as returned from
+            TTFont.getReverseGlyphMap(), to optionally sort base records by GID.
+        varStore: Optional ItemVarationStore for deltas associated with v1 layer.
+        varIndexMap: Optional DeltaSetIndexMap for deltas associated with v1 layer.
+        clipBoxes: Optional map of base glyph name to clip box 4- or 5-tuples:
+            (xMin, yMin, xMax, yMax) or (xMin, yMin, xMax, yMax, varIndexBase).
+
+    Returns:
+        A new COLR table.
+    """
+    self = C_O_L_R_.table_C_O_L_R_()
+
+    if varStore is not None and version == 0:
+        raise ValueError("Can't add VarStore to COLRv0")
+
+    if version in (None, 0) and not varStore:
+        # split color glyphs into v0 and v1 and encode separately
+        colorGlyphsV0, colorGlyphsV1 = _split_color_glyphs_by_version(colorGlyphs)
+        if version == 0 and colorGlyphsV1:
+            raise ValueError("Can't encode COLRv1 glyphs in COLRv0")
+    else:
+        # unless explicitly requested for v1 or have variations, in which case
+        # we encode all color glyph as v1
+        colorGlyphsV0, colorGlyphsV1 = {}, colorGlyphs
+
+    colr = ot.COLR()
+
+    populateCOLRv0(colr, colorGlyphsV0, glyphMap)
+
+    colr.LayerList, colr.BaseGlyphList = buildColrV1(
+        colorGlyphsV1,
+        glyphMap,
+        allowLayerReuse=allowLayerReuse,
+    )
+
+    if version is None:
+        version = 1 if (varStore or colorGlyphsV1) else 0
+    elif version not in (0, 1):
+        raise NotImplementedError(version)
+    self.version = colr.Version = version
+
+    if version == 0:
+        self.ColorLayers = self._decompileColorLayersV0(colr)
+    else:
+        colr.ClipList = buildClipList(clipBoxes) if clipBoxes else None
+        colr.VarIndexMap = varIndexMap
+        colr.VarStore = varStore
+        self.table = colr
+
+    return self
+
+
+def buildClipList(clipBoxes: Dict[str, _ClipBoxInput]) -> ot.ClipList:
+    clipList = ot.ClipList()
+    clipList.Format = 1
+    clipList.clips = {name: buildClipBox(box) for name, box in clipBoxes.items()}
+    return clipList
+
+
+def buildClipBox(clipBox: _ClipBoxInput) -> ot.ClipBox:
+    if isinstance(clipBox, ot.ClipBox):
+        return clipBox
+    n = len(clipBox)
+    clip = ot.ClipBox()
+    if n not in (4, 5):
+        raise ValueError(f"Invalid ClipBox: expected 4 or 5 values, found {n}")
+    clip.xMin, clip.yMin, clip.xMax, clip.yMax = intRect(clipBox[:4])
+    clip.Format = int(n == 5) + 1
+    if n == 5:
+        clip.VarIndexBase = int(clipBox[4])
+    return clip
+
+
+class ColorPaletteType(enum.IntFlag):
+    USABLE_WITH_LIGHT_BACKGROUND = 0x0001
+    USABLE_WITH_DARK_BACKGROUND = 0x0002
+
+    @classmethod
+    def _missing_(cls, value):
+        # enforce reserved bits
+        if isinstance(value, int) and (value < 0 or value & 0xFFFC != 0):
+            raise ValueError(f"{value} is not a valid {cls.__name__}")
+        return super()._missing_(value)
+
+
+# None, 'abc' or {'en': 'abc', 'de': 'xyz'}
+_OptionalLocalizedString = Union[None, str, Dict[str, str]]
+
+
+def buildPaletteLabels(
+    labels: Iterable[_OptionalLocalizedString], nameTable: _n_a_m_e.table__n_a_m_e
+) -> List[Optional[int]]:
+    return [
+        (
+            nameTable.addMultilingualName(l, mac=False)
+            if isinstance(l, dict)
+            else (
+                C_P_A_L_.table_C_P_A_L_.NO_NAME_ID
+                if l is None
+                else nameTable.addMultilingualName({"en": l}, mac=False)
+            )
+        )
+        for l in labels
+    ]
+
+
+def buildCPAL(
+    palettes: Sequence[Sequence[Tuple[float, float, float, float]]],
+    paletteTypes: Optional[Sequence[ColorPaletteType]] = None,
+    paletteLabels: Optional[Sequence[_OptionalLocalizedString]] = None,
+    paletteEntryLabels: Optional[Sequence[_OptionalLocalizedString]] = None,
+    nameTable: Optional[_n_a_m_e.table__n_a_m_e] = None,
+) -> C_P_A_L_.table_C_P_A_L_:
+    """Build CPAL table from list of color palettes.
+
+    Args:
+        palettes: list of lists of colors encoded as tuples of (R, G, B, A) floats
+            in the range [0..1].
+        paletteTypes: optional list of ColorPaletteType, one for each palette.
+        paletteLabels: optional list of palette labels. Each lable can be either:
+            None (no label), a string (for for default English labels), or a
+            localized string (as a dict keyed with BCP47 language codes).
+        paletteEntryLabels: optional list of palette entry labels, one for each
+            palette entry (see paletteLabels).
+        nameTable: optional name table where to store palette and palette entry
+            labels. Required if either paletteLabels or paletteEntryLabels is set.
+
+    Return:
+        A new CPAL v0 or v1 table, if custom palette types or labels are specified.
+    """
+    if len({len(p) for p in palettes}) != 1:
+        raise ColorLibError("color palettes have different lengths")
+
+    if (paletteLabels or paletteEntryLabels) and not nameTable:
+        raise TypeError(
+            "nameTable is required if palette or palette entries have labels"
+        )
+
+    cpal = C_P_A_L_.table_C_P_A_L_()
+    cpal.numPaletteEntries = len(palettes[0])
+
+    cpal.palettes = []
+    for i, palette in enumerate(palettes):
+        colors = []
+        for j, color in enumerate(palette):
+            if not isinstance(color, tuple) or len(color) != 4:
+                raise ColorLibError(
+                    f"In palette[{i}][{j}]: expected (R, G, B, A) tuple, got {color!r}"
+                )
+            if any(v > 1 or v < 0 for v in color):
+                raise ColorLibError(
+                    f"palette[{i}][{j}] has invalid out-of-range [0..1] color: {color!r}"
+                )
+            # input colors are RGBA, CPAL encodes them as BGRA
+            red, green, blue, alpha = color
+            colors.append(
+                C_P_A_L_.Color(*(round(v * 255) for v in (blue, green, red, alpha)))
+            )
+        cpal.palettes.append(colors)
+
+    if any(v is not None for v in (paletteTypes, paletteLabels, paletteEntryLabels)):
+        cpal.version = 1
+
+        if paletteTypes is not None:
+            if len(paletteTypes) != len(palettes):
+                raise ColorLibError(
+                    f"Expected {len(palettes)} paletteTypes, got {len(paletteTypes)}"
+                )
+            cpal.paletteTypes = [ColorPaletteType(t).value for t in paletteTypes]
+        else:
+            cpal.paletteTypes = [C_P_A_L_.table_C_P_A_L_.DEFAULT_PALETTE_TYPE] * len(
+                palettes
+            )
+
+        if paletteLabels is not None:
+            if len(paletteLabels) != len(palettes):
+                raise ColorLibError(
+                    f"Expected {len(palettes)} paletteLabels, got {len(paletteLabels)}"
+                )
+            cpal.paletteLabels = buildPaletteLabels(paletteLabels, nameTable)
+        else:
+            cpal.paletteLabels = [C_P_A_L_.table_C_P_A_L_.NO_NAME_ID] * len(palettes)
+
+        if paletteEntryLabels is not None:
+            if len(paletteEntryLabels) != cpal.numPaletteEntries:
+                raise ColorLibError(
+                    f"Expected {cpal.numPaletteEntries} paletteEntryLabels, "
+                    f"got {len(paletteEntryLabels)}"
+                )
+            cpal.paletteEntryLabels = buildPaletteLabels(paletteEntryLabels, nameTable)
+        else:
+            cpal.paletteEntryLabels = [
+                C_P_A_L_.table_C_P_A_L_.NO_NAME_ID
+            ] * cpal.numPaletteEntries
+    else:
+        cpal.version = 0
+
+    return cpal
+
+
+# COLR v1 tables
+# See draft proposal at: https://github.com/googlefonts/colr-gradients-spec
+
+
+def _is_colrv0_layer(layer: Any) -> bool:
+    # Consider as COLRv0 layer any sequence of length 2 (be it tuple or list) in which
+    # the first element is a str (the layerGlyph) and the second element is an int
+    # (CPAL paletteIndex).
+    # https://github.com/googlefonts/ufo2ft/issues/426
+    try:
+        layerGlyph, paletteIndex = layer
+    except (TypeError, ValueError):
+        return False
+    else:
+        return isinstance(layerGlyph, str) and isinstance(paletteIndex, int)
+
+
+def _split_color_glyphs_by_version(
+    colorGlyphs: _ColorGlyphsDict,
+) -> Tuple[_ColorGlyphsV0Dict, _ColorGlyphsDict]:
+    colorGlyphsV0 = {}
+    colorGlyphsV1 = {}
+    for baseGlyph, layers in colorGlyphs.items():
+        if all(_is_colrv0_layer(l) for l in layers):
+            colorGlyphsV0[baseGlyph] = layers
+        else:
+            colorGlyphsV1[baseGlyph] = layers
+
+    # sanity check
+    assert set(colorGlyphs) == (set(colorGlyphsV0) | set(colorGlyphsV1))
+
+    return colorGlyphsV0, colorGlyphsV1
+
+
+def _reuse_ranges(num_layers: int) -> Generator[Tuple[int, int], None, None]:
+    # TODO feels like something itertools might have already
+    for lbound in range(num_layers):
+        # Reuse of very large #s of layers is relatively unlikely
+        # +2: we want sequences of at least 2
+        # otData handles single-record duplication
+        for ubound in range(
+            lbound + 2, min(num_layers + 1, lbound + 2 + _MAX_REUSE_LEN)
+        ):
+            yield (lbound, ubound)
+
+
+class LayerReuseCache:
+    reusePool: Mapping[Tuple[Any, ...], int]
+    tuples: Mapping[int, Tuple[Any, ...]]
+    keepAlive: List[ot.Paint]  # we need id to remain valid
+
+    def __init__(self):
+        self.reusePool = {}
+        self.tuples = {}
+        self.keepAlive = []
+
+    def _paint_tuple(self, paint: ot.Paint):
+        # start simple, who even cares about cyclic graphs or interesting field types
+        def _tuple_safe(value):
+            if isinstance(value, enum.Enum):
+                return value
+            elif hasattr(value, "__dict__"):
+                return tuple(
+                    (k, _tuple_safe(v)) for k, v in sorted(value.__dict__.items())
+                )
+            elif isinstance(value, collections.abc.MutableSequence):
+                return tuple(_tuple_safe(e) for e in value)
+            return value
+
+        # Cache the tuples for individual Paint instead of the whole sequence
+        # because the seq could be a transient slice
+        result = self.tuples.get(id(paint), None)
+        if result is None:
+            result = _tuple_safe(paint)
+            self.tuples[id(paint)] = result
+            self.keepAlive.append(paint)
+        return result
+
+    def _as_tuple(self, paints: Sequence[ot.Paint]) -> Tuple[Any, ...]:
+        return tuple(self._paint_tuple(p) for p in paints)
+
+    def try_reuse(self, layers: List[ot.Paint]) -> List[ot.Paint]:
+        found_reuse = True
+        while found_reuse:
+            found_reuse = False
+
+            ranges = sorted(
+                _reuse_ranges(len(layers)),
+                key=lambda t: (t[1] - t[0], t[1], t[0]),
+                reverse=True,
+            )
+            for lbound, ubound in ranges:
+                reuse_lbound = self.reusePool.get(
+                    self._as_tuple(layers[lbound:ubound]), -1
+                )
+                if reuse_lbound == -1:
+                    continue
+                new_slice = ot.Paint()
+                new_slice.Format = int(ot.PaintFormat.PaintColrLayers)
+                new_slice.NumLayers = ubound - lbound
+                new_slice.FirstLayerIndex = reuse_lbound
+                layers = layers[:lbound] + [new_slice] + layers[ubound:]
+                found_reuse = True
+                break
+        return layers
+
+    def add(self, layers: List[ot.Paint], first_layer_index: int):
+        for lbound, ubound in _reuse_ranges(len(layers)):
+            self.reusePool[self._as_tuple(layers[lbound:ubound])] = (
+                lbound + first_layer_index
+            )
+
+
+class LayerListBuilder:
+    layers: List[ot.Paint]
+    cache: LayerReuseCache
+    allowLayerReuse: bool
+
+    def __init__(self, *, allowLayerReuse=True):
+        self.layers = []
+        if allowLayerReuse:
+            self.cache = LayerReuseCache()
+        else:
+            self.cache = None
+
+        # We need to intercept construction of PaintColrLayers
+        callbacks = _buildPaintCallbacks()
+        callbacks[
+            (
+                BuildCallback.BEFORE_BUILD,
+                ot.Paint,
+                ot.PaintFormat.PaintColrLayers,
+            )
+        ] = self._beforeBuildPaintColrLayers
+        self.tableBuilder = TableBuilder(callbacks)
+
+    # COLR layers is unusual in that it modifies shared state
+    # so we need a callback into an object
+    def _beforeBuildPaintColrLayers(self, dest, source):
+        # Sketchy gymnastics: a sequence input will have dropped it's layers
+        # into NumLayers; get it back
+        if isinstance(source.get("NumLayers", None), collections.abc.Sequence):
+            layers = source["NumLayers"]
+        else:
+            layers = source["Layers"]
+
+        # Convert maps seqs or whatever into typed objects
+        layers = [self.buildPaint(l) for l in layers]
+
+        # No reason to have a colr layers with just one entry
+        if len(layers) == 1:
+            return layers[0], {}
+
+        if self.cache is not None:
+            # Look for reuse, with preference to longer sequences
+            # This may make the layer list smaller
+            layers = self.cache.try_reuse(layers)
+
+        # The layer list is now final; if it's too big we need to tree it
+        is_tree = len(layers) > MAX_PAINT_COLR_LAYER_COUNT
+        layers = build_n_ary_tree(layers, n=MAX_PAINT_COLR_LAYER_COUNT)
+
+        # We now have a tree of sequences with Paint leaves.
+        # Convert the sequences into PaintColrLayers.
+        def listToColrLayers(layer):
+            if isinstance(layer, collections.abc.Sequence):
+                return self.buildPaint(
+                    {
+                        "Format": ot.PaintFormat.PaintColrLayers,
+                        "Layers": [listToColrLayers(l) for l in layer],
+                    }
+                )
+            return layer
+
+        layers = [listToColrLayers(l) for l in layers]
+
+        # No reason to have a colr layers with just one entry
+        if len(layers) == 1:
+            return layers[0], {}
+
+        paint = ot.Paint()
+        paint.Format = int(ot.PaintFormat.PaintColrLayers)
+        paint.NumLayers = len(layers)
+        paint.FirstLayerIndex = len(self.layers)
+        self.layers.extend(layers)
+
+        # Register our parts for reuse provided we aren't a tree
+        # If we are a tree the leaves registered for reuse and that will suffice
+        if self.cache is not None and not is_tree:
+            self.cache.add(layers, paint.FirstLayerIndex)
+
+        # we've fully built dest; empty source prevents generalized build from kicking in
+        return paint, {}
+
+    def buildPaint(self, paint: _PaintInput) -> ot.Paint:
+        return self.tableBuilder.build(ot.Paint, paint)
+
+    def build(self) -> Optional[ot.LayerList]:
+        if not self.layers:
+            return None
+        layers = ot.LayerList()
+        layers.LayerCount = len(self.layers)
+        layers.Paint = self.layers
+        return layers
+
+
+def buildBaseGlyphPaintRecord(
+    baseGlyph: str, layerBuilder: LayerListBuilder, paint: _PaintInput
+) -> ot.BaseGlyphList:
+    self = ot.BaseGlyphPaintRecord()
+    self.BaseGlyph = baseGlyph
+    self.Paint = layerBuilder.buildPaint(paint)
+    return self
+
+
+def _format_glyph_errors(errors: Mapping[str, Exception]) -> str:
+    lines = []
+    for baseGlyph, error in sorted(errors.items()):
+        lines.append(f"    {baseGlyph} => {type(error).__name__}: {error}")
+    return "\n".join(lines)
+
+
+def buildColrV1(
+    colorGlyphs: _ColorGlyphsDict,
+    glyphMap: Optional[Mapping[str, int]] = None,
+    *,
+    allowLayerReuse: bool = True,
+) -> Tuple[Optional[ot.LayerList], ot.BaseGlyphList]:
+    if glyphMap is not None:
+        colorGlyphItems = sorted(
+            colorGlyphs.items(), key=lambda item: glyphMap[item[0]]
+        )
+    else:
+        colorGlyphItems = colorGlyphs.items()
+
+    errors = {}
+    baseGlyphs = []
+    layerBuilder = LayerListBuilder(allowLayerReuse=allowLayerReuse)
+    for baseGlyph, paint in colorGlyphItems:
+        try:
+            baseGlyphs.append(buildBaseGlyphPaintRecord(baseGlyph, layerBuilder, paint))
+
+        except (ColorLibError, OverflowError, ValueError, TypeError) as e:
+            errors[baseGlyph] = e
+
+    if errors:
+        failed_glyphs = _format_glyph_errors(errors)
+        exc = ColorLibError(f"Failed to build BaseGlyphList:\n{failed_glyphs}")
+        exc.errors = errors
+        raise exc from next(iter(errors.values()))
+
+    layers = layerBuilder.build()
+    glyphs = ot.BaseGlyphList()
+    glyphs.BaseGlyphCount = len(baseGlyphs)
+    glyphs.BaseGlyphPaintRecord = baseGlyphs
+    return (layers, glyphs)

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/colorLib/unbuilder.py

@@ -0,0 +1,81 @@
+from fontTools.ttLib.tables import otTables as ot
+from .table_builder import TableUnbuilder
+
+
+def unbuildColrV1(layerList, baseGlyphList):
+    layers = []
+    if layerList:
+        layers = layerList.Paint
+    unbuilder = LayerListUnbuilder(layers)
+    return {
+        rec.BaseGlyph: unbuilder.unbuildPaint(rec.Paint)
+        for rec in baseGlyphList.BaseGlyphPaintRecord
+    }
+
+
+def _flatten_layers(lst):
+    for paint in lst:
+        if paint["Format"] == ot.PaintFormat.PaintColrLayers:
+            yield from _flatten_layers(paint["Layers"])
+        else:
+            yield paint
+
+
+class LayerListUnbuilder:
+    def __init__(self, layers):
+        self.layers = layers
+
+        callbacks = {
+            (
+                ot.Paint,
+                ot.PaintFormat.PaintColrLayers,
+            ): self._unbuildPaintColrLayers,
+        }
+        self.tableUnbuilder = TableUnbuilder(callbacks)
+
+    def unbuildPaint(self, paint):
+        assert isinstance(paint, ot.Paint)
+        return self.tableUnbuilder.unbuild(paint)
+
+    def _unbuildPaintColrLayers(self, source):
+        assert source["Format"] == ot.PaintFormat.PaintColrLayers
+
+        layers = list(
+            _flatten_layers(
+                [
+                    self.unbuildPaint(childPaint)
+                    for childPaint in self.layers[
+                        source["FirstLayerIndex"] : source["FirstLayerIndex"]
+                        + source["NumLayers"]
+                    ]
+                ]
+            )
+        )
+
+        if len(layers) == 1:
+            return layers[0]
+
+        return {"Format": source["Format"], "Layers": layers}
+
+
+if __name__ == "__main__":
+    from pprint import pprint
+    import sys
+    from fontTools.ttLib import TTFont
+
+    try:
+        fontfile = sys.argv[1]
+    except IndexError:
+        sys.exit("usage: fonttools colorLib.unbuilder FONTFILE")
+
+    font = TTFont(fontfile)
+    colr = font["COLR"]
+    if colr.version < 1:
+        sys.exit(f"error: No COLR table version=1 found in {fontfile}")
+
+    colorGlyphs = unbuildColrV1(
+        colr.table.LayerList,
+        colr.table.BaseGlyphList,
+    )
+
+    pprint(colorGlyphs)

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/config/__init__.py

@@ -0,0 +1,90 @@
+"""
+Define all configuration options that can affect the working of fontTools
+modules. E.g. optimization levels of varLib IUP, otlLib GPOS compression level,
+etc. If this file gets too big, split it into smaller files per-module.
+
+An instance of the Config class can be attached to a TTFont object, so that
+the various modules can access their configuration options from it.
+"""
+
+from textwrap import dedent
+
+from fontTools.misc.configTools import *
+
+
+class Config(AbstractConfig):
+    options = Options()
+
+
+OPTIONS = Config.options
+
+
+Config.register_option(
+    name="fontTools.otlLib.optimize.gpos:COMPRESSION_LEVEL",
+    help=dedent(
+        """\
+        GPOS Lookup type 2 (PairPos) compression level:
+            0 = do not attempt to compact PairPos lookups;
+            1 to 8 = create at most 1 to 8 new subtables for each existing
+                subtable, provided that it would yield a 50%% file size saving;
+            9 = create as many new subtables as needed to yield a file size saving.
+        Default: 0.
+
+        This compaction aims to save file size, by splitting large class
+        kerning subtables (Format 2) that contain many zero values into
+        smaller and denser subtables. It's a trade-off between the overhead
+        of several subtables versus the sparseness of one big subtable.
+
+        See the pull request: https://github.com/fonttools/fonttools/pull/2326
+        """
+    ),
+    default=0,
+    parse=int,
+    validate=lambda v: v in range(10),
+)
+
+Config.register_option(
+    name="fontTools.ttLib.tables.otBase:USE_HARFBUZZ_REPACKER",
+    help=dedent(
+        """\
+        FontTools tries to use the HarfBuzz Repacker to serialize GPOS/GSUB tables
+        if the uharfbuzz python bindings are importable, otherwise falls back to its
+        slower, less efficient serializer. Set to False to always use the latter.
+        Set to True to explicitly request the HarfBuzz Repacker (will raise an
+        error if uharfbuzz cannot be imported).
+        """
+    ),
+    default=None,
+    parse=Option.parse_optional_bool,
+    validate=Option.validate_optional_bool,
+)
+
+Config.register_option(
+    name="fontTools.otlLib.builder:WRITE_GPOS7",
+    help=dedent(
+        """\
+        macOS before 13.2 didn’t support GPOS LookupType 7 (non-chaining
+        ContextPos lookups), so FontTools.otlLib.builder disables a file size
+        optimisation that would use LookupType 7 instead of 8 when there is no
+        chaining (no prefix or suffix). Set to True to enable the optimization.
+        """
+    ),
+    default=False,
+    parse=Option.parse_optional_bool,
+    validate=Option.validate_optional_bool,
+)
+
+Config.register_option(
+    name="fontTools.ttLib:OPTIMIZE_FONT_SPEED",
+    help=dedent(
+        """\
+        Enable optimizations that prioritize speed over file size. This
+        mainly affects how glyf table and gvar / VARC tables are compiled.
+        The produced fonts will be larger, but rendering performance will
+        be improved with HarfBuzz and other text layout engines.
+        """
+    ),
+    default=False,
+    parse=Option.parse_optional_bool,
+    validate=Option.validate_optional_bool,
+)

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/cu2qu/__init__.py

@@ -0,0 +1,15 @@
+# Copyright 2016 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .cu2qu import *

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/cu2qu/__main__.py

@@ -0,0 +1,6 @@
+import sys
+from .cli import _main as main
+
+
+if __name__ == "__main__":
+    sys.exit(main())

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/cu2qu/benchmark.py

@@ -0,0 +1,54 @@
+"""Benchmark the cu2qu algorithm performance."""
+
+from .cu2qu import *
+import random
+import timeit
+
+MAX_ERR = 0.05
+
+
+def generate_curve():
+    return [
+        tuple(float(random.randint(0, 2048)) for coord in range(2))
+        for point in range(4)
+    ]
+
+
+def setup_curve_to_quadratic():
+    return generate_curve(), MAX_ERR
+
+
+def setup_curves_to_quadratic():
+    num_curves = 3
+    return ([generate_curve() for curve in range(num_curves)], [MAX_ERR] * num_curves)
+
+
+def run_benchmark(module, function, setup_suffix="", repeat=5, number=1000):
+    setup_func = "setup_" + function
+    if setup_suffix:
+        print("%s with %s:" % (function, setup_suffix), end="")
+        setup_func += "_" + setup_suffix
+    else:
+        print("%s:" % function, end="")
+
+    def wrapper(function, setup_func):
+        function = globals()[function]
+        setup_func = globals()[setup_func]
+
+        def wrapped():
+            return function(*setup_func())
+
+        return wrapped
+
+    results = timeit.repeat(wrapper(function, setup_func), repeat=repeat, number=number)
+    print("\t%5.1fus" % (min(results) * 1000000.0 / number))
+
+
+def main():
+    run_benchmark("cu2qu", "curve_to_quadratic")
+    run_benchmark("cu2qu", "curves_to_quadratic")
+
+
+if __name__ == "__main__":
+    random.seed(1)
+    main()

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/cu2qu/cli.py

@@ -0,0 +1,198 @@
+import os
+import argparse
+import logging
+import shutil
+import multiprocessing as mp
+from contextlib import closing
+from functools import partial
+
+import fontTools
+from .ufo import font_to_quadratic, fonts_to_quadratic
+
+ufo_module = None
+try:
+    import ufoLib2 as ufo_module
+except ImportError:
+    try:
+        import defcon as ufo_module
+    except ImportError as e:
+        pass
+
+
+logger = logging.getLogger("fontTools.cu2qu")
+
+
+def _cpu_count():
+    try:
+        return mp.cpu_count()
+    except NotImplementedError:  # pragma: no cover
+        return 1
+
+
+def open_ufo(path):
+    if hasattr(ufo_module.Font, "open"):  # ufoLib2
+        return ufo_module.Font.open(path)
+    return ufo_module.Font(path)  # defcon
+
+
+def _font_to_quadratic(input_path, output_path=None, **kwargs):
+    ufo = open_ufo(input_path)
+    logger.info("Converting curves for %s", input_path)
+    if font_to_quadratic(ufo, **kwargs):
+        logger.info("Saving %s", output_path)
+        if output_path:
+            ufo.save(output_path)
+        else:
+            ufo.save()  # save in-place
+    elif output_path:
+        _copytree(input_path, output_path)
+
+
+def _samepath(path1, path2):
+    # TODO on python3+, there's os.path.samefile
+    path1 = os.path.normcase(os.path.abspath(os.path.realpath(path1)))
+    path2 = os.path.normcase(os.path.abspath(os.path.realpath(path2)))
+    return path1 == path2
+
+
+def _copytree(input_path, output_path):
+    if _samepath(input_path, output_path):
+        logger.debug("input and output paths are the same file; skipped copy")
+        return
+    if os.path.exists(output_path):
+        shutil.rmtree(output_path)
+    shutil.copytree(input_path, output_path)
+
+
+def _main(args=None):
+    """Convert a UFO font from cubic to quadratic curves"""
+    parser = argparse.ArgumentParser(prog="cu2qu")
+    parser.add_argument("--version", action="version", version=fontTools.__version__)
+    parser.add_argument(
+        "infiles",
+        nargs="+",
+        metavar="INPUT",
+        help="one or more input UFO source file(s).",
+    )
+    parser.add_argument("-v", "--verbose", action="count", default=0)
+    parser.add_argument(
+        "-e",
+        "--conversion-error",
+        type=float,
+        metavar="ERROR",
+        default=None,
+        help="maxiumum approximation error measured in EM (default: 0.001)",
+    )
+    parser.add_argument(
+        "-m",
+        "--mixed",
+        default=False,
+        action="store_true",
+        help="whether to used mixed quadratic and cubic curves",
+    )
+    parser.add_argument(
+        "--keep-direction",
+        dest="reverse_direction",
+        action="store_false",
+        help="do not reverse the contour direction",
+    )
+
+    mode_parser = parser.add_mutually_exclusive_group()
+    mode_parser.add_argument(
+        "-i",
+        "--interpolatable",
+        action="store_true",
+        help="whether curve conversion should keep interpolation compatibility",
+    )
+    mode_parser.add_argument(
+        "-j",
+        "--jobs",
+        type=int,
+        nargs="?",
+        default=1,
+        const=_cpu_count(),
+        metavar="N",
+        help="Convert using N multiple processes (default: %(default)s)",
+    )
+
+    output_parser = parser.add_mutually_exclusive_group()
+    output_parser.add_argument(
+        "-o",
+        "--output-file",
+        default=None,
+        metavar="OUTPUT",
+        help=(
+            "output filename for the converted UFO. By default fonts are "
+            "modified in place. This only works with a single input."
+        ),
+    )
+    output_parser.add_argument(
+        "-d",
+        "--output-dir",
+        default=None,
+        metavar="DIRECTORY",
+        help="output directory where to save converted UFOs",
+    )
+
+    options = parser.parse_args(args)
+
+    if ufo_module is None:
+        parser.error("Either ufoLib2 or defcon are required to run this script.")
+
+    if not options.verbose:
+        level = "WARNING"
+    elif options.verbose == 1:
+        level = "INFO"
+    else:
+        level = "DEBUG"
+    logging.basicConfig(level=level)
+
+    if len(options.infiles) > 1 and options.output_file:
+        parser.error("-o/--output-file can't be used with multile inputs")
+
+    if options.output_dir:
+        output_dir = options.output_dir
+        if not os.path.exists(output_dir):
+            os.mkdir(output_dir)
+        elif not os.path.isdir(output_dir):
+            parser.error("'%s' is not a directory" % output_dir)
+        output_paths = [
+            os.path.join(output_dir, os.path.basename(p)) for p in options.infiles
+        ]
+    elif options.output_file:
+        output_paths = [options.output_file]
+    else:
+        # save in-place
+        output_paths = [None] * len(options.infiles)
+
+    kwargs = dict(
+        dump_stats=options.verbose > 0,
+        max_err_em=options.conversion_error,
+        reverse_direction=options.reverse_direction,
+        all_quadratic=False if options.mixed else True,
+    )
+
+    if options.interpolatable:
+        logger.info("Converting curves compatibly")
+        ufos = [open_ufo(infile) for infile in options.infiles]
+        if fonts_to_quadratic(ufos, **kwargs):
+            for ufo, output_path in zip(ufos, output_paths):
+                logger.info("Saving %s", output_path)
+                if output_path:
+                    ufo.save(output_path)
+                else:
+                    ufo.save()
+        else:
+            for input_path, output_path in zip(options.infiles, output_paths):
+                if output_path:
+                    _copytree(input_path, output_path)
+    else:
+        jobs = min(len(options.infiles), options.jobs) if options.jobs > 1 else 1
+        if jobs > 1:
+            func = partial(_font_to_quadratic, **kwargs)
+            logger.info("Running %d parallel processes", jobs)
+            with closing(mp.Pool(jobs)) as pool:
+                pool.starmap(func, zip(options.infiles, output_paths))
+        else:
+            for input_path, output_path in zip(options.infiles, output_paths):
+                _font_to_quadratic(input_path, output_path, **kwargs)

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/cu2qu/cu2qu.py

@@ -0,0 +1,563 @@
+# cython: language_level=3
+# distutils: define_macros=CYTHON_TRACE_NOGIL=1
+
+# Copyright 2015 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+try:
+    import cython
+except (AttributeError, ImportError):
+    # if cython not installed, use mock module with no-op decorators and types
+    from fontTools.misc import cython
+COMPILED = cython.compiled
+
+import math
+
+from .errors import Error as Cu2QuError, ApproxNotFoundError
+
+
+__all__ = ["curve_to_quadratic", "curves_to_quadratic"]
+
+MAX_N = 100
+
+NAN = float("NaN")
+
+
+@cython.cfunc
+@cython.inline
+@cython.returns(cython.double)
+@cython.locals(v1=cython.complex, v2=cython.complex, result=cython.double)
+def dot(v1, v2):
+    """Return the dot product of two vectors.
+
+    Args:
+        v1 (complex): First vector.
+        v2 (complex): Second vector.
+
+    Returns:
+        double: Dot product.
+    """
+    result = (v1 * v2.conjugate()).real
+    # When vectors are perpendicular (i.e. dot product is 0), the above expression may
+    # yield slightly different results when running in pure Python vs C/Cython,
+    # both of which are correct within IEEE-754 floating-point precision.
+    # It's probably due to the different order of operations and roundings in each
+    # implementation. Because we are using the result in a denominator and catching
+    # ZeroDivisionError (see `calc_intersect`), it's best to normalize the result here.
+    if abs(result) < 1e-15:
+        result = 0.0
+    return result
+
+
+@cython.cfunc
+@cython.locals(z=cython.complex, den=cython.double)
+@cython.locals(zr=cython.double, zi=cython.double)
+def _complex_div_by_real(z, den):
+    """Divide complex by real using Python's method (two separate divisions).
+
+    This ensures bit-exact compatibility with Python's complex division,
+    avoiding C's multiply-by-reciprocal optimization that can cause 1 ULP differences
+    on some platforms/compilers (e.g. clang on macOS arm64).
+
+    https://github.com/fonttools/fonttools/issues/3928
+    """
+    zr = z.real
+    zi = z.imag
+    return complex(zr / den, zi / den)
+
+
+@cython.cfunc
+@cython.inline
+@cython.locals(a=cython.complex, b=cython.complex, c=cython.complex, d=cython.complex)
+@cython.locals(
+    _1=cython.complex, _2=cython.complex, _3=cython.complex, _4=cython.complex
+)
+def calc_cubic_points(a, b, c, d):
+    _1 = d
+    _2 = _complex_div_by_real(c, 3.0) + d
+    _3 = _complex_div_by_real(b + c, 3.0) + _2
+    _4 = a + d + c + b
+    return _1, _2, _3, _4
+
+
+@cython.cfunc
+@cython.inline
+@cython.locals(
+    p0=cython.complex, p1=cython.complex, p2=cython.complex, p3=cython.complex
+)
+@cython.locals(a=cython.complex, b=cython.complex, c=cython.complex, d=cython.complex)
+def calc_cubic_parameters(p0, p1, p2, p3):
+    c = (p1 - p0) * 3.0
+    b = (p2 - p1) * 3.0 - c
+    d = p0
+    a = p3 - d - c - b
+    return a, b, c, d
+
+
+@cython.cfunc
+@cython.inline
+@cython.locals(
+    p0=cython.complex, p1=cython.complex, p2=cython.complex, p3=cython.complex
+)
+def split_cubic_into_n_iter(p0, p1, p2, p3, n):
+    """Split a cubic Bezier into n equal parts.
+
+    Splits the curve into `n` equal parts by curve time.
+    (t=0..1/n, t=1/n..2/n, ...)
+
+    Args:
+        p0 (complex): Start point of curve.
+        p1 (complex): First handle of curve.
+        p2 (complex): Second handle of curve.
+        p3 (complex): End point of curve.
+
+    Returns:
+        An iterator yielding the control points (four complex values) of the
+        subcurves.
+    """
+    # Hand-coded special-cases
+    if n == 2:
+        return iter(split_cubic_into_two(p0, p1, p2, p3))
+    if n == 3:
+        return iter(split_cubic_into_three(p0, p1, p2, p3))
+    if n == 4:
+        a, b = split_cubic_into_two(p0, p1, p2, p3)
+        return iter(
+            split_cubic_into_two(a[0], a[1], a[2], a[3])
+            + split_cubic_into_two(b[0], b[1], b[2], b[3])
+        )
+    if n == 6:
+        a, b = split_cubic_into_two(p0, p1, p2, p3)
+        return iter(
+            split_cubic_into_three(a[0], a[1], a[2], a[3])
+            + split_cubic_into_three(b[0], b[1], b[2], b[3])
+        )
+
+    return _split_cubic_into_n_gen(p0, p1, p2, p3, n)
+
+
+@cython.locals(
+    p0=cython.complex,
+    p1=cython.complex,
+    p2=cython.complex,
+    p3=cython.complex,
+    n=cython.int,
+)
+@cython.locals(a=cython.complex, b=cython.complex, c=cython.complex, d=cython.complex)
+@cython.locals(
+    dt=cython.double, delta_2=cython.double, delta_3=cython.double, i=cython.int
+)
+@cython.locals(
+    a1=cython.complex, b1=cython.complex, c1=cython.complex, d1=cython.complex
+)
+def _split_cubic_into_n_gen(p0, p1, p2, p3, n):
+    a, b, c, d = calc_cubic_parameters(p0, p1, p2, p3)
+    dt = 1 / n
+    delta_2 = dt * dt
+    delta_3 = dt * delta_2
+    for i in range(n):
+        t1 = i * dt
+        t1_2 = t1 * t1
+        # calc new a, b, c and d
+        a1 = a * delta_3
+        b1 = (3 * a * t1 + b) * delta_2
+        c1 = (2 * b * t1 + c + 3 * a * t1_2) * dt
+        d1 = a * t1 * t1_2 + b * t1_2 + c * t1 + d
+        yield calc_cubic_points(a1, b1, c1, d1)
+
+
+@cython.cfunc
+@cython.inline
+@cython.locals(
+    p0=cython.complex, p1=cython.complex, p2=cython.complex, p3=cython.complex
+)
+@cython.locals(mid=cython.complex, deriv3=cython.complex)
+def split_cubic_into_two(p0, p1, p2, p3):
+    """Split a cubic Bezier into two equal parts.
+
+    Splits the curve into two equal parts at t = 0.5
+
+    Args:
+        p0 (complex): Start point of curve.
+        p1 (complex): First handle of curve.
+        p2 (complex): Second handle of curve.
+        p3 (complex): End point of curve.
+
+    Returns:
+        tuple: Two cubic Beziers (each expressed as a tuple of four complex
+        values).
+    """
+    mid = (p0 + 3 * (p1 + p2) + p3) * 0.125
+    deriv3 = (p3 + p2 - p1 - p0) * 0.125
+    return (
+        (p0, (p0 + p1) * 0.5, mid - deriv3, mid),
+        (mid, mid + deriv3, (p2 + p3) * 0.5, p3),
+    )
+
+
+@cython.cfunc
+@cython.inline
+@cython.locals(
+    p0=cython.complex,
+    p1=cython.complex,
+    p2=cython.complex,
+    p3=cython.complex,
+)
+@cython.locals(
+    mid1=cython.complex,
+    deriv1=cython.complex,
+    mid2=cython.complex,
+    deriv2=cython.complex,
+)
+def split_cubic_into_three(p0, p1, p2, p3):
+    """Split a cubic Bezier into three equal parts.
+
+    Splits the curve into three equal parts at t = 1/3 and t = 2/3
+
+    Args:
+        p0 (complex): Start point of curve.
+        p1 (complex): First handle of curve.
+        p2 (complex): Second handle of curve.
+        p3 (complex): End point of curve.
+
+    Returns:
+        tuple: Three cubic Beziers (each expressed as a tuple of four complex
+        values).
+    """
+    mid1 = (8 * p0 + 12 * p1 + 6 * p2 + p3) * (1 / 27)
+    deriv1 = (p3 + 3 * p2 - 4 * p0) * (1 / 27)
+    mid2 = (p0 + 6 * p1 + 12 * p2 + 8 * p3) * (1 / 27)
+    deriv2 = (4 * p3 - 3 * p1 - p0) * (1 / 27)
+    return (
+        (p0, (2 * p0 + p1) / 3.0, mid1 - deriv1, mid1),
+        (mid1, mid1 + deriv1, mid2 - deriv2, mid2),
+        (mid2, mid2 + deriv2, (p2 + 2 * p3) / 3.0, p3),
+    )
+
+
+@cython.cfunc
+@cython.inline
+@cython.returns(cython.complex)
+@cython.locals(
+    t=cython.double,
+    p0=cython.complex,
+    p1=cython.complex,
+    p2=cython.complex,
+    p3=cython.complex,
+)
+@cython.locals(_p1=cython.complex, _p2=cython.complex)
+def cubic_approx_control(t, p0, p1, p2, p3):
+    """Approximate a cubic Bezier using a quadratic one.
+
+    Args:
+        t (double): Position of control point.
+        p0 (complex): Start point of curve.
+        p1 (complex): First handle of curve.
+        p2 (complex): Second handle of curve.
+        p3 (complex): End point of curve.
+
+    Returns:
+        complex: Location of candidate control point on quadratic curve.
+    """
+    _p1 = p0 + (p1 - p0) * 1.5
+    _p2 = p3 + (p2 - p3) * 1.5
+    return _p1 + (_p2 - _p1) * t
+
+
+@cython.cfunc
+@cython.inline
+@cython.returns(cython.complex)
+@cython.locals(a=cython.complex, b=cython.complex, c=cython.complex, d=cython.complex)
+@cython.locals(ab=cython.complex, cd=cython.complex, p=cython.complex, h=cython.double)
+def calc_intersect(a, b, c, d):
+    """Calculate the intersection of two lines.
+
+    Args:
+        a (complex): Start point of first line.
+        b (complex): End point of first line.
+        c (complex): Start point of second line.
+        d (complex): End point of second line.
+
+    Returns:
+        complex: Location of intersection if one present, ``complex(NaN,NaN)``
+        if no intersection was found.
+    """
+    ab = b - a
+    cd = d - c
+    p = ab * 1j
+    try:
+        h = dot(p, a - c) / dot(p, cd)
+    except ZeroDivisionError:
+        # if 3 or 4 points are equal, we do have an intersection despite the zero-div:
+        # return one of the off-curves so that the algorithm can attempt a one-curve
+        # solution if it's within tolerance:
+        # https://github.com/linebender/kurbo/pull/484
+        if b == c and (a == b or c == d):
+            return b
+        return complex(NAN, NAN)
+    return c + cd * h
+
+
+@cython.cfunc
+@cython.returns(cython.int)
+@cython.locals(
+    tolerance=cython.double,
+    p0=cython.complex,
+    p1=cython.complex,
+    p2=cython.complex,
+    p3=cython.complex,
+)
+@cython.locals(mid=cython.complex, deriv3=cython.complex)
+def cubic_farthest_fit_inside(p0, p1, p2, p3, tolerance):
+    """Check if a cubic Bezier lies within a given distance of the origin.
+
+    "Origin" means *the* origin (0,0), not the start of the curve. Note that no
+    checks are made on the start and end positions of the curve; this function
+    only checks the inside of the curve.
+
+    Args:
+        p0 (complex): Start point of curve.
+        p1 (complex): First handle of curve.
+        p2 (complex): Second handle of curve.
+        p3 (complex): End point of curve.
+        tolerance (double): Distance from origin.
+
+    Returns:
+        bool: True if the cubic Bezier ``p`` entirely lies within a distance
+        ``tolerance`` of the origin, False otherwise.
+    """
+    # First check p2 then p1, as p2 has higher error early on.
+    if abs(p2) <= tolerance and abs(p1) <= tolerance:
+        return True
+
+    # Split.
+    mid = (p0 + 3 * (p1 + p2) + p3) * 0.125
+    if abs(mid) > tolerance:
+        return False
+    deriv3 = (p3 + p2 - p1 - p0) * 0.125
+    return cubic_farthest_fit_inside(
+        p0, (p0 + p1) * 0.5, mid - deriv3, mid, tolerance
+    ) and cubic_farthest_fit_inside(mid, mid + deriv3, (p2 + p3) * 0.5, p3, tolerance)
+
+
+@cython.cfunc
+@cython.inline
+@cython.locals(tolerance=cython.double)
+@cython.locals(
+    q1=cython.complex,
+    c0=cython.complex,
+    c1=cython.complex,
+    c2=cython.complex,
+    c3=cython.complex,
+)
+def cubic_approx_quadratic(cubic, tolerance):
+    """Approximate a cubic Bezier with a single quadratic within a given tolerance.
+
+    Args:
+        cubic (sequence): Four complex numbers representing control points of
+            the cubic Bezier curve.
+        tolerance (double): Permitted deviation from the original curve.
+
+    Returns:
+        Three complex numbers representing control points of the quadratic
+        curve if it fits within the given tolerance, or ``None`` if no suitable
+        curve could be calculated.
+    """
+
+    q1 = calc_intersect(cubic[0], cubic[1], cubic[2], cubic[3])
+    if math.isnan(q1.imag):
+        return None
+    c0 = cubic[0]
+    c3 = cubic[3]
+    c1 = c0 + (q1 - c0) * (2 / 3)
+    c2 = c3 + (q1 - c3) * (2 / 3)
+    if not cubic_farthest_fit_inside(0, c1 - cubic[1], c2 - cubic[2], 0, tolerance):
+        return None
+    return c0, q1, c3
+
+
+@cython.cfunc
+@cython.locals(n=cython.int, tolerance=cython.double)
+@cython.locals(i=cython.int)
+@cython.locals(all_quadratic=cython.int)
+@cython.locals(
+    c0=cython.complex, c1=cython.complex, c2=cython.complex, c3=cython.complex
+)
+@cython.locals(
+    q0=cython.complex,
+    q1=cython.complex,
+    next_q1=cython.complex,
+    q2=cython.complex,
+    d1=cython.complex,
+)
+def cubic_approx_spline(cubic, n, tolerance, all_quadratic):
+    """Approximate a cubic Bezier curve with a spline of n quadratics.
+
+    Args:
+        cubic (sequence): Four complex numbers representing control points of
+            the cubic Bezier curve.
+        n (int): Number of quadratic Bezier curves in the spline.
+        tolerance (double): Permitted deviation from the original curve.
+
+    Returns:
+        A list of ``n+2`` complex numbers, representing control points of the
+        quadratic spline if it fits within the given tolerance, or ``None`` if
+        no suitable spline could be calculated.
+    """
+
+    if n == 1:
+        return cubic_approx_quadratic(cubic, tolerance)
+    if n == 2 and all_quadratic == False:
+        return cubic
+
+    cubics = split_cubic_into_n_iter(cubic[0], cubic[1], cubic[2], cubic[3], n)
+
+    # calculate the spline of quadratics and check errors at the same time.
+    next_cubic = next(cubics)
+    next_q1 = cubic_approx_control(
+        0, next_cubic[0], next_cubic[1], next_cubic[2], next_cubic[3]
+    )
+    q2 = cubic[0]
+    d1 = 0j
+    spline = [cubic[0], next_q1]
+    for i in range(1, n + 1):
+        # Current cubic to convert
+        c0, c1, c2, c3 = next_cubic
+
+        # Current quadratic approximation of current cubic
+        q0 = q2
+        q1 = next_q1
+        if i < n:
+            next_cubic = next(cubics)
+            next_q1 = cubic_approx_control(
+                i / (n - 1), next_cubic[0], next_cubic[1], next_cubic[2], next_cubic[3]
+            )
+            spline.append(next_q1)
+            q2 = (q1 + next_q1) * 0.5
+        else:
+            q2 = c3
+
+        # End-point deltas
+        d0 = d1
+        d1 = q2 - c3
+
+        if abs(d1) > tolerance or not cubic_farthest_fit_inside(
+            d0,
+            q0 + (q1 - q0) * (2 / 3) - c1,
+            q2 + (q1 - q2) * (2 / 3) - c2,
+            d1,
+            tolerance,
+        ):
+            return None
+    spline.append(cubic[3])
+
+    return spline
+
+
+@cython.locals(max_err=cython.double)
+@cython.locals(n=cython.int)
+@cython.locals(all_quadratic=cython.int)
+def curve_to_quadratic(curve, max_err, all_quadratic=True):
+    """Approximate a cubic Bezier curve with a spline of n quadratics.
+
+    Args:
+        cubic (sequence): Four 2D tuples representing control points of
+            the cubic Bezier curve.
+        max_err (double): Permitted deviation from the original curve.
+        all_quadratic (bool): If True (default) returned value is a
+            quadratic spline. If False, it's either a single quadratic
+            curve or a single cubic curve.
+
+    Returns:
+        If all_quadratic is True: A list of 2D tuples, representing
+        control points of the quadratic spline if it fits within the
+        given tolerance, or ``None`` if no suitable spline could be
+        calculated.
+
+        If all_quadratic is False: Either a quadratic curve (if length
+        of output is 3), or a cubic curve (if length of output is 4).
+    """
+
+    curve = [complex(*p) for p in curve]
+
+    for n in range(1, MAX_N + 1):
+        spline = cubic_approx_spline(curve, n, max_err, all_quadratic)
+        if spline is not None:
+            # done. go home
+            return [(s.real, s.imag) for s in spline]
+
+    raise ApproxNotFoundError(curve)
+
+
+@cython.locals(l=cython.int, last_i=cython.int, i=cython.int)
+@cython.locals(all_quadratic=cython.int)
+def curves_to_quadratic(curves, max_errors, all_quadratic=True):
+    """Return quadratic Bezier splines approximating the input cubic Beziers.
+
+    Args:
+        curves: A sequence of *n* curves, each curve being a sequence of four
+            2D tuples.
+        max_errors: A sequence of *n* floats representing the maximum permissible
+            deviation from each of the cubic Bezier curves.
+        all_quadratic (bool): If True (default) returned values are a
+            quadratic spline. If False, they are either a single quadratic
+            curve or a single cubic curve.
+
+    Example::
+
+        >>> curves_to_quadratic( [
+        ...   [ (50,50), (100,100), (150,100), (200,50) ],
+        ...   [ (75,50), (120,100), (150,75),  (200,60) ]
+        ... ], [1,1] )
+        [[(50.0, 50.0), (75.0, 75.0), (125.0, 91.66666666666666), (175.0, 75.0), (200.0, 50.0)], [(75.0, 50.0), (97.5, 75.0), (135.41666666666666, 82.08333333333333), (175.0, 67.5), (200.0, 60.0)]]
+
+    The returned splines have "implied oncurve points" suitable for use in
+    TrueType ``glif`` outlines - i.e. in the first spline returned above,
+    the first quadratic segment runs from (50,50) to
+    ( (75 + 125)/2 , (120 + 91.666..)/2 ) = (100, 83.333...).
+
+    Returns:
+        If all_quadratic is True, a list of splines, each spline being a list
+        of 2D tuples.
+
+        If all_quadratic is False, a list of curves, each curve being a quadratic
+        (length 3), or cubic (length 4).
+
+    Raises:
+        fontTools.cu2qu.Errors.ApproxNotFoundError: if no suitable approximation
+        can be found for all curves with the given parameters.
+    """
+
+    curves = [[complex(*p) for p in curve] for curve in curves]
+    assert len(max_errors) == len(curves)
+
+    l = len(curves)
+    splines = [None] * l
+    last_i = i = 0
+    n = 1
+    while True:
+        spline = cubic_approx_spline(curves[i], n, max_errors[i], all_quadratic)
+        if spline is None:
+            if n == MAX_N:
+                break
+            n += 1
+            last_i = i
+            continue
+        splines[i] = spline
+        i = (i + 1) % l
+        if i == last_i:
+            # done. go home
+            return [[(s.real, s.imag) for s in spline] for spline in splines]
+
+    raise ApproxNotFoundError(curves)

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/cu2qu/errors.py

@@ -0,0 +1,77 @@
+# Copyright 2016 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+class Error(Exception):
+    """Base Cu2Qu exception class for all other errors."""
+
+
+class ApproxNotFoundError(Error):
+    def __init__(self, curve):
+        message = "no approximation found: %s" % curve
+        super().__init__(message)
+        self.curve = curve
+
+
+class UnequalZipLengthsError(Error):
+    pass
+
+
+class IncompatibleGlyphsError(Error):
+    def __init__(self, glyphs):
+        assert len(glyphs) > 1
+        self.glyphs = glyphs
+        names = set(repr(g.name) for g in glyphs)
+        if len(names) > 1:
+            self.combined_name = "{%s}" % ", ".join(sorted(names))
+        else:
+            self.combined_name = names.pop()
+
+    def __repr__(self):
+        return "<%s %s>" % (type(self).__name__, self.combined_name)
+
+
+class IncompatibleSegmentNumberError(IncompatibleGlyphsError):
+    def __str__(self):
+        return "Glyphs named %s have different number of segments" % (
+            self.combined_name
+        )
+
+
+class IncompatibleSegmentTypesError(IncompatibleGlyphsError):
+    def __init__(self, glyphs, segments):
+        IncompatibleGlyphsError.__init__(self, glyphs)
+        self.segments = segments
+
+    def __str__(self):
+        lines = []
+        ndigits = len(str(max(self.segments)))
+        for i, tags in sorted(self.segments.items()):
+            lines.append(
+                "%s: (%s)" % (str(i).rjust(ndigits), ", ".join(repr(t) for t in tags))
+            )
+        return "Glyphs named %s have incompatible segment types:\n  %s" % (
+            self.combined_name,
+            "\n  ".join(lines),
+        )
+
+
+class IncompatibleFontsError(Error):
+    def __init__(self, glyph_errors):
+        self.glyph_errors = glyph_errors
+
+    def __str__(self):
+        return "fonts contains incompatible glyphs: %s" % (
+            ", ".join(repr(g) for g in sorted(self.glyph_errors.keys()))
+        )

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/cu2qu/ufo.py

@@ -0,0 +1,349 @@
+# Copyright 2015 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""Converts cubic bezier curves to quadratic splines.
+
+Conversion is performed such that the quadratic splines keep the same end-curve
+tangents as the original cubics. The approach is iterative, increasing the
+number of segments for a spline until the error gets below a bound.
+
+Respective curves from multiple fonts will be converted at once to ensure that
+the resulting splines are interpolation-compatible.
+"""
+
+import logging
+from fontTools.pens.basePen import AbstractPen
+from fontTools.pens.pointPen import PointToSegmentPen
+from fontTools.pens.reverseContourPen import ReverseContourPen
+
+from . import curves_to_quadratic
+from .errors import (
+    UnequalZipLengthsError,
+    IncompatibleSegmentNumberError,
+    IncompatibleSegmentTypesError,
+    IncompatibleGlyphsError,
+    IncompatibleFontsError,
+)
+
+
+__all__ = ["fonts_to_quadratic", "font_to_quadratic"]
+
+# The default approximation error below is a relative value (1/1000 of the EM square).
+# Later on, we convert it to absolute font units by multiplying it by a font's UPEM
+# (see fonts_to_quadratic).
+DEFAULT_MAX_ERR = 0.001
+CURVE_TYPE_LIB_KEY = "com.github.googlei18n.cu2qu.curve_type"
+
+logger = logging.getLogger(__name__)
+
+
+_zip = zip
+
+
+def zip(*args):
+    """Ensure each argument to zip has the same length. Also make sure a list is
+    returned for python 2/3 compatibility.
+    """
+
+    if len(set(len(a) for a in args)) != 1:
+        raise UnequalZipLengthsError(*args)
+    return list(_zip(*args))
+
+
+class GetSegmentsPen(AbstractPen):
+    """Pen to collect segments into lists of points for conversion.
+
+    Curves always include their initial on-curve point, so some points are
+    duplicated between segments.
+    """
+
+    def __init__(self):
+        self._last_pt = None
+        self.segments = []
+
+    def _add_segment(self, tag, *args):
+        if tag in ["move", "line", "qcurve", "curve"]:
+            self._last_pt = args[-1]
+        self.segments.append((tag, args))
+
+    def moveTo(self, pt):
+        self._add_segment("move", pt)
+
+    def lineTo(self, pt):
+        self._add_segment("line", pt)
+
+    def qCurveTo(self, *points):
+        self._add_segment("qcurve", self._last_pt, *points)
+
+    def curveTo(self, *points):
+        self._add_segment("curve", self._last_pt, *points)
+
+    def closePath(self):
+        self._add_segment("close")
+
+    def endPath(self):
+        self._add_segment("end")
+
+    def addComponent(self, glyphName, transformation):
+        pass
+
+
+def _get_segments(glyph):
+    """Get a glyph's segments as extracted by GetSegmentsPen."""
+
+    pen = GetSegmentsPen()
+    # glyph.draw(pen)
+    # We can't simply draw the glyph with the pen, but we must initialize the
+    # PointToSegmentPen explicitly with outputImpliedClosingLine=True.
+    # By default PointToSegmentPen does not outputImpliedClosingLine -- unless
+    # last and first point on closed contour are duplicated. Because we are
+    # converting multiple glyphs at the same time, we want to make sure
+    # this function returns the same number of segments, whether or not
+    # the last and first point overlap.
+    # https://github.com/googlefonts/fontmake/issues/572
+    # https://github.com/fonttools/fonttools/pull/1720
+    pointPen = PointToSegmentPen(pen, outputImpliedClosingLine=True)
+    glyph.drawPoints(pointPen)
+    return pen.segments
+
+
+def _set_segments(glyph, segments, reverse_direction):
+    """Draw segments as extracted by GetSegmentsPen back to a glyph."""
+
+    glyph.clearContours()
+    pen = glyph.getPen()
+    if reverse_direction:
+        pen = ReverseContourPen(pen)
+    for tag, args in segments:
+        if tag == "move":
+            pen.moveTo(*args)
+        elif tag == "line":
+            pen.lineTo(*args)
+        elif tag == "curve":
+            pen.curveTo(*args[1:])
+        elif tag == "qcurve":
+            pen.qCurveTo(*args[1:])
+        elif tag == "close":
+            pen.closePath()
+        elif tag == "end":
+            pen.endPath()
+        else:
+            raise AssertionError('Unhandled segment type "%s"' % tag)
+
+
+def _segments_to_quadratic(segments, max_err, stats, all_quadratic=True):
+    """Return quadratic approximations of cubic segments."""
+
+    assert all(s[0] == "curve" for s in segments), "Non-cubic given to convert"
+
+    new_points = curves_to_quadratic([s[1] for s in segments], max_err, all_quadratic)
+    n = len(new_points[0])
+    assert all(len(s) == n for s in new_points[1:]), "Converted incompatibly"
+
+    spline_length = str(n - 2)
+    stats[spline_length] = stats.get(spline_length, 0) + 1
+
+    if all_quadratic or n == 3:
+        return [("qcurve", p) for p in new_points]
+    else:
+        return [("curve", p) for p in new_points]
+
+
+def _glyphs_to_quadratic(glyphs, max_err, reverse_direction, stats, all_quadratic=True):
+    """Do the actual conversion of a set of compatible glyphs, after arguments
+    have been set up.
+
+    Return True if the glyphs were modified, else return False.
+    """
+
+    try:
+        segments_by_location = zip(*[_get_segments(g) for g in glyphs])
+    except UnequalZipLengthsError:
+        raise IncompatibleSegmentNumberError(glyphs)
+    if not any(segments_by_location):
+        return False
+
+    # always modify input glyphs if reverse_direction is True
+    glyphs_modified = reverse_direction
+
+    new_segments_by_location = []
+    incompatible = {}
+    for i, segments in enumerate(segments_by_location):
+        tag = segments[0][0]
+        if not all(s[0] == tag for s in segments[1:]):
+            incompatible[i] = [s[0] for s in segments]
+        elif tag == "curve":
+            new_segments = _segments_to_quadratic(
+                segments, max_err, stats, all_quadratic
+            )
+            if all_quadratic or new_segments != segments:
+                glyphs_modified = True
+            segments = new_segments
+        new_segments_by_location.append(segments)
+
+    if glyphs_modified:
+        new_segments_by_glyph = zip(*new_segments_by_location)
+        for glyph, new_segments in zip(glyphs, new_segments_by_glyph):
+            _set_segments(glyph, new_segments, reverse_direction)
+
+    if incompatible:
+        raise IncompatibleSegmentTypesError(glyphs, segments=incompatible)
+    return glyphs_modified
+
+
+def glyphs_to_quadratic(
+    glyphs, max_err=None, reverse_direction=False, stats=None, all_quadratic=True
+):
+    """Convert the curves of a set of compatible of glyphs to quadratic.
+
+    All curves will be converted to quadratic at once, ensuring interpolation
+    compatibility. If this is not required, calling glyphs_to_quadratic with one
+    glyph at a time may yield slightly more optimized results.
+
+    Return True if glyphs were modified, else return False.
+
+    Raises IncompatibleGlyphsError if glyphs have non-interpolatable outlines.
+    """
+    if stats is None:
+        stats = {}
+
+    if not max_err:
+        # assume 1000 is the default UPEM
+        max_err = DEFAULT_MAX_ERR * 1000
+
+    if isinstance(max_err, (list, tuple)):
+        max_errors = max_err
+    else:
+        max_errors = [max_err] * len(glyphs)
+    assert len(max_errors) == len(glyphs)
+
+    return _glyphs_to_quadratic(
+        glyphs, max_errors, reverse_direction, stats, all_quadratic
+    )
+
+
+def fonts_to_quadratic(
+    fonts,
+    max_err_em=None,
+    max_err=None,
+    reverse_direction=False,
+    stats=None,
+    dump_stats=False,
+    remember_curve_type=True,
+    all_quadratic=True,
+):
+    """Convert the curves of a collection of fonts to quadratic.
+
+    All curves will be converted to quadratic at once, ensuring interpolation
+    compatibility. If this is not required, calling fonts_to_quadratic with one
+    font at a time may yield slightly more optimized results.
+
+    Return the set of modified glyph names if any, else return an empty set.
+
+    By default, cu2qu stores the curve type in the fonts' lib, under a private
+    key "com.github.googlei18n.cu2qu.curve_type", and will not try to convert
+    them again if the curve type is already set to "quadratic".
+    Setting 'remember_curve_type' to False disables this optimization.
+
+    Raises IncompatibleFontsError if same-named glyphs from different fonts
+    have non-interpolatable outlines.
+    """
+
+    if remember_curve_type:
+        curve_types = {f.lib.get(CURVE_TYPE_LIB_KEY, "cubic") for f in fonts}
+        if len(curve_types) == 1:
+            curve_type = next(iter(curve_types))
+            if curve_type in ("quadratic", "mixed"):
+                logger.info("Curves already converted to quadratic")
+                return False
+            elif curve_type == "cubic":
+                pass  # keep converting
+            else:
+                raise NotImplementedError(curve_type)
+        elif len(curve_types) > 1:
+            # going to crash later if they do differ
+            logger.warning("fonts may contain different curve types")
+
+    if stats is None:
+        stats = {}
+
+    if max_err_em and max_err:
+        raise TypeError("Only one of max_err and max_err_em can be specified.")
+    if not (max_err_em or max_err):
+        max_err_em = DEFAULT_MAX_ERR
+
+    if isinstance(max_err, (list, tuple)):
+        assert len(max_err) == len(fonts)
+        max_errors = max_err
+    elif max_err:
+        max_errors = [max_err] * len(fonts)
+
+    if isinstance(max_err_em, (list, tuple)):
+        assert len(fonts) == len(max_err_em)
+        max_errors = [f.info.unitsPerEm * e for f, e in zip(fonts, max_err_em)]
+    elif max_err_em:
+        max_errors = [f.info.unitsPerEm * max_err_em for f in fonts]
+
+    modified = set()
+    glyph_errors = {}
+    for name in set().union(*(f.keys() for f in fonts)):
+        glyphs = []
+        cur_max_errors = []
+        for font, error in zip(fonts, max_errors):
+            if name in font:
+                glyphs.append(font[name])
+                cur_max_errors.append(error)
+        try:
+            if _glyphs_to_quadratic(
+                glyphs, cur_max_errors, reverse_direction, stats, all_quadratic
+            ):
+                modified.add(name)
+        except IncompatibleGlyphsError as exc:
+            logger.error(exc)
+            glyph_errors[name] = exc
+
+    if glyph_errors:
+        raise IncompatibleFontsError(glyph_errors)
+
+    if modified and dump_stats:
+        spline_lengths = sorted(stats.keys())
+        logger.info(
+            "New spline lengths: %s"
+            % (", ".join("%s: %d" % (l, stats[l]) for l in spline_lengths))
+        )
+
+    if remember_curve_type:
+        for font in fonts:
+            curve_type = font.lib.get(CURVE_TYPE_LIB_KEY, "cubic")
+            new_curve_type = "quadratic" if all_quadratic else "mixed"
+            if curve_type != new_curve_type:
+                font.lib[CURVE_TYPE_LIB_KEY] = new_curve_type
+    return modified
+
+
+def glyph_to_quadratic(glyph, **kwargs):
+    """Convenience wrapper around glyphs_to_quadratic, for just one glyph.
+    Return True if the glyph was modified, else return False.
+    """
+
+    return glyphs_to_quadratic([glyph], **kwargs)
+
+
+def font_to_quadratic(font, **kwargs):
+    """Convenience wrapper around fonts_to_quadratic, for just one font.
+    Return the set of modified glyph names if any, else return empty set.
+    """
+
+    return fonts_to_quadratic([font], **kwargs)

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/designspaceLib/__main__.py

@@ -0,0 +1,6 @@
+import sys
+from fontTools.designspaceLib import main
+
+
+if __name__ == "__main__":
+    sys.exit(main())

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/designspaceLib/split.py

@@ -0,0 +1,475 @@
+"""Allows building all the variable fonts of a DesignSpace version 5 by
+splitting the document into interpolable sub-space, then into each VF.
+"""
+
+from __future__ import annotations
+
+import itertools
+import logging
+import math
+from typing import Any, Callable, Dict, Iterator, List, Tuple, cast
+
+from fontTools.designspaceLib import (
+    AxisDescriptor,
+    AxisMappingDescriptor,
+    DesignSpaceDocument,
+    DiscreteAxisDescriptor,
+    InstanceDescriptor,
+    RuleDescriptor,
+    SimpleLocationDict,
+    SourceDescriptor,
+    VariableFontDescriptor,
+)
+from fontTools.designspaceLib.statNames import StatNames, getStatNames
+from fontTools.designspaceLib.types import (
+    ConditionSet,
+    Range,
+    Region,
+    getVFUserRegion,
+    locationInRegion,
+    regionInRegion,
+    userRegionToDesignRegion,
+)
+
+LOGGER = logging.getLogger(__name__)
+
+MakeInstanceFilenameCallable = Callable[
+    [DesignSpaceDocument, InstanceDescriptor, StatNames], str
+]
+
+
+def defaultMakeInstanceFilename(
+    doc: DesignSpaceDocument, instance: InstanceDescriptor, statNames: StatNames
+) -> str:
+    """Default callable to synthesize an instance filename
+    when makeNames=True, for instances that don't specify an instance name
+    in the designspace. This part of the name generation can be overriden
+    because it's not specified by the STAT table.
+    """
+    familyName = instance.familyName or statNames.familyNames.get("en")
+    styleName = instance.styleName or statNames.styleNames.get("en")
+    return f"{familyName}-{styleName}.ttf"
+
+
+def splitInterpolable(
+    doc: DesignSpaceDocument,
+    makeNames: bool = True,
+    expandLocations: bool = True,
+    makeInstanceFilename: MakeInstanceFilenameCallable = defaultMakeInstanceFilename,
+) -> Iterator[Tuple[SimpleLocationDict, DesignSpaceDocument]]:
+    """Split the given DS5 into several interpolable sub-designspaces.
+    There are as many interpolable sub-spaces as there are combinations of
+    discrete axis values.
+
+    E.g. with axes:
+        - italic (discrete) Upright or Italic
+        - style (discrete) Sans or Serif
+        - weight (continuous) 100 to 900
+
+    There are 4 sub-spaces in which the Weight axis should interpolate:
+    (Upright, Sans), (Upright, Serif), (Italic, Sans) and (Italic, Serif).
+
+    The sub-designspaces still include the full axis definitions and STAT data,
+    but the rules, sources, variable fonts, instances are trimmed down to only
+    keep what falls within the interpolable sub-space.
+
+    Args:
+      - ``makeNames``: Whether to compute the instance family and style
+        names using the STAT data.
+      - ``expandLocations``: Whether to turn all locations into "full"
+        locations, including implicit default axis values where missing.
+      - ``makeInstanceFilename``: Callable to synthesize an instance filename
+        when makeNames=True, for instances that don't specify an instance name
+        in the designspace. This part of the name generation can be overridden
+        because it's not specified by the STAT table.
+
+    .. versionadded:: 5.0
+    """
+    discreteAxes = []
+    interpolableUserRegion: Region = {}
+    for axis in doc.axes:
+        if hasattr(axis, "values"):
+            # Mypy doesn't support narrowing union types via hasattr()
+            # TODO(Python 3.10): use TypeGuard
+            # https://mypy.readthedocs.io/en/stable/type_narrowing.html
+            axis = cast(DiscreteAxisDescriptor, axis)
+            discreteAxes.append(axis)
+        else:
+            axis = cast(AxisDescriptor, axis)
+            interpolableUserRegion[axis.name] = Range(
+                axis.minimum,
+                axis.maximum,
+                axis.default,
+            )
+    valueCombinations = itertools.product(*[axis.values for axis in discreteAxes])
+    for values in valueCombinations:
+        discreteUserLocation = {
+            discreteAxis.name: value
+            for discreteAxis, value in zip(discreteAxes, values)
+        }
+        subDoc = _extractSubSpace(
+            doc,
+            {**interpolableUserRegion, **discreteUserLocation},
+            keepVFs=True,
+            makeNames=makeNames,
+            expandLocations=expandLocations,
+            makeInstanceFilename=makeInstanceFilename,
+        )
+        yield discreteUserLocation, subDoc
+
+
+def splitVariableFonts(
+    doc: DesignSpaceDocument,
+    makeNames: bool = False,
+    expandLocations: bool = False,
+    makeInstanceFilename: MakeInstanceFilenameCallable = defaultMakeInstanceFilename,
+) -> Iterator[Tuple[str, DesignSpaceDocument]]:
+    """Convert each variable font listed in this document into a standalone
+    designspace. This can be used to compile all the variable fonts from a
+    format 5 designspace using tools that can only deal with 1 VF at a time.
+
+    Args:
+      - ``makeNames``: Whether to compute the instance family and style
+        names using the STAT data.
+      - ``expandLocations``: Whether to turn all locations into "full"
+        locations, including implicit default axis values where missing.
+      - ``makeInstanceFilename``: Callable to synthesize an instance filename
+        when makeNames=True, for instances that don't specify an instance name
+        in the designspace. This part of the name generation can be overridden
+        because it's not specified by the STAT table.
+
+    .. versionadded:: 5.0
+    """
+    # Make one DesignspaceDoc v5 for each variable font
+    for vf in doc.getVariableFonts():
+        vfUserRegion = getVFUserRegion(doc, vf)
+        vfDoc = _extractSubSpace(
+            doc,
+            vfUserRegion,
+            keepVFs=False,
+            makeNames=makeNames,
+            expandLocations=expandLocations,
+            makeInstanceFilename=makeInstanceFilename,
+        )
+        vfDoc.lib = {**vfDoc.lib, **vf.lib}
+        yield vf.name, vfDoc
+
+
+def convert5to4(
+    doc: DesignSpaceDocument,
+) -> Dict[str, DesignSpaceDocument]:
+    """Convert each variable font listed in this document into a standalone
+    format 4 designspace. This can be used to compile all the variable fonts
+    from a format 5 designspace using tools that only know about format 4.
+
+    .. versionadded:: 5.0
+    """
+    vfs = {}
+    for _location, subDoc in splitInterpolable(doc):
+        for vfName, vfDoc in splitVariableFonts(subDoc):
+            vfDoc.formatVersion = "4.1"
+            vfs[vfName] = vfDoc
+    return vfs
+
+
+def _extractSubSpace(
+    doc: DesignSpaceDocument,
+    userRegion: Region,
+    *,
+    keepVFs: bool,
+    makeNames: bool,
+    expandLocations: bool,
+    makeInstanceFilename: MakeInstanceFilenameCallable,
+) -> DesignSpaceDocument:
+    subDoc = DesignSpaceDocument()
+    # Don't include STAT info
+    # FIXME: (Jany) let's think about it. Not include = OK because the point of
+    # the splitting is to build VFs and we'll use the STAT data of the full
+    # document to generate the STAT of the VFs, so "no need" to have STAT data
+    # in sub-docs. Counterpoint: what if someone wants to split this DS for
+    # other purposes?  Maybe for that it would be useful to also subset the STAT
+    # data?
+    # subDoc.elidedFallbackName = doc.elidedFallbackName
+
+    def maybeExpandDesignLocation(object):
+        if expandLocations:
+            return object.getFullDesignLocation(doc)
+        else:
+            return object.designLocation
+
+    for axis in doc.axes:
+        range = userRegion[axis.name]
+        if isinstance(range, Range) and hasattr(axis, "minimum"):
+            # Mypy doesn't support narrowing union types via hasattr()
+            # TODO(Python 3.10): use TypeGuard
+            # https://mypy.readthedocs.io/en/stable/type_narrowing.html
+            axis = cast(AxisDescriptor, axis)
+            subDoc.addAxis(
+                AxisDescriptor(
+                    # Same info
+                    tag=axis.tag,
+                    name=axis.name,
+                    labelNames=axis.labelNames,
+                    hidden=axis.hidden,
+                    # Subset range
+                    minimum=max(range.minimum, axis.minimum),
+                    default=range.default or axis.default,
+                    maximum=min(range.maximum, axis.maximum),
+                    map=[
+                        (user, design)
+                        for user, design in axis.map
+                        if range.minimum <= user <= range.maximum
+                    ],
+                    # Don't include STAT info
+                    axisOrdering=None,
+                    axisLabels=None,
+                )
+            )
+
+    subDoc.axisMappings = mappings = []
+    subDocAxes = {axis.name for axis in subDoc.axes}
+    for mapping in doc.axisMappings:
+        if not all(axis in subDocAxes for axis in mapping.inputLocation.keys()):
+            continue
+        if not all(axis in subDocAxes for axis in mapping.outputLocation.keys()):
+            LOGGER.error(
+                "In axis mapping from input %s, some output axes are not in the variable-font: %s",
+                mapping.inputLocation,
+                mapping.outputLocation,
+            )
+            continue
+
+        mappingAxes = set()
+        mappingAxes.update(mapping.inputLocation.keys())
+        mappingAxes.update(mapping.outputLocation.keys())
+        for axis in doc.axes:
+            if axis.name not in mappingAxes:
+                continue
+            range = userRegion[axis.name]
+            if (
+                range.minimum != axis.minimum
+                or (range.default is not None and range.default != axis.default)
+                or range.maximum != axis.maximum
+            ):
+                LOGGER.error(
+                    "Limiting axis ranges used in <mapping> elements not supported: %s",
+                    axis.name,
+                )
+                continue
+
+        mappings.append(
+            AxisMappingDescriptor(
+                inputLocation=mapping.inputLocation,
+                outputLocation=mapping.outputLocation,
+            )
+        )
+
+    # Don't include STAT info
+    # subDoc.locationLabels = doc.locationLabels
+
+    # Rules: subset them based on conditions
+    designRegion = userRegionToDesignRegion(doc, userRegion)
+    subDoc.rules = _subsetRulesBasedOnConditions(doc.rules, designRegion)
+    subDoc.rulesProcessingLast = doc.rulesProcessingLast
+
+    # Sources: keep only the ones that fall within the kept axis ranges
+    for source in doc.sources:
+        if not locationInRegion(doc.map_backward(source.designLocation), userRegion):
+            continue
+
+        subDoc.addSource(
+            SourceDescriptor(
+                filename=source.filename,
+                path=source.path,
+                font=source.font,
+                name=source.name,
+                designLocation=_filterLocation(
+                    userRegion, maybeExpandDesignLocation(source)
+                ),
+                layerName=source.layerName,
+                familyName=source.familyName,
+                styleName=source.styleName,
+                muteKerning=source.muteKerning,
+                muteInfo=source.muteInfo,
+                mutedGlyphNames=source.mutedGlyphNames,
+            )
+        )
+
+    # Copy family name translations from the old default source to the new default
+    vfDefault = subDoc.findDefault()
+    oldDefault = doc.findDefault()
+    if vfDefault is not None and oldDefault is not None:
+        vfDefault.localisedFamilyName = oldDefault.localisedFamilyName
+
+    # Variable fonts: keep only the ones that fall within the kept axis ranges
+    if keepVFs:
+        # Note: call getVariableFont() to make the implicit VFs explicit
+        for vf in doc.getVariableFonts():
+            vfUserRegion = getVFUserRegion(doc, vf)
+            if regionInRegion(vfUserRegion, userRegion):
+                subDoc.addVariableFont(
+                    VariableFontDescriptor(
+                        name=vf.name,
+                        filename=vf.filename,
+                        axisSubsets=[
+                            axisSubset
+                            for axisSubset in vf.axisSubsets
+                            if isinstance(userRegion[axisSubset.name], Range)
+                        ],
+                        lib=vf.lib,
+                    )
+                )
+
+    # Instances: same as Sources + compute missing names
+    for instance in doc.instances:
+        if not locationInRegion(instance.getFullUserLocation(doc), userRegion):
+            continue
+
+        if makeNames:
+            statNames = getStatNames(doc, instance.getFullUserLocation(doc))
+            familyName = instance.familyName or statNames.familyNames.get("en")
+            styleName = instance.styleName or statNames.styleNames.get("en")
+            subDoc.addInstance(
+                InstanceDescriptor(
+                    filename=instance.filename
+                    or makeInstanceFilename(doc, instance, statNames),
+                    path=instance.path,
+                    font=instance.font,
+                    name=instance.name or f"{familyName} {styleName}",
+                    userLocation={} if expandLocations else instance.userLocation,
+                    designLocation=_filterLocation(
+                        userRegion, maybeExpandDesignLocation(instance)
+                    ),
+                    familyName=familyName,
+                    styleName=styleName,
+                    postScriptFontName=instance.postScriptFontName
+                    or statNames.postScriptFontName,
+                    styleMapFamilyName=instance.styleMapFamilyName
+                    or statNames.styleMapFamilyNames.get("en"),
+                    styleMapStyleName=instance.styleMapStyleName
+                    or statNames.styleMapStyleName,
+                    localisedFamilyName=instance.localisedFamilyName
+                    or statNames.familyNames,
+                    localisedStyleName=instance.localisedStyleName
+                    or statNames.styleNames,
+                    localisedStyleMapFamilyName=instance.localisedStyleMapFamilyName
+                    or statNames.styleMapFamilyNames,
+                    localisedStyleMapStyleName=instance.localisedStyleMapStyleName
+                    or {},
+                    lib=instance.lib,
+                )
+            )
+        else:
+            subDoc.addInstance(
+                InstanceDescriptor(
+                    filename=instance.filename,
+                    path=instance.path,
+                    font=instance.font,
+                    name=instance.name,
+                    userLocation={} if expandLocations else instance.userLocation,
+                    designLocation=_filterLocation(
+                        userRegion, maybeExpandDesignLocation(instance)
+                    ),
+                    familyName=instance.familyName,
+                    styleName=instance.styleName,
+                    postScriptFontName=instance.postScriptFontName,
+                    styleMapFamilyName=instance.styleMapFamilyName,
+                    styleMapStyleName=instance.styleMapStyleName,
+                    localisedFamilyName=instance.localisedFamilyName,
+                    localisedStyleName=instance.localisedStyleName,
+                    localisedStyleMapFamilyName=instance.localisedStyleMapFamilyName,
+                    localisedStyleMapStyleName=instance.localisedStyleMapStyleName,
+                    lib=instance.lib,
+                )
+            )
+
+    subDoc.lib = doc.lib
+
+    return subDoc
+
+
+def _conditionSetFrom(conditionSet: List[Dict[str, Any]]) -> ConditionSet:
+    c: Dict[str, Range] = {}
+    for condition in conditionSet:
+        minimum, maximum = condition.get("minimum"), condition.get("maximum")
+        c[condition["name"]] = Range(
+            minimum if minimum is not None else -math.inf,
+            maximum if maximum is not None else math.inf,
+        )
+    return c
+
+
+def _subsetRulesBasedOnConditions(
+    rules: List[RuleDescriptor], designRegion: Region
+) -> List[RuleDescriptor]:
+    # What rules to keep:
+    #  - Keep the rule if any conditionset is relevant.
+    #  - A conditionset is relevant if all conditions are relevant or it is empty.
+    #  - A condition is relevant if
+    #    - axis is point (C-AP),
+    #       - and point in condition's range (C-AP-in)
+    #            (in this case remove the condition because it's always true)
+    #       - else (C-AP-out) whole conditionset can be discarded (condition false
+    #         => conditionset false)
+    #    - axis is range (C-AR),
+    #       - (C-AR-all) and axis range fully contained in condition range: we can
+    #         scrap the condition because it's always true
+    #       - (C-AR-inter) and intersection(axis range, condition range) not empty:
+    #         keep the condition with the smaller range (= intersection)
+    #       - (C-AR-none) else, whole conditionset can be discarded
+    newRules: List[RuleDescriptor] = []
+    for rule in rules:
+        newRule: RuleDescriptor = RuleDescriptor(
+            name=rule.name, conditionSets=[], subs=rule.subs
+        )
+        for conditionset in rule.conditionSets:
+            cs = _conditionSetFrom(conditionset)
+            newConditionset: List[Dict[str, Any]] = []
+            discardConditionset = False
+            for selectionName, selectionValue in designRegion.items():
+                # TODO: Ensure that all(key in conditionset for key in region.keys())?
+                if selectionName not in cs:
+                    # raise Exception("Selection has different axes than the rules")
+                    continue
+                if isinstance(selectionValue, (float, int)):  # is point
+                    # Case C-AP-in
+                    if selectionValue in cs[selectionName]:
+                        pass  # always matches, conditionset can stay empty for this one.
+                    # Case C-AP-out
+                    else:
+                        discardConditionset = True
+                else:  # is range
+                    # Case C-AR-all
+                    if selectionValue in cs[selectionName]:
+                        pass  # always matches, conditionset can stay empty for this one.
+                    else:
+                        intersection = cs[selectionName].intersection(selectionValue)
+                        # Case C-AR-inter
+                        if intersection is not None:
+                            newConditionset.append(
+                                {
+                                    "name": selectionName,
+                                    "minimum": intersection.minimum,
+                                    "maximum": intersection.maximum,
+                                }
+                            )
+                        # Case C-AR-none
+                        else:
+                            discardConditionset = True
+            if not discardConditionset:
+                newRule.conditionSets.append(newConditionset)
+        if newRule.conditionSets:
+            newRules.append(newRule)
+
+    return newRules
+
+
+def _filterLocation(
+    userRegion: Region,
+    location: Dict[str, float],
+) -> Dict[str, float]:
+    return {
+        name: value
+        for name, value in location.items()
+        if name in userRegion and isinstance(userRegion[name], Range)
+    }

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/designspaceLib/statNames.py

@@ -0,0 +1,260 @@
+"""Compute name information for a given location in user-space coordinates
+using STAT data. This can be used to fill-in automatically the names of an
+instance:
+
+.. code:: python
+
+    instance = doc.instances[0]
+    names = getStatNames(doc, instance.getFullUserLocation(doc))
+    print(names.styleNames)
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, Literal, Optional, Tuple, Union
+import logging
+
+from fontTools.designspaceLib import (
+    AxisDescriptor,
+    AxisLabelDescriptor,
+    DesignSpaceDocument,
+    DiscreteAxisDescriptor,
+    SimpleLocationDict,
+    SourceDescriptor,
+)
+
+LOGGER = logging.getLogger(__name__)
+
+RibbiStyleName = Union[
+    Literal["regular"],
+    Literal["bold"],
+    Literal["italic"],
+    Literal["bold italic"],
+]
+
+BOLD_ITALIC_TO_RIBBI_STYLE = {
+    (False, False): "regular",
+    (False, True): "italic",
+    (True, False): "bold",
+    (True, True): "bold italic",
+}
+
+
+@dataclass
+class StatNames:
+    """Name data generated from the STAT table information."""
+
+    familyNames: Dict[str, str]
+    styleNames: Dict[str, str]
+    postScriptFontName: Optional[str]
+    styleMapFamilyNames: Dict[str, str]
+    styleMapStyleName: Optional[RibbiStyleName]
+
+
+def getStatNames(
+    doc: DesignSpaceDocument, userLocation: SimpleLocationDict
+) -> StatNames:
+    """Compute the family, style, PostScript names of the given ``userLocation``
+    using the document's STAT information.
+
+    Also computes localizations.
+
+    If not enough STAT data is available for a given name, either its dict of
+    localized names will be empty (family and style names), or the name will be
+    None (PostScript name).
+
+    Note: this method does not consider info attached to the instance, like
+    family name. The user needs to override all names on an instance that STAT
+    information would compute differently than desired.
+
+    .. versionadded:: 5.0
+    """
+    familyNames: Dict[str, str] = {}
+    defaultSource: Optional[SourceDescriptor] = doc.findDefault()
+    if defaultSource is None:
+        LOGGER.warning("Cannot determine default source to look up family name.")
+    elif defaultSource.familyName is None:
+        LOGGER.warning(
+            "Cannot look up family name, assign the 'familyname' attribute to the default source."
+        )
+    else:
+        familyNames = {
+            "en": defaultSource.familyName,
+            **defaultSource.localisedFamilyName,
+        }
+
+    styleNames: Dict[str, str] = {}
+    # If a free-standing label matches the location, use it for name generation.
+    label = doc.labelForUserLocation(userLocation)
+    if label is not None:
+        styleNames = {"en": label.name, **label.labelNames}
+    # Otherwise, scour the axis labels for matches.
+    else:
+        # Gather all languages in which at least one translation is provided
+        # Then build names for all these languages, but fallback to English
+        # whenever a translation is missing.
+        labels = _getAxisLabelsForUserLocation(doc.axes, userLocation)
+        if labels:
+            languages = set(
+                language for label in labels for language in label.labelNames
+            )
+            languages.add("en")
+            for language in languages:
+                styleName = " ".join(
+                    label.labelNames.get(language, label.defaultName)
+                    for label in labels
+                    if not label.elidable
+                )
+                if not styleName and doc.elidedFallbackName is not None:
+                    styleName = doc.elidedFallbackName
+                styleNames[language] = styleName
+
+    if "en" not in familyNames or "en" not in styleNames:
+        # Not enough information to compute PS names of styleMap names
+        return StatNames(
+            familyNames=familyNames,
+            styleNames=styleNames,
+            postScriptFontName=None,
+            styleMapFamilyNames={},
+            styleMapStyleName=None,
+        )
+
+    postScriptFontName = f"{familyNames['en']}-{styleNames['en']}".replace(" ", "")
+
+    styleMapStyleName, regularUserLocation = _getRibbiStyle(doc, userLocation)
+
+    styleNamesForStyleMap = styleNames
+    if regularUserLocation != userLocation:
+        regularStatNames = getStatNames(doc, regularUserLocation)
+        styleNamesForStyleMap = regularStatNames.styleNames
+
+    styleMapFamilyNames = {}
+    for language in set(familyNames).union(styleNames.keys()):
+        familyName = familyNames.get(language, familyNames["en"])
+        styleName = styleNamesForStyleMap.get(language, styleNamesForStyleMap["en"])
+        styleMapFamilyNames[language] = (familyName + " " + styleName).strip()
+
+    return StatNames(
+        familyNames=familyNames,
+        styleNames=styleNames,
+        postScriptFontName=postScriptFontName,
+        styleMapFamilyNames=styleMapFamilyNames,
+        styleMapStyleName=styleMapStyleName,
+    )
+
+
+def _getSortedAxisLabels(
+    axes: list[Union[AxisDescriptor, DiscreteAxisDescriptor]],
+) -> Dict[str, list[AxisLabelDescriptor]]:
+    """Returns axis labels sorted by their ordering, with unordered ones appended as
+    they are listed."""
+
+    # First, get the axis labels with explicit ordering...
+    sortedAxes = sorted(
+        (axis for axis in axes if axis.axisOrdering is not None),
+        key=lambda a: a.axisOrdering,
+    )
+    sortedLabels: Dict[str, list[AxisLabelDescriptor]] = {
+        axis.name: axis.axisLabels for axis in sortedAxes
+    }
+
+    # ... then append the others in the order they appear.
+    # NOTE: This relies on Python 3.7+ dict's preserved insertion order.
+    for axis in axes:
+        if axis.axisOrdering is None:
+            sortedLabels[axis.name] = axis.axisLabels
+
+    return sortedLabels
+
+
+def _getAxisLabelsForUserLocation(
+    axes: list[Union[AxisDescriptor, DiscreteAxisDescriptor]],
+    userLocation: SimpleLocationDict,
+) -> list[AxisLabelDescriptor]:
+    labels: list[AxisLabelDescriptor] = []
+
+    allAxisLabels = _getSortedAxisLabels(axes)
+    if allAxisLabels.keys() != userLocation.keys():
+        LOGGER.warning(
+            f"Mismatch between user location '{userLocation.keys()}' and available "
+            f"labels for '{allAxisLabels.keys()}'."
+        )
+
+    for axisName, axisLabels in allAxisLabels.items():
+        userValue = userLocation[axisName]
+        label: Optional[AxisLabelDescriptor] = next(
+            (
+                l
+                for l in axisLabels
+                if l.userValue == userValue
+                or (
+                    l.userMinimum is not None
+                    and l.userMaximum is not None
+                    and l.userMinimum <= userValue <= l.userMaximum
+                )
+            ),
+            None,
+        )
+        if label is None:
+            LOGGER.debug(
+                f"Document needs a label for axis '{axisName}', user value '{userValue}'."
+            )
+        else:
+            labels.append(label)
+
+    return labels
+
+
+def _getRibbiStyle(
+    self: DesignSpaceDocument, userLocation: SimpleLocationDict
+) -> Tuple[RibbiStyleName, SimpleLocationDict]:
+    """Compute the RIBBI style name of the given user location,
+    return the location of the matching Regular in the RIBBI group.
+
+    .. versionadded:: 5.0
+    """
+    regularUserLocation = {}
+    axes_by_tag = {axis.tag: axis for axis in self.axes}
+
+    bold: bool = False
+    italic: bool = False
+
+    axis = axes_by_tag.get("wght")
+    if axis is not None:
+        for regular_label in axis.axisLabels:
+            if (
+                regular_label.linkedUserValue == userLocation[axis.name]
+                # In the "recursive" case where both the Regular has
+                # linkedUserValue pointing the Bold, and the Bold has
+                # linkedUserValue pointing to the Regular, only consider the
+                # first case: Regular (e.g. 400) has linkedUserValue pointing to
+                # Bold (e.g. 700, higher than Regular)
+                and regular_label.userValue < regular_label.linkedUserValue
+            ):
+                regularUserLocation[axis.name] = regular_label.userValue
+                bold = True
+                break
+
+    axis = axes_by_tag.get("ital") or axes_by_tag.get("slnt")
+    if axis is not None:
+        for upright_label in axis.axisLabels:
+            if (
+                upright_label.linkedUserValue == userLocation[axis.name]
+                # In the "recursive" case where both the Upright has
+                # linkedUserValue pointing the Italic, and the Italic has
+                # linkedUserValue pointing to the Upright, only consider the
+                # first case: Upright (e.g. ital=0, slant=0) has
+                # linkedUserValue pointing to Italic (e.g ital=1, slant=-12 or
+                # slant=12 for backwards italics, in any case higher than
+                # Upright in absolute value, hence the abs() below.
+                and abs(upright_label.userValue) < abs(upright_label.linkedUserValue)
+            ):
+                regularUserLocation[axis.name] = upright_label.userValue
+                italic = True
+                break
+
+    return BOLD_ITALIC_TO_RIBBI_STYLE[bold, italic], {
+        **userLocation,
+        **regularUserLocation,
+    }

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/designspaceLib/types.py

@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Union, cast
+
+from fontTools.designspaceLib import (
+    AxisDescriptor,
+    DesignSpaceDocument,
+    DesignSpaceDocumentError,
+    RangeAxisSubsetDescriptor,
+    SimpleLocationDict,
+    ValueAxisSubsetDescriptor,
+    VariableFontDescriptor,
+)
+
+
+def clamp(value, minimum, maximum):
+    return min(max(value, minimum), maximum)
+
+
+@dataclass
+class Range:
+    minimum: float
+    """Inclusive minimum of the range."""
+    maximum: float
+    """Inclusive maximum of the range."""
+    default: float = 0
+    """Default value"""
+
+    def __post_init__(self):
+        self.minimum, self.maximum = sorted((self.minimum, self.maximum))
+        self.default = clamp(self.default, self.minimum, self.maximum)
+
+    def __contains__(self, value: Union[float, Range]) -> bool:
+        if isinstance(value, Range):
+            return self.minimum <= value.minimum and value.maximum <= self.maximum
+        return self.minimum <= value <= self.maximum
+
+    def intersection(self, other: Range) -> Optional[Range]:
+        if self.maximum < other.minimum or self.minimum > other.maximum:
+            return None
+        else:
+            return Range(
+                max(self.minimum, other.minimum),
+                min(self.maximum, other.maximum),
+                self.default,  # We don't care about the default in this use-case
+            )
+
+
+# A region selection is either a range or a single value, as a Designspace v5
+# axis-subset element only allows a single discrete value or a range for a
+# variable-font element.
+Region = Dict[str, Union[Range, float]]
+
+# A conditionset is a set of named ranges.
+ConditionSet = Dict[str, Range]
+
+# A rule is a list of conditionsets where any has to be relevant for the whole rule to be relevant.
+Rule = List[ConditionSet]
+Rules = Dict[str, Rule]
+
+
+def locationInRegion(location: SimpleLocationDict, region: Region) -> bool:
+    for name, value in location.items():
+        if name not in region:
+            return False
+        regionValue = region[name]
+        if isinstance(regionValue, (float, int)):
+            if value != regionValue:
+                return False
+        else:
+            if value not in regionValue:
+                return False
+    return True
+
+
+def regionInRegion(region: Region, superRegion: Region) -> bool:
+    for name, value in region.items():
+        if not name in superRegion:
+            return False
+        superValue = superRegion[name]
+        if isinstance(superValue, (float, int)):
+            if value != superValue:
+                return False
+        else:
+            if value not in superValue:
+                return False
+    return True
+
+
+def userRegionToDesignRegion(doc: DesignSpaceDocument, userRegion: Region) -> Region:
+    designRegion = {}
+    for name, value in userRegion.items():
+        axis = doc.getAxis(name)
+        if axis is None:
+            raise DesignSpaceDocumentError(
+                f"Cannot find axis named '{name}' for region."
+            )
+        if isinstance(value, (float, int)):
+            designRegion[name] = axis.map_forward(value)
+        else:
+            designRegion[name] = Range(
+                axis.map_forward(value.minimum),
+                axis.map_forward(value.maximum),
+                axis.map_forward(value.default),
+            )
+    return designRegion
+
+
+def getVFUserRegion(doc: DesignSpaceDocument, vf: VariableFontDescriptor) -> Region:
+    vfUserRegion: Region = {}
+    # For each axis, 2 cases:
+    #  - it has a range = it's an axis in the VF DS
+    #  - it's a single location = use it to know which rules should apply in the VF
+    for axisSubset in vf.axisSubsets:
+        axis = doc.getAxis(axisSubset.name)
+        if axis is None:
+            raise DesignSpaceDocumentError(
+                f"Cannot find axis named '{axisSubset.name}' for variable font '{vf.name}'."
+            )
+        if hasattr(axisSubset, "userMinimum"):
+            # Mypy doesn't support narrowing union types via hasattr()
+            # TODO(Python 3.10): use TypeGuard
+            # https://mypy.readthedocs.io/en/stable/type_narrowing.html
+            axisSubset = cast(RangeAxisSubsetDescriptor, axisSubset)
+            if not hasattr(axis, "minimum"):
+                raise DesignSpaceDocumentError(
+                    f"Cannot select a range over '{axis.name}' for variable font '{vf.name}' "
+                    "because it's a discrete axis, use only 'userValue' instead."
+                )
+            axis = cast(AxisDescriptor, axis)
+            vfUserRegion[axis.name] = Range(
+                max(axisSubset.userMinimum, axis.minimum),
+                min(axisSubset.userMaximum, axis.maximum),
+                axisSubset.userDefault or axis.default,
+            )
+        else:
+            axisSubset = cast(ValueAxisSubsetDescriptor, axisSubset)
+            vfUserRegion[axis.name] = axisSubset.userValue
+    # Any axis not mentioned explicitly has a single location = default value
+    for axis in doc.axes:
+        if axis.name not in vfUserRegion:
+            assert isinstance(
+                axis.default, (int, float)
+            ), f"Axis '{axis.name}' has no valid default value."
+            vfUserRegion[axis.name] = axis.default
+    return vfUserRegion

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/fontBuilder.py

@@ -0,0 +1,1014 @@
+__all__ = ["FontBuilder"]
+
+"""
+This module is *experimental*, meaning it still may evolve and change.
+
+The `FontBuilder` class is a convenient helper to construct working TTF or
+OTF fonts from scratch.
+
+Note that the various setup methods cannot be called in arbitrary order,
+due to various interdependencies between OpenType tables. Here is an order
+that works:
+
+    fb = FontBuilder(...)
+    fb.setupGlyphOrder(...)
+    fb.setupCharacterMap(...)
+    fb.setupGlyf(...) --or-- fb.setupCFF(...)
+    fb.setupHorizontalMetrics(...)
+    fb.setupHorizontalHeader()
+    fb.setupNameTable(...)
+    fb.setupOS2()
+    fb.addOpenTypeFeatures(...)
+    fb.setupPost()
+    fb.save(...)
+
+Here is how to build a minimal TTF:
+
+```python
+from fontTools.fontBuilder import FontBuilder
+from fontTools.pens.ttGlyphPen import TTGlyphPen
+
+
+def drawTestGlyph(pen):
+    pen.moveTo((100, 100))
+    pen.lineTo((100, 1000))
+    pen.qCurveTo((200, 900), (400, 900), (500, 1000))
+    pen.lineTo((500, 100))
+    pen.closePath()
+
+
+fb = FontBuilder(1024, isTTF=True)
+fb.setupGlyphOrder([".notdef", ".null", "space", "A", "a"])
+fb.setupCharacterMap({32: "space", 65: "A", 97: "a"})
+advanceWidths = {".notdef": 600, "space": 500, "A": 600, "a": 600, ".null": 0}
+
+familyName = "HelloTestFont"
+styleName = "TotallyNormal"
+version = "0.1"
+
+nameStrings = dict(
+    familyName=dict(en=familyName, nl="HalloTestFont"),
+    styleName=dict(en=styleName, nl="TotaalNormaal"),
+    uniqueFontIdentifier="fontBuilder: " + familyName + "." + styleName,
+    fullName=familyName + "-" + styleName,
+    psName=familyName + "-" + styleName,
+    version="Version " + version,
+)
+
+pen = TTGlyphPen(None)
+drawTestGlyph(pen)
+glyph = pen.glyph()
+glyphs = {".notdef": glyph, "space": glyph, "A": glyph, "a": glyph, ".null": glyph}
+fb.setupGlyf(glyphs)
+metrics = {}
+glyphTable = fb.font["glyf"]
+for gn, advanceWidth in advanceWidths.items():
+    metrics[gn] = (advanceWidth, glyphTable[gn].xMin)
+fb.setupHorizontalMetrics(metrics)
+fb.setupHorizontalHeader(ascent=824, descent=-200)
+fb.setupNameTable(nameStrings)
+fb.setupOS2(sTypoAscender=824, usWinAscent=824, usWinDescent=200)
+fb.setupPost()
+fb.save("test.ttf")
+```
+
+And here's how to build a minimal OTF:
+
+```python
+from fontTools.fontBuilder import FontBuilder
+from fontTools.pens.t2CharStringPen import T2CharStringPen
+
+
+def drawTestGlyph(pen):
+    pen.moveTo((100, 100))
+    pen.lineTo((100, 1000))
+    pen.curveTo((200, 900), (400, 900), (500, 1000))
+    pen.lineTo((500, 100))
+    pen.closePath()
+
+
+fb = FontBuilder(1024, isTTF=False)
+fb.setupGlyphOrder([".notdef", ".null", "space", "A", "a"])
+fb.setupCharacterMap({32: "space", 65: "A", 97: "a"})
+advanceWidths = {".notdef": 600, "space": 500, "A": 600, "a": 600, ".null": 0}
+
+familyName = "HelloTestFont"
+styleName = "TotallyNormal"
+version = "0.1"
+
+nameStrings = dict(
+    familyName=dict(en=familyName, nl="HalloTestFont"),
+    styleName=dict(en=styleName, nl="TotaalNormaal"),
+    uniqueFontIdentifier="fontBuilder: " + familyName + "." + styleName,
+    fullName=familyName + "-" + styleName,
+    psName=familyName + "-" + styleName,
+    version="Version " + version,
+)
+
+pen = T2CharStringPen(600, None)
+drawTestGlyph(pen)
+charString = pen.getCharString()
+charStrings = {
+    ".notdef": charString,
+    "space": charString,
+    "A": charString,
+    "a": charString,
+    ".null": charString,
+}
+fb.setupCFF(nameStrings["psName"], {"FullName": nameStrings["psName"]}, charStrings, {})
+lsb = {gn: cs.calcBounds(None)[0] for gn, cs in charStrings.items()}
+metrics = {}
+for gn, advanceWidth in advanceWidths.items():
+    metrics[gn] = (advanceWidth, lsb[gn])
+fb.setupHorizontalMetrics(metrics)
+fb.setupHorizontalHeader(ascent=824, descent=200)
+fb.setupNameTable(nameStrings)
+fb.setupOS2(sTypoAscender=824, usWinAscent=824, usWinDescent=200)
+fb.setupPost()
+fb.save("test.otf")
+```
+"""
+
+from .ttLib import TTFont, newTable
+from .ttLib.tables._c_m_a_p import cmap_classes
+from .ttLib.tables._g_l_y_f import flagCubic
+from .ttLib.tables.O_S_2f_2 import Panose
+from .misc.timeTools import timestampNow
+import struct
+from collections import OrderedDict
+
+
+_headDefaults = dict(
+    tableVersion=1.0,
+    fontRevision=1.0,
+    checkSumAdjustment=0,
+    magicNumber=0x5F0F3CF5,
+    flags=0x0003,
+    unitsPerEm=1000,
+    created=0,
+    modified=0,
+    xMin=0,
+    yMin=0,
+    xMax=0,
+    yMax=0,
+    macStyle=0,
+    lowestRecPPEM=3,
+    fontDirectionHint=2,
+    indexToLocFormat=0,
+    glyphDataFormat=0,
+)
+
+_maxpDefaultsTTF = dict(
+    tableVersion=0x00010000,
+    numGlyphs=0,
+    maxPoints=0,
+    maxContours=0,
+    maxCompositePoints=0,
+    maxCompositeContours=0,
+    maxZones=2,
+    maxTwilightPoints=0,
+    maxStorage=0,
+    maxFunctionDefs=0,
+    maxInstructionDefs=0,
+    maxStackElements=0,
+    maxSizeOfInstructions=0,
+    maxComponentElements=0,
+    maxComponentDepth=0,
+)
+_maxpDefaultsOTF = dict(
+    tableVersion=0x00005000,
+    numGlyphs=0,
+)
+
+_postDefaults = dict(
+    formatType=3.0,
+    italicAngle=0,
+    underlinePosition=0,
+    underlineThickness=0,
+    isFixedPitch=0,
+    minMemType42=0,
+    maxMemType42=0,
+    minMemType1=0,
+    maxMemType1=0,
+)
+
+_hheaDefaults = dict(
+    tableVersion=0x00010000,
+    ascent=0,
+    descent=0,
+    lineGap=0,
+    advanceWidthMax=0,
+    minLeftSideBearing=0,
+    minRightSideBearing=0,
+    xMaxExtent=0,
+    caretSlopeRise=1,
+    caretSlopeRun=0,
+    caretOffset=0,
+    reserved0=0,
+    reserved1=0,
+    reserved2=0,
+    reserved3=0,
+    metricDataFormat=0,
+    numberOfHMetrics=0,
+)
+
+_vheaDefaults = dict(
+    tableVersion=0x00010000,
+    ascent=0,
+    descent=0,
+    lineGap=0,
+    advanceHeightMax=0,
+    minTopSideBearing=0,
+    minBottomSideBearing=0,
+    yMaxExtent=0,
+    caretSlopeRise=0,
+    caretSlopeRun=0,
+    reserved0=0,
+    reserved1=0,
+    reserved2=0,
+    reserved3=0,
+    reserved4=0,
+    metricDataFormat=0,
+    numberOfVMetrics=0,
+)
+
+_nameIDs = dict(
+    copyright=0,
+    familyName=1,
+    styleName=2,
+    uniqueFontIdentifier=3,
+    fullName=4,
+    version=5,
+    psName=6,
+    trademark=7,
+    manufacturer=8,
+    designer=9,
+    description=10,
+    vendorURL=11,
+    designerURL=12,
+    licenseDescription=13,
+    licenseInfoURL=14,
+    # reserved = 15,
+    typographicFamily=16,
+    typographicSubfamily=17,
+    compatibleFullName=18,
+    sampleText=19,
+    postScriptCIDFindfontName=20,
+    wwsFamilyName=21,
+    wwsSubfamilyName=22,
+    lightBackgroundPalette=23,
+    darkBackgroundPalette=24,
+    variationsPostScriptNamePrefix=25,
+)
+
+# to insert in setupNameTable doc string:
+# print("\n".join(("%s (nameID %s)" % (k, v)) for k, v in sorted(_nameIDs.items(), key=lambda x: x[1])))
+
+_panoseDefaults = Panose()
+
+_OS2Defaults = dict(
+    version=3,
+    xAvgCharWidth=0,
+    usWeightClass=400,
+    usWidthClass=5,
+    fsType=0x0004,  # default: Preview & Print embedding
+    ySubscriptXSize=0,
+    ySubscriptYSize=0,
+    ySubscriptXOffset=0,
+    ySubscriptYOffset=0,
+    ySuperscriptXSize=0,
+    ySuperscriptYSize=0,
+    ySuperscriptXOffset=0,
+    ySuperscriptYOffset=0,
+    yStrikeoutSize=0,
+    yStrikeoutPosition=0,
+    sFamilyClass=0,
+    panose=_panoseDefaults,
+    ulUnicodeRange1=0,
+    ulUnicodeRange2=0,
+    ulUnicodeRange3=0,
+    ulUnicodeRange4=0,
+    achVendID="????",
+    fsSelection=0,
+    usFirstCharIndex=0,
+    usLastCharIndex=0,
+    sTypoAscender=0,
+    sTypoDescender=0,
+    sTypoLineGap=0,
+    usWinAscent=0,
+    usWinDescent=0,
+    ulCodePageRange1=0,
+    ulCodePageRange2=0,
+    sxHeight=0,
+    sCapHeight=0,
+    usDefaultChar=0,  # .notdef
+    usBreakChar=32,  # space
+    usMaxContext=0,
+    usLowerOpticalPointSize=0,
+    usUpperOpticalPointSize=0,
+)
+
+
+class FontBuilder(object):
+    def __init__(self, unitsPerEm=None, font=None, isTTF=True, glyphDataFormat=0):
+        """Initialize a FontBuilder instance.
+
+        If the `font` argument is not given, a new `TTFont` will be
+        constructed, and `unitsPerEm` must be given. If `isTTF` is True,
+        the font will be a glyf-based TTF; if `isTTF` is False it will be
+        a CFF-based OTF.
+
+        The `glyphDataFormat` argument corresponds to the `head` table field
+        that defines the format of the TrueType `glyf` table (default=0).
+        TrueType glyphs historically can only contain quadratic splines and static
+        components, but there's a proposal to add support for cubic Bezier curves as well
+        as variable composites/components at
+        https://github.com/harfbuzz/boring-expansion-spec/blob/main/glyf1.md
+        You can experiment with the new features by setting `glyphDataFormat` to 1.
+        A ValueError is raised if `glyphDataFormat` is left at 0 but glyphs are added
+        that contain cubic splines or varcomposites. This is to prevent accidentally
+        creating fonts that are incompatible with existing TrueType implementations.
+
+        If `font` is given, it must be a `TTFont` instance and `unitsPerEm`
+        must _not_ be given. The `isTTF` and `glyphDataFormat` arguments will be ignored.
+        """
+        if font is None:
+            self.font = TTFont(recalcTimestamp=False)
+            self.isTTF = isTTF
+            now = timestampNow()
+            assert unitsPerEm is not None
+            self.setupHead(
+                unitsPerEm=unitsPerEm,
+                created=now,
+                modified=now,
+                glyphDataFormat=glyphDataFormat,
+            )
+            self.setupMaxp()
+        else:
+            assert unitsPerEm is None
+            self.font = font
+            self.isTTF = "glyf" in font
+
+    def save(self, file):
+        """Save the font. The 'file' argument can be either a pathname or a
+        writable file object.
+        """
+        self.font.save(file)
+
+    def _initTableWithValues(self, tableTag, defaults, values):
+        table = self.font[tableTag] = newTable(tableTag)
+        for k, v in defaults.items():
+            setattr(table, k, v)
+        for k, v in values.items():
+            setattr(table, k, v)
+        return table
+
+    def _updateTableWithValues(self, tableTag, values):
+        table = self.font[tableTag]
+        for k, v in values.items():
+            setattr(table, k, v)
+
+    def setupHead(self, **values):
+        """Create a new `head` table and initialize it with default values,
+        which can be overridden by keyword arguments.
+        """
+        self._initTableWithValues("head", _headDefaults, values)
+
+    def updateHead(self, **values):
+        """Update the head table with the fields and values passed as
+        keyword arguments.
+        """
+        self._updateTableWithValues("head", values)
+
+    def setupGlyphOrder(self, glyphOrder):
+        """Set the glyph order for the font."""
+        self.font.setGlyphOrder(glyphOrder)
+
+    def setupCharacterMap(self, cmapping, uvs=None, allowFallback=False):
+        """Build the `cmap` table for the font. The `cmapping` argument should
+        be a dict mapping unicode code points as integers to glyph names.
+
+        The `uvs` argument, when passed, must be a list of tuples, describing
+        Unicode Variation Sequences. These tuples have three elements:
+            (unicodeValue, variationSelector, glyphName)
+        `unicodeValue` and `variationSelector` are integer code points.
+        `glyphName` may be None, to indicate this is the default variation.
+        Text processors will then use the cmap to find the glyph name.
+        Each Unicode Variation Sequence should be an officially supported
+        sequence, but this is not policed.
+        """
+        subTables = []
+        highestUnicode = max(cmapping) if cmapping else 0
+        if highestUnicode > 0xFFFF:
+            cmapping_3_1 = dict((k, v) for k, v in cmapping.items() if k < 0x10000)
+            subTable_3_10 = buildCmapSubTable(cmapping, 12, 3, 10)
+            subTables.append(subTable_3_10)
+        else:
+            cmapping_3_1 = cmapping
+        format = 4
+        subTable_3_1 = buildCmapSubTable(cmapping_3_1, format, 3, 1)
+        try:
+            subTable_3_1.compile(self.font)
+        except struct.error:
+            # format 4 overflowed, fall back to format 12
+            if not allowFallback:
+                raise ValueError(
+                    "cmap format 4 subtable overflowed; sort glyph order by unicode to fix."
+                )
+            format = 12
+            subTable_3_1 = buildCmapSubTable(cmapping_3_1, format, 3, 1)
+        subTables.append(subTable_3_1)
+        subTable_0_3 = buildCmapSubTable(cmapping_3_1, format, 0, 3)
+        subTables.append(subTable_0_3)
+
+        if uvs is not None:
+            uvsDict = {}
+            for unicodeValue, variationSelector, glyphName in uvs:
+                if cmapping.get(unicodeValue) == glyphName:
+                    # this is a default variation
+                    glyphName = None
+                if variationSelector not in uvsDict:
+                    uvsDict[variationSelector] = []
+                uvsDict[variationSelector].append((unicodeValue, glyphName))
+            uvsSubTable = buildCmapSubTable({}, 14, 0, 5)
+            uvsSubTable.uvsDict = uvsDict
+            subTables.append(uvsSubTable)
+
+        self.font["cmap"] = newTable("cmap")
+        self.font["cmap"].tableVersion = 0
+        self.font["cmap"].tables = subTables
+
+    def setupNameTable(self, nameStrings, windows=True, mac=True):
+        """Create the `name` table for the font. The `nameStrings` argument must
+        be a dict, mapping nameIDs or descriptive names for the nameIDs to name
+        record values. A value is either a string, or a dict, mapping language codes
+        to strings, to allow localized name table entries.
+
+        By default, both Windows (platformID=3) and Macintosh (platformID=1) name
+        records are added, unless any of `windows` or `mac` arguments is False.
+
+        The following descriptive names are available for nameIDs:
+
+            copyright (nameID 0)
+            familyName (nameID 1)
+            styleName (nameID 2)
+            uniqueFontIdentifier (nameID 3)
+            fullName (nameID 4)
+            version (nameID 5)
+            psName (nameID 6)
+            trademark (nameID 7)
+            manufacturer (nameID 8)
+            designer (nameID 9)
+            description (nameID 10)
+            vendorURL (nameID 11)
+            designerURL (nameID 12)
+            licenseDescription (nameID 13)
+            licenseInfoURL (nameID 14)
+            typographicFamily (nameID 16)
+            typographicSubfamily (nameID 17)
+            compatibleFullName (nameID 18)
+            sampleText (nameID 19)
+            postScriptCIDFindfontName (nameID 20)
+            wwsFamilyName (nameID 21)
+            wwsSubfamilyName (nameID 22)
+            lightBackgroundPalette (nameID 23)
+            darkBackgroundPalette (nameID 24)
+            variationsPostScriptNamePrefix (nameID 25)
+        """
+        nameTable = self.font["name"] = newTable("name")
+        nameTable.names = []
+
+        for nameName, nameValue in nameStrings.items():
+            if isinstance(nameName, int):
+                nameID = nameName
+            else:
+                nameID = _nameIDs[nameName]
+            if isinstance(nameValue, str):
+                nameValue = dict(en=nameValue)
+            nameTable.addMultilingualName(
+                nameValue, ttFont=self.font, nameID=nameID, windows=windows, mac=mac
+            )
+
+    def setupOS2(self, **values):
+        """Create a new `OS/2` table and initialize it with default values,
+        which can be overridden by keyword arguments.
+        """
+        self._initTableWithValues("OS/2", _OS2Defaults, values)
+        if "xAvgCharWidth" not in values:
+            assert (
+                "hmtx" in self.font
+            ), "the 'hmtx' table must be setup before the 'OS/2' table"
+            self.font["OS/2"].recalcAvgCharWidth(self.font)
+        if not (
+            "ulUnicodeRange1" in values
+            or "ulUnicodeRange2" in values
+            or "ulUnicodeRange3" in values
+            or "ulUnicodeRange3" in values
+        ):
+            assert (
+                "cmap" in self.font
+            ), "the 'cmap' table must be setup before the 'OS/2' table"
+            self.font["OS/2"].recalcUnicodeRanges(self.font)
+
+    def setupCFF(self, psName, fontInfo, charStringsDict, privateDict):
+        from .cffLib import (
+            CFFFontSet,
+            TopDictIndex,
+            TopDict,
+            CharStrings,
+            GlobalSubrsIndex,
+            PrivateDict,
+        )
+
+        assert not self.isTTF
+        self.font.sfntVersion = "OTTO"
+        fontSet = CFFFontSet()
+        fontSet.major = 1
+        fontSet.minor = 0
+        fontSet.otFont = self.font
+        fontSet.fontNames = [psName]
+        fontSet.topDictIndex = TopDictIndex()
+
+        globalSubrs = GlobalSubrsIndex()
+        fontSet.GlobalSubrs = globalSubrs
+        private = PrivateDict()
+        for key, value in privateDict.items():
+            setattr(private, key, value)
+        fdSelect = None
+        fdArray = None
+
+        topDict = TopDict()
+        topDict.charset = self.font.getGlyphOrder()
+        topDict.Private = private
+        topDict.GlobalSubrs = fontSet.GlobalSubrs
+        for key, value in fontInfo.items():
+            setattr(topDict, key, value)
+        if "FontMatrix" not in fontInfo:
+            scale = 1 / self.font["head"].unitsPerEm
+            topDict.FontMatrix = [scale, 0, 0, scale, 0, 0]
+
+        charStrings = CharStrings(
+            None, topDict.charset, globalSubrs, private, fdSelect, fdArray
+        )
+        for glyphName, charString in charStringsDict.items():
+            charString.private = private
+            charString.globalSubrs = globalSubrs
+            charStrings[glyphName] = charString
+        topDict.CharStrings = charStrings
+
+        fontSet.topDictIndex.append(topDict)
+
+        self.font["CFF "] = newTable("CFF ")
+        self.font["CFF "].cff = fontSet
+
+    def setupCFF2(self, charStringsDict, fdArrayList=None, regions=None):
+        from .cffLib import (
+            CFFFontSet,
+            TopDictIndex,
+            TopDict,
+            CharStrings,
+            GlobalSubrsIndex,
+            PrivateDict,
+            FDArrayIndex,
+            FontDict,
+        )
+
+        assert not self.isTTF
+        self.font.sfntVersion = "OTTO"
+        fontSet = CFFFontSet()
+        fontSet.major = 2
+        fontSet.minor = 0
+
+        cff2GetGlyphOrder = self.font.getGlyphOrder
+        fontSet.topDictIndex = TopDictIndex(None, cff2GetGlyphOrder, None)
+
+        globalSubrs = GlobalSubrsIndex()
+        fontSet.GlobalSubrs = globalSubrs
+
+        if fdArrayList is None:
+            fdArrayList = [{}]
+        fdSelect = None
+        fdArray = FDArrayIndex()
+        fdArray.strings = None
+        fdArray.GlobalSubrs = globalSubrs
+        for privateDict in fdArrayList:
+            fontDict = FontDict()
+            fontDict.setCFF2(True)
+            private = PrivateDict()
+            for key, value in privateDict.items():
+                setattr(private, key, value)
+            fontDict.Private = private
+            fdArray.append(fontDict)
+
+        topDict = TopDict()
+        topDict.cff2GetGlyphOrder = cff2GetGlyphOrder
+        topDict.FDArray = fdArray
+        scale = 1 / self.font["head"].unitsPerEm
+        topDict.FontMatrix = [scale, 0, 0, scale, 0, 0]
+
+        private = fdArray[0].Private
+        charStrings = CharStrings(None, None, globalSubrs, private, fdSelect, fdArray)
+        for glyphName, charString in charStringsDict.items():
+            charString.private = private
+            charString.globalSubrs = globalSubrs
+            charStrings[glyphName] = charString
+        topDict.CharStrings = charStrings
+
+        fontSet.topDictIndex.append(topDict)
+
+        self.font["CFF2"] = newTable("CFF2")
+        self.font["CFF2"].cff = fontSet
+
+        if regions:
+            self.setupCFF2Regions(regions)
+
+    def setupCFF2Regions(self, regions):
+        from .varLib.builder import buildVarRegionList, buildVarData, buildVarStore
+        from .cffLib import VarStoreData
+
+        assert "fvar" in self.font, "fvar must to be set up first"
+        assert "CFF2" in self.font, "CFF2 must to be set up first"
+        axisTags = [a.axisTag for a in self.font["fvar"].axes]
+        varRegionList = buildVarRegionList(regions, axisTags)
+        varData = buildVarData(list(range(len(regions))), None, optimize=False)
+        varStore = buildVarStore(varRegionList, [varData])
+        vstore = VarStoreData(otVarStore=varStore)
+        topDict = self.font["CFF2"].cff.topDictIndex[0]
+        topDict.VarStore = vstore
+        for fontDict in topDict.FDArray:
+            fontDict.Private.vstore = vstore
+
+    def setupGlyf(self, glyphs, calcGlyphBounds=True, validateGlyphFormat=True):
+        """Create the `glyf` table from a dict, that maps glyph names
+        to `fontTools.ttLib.tables._g_l_y_f.Glyph` objects, for example
+        as made by `fontTools.pens.ttGlyphPen.TTGlyphPen`.
+
+        If `calcGlyphBounds` is True, the bounds of all glyphs will be
+        calculated. Only pass False if your glyph objects already have
+        their bounding box values set.
+
+        If `validateGlyphFormat` is True, raise ValueError if any of the glyphs contains
+        cubic curves or is a variable composite but head.glyphDataFormat=0.
+        Set it to False to skip the check if you know in advance all the glyphs are
+        compatible with the specified glyphDataFormat.
+        """
+        assert self.isTTF
+
+        if validateGlyphFormat and self.font["head"].glyphDataFormat == 0:
+            for name, g in glyphs.items():
+                if g.numberOfContours > 0 and any(f & flagCubic for f in g.flags):
+                    raise ValueError(
+                        f"Glyph {name!r} has cubic Bezier outlines, but glyphDataFormat=0; "
+                        "either convert to quadratics with cu2qu or set glyphDataFormat=1."
+                    )
+
+        self.font["loca"] = newTable("loca")
+        self.font["glyf"] = newTable("glyf")
+        self.font["glyf"].glyphs = glyphs
+        if hasattr(self.font, "glyphOrder"):
+            self.font["glyf"].glyphOrder = self.font.glyphOrder
+        if calcGlyphBounds:
+            self.calcGlyphBounds()
+
+    def setupFvar(self, axes, instances):
+        """Adds an font variations table to the font.
+
+        Args:
+            axes (list): See below.
+            instances (list): See below.
+
+        ``axes`` should be a list of axes, with each axis either supplied as
+        a py:class:`.designspaceLib.AxisDescriptor` object, or a tuple in the
+        format ```tupletag, minValue, defaultValue, maxValue, name``.
+        The ``name`` is either a string, or a dict, mapping language codes
+        to strings, to allow localized name table entries.
+
+        ```instances`` should be a list of instances, with each instance either
+        supplied as a py:class:`.designspaceLib.InstanceDescriptor` object, or a
+        dict with keys ``location`` (mapping of axis tags to float values),
+        ``stylename`` and (optionally) ``postscriptfontname``.
+        The ``stylename`` is either a string, or a dict, mapping language codes
+        to strings, to allow localized name table entries.
+        """
+
+        addFvar(self.font, axes, instances)
+
+    def setupAvar(self, axes, mappings=None):
+        """Adds an axis variations table to the font.
+
+        Args:
+            axes (list): A list of py:class:`.designspaceLib.AxisDescriptor` objects.
+        """
+        from .varLib import _add_avar
+
+        if "fvar" not in self.font:
+            raise KeyError("'fvar' table is missing; can't add 'avar'.")
+
+        axisTags = [axis.axisTag for axis in self.font["fvar"].axes]
+        axes = OrderedDict(enumerate(axes))  # Only values are used
+        _add_avar(self.font, axes, mappings, axisTags)
+
+    def setupGvar(self, variations):
+        gvar = self.font["gvar"] = newTable("gvar")
+        gvar.version = 1
+        gvar.reserved = 0
+        gvar.variations = variations
+
+    def setupGVAR(self, variations):
+        gvar = self.font["GVAR"] = newTable("GVAR")
+        gvar.version = 1
+        gvar.reserved = 0
+        gvar.variations = variations
+
+    def calcGlyphBounds(self):
+        """Calculate the bounding boxes of all glyphs in the `glyf` table.
+        This is usually not called explicitly by client code.
+        """
+        glyphTable = self.font["glyf"]
+        for glyph in glyphTable.glyphs.values():
+            glyph.recalcBounds(glyphTable)
+
+    def setupHorizontalMetrics(self, metrics):
+        """Create a new `hmtx` table, for horizontal metrics.
+
+        The `metrics` argument must be a dict, mapping glyph names to
+        `(width, leftSidebearing)` tuples.
+        """
+        self.setupMetrics("hmtx", metrics)
+
+    def setupVerticalMetrics(self, metrics):
+        """Create a new `vmtx` table, for horizontal metrics.
+
+        The `metrics` argument must be a dict, mapping glyph names to
+        `(height, topSidebearing)` tuples.
+        """
+        self.setupMetrics("vmtx", metrics)
+
+    def setupMetrics(self, tableTag, metrics):
+        """See `setupHorizontalMetrics()` and `setupVerticalMetrics()`."""
+        assert tableTag in ("hmtx", "vmtx")
+        mtxTable = self.font[tableTag] = newTable(tableTag)
+        roundedMetrics = {}
+        for gn in metrics:
+            w, lsb = metrics[gn]
+            roundedMetrics[gn] = int(round(w)), int(round(lsb))
+        mtxTable.metrics = roundedMetrics
+
+    def setupHorizontalHeader(self, **values):
+        """Create a new `hhea` table initialize it with default values,
+        which can be overridden by keyword arguments.
+        """
+        self._initTableWithValues("hhea", _hheaDefaults, values)
+
+    def setupVerticalHeader(self, **values):
+        """Create a new `vhea` table initialize it with default values,
+        which can be overridden by keyword arguments.
+        """
+        self._initTableWithValues("vhea", _vheaDefaults, values)
+
+    def setupVerticalOrigins(self, verticalOrigins, defaultVerticalOrigin=None):
+        """Create a new `VORG` table. The `verticalOrigins` argument must be
+        a dict, mapping glyph names to vertical origin values.
+
+        The `defaultVerticalOrigin` argument should be the most common vertical
+        origin value. If omitted, this value will be derived from the actual
+        values in the `verticalOrigins` argument.
+        """
+        if defaultVerticalOrigin is None:
+            # find the most frequent vorg value
+            bag = {}
+            for gn in verticalOrigins:
+                vorg = verticalOrigins[gn]
+                if vorg not in bag:
+                    bag[vorg] = 1
+                else:
+                    bag[vorg] += 1
+            defaultVerticalOrigin = sorted(
+                bag, key=lambda vorg: bag[vorg], reverse=True
+            )[0]
+        self._initTableWithValues(
+            "VORG",
+            {},
+            dict(VOriginRecords={}, defaultVertOriginY=defaultVerticalOrigin),
+        )
+        vorgTable = self.font["VORG"]
+        vorgTable.majorVersion = 1
+        vorgTable.minorVersion = 0
+        for gn in verticalOrigins:
+            vorgTable[gn] = verticalOrigins[gn]
+
+    def setupPost(self, keepGlyphNames=True, **values):
+        """Create a new `post` table and initialize it with default values,
+        which can be overridden by keyword arguments.
+        """
+        isCFF2 = "CFF2" in self.font
+        postTable = self._initTableWithValues("post", _postDefaults, values)
+        if (self.isTTF or isCFF2) and keepGlyphNames:
+            postTable.formatType = 2.0
+            postTable.extraNames = []
+            postTable.mapping = {}
+        else:
+            postTable.formatType = 3.0
+
+    def setupMaxp(self):
+        """Create a new `maxp` table. This is called implicitly by FontBuilder
+        itself and is usually not called by client code.
+        """
+        if self.isTTF:
+            defaults = _maxpDefaultsTTF
+        else:
+            defaults = _maxpDefaultsOTF
+        self._initTableWithValues("maxp", defaults, {})
+
+    def setupDummyDSIG(self):
+        """This adds an empty DSIG table to the font to make some MS applications
+        happy. This does not properly sign the font.
+        """
+        values = dict(
+            ulVersion=1,
+            usFlag=0,
+            usNumSigs=0,
+            signatureRecords=[],
+        )
+        self._initTableWithValues("DSIG", {}, values)
+
+    def addOpenTypeFeatures(self, features, filename=None, tables=None, debug=False):
+        """Add OpenType features to the font from a string containing
+        Feature File syntax.
+
+        The `filename` argument is used in error messages and to determine
+        where to look for "include" files.
+
+        The optional `tables` argument can be a list of OTL tables tags to
+        build, allowing the caller to only build selected OTL tables. See
+        `fontTools.feaLib` for details.
+
+        The optional `debug` argument controls whether to add source debugging
+        information to the font in the `Debg` table.
+        """
+        from .feaLib.builder import addOpenTypeFeaturesFromString
+
+        addOpenTypeFeaturesFromString(
+            self.font, features, filename=filename, tables=tables, debug=debug
+        )
+
+    def addFeatureVariations(self, conditionalSubstitutions, featureTag="rvrn"):
+        """Add conditional substitutions to a Variable Font.
+
+        See `fontTools.varLib.featureVars.addFeatureVariations`.
+        """
+        from .varLib import featureVars
+
+        if "fvar" not in self.font:
+            raise KeyError("'fvar' table is missing; can't add FeatureVariations.")
+
+        featureVars.addFeatureVariations(
+            self.font, conditionalSubstitutions, featureTag=featureTag
+        )
+
+    def setupCOLR(
+        self,
+        colorLayers,
+        version=None,
+        varStore=None,
+        varIndexMap=None,
+        clipBoxes=None,
+        allowLayerReuse=True,
+    ):
+        """Build new COLR table using color layers dictionary.
+
+        Cf. `fontTools.colorLib.builder.buildCOLR`.
+        """
+        from fontTools.colorLib.builder import buildCOLR
+
+        glyphMap = self.font.getReverseGlyphMap()
+        self.font["COLR"] = buildCOLR(
+            colorLayers,
+            version=version,
+            glyphMap=glyphMap,
+            varStore=varStore,
+            varIndexMap=varIndexMap,
+            clipBoxes=clipBoxes,
+            allowLayerReuse=allowLayerReuse,
+        )
+
+    def setupCPAL(
+        self,
+        palettes,
+        paletteTypes=None,
+        paletteLabels=None,
+        paletteEntryLabels=None,
+    ):
+        """Build new CPAL table using list of palettes.
+
+        Optionally build CPAL v1 table using paletteTypes, paletteLabels and
+        paletteEntryLabels.
+
+        Cf. `fontTools.colorLib.builder.buildCPAL`.
+        """
+        from fontTools.colorLib.builder import buildCPAL
+
+        self.font["CPAL"] = buildCPAL(
+            palettes,
+            paletteTypes=paletteTypes,
+            paletteLabels=paletteLabels,
+            paletteEntryLabels=paletteEntryLabels,
+            nameTable=self.font.get("name"),
+        )
+
+    def setupStat(self, axes, locations=None, elidedFallbackName=2):
+        """Build a new 'STAT' table.
+
+        See `fontTools.otlLib.builder.buildStatTable` for details about
+        the arguments.
+        """
+        from .otlLib.builder import buildStatTable
+
+        assert "name" in self.font, "name must to be set up first"
+
+        buildStatTable(
+            self.font,
+            axes,
+            locations,
+            elidedFallbackName,
+            macNames=any(nr.platformID == 1 for nr in self.font["name"].names),
+        )
+
+
+def buildCmapSubTable(cmapping, format, platformID, platEncID):
+    subTable = cmap_classes[format](format)
+    subTable.cmap = cmapping
+    subTable.platformID = platformID
+    subTable.platEncID = platEncID
+    subTable.language = 0
+    return subTable
+
+
+def addFvar(font, axes, instances):
+    from .ttLib.tables._f_v_a_r import Axis, NamedInstance
+
+    assert axes
+
+    fvar = newTable("fvar")
+    nameTable = font["name"]
+
+    # if there are not currently any mac names don't add them here, that's inconsistent
+    # https://github.com/fonttools/fonttools/issues/683
+    macNames = any(nr.platformID == 1 for nr in getattr(nameTable, "names", ()))
+
+    # we have all the best ways to express mac names
+    platforms = ((3, 1, 0x409),)
+    if macNames:
+        platforms = ((1, 0, 0),) + platforms
+
+    for axis_def in axes:
+        axis = Axis()
+
+        if isinstance(axis_def, tuple):
+            (
+                axis.axisTag,
+                axis.minValue,
+                axis.defaultValue,
+                axis.maxValue,
+                name,
+            ) = axis_def
+        else:
+            (axis.axisTag, axis.minValue, axis.defaultValue, axis.maxValue, name) = (
+                axis_def.tag,
+                axis_def.minimum,
+                axis_def.default,
+                axis_def.maximum,
+                axis_def.name,
+            )
+            if axis_def.hidden:
+                axis.flags = 0x0001  # HIDDEN_AXIS
+
+        if isinstance(name, str):
+            name = dict(en=name)
+
+        axis.axisNameID = nameTable.addMultilingualName(name, ttFont=font, mac=macNames)
+        fvar.axes.append(axis)
+
+    for instance in instances:
+        if isinstance(instance, dict):
+            coordinates = instance["location"]
+            name = instance["stylename"]
+            psname = instance.get("postscriptfontname")
+        else:
+            coordinates = instance.location
+            name = instance.localisedStyleName or instance.styleName
+            psname = instance.postScriptFontName
+
+        if isinstance(name, str):
+            name = dict(en=name)
+
+        inst = NamedInstance()
+        inst.subfamilyNameID = nameTable.addMultilingualName(
+            name, ttFont=font, mac=macNames
+        )
+        if psname is not None:
+            inst.postscriptNameID = nameTable.addName(psname, platforms=platforms)
+        inst.coordinates = coordinates
+        fvar.instances.append(inst)
+
+    font["fvar"] = fvar

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/help.py

@@ -0,0 +1,36 @@
+import pkgutil
+import sys
+import fontTools
+import importlib
+import os
+from pathlib import Path
+
+
+def main():
+    """Show this help"""
+    path = fontTools.__path__
+    descriptions = {}
+    for pkg in sorted(
+        mod.name
+        for mod in pkgutil.walk_packages([fontTools.__path__[0]], prefix="fontTools.")
+    ):
+        try:
+            imports = __import__(pkg, globals(), locals(), ["main"])
+        except ImportError as e:
+            continue
+        try:
+            description = imports.main.__doc__
+            # Cython modules seem to return "main()" as the docstring
+            if description and description != "main()":
+                pkg = pkg.replace("fontTools.", "").replace(".__main__", "")
+                # show the docstring's first line only
+                descriptions[pkg] = description.splitlines()[0]
+        except AttributeError as e:
+            pass
+    for pkg, description in descriptions.items():
+        print("fonttools %-25s %s" % (pkg, description), file=sys.stderr)
+
+
+if __name__ == "__main__":
+    print("fonttools v%s\n" % fontTools.__version__, file=sys.stderr)
+    main()

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/merge/__init__.py

@@ -0,0 +1,248 @@
+# Copyright 2013 Google, Inc. All Rights Reserved.
+#
+# Google Author(s): Behdad Esfahbod, Roozbeh Pournader
+
+from fontTools import ttLib
+import fontTools.merge.base
+from fontTools.merge.cmap import (
+    computeMegaGlyphOrder,
+    computeMegaCmap,
+    renameCFFCharStrings,
+)
+from fontTools.merge.layout import layoutPreMerge, layoutPostMerge
+from fontTools.merge.options import Options
+import fontTools.merge.tables
+from fontTools.misc.loggingTools import Timer
+from functools import reduce
+import sys
+import logging
+
+
+log = logging.getLogger("fontTools.merge")
+timer = Timer(logger=logging.getLogger(__name__ + ".timer"), level=logging.INFO)
+
+
+class Merger(object):
+    """Font merger.
+
+    This class merges multiple files into a single OpenType font, taking into
+    account complexities such as OpenType layout (``GSUB``/``GPOS``) tables and
+    cross-font metrics (for example ``hhea.ascent`` is set to the maximum value
+    across all the fonts).
+
+    If multiple glyphs map to the same Unicode value, and the glyphs are considered
+    sufficiently different (that is, they differ in any of paths, widths, or
+    height), then subsequent glyphs are renamed and a lookup in the ``locl``
+    feature will be created to disambiguate them. For example, if the arguments
+    are an Arabic font and a Latin font and both contain a set of parentheses,
+    the Latin glyphs will be renamed to ``parenleft.1`` and ``parenright.1``,
+    and a lookup will be inserted into the to ``locl`` feature (creating it if
+    necessary) under the ``latn`` script to substitute ``parenleft`` with
+    ``parenleft.1`` etc.
+
+    Restrictions:
+
+    - All fonts must have the same units per em.
+    - If duplicate glyph disambiguation takes place as described above then the
+      fonts must have a ``GSUB`` table.
+
+    Attributes:
+            options: Currently unused.
+    """
+
+    def __init__(self, options=None):
+        if not options:
+            options = Options()
+
+        self.options = options
+
+    def _openFonts(self, fontfiles):
+        fonts = [ttLib.TTFont(fontfile) for fontfile in fontfiles]
+        for font, fontfile in zip(fonts, fontfiles):
+            font._merger__fontfile = fontfile
+            font._merger__name = font["name"].getDebugName(4)
+        return fonts
+
+    def merge(self, fontfiles):
+        """Merges fonts together.
+
+        Args:
+                fontfiles: A list of file names to be merged
+
+        Returns:
+                A :class:`fontTools.ttLib.TTFont` object. Call the ``save`` method on
+                this to write it out to an OTF file.
+        """
+        #
+        # Settle on a mega glyph order.
+        #
+        fonts = self._openFonts(fontfiles)
+        glyphOrders = [list(font.getGlyphOrder()) for font in fonts]
+        computeMegaGlyphOrder(self, glyphOrders)
+
+        # Take first input file sfntVersion
+        sfntVersion = fonts[0].sfntVersion
+
+        # Reload fonts and set new glyph names on them.
+        fonts = self._openFonts(fontfiles)
+        for font, glyphOrder in zip(fonts, glyphOrders):
+            font.setGlyphOrder(glyphOrder)
+            if "CFF " in font:
+                renameCFFCharStrings(self, glyphOrder, font["CFF "])
+
+        cmaps = [font["cmap"] for font in fonts]
+        self.duplicateGlyphsPerFont = [{} for _ in fonts]
+        computeMegaCmap(self, cmaps)
+
+        mega = ttLib.TTFont(sfntVersion=sfntVersion)
+        mega.setGlyphOrder(self.glyphOrder)
+
+        for font in fonts:
+            self._preMerge(font)
+
+        self.fonts = fonts
+
+        allTags = reduce(set.union, (list(font.keys()) for font in fonts), set())
+        allTags.remove("GlyphOrder")
+
+        for tag in sorted(allTags):
+            if tag in self.options.drop_tables:
+                continue
+
+            with timer("merge '%s'" % tag):
+                tables = [font.get(tag, NotImplemented) for font in fonts]
+
+                log.info("Merging '%s'.", tag)
+                clazz = ttLib.getTableClass(tag)
+                table = clazz(tag).merge(self, tables)
+                # XXX Clean this up and use:  table = mergeObjects(tables)
+
+                if table is not NotImplemented and table is not False:
+                    mega[tag] = table
+                    log.info("Merged '%s'.", tag)
+                else:
+                    log.info("Dropped '%s'.", tag)
+
+        del self.duplicateGlyphsPerFont
+        del self.fonts
+
+        self._postMerge(mega)
+
+        return mega
+
+    def mergeObjects(self, returnTable, logic, tables):
+        # Right now we don't use self at all.  Will use in the future
+        # for options and logging.
+
+        allKeys = set.union(
+            set(),
+            *(vars(table).keys() for table in tables if table is not NotImplemented),
+        )
+        for key in allKeys:
+            log.info(" %s", key)
+            try:
+                mergeLogic = logic[key]
+            except KeyError:
+                try:
+                    mergeLogic = logic["*"]
+                except KeyError:
+                    raise Exception(
+                        "Don't know how to merge key %s of class %s"
+                        % (key, returnTable.__class__.__name__)
+                    )
+            if mergeLogic is NotImplemented:
+                continue
+            value = mergeLogic(getattr(table, key, NotImplemented) for table in tables)
+            if value is not NotImplemented:
+                setattr(returnTable, key, value)
+
+        return returnTable
+
+    def _preMerge(self, font):
+        layoutPreMerge(font)
+
+    def _postMerge(self, font):
+        layoutPostMerge(font)
+
+        if "OS/2" in font:
+            # https://github.com/fonttools/fonttools/issues/2538
+            # TODO: Add an option to disable this?
+            font["OS/2"].recalcAvgCharWidth(font)
+
+
+__all__ = ["Options", "Merger", "main"]
+
+
+@timer("make one with everything (TOTAL TIME)")
+def main(args=None):
+    """Merge multiple fonts into one"""
+    from fontTools import configLogger
+
+    if args is None:
+        args = sys.argv[1:]
+
+    options = Options()
+    args = options.parse_opts(args)
+    fontfiles = []
+    if options.input_file:
+        with open(options.input_file) as inputfile:
+            fontfiles = [
+                line.strip()
+                for line in inputfile.readlines()
+                if not line.lstrip().startswith("#")
+            ]
+    for g in args:
+        fontfiles.append(g)
+
+    if len(fontfiles) < 1:
+        print(
+            "usage: fonttools merge [font1 ... fontN] [--input-file=filelist.txt] [--output-file=merged.ttf] [--import-file=tables.ttx]",
+            file=sys.stderr,
+        )
+        print(
+            "                                   [--drop-tables=tags] [--verbose] [--timing]",
+            file=sys.stderr,
+        )
+        print("", file=sys.stderr)
+        print(" font1 ... fontN              Files to merge.", file=sys.stderr)
+        print(
+            " --input-file=<filename>      Read files to merge from a text file, each path new line. # Comment lines allowed.",
+            file=sys.stderr,
+        )
+        print(
+            " --output-file=<filename>     Specify output file name (default: merged.ttf).",
+            file=sys.stderr,
+        )
+        print(
+            " --import-file=<filename>     TTX file to import after merging. This can be used to set metadata.",
+            file=sys.stderr,
+        )
+        print(
+            " --drop-tables=<table tags>   Comma separated list of table tags to skip, case sensitive.",
+            file=sys.stderr,
+        )
+        print(
+            " --verbose                    Output progress information.",
+            file=sys.stderr,
+        )
+        print(" --timing                     Output progress timing.", file=sys.stderr)
+        return 1
+
+    configLogger(level=logging.INFO if options.verbose else logging.WARNING)
+    if options.timing:
+        timer.logger.setLevel(logging.DEBUG)
+    else:
+        timer.logger.disabled = True
+
+    merger = Merger(options=options)
+    font = merger.merge(fontfiles)
+
+    if options.import_file:
+        font.importXML(options.import_file)
+
+    with timer("compile and save font"):
+        font.save(options.output_file)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/merge/__main__.py

@@ -0,0 +1,6 @@
+import sys
+from fontTools.merge import main
+
+
+if __name__ == "__main__":
+    sys.exit(main())

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/merge/base.py

@@ -0,0 +1,81 @@
+# Copyright 2013 Google, Inc. All Rights Reserved.
+#
+# Google Author(s): Behdad Esfahbod, Roozbeh Pournader
+
+from fontTools.ttLib.tables.DefaultTable import DefaultTable
+import logging
+
+
+log = logging.getLogger("fontTools.merge")
+
+
+def add_method(*clazzes, **kwargs):
+    """Returns a decorator function that adds a new method to one or
+    more classes."""
+    allowDefault = kwargs.get("allowDefaultTable", False)
+
+    def wrapper(method):
+        done = []
+        for clazz in clazzes:
+            if clazz in done:
+                continue  # Support multiple names of a clazz
+            done.append(clazz)
+            assert allowDefault or clazz != DefaultTable, "Oops, table class not found."
+            assert (
+                method.__name__ not in clazz.__dict__
+            ), "Oops, class '%s' has method '%s'." % (clazz.__name__, method.__name__)
+            setattr(clazz, method.__name__, method)
+        return None
+
+    return wrapper
+
+
+def mergeObjects(lst):
+    lst = [item for item in lst if item is not NotImplemented]
+    if not lst:
+        return NotImplemented
+    lst = [item for item in lst if item is not None]
+    if not lst:
+        return None
+
+    clazz = lst[0].__class__
+    assert all(type(item) == clazz for item in lst), lst
+
+    logic = clazz.mergeMap
+    returnTable = clazz()
+    returnDict = {}
+
+    allKeys = set.union(set(), *(vars(table).keys() for table in lst))
+    for key in allKeys:
+        try:
+            mergeLogic = logic[key]
+        except KeyError:
+            try:
+                mergeLogic = logic["*"]
+            except KeyError:
+                raise Exception(
+                    "Don't know how to merge key %s of class %s" % (key, clazz.__name__)
+                )
+        if mergeLogic is NotImplemented:
+            continue
+        value = mergeLogic(getattr(table, key, NotImplemented) for table in lst)
+        if value is not NotImplemented:
+            returnDict[key] = value
+
+    returnTable.__dict__ = returnDict
+
+    return returnTable
+
+
+@add_method(DefaultTable, allowDefaultTable=True)
+def merge(self, m, tables):
+    if not hasattr(self, "mergeMap"):
+        log.info("Don't know how to merge '%s'.", self.tableTag)
+        return NotImplemented
+
+    logic = self.mergeMap
+
+    if isinstance(logic, dict):
+        return m.mergeObjects(self, self.mergeMap, tables)
+    else:
+        return logic(tables)

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/merge/cmap.py

@@ -0,0 +1,173 @@
+# Copyright 2013 Google, Inc. All Rights Reserved.
+#
+# Google Author(s): Behdad Esfahbod, Roozbeh Pournader
+
+from fontTools.merge.unicode import is_Default_Ignorable
+from fontTools.pens.recordingPen import DecomposingRecordingPen
+import logging
+
+
+log = logging.getLogger("fontTools.merge")
+
+
+def computeMegaGlyphOrder(merger, glyphOrders):
+    """Modifies passed-in glyphOrders to reflect new glyph names.
+    Stores merger.glyphOrder."""
+    megaOrder = {}
+    for glyphOrder in glyphOrders:
+        for i, glyphName in enumerate(glyphOrder):
+            if glyphName in megaOrder:
+                n = megaOrder[glyphName]
+                while (glyphName + "." + repr(n)) in megaOrder:
+                    n += 1
+                megaOrder[glyphName] = n
+                glyphName += "." + repr(n)
+                glyphOrder[i] = glyphName
+            megaOrder[glyphName] = 1
+    merger.glyphOrder = megaOrder = list(megaOrder.keys())
+
+
+def _glyphsAreSame(
+    glyphSet1,
+    glyphSet2,
+    glyph1,
+    glyph2,
+    advanceTolerance=0.05,
+    advanceToleranceEmpty=0.20,
+):
+    pen1 = DecomposingRecordingPen(glyphSet1)
+    pen2 = DecomposingRecordingPen(glyphSet2)
+    g1 = glyphSet1[glyph1]
+    g2 = glyphSet2[glyph2]
+    g1.draw(pen1)
+    g2.draw(pen2)
+    if pen1.value != pen2.value:
+        return False
+    # Allow more width tolerance for glyphs with no ink
+    tolerance = advanceTolerance if pen1.value else advanceToleranceEmpty
+    # TODO Warn if advances not the same but within tolerance.
+    if abs(g1.width - g2.width) > g1.width * tolerance:
+        return False
+    if hasattr(g1, "height") and g1.height is not None:
+        if abs(g1.height - g2.height) > g1.height * tolerance:
+            return False
+    return True
+
+
+def computeMegaUvs(merger, uvsTables):
+    """Returns merged UVS subtable (cmap format=14)."""
+    uvsDict = {}
+    cmap = merger.cmap
+    for table in uvsTables:
+        for variationSelector, uvsMapping in table.uvsDict.items():
+            if variationSelector not in uvsDict:
+                uvsDict[variationSelector] = {}
+            for unicodeValue, glyphName in uvsMapping:
+                if cmap.get(unicodeValue) == glyphName:
+                    # this is a default variation
+                    glyphName = None
+                    # prefer previous glyph id if both fonts defined UVS
+                if unicodeValue not in uvsDict[variationSelector]:
+                    uvsDict[variationSelector][unicodeValue] = glyphName
+
+    for variationSelector in uvsDict:
+        uvsDict[variationSelector] = [*uvsDict[variationSelector].items()]
+
+    return uvsDict
+
+
+# Valid (format, platformID, platEncID) triplets for cmap subtables containing
+# Unicode BMP-only and Unicode Full Repertoire semantics.
+# Cf. OpenType spec for "Platform specific encodings":
+# https://docs.microsoft.com/en-us/typography/opentype/spec/name
+class _CmapUnicodePlatEncodings:
+    BMP = {(4, 3, 1), (4, 0, 3), (4, 0, 4), (4, 0, 6)}
+    FullRepertoire = {(12, 3, 10), (12, 0, 4), (12, 0, 6)}
+    UVS = {(14, 0, 5)}
+
+
+def computeMegaCmap(merger, cmapTables):
+    """Sets merger.cmap and merger.uvsDict."""
+
+    # TODO Handle format=14.
+    # Only merge format 4 and 12 Unicode subtables, ignores all other subtables
+    # If there is a format 12 table for a font, ignore the format 4 table of it
+    chosenCmapTables = []
+    chosenUvsTables = []
+    for fontIdx, table in enumerate(cmapTables):
+        format4 = None
+        format12 = None
+        format14 = None
+        for subtable in table.tables:
+            properties = (subtable.format, subtable.platformID, subtable.platEncID)
+            if properties in _CmapUnicodePlatEncodings.BMP:
+                format4 = subtable
+            elif properties in _CmapUnicodePlatEncodings.FullRepertoire:
+                format12 = subtable
+            elif properties in _CmapUnicodePlatEncodings.UVS:
+                format14 = subtable
+            else:
+                log.warning(
+                    "Dropped cmap subtable from font '%s':\t"
+                    "format %2s, platformID %2s, platEncID %2s",
+                    fontIdx,
+                    subtable.format,
+                    subtable.platformID,
+                    subtable.platEncID,
+                )
+        if format12 is not None:
+            chosenCmapTables.append((format12, fontIdx))
+        elif format4 is not None:
+            chosenCmapTables.append((format4, fontIdx))
+
+        if format14 is not None:
+            chosenUvsTables.append(format14)
+
+    # Build the unicode mapping
+    merger.cmap = cmap = {}
+    fontIndexForGlyph = {}
+    glyphSets = [None for f in merger.fonts] if hasattr(merger, "fonts") else None
+
+    for table, fontIdx in chosenCmapTables:
+        # handle duplicates
+        for uni, gid in table.cmap.items():
+            oldgid = cmap.get(uni, None)
+            if oldgid is None:
+                cmap[uni] = gid
+                fontIndexForGlyph[gid] = fontIdx
+            elif is_Default_Ignorable(uni) or uni in (0x25CC,):  # U+25CC DOTTED CIRCLE
+                continue
+            elif oldgid != gid:
+                # Char previously mapped to oldgid, now to gid.
+                # Record, to fix up in GSUB 'locl' later.
+                if merger.duplicateGlyphsPerFont[fontIdx].get(oldgid) is None:
+                    if glyphSets is not None:
+                        oldFontIdx = fontIndexForGlyph[oldgid]
+                        for idx in (fontIdx, oldFontIdx):
+                            if glyphSets[idx] is None:
+                                glyphSets[idx] = merger.fonts[idx].getGlyphSet()
+                        # if _glyphsAreSame(glyphSets[oldFontIdx], glyphSets[fontIdx], oldgid, gid):
+                        # 	continue
+                    merger.duplicateGlyphsPerFont[fontIdx][oldgid] = gid
+                elif merger.duplicateGlyphsPerFont[fontIdx][oldgid] != gid:
+                    # Char previously mapped to oldgid but oldgid is already remapped to a different
+                    # gid, because of another Unicode character.
+                    # TODO: Try harder to do something about these.
+                    log.warning(
+                        "Dropped mapping from codepoint %#06X to glyphId '%s'", uni, gid
+                    )
+
+    merger.uvsDict = computeMegaUvs(merger, chosenUvsTables)
+
+
+def renameCFFCharStrings(merger, glyphOrder, cffTable):
+    """Rename topDictIndex charStrings based on glyphOrder."""
+    td = cffTable.cff.topDictIndex[0]
+
+    charStrings = {}
+    for i, v in enumerate(td.CharStrings.charStrings.values()):
+        glyphName = glyphOrder[i]
+        charStrings[glyphName] = v
+    td.CharStrings.charStrings = charStrings
+
+    td.charset = list(glyphOrder)

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/merge/layout.py

@@ -0,0 +1,526 @@
+# Copyright 2013 Google, Inc. All Rights Reserved.
+#
+# Google Author(s): Behdad Esfahbod, Roozbeh Pournader
+
+from fontTools import ttLib
+from fontTools.ttLib.tables.DefaultTable import DefaultTable
+from fontTools.ttLib.tables import otTables
+from fontTools.merge.base import add_method, mergeObjects
+from fontTools.merge.util import *
+import logging
+
+
+log = logging.getLogger("fontTools.merge")
+
+
+def mergeLookupLists(lst):
+    # TODO Do smarter merge.
+    return sumLists(lst)
+
+
+def mergeFeatures(lst):
+    assert lst
+    self = otTables.Feature()
+    self.FeatureParams = None
+    self.LookupListIndex = mergeLookupLists(
+        [l.LookupListIndex for l in lst if l.LookupListIndex]
+    )
+    self.LookupCount = len(self.LookupListIndex)
+    return self
+
+
+def mergeFeatureLists(lst):
+    d = {}
+    for l in lst:
+        for f in l:
+            tag = f.FeatureTag
+            if tag not in d:
+                d[tag] = []
+            d[tag].append(f.Feature)
+    ret = []
+    for tag in sorted(d.keys()):
+        rec = otTables.FeatureRecord()
+        rec.FeatureTag = tag
+        rec.Feature = mergeFeatures(d[tag])
+        ret.append(rec)
+    return ret
+
+
+def mergeLangSyses(lst):
+    assert lst
+
+    # TODO Support merging ReqFeatureIndex
+    assert all(l.ReqFeatureIndex == 0xFFFF for l in lst)
+
+    self = otTables.LangSys()
+    self.LookupOrder = None
+    self.ReqFeatureIndex = 0xFFFF
+    self.FeatureIndex = mergeFeatureLists(
+        [l.FeatureIndex for l in lst if l.FeatureIndex]
+    )
+    self.FeatureCount = len(self.FeatureIndex)
+    return self
+
+
+def mergeScripts(lst):
+    assert lst
+
+    if len(lst) == 1:
+        return lst[0]
+    langSyses = {}
+    for sr in lst:
+        for lsr in sr.LangSysRecord:
+            if lsr.LangSysTag not in langSyses:
+                langSyses[lsr.LangSysTag] = []
+            langSyses[lsr.LangSysTag].append(lsr.LangSys)
+    lsrecords = []
+    for tag, langSys_list in sorted(langSyses.items()):
+        lsr = otTables.LangSysRecord()
+        lsr.LangSys = mergeLangSyses(langSys_list)
+        lsr.LangSysTag = tag
+        lsrecords.append(lsr)
+
+    self = otTables.Script()
+    self.LangSysRecord = lsrecords
+    self.LangSysCount = len(lsrecords)
+    dfltLangSyses = [s.DefaultLangSys for s in lst if s.DefaultLangSys]
+    if dfltLangSyses:
+        self.DefaultLangSys = mergeLangSyses(dfltLangSyses)
+    else:
+        self.DefaultLangSys = None
+    return self
+
+
+def mergeScriptRecords(lst):
+    d = {}
+    for l in lst:
+        for s in l:
+            tag = s.ScriptTag
+            if tag not in d:
+                d[tag] = []
+            d[tag].append(s.Script)
+    ret = []
+    for tag in sorted(d.keys()):
+        rec = otTables.ScriptRecord()
+        rec.ScriptTag = tag
+        rec.Script = mergeScripts(d[tag])
+        ret.append(rec)
+    return ret
+
+
+otTables.ScriptList.mergeMap = {
+    "ScriptCount": lambda lst: None,  # TODO
+    "ScriptRecord": mergeScriptRecords,
+}
+otTables.BaseScriptList.mergeMap = {
+    "BaseScriptCount": lambda lst: None,  # TODO
+    # TODO: Merge duplicate entries
+    "BaseScriptRecord": lambda lst: sorted(
+        sumLists(lst), key=lambda s: s.BaseScriptTag
+    ),
+}
+
+otTables.FeatureList.mergeMap = {
+    "FeatureCount": sum,
+    "FeatureRecord": lambda lst: sorted(sumLists(lst), key=lambda s: s.FeatureTag),
+}
+
+otTables.LookupList.mergeMap = {
+    "LookupCount": sum,
+    "Lookup": sumLists,
+}
+
+otTables.Coverage.mergeMap = {
+    "Format": min,
+    "glyphs": sumLists,
+}
+
+otTables.ClassDef.mergeMap = {
+    "Format": min,
+    "classDefs": sumDicts,
+}
+
+otTables.LigCaretList.mergeMap = {
+    "Coverage": mergeObjects,
+    "LigGlyphCount": sum,
+    "LigGlyph": sumLists,
+}
+
+otTables.AttachList.mergeMap = {
+    "Coverage": mergeObjects,
+    "GlyphCount": sum,
+    "AttachPoint": sumLists,
+}
+
+# XXX Renumber MarkFilterSets of lookups
+otTables.MarkGlyphSetsDef.mergeMap = {
+    "MarkSetTableFormat": equal,
+    "MarkSetCount": sum,
+    "Coverage": sumLists,
+}
+
+otTables.Axis.mergeMap = {
+    "*": mergeObjects,
+}
+
+# XXX Fix BASE table merging
+otTables.BaseTagList.mergeMap = {
+    "BaseTagCount": sum,
+    "BaselineTag": sumLists,
+}
+
+otTables.GDEF.mergeMap = otTables.GSUB.mergeMap = otTables.GPOS.mergeMap = (
+    otTables.BASE.mergeMap
+) = otTables.JSTF.mergeMap = otTables.MATH.mergeMap = {
+    "*": mergeObjects,
+    "Version": max,
+}
+
+ttLib.getTableClass("GDEF").mergeMap = ttLib.getTableClass("GSUB").mergeMap = (
+    ttLib.getTableClass("GPOS").mergeMap
+) = ttLib.getTableClass("BASE").mergeMap = ttLib.getTableClass(
+    "JSTF"
+).mergeMap = ttLib.getTableClass(
+    "MATH"
+).mergeMap = {
+    "tableTag": onlyExisting(equal),  # XXX clean me up
+    "table": mergeObjects,
+}
+
+
+@add_method(ttLib.getTableClass("GSUB"))
+def merge(self, m, tables):
+    assert len(tables) == len(m.duplicateGlyphsPerFont)
+    for i, (table, dups) in enumerate(zip(tables, m.duplicateGlyphsPerFont)):
+        if not dups:
+            continue
+        if table is None or table is NotImplemented:
+            log.warning(
+                "Have non-identical duplicates to resolve for '%s' but no GSUB. Are duplicates intended?: %s",
+                m.fonts[i]._merger__name,
+                dups,
+            )
+            continue
+
+        synthFeature = None
+        synthLookup = None
+        for script in table.table.ScriptList.ScriptRecord:
+            if script.ScriptTag == "DFLT":
+                continue  # XXX
+            for langsys in [script.Script.DefaultLangSys] + [
+                l.LangSys for l in script.Script.LangSysRecord
+            ]:
+                if langsys is None:
+                    continue  # XXX Create!
+                feature = [v for v in langsys.FeatureIndex if v.FeatureTag == "locl"]
+                assert len(feature) <= 1
+                if feature:
+                    feature = feature[0]
+                else:
+                    if not synthFeature:
+                        synthFeature = otTables.FeatureRecord()
+                        synthFeature.FeatureTag = "locl"
+                        f = synthFeature.Feature = otTables.Feature()
+                        f.FeatureParams = None
+                        f.LookupCount = 0
+                        f.LookupListIndex = []
+                        table.table.FeatureList.FeatureRecord.append(synthFeature)
+                        table.table.FeatureList.FeatureCount += 1
+                    feature = synthFeature
+                    langsys.FeatureIndex.append(feature)
+                    langsys.FeatureIndex.sort(key=lambda v: v.FeatureTag)
+
+                if not synthLookup:
+                    subtable = otTables.SingleSubst()
+                    subtable.mapping = dups
+                    synthLookup = otTables.Lookup()
+                    synthLookup.LookupFlag = 0
+                    synthLookup.LookupType = 1
+                    synthLookup.SubTableCount = 1
+                    synthLookup.SubTable = [subtable]
+                    if table.table.LookupList is None:
+                        # mtiLib uses None as default value for LookupList,
+                        # while feaLib points to an empty array with count 0
+                        # TODO: make them do the same
+                        table.table.LookupList = otTables.LookupList()
+                        table.table.LookupList.Lookup = []
+                        table.table.LookupList.LookupCount = 0
+                    table.table.LookupList.Lookup.append(synthLookup)
+                    table.table.LookupList.LookupCount += 1
+
+                if feature.Feature.LookupListIndex[:1] != [synthLookup]:
+                    feature.Feature.LookupListIndex[:0] = [synthLookup]
+                    feature.Feature.LookupCount += 1
+
+    DefaultTable.merge(self, m, tables)
+    return self
+
+
+@add_method(
+    otTables.SingleSubst,
+    otTables.MultipleSubst,
+    otTables.AlternateSubst,
+    otTables.LigatureSubst,
+    otTables.ReverseChainSingleSubst,
+    otTables.SinglePos,
+    otTables.PairPos,
+    otTables.CursivePos,
+    otTables.MarkBasePos,
+    otTables.MarkLigPos,
+    otTables.MarkMarkPos,
+)
+def mapLookups(self, lookupMap):
+    pass
+
+
+# Copied and trimmed down from subset.py
+@add_method(
+    otTables.ContextSubst,
+    otTables.ChainContextSubst,
+    otTables.ContextPos,
+    otTables.ChainContextPos,
+)
+def __merge_classify_context(self):
+    class ContextHelper(object):
+        def __init__(self, klass, Format):
+            if klass.__name__.endswith("Subst"):
+                Typ = "Sub"
+                Type = "Subst"
+            else:
+                Typ = "Pos"
+                Type = "Pos"
+            if klass.__name__.startswith("Chain"):
+                Chain = "Chain"
+            else:
+                Chain = ""
+            ChainTyp = Chain + Typ
+
+            self.Typ = Typ
+            self.Type = Type
+            self.Chain = Chain
+            self.ChainTyp = ChainTyp
+
+            self.LookupRecord = Type + "LookupRecord"
+
+            if Format == 1:
+                self.Rule = ChainTyp + "Rule"
+                self.RuleSet = ChainTyp + "RuleSet"
+            elif Format == 2:
+                self.Rule = ChainTyp + "ClassRule"
+                self.RuleSet = ChainTyp + "ClassSet"
+
+    if self.Format not in [1, 2, 3]:
+        return None  # Don't shoot the messenger; let it go
+    if not hasattr(self.__class__, "_merge__ContextHelpers"):
+        self.__class__._merge__ContextHelpers = {}
+    if self.Format not in self.__class__._merge__ContextHelpers:
+        helper = ContextHelper(self.__class__, self.Format)
+        self.__class__._merge__ContextHelpers[self.Format] = helper
+    return self.__class__._merge__ContextHelpers[self.Format]
+
+
+@add_method(
+    otTables.ContextSubst,
+    otTables.ChainContextSubst,
+    otTables.ContextPos,
+    otTables.ChainContextPos,
+)
+def mapLookups(self, lookupMap):
+    c = self.__merge_classify_context()
+
+    if self.Format in [1, 2]:
+        for rs in getattr(self, c.RuleSet):
+            if not rs:
+                continue
+            for r in getattr(rs, c.Rule):
+                if not r:
+                    continue
+                for ll in getattr(r, c.LookupRecord):
+                    if not ll:
+                        continue
+                    ll.LookupListIndex = lookupMap[ll.LookupListIndex]
+    elif self.Format == 3:
+        for ll in getattr(self, c.LookupRecord):
+            if not ll:
+                continue
+            ll.LookupListIndex = lookupMap[ll.LookupListIndex]
+    else:
+        assert 0, "unknown format: %s" % self.Format
+
+
+@add_method(otTables.ExtensionSubst, otTables.ExtensionPos)
+def mapLookups(self, lookupMap):
+    if self.Format == 1:
+        self.ExtSubTable.mapLookups(lookupMap)
+    else:
+        assert 0, "unknown format: %s" % self.Format
+
+
+@add_method(otTables.Lookup)
+def mapLookups(self, lookupMap):
+    for st in self.SubTable:
+        if not st:
+            continue
+        st.mapLookups(lookupMap)
+
+
+@add_method(otTables.LookupList)
+def mapLookups(self, lookupMap):
+    for l in self.Lookup:
+        if not l:
+            continue
+        l.mapLookups(lookupMap)
+
+
+@add_method(otTables.Lookup)
+def mapMarkFilteringSets(self, markFilteringSetMap):
+    if self.LookupFlag & 0x0010:
+        self.MarkFilteringSet = markFilteringSetMap[self.MarkFilteringSet]
+
+
+@add_method(otTables.LookupList)
+def mapMarkFilteringSets(self, markFilteringSetMap):
+    for l in self.Lookup:
+        if not l:
+            continue
+        l.mapMarkFilteringSets(markFilteringSetMap)
+
+
+@add_method(otTables.Feature)
+def mapLookups(self, lookupMap):
+    self.LookupListIndex = [lookupMap[i] for i in self.LookupListIndex]
+
+
+@add_method(otTables.FeatureList)
+def mapLookups(self, lookupMap):
+    for f in self.FeatureRecord:
+        if not f or not f.Feature:
+            continue
+        f.Feature.mapLookups(lookupMap)
+
+
+@add_method(otTables.DefaultLangSys, otTables.LangSys)
+def mapFeatures(self, featureMap):
+    self.FeatureIndex = [featureMap[i] for i in self.FeatureIndex]
+    if self.ReqFeatureIndex != 65535:
+        self.ReqFeatureIndex = featureMap[self.ReqFeatureIndex]
+
+
+@add_method(otTables.Script)
+def mapFeatures(self, featureMap):
+    if self.DefaultLangSys:
+        self.DefaultLangSys.mapFeatures(featureMap)
+    for l in self.LangSysRecord:
+        if not l or not l.LangSys:
+            continue
+        l.LangSys.mapFeatures(featureMap)
+
+
+@add_method(otTables.ScriptList)
+def mapFeatures(self, featureMap):
+    for s in self.ScriptRecord:
+        if not s or not s.Script:
+            continue
+        s.Script.mapFeatures(featureMap)
+
+
+def layoutPreMerge(font):
+    # Map indices to references
+
+    GDEF = font.get("GDEF")
+    GSUB = font.get("GSUB")
+    GPOS = font.get("GPOS")
+
+    for t in [GSUB, GPOS]:
+        if not t:
+            continue
+
+        if t.table.LookupList:
+            lookupMap = {i: v for i, v in enumerate(t.table.LookupList.Lookup)}
+            t.table.LookupList.mapLookups(lookupMap)
+            t.table.FeatureList.mapLookups(lookupMap)
+
+            if (
+                GDEF
+                and GDEF.table.Version >= 0x00010002
+                and GDEF.table.MarkGlyphSetsDef
+            ):
+                markFilteringSetMap = {
+                    i: v for i, v in enumerate(GDEF.table.MarkGlyphSetsDef.Coverage)
+                }
+                t.table.LookupList.mapMarkFilteringSets(markFilteringSetMap)
+
+        if t.table.FeatureList and t.table.ScriptList:
+            featureMap = {i: v for i, v in enumerate(t.table.FeatureList.FeatureRecord)}
+            t.table.ScriptList.mapFeatures(featureMap)
+
+    # TODO FeatureParams nameIDs
+
+
+def layoutPostMerge(font):
+    # Map references back to indices
+
+    GDEF = font.get("GDEF")
+    GSUB = font.get("GSUB")
+    GPOS = font.get("GPOS")
+
+    for t in [GSUB, GPOS]:
+        if not t:
+            continue
+
+        if t.table.FeatureList and t.table.ScriptList:
+            # Collect unregistered (new) features.
+            featureMap = GregariousIdentityDict(t.table.FeatureList.FeatureRecord)
+            t.table.ScriptList.mapFeatures(featureMap)
+
+            # Record used features.
+            featureMap = AttendanceRecordingIdentityDict(
+                t.table.FeatureList.FeatureRecord
+            )
+            t.table.ScriptList.mapFeatures(featureMap)
+            usedIndices = featureMap.s
+
+            # Remove unused features
+            t.table.FeatureList.FeatureRecord = [
+                f
+                for i, f in enumerate(t.table.FeatureList.FeatureRecord)
+                if i in usedIndices
+            ]
+
+            # Map back to indices.
+            featureMap = NonhashableDict(t.table.FeatureList.FeatureRecord)
+            t.table.ScriptList.mapFeatures(featureMap)
+
+            t.table.FeatureList.FeatureCount = len(t.table.FeatureList.FeatureRecord)
+
+        if t.table.LookupList:
+            # Collect unregistered (new) lookups.
+            lookupMap = GregariousIdentityDict(t.table.LookupList.Lookup)
+            t.table.FeatureList.mapLookups(lookupMap)
+            t.table.LookupList.mapLookups(lookupMap)
+
+            # Record used lookups.
+            lookupMap = AttendanceRecordingIdentityDict(t.table.LookupList.Lookup)
+            t.table.FeatureList.mapLookups(lookupMap)
+            t.table.LookupList.mapLookups(lookupMap)
+            usedIndices = lookupMap.s
+
+            # Remove unused lookups
+            t.table.LookupList.Lookup = [
+                l for i, l in enumerate(t.table.LookupList.Lookup) if i in usedIndices
+            ]
+
+            # Map back to indices.
+            lookupMap = NonhashableDict(t.table.LookupList.Lookup)
+            t.table.FeatureList.mapLookups(lookupMap)
+            t.table.LookupList.mapLookups(lookupMap)
+
+            t.table.LookupList.LookupCount = len(t.table.LookupList.Lookup)
+
+            if GDEF and GDEF.table.Version >= 0x00010002:
+                markFilteringSetMap = NonhashableDict(
+                    GDEF.table.MarkGlyphSetsDef.Coverage
+                )
+                t.table.LookupList.mapMarkFilteringSets(markFilteringSetMap)
+
+    # TODO FeatureParams nameIDs

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/merge/options.py

@@ -0,0 +1,85 @@
+# Copyright 2013 Google, Inc. All Rights Reserved.
+#
+# Google Author(s): Behdad Esfahbod, Roozbeh Pournader
+
+
+class Options(object):
+    class UnknownOptionError(Exception):
+        pass
+
+    def __init__(self, **kwargs):
+        self.verbose = False
+        self.timing = False
+        self.drop_tables = []
+        self.input_file = None
+        self.output_file = "merged.ttf"
+        self.import_file = None
+
+        self.set(**kwargs)
+
+    def set(self, **kwargs):
+        for k, v in kwargs.items():
+            if not hasattr(self, k):
+                raise self.UnknownOptionError("Unknown option '%s'" % k)
+            setattr(self, k, v)
+
+    def parse_opts(self, argv, ignore_unknown=[]):
+        ret = []
+        opts = {}
+        for a in argv:
+            orig_a = a
+            if not a.startswith("--"):
+                ret.append(a)
+                continue
+            a = a[2:]
+            i = a.find("=")
+            op = "="
+            if i == -1:
+                if a.startswith("no-"):
+                    k = a[3:]
+                    v = False
+                else:
+                    k = a
+                    v = True
+            else:
+                k = a[:i]
+                if k[-1] in "-+":
+                    op = k[-1] + "="  # Ops is '-=' or '+=' now.
+                    k = k[:-1]
+                v = a[i + 1 :]
+            ok = k
+            k = k.replace("-", "_")
+            if not hasattr(self, k):
+                if ignore_unknown is True or ok in ignore_unknown:
+                    ret.append(orig_a)
+                    continue
+                else:
+                    raise self.UnknownOptionError("Unknown option '%s'" % a)
+
+            ov = getattr(self, k)
+            if isinstance(ov, bool):
+                v = bool(v)
+            elif isinstance(ov, int):
+                v = int(v)
+            elif isinstance(ov, list):
+                vv = v.split(",")
+                if vv == [""]:
+                    vv = []
+                vv = [int(x, 0) if len(x) and x[0] in "0123456789" else x for x in vv]
+                if op == "=":
+                    v = vv
+                elif op == "+=":
+                    v = ov
+                    v.extend(vv)
+                elif op == "-=":
+                    v = ov
+                    for x in vv:
+                        if x in v:
+                            v.remove(x)
+                else:
+                    assert 0
+
+            opts[k] = v
+        self.set(**opts)
+
+        return ret

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/merge/tables.py

@@ -0,0 +1,352 @@
+# Copyright 2013 Google, Inc. All Rights Reserved.
+#
+# Google Author(s): Behdad Esfahbod, Roozbeh Pournader
+
+from fontTools import ttLib, cffLib
+from fontTools.misc.psCharStrings import T2WidthExtractor
+from fontTools.ttLib.tables.DefaultTable import DefaultTable
+from fontTools.merge.base import add_method, mergeObjects
+from fontTools.merge.cmap import computeMegaCmap
+from fontTools.merge.util import *
+import logging
+
+
+log = logging.getLogger("fontTools.merge")
+
+
+ttLib.getTableClass("maxp").mergeMap = {
+    "*": max,
+    "tableTag": equal,
+    "tableVersion": equal,
+    "numGlyphs": sum,
+    "maxStorage": first,
+    "maxFunctionDefs": first,
+    "maxInstructionDefs": first,
+    # TODO When we correctly merge hinting data, update these values:
+    # maxFunctionDefs, maxInstructionDefs, maxSizeOfInstructions
+}
+
+headFlagsMergeBitMap = {
+    "size": 16,
+    "*": bitwise_or,
+    1: bitwise_and,  # Baseline at y = 0
+    2: bitwise_and,  # lsb at x = 0
+    3: bitwise_and,  # Force ppem to integer values. FIXME?
+    5: bitwise_and,  # Font is vertical
+    6: lambda bit: 0,  # Always set to zero
+    11: bitwise_and,  # Font data is 'lossless'
+    13: bitwise_and,  # Optimized for ClearType
+    14: bitwise_and,  # Last resort font. FIXME? equal or first may be better
+    15: lambda bit: 0,  # Always set to zero
+}
+
+ttLib.getTableClass("head").mergeMap = {
+    "tableTag": equal,
+    "tableVersion": max,
+    "fontRevision": max,
+    "checkSumAdjustment": lambda lst: 0,  # We need *something* here
+    "magicNumber": equal,
+    "flags": mergeBits(headFlagsMergeBitMap),
+    "unitsPerEm": equal,
+    "created": current_time,
+    "modified": current_time,
+    "xMin": min,
+    "yMin": min,
+    "xMax": max,
+    "yMax": max,
+    "macStyle": first,
+    "lowestRecPPEM": max,
+    "fontDirectionHint": lambda lst: 2,
+    "indexToLocFormat": first,
+    "glyphDataFormat": equal,
+}
+
+ttLib.getTableClass("hhea").mergeMap = {
+    "*": equal,
+    "tableTag": equal,
+    "tableVersion": max,
+    "ascent": max,
+    "descent": min,
+    "lineGap": max,
+    "advanceWidthMax": max,
+    "minLeftSideBearing": min,
+    "minRightSideBearing": min,
+    "xMaxExtent": max,
+    "caretSlopeRise": first,
+    "caretSlopeRun": first,
+    "caretOffset": first,
+    "numberOfHMetrics": recalculate,
+}
+
+ttLib.getTableClass("vhea").mergeMap = {
+    "*": equal,
+    "tableTag": equal,
+    "tableVersion": max,
+    "ascent": max,
+    "descent": min,
+    "lineGap": max,
+    "advanceHeightMax": max,
+    "minTopSideBearing": min,
+    "minBottomSideBearing": min,
+    "yMaxExtent": max,
+    "caretSlopeRise": first,
+    "caretSlopeRun": first,
+    "caretOffset": first,
+    "numberOfVMetrics": recalculate,
+}
+
+os2FsTypeMergeBitMap = {
+    "size": 16,
+    "*": lambda bit: 0,
+    1: bitwise_or,  # no embedding permitted
+    2: bitwise_and,  # allow previewing and printing documents
+    3: bitwise_and,  # allow editing documents
+    8: bitwise_or,  # no subsetting permitted
+    9: bitwise_or,  # no embedding of outlines permitted
+}
+
+
+def mergeOs2FsType(lst):
+    lst = list(lst)
+    if all(item == 0 for item in lst):
+        return 0
+
+    # Compute least restrictive logic for each fsType value
+    for i in range(len(lst)):
+        # unset bit 1 (no embedding permitted) if either bit 2 or 3 is set
+        if lst[i] & 0x000C:
+            lst[i] &= ~0x0002
+        # set bit 2 (allow previewing) if bit 3 is set (allow editing)
+        elif lst[i] & 0x0008:
+            lst[i] |= 0x0004
+        # set bits 2 and 3 if everything is allowed
+        elif lst[i] == 0:
+            lst[i] = 0x000C
+
+    fsType = mergeBits(os2FsTypeMergeBitMap)(lst)
+    # unset bits 2 and 3 if bit 1 is set (some font is "no embedding")
+    if fsType & 0x0002:
+        fsType &= ~0x000C
+    return fsType
+
+
+ttLib.getTableClass("OS/2").mergeMap = {
+    "*": first,
+    "tableTag": equal,
+    "version": max,
+    "xAvgCharWidth": first,  # Will be recalculated at the end on the merged font
+    "fsType": mergeOs2FsType,  # Will be overwritten
+    "panose": first,  # FIXME: should really be the first Latin font
+    "ulUnicodeRange1": bitwise_or,
+    "ulUnicodeRange2": bitwise_or,
+    "ulUnicodeRange3": bitwise_or,
+    "ulUnicodeRange4": bitwise_or,
+    "fsFirstCharIndex": min,
+    "fsLastCharIndex": max,
+    "sTypoAscender": max,
+    "sTypoDescender": min,
+    "sTypoLineGap": max,
+    "usWinAscent": max,
+    "usWinDescent": max,
+    # Version 1
+    "ulCodePageRange1": onlyExisting(bitwise_or),
+    "ulCodePageRange2": onlyExisting(bitwise_or),
+    # Version 2, 3, 4
+    "sxHeight": onlyExisting(max),
+    "sCapHeight": onlyExisting(max),
+    "usDefaultChar": onlyExisting(first),
+    "usBreakChar": onlyExisting(first),
+    "usMaxContext": onlyExisting(max),
+    # version 5
+    "usLowerOpticalPointSize": onlyExisting(min),
+    "usUpperOpticalPointSize": onlyExisting(max),
+}
+
+
+@add_method(ttLib.getTableClass("OS/2"))
+def merge(self, m, tables):
+    DefaultTable.merge(self, m, tables)
+    if self.version < 2:
+        # bits 8 and 9 are reserved and should be set to zero
+        self.fsType &= ~0x0300
+    if self.version >= 3:
+        # Only one of bits 1, 2, and 3 may be set. We already take
+        # care of bit 1 implications in mergeOs2FsType. So unset
+        # bit 2 if bit 3 is already set.
+        if self.fsType & 0x0008:
+            self.fsType &= ~0x0004
+    return self
+
+
+ttLib.getTableClass("post").mergeMap = {
+    "*": first,
+    "tableTag": equal,
+    "formatType": max,
+    "isFixedPitch": min,
+    "minMemType42": max,
+    "maxMemType42": lambda lst: 0,
+    "minMemType1": max,
+    "maxMemType1": lambda lst: 0,
+    "mapping": onlyExisting(sumDicts),
+    "extraNames": lambda lst: [],
+}
+
+ttLib.getTableClass("vmtx").mergeMap = ttLib.getTableClass("hmtx").mergeMap = {
+    "tableTag": equal,
+    "metrics": sumDicts,
+}
+
+ttLib.getTableClass("name").mergeMap = {
+    "tableTag": equal,
+    "names": first,  # FIXME? Does mixing name records make sense?
+}
+
+ttLib.getTableClass("loca").mergeMap = {
+    "*": recalculate,
+    "tableTag": equal,
+}
+
+ttLib.getTableClass("glyf").mergeMap = {
+    "tableTag": equal,
+    "glyphs": sumDicts,
+    "glyphOrder": sumLists,
+    "_reverseGlyphOrder": recalculate,
+    "axisTags": equal,
+}
+
+
+@add_method(ttLib.getTableClass("glyf"))
+def merge(self, m, tables):
+    for i, table in enumerate(tables):
+        for g in table.glyphs.values():
+            if i:
+                # Drop hints for all but first font, since
+                # we don't map functions / CVT values.
+                g.removeHinting()
+            # Expand composite glyphs to load their
+            # composite glyph names.
+            if g.isComposite():
+                g.expand(table)
+    return DefaultTable.merge(self, m, tables)
+
+
+ttLib.getTableClass("prep").mergeMap = lambda self, lst: first(lst)
+ttLib.getTableClass("fpgm").mergeMap = lambda self, lst: first(lst)
+ttLib.getTableClass("cvt ").mergeMap = lambda self, lst: first(lst)
+ttLib.getTableClass("gasp").mergeMap = lambda self, lst: first(
+    lst
+)  # FIXME? Appears irreconcilable
+
+
+@add_method(ttLib.getTableClass("CFF "))
+def merge(self, m, tables):
+    if any(hasattr(table.cff[0], "FDSelect") for table in tables):
+        raise NotImplementedError("Merging CID-keyed CFF tables is not supported yet")
+
+    for table in tables:
+        table.cff.desubroutinize()
+
+    newcff = tables[0]
+    newfont = newcff.cff[0]
+    private = newfont.Private
+    newDefaultWidthX, newNominalWidthX = private.defaultWidthX, private.nominalWidthX
+    storedNamesStrings = []
+    glyphOrderStrings = []
+    glyphOrder = set(newfont.getGlyphOrder())
+
+    for name in newfont.strings.strings:
+        if name not in glyphOrder:
+            storedNamesStrings.append(name)
+        else:
+            glyphOrderStrings.append(name)
+
+    chrset = list(newfont.charset)
+    newcs = newfont.CharStrings
+    log.debug("FONT 0 CharStrings: %d.", len(newcs))
+
+    for i, table in enumerate(tables[1:], start=1):
+        font = table.cff[0]
+        defaultWidthX, nominalWidthX = (
+            font.Private.defaultWidthX,
+            font.Private.nominalWidthX,
+        )
+        widthsDiffer = (
+            defaultWidthX != newDefaultWidthX or nominalWidthX != newNominalWidthX
+        )
+        font.Private = private
+        fontGlyphOrder = set(font.getGlyphOrder())
+        for name in font.strings.strings:
+            if name in fontGlyphOrder:
+                glyphOrderStrings.append(name)
+        cs = font.CharStrings
+        gs = table.cff.GlobalSubrs
+        log.debug("Font %d CharStrings: %d.", i, len(cs))
+        chrset.extend(font.charset)
+        if newcs.charStringsAreIndexed:
+            for i, name in enumerate(cs.charStrings, start=len(newcs)):
+                newcs.charStrings[name] = i
+                newcs.charStringsIndex.items.append(None)
+        for name in cs.charStrings:
+            if widthsDiffer:
+                c = cs[name]
+                defaultWidthXToken = object()
+                extractor = T2WidthExtractor([], [], nominalWidthX, defaultWidthXToken)
+                extractor.execute(c)
+                width = extractor.width
+                if width is not defaultWidthXToken:
+                    # The following will be wrong if the width is added
+                    # by a subroutine. Ouch!
+                    c.program.pop(0)
+                else:
+                    width = defaultWidthX
+                if width != newDefaultWidthX:
+                    c.program.insert(0, width - newNominalWidthX)
+            newcs[name] = cs[name]
+
+    newfont.charset = chrset
+    newfont.numGlyphs = len(chrset)
+    newfont.strings.strings = glyphOrderStrings + storedNamesStrings
+
+    return newcff
+
+
+@add_method(ttLib.getTableClass("cmap"))
+def merge(self, m, tables):
+    if not hasattr(m, "cmap"):
+        computeMegaCmap(m, tables)
+    cmap = m.cmap
+
+    cmapBmpOnly = {uni: gid for uni, gid in cmap.items() if uni <= 0xFFFF}
+    self.tables = []
+    module = ttLib.getTableModule("cmap")
+    if len(cmapBmpOnly) != len(cmap):
+        # format-12 required.
+        cmapTable = module.cmap_classes[12](12)
+        cmapTable.platformID = 3
+        cmapTable.platEncID = 10
+        cmapTable.language = 0
+        cmapTable.cmap = cmap
+        self.tables.append(cmapTable)
+    # always create format-4
+    cmapTable = module.cmap_classes[4](4)
+    cmapTable.platformID = 3
+    cmapTable.platEncID = 1
+    cmapTable.language = 0
+    cmapTable.cmap = cmapBmpOnly
+    # ordered by platform then encoding
+    self.tables.insert(0, cmapTable)
+
+    uvsDict = m.uvsDict
+    if uvsDict:
+        # format-14
+        uvsTable = module.cmap_classes[14](14)
+        uvsTable.platformID = 0
+        uvsTable.platEncID = 5
+        uvsTable.language = 0
+        uvsTable.cmap = {}
+        uvsTable.uvsDict = uvsDict
+        # ordered by platform then encoding
+        self.tables.insert(0, uvsTable)
+    self.tableVersion = 0
+    self.numSubTables = len(self.tables)
+    return self

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/merge/unicode.py

@@ -0,0 +1,78 @@
+# Copyright 2021 Behdad Esfahbod. All Rights Reserved.
+
+
+def is_Default_Ignorable(u):
+    # http://www.unicode.org/reports/tr44/#Default_Ignorable_Code_Point
+    #
+    # TODO Move me to unicodedata module and autogenerate.
+    #
+    # Unicode 14.0:
+    # $ grep '; Default_Ignorable_Code_Point ' DerivedCoreProperties.txt | sed 's/;.*#/#/'
+    # 00AD          # Cf       SOFT HYPHEN
+    # 034F          # Mn       COMBINING GRAPHEME JOINER
+    # 061C          # Cf       ARABIC LETTER MARK
+    # 115F..1160    # Lo   [2] HANGUL CHOSEONG FILLER..HANGUL JUNGSEONG FILLER
+    # 17B4..17B5    # Mn   [2] KHMER VOWEL INHERENT AQ..KHMER VOWEL INHERENT AA
+    # 180B..180D    # Mn   [3] MONGOLIAN FREE VARIATION SELECTOR ONE..MONGOLIAN FREE VARIATION SELECTOR THREE
+    # 180E          # Cf       MONGOLIAN VOWEL SEPARATOR
+    # 180F          # Mn       MONGOLIAN FREE VARIATION SELECTOR FOUR
+    # 200B..200F    # Cf   [5] ZERO WIDTH SPACE..RIGHT-TO-LEFT MARK
+    # 202A..202E    # Cf   [5] LEFT-TO-RIGHT EMBEDDING..RIGHT-TO-LEFT OVERRIDE
+    # 2060..2064    # Cf   [5] WORD JOINER..INVISIBLE PLUS
+    # 2065          # Cn       <reserved-2065>
+    # 2066..206F    # Cf  [10] LEFT-TO-RIGHT ISOLATE..NOMINAL DIGIT SHAPES
+    # 3164          # Lo       HANGUL FILLER
+    # FE00..FE0F    # Mn  [16] VARIATION SELECTOR-1..VARIATION SELECTOR-16
+    # FEFF          # Cf       ZERO WIDTH NO-BREAK SPACE
+    # FFA0          # Lo       HALFWIDTH HANGUL FILLER
+    # FFF0..FFF8    # Cn   [9] <reserved-FFF0>..<reserved-FFF8>
+    # 1BCA0..1BCA3  # Cf   [4] SHORTHAND FORMAT LETTER OVERLAP..SHORTHAND FORMAT UP STEP
+    # 1D173..1D17A  # Cf   [8] MUSICAL SYMBOL BEGIN BEAM..MUSICAL SYMBOL END PHRASE
+    # E0000         # Cn       <reserved-E0000>
+    # E0001         # Cf       LANGUAGE TAG
+    # E0002..E001F  # Cn  [30] <reserved-E0002>..<reserved-E001F>
+    # E0020..E007F  # Cf  [96] TAG SPACE..CANCEL TAG
+    # E0080..E00FF  # Cn [128] <reserved-E0080>..<reserved-E00FF>
+    # E0100..E01EF  # Mn [240] VARIATION SELECTOR-17..VARIATION SELECTOR-256
+    # E01F0..E0FFF  # Cn [3600] <reserved-E01F0>..<reserved-E0FFF>
+    return (
+        u == 0x00AD
+        or u == 0x034F  # Cf       SOFT HYPHEN
+        or u == 0x061C  # Mn       COMBINING GRAPHEME JOINER
+        or 0x115F <= u <= 0x1160  # Cf       ARABIC LETTER MARK
+        or 0x17B4  # Lo   [2] HANGUL CHOSEONG FILLER..HANGUL JUNGSEONG FILLER
+        <= u
+        <= 0x17B5
+        or 0x180B  # Mn   [2] KHMER VOWEL INHERENT AQ..KHMER VOWEL INHERENT AA
+        <= u
+        <= 0x180D
+        or u  # Mn   [3] MONGOLIAN FREE VARIATION SELECTOR ONE..MONGOLIAN FREE VARIATION SELECTOR THREE
+        == 0x180E
+        or u == 0x180F  # Cf       MONGOLIAN VOWEL SEPARATOR
+        or 0x200B <= u <= 0x200F  # Mn       MONGOLIAN FREE VARIATION SELECTOR FOUR
+        or 0x202A <= u <= 0x202E  # Cf   [5] ZERO WIDTH SPACE..RIGHT-TO-LEFT MARK
+        or 0x2060  # Cf   [5] LEFT-TO-RIGHT EMBEDDING..RIGHT-TO-LEFT OVERRIDE
+        <= u
+        <= 0x2064
+        or u == 0x2065  # Cf   [5] WORD JOINER..INVISIBLE PLUS
+        or 0x2066 <= u <= 0x206F  # Cn       <reserved-2065>
+        or u == 0x3164  # Cf  [10] LEFT-TO-RIGHT ISOLATE..NOMINAL DIGIT SHAPES
+        or 0xFE00 <= u <= 0xFE0F  # Lo       HANGUL FILLER
+        or u == 0xFEFF  # Mn  [16] VARIATION SELECTOR-1..VARIATION SELECTOR-16
+        or u == 0xFFA0  # Cf       ZERO WIDTH NO-BREAK SPACE
+        or 0xFFF0 <= u <= 0xFFF8  # Lo       HALFWIDTH HANGUL FILLER
+        or 0x1BCA0 <= u <= 0x1BCA3  # Cn   [9] <reserved-FFF0>..<reserved-FFF8>
+        or 0x1D173  # Cf   [4] SHORTHAND FORMAT LETTER OVERLAP..SHORTHAND FORMAT UP STEP
+        <= u
+        <= 0x1D17A
+        or u == 0xE0000  # Cf   [8] MUSICAL SYMBOL BEGIN BEAM..MUSICAL SYMBOL END PHRASE
+        or u == 0xE0001  # Cn       <reserved-E0000>
+        or 0xE0002 <= u <= 0xE001F  # Cf       LANGUAGE TAG
+        or 0xE0020 <= u <= 0xE007F  # Cn  [30] <reserved-E0002>..<reserved-E001F>
+        or 0xE0080 <= u <= 0xE00FF  # Cf  [96] TAG SPACE..CANCEL TAG
+        or 0xE0100 <= u <= 0xE01EF  # Cn [128] <reserved-E0080>..<reserved-E00FF>
+        or 0xE01F0  # Mn [240] VARIATION SELECTOR-17..VARIATION SELECTOR-256
+        <= u
+        <= 0xE0FFF
+        or False  # Cn [3600] <reserved-E01F0>..<reserved-E0FFF>
+    )

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/merge/util.py

@@ -0,0 +1,143 @@
+# Copyright 2013 Google, Inc. All Rights Reserved.
+#
+# Google Author(s): Behdad Esfahbod, Roozbeh Pournader
+
+from fontTools.misc.timeTools import timestampNow
+from fontTools.ttLib.tables.DefaultTable import DefaultTable
+from functools import reduce
+import operator
+import logging
+
+
+log = logging.getLogger("fontTools.merge")
+
+
+# General utility functions for merging values from different fonts
+
+
+def equal(lst):
+    lst = list(lst)
+    t = iter(lst)
+    first = next(t)
+    assert all(item == first for item in t), "Expected all items to be equal: %s" % lst
+    return first
+
+
+def first(lst):
+    return next(iter(lst))
+
+
+def recalculate(lst):
+    return NotImplemented
+
+
+def current_time(lst):
+    return timestampNow()
+
+
+def bitwise_and(lst):
+    return reduce(operator.and_, lst)
+
+
+def bitwise_or(lst):
+    return reduce(operator.or_, lst)
+
+
+def avg_int(lst):
+    lst = list(lst)
+    return sum(lst) // len(lst)
+
+
+def onlyExisting(func):
+    """Returns a filter func that when called with a list,
+    only calls func on the non-NotImplemented items of the list,
+    and only so if there's at least one item remaining.
+    Otherwise returns NotImplemented."""
+
+    def wrapper(lst):
+        items = [item for item in lst if item is not NotImplemented]
+        return func(items) if items else NotImplemented
+
+    return wrapper
+
+
+def sumLists(lst):
+    l = []
+    for item in lst:
+        l.extend(item)
+    return l
+
+
+def sumDicts(lst):
+    d = {}
+    for item in lst:
+        d.update(item)
+    return d
+
+
+def mergeBits(bitmap):
+    def wrapper(lst):
+        lst = list(lst)
+        returnValue = 0
+        for bitNumber in range(bitmap["size"]):
+            try:
+                mergeLogic = bitmap[bitNumber]
+            except KeyError:
+                try:
+                    mergeLogic = bitmap["*"]
+                except KeyError:
+                    raise Exception("Don't know how to merge bit %s" % bitNumber)
+            shiftedBit = 1 << bitNumber
+            mergedValue = mergeLogic(bool(item & shiftedBit) for item in lst)
+            returnValue |= mergedValue << bitNumber
+        return returnValue
+
+    return wrapper
+
+
+class AttendanceRecordingIdentityDict(object):
+    """A dictionary-like object that records indices of items actually accessed
+    from a list."""
+
+    def __init__(self, lst):
+        self.l = lst
+        self.d = {id(v): i for i, v in enumerate(lst)}
+        self.s = set()
+
+    def __getitem__(self, v):
+        self.s.add(self.d[id(v)])
+        return v
+
+
+class GregariousIdentityDict(object):
+    """A dictionary-like object that welcomes guests without reservations and
+    adds them to the end of the guest list."""
+
+    def __init__(self, lst):
+        self.l = lst
+        self.s = set(id(v) for v in lst)
+
+    def __getitem__(self, v):
+        if id(v) not in self.s:
+            self.s.add(id(v))
+            self.l.append(v)
+        return v
+
+
+class NonhashableDict(object):
+    """A dictionary-like object mapping objects to values."""
+
+    def __init__(self, keys, values=None):
+        if values is None:
+            self.d = {id(v): i for i, v in enumerate(keys)}
+        else:
+            self.d = {id(k): v for k, v in zip(keys, values)}
+
+    def __getitem__(self, k):
+        return self.d[id(k)]
+
+    def __setitem__(self, k, v):
+        self.d[id(k)] = v
+
+    def __delitem__(self, k):
+        del self.d[id(k)]

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/mtiLib/__init__.py

@@ -0,0 +1,1400 @@
+# FontDame-to-FontTools for OpenType Layout tables
+#
+# Source language spec is available at:
+# http://monotype.github.io/OpenType_Table_Source/otl_source.html
+# https://github.com/Monotype/OpenType_Table_Source/
+
+from fontTools import ttLib
+from fontTools.ttLib.tables._c_m_a_p import cmap_classes
+from fontTools.ttLib.tables import otTables as ot
+from fontTools.ttLib.tables.otBase import ValueRecord, valueRecordFormatDict
+from fontTools.otlLib import builder as otl
+from contextlib import contextmanager
+from fontTools.ttLib import newTable
+from fontTools.feaLib.lookupDebugInfo import LOOKUP_DEBUG_ENV_VAR, LOOKUP_DEBUG_INFO_KEY
+from operator import setitem
+import os
+import logging
+
+
+class MtiLibError(Exception):
+    pass
+
+
+class ReferenceNotFoundError(MtiLibError):
+    pass
+
+
+class FeatureNotFoundError(ReferenceNotFoundError):
+    pass
+
+
+class LookupNotFoundError(ReferenceNotFoundError):
+    pass
+
+
+log = logging.getLogger("fontTools.mtiLib")
+
+
+def makeGlyph(s):
+    if s[:2] in ["U ", "u "]:
+        return ttLib.TTFont._makeGlyphName(int(s[2:], 16))
+    elif s[:2] == "# ":
+        return "glyph%.5d" % int(s[2:])
+    assert s.find(" ") < 0, "Space found in glyph name: %s" % s
+    assert s, "Glyph name is empty"
+    return s
+
+
+def makeGlyphs(l):
+    return [makeGlyph(g) for g in l]
+
+
+def mapLookup(sym, mapping):
+    # Lookups are addressed by name.  So resolved them using a map if available.
+    # Fallback to parsing as lookup index if a map isn't provided.
+    if mapping is not None:
+        try:
+            idx = mapping[sym]
+        except KeyError:
+            raise LookupNotFoundError(sym)
+    else:
+        idx = int(sym)
+    return idx
+
+
+def mapFeature(sym, mapping):
+    # Features are referenced by index according the spec.  So, if symbol is an
+    # integer, use it directly.  Otherwise look up in the map if provided.
+    try:
+        idx = int(sym)
+    except ValueError:
+        try:
+            idx = mapping[sym]
+        except KeyError:
+            raise FeatureNotFoundError(sym)
+    return idx
+
+
+def setReference(mapper, mapping, sym, setter, collection, key):
+    try:
+        mapped = mapper(sym, mapping)
+    except ReferenceNotFoundError as e:
+        try:
+            if mapping is not None:
+                mapping.addDeferredMapping(
+                    lambda ref: setter(collection, key, ref), sym, e
+                )
+                return
+        except AttributeError:
+            pass
+        raise
+    setter(collection, key, mapped)
+
+
+class DeferredMapping(dict):
+    def __init__(self):
+        self._deferredMappings = []
+
+    def addDeferredMapping(self, setter, sym, e):
+        log.debug("Adding deferred mapping for symbol '%s' %s", sym, type(e).__name__)
+        self._deferredMappings.append((setter, sym, e))
+
+    def applyDeferredMappings(self):
+        for setter, sym, e in self._deferredMappings:
+            log.debug(
+                "Applying deferred mapping for symbol '%s' %s", sym, type(e).__name__
+            )
+            try:
+                mapped = self[sym]
+            except KeyError:
+                raise e
+            setter(mapped)
+            log.debug("Set to %s", mapped)
+        self._deferredMappings = []
+
+
+def parseScriptList(lines, featureMap=None):
+    self = ot.ScriptList()
+    records = []
+    with lines.between("script table"):
+        for line in lines:
+            while len(line) < 4:
+                line.append("")
+            scriptTag, langSysTag, defaultFeature, features = line
+            log.debug("Adding script %s language-system %s", scriptTag, langSysTag)
+
+            langSys = ot.LangSys()
+            langSys.LookupOrder = None
+            if defaultFeature:
+                setReference(
+                    mapFeature,
+                    featureMap,
+                    defaultFeature,
+                    setattr,
+                    langSys,
+                    "ReqFeatureIndex",
+                )
+            else:
+                langSys.ReqFeatureIndex = 0xFFFF
+            syms = stripSplitComma(features)
+            langSys.FeatureIndex = theList = [3] * len(syms)
+            for i, sym in enumerate(syms):
+                setReference(mapFeature, featureMap, sym, setitem, theList, i)
+            langSys.FeatureCount = len(langSys.FeatureIndex)
+
+            script = [s for s in records if s.ScriptTag == scriptTag]
+            if script:
+                script = script[0].Script
+            else:
+                scriptRec = ot.ScriptRecord()
+                scriptRec.ScriptTag = scriptTag + " " * (4 - len(scriptTag))
+                scriptRec.Script = ot.Script()
+                records.append(scriptRec)
+                script = scriptRec.Script
+                script.DefaultLangSys = None
+                script.LangSysRecord = []
+                script.LangSysCount = 0
+
+            if langSysTag == "default":
+                script.DefaultLangSys = langSys
+            else:
+                langSysRec = ot.LangSysRecord()
+                langSysRec.LangSysTag = langSysTag + " " * (4 - len(langSysTag))
+                langSysRec.LangSys = langSys
+                script.LangSysRecord.append(langSysRec)
+                script.LangSysCount = len(script.LangSysRecord)
+
+    for script in records:
+        script.Script.LangSysRecord = sorted(
+            script.Script.LangSysRecord, key=lambda rec: rec.LangSysTag
+        )
+    self.ScriptRecord = sorted(records, key=lambda rec: rec.ScriptTag)
+    self.ScriptCount = len(self.ScriptRecord)
+    return self
+
+
+def parseFeatureList(lines, lookupMap=None, featureMap=None):
+    self = ot.FeatureList()
+    self.FeatureRecord = []
+    with lines.between("feature table"):
+        for line in lines:
+            name, featureTag, lookups = line
+            if featureMap is not None:
+                assert name not in featureMap, "Duplicate feature name: %s" % name
+                featureMap[name] = len(self.FeatureRecord)
+            # If feature name is integer, make sure it matches its index.
+            try:
+                assert int(name) == len(self.FeatureRecord), "%d %d" % (
+                    name,
+                    len(self.FeatureRecord),
+                )
+            except ValueError:
+                pass
+            featureRec = ot.FeatureRecord()
+            featureRec.FeatureTag = featureTag
+            featureRec.Feature = ot.Feature()
+            self.FeatureRecord.append(featureRec)
+            feature = featureRec.Feature
+            feature.FeatureParams = None
+            syms = stripSplitComma(lookups)
+            feature.LookupListIndex = theList = [None] * len(syms)
+            for i, sym in enumerate(syms):
+                setReference(mapLookup, lookupMap, sym, setitem, theList, i)
+            feature.LookupCount = len(feature.LookupListIndex)
+
+    self.FeatureCount = len(self.FeatureRecord)
+    return self
+
+
+def parseLookupFlags(lines):
+    flags = 0
+    filterset = None
+    allFlags = [
+        "righttoleft",
+        "ignorebaseglyphs",
+        "ignoreligatures",
+        "ignoremarks",
+        "markattachmenttype",
+        "markfiltertype",
+    ]
+    while lines.peeks()[0].lower() in allFlags:
+        line = next(lines)
+        flag = {
+            "righttoleft": 0x0001,
+            "ignorebaseglyphs": 0x0002,
+            "ignoreligatures": 0x0004,
+            "ignoremarks": 0x0008,
+        }.get(line[0].lower())
+        if flag:
+            assert line[1].lower() in ["yes", "no"], line[1]
+            if line[1].lower() == "yes":
+                flags |= flag
+            continue
+        if line[0].lower() == "markattachmenttype":
+            flags |= int(line[1]) << 8
+            continue
+        if line[0].lower() == "markfiltertype":
+            flags |= 0x10
+            filterset = int(line[1])
+    return flags, filterset
+
+
+def parseSingleSubst(lines, font, _lookupMap=None):
+    mapping = {}
+    for line in lines:
+        assert len(line) == 2, line
+        line = makeGlyphs(line)
+        mapping[line[0]] = line[1]
+    return otl.buildSingleSubstSubtable(mapping)
+
+
+def parseMultiple(lines, font, _lookupMap=None):
+    mapping = {}
+    for line in lines:
+        line = makeGlyphs(line)
+        mapping[line[0]] = line[1:]
+    return otl.buildMultipleSubstSubtable(mapping)
+
+
+def parseAlternate(lines, font, _lookupMap=None):
+    mapping = {}
+    for line in lines:
+        line = makeGlyphs(line)
+        mapping[line[0]] = line[1:]
+    return otl.buildAlternateSubstSubtable(mapping)
+
+
+def parseLigature(lines, font, _lookupMap=None):
+    mapping = {}
+    for line in lines:
+        assert len(line) >= 2, line
+        line = makeGlyphs(line)
+        mapping[tuple(line[1:])] = line[0]
+    return otl.buildLigatureSubstSubtable(mapping)
+
+
+def parseSinglePos(lines, font, _lookupMap=None):
+    values = {}
+    for line in lines:
+        assert len(line) == 3, line
+        w = line[0].title().replace(" ", "")
+        assert w in valueRecordFormatDict
+        g = makeGlyph(line[1])
+        v = int(line[2])
+        if g not in values:
+            values[g] = ValueRecord()
+        assert not hasattr(values[g], w), (g, w)
+        setattr(values[g], w, v)
+    return otl.buildSinglePosSubtable(values, font.getReverseGlyphMap())
+
+
+def parsePair(lines, font, _lookupMap=None):
+    self = ot.PairPos()
+    self.ValueFormat1 = self.ValueFormat2 = 0
+    typ = lines.peeks()[0].split()[0].lower()
+    if typ in ("left", "right"):
+        self.Format = 1
+        values = {}
+        for line in lines:
+            assert len(line) == 4, line
+            side = line[0].split()[0].lower()
+            assert side in ("left", "right"), side
+            what = line[0][len(side) :].title().replace(" ", "")
+            mask = valueRecordFormatDict[what][0]
+            glyph1, glyph2 = makeGlyphs(line[1:3])
+            value = int(line[3])
+            if not glyph1 in values:
+                values[glyph1] = {}
+            if not glyph2 in values[glyph1]:
+                values[glyph1][glyph2] = (ValueRecord(), ValueRecord())
+            rec2 = values[glyph1][glyph2]
+            if side == "left":
+                self.ValueFormat1 |= mask
+                vr = rec2[0]
+            else:
+                self.ValueFormat2 |= mask
+                vr = rec2[1]
+            assert not hasattr(vr, what), (vr, what)
+            setattr(vr, what, value)
+        self.Coverage = makeCoverage(set(values.keys()), font)
+        self.PairSet = []
+        for glyph1 in self.Coverage.glyphs:
+            values1 = values[glyph1]
+            pairset = ot.PairSet()
+            records = pairset.PairValueRecord = []
+            for glyph2 in sorted(values1.keys(), key=font.getGlyphID):
+                values2 = values1[glyph2]
+                pair = ot.PairValueRecord()
+                pair.SecondGlyph = glyph2
+                pair.Value1 = values2[0]
+                pair.Value2 = values2[1] if self.ValueFormat2 else None
+                records.append(pair)
+            pairset.PairValueCount = len(pairset.PairValueRecord)
+            self.PairSet.append(pairset)
+        self.PairSetCount = len(self.PairSet)
+    elif typ.endswith("class"):
+        self.Format = 2
+        classDefs = [None, None]
+        while lines.peeks()[0].endswith("class definition begin"):
+            typ = lines.peek()[0][: -len("class definition begin")].lower()
+            idx, klass = {
+                "first": (0, ot.ClassDef1),
+                "second": (1, ot.ClassDef2),
+            }[typ]
+            assert classDefs[idx] is None
+            classDefs[idx] = parseClassDef(lines, font, klass=klass)
+        self.ClassDef1, self.ClassDef2 = classDefs
+        self.Class1Count, self.Class2Count = (
+            1 + max(c.classDefs.values()) for c in classDefs
+        )
+        self.Class1Record = [ot.Class1Record() for i in range(self.Class1Count)]
+        for rec1 in self.Class1Record:
+            rec1.Class2Record = [ot.Class2Record() for j in range(self.Class2Count)]
+            for rec2 in rec1.Class2Record:
+                rec2.Value1 = ValueRecord()
+                rec2.Value2 = ValueRecord()
+        for line in lines:
+            assert len(line) == 4, line
+            side = line[0].split()[0].lower()
+            assert side in ("left", "right"), side
+            what = line[0][len(side) :].title().replace(" ", "")
+            mask = valueRecordFormatDict[what][0]
+            class1, class2, value = (int(x) for x in line[1:4])
+            rec2 = self.Class1Record[class1].Class2Record[class2]
+            if side == "left":
+                self.ValueFormat1 |= mask
+                vr = rec2.Value1
+            else:
+                self.ValueFormat2 |= mask
+                vr = rec2.Value2
+            assert not hasattr(vr, what), (vr, what)
+            setattr(vr, what, value)
+        for rec1 in self.Class1Record:
+            for rec2 in rec1.Class2Record:
+                rec2.Value1 = ValueRecord(self.ValueFormat1, rec2.Value1)
+                rec2.Value2 = (
+                    ValueRecord(self.ValueFormat2, rec2.Value2)
+                    if self.ValueFormat2
+                    else None
+                )
+
+        self.Coverage = makeCoverage(set(self.ClassDef1.classDefs.keys()), font)
+    else:
+        assert 0, typ
+    return self
+
+
+def parseKernset(lines, font, _lookupMap=None):
+    typ = lines.peeks()[0].split()[0].lower()
+    if typ in ("left", "right"):
+        with lines.until(
+            ("firstclass definition begin", "secondclass definition begin")
+        ):
+            return parsePair(lines, font)
+    return parsePair(lines, font)
+
+
+def makeAnchor(data, klass=ot.Anchor):
+    assert len(data) <= 2
+    anchor = klass()
+    anchor.Format = 1
+    anchor.XCoordinate, anchor.YCoordinate = intSplitComma(data[0])
+    if len(data) > 1 and data[1] != "":
+        anchor.Format = 2
+        anchor.AnchorPoint = int(data[1])
+    return anchor
+
+
+def parseCursive(lines, font, _lookupMap=None):
+    records = {}
+    for line in lines:
+        assert len(line) in [3, 4], line
+        idx, klass = {
+            "entry": (0, ot.EntryAnchor),
+            "exit": (1, ot.ExitAnchor),
+        }[line[0]]
+        glyph = makeGlyph(line[1])
+        if glyph not in records:
+            records[glyph] = [None, None]
+        assert records[glyph][idx] is None, (glyph, idx)
+        records[glyph][idx] = makeAnchor(line[2:], klass)
+    return otl.buildCursivePosSubtable(records, font.getReverseGlyphMap())
+
+
+def makeMarkRecords(data, coverage, c):
+    records = []
+    for glyph in coverage.glyphs:
+        klass, anchor = data[glyph]
+        record = c.MarkRecordClass()
+        record.Class = klass
+        setattr(record, c.MarkAnchor, anchor)
+        records.append(record)
+    return records
+
+
+def makeBaseRecords(data, coverage, c, classCount):
+    records = []
+    idx = {}
+    for glyph in coverage.glyphs:
+        idx[glyph] = len(records)
+        record = c.BaseRecordClass()
+        anchors = [None] * classCount
+        setattr(record, c.BaseAnchor, anchors)
+        records.append(record)
+    for (glyph, klass), anchor in data.items():
+        record = records[idx[glyph]]
+        anchors = getattr(record, c.BaseAnchor)
+        assert anchors[klass] is None, (glyph, klass)
+        anchors[klass] = anchor
+    return records
+
+
+def makeLigatureRecords(data, coverage, c, classCount):
+    records = [None] * len(coverage.glyphs)
+    idx = {g: i for i, g in enumerate(coverage.glyphs)}
+
+    for (glyph, klass, compIdx, compCount), anchor in data.items():
+        record = records[idx[glyph]]
+        if record is None:
+            record = records[idx[glyph]] = ot.LigatureAttach()
+            record.ComponentCount = compCount
+            record.ComponentRecord = [ot.ComponentRecord() for i in range(compCount)]
+            for compRec in record.ComponentRecord:
+                compRec.LigatureAnchor = [None] * classCount
+        assert record.ComponentCount == compCount, (
+            glyph,
+            record.ComponentCount,
+            compCount,
+        )
+
+        anchors = record.ComponentRecord[compIdx - 1].LigatureAnchor
+        assert anchors[klass] is None, (glyph, compIdx, klass)
+        anchors[klass] = anchor
+    return records
+
+
+def parseMarkToSomething(lines, font, c):
+    self = c.Type()
+    self.Format = 1
+    markData = {}
+    baseData = {}
+    Data = {
+        "mark": (markData, c.MarkAnchorClass),
+        "base": (baseData, c.BaseAnchorClass),
+        "ligature": (baseData, c.BaseAnchorClass),
+    }
+    maxKlass = 0
+    for line in lines:
+        typ = line[0]
+        assert typ in ("mark", "base", "ligature")
+        glyph = makeGlyph(line[1])
+        data, anchorClass = Data[typ]
+        extraItems = 2 if typ == "ligature" else 0
+        extras = tuple(int(i) for i in line[2 : 2 + extraItems])
+        klass = int(line[2 + extraItems])
+        anchor = makeAnchor(line[3 + extraItems :], anchorClass)
+        if typ == "mark":
+            key, value = glyph, (klass, anchor)
+        else:
+            key, value = ((glyph, klass) + extras), anchor
+        assert key not in data, key
+        data[key] = value
+        maxKlass = max(maxKlass, klass)
+
+    # Mark
+    markCoverage = makeCoverage(set(markData.keys()), font, c.MarkCoverageClass)
+    markArray = c.MarkArrayClass()
+    markRecords = makeMarkRecords(markData, markCoverage, c)
+    setattr(markArray, c.MarkRecord, markRecords)
+    setattr(markArray, c.MarkCount, len(markRecords))
+    setattr(self, c.MarkCoverage, markCoverage)
+    setattr(self, c.MarkArray, markArray)
+    self.ClassCount = maxKlass + 1
+
+    # Base
+    self.classCount = 0 if not baseData else 1 + max(k[1] for k, v in baseData.items())
+    baseCoverage = makeCoverage(
+        set([k[0] for k in baseData.keys()]), font, c.BaseCoverageClass
+    )
+    baseArray = c.BaseArrayClass()
+    if c.Base == "Ligature":
+        baseRecords = makeLigatureRecords(baseData, baseCoverage, c, self.classCount)
+    else:
+        baseRecords = makeBaseRecords(baseData, baseCoverage, c, self.classCount)
+    setattr(baseArray, c.BaseRecord, baseRecords)
+    setattr(baseArray, c.BaseCount, len(baseRecords))
+    setattr(self, c.BaseCoverage, baseCoverage)
+    setattr(self, c.BaseArray, baseArray)
+
+    return self
+
+
+class MarkHelper(object):
+    def __init__(self):
+        for Which in ("Mark", "Base"):
+            for What in ("Coverage", "Array", "Count", "Record", "Anchor"):
+                key = Which + What
+                if Which == "Mark" and What in ("Count", "Record", "Anchor"):
+                    value = key
+                else:
+                    value = getattr(self, Which) + What
+                if value == "LigatureRecord":
+                    value = "LigatureAttach"
+                setattr(self, key, value)
+                if What != "Count":
+                    klass = getattr(ot, value)
+                    setattr(self, key + "Class", klass)
+
+
+class MarkToBaseHelper(MarkHelper):
+    Mark = "Mark"
+    Base = "Base"
+    Type = ot.MarkBasePos
+
+
+class MarkToMarkHelper(MarkHelper):
+    Mark = "Mark1"
+    Base = "Mark2"
+    Type = ot.MarkMarkPos
+
+
+class MarkToLigatureHelper(MarkHelper):
+    Mark = "Mark"
+    Base = "Ligature"
+    Type = ot.MarkLigPos
+
+
+def parseMarkToBase(lines, font, _lookupMap=None):
+    return parseMarkToSomething(lines, font, MarkToBaseHelper())
+
+
+def parseMarkToMark(lines, font, _lookupMap=None):
+    return parseMarkToSomething(lines, font, MarkToMarkHelper())
+
+
+def parseMarkToLigature(lines, font, _lookupMap=None):
+    return parseMarkToSomething(lines, font, MarkToLigatureHelper())
+
+
+def stripSplitComma(line):
+    return [s.strip() for s in line.split(",")] if line else []
+
+
+def intSplitComma(line):
+    return [int(i) for i in line.split(",")] if line else []
+
+
+# Copied from fontTools.subset
+class ContextHelper(object):
+    def __init__(self, klassName, Format):
+        if klassName.endswith("Subst"):
+            Typ = "Sub"
+            Type = "Subst"
+        else:
+            Typ = "Pos"
+            Type = "Pos"
+        if klassName.startswith("Chain"):
+            Chain = "Chain"
+            InputIdx = 1
+            DataLen = 3
+        else:
+            Chain = ""
+            InputIdx = 0
+            DataLen = 1
+        ChainTyp = Chain + Typ
+
+        self.Typ = Typ
+        self.Type = Type
+        self.Chain = Chain
+        self.ChainTyp = ChainTyp
+        self.InputIdx = InputIdx
+        self.DataLen = DataLen
+
+        self.LookupRecord = Type + "LookupRecord"
+
+        if Format == 1:
+            Coverage = lambda r: r.Coverage
+            ChainCoverage = lambda r: r.Coverage
+            ContextData = lambda r: (None,)
+            ChainContextData = lambda r: (None, None, None)
+            SetContextData = None
+            SetChainContextData = None
+            RuleData = lambda r: (r.Input,)
+            ChainRuleData = lambda r: (r.Backtrack, r.Input, r.LookAhead)
+
+            def SetRuleData(r, d):
+                (r.Input,) = d
+                (r.GlyphCount,) = (len(x) + 1 for x in d)
+
+            def ChainSetRuleData(r, d):
+                (r.Backtrack, r.Input, r.LookAhead) = d
+                (
+                    r.BacktrackGlyphCount,
+                    r.InputGlyphCount,
+                    r.LookAheadGlyphCount,
+                ) = (len(d[0]), len(d[1]) + 1, len(d[2]))
+
+        elif Format == 2:
+            Coverage = lambda r: r.Coverage
+            ChainCoverage = lambda r: r.Coverage
+            ContextData = lambda r: (r.ClassDef,)
+            ChainContextData = lambda r: (
+                r.BacktrackClassDef,
+                r.InputClassDef,
+                r.LookAheadClassDef,
+            )
+
+            def SetContextData(r, d):
+                (r.ClassDef,) = d
+
+            def SetChainContextData(r, d):
+                (r.BacktrackClassDef, r.InputClassDef, r.LookAheadClassDef) = d
+
+            RuleData = lambda r: (r.Class,)
+            ChainRuleData = lambda r: (r.Backtrack, r.Input, r.LookAhead)
+
+            def SetRuleData(r, d):
+                (r.Class,) = d
+                (r.GlyphCount,) = (len(x) + 1 for x in d)
+
+            def ChainSetRuleData(r, d):
+                (r.Backtrack, r.Input, r.LookAhead) = d
+                (
+                    r.BacktrackGlyphCount,
+                    r.InputGlyphCount,
+                    r.LookAheadGlyphCount,
+                ) = (len(d[0]), len(d[1]) + 1, len(d[2]))
+
+        elif Format == 3:
+            Coverage = lambda r: r.Coverage[0]
+            ChainCoverage = lambda r: r.InputCoverage[0]
+            ContextData = None
+            ChainContextData = None
+            SetContextData = None
+            SetChainContextData = None
+            RuleData = lambda r: r.Coverage
+            ChainRuleData = lambda r: (
+                r.BacktrackCoverage + r.InputCoverage + r.LookAheadCoverage
+            )
+
+            def SetRuleData(r, d):
+                (r.Coverage,) = d
+                (r.GlyphCount,) = (len(x) for x in d)
+
+            def ChainSetRuleData(r, d):
+                (r.BacktrackCoverage, r.InputCoverage, r.LookAheadCoverage) = d
+                (
+                    r.BacktrackGlyphCount,
+                    r.InputGlyphCount,
+                    r.LookAheadGlyphCount,
+                ) = (len(x) for x in d)
+
+        else:
+            assert 0, "unknown format: %s" % Format
+
+        if Chain:
+            self.Coverage = ChainCoverage
+            self.ContextData = ChainContextData
+            self.SetContextData = SetChainContextData
+            self.RuleData = ChainRuleData
+            self.SetRuleData = ChainSetRuleData
+        else:
+            self.Coverage = Coverage
+            self.ContextData = ContextData
+            self.SetContextData = SetContextData
+            self.RuleData = RuleData
+            self.SetRuleData = SetRuleData
+
+        if Format == 1:
+            self.Rule = ChainTyp + "Rule"
+            self.RuleCount = ChainTyp + "RuleCount"
+            self.RuleSet = ChainTyp + "RuleSet"
+            self.RuleSetCount = ChainTyp + "RuleSetCount"
+            self.Intersect = lambda glyphs, c, r: [r] if r in glyphs else []
+        elif Format == 2:
+            self.Rule = ChainTyp + "ClassRule"
+            self.RuleCount = ChainTyp + "ClassRuleCount"
+            self.RuleSet = ChainTyp + "ClassSet"
+            self.RuleSetCount = ChainTyp + "ClassSetCount"
+            self.Intersect = lambda glyphs, c, r: (
+                c.intersect_class(glyphs, r)
+                if c
+                else (set(glyphs) if r == 0 else set())
+            )
+
+            self.ClassDef = "InputClassDef" if Chain else "ClassDef"
+            self.ClassDefIndex = 1 if Chain else 0
+            self.Input = "Input" if Chain else "Class"
+
+
+def parseLookupRecords(items, klassName, lookupMap=None):
+    klass = getattr(ot, klassName)
+    lst = []
+    for item in items:
+        rec = klass()
+        item = stripSplitComma(item)
+        assert len(item) == 2, item
+        idx = int(item[0])
+        assert idx > 0, idx
+        rec.SequenceIndex = idx - 1
+        setReference(mapLookup, lookupMap, item[1], setattr, rec, "LookupListIndex")
+        lst.append(rec)
+    return lst
+
+
+def makeClassDef(classDefs, font, klass=ot.Coverage):
+    if not classDefs:
+        return None
+    self = klass()
+    self.classDefs = dict(classDefs)
+    return self
+
+
+def parseClassDef(lines, font, klass=ot.ClassDef):
+    classDefs = {}
+    with lines.between("class definition"):
+        for line in lines:
+            glyph = makeGlyph(line[0])
+            assert glyph not in classDefs, glyph
+            classDefs[glyph] = int(line[1])
+    return makeClassDef(classDefs, font, klass)
+
+
+def makeCoverage(glyphs, font, klass=ot.Coverage):
+    if not glyphs:
+        return None
+    if isinstance(glyphs, set):
+        glyphs = sorted(glyphs)
+    coverage = klass()
+    coverage.glyphs = sorted(set(glyphs), key=font.getGlyphID)
+    return coverage
+
+
+def parseCoverage(lines, font, klass=ot.Coverage):
+    glyphs = []
+    with lines.between("coverage definition"):
+        for line in lines:
+            glyphs.append(makeGlyph(line[0]))
+    return makeCoverage(glyphs, font, klass)
+
+
+def bucketizeRules(self, c, rules, bucketKeys):
+    buckets = {}
+    for seq, recs in rules:
+        buckets.setdefault(seq[c.InputIdx][0], []).append(
+            (tuple(s[1 if i == c.InputIdx else 0 :] for i, s in enumerate(seq)), recs)
+        )
+
+    rulesets = []
+    for firstGlyph in bucketKeys:
+        if firstGlyph not in buckets:
+            rulesets.append(None)
+            continue
+        thisRules = []
+        for seq, recs in buckets[firstGlyph]:
+            rule = getattr(ot, c.Rule)()
+            c.SetRuleData(rule, seq)
+            setattr(rule, c.Type + "Count", len(recs))
+            setattr(rule, c.LookupRecord, recs)
+            thisRules.append(rule)
+
+        ruleset = getattr(ot, c.RuleSet)()
+        setattr(ruleset, c.Rule, thisRules)
+        setattr(ruleset, c.RuleCount, len(thisRules))
+        rulesets.append(ruleset)
+
+    setattr(self, c.RuleSet, rulesets)
+    setattr(self, c.RuleSetCount, len(rulesets))
+
+
+def parseContext(lines, font, Type, lookupMap=None):
+    self = getattr(ot, Type)()
+    typ = lines.peeks()[0].split()[0].lower()
+    if typ == "glyph":
+        self.Format = 1
+        log.debug("Parsing %s format %s", Type, self.Format)
+        c = ContextHelper(Type, self.Format)
+        rules = []
+        for line in lines:
+            assert line[0].lower() == "glyph", line[0]
+            while len(line) < 1 + c.DataLen:
+                line.append("")
+            seq = tuple(makeGlyphs(stripSplitComma(i)) for i in line[1 : 1 + c.DataLen])
+            recs = parseLookupRecords(line[1 + c.DataLen :], c.LookupRecord, lookupMap)
+            rules.append((seq, recs))
+
+        firstGlyphs = set(seq[c.InputIdx][0] for seq, recs in rules)
+        self.Coverage = makeCoverage(firstGlyphs, font)
+        bucketizeRules(self, c, rules, self.Coverage.glyphs)
+    elif typ.endswith("class"):
+        self.Format = 2
+        log.debug("Parsing %s format %s", Type, self.Format)
+        c = ContextHelper(Type, self.Format)
+        classDefs = [None] * c.DataLen
+        while lines.peeks()[0].endswith("class definition begin"):
+            typ = lines.peek()[0][: -len("class definition begin")].lower()
+            idx, klass = {
+                1: {
+                    "": (0, ot.ClassDef),
+                },
+                3: {
+                    "backtrack": (0, ot.BacktrackClassDef),
+                    "": (1, ot.InputClassDef),
+                    "lookahead": (2, ot.LookAheadClassDef),
+                },
+            }[c.DataLen][typ]
+            assert classDefs[idx] is None, idx
+            classDefs[idx] = parseClassDef(lines, font, klass=klass)
+        c.SetContextData(self, classDefs)
+        rules = []
+        for line in lines:
+            assert line[0].lower().startswith("class"), line[0]
+            while len(line) < 1 + c.DataLen:
+                line.append("")
+            seq = tuple(intSplitComma(i) for i in line[1 : 1 + c.DataLen])
+            recs = parseLookupRecords(line[1 + c.DataLen :], c.LookupRecord, lookupMap)
+            rules.append((seq, recs))
+        firstClasses = set(seq[c.InputIdx][0] for seq, recs in rules)
+        firstGlyphs = set(
+            g for g, c in classDefs[c.InputIdx].classDefs.items() if c in firstClasses
+        )
+        self.Coverage = makeCoverage(firstGlyphs, font)
+        bucketizeRules(self, c, rules, range(max(firstClasses) + 1))
+    elif typ.endswith("coverage"):
+        self.Format = 3
+        log.debug("Parsing %s format %s", Type, self.Format)
+        c = ContextHelper(Type, self.Format)
+        coverages = tuple([] for i in range(c.DataLen))
+        while lines.peeks()[0].endswith("coverage definition begin"):
+            typ = lines.peek()[0][: -len("coverage definition begin")].lower()
+            idx, klass = {
+                1: {
+                    "": (0, ot.Coverage),
+                },
+                3: {
+                    "backtrack": (0, ot.BacktrackCoverage),
+                    "input": (1, ot.InputCoverage),
+                    "lookahead": (2, ot.LookAheadCoverage),
+                },
+            }[c.DataLen][typ]
+            coverages[idx].append(parseCoverage(lines, font, klass=klass))
+        c.SetRuleData(self, coverages)
+        lines = list(lines)
+        assert len(lines) == 1
+        line = lines[0]
+        assert line[0].lower() == "coverage", line[0]
+        recs = parseLookupRecords(line[1:], c.LookupRecord, lookupMap)
+        setattr(self, c.Type + "Count", len(recs))
+        setattr(self, c.LookupRecord, recs)
+    else:
+        assert 0, typ
+    return self
+
+
+def parseContextSubst(lines, font, lookupMap=None):
+    return parseContext(lines, font, "ContextSubst", lookupMap=lookupMap)
+
+
+def parseContextPos(lines, font, lookupMap=None):
+    return parseContext(lines, font, "ContextPos", lookupMap=lookupMap)
+
+
+def parseChainedSubst(lines, font, lookupMap=None):
+    return parseContext(lines, font, "ChainContextSubst", lookupMap=lookupMap)
+
+
+def parseChainedPos(lines, font, lookupMap=None):
+    return parseContext(lines, font, "ChainContextPos", lookupMap=lookupMap)
+
+
+def parseReverseChainedSubst(lines, font, _lookupMap=None):
+    self = ot.ReverseChainSingleSubst()
+    self.Format = 1
+    coverages = ([], [])
+    while lines.peeks()[0].endswith("coverage definition begin"):
+        typ = lines.peek()[0][: -len("coverage definition begin")].lower()
+        idx, klass = {
+            "backtrack": (0, ot.BacktrackCoverage),
+            "lookahead": (1, ot.LookAheadCoverage),
+        }[typ]
+        coverages[idx].append(parseCoverage(lines, font, klass=klass))
+    self.BacktrackCoverage = coverages[0]
+    self.BacktrackGlyphCount = len(self.BacktrackCoverage)
+    self.LookAheadCoverage = coverages[1]
+    self.LookAheadGlyphCount = len(self.LookAheadCoverage)
+    mapping = {}
+    for line in lines:
+        assert len(line) == 2, line
+        line = makeGlyphs(line)
+        mapping[line[0]] = line[1]
+    self.Coverage = makeCoverage(set(mapping.keys()), font)
+    self.Substitute = [mapping[k] for k in self.Coverage.glyphs]
+    self.GlyphCount = len(self.Substitute)
+    return self
+
+
+def parseLookup(lines, tableTag, font, lookupMap=None):
+    line = lines.expect("lookup")
+    _, name, typ = line
+    log.debug("Parsing lookup type %s %s", typ, name)
+    lookup = ot.Lookup()
+    lookup.LookupFlag, filterset = parseLookupFlags(lines)
+    if filterset is not None:
+        lookup.MarkFilteringSet = filterset
+    lookup.LookupType, parseLookupSubTable = {
+        "GSUB": {
+            "single": (1, parseSingleSubst),
+            "multiple": (2, parseMultiple),
+            "alternate": (3, parseAlternate),
+            "ligature": (4, parseLigature),
+            "context": (5, parseContextSubst),
+            "chained": (6, parseChainedSubst),
+            "reversechained": (8, parseReverseChainedSubst),
+        },
+        "GPOS": {
+            "single": (1, parseSinglePos),
+            "pair": (2, parsePair),
+            "kernset": (2, parseKernset),
+            "cursive": (3, parseCursive),
+            "mark to base": (4, parseMarkToBase),
+            "mark to ligature": (5, parseMarkToLigature),
+            "mark to mark": (6, parseMarkToMark),
+            "context": (7, parseContextPos),
+            "chained": (8, parseChainedPos),
+        },
+    }[tableTag][typ]
+
+    with lines.until("lookup end"):
+        subtables = []
+
+        while lines.peek():
+            with lines.until(("% subtable", "subtable end")):
+                while lines.peek():
+                    subtable = parseLookupSubTable(lines, font, lookupMap)
+                    assert lookup.LookupType == subtable.LookupType
+                    subtables.append(subtable)
+            if lines.peeks()[0] in ("% subtable", "subtable end"):
+                next(lines)
+    lines.expect("lookup end")
+
+    lookup.SubTable = subtables
+    lookup.SubTableCount = len(lookup.SubTable)
+    if lookup.SubTableCount == 0:
+        # Remove this return when following is fixed:
+        # https://github.com/fonttools/fonttools/issues/789
+        return None
+    return lookup
+
+
+def parseGSUBGPOS(lines, font, tableTag):
+    container = ttLib.getTableClass(tableTag)()
+    lookupMap = DeferredMapping()
+    featureMap = DeferredMapping()
+    assert tableTag in ("GSUB", "GPOS")
+    log.debug("Parsing %s", tableTag)
+    self = getattr(ot, tableTag)()
+    self.Version = 0x00010000
+    fields = {
+        "script table begin": (
+            "ScriptList",
+            lambda lines: parseScriptList(lines, featureMap),
+        ),
+        "feature table begin": (
+            "FeatureList",
+            lambda lines: parseFeatureList(lines, lookupMap, featureMap),
+        ),
+        "lookup": ("LookupList", None),
+    }
+    for attr, parser in fields.values():
+        setattr(self, attr, None)
+    while lines.peek() is not None:
+        typ = lines.peek()[0].lower()
+        if typ not in fields:
+            log.debug("Skipping %s", lines.peek())
+            next(lines)
+            continue
+        attr, parser = fields[typ]
+        if typ == "lookup":
+            if self.LookupList is None:
+                self.LookupList = ot.LookupList()
+                self.LookupList.Lookup = []
+            _, name, _ = lines.peek()
+            lookup = parseLookup(lines, tableTag, font, lookupMap)
+            if lookupMap is not None:
+                assert name not in lookupMap, "Duplicate lookup name: %s" % name
+                lookupMap[name] = len(self.LookupList.Lookup)
+            else:
+                assert int(name) == len(self.LookupList.Lookup), "%d %d" % (
+                    name,
+                    len(self.Lookup),
+                )
+            self.LookupList.Lookup.append(lookup)
+        else:
+            assert getattr(self, attr) is None, attr
+            setattr(self, attr, parser(lines))
+    if self.LookupList:
+        self.LookupList.LookupCount = len(self.LookupList.Lookup)
+    if lookupMap is not None:
+        lookupMap.applyDeferredMappings()
+        if os.environ.get(LOOKUP_DEBUG_ENV_VAR):
+            if "Debg" not in font:
+                font["Debg"] = newTable("Debg")
+                font["Debg"].data = {}
+            debug = (
+                font["Debg"]
+                .data.setdefault(LOOKUP_DEBUG_INFO_KEY, {})
+                .setdefault(tableTag, {})
+            )
+            for name, lookup in lookupMap.items():
+                debug[str(lookup)] = ["", name, ""]
+
+        featureMap.applyDeferredMappings()
+    container.table = self
+    return container
+
+
+def parseGSUB(lines, font):
+    return parseGSUBGPOS(lines, font, "GSUB")
+
+
+def parseGPOS(lines, font):
+    return parseGSUBGPOS(lines, font, "GPOS")
+
+
+def parseAttachList(lines, font):
+    points = {}
+    with lines.between("attachment list"):
+        for line in lines:
+            glyph = makeGlyph(line[0])
+            assert glyph not in points, glyph
+            points[glyph] = [int(i) for i in line[1:]]
+    return otl.buildAttachList(points, font.getReverseGlyphMap())
+
+
+def parseCaretList(lines, font):
+    carets = {}
+    with lines.between("carets"):
+        for line in lines:
+            glyph = makeGlyph(line[0])
+            assert glyph not in carets, glyph
+            num = int(line[1])
+            thisCarets = [int(i) for i in line[2:]]
+            assert num == len(thisCarets), line
+            carets[glyph] = thisCarets
+    return otl.buildLigCaretList(carets, {}, font.getReverseGlyphMap())
+
+
+def makeMarkFilteringSets(sets, font):
+    self = ot.MarkGlyphSetsDef()
+    self.MarkSetTableFormat = 1
+    self.MarkSetCount = 1 + max(sets.keys())
+    self.Coverage = [None] * self.MarkSetCount
+    for k, v in sorted(sets.items()):
+        self.Coverage[k] = makeCoverage(set(v), font)
+    return self
+
+
+def parseMarkFilteringSets(lines, font):
+    sets = {}
+    with lines.between("set definition"):
+        for line in lines:
+            assert len(line) == 2, line
+            glyph = makeGlyph(line[0])
+            # TODO accept set names
+            st = int(line[1])
+            if st not in sets:
+                sets[st] = []
+            sets[st].append(glyph)
+    return makeMarkFilteringSets(sets, font)
+
+
+def parseGDEF(lines, font):
+    container = ttLib.getTableClass("GDEF")()
+    log.debug("Parsing GDEF")
+    self = ot.GDEF()
+    fields = {
+        "class definition begin": (
+            "GlyphClassDef",
+            lambda lines, font: parseClassDef(lines, font, klass=ot.GlyphClassDef),
+        ),
+        "attachment list begin": ("AttachList", parseAttachList),
+        "carets begin": ("LigCaretList", parseCaretList),
+        "mark attachment class definition begin": (
+            "MarkAttachClassDef",
+            lambda lines, font: parseClassDef(lines, font, klass=ot.MarkAttachClassDef),
+        ),
+        "markfilter set definition begin": ("MarkGlyphSetsDef", parseMarkFilteringSets),
+    }
+    for attr, parser in fields.values():
+        setattr(self, attr, None)
+    while lines.peek() is not None:
+        typ = lines.peek()[0].lower()
+        if typ not in fields:
+            log.debug("Skipping %s", typ)
+            next(lines)
+            continue
+        attr, parser = fields[typ]
+        assert getattr(self, attr) is None, attr
+        setattr(self, attr, parser(lines, font))
+    self.Version = 0x00010000 if self.MarkGlyphSetsDef is None else 0x00010002
+    container.table = self
+    return container
+
+
+def parseCmap(lines, font):
+    container = ttLib.getTableClass("cmap")()
+    log.debug("Parsing cmap")
+    tables = []
+    while lines.peek() is not None:
+        lines.expect("cmap subtable %d" % len(tables))
+        platId, encId, fmt, lang = [
+            parseCmapId(lines, field)
+            for field in ("platformID", "encodingID", "format", "language")
+        ]
+        table = cmap_classes[fmt](fmt)
+        table.platformID = platId
+        table.platEncID = encId
+        table.language = lang
+        table.cmap = {}
+        line = next(lines)
+        while line[0] != "end subtable":
+            table.cmap[int(line[0], 16)] = line[1]
+            line = next(lines)
+        tables.append(table)
+    container.tableVersion = 0
+    container.tables = tables
+    return container
+
+
+def parseCmapId(lines, field):
+    line = next(lines)
+    assert field == line[0]
+    return int(line[1])
+
+
+def parseTable(lines, font, tableTag=None):
+    log.debug("Parsing table")
+    line = lines.peeks()
+    tag = None
+    if line[0].split()[0] == "FontDame":
+        tag = line[0].split()[1]
+    elif " ".join(line[0].split()[:3]) == "Font Chef Table":
+        tag = line[0].split()[3]
+    if tag is not None:
+        next(lines)
+        tag = tag.ljust(4)
+        if tableTag is None:
+            tableTag = tag
+        else:
+            assert tableTag == tag, (tableTag, tag)
+
+    assert (
+        tableTag is not None
+    ), "Don't know what table to parse and data doesn't specify"
+
+    return {
+        "GSUB": parseGSUB,
+        "GPOS": parseGPOS,
+        "GDEF": parseGDEF,
+        "cmap": parseCmap,
+    }[tableTag](lines, font)
+
+
+class Tokenizer(object):
+    def __init__(self, f):
+        # TODO BytesIO / StringIO as needed?  also, figure out whether we work on bytes or unicode
+        lines = iter(f)
+        try:
+            self.filename = f.name
+        except:
+            self.filename = None
+        self.lines = iter(lines)
+        self.line = ""
+        self.lineno = 0
+        self.stoppers = []
+        self.buffer = None
+
+    def __iter__(self):
+        return self
+
+    def _next_line(self):
+        self.lineno += 1
+        line = self.line = next(self.lines)
+        line = [s.strip() for s in line.split("\t")]
+        if len(line) == 1 and not line[0]:
+            del line[0]
+        if line and not line[-1]:
+            log.warning("trailing tab found on line %d: %s" % (self.lineno, self.line))
+            while line and not line[-1]:
+                del line[-1]
+        return line
+
+    def _next_nonempty(self):
+        while True:
+            line = self._next_line()
+            # Skip comments and empty lines
+            if line and line[0] and (line[0][0] != "%" or line[0] == "% subtable"):
+                return line
+
+    def _next_buffered(self):
+        if self.buffer:
+            ret = self.buffer
+            self.buffer = None
+            return ret
+        else:
+            return self._next_nonempty()
+
+    def __next__(self):
+        line = self._next_buffered()
+        if line[0].lower() in self.stoppers:
+            self.buffer = line
+            raise StopIteration
+        return line
+
+    def next(self):
+        return self.__next__()
+
+    def peek(self):
+        if not self.buffer:
+            try:
+                self.buffer = self._next_nonempty()
+            except StopIteration:
+                return None
+        if self.buffer[0].lower() in self.stoppers:
+            return None
+        return self.buffer
+
+    def peeks(self):
+        ret = self.peek()
+        return ret if ret is not None else ("",)
+
+    @contextmanager
+    def between(self, tag):
+        start = tag + " begin"
+        end = tag + " end"
+        self.expectendswith(start)
+        self.stoppers.append(end)
+        yield
+        del self.stoppers[-1]
+        self.expect(tag + " end")
+
+    @contextmanager
+    def until(self, tags):
+        if type(tags) is not tuple:
+            tags = (tags,)
+        self.stoppers.extend(tags)
+        yield
+        del self.stoppers[-len(tags) :]
+
+    def expect(self, s):
+        line = next(self)
+        tag = line[0].lower()
+        assert tag == s, "Expected '%s', got '%s'" % (s, tag)
+        return line
+
+    def expectendswith(self, s):
+        line = next(self)
+        tag = line[0].lower()
+        assert tag.endswith(s), "Expected '*%s', got '%s'" % (s, tag)
+        return line
+
+
+def build(f, font, tableTag=None):
+    """Convert a Monotype font layout file to an OpenType layout object
+
+    A font object must be passed, but this may be a "dummy" font; it is only
+    used for sorting glyph sets when making coverage tables and to hold the
+    OpenType layout table while it is being built.
+
+    Args:
+            f: A file object.
+            font (TTFont): A font object.
+            tableTag (string): If provided, asserts that the file contains data for the
+                    given OpenType table.
+
+    Returns:
+            An object representing the table. (e.g. ``table_G_S_U_B_``)
+    """
+    lines = Tokenizer(f)
+    return parseTable(lines, font, tableTag=tableTag)
+
+
+def main(args=None, font=None):
+    """Convert a FontDame OTL file to TTX XML
+
+    Writes XML output to stdout.
+
+    Args:
+            args: Command line arguments (``--font``, ``--table``, input files).
+    """
+    import sys
+    from fontTools import configLogger
+    from fontTools.misc.testTools import MockFont
+
+    if args is None:
+        args = sys.argv[1:]
+
+    # configure the library logger (for >= WARNING)
+    configLogger()
+    # comment this out to enable debug messages from mtiLib's logger
+    # log.setLevel(logging.DEBUG)
+
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        "fonttools mtiLib",
+        description=main.__doc__,
+    )
+
+    parser.add_argument(
+        "--font",
+        "-f",
+        metavar="FILE",
+        dest="font",
+        help="Input TTF files (used for glyph classes and sorting coverage tables)",
+    )
+    parser.add_argument(
+        "--table",
+        "-t",
+        metavar="TABLE",
+        dest="tableTag",
+        help="Table to fill (sniffed from input file if not provided)",
+    )
+    parser.add_argument(
+        "inputs", metavar="FILE", type=str, nargs="+", help="Input FontDame .txt files"
+    )
+
+    args = parser.parse_args(args)
+
+    if font is None:
+        if args.font:
+            font = ttLib.TTFont(args.font)
+        else:
+            font = MockFont()
+
+    for f in args.inputs:
+        log.debug("Processing %s", f)
+        with open(f, "rt", encoding="utf-8-sig") as f:
+            table = build(f, font, tableTag=args.tableTag)
+        blob = table.compile(font)  # Make sure it compiles
+        decompiled = table.__class__()
+        decompiled.decompile(blob, font)  # Make sure it decompiles!
+
+        # continue
+        from fontTools.misc import xmlWriter
+
+        tag = table.tableTag
+        writer = xmlWriter.XMLWriter(sys.stdout)
+        writer.begintag(tag)
+        writer.newline()
+        # table.toXML(writer, font)
+        decompiled.toXML(writer, font)
+        writer.endtag(tag)
+        writer.newline()
+
+
+if __name__ == "__main__":
+    import sys
+
+    sys.exit(main())

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/mtiLib/__main__.py

@@ -0,0 +1,5 @@
+import sys
+from fontTools.mtiLib import main
+
+if __name__ == "__main__":
+    sys.exit(main())

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/otlLib/__init__.py

@@ -0,0 +1 @@
+"""OpenType Layout-related functionality."""

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/otlLib/error.py

@@ -0,0 +1,11 @@
+class OpenTypeLibError(Exception):
+    def __init__(self, message, location):
+        Exception.__init__(self, message)
+        self.location = location
+
+    def __str__(self):
+        message = Exception.__str__(self)
+        if self.location:
+            return f"{self.location}: {message}"
+        else:
+            return message

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/otlLib/maxContextCalc.py

@@ -0,0 +1,96 @@
+__all__ = ["maxCtxFont"]
+
+
+def maxCtxFont(font):
+    """Calculate the usMaxContext value for an entire font."""
+
+    maxCtx = 0
+    for tag in ("GSUB", "GPOS"):
+        if tag not in font:
+            continue
+        table = font[tag].table
+        if not table.LookupList:
+            continue
+        for lookup in table.LookupList.Lookup:
+            for st in lookup.SubTable:
+                maxCtx = maxCtxSubtable(maxCtx, tag, lookup.LookupType, st)
+    return maxCtx
+
+
+def maxCtxSubtable(maxCtx, tag, lookupType, st):
+    """Calculate usMaxContext based on a single lookup table (and an existing
+    max value).
+    """
+
+    # single positioning, single / multiple substitution
+    if (tag == "GPOS" and lookupType == 1) or (
+        tag == "GSUB" and lookupType in (1, 2, 3)
+    ):
+        maxCtx = max(maxCtx, 1)
+
+    # pair positioning
+    elif tag == "GPOS" and lookupType == 2:
+        maxCtx = max(maxCtx, 2)
+
+    # ligatures
+    elif tag == "GSUB" and lookupType == 4:
+        for ligatures in st.ligatures.values():
+            for ligature in ligatures:
+                maxCtx = max(maxCtx, ligature.CompCount)
+
+    # context
+    elif (tag == "GPOS" and lookupType == 7) or (tag == "GSUB" and lookupType == 5):
+        maxCtx = maxCtxContextualSubtable(maxCtx, st, "Pos" if tag == "GPOS" else "Sub")
+
+    # chained context
+    elif (tag == "GPOS" and lookupType == 8) or (tag == "GSUB" and lookupType == 6):
+        maxCtx = maxCtxContextualSubtable(
+            maxCtx, st, "Pos" if tag == "GPOS" else "Sub", "Chain"
+        )
+
+    # extensions
+    elif (tag == "GPOS" and lookupType == 9) or (tag == "GSUB" and lookupType == 7):
+        maxCtx = maxCtxSubtable(maxCtx, tag, st.ExtensionLookupType, st.ExtSubTable)
+
+    # reverse-chained context
+    elif tag == "GSUB" and lookupType == 8:
+        maxCtx = maxCtxContextualRule(maxCtx, st, "Reverse")
+
+    return maxCtx
+
+
+def maxCtxContextualSubtable(maxCtx, st, ruleType, chain=""):
+    """Calculate usMaxContext based on a contextual feature subtable."""
+
+    if st.Format == 1:
+        for ruleset in getattr(st, "%s%sRuleSet" % (chain, ruleType)):
+            if ruleset is None:
+                continue
+            for rule in getattr(ruleset, "%s%sRule" % (chain, ruleType)):
+                if rule is None:
+                    continue
+                maxCtx = maxCtxContextualRule(maxCtx, rule, chain)
+
+    elif st.Format == 2:
+        for ruleset in getattr(st, "%s%sClassSet" % (chain, ruleType)):
+            if ruleset is None:
+                continue
+            for rule in getattr(ruleset, "%s%sClassRule" % (chain, ruleType)):
+                if rule is None:
+                    continue
+                maxCtx = maxCtxContextualRule(maxCtx, rule, chain)
+
+    elif st.Format == 3:
+        maxCtx = maxCtxContextualRule(maxCtx, st, chain)
+
+    return maxCtx
+
+
+def maxCtxContextualRule(maxCtx, st, chain):
+    """Calculate usMaxContext based on a contextual feature rule."""
+
+    if not chain:
+        return max(maxCtx, st.GlyphCount)
+    elif chain == "Reverse":
+        return max(maxCtx, 1 + st.LookAheadGlyphCount)
+    return max(maxCtx, st.InputGlyphCount + st.LookAheadGlyphCount)

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/otlLib/optimize/__init__.py

@@ -0,0 +1,53 @@
+from argparse import RawTextHelpFormatter
+from fontTools.otlLib.optimize.gpos import COMPRESSION_LEVEL, compact
+from fontTools.ttLib import TTFont
+
+
+def main(args=None):
+    """Optimize the layout tables of an existing font"""
+    from argparse import ArgumentParser
+
+    from fontTools import configLogger
+
+    parser = ArgumentParser(
+        prog="otlLib.optimize",
+        description=main.__doc__,
+        formatter_class=RawTextHelpFormatter,
+    )
+    parser.add_argument("font")
+    parser.add_argument(
+        "-o", metavar="OUTPUTFILE", dest="outfile", default=None, help="output file"
+    )
+    parser.add_argument(
+        "--gpos-compression-level",
+        help=COMPRESSION_LEVEL.help,
+        default=COMPRESSION_LEVEL.default,
+        choices=list(range(10)),
+        type=int,
+    )
+    logging_group = parser.add_mutually_exclusive_group(required=False)
+    logging_group.add_argument(
+        "-v", "--verbose", action="store_true", help="Run more verbosely."
+    )
+    logging_group.add_argument(
+        "-q", "--quiet", action="store_true", help="Turn verbosity off."
+    )
+    options = parser.parse_args(args)
+
+    configLogger(
+        level=("DEBUG" if options.verbose else "ERROR" if options.quiet else "INFO")
+    )
+
+    font = TTFont(options.font)
+    compact(font, options.gpos_compression_level)
+    font.save(options.outfile or options.font)
+
+
+if __name__ == "__main__":
+    import sys
+
+    if len(sys.argv) > 1:
+        sys.exit(main())
+    import doctest
+
+    sys.exit(doctest.testmod().failed)

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/otlLib/optimize/__main__.py

@@ -0,0 +1,6 @@
+import sys
+from fontTools.otlLib.optimize import main
+
+
+if __name__ == "__main__":
+    sys.exit(main())

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/otlLib/optimize/gpos.py

@@ -0,0 +1,439 @@
+import logging
+import os
+from collections import defaultdict, namedtuple
+from dataclasses import dataclass
+from functools import cached_property, reduce
+from itertools import chain
+from math import log2
+from typing import DefaultDict, Dict, Iterable, List, Sequence, Tuple
+
+from fontTools.config import OPTIONS
+from fontTools.misc.intTools import bit_count, bit_indices
+from fontTools.ttLib import TTFont
+from fontTools.ttLib.tables import otBase, otTables
+
+log = logging.getLogger(__name__)
+
+COMPRESSION_LEVEL = OPTIONS[f"{__name__}:COMPRESSION_LEVEL"]
+
+# Kept because ufo2ft depends on it, to be removed once ufo2ft uses the config instead
+# https://github.com/fonttools/fonttools/issues/2592
+GPOS_COMPACT_MODE_ENV_KEY = "FONTTOOLS_GPOS_COMPACT_MODE"
+GPOS_COMPACT_MODE_DEFAULT = str(COMPRESSION_LEVEL.default)
+
+
+def _compression_level_from_env() -> int:
+    env_level = GPOS_COMPACT_MODE_DEFAULT
+    if GPOS_COMPACT_MODE_ENV_KEY in os.environ:
+        import warnings
+
+        warnings.warn(
+            f"'{GPOS_COMPACT_MODE_ENV_KEY}' environment variable is deprecated. "
+            "Please set the 'fontTools.otlLib.optimize.gpos:COMPRESSION_LEVEL' option "
+            "in TTFont.cfg.",
+            DeprecationWarning,
+        )
+
+        env_level = os.environ[GPOS_COMPACT_MODE_ENV_KEY]
+    if len(env_level) == 1 and env_level in "0123456789":
+        return int(env_level)
+    raise ValueError(f"Bad {GPOS_COMPACT_MODE_ENV_KEY}={env_level}")
+
+
+def compact(font: TTFont, level: int) -> TTFont:
+    # Ideal plan:
+    #  1. Find lookups of Lookup Type 2: Pair Adjustment Positioning Subtable
+    #     https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#lookup-type-2-pair-adjustment-positioning-subtable
+    #  2. Extract glyph-glyph kerning and class-kerning from all present subtables
+    #  3. Regroup into different subtable arrangements
+    #  4. Put back into the lookup
+    #
+    # Actual implementation:
+    #  2. Only class kerning is optimized currently
+    #  3. If the input kerning is already in several subtables, the subtables
+    #     are not grouped together first; instead each subtable is treated
+    #     independently, so currently this step is:
+    #     Split existing subtables into more smaller subtables
+    gpos = font.get("GPOS")
+
+    # If the font does not contain a GPOS table, there is nothing to do.
+    if gpos is None:
+        return font
+
+    for lookup in gpos.table.LookupList.Lookup:
+        if lookup.LookupType == 2:
+            compact_lookup(font, level, lookup)
+        elif lookup.LookupType == 9 and lookup.SubTable[0].ExtensionLookupType == 2:
+            compact_ext_lookup(font, level, lookup)
+
+    return font
+
+
+def compact_lookup(font: TTFont, level: int, lookup: otTables.Lookup) -> None:
+    new_subtables = compact_pair_pos(font, level, lookup.SubTable)
+    lookup.SubTable = new_subtables
+    lookup.SubTableCount = len(new_subtables)
+
+
+def compact_ext_lookup(font: TTFont, level: int, lookup: otTables.Lookup) -> None:
+    new_subtables = compact_pair_pos(
+        font, level, [ext_subtable.ExtSubTable for ext_subtable in lookup.SubTable]
+    )
+    new_ext_subtables = []
+    for subtable in new_subtables:
+        ext_subtable = otTables.ExtensionPos()
+        ext_subtable.Format = 1
+        ext_subtable.ExtSubTable = subtable
+        new_ext_subtables.append(ext_subtable)
+    lookup.SubTable = new_ext_subtables
+    lookup.SubTableCount = len(new_ext_subtables)
+
+
+def compact_pair_pos(
+    font: TTFont, level: int, subtables: Sequence[otTables.PairPos]
+) -> Sequence[otTables.PairPos]:
+    new_subtables = []
+    for subtable in subtables:
+        if subtable.Format == 1:
+            # Not doing anything to Format 1 (yet?)
+            new_subtables.append(subtable)
+        elif subtable.Format == 2:
+            new_subtables.extend(compact_class_pairs(font, level, subtable))
+    return new_subtables
+
+
+def compact_class_pairs(
+    font: TTFont, level: int, subtable: otTables.PairPos
+) -> List[otTables.PairPos]:
+    from fontTools.otlLib.builder import buildPairPosClassesSubtable
+
+    subtables = []
+    classes1: DefaultDict[int, List[str]] = defaultdict(list)
+    for g in subtable.Coverage.glyphs:
+        classes1[subtable.ClassDef1.classDefs.get(g, 0)].append(g)
+    classes2: DefaultDict[int, List[str]] = defaultdict(list)
+    for g, i in subtable.ClassDef2.classDefs.items():
+        classes2[i].append(g)
+    all_pairs = {}
+    for i, class1 in enumerate(subtable.Class1Record):
+        for j, class2 in enumerate(class1.Class2Record):
+            if is_really_zero(class2):
+                continue
+            all_pairs[(tuple(sorted(classes1[i])), tuple(sorted(classes2[j])))] = (
+                getattr(class2, "Value1", None),
+                getattr(class2, "Value2", None),
+            )
+    grouped_pairs = cluster_pairs_by_class2_coverage_custom_cost(font, all_pairs, level)
+    for pairs in grouped_pairs:
+        subtables.append(buildPairPosClassesSubtable(pairs, font.getReverseGlyphMap()))
+    return subtables
+
+
+def is_really_zero(class2: otTables.Class2Record) -> bool:
+    v1 = getattr(class2, "Value1", None)
+    v2 = getattr(class2, "Value2", None)
+    return (v1 is None or v1.getEffectiveFormat() == 0) and (
+        v2 is None or v2.getEffectiveFormat() == 0
+    )
+
+
+Pairs = Dict[
+    Tuple[Tuple[str, ...], Tuple[str, ...]],
+    Tuple[otBase.ValueRecord, otBase.ValueRecord],
+]
+
+
+# Adapted from https://github.com/fonttools/fonttools/blob/f64f0b42f2d1163b2d85194e0979def539f5dca3/Lib/fontTools/ttLib/tables/otTables.py#L935-L958
+def _getClassRanges(glyphIDs: Iterable[int]):
+    glyphIDs = sorted(glyphIDs)
+    last = glyphIDs[0]
+    ranges = [[last]]
+    for glyphID in glyphIDs[1:]:
+        if glyphID != last + 1:
+            ranges[-1].append(last)
+            ranges.append([glyphID])
+        last = glyphID
+    ranges[-1].append(last)
+    return ranges, glyphIDs[0], glyphIDs[-1]
+
+
+# Adapted from https://github.com/fonttools/fonttools/blob/f64f0b42f2d1163b2d85194e0979def539f5dca3/Lib/fontTools/ttLib/tables/otTables.py#L960-L989
+def _classDef_bytes(
+    class_data: List[Tuple[List[Tuple[int, int]], int, int]],
+    class_ids: List[int],
+    coverage=False,
+):
+    if not class_ids:
+        return 0
+    first_ranges, min_glyph_id, max_glyph_id = class_data[class_ids[0]]
+    range_count = len(first_ranges)
+    for i in class_ids[1:]:
+        data = class_data[i]
+        range_count += len(data[0])
+        min_glyph_id = min(min_glyph_id, data[1])
+        max_glyph_id = max(max_glyph_id, data[2])
+    glyphCount = max_glyph_id - min_glyph_id + 1
+    # https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#class-definition-table-format-1
+    format1_bytes = 6 + glyphCount * 2
+    # https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#class-definition-table-format-2
+    format2_bytes = 4 + range_count * 6
+    return min(format1_bytes, format2_bytes)
+
+
+ClusteringContext = namedtuple(
+    "ClusteringContext",
+    [
+        "lines",
+        "all_class1",
+        "all_class1_data",
+        "all_class2_data",
+        "valueFormat1_bytes",
+        "valueFormat2_bytes",
+    ],
+)
+
+
+@dataclass
+class Cluster:
+    ctx: ClusteringContext
+    indices_bitmask: int
+
+    @cached_property
+    def indices(self):
+        return bit_indices(self.indices_bitmask)
+
+    @cached_property
+    def column_indices(self):
+        # Indices of columns that have a 1 in at least 1 line
+        #   => binary OR all the lines
+        bitmask = reduce(int.__or__, (self.ctx.lines[i] for i in self.indices))
+        return bit_indices(bitmask)
+
+    @property
+    def width(self):
+        # Add 1 because Class2=0 cannot be used but needs to be encoded.
+        return len(self.column_indices) + 1
+
+    @cached_property
+    def cost(self):
+        return (
+            # 2 bytes to store the offset to this subtable in the Lookup table above
+            2
+            # Contents of the subtable
+            # From: https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#pair-adjustment-positioning-format-2-class-pair-adjustment
+            # uint16	posFormat	Format identifier: format = 2
+            + 2
+            # Offset16	coverageOffset	Offset to Coverage table, from beginning of PairPos subtable.
+            + 2
+            + self.coverage_bytes
+            # uint16	valueFormat1	ValueRecord definition — for the first glyph of the pair (may be zero).
+            + 2
+            # uint16	valueFormat2	ValueRecord definition — for the second glyph of the pair (may be zero).
+            + 2
+            # Offset16	classDef1Offset	Offset to ClassDef table, from beginning of PairPos subtable — for the first glyph of the pair.
+            + 2
+            + self.classDef1_bytes
+            # Offset16	classDef2Offset	Offset to ClassDef table, from beginning of PairPos subtable — for the second glyph of the pair.
+            + 2
+            + self.classDef2_bytes
+            # uint16	class1Count	Number of classes in classDef1 table — includes Class 0.
+            + 2
+            # uint16	class2Count	Number of classes in classDef2 table — includes Class 0.
+            + 2
+            # Class1Record	class1Records[class1Count]	Array of Class1 records, ordered by classes in classDef1.
+            + (self.ctx.valueFormat1_bytes + self.ctx.valueFormat2_bytes)
+            * len(self.indices)
+            * self.width
+        )
+
+    @property
+    def coverage_bytes(self):
+        format1_bytes = (
+            # From https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#coverage-format-1
+            # uint16	coverageFormat	Format identifier — format = 1
+            # uint16	glyphCount	Number of glyphs in the glyph array
+            4
+            # uint16	glyphArray[glyphCount]	Array of glyph IDs — in numerical order
+            + sum(len(self.ctx.all_class1[i]) for i in self.indices) * 2
+        )
+        ranges = sorted(
+            chain.from_iterable(self.ctx.all_class1_data[i][0] for i in self.indices)
+        )
+        merged_range_count = 0
+        last = None
+        for start, end in ranges:
+            if last is not None and start != last + 1:
+                merged_range_count += 1
+            last = end
+        format2_bytes = (
+            # From https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#coverage-format-2
+            # uint16	coverageFormat	Format identifier — format = 2
+            # uint16	rangeCount	Number of RangeRecords
+            4
+            # RangeRecord	rangeRecords[rangeCount]	Array of glyph ranges — ordered by startGlyphID.
+            # uint16	startGlyphID	First glyph ID in the range
+            # uint16	endGlyphID	Last glyph ID in the range
+            # uint16	startCoverageIndex	Coverage Index of first glyph ID in range
+            + merged_range_count * 6
+        )
+        return min(format1_bytes, format2_bytes)
+
+    @property
+    def classDef1_bytes(self):
+        # We can skip encoding one of the Class1 definitions, and use
+        # Class1=0 to represent it instead, because Class1 is gated by the
+        # Coverage definition. Use Class1=0 for the highest byte savings.
+        # Going through all options takes too long, pick the biggest class
+        # = what happens in otlLib.builder.ClassDefBuilder.classes()
+        biggest_index = max(self.indices, key=lambda i: len(self.ctx.all_class1[i]))
+        return _classDef_bytes(
+            self.ctx.all_class1_data, [i for i in self.indices if i != biggest_index]
+        )
+
+    @property
+    def classDef2_bytes(self):
+        # All Class2 need to be encoded because we can't use Class2=0
+        return _classDef_bytes(self.ctx.all_class2_data, self.column_indices)
+
+
+def cluster_pairs_by_class2_coverage_custom_cost(
+    font: TTFont,
+    pairs: Pairs,
+    compression: int = 5,
+) -> List[Pairs]:
+    if not pairs:
+        # The subtable was actually empty?
+        return [pairs]
+
+    # Sorted for reproducibility/determinism
+    all_class1 = sorted(set(pair[0] for pair in pairs))
+    all_class2 = sorted(set(pair[1] for pair in pairs))
+
+    # Use Python's big ints for binary vectors representing each line
+    lines = [
+        sum(
+            1 << i if (class1, class2) in pairs else 0
+            for i, class2 in enumerate(all_class2)
+        )
+        for class1 in all_class1
+    ]
+
+    # Map glyph names to ids and work with ints throughout for ClassDef formats
+    name_to_id = font.getReverseGlyphMap()
+    # Each entry in the arrays below is (range_count, min_glyph_id, max_glyph_id)
+    all_class1_data = [
+        _getClassRanges(name_to_id[name] for name in cls) for cls in all_class1
+    ]
+    all_class2_data = [
+        _getClassRanges(name_to_id[name] for name in cls) for cls in all_class2
+    ]
+
+    format1 = 0
+    format2 = 0
+    for pair, value in pairs.items():
+        format1 |= value[0].getEffectiveFormat() if value[0] else 0
+        format2 |= value[1].getEffectiveFormat() if value[1] else 0
+    valueFormat1_bytes = bit_count(format1) * 2
+    valueFormat2_bytes = bit_count(format2) * 2
+
+    ctx = ClusteringContext(
+        lines,
+        all_class1,
+        all_class1_data,
+        all_class2_data,
+        valueFormat1_bytes,
+        valueFormat2_bytes,
+    )
+
+    cluster_cache: Dict[int, Cluster] = {}
+
+    def make_cluster(indices: int) -> Cluster:
+        cluster = cluster_cache.get(indices, None)
+        if cluster is not None:
+            return cluster
+        cluster = Cluster(ctx, indices)
+        cluster_cache[indices] = cluster
+        return cluster
+
+    def merge(cluster: Cluster, other: Cluster) -> Cluster:
+        return make_cluster(cluster.indices_bitmask | other.indices_bitmask)
+
+    # Agglomerative clustering by hand, checking the cost gain of the new
+    # cluster against the previously separate clusters
+    # Start with 1 cluster per line
+    # cluster = set of lines = new subtable
+    clusters = [make_cluster(1 << i) for i in range(len(lines))]
+
+    # Cost of 1 cluster with everything
+    # `(1 << len) - 1` gives a bitmask full of 1's of length `len`
+    cost_before_splitting = make_cluster((1 << len(lines)) - 1).cost
+    log.debug(f"        len(clusters) = {len(clusters)}")
+
+    while len(clusters) > 1:
+        lowest_cost_change = None
+        best_cluster_index = None
+        best_other_index = None
+        best_merged = None
+        for i, cluster in enumerate(clusters):
+            for j, other in enumerate(clusters[i + 1 :]):
+                merged = merge(cluster, other)
+                cost_change = merged.cost - cluster.cost - other.cost
+                if lowest_cost_change is None or cost_change < lowest_cost_change:
+                    lowest_cost_change = cost_change
+                    best_cluster_index = i
+                    best_other_index = i + 1 + j
+                    best_merged = merged
+        assert lowest_cost_change is not None
+        assert best_cluster_index is not None
+        assert best_other_index is not None
+        assert best_merged is not None
+
+        # If the best merge we found is still taking down the file size, then
+        # there's no question: we must do it, because it's beneficial in both
+        # ways (lower file size and lower number of subtables).  However, if the
+        # best merge we found is not reducing file size anymore, then we need to
+        # look at the other stop criteria = the compression factor.
+        if lowest_cost_change > 0:
+            # Stop critera: check whether we should keep merging.
+            # Compute size reduction brought by splitting
+            cost_after_splitting = sum(c.cost for c in clusters)
+            # size_reduction so that after = before * (1 - size_reduction)
+            # E.g. before = 1000, after = 800, 1 - 800/1000 = 0.2
+            size_reduction = 1 - cost_after_splitting / cost_before_splitting
+
+            # Force more merging by taking into account the compression number.
+            # Target behaviour: compression number = 1 to 9, default 5 like gzip
+            #   - 1 = accept to add 1 subtable to reduce size by 50%
+            #   - 5 = accept to add 5 subtables to reduce size by 50%
+            # See https://github.com/harfbuzz/packtab/blob/master/Lib/packTab/__init__.py#L690-L691
+            # Given the size reduction we have achieved so far, compute how many
+            # new subtables are acceptable.
+            max_new_subtables = -log2(1 - size_reduction) * compression
+            log.debug(
+                f"            len(clusters) = {len(clusters):3d}    size_reduction={size_reduction:5.2f}    max_new_subtables={max_new_subtables}",
+            )
+            if compression == 9:
+                # Override level 9 to mean: create any number of subtables
+                max_new_subtables = len(clusters)
+
+            # If we have managed to take the number of new subtables below the
+            # threshold, then we can stop.
+            if len(clusters) <= max_new_subtables + 1:
+                break
+
+        # No reason to stop yet, do the merge and move on to the next.
+        del clusters[best_other_index]
+        clusters[best_cluster_index] = best_merged
+
+    # All clusters are final; turn bitmasks back into the "Pairs" format
+    pairs_by_class1: Dict[Tuple[str, ...], Pairs] = defaultdict(dict)
+    for pair, values in pairs.items():
+        pairs_by_class1[pair[0]][pair] = values
+    pairs_groups: List[Pairs] = []
+    for cluster in clusters:
+        pairs_group: Pairs = dict()
+        for i in cluster.indices:
+            class1 = all_class1[i]
+            pairs_group.update(pairs_by_class1[class1])
+        pairs_groups.append(pairs_group)
+    return pairs_groups

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/pens/__init__.py

@@ -0,0 +1 @@
+"""Empty __init__.py file to signal Python this directory is a package."""

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/pens/areaPen.py

@@ -0,0 +1,52 @@
+"""Calculate the area of a glyph."""
+
+from fontTools.pens.basePen import BasePen
+
+
+__all__ = ["AreaPen"]
+
+
+class AreaPen(BasePen):
+    def __init__(self, glyphset=None):
+        BasePen.__init__(self, glyphset)
+        self.value = 0
+
+    def _moveTo(self, p0):
+        self._p0 = self._startPoint = p0
+
+    def _lineTo(self, p1):
+        x0, y0 = self._p0
+        x1, y1 = p1
+        self.value -= (x1 - x0) * (y1 + y0) * 0.5
+        self._p0 = p1
+
+    def _qCurveToOne(self, p1, p2):
+        # https://github.com/Pomax/bezierinfo/issues/44
+        p0 = self._p0
+        x0, y0 = p0[0], p0[1]
+        x1, y1 = p1[0] - x0, p1[1] - y0
+        x2, y2 = p2[0] - x0, p2[1] - y0
+        self.value -= (x2 * y1 - x1 * y2) / 3
+        self._lineTo(p2)
+        self._p0 = p2
+
+    def _curveToOne(self, p1, p2, p3):
+        # https://github.com/Pomax/bezierinfo/issues/44
+        p0 = self._p0
+        x0, y0 = p0[0], p0[1]
+        x1, y1 = p1[0] - x0, p1[1] - y0
+        x2, y2 = p2[0] - x0, p2[1] - y0
+        x3, y3 = p3[0] - x0, p3[1] - y0
+        self.value -= (x1 * (-y2 - y3) + x2 * (y1 - 2 * y3) + x3 * (y1 + 2 * y2)) * 0.15
+        self._lineTo(p3)
+        self._p0 = p3
+
+    def _closePath(self):
+        self._lineTo(self._startPoint)
+        del self._p0, self._startPoint
+
+    def _endPath(self):
+        if self._p0 != self._startPoint:
+            # Area is not defined for open contours.
+            raise NotImplementedError
+        del self._p0, self._startPoint

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/pens/cairoPen.py

@@ -0,0 +1,26 @@
+"""Pen to draw to a Cairo graphics library context."""
+
+from fontTools.pens.basePen import BasePen
+
+
+__all__ = ["CairoPen"]
+
+
+class CairoPen(BasePen):
+    """Pen to draw to a Cairo graphics library context."""
+
+    def __init__(self, glyphSet, context):
+        BasePen.__init__(self, glyphSet)
+        self.context = context
+
+    def _moveTo(self, p):
+        self.context.move_to(*p)
+
+    def _lineTo(self, p):
+        self.context.line_to(*p)
+
+    def _curveToOne(self, p1, p2, p3):
+        self.context.curve_to(*p1, *p2, *p3)
+
+    def _closePath(self):
+        self.context.close_path()

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/pens/cocoaPen.py

@@ -0,0 +1,26 @@
+from fontTools.pens.basePen import BasePen
+
+
+__all__ = ["CocoaPen"]
+
+
+class CocoaPen(BasePen):
+    def __init__(self, glyphSet, path=None):
+        BasePen.__init__(self, glyphSet)
+        if path is None:
+            from AppKit import NSBezierPath
+
+            path = NSBezierPath.bezierPath()
+        self.path = path
+
+    def _moveTo(self, p):
+        self.path.moveToPoint_(p)
+
+    def _lineTo(self, p):
+        self.path.lineToPoint_(p)
+
+    def _curveToOne(self, p1, p2, p3):
+        self.path.curveToPoint_controlPoint1_controlPoint2_(p3, p1, p2)
+
+    def _closePath(self):
+        self.path.closePath()

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/pens/cu2quPen.py

@@ -0,0 +1,325 @@
+# Copyright 2016 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import operator
+from fontTools.cu2qu import curve_to_quadratic, curves_to_quadratic
+from fontTools.pens.basePen import decomposeSuperBezierSegment
+from fontTools.pens.filterPen import FilterPen
+from fontTools.pens.reverseContourPen import ReverseContourPen
+from fontTools.pens.pointPen import BasePointToSegmentPen
+from fontTools.pens.pointPen import ReverseContourPointPen
+
+
+class Cu2QuPen(FilterPen):
+    """A filter pen to convert cubic bezier curves to quadratic b-splines
+    using the FontTools SegmentPen protocol.
+
+    Args:
+
+        other_pen: another SegmentPen used to draw the transformed outline.
+        max_err: maximum approximation error in font units. For optimal results,
+            if you know the UPEM of the font, we recommend setting this to a
+            value equal, or close to UPEM / 1000.
+        reverse_direction: flip the contours' direction but keep starting point.
+        stats: a dictionary counting the point numbers of quadratic segments.
+        all_quadratic: if True (default), only quadratic b-splines are generated.
+            if False, quadratic curves or cubic curves are generated depending
+            on which one is more economical.
+    """
+
+    def __init__(
+        self,
+        other_pen,
+        max_err,
+        reverse_direction=False,
+        stats=None,
+        all_quadratic=True,
+    ):
+        if reverse_direction:
+            other_pen = ReverseContourPen(other_pen)
+        super().__init__(other_pen)
+        self.max_err = max_err
+        self.stats = stats
+        self.all_quadratic = all_quadratic
+
+    def _convert_curve(self, pt1, pt2, pt3):
+        curve = (self.current_pt, pt1, pt2, pt3)
+        result = curve_to_quadratic(curve, self.max_err, self.all_quadratic)
+        if self.stats is not None:
+            n = str(len(result) - 2)
+            self.stats[n] = self.stats.get(n, 0) + 1
+        if self.all_quadratic:
+            self.qCurveTo(*result[1:])
+        else:
+            if len(result) == 3:
+                self.qCurveTo(*result[1:])
+            else:
+                assert len(result) == 4
+                super().curveTo(*result[1:])
+
+    def curveTo(self, *points):
+        n = len(points)
+        if n == 3:
+            # this is the most common case, so we special-case it
+            self._convert_curve(*points)
+        elif n > 3:
+            for segment in decomposeSuperBezierSegment(points):
+                self._convert_curve(*segment)
+        else:
+            self.qCurveTo(*points)
+
+
+class Cu2QuPointPen(BasePointToSegmentPen):
+    """A filter pen to convert cubic bezier curves to quadratic b-splines
+    using the FontTools PointPen protocol.
+
+    Args:
+        other_point_pen: another PointPen used to draw the transformed outline.
+        max_err: maximum approximation error in font units. For optimal results,
+            if you know the UPEM of the font, we recommend setting this to a
+            value equal, or close to UPEM / 1000.
+        reverse_direction: reverse the winding direction of all contours.
+        stats: a dictionary counting the point numbers of quadratic segments.
+        all_quadratic: if True (default), only quadratic b-splines are generated.
+            if False, quadratic curves or cubic curves are generated depending
+            on which one is more economical.
+    """
+
+    __points_required = {
+        "move": (1, operator.eq),
+        "line": (1, operator.eq),
+        "qcurve": (2, operator.ge),
+        "curve": (3, operator.eq),
+    }
+
+    def __init__(
+        self,
+        other_point_pen,
+        max_err,
+        reverse_direction=False,
+        stats=None,
+        all_quadratic=True,
+    ):
+        BasePointToSegmentPen.__init__(self)
+        if reverse_direction:
+            self.pen = ReverseContourPointPen(other_point_pen)
+        else:
+            self.pen = other_point_pen
+        self.max_err = max_err
+        self.stats = stats
+        self.all_quadratic = all_quadratic
+
+    def _flushContour(self, segments):
+        assert len(segments) >= 1
+        closed = segments[0][0] != "move"
+        new_segments = []
+        prev_points = segments[-1][1]
+        prev_on_curve = prev_points[-1][0]
+        for segment_type, points in segments:
+            if segment_type == "curve":
+                for sub_points in self._split_super_bezier_segments(points):
+                    on_curve, smooth, name, kwargs = sub_points[-1]
+                    bcp1, bcp2 = sub_points[0][0], sub_points[1][0]
+                    cubic = [prev_on_curve, bcp1, bcp2, on_curve]
+                    quad = curve_to_quadratic(cubic, self.max_err, self.all_quadratic)
+                    if self.stats is not None:
+                        n = str(len(quad) - 2)
+                        self.stats[n] = self.stats.get(n, 0) + 1
+                    new_points = [(pt, False, None, {}) for pt in quad[1:-1]]
+                    new_points.append((on_curve, smooth, name, kwargs))
+                    if self.all_quadratic or len(new_points) == 2:
+                        new_segments.append(["qcurve", new_points])
+                    else:
+                        new_segments.append(["curve", new_points])
+                    prev_on_curve = sub_points[-1][0]
+            else:
+                new_segments.append([segment_type, points])
+                prev_on_curve = points[-1][0]
+        if closed:
+            # the BasePointToSegmentPen.endPath method that calls _flushContour
+            # rotates the point list of closed contours so that they end with
+            # the first on-curve point. We restore the original starting point.
+            new_segments = new_segments[-1:] + new_segments[:-1]
+        self._drawPoints(new_segments)
+
+    def _split_super_bezier_segments(self, points):
+        sub_segments = []
+        # n is the number of control points
+        n = len(points) - 1
+        if n == 2:
+            # a simple bezier curve segment
+            sub_segments.append(points)
+        elif n > 2:
+            # a "super" bezier; decompose it
+            on_curve, smooth, name, kwargs = points[-1]
+            num_sub_segments = n - 1
+            for i, sub_points in enumerate(
+                decomposeSuperBezierSegment([pt for pt, _, _, _ in points])
+            ):
+                new_segment = []
+                for point in sub_points[:-1]:
+                    new_segment.append((point, False, None, {}))
+                if i == (num_sub_segments - 1):
+                    # the last on-curve keeps its original attributes
+                    new_segment.append((on_curve, smooth, name, kwargs))
+                else:
+                    # on-curves of sub-segments are always "smooth"
+                    new_segment.append((sub_points[-1], True, None, {}))
+                sub_segments.append(new_segment)
+        else:
+            raise AssertionError("expected 2 control points, found: %d" % n)
+        return sub_segments
+
+    def _drawPoints(self, segments):
+        pen = self.pen
+        pen.beginPath()
+        last_offcurves = []
+        points_required = self.__points_required
+        for i, (segment_type, points) in enumerate(segments):
+            if segment_type in points_required:
+                n, op = points_required[segment_type]
+                assert op(len(points), n), (
+                    f"illegal {segment_type!r} segment point count: "
+                    f"expected {n}, got {len(points)}"
+                )
+                offcurves = points[:-1]
+                if i == 0:
+                    # any off-curve points preceding the first on-curve
+                    # will be appended at the end of the contour
+                    last_offcurves = offcurves
+                else:
+                    for pt, smooth, name, kwargs in offcurves:
+                        pen.addPoint(pt, None, smooth, name, **kwargs)
+                pt, smooth, name, kwargs = points[-1]
+                if pt is None:
+                    assert segment_type == "qcurve"
+                    # special quadratic contour with no on-curve points:
+                    # we need to skip the "None" point. See also the Pen
+                    # protocol's qCurveTo() method and fontTools.pens.basePen
+                    pass
+                else:
+                    pen.addPoint(pt, segment_type, smooth, name, **kwargs)
+            else:
+                raise AssertionError("unexpected segment type: %r" % segment_type)
+        for pt, smooth, name, kwargs in last_offcurves:
+            pen.addPoint(pt, None, smooth, name, **kwargs)
+        pen.endPath()
+
+    def addComponent(self, baseGlyphName, transformation):
+        assert self.currentPath is None
+        self.pen.addComponent(baseGlyphName, transformation)
+
+
+class Cu2QuMultiPen:
+    """A filter multi-pen to convert cubic bezier curves to quadratic b-splines
+    in a interpolation-compatible manner, using the FontTools SegmentPen protocol.
+
+    Args:
+
+        other_pens: list of SegmentPens used to draw the transformed outlines.
+        max_err: maximum approximation error in font units. For optimal results,
+            if you know the UPEM of the font, we recommend setting this to a
+            value equal, or close to UPEM / 1000.
+        reverse_direction: flip the contours' direction but keep starting point.
+
+    This pen does not follow the normal SegmentPen protocol. Instead, its
+    moveTo/lineTo/qCurveTo/curveTo methods take a list of tuples that are
+    arguments that would normally be passed to a SegmentPen, one item for
+    each of the pens in other_pens.
+    """
+
+    # TODO Simplify like 3e8ebcdce592fe8a59ca4c3a294cc9724351e1ce
+    # Remove start_pts and _add_moveTO
+
+    def __init__(self, other_pens, max_err, reverse_direction=False):
+        if reverse_direction:
+            other_pens = [
+                ReverseContourPen(pen, outputImpliedClosingLine=True)
+                for pen in other_pens
+            ]
+        self.pens = other_pens
+        self.max_err = max_err
+        self.start_pts = None
+        self.current_pts = None
+
+    def _check_contour_is_open(self):
+        if self.current_pts is None:
+            raise AssertionError("moveTo is required")
+
+    def _check_contour_is_closed(self):
+        if self.current_pts is not None:
+            raise AssertionError("closePath or endPath is required")
+
+    def _add_moveTo(self):
+        if self.start_pts is not None:
+            for pt, pen in zip(self.start_pts, self.pens):
+                pen.moveTo(*pt)
+            self.start_pts = None
+
+    def moveTo(self, pts):
+        self._check_contour_is_closed()
+        self.start_pts = self.current_pts = pts
+        self._add_moveTo()
+
+    def lineTo(self, pts):
+        self._check_contour_is_open()
+        self._add_moveTo()
+        for pt, pen in zip(pts, self.pens):
+            pen.lineTo(*pt)
+        self.current_pts = pts
+
+    def qCurveTo(self, pointsList):
+        self._check_contour_is_open()
+        if len(pointsList[0]) == 1:
+            self.lineTo([(points[0],) for points in pointsList])
+            return
+        self._add_moveTo()
+        current_pts = []
+        for points, pen in zip(pointsList, self.pens):
+            pen.qCurveTo(*points)
+            current_pts.append((points[-1],))
+        self.current_pts = current_pts
+
+    def _curves_to_quadratic(self, pointsList):
+        curves = []
+        for current_pt, points in zip(self.current_pts, pointsList):
+            curves.append(current_pt + points)
+        quadratics = curves_to_quadratic(curves, [self.max_err] * len(curves))
+        pointsList = []
+        for quadratic in quadratics:
+            pointsList.append(quadratic[1:])
+        self.qCurveTo(pointsList)
+
+    def curveTo(self, pointsList):
+        self._check_contour_is_open()
+        self._curves_to_quadratic(pointsList)
+
+    def closePath(self):
+        self._check_contour_is_open()
+        if self.start_pts is None:
+            for pen in self.pens:
+                pen.closePath()
+        self.current_pts = self.start_pts = None
+
+    def endPath(self):
+        self._check_contour_is_open()
+        if self.start_pts is None:
+            for pen in self.pens:
+                pen.endPath()
+        self.current_pts = self.start_pts = None
+
+    def addComponent(self, glyphName, transformations):
+        self._check_contour_is_closed()
+        for trans, pen in zip(transformations, self.pens):
+            pen.addComponent(glyphName, trans)

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/pens/freetypePen.py

@@ -0,0 +1,462 @@
+# -*- coding: utf-8 -*-
+
+"""Pen to rasterize paths with FreeType."""
+
+__all__ = ["FreeTypePen"]
+
+import os
+import ctypes
+import platform
+import subprocess
+import collections
+import math
+
+import freetype
+from freetype.raw import FT_Outline_Get_Bitmap, FT_Outline_Get_BBox, FT_Outline_Get_CBox
+from freetype.ft_types import FT_Pos
+from freetype.ft_structs import FT_Vector, FT_BBox, FT_Bitmap, FT_Outline
+from freetype.ft_enums import (
+    FT_OUTLINE_NONE,
+    FT_OUTLINE_EVEN_ODD_FILL,
+    FT_PIXEL_MODE_GRAY,
+    FT_CURVE_TAG_ON,
+    FT_CURVE_TAG_CONIC,
+    FT_CURVE_TAG_CUBIC,
+)
+from freetype.ft_errors import FT_Exception
+
+from fontTools.pens.basePen import BasePen, PenError
+from fontTools.misc.roundTools import otRound
+from fontTools.misc.transform import Transform
+
+Contour = collections.namedtuple("Contour", ("points", "tags"))
+
+
+class FreeTypePen(BasePen):
+    """Pen to rasterize paths with FreeType. Requires `freetype-py` module.
+
+    Constructs ``FT_Outline`` from the paths, and renders it within a bitmap
+    buffer.
+
+    For ``array()`` and ``show()``, `numpy` and `matplotlib` must be installed.
+    For ``image()``, `Pillow` is required. Each module is lazily loaded when the
+    corresponding method is called.
+
+    Args:
+        glyphSet: a dictionary of drawable glyph objects keyed by name
+            used to resolve component references in composite glyphs.
+
+    Examples:
+        If `numpy` and `matplotlib` is available, the following code will
+        show the glyph image of `fi` in a new window::
+
+            from fontTools.ttLib import TTFont
+            from fontTools.pens.freetypePen import FreeTypePen
+            from fontTools.misc.transform import Offset
+            pen = FreeTypePen(None)
+            font = TTFont('SourceSansPro-Regular.otf')
+            glyph = font.getGlyphSet()['fi']
+            glyph.draw(pen)
+            width, ascender, descender = glyph.width, font['OS/2'].usWinAscent, -font['OS/2'].usWinDescent
+            height = ascender - descender
+            pen.show(width=width, height=height, transform=Offset(0, -descender))
+
+        Combining with `uharfbuzz`, you can typeset a chunk of glyphs in a pen::
+
+            import uharfbuzz as hb
+            from fontTools.pens.freetypePen import FreeTypePen
+            from fontTools.pens.transformPen import TransformPen
+            from fontTools.misc.transform import Offset
+
+            en1, en2, ar, ja = 'Typesetting', 'Jeff', 'صف الحروف', 'たいぷせっと'
+            for text, font_path, direction, typo_ascender, typo_descender, vhea_ascender, vhea_descender, contain, features in (
+                (en1, 'NotoSans-Regular.ttf',       'ltr', 2189, -600, None, None, False, {"kern": True, "liga": True}),
+                (en2, 'NotoSans-Regular.ttf',       'ltr', 2189, -600, None, None, True,  {"kern": True, "liga": True}),
+                (ar,  'NotoSansArabic-Regular.ttf', 'rtl', 1374, -738, None, None, False, {"kern": True, "liga": True}),
+                (ja,  'NotoSansJP-Regular.otf',     'ltr', 880,  -120, 500,  -500, False, {"palt": True, "kern": True}),
+                (ja,  'NotoSansJP-Regular.otf',     'ttb', 880,  -120, 500,  -500, False, {"vert": True, "vpal": True, "vkrn": True})
+            ):
+                blob = hb.Blob.from_file_path(font_path)
+                face = hb.Face(blob)
+                font = hb.Font(face)
+                buf = hb.Buffer()
+                buf.direction = direction
+                buf.add_str(text)
+                buf.guess_segment_properties()
+                hb.shape(font, buf, features)
+
+                x, y = 0, 0
+                pen = FreeTypePen(None)
+                for info, pos in zip(buf.glyph_infos, buf.glyph_positions):
+                    gid = info.codepoint
+                    transformed = TransformPen(pen, Offset(x + pos.x_offset, y + pos.y_offset))
+                    font.draw_glyph_with_pen(gid, transformed)
+                    x += pos.x_advance
+                    y += pos.y_advance
+
+                offset, width, height = None, None, None
+                if direction in ('ltr', 'rtl'):
+                    offset = (0, -typo_descender)
+                    width  = x
+                    height = typo_ascender - typo_descender
+                else:
+                    offset = (-vhea_descender, -y)
+                    width  = vhea_ascender - vhea_descender
+                    height = -y
+                pen.show(width=width, height=height, transform=Offset(*offset), contain=contain)
+
+        For Jupyter Notebook, the rendered image will be displayed in a cell if
+        you replace ``show()`` with ``image()`` in the examples.
+    """
+
+    def __init__(self, glyphSet):
+        BasePen.__init__(self, glyphSet)
+        self.contours = []
+
+    def outline(self, transform=None, evenOdd=False):
+        """Converts the current contours to ``FT_Outline``.
+
+        Args:
+            transform: An optional 6-tuple containing an affine transformation,
+                or a ``Transform`` object from the ``fontTools.misc.transform``
+                module.
+            evenOdd: Pass ``True`` for even-odd fill instead of non-zero.
+        """
+        transform = transform or Transform()
+        if not hasattr(transform, "transformPoint"):
+            transform = Transform(*transform)
+        n_contours = len(self.contours)
+        n_points = sum((len(contour.points) for contour in self.contours))
+        points = []
+        for contour in self.contours:
+            for point in contour.points:
+                point = transform.transformPoint(point)
+                points.append(
+                    FT_Vector(
+                        FT_Pos(otRound(point[0] * 64)), FT_Pos(otRound(point[1] * 64))
+                    )
+                )
+        tags = []
+        for contour in self.contours:
+            for tag in contour.tags:
+                tags.append(tag)
+        contours = []
+        contours_sum = 0
+        for contour in self.contours:
+            contours_sum += len(contour.points)
+            contours.append(contours_sum - 1)
+        flags = FT_OUTLINE_EVEN_ODD_FILL if evenOdd else FT_OUTLINE_NONE
+        return FT_Outline(
+            (ctypes.c_short)(n_contours),
+            (ctypes.c_short)(n_points),
+            (FT_Vector * n_points)(*points),
+            (ctypes.c_ubyte * n_points)(*tags),
+            (ctypes.c_short * n_contours)(*contours),
+            (ctypes.c_int)(flags),
+        )
+
+    def buffer(
+        self, width=None, height=None, transform=None, contain=False, evenOdd=False
+    ):
+        """Renders the current contours within a bitmap buffer.
+
+        Args:
+            width: Image width of the bitmap in pixels. If omitted, it
+                automatically fits to the bounding box of the contours.
+            height: Image height of the bitmap in pixels. If omitted, it
+                automatically fits to the bounding box of the contours.
+            transform: An optional 6-tuple containing an affine transformation,
+                or a ``Transform`` object from the ``fontTools.misc.transform``
+                module. The bitmap size is not affected by this matrix.
+            contain: If ``True``, the image size will be automatically expanded
+                so that it fits to the bounding box of the paths. Useful for
+                rendering glyphs with negative sidebearings without clipping.
+            evenOdd: Pass ``True`` for even-odd fill instead of non-zero.
+
+        Returns:
+            A tuple of ``(buffer, size)``, where ``buffer`` is a ``bytes``
+            object of the resulted bitmap and ``size`` is a 2-tuple of its
+            dimension.
+
+        Notes:
+            The image size should always be given explicitly if you need to get
+            a proper glyph image. When ``width`` and ``height`` are omitted, it
+            forcifully fits to the bounding box and the side bearings get
+            cropped. If you pass ``0`` to both ``width`` and ``height`` and set
+            ``contain`` to ``True``, it expands to the bounding box while
+            maintaining the origin of the contours, meaning that LSB will be
+            maintained but RSB won’t. The difference between the two becomes
+            more obvious when rotate or skew transformation is applied.
+
+        Example:
+            .. code-block:: pycon
+
+                >>>
+                >> pen = FreeTypePen(None)
+                >> glyph.draw(pen)
+                >> buf, size = pen.buffer(width=500, height=1000)
+                >> type(buf), len(buf), size
+                (<class 'bytes'>, 500000, (500, 1000))
+        """
+        transform = transform or Transform()
+        if not hasattr(transform, "transformPoint"):
+            transform = Transform(*transform)
+        contain_x, contain_y = contain or width is None, contain or height is None
+        if contain_x or contain_y:
+            dx, dy = transform.dx, transform.dy
+            bbox = self.bbox
+            p1, p2, p3, p4 = (
+                transform.transformPoint((bbox[0], bbox[1])),
+                transform.transformPoint((bbox[2], bbox[1])),
+                transform.transformPoint((bbox[0], bbox[3])),
+                transform.transformPoint((bbox[2], bbox[3])),
+            )
+            px, py = (p1[0], p2[0], p3[0], p4[0]), (p1[1], p2[1], p3[1], p4[1])
+            if contain_x:
+                if width is None:
+                    dx = dx - min(*px)
+                    width = max(*px) - min(*px)
+                else:
+                    dx = dx - min(min(*px), 0.0)
+                    width = max(width, max(*px) - min(min(*px), 0.0))
+            if contain_y:
+                if height is None:
+                    dy = dy - min(*py)
+                    height = max(*py) - min(*py)
+                else:
+                    dy = dy - min(min(*py), 0.0)
+                    height = max(height, max(*py) - min(min(*py), 0.0))
+            transform = Transform(*transform[:4], dx, dy)
+        width, height = math.ceil(width), math.ceil(height)
+        buf = ctypes.create_string_buffer(width * height)
+        bitmap = FT_Bitmap(
+            (ctypes.c_int)(height),
+            (ctypes.c_int)(width),
+            (ctypes.c_int)(width),
+            (ctypes.POINTER(ctypes.c_ubyte))(buf),
+            (ctypes.c_short)(256),
+            (ctypes.c_ubyte)(FT_PIXEL_MODE_GRAY),
+            (ctypes.c_char)(0),
+            (ctypes.c_void_p)(None),
+        )
+        outline = self.outline(transform=transform, evenOdd=evenOdd)
+        err = FT_Outline_Get_Bitmap(
+            freetype.get_handle(), ctypes.byref(outline), ctypes.byref(bitmap)
+        )
+        if err != 0:
+            raise FT_Exception(err)
+        return buf.raw, (width, height)
+
+    def array(
+        self, width=None, height=None, transform=None, contain=False, evenOdd=False
+    ):
+        """Returns the rendered contours as a numpy array. Requires `numpy`.
+
+        Args:
+            width: Image width of the bitmap in pixels. If omitted, it
+                automatically fits to the bounding box of the contours.
+            height: Image height of the bitmap in pixels. If omitted, it
+                automatically fits to the bounding box of the contours.
+            transform: An optional 6-tuple containing an affine transformation,
+                or a ``Transform`` object from the ``fontTools.misc.transform``
+                module. The bitmap size is not affected by this matrix.
+            contain: If ``True``, the image size will be automatically expanded
+                so that it fits to the bounding box of the paths. Useful for
+                rendering glyphs with negative sidebearings without clipping.
+            evenOdd: Pass ``True`` for even-odd fill instead of non-zero.
+
+        Returns:
+            A ``numpy.ndarray`` object with a shape of ``(height, width)``.
+            Each element takes a value in the range of ``[0.0, 1.0]``.
+
+        Notes:
+            The image size should always be given explicitly if you need to get
+            a proper glyph image. When ``width`` and ``height`` are omitted, it
+            forcifully fits to the bounding box and the side bearings get
+            cropped. If you pass ``0`` to both ``width`` and ``height`` and set
+            ``contain`` to ``True``, it expands to the bounding box while
+            maintaining the origin of the contours, meaning that LSB will be
+            maintained but RSB won’t. The difference between the two becomes
+            more obvious when rotate or skew transformation is applied.
+
+        Example:
+            .. code-block:: pycon
+
+                >>>
+                >> pen = FreeTypePen(None)
+                >> glyph.draw(pen)
+                >> arr = pen.array(width=500, height=1000)
+                >> type(a), a.shape
+                (<class 'numpy.ndarray'>, (1000, 500))
+        """
+
+        import numpy as np
+
+        buf, size = self.buffer(
+            width=width,
+            height=height,
+            transform=transform,
+            contain=contain,
+            evenOdd=evenOdd,
+        )
+        return np.frombuffer(buf, "B").reshape((size[1], size[0])) / 255.0
+
+    def show(
+        self, width=None, height=None, transform=None, contain=False, evenOdd=False
+    ):
+        """Plots the rendered contours with `pyplot`. Requires `numpy` and
+        `matplotlib`.
+
+        Args:
+            width: Image width of the bitmap in pixels. If omitted, it
+                automatically fits to the bounding box of the contours.
+            height: Image height of the bitmap in pixels. If omitted, it
+                automatically fits to the bounding box of the contours.
+            transform: An optional 6-tuple containing an affine transformation,
+                or a ``Transform`` object from the ``fontTools.misc.transform``
+                module. The bitmap size is not affected by this matrix.
+            contain: If ``True``, the image size will be automatically expanded
+                so that it fits to the bounding box of the paths. Useful for
+                rendering glyphs with negative sidebearings without clipping.
+            evenOdd: Pass ``True`` for even-odd fill instead of non-zero.
+
+        Notes:
+            The image size should always be given explicitly if you need to get
+            a proper glyph image. When ``width`` and ``height`` are omitted, it
+            forcifully fits to the bounding box and the side bearings get
+            cropped. If you pass ``0`` to both ``width`` and ``height`` and set
+            ``contain`` to ``True``, it expands to the bounding box while
+            maintaining the origin of the contours, meaning that LSB will be
+            maintained but RSB won’t. The difference between the two becomes
+            more obvious when rotate or skew transformation is applied.
+
+        Example:
+            .. code-block:: pycon
+
+                >>>
+                >> pen = FreeTypePen(None)
+                >> glyph.draw(pen)
+                >> pen.show(width=500, height=1000)
+        """
+        from matplotlib import pyplot as plt
+
+        a = self.array(
+            width=width,
+            height=height,
+            transform=transform,
+            contain=contain,
+            evenOdd=evenOdd,
+        )
+        plt.imshow(a, cmap="gray_r", vmin=0, vmax=1)
+        plt.show()
+
+    def image(
+        self, width=None, height=None, transform=None, contain=False, evenOdd=False
+    ):
+        """Returns the rendered contours as a PIL image. Requires `Pillow`.
+        Can be used to display a glyph image in Jupyter Notebook.
+
+        Args:
+            width: Image width of the bitmap in pixels. If omitted, it
+                automatically fits to the bounding box of the contours.
+            height: Image height of the bitmap in pixels. If omitted, it
+                automatically fits to the bounding box of the contours.
+            transform: An optional 6-tuple containing an affine transformation,
+                or a ``Transform`` object from the ``fontTools.misc.transform``
+                module. The bitmap size is not affected by this matrix.
+            contain: If ``True``, the image size will be automatically expanded
+                so that it fits to the bounding box of the paths. Useful for
+                rendering glyphs with negative sidebearings without clipping.
+            evenOdd: Pass ``True`` for even-odd fill instead of non-zero.
+
+        Returns:
+            A ``PIL.image`` object. The image is filled in black with alpha
+            channel obtained from the rendered bitmap.
+
+        Notes:
+            The image size should always be given explicitly if you need to get
+            a proper glyph image. When ``width`` and ``height`` are omitted, it
+            forcifully fits to the bounding box and the side bearings get
+            cropped. If you pass ``0`` to both ``width`` and ``height`` and set
+            ``contain`` to ``True``, it expands to the bounding box while
+            maintaining the origin of the contours, meaning that LSB will be
+            maintained but RSB won’t. The difference between the two becomes
+            more obvious when rotate or skew transformation is applied.
+
+        Example:
+            .. code-block:: pycon
+
+                >>>
+                >> pen = FreeTypePen(None)
+                >> glyph.draw(pen)
+                >> img = pen.image(width=500, height=1000)
+                >> type(img), img.size
+                (<class 'PIL.Image.Image'>, (500, 1000))
+        """
+        from PIL import Image
+
+        buf, size = self.buffer(
+            width=width,
+            height=height,
+            transform=transform,
+            contain=contain,
+            evenOdd=evenOdd,
+        )
+        img = Image.new("L", size, 0)
+        img.putalpha(Image.frombuffer("L", size, buf))
+        return img
+
+    @property
+    def bbox(self):
+        """Computes the exact bounding box of an outline.
+
+        Returns:
+            A tuple of ``(xMin, yMin, xMax, yMax)``.
+        """
+        bbox = FT_BBox()
+        outline = self.outline()
+        FT_Outline_Get_BBox(ctypes.byref(outline), ctypes.byref(bbox))
+        return (bbox.xMin / 64.0, bbox.yMin / 64.0, bbox.xMax / 64.0, bbox.yMax / 64.0)
+
+    @property
+    def cbox(self):
+        """Returns an outline's ‘control box’.
+
+        Returns:
+            A tuple of ``(xMin, yMin, xMax, yMax)``.
+        """
+        cbox = FT_BBox()
+        outline = self.outline()
+        FT_Outline_Get_CBox(ctypes.byref(outline), ctypes.byref(cbox))
+        return (cbox.xMin / 64.0, cbox.yMin / 64.0, cbox.xMax / 64.0, cbox.yMax / 64.0)
+
+    def _moveTo(self, pt):
+        contour = Contour([], [])
+        self.contours.append(contour)
+        contour.points.append(pt)
+        contour.tags.append(FT_CURVE_TAG_ON)
+
+    def _lineTo(self, pt):
+        if not (self.contours and len(self.contours[-1].points) > 0):
+            raise PenError("Contour missing required initial moveTo")
+        contour = self.contours[-1]
+        contour.points.append(pt)
+        contour.tags.append(FT_CURVE_TAG_ON)
+
+    def _curveToOne(self, p1, p2, p3):
+        if not (self.contours and len(self.contours[-1].points) > 0):
+            raise PenError("Contour missing required initial moveTo")
+        t1, t2, t3 = FT_CURVE_TAG_CUBIC, FT_CURVE_TAG_CUBIC, FT_CURVE_TAG_ON
+        contour = self.contours[-1]
+        for p, t in ((p1, t1), (p2, t2), (p3, t3)):
+            contour.points.append(p)
+            contour.tags.append(t)
+
+    def _qCurveToOne(self, p1, p2):
+        if not (self.contours and len(self.contours[-1].points) > 0):
+            raise PenError("Contour missing required initial moveTo")
+        t1, t2 = FT_CURVE_TAG_CONIC, FT_CURVE_TAG_ON
+        contour = self.contours[-1]
+        for p, t in ((p1, t1), (p2, t2)):
+            contour.points.append(p)
+            contour.tags.append(t)

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/pens/t2CharStringPen.py

@@ -0,0 +1,88 @@
+# Copyright (c) 2009 Type Supply LLC
+# Author: Tal Leming
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Tuple
+
+from fontTools.cffLib.specializer import commandsToProgram, specializeCommands
+from fontTools.misc.psCharStrings import T2CharString
+from fontTools.misc.roundTools import otRound, roundFunc
+from fontTools.pens.basePen import BasePen
+
+
+class T2CharStringPen(BasePen):
+    """Pen to draw Type 2 CharStrings.
+
+    The 'roundTolerance' argument controls the rounding of point coordinates.
+    It is defined as the maximum absolute difference between the original
+    float and the rounded integer value.
+    The default tolerance of 0.5 means that all floats are rounded to integer;
+    a value of 0 disables rounding; values in between will only round floats
+    which are close to their integral part within the tolerated range.
+    """
+
+    def __init__(
+        self,
+        width: float | None,
+        glyphSet: Dict[str, Any] | None,
+        roundTolerance: float = 0.5,
+        CFF2: bool = False,
+    ) -> None:
+        super(T2CharStringPen, self).__init__(glyphSet)
+        self.round = roundFunc(roundTolerance)
+        self._CFF2 = CFF2
+        self._width = width
+        self._commands: List[Tuple[str | bytes, List[float]]] = []
+        self._p0 = (0, 0)
+
+    def _p(self, pt: Tuple[float, float]) -> List[float]:
+        p0 = self._p0
+        pt = self._p0 = (self.round(pt[0]), self.round(pt[1]))
+        return [pt[0] - p0[0], pt[1] - p0[1]]
+
+    def _moveTo(self, pt: Tuple[float, float]) -> None:
+        self._commands.append(("rmoveto", self._p(pt)))
+
+    def _lineTo(self, pt: Tuple[float, float]) -> None:
+        self._commands.append(("rlineto", self._p(pt)))
+
+    def _curveToOne(
+        self,
+        pt1: Tuple[float, float],
+        pt2: Tuple[float, float],
+        pt3: Tuple[float, float],
+    ) -> None:
+        _p = self._p
+        self._commands.append(("rrcurveto", _p(pt1) + _p(pt2) + _p(pt3)))
+
+    def _closePath(self) -> None:
+        pass
+
+    def _endPath(self) -> None:
+        pass
+
+    def getCharString(
+        self,
+        private: Dict | None = None,
+        globalSubrs: List | None = None,
+        optimize: bool = True,
+    ) -> T2CharString:
+        commands = self._commands
+        if optimize:
+            maxstack = 48 if not self._CFF2 else 513
+            commands = specializeCommands(
+                commands, generalizeFirst=False, maxstack=maxstack
+            )
+        program = commandsToProgram(commands)
+        if self._width is not None:
+            assert (
+                not self._CFF2
+            ), "CFF2 does not allow encoding glyph width in CharString."
+            program.insert(0, otRound(self._width))
+        if not self._CFF2:
+            program.append("endchar")
+        charString = T2CharString(
+            program=program, private=private, globalSubrs=globalSubrs
+        )
+        return charString

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/pens/ttGlyphPen.py

@@ -0,0 +1,335 @@
+from array import array
+from typing import Any, Callable, Dict, Optional, Tuple
+from fontTools.misc.fixedTools import MAX_F2DOT14, floatToFixedToFloat
+from fontTools.misc.loggingTools import LogMixin
+from fontTools.pens.pointPen import AbstractPointPen
+from fontTools.misc.roundTools import otRound
+from fontTools.pens.basePen import LoggingPen, PenError
+from fontTools.pens.transformPen import TransformPen, TransformPointPen
+from fontTools.ttLib.tables import ttProgram
+from fontTools.ttLib.tables._g_l_y_f import flagOnCurve, flagCubic
+from fontTools.ttLib.tables._g_l_y_f import Glyph
+from fontTools.ttLib.tables._g_l_y_f import GlyphComponent
+from fontTools.ttLib.tables._g_l_y_f import GlyphCoordinates
+from fontTools.ttLib.tables._g_l_y_f import dropImpliedOnCurvePoints
+import math
+
+
+__all__ = ["TTGlyphPen", "TTGlyphPointPen"]
+
+
+class _TTGlyphBasePen:
+    def __init__(
+        self,
+        glyphSet: Optional[Dict[str, Any]],
+        handleOverflowingTransforms: bool = True,
+    ) -> None:
+        """
+        Construct a new pen.
+
+        Args:
+            glyphSet (Dict[str, Any]): A glyphset object, used to resolve components.
+            handleOverflowingTransforms (bool): See below.
+
+        If ``handleOverflowingTransforms`` is True, the components' transform values
+        are checked that they don't overflow the limits of a F2Dot14 number:
+        -2.0 <= v < +2.0. If any transform value exceeds these, the composite
+        glyph is decomposed.
+
+        An exception to this rule is done for values that are very close to +2.0
+        (both for consistency with the -2.0 case, and for the relative frequency
+        these occur in real fonts). When almost +2.0 values occur (and all other
+        values are within the range -2.0 <= x <= +2.0), they are clamped to the
+        maximum positive value that can still be encoded as an F2Dot14: i.e.
+        1.99993896484375.
+
+        If False, no check is done and all components are translated unmodified
+        into the glyf table, followed by an inevitable ``struct.error`` once an
+        attempt is made to compile them.
+
+        If both contours and components are present in a glyph, the components
+        are decomposed.
+        """
+        self.glyphSet = glyphSet
+        self.handleOverflowingTransforms = handleOverflowingTransforms
+        self.init()
+
+    def _decompose(
+        self,
+        glyphName: str,
+        transformation: Tuple[float, float, float, float, float, float],
+    ):
+        tpen = self.transformPen(self, transformation)
+        getattr(self.glyphSet[glyphName], self.drawMethod)(tpen)
+
+    def _isClosed(self):
+        """
+        Check if the current path is closed.
+        """
+        raise NotImplementedError
+
+    def init(self) -> None:
+        self.points = []
+        self.endPts = []
+        self.types = []
+        self.components = []
+
+    def addComponent(
+        self,
+        baseGlyphName: str,
+        transformation: Tuple[float, float, float, float, float, float],
+        identifier: Optional[str] = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Add a sub glyph.
+        """
+        self.components.append((baseGlyphName, transformation))
+
+    def _buildComponents(self, componentFlags):
+        if self.handleOverflowingTransforms:
+            # we can't encode transform values > 2 or < -2 in F2Dot14,
+            # so we must decompose the glyph if any transform exceeds these
+            overflowing = any(
+                s > 2 or s < -2
+                for (glyphName, transformation) in self.components
+                for s in transformation[:4]
+            )
+        components = []
+        for glyphName, transformation in self.components:
+            if glyphName not in self.glyphSet:
+                self.log.warning(f"skipped non-existing component '{glyphName}'")
+                continue
+            if self.points or (self.handleOverflowingTransforms and overflowing):
+                # can't have both coordinates and components, so decompose
+                self._decompose(glyphName, transformation)
+                continue
+
+            component = GlyphComponent()
+            component.glyphName = glyphName
+            component.x, component.y = (otRound(v) for v in transformation[4:])
+            # quantize floats to F2Dot14 so we get same values as when decompiled
+            # from a binary glyf table
+            transformation = tuple(
+                floatToFixedToFloat(v, 14) for v in transformation[:4]
+            )
+            if transformation != (1, 0, 0, 1):
+                if self.handleOverflowingTransforms and any(
+                    MAX_F2DOT14 < s <= 2 for s in transformation
+                ):
+                    # clamp values ~= +2.0 so we can keep the component
+                    transformation = tuple(
+                        MAX_F2DOT14 if MAX_F2DOT14 < s <= 2 else s
+                        for s in transformation
+                    )
+                component.transform = (transformation[:2], transformation[2:])
+            component.flags = componentFlags
+            components.append(component)
+        return components
+
+    def glyph(
+        self,
+        componentFlags: int = 0x04,
+        dropImpliedOnCurves: bool = False,
+        *,
+        round: Callable[[float], int] = otRound,
+    ) -> Glyph:
+        """
+        Returns a :py:class:`~._g_l_y_f.Glyph` object representing the glyph.
+
+        Args:
+            componentFlags: Flags to use for component glyphs. (default: 0x04)
+
+            dropImpliedOnCurves: Whether to remove implied-oncurve points. (default: False)
+        """
+        if not self._isClosed():
+            raise PenError("Didn't close last contour.")
+        components = self._buildComponents(componentFlags)
+
+        glyph = Glyph()
+        glyph.coordinates = GlyphCoordinates(self.points)
+        glyph.endPtsOfContours = self.endPts
+        glyph.flags = array("B", self.types)
+        self.init()
+
+        if components:
+            # If both components and contours were present, they have by now
+            # been decomposed by _buildComponents.
+            glyph.components = components
+            glyph.numberOfContours = -1
+        else:
+            glyph.numberOfContours = len(glyph.endPtsOfContours)
+            glyph.program = ttProgram.Program()
+            glyph.program.fromBytecode(b"")
+            if dropImpliedOnCurves:
+                dropImpliedOnCurvePoints(glyph)
+            glyph.coordinates.toInt(round=round)
+
+        return glyph
+
+
+class TTGlyphPen(_TTGlyphBasePen, LoggingPen):
+    """
+    Pen used for drawing to a TrueType glyph.
+
+    This pen can be used to construct or modify glyphs in a TrueType format
+    font. After using the pen to draw, use the ``.glyph()`` method to retrieve
+    a :py:class:`~._g_l_y_f.Glyph` object representing the glyph.
+    """
+
+    drawMethod = "draw"
+    transformPen = TransformPen
+
+    def __init__(
+        self,
+        glyphSet: Optional[Dict[str, Any]] = None,
+        handleOverflowingTransforms: bool = True,
+        outputImpliedClosingLine: bool = False,
+    ) -> None:
+        super().__init__(glyphSet, handleOverflowingTransforms)
+        self.outputImpliedClosingLine = outputImpliedClosingLine
+
+    def _addPoint(self, pt: Tuple[float, float], tp: int) -> None:
+        self.points.append(pt)
+        self.types.append(tp)
+
+    def _popPoint(self) -> None:
+        self.points.pop()
+        self.types.pop()
+
+    def _isClosed(self) -> bool:
+        return (not self.points) or (
+            self.endPts and self.endPts[-1] == len(self.points) - 1
+        )
+
+    def lineTo(self, pt: Tuple[float, float]) -> None:
+        self._addPoint(pt, flagOnCurve)
+
+    def moveTo(self, pt: Tuple[float, float]) -> None:
+        if not self._isClosed():
+            raise PenError('"move"-type point must begin a new contour.')
+        self._addPoint(pt, flagOnCurve)
+
+    def curveTo(self, *points) -> None:
+        assert len(points) % 2 == 1
+        for pt in points[:-1]:
+            self._addPoint(pt, flagCubic)
+
+        # last point is None if there are no on-curve points
+        if points[-1] is not None:
+            self._addPoint(points[-1], 1)
+
+    def qCurveTo(self, *points) -> None:
+        assert len(points) >= 1
+        for pt in points[:-1]:
+            self._addPoint(pt, 0)
+
+        # last point is None if there are no on-curve points
+        if points[-1] is not None:
+            self._addPoint(points[-1], 1)
+
+    def closePath(self) -> None:
+        endPt = len(self.points) - 1
+
+        # ignore anchors (one-point paths)
+        if endPt == 0 or (self.endPts and endPt == self.endPts[-1] + 1):
+            self._popPoint()
+            return
+
+        if not self.outputImpliedClosingLine:
+            # if first and last point on this path are the same, remove last
+            startPt = 0
+            if self.endPts:
+                startPt = self.endPts[-1] + 1
+            if self.points[startPt] == self.points[endPt]:
+                self._popPoint()
+                endPt -= 1
+
+        self.endPts.append(endPt)
+
+    def endPath(self) -> None:
+        # TrueType contours are always "closed"
+        self.closePath()
+
+
+class TTGlyphPointPen(_TTGlyphBasePen, LogMixin, AbstractPointPen):
+    """
+    Point pen used for drawing to a TrueType glyph.
+
+    This pen can be used to construct or modify glyphs in a TrueType format
+    font. After using the pen to draw, use the ``.glyph()`` method to retrieve
+    a :py:class:`~._g_l_y_f.Glyph` object representing the glyph.
+    """
+
+    drawMethod = "drawPoints"
+    transformPen = TransformPointPen
+
+    def init(self) -> None:
+        super().init()
+        self._currentContourStartIndex = None
+
+    def _isClosed(self) -> bool:
+        return self._currentContourStartIndex is None
+
+    def beginPath(self, identifier: Optional[str] = None, **kwargs: Any) -> None:
+        """
+        Start a new sub path.
+        """
+        if not self._isClosed():
+            raise PenError("Didn't close previous contour.")
+        self._currentContourStartIndex = len(self.points)
+
+    def endPath(self) -> None:
+        """
+        End the current sub path.
+        """
+        # TrueType contours are always "closed"
+        if self._isClosed():
+            raise PenError("Contour is already closed.")
+        if self._currentContourStartIndex == len(self.points):
+            # ignore empty contours
+            self._currentContourStartIndex = None
+            return
+
+        contourStart = self.endPts[-1] + 1 if self.endPts else 0
+        self.endPts.append(len(self.points) - 1)
+        self._currentContourStartIndex = None
+
+        # Resolve types for any cubic segments
+        flags = self.types
+        for i in range(contourStart, len(flags)):
+            if flags[i] == "curve":
+                j = i - 1
+                if j < contourStart:
+                    j = len(flags) - 1
+                while flags[j] == 0:
+                    flags[j] = flagCubic
+                    j -= 1
+                flags[i] = flagOnCurve
+
+    def addPoint(
+        self,
+        pt: Tuple[float, float],
+        segmentType: Optional[str] = None,
+        smooth: bool = False,
+        name: Optional[str] = None,
+        identifier: Optional[str] = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Add a point to the current sub path.
+        """
+        if self._isClosed():
+            raise PenError("Can't add a point to a closed contour.")
+        if segmentType is None:
+            self.types.append(0)
+        elif segmentType in ("line", "move"):
+            self.types.append(flagOnCurve)
+        elif segmentType == "qcurve":
+            self.types.append(flagOnCurve)
+        elif segmentType == "curve":
+            self.types.append("curve")
+        else:
+            raise AssertionError(segmentType)
+
+        self.points.append(pt)

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/fontTools/qu2cu/__init__.py

@@ -0,0 +1,15 @@
+# Copyright 2016 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .qu2cu import *