Add files using upload-large-folder tool

evalkit_tf437/lib/python3.10/site-packages/MarkupSafe-2.1.5.dist-info/METADATA

@@ -0,0 +1,93 @@
+Metadata-Version: 2.1
+Name: MarkupSafe
+Version: 2.1.5
+Summary: Safely add untrusted strings to HTML/XML markup.
+Home-page: https://palletsprojects.com/p/markupsafe/
+Maintainer: Pallets
+Maintainer-email: contact@palletsprojects.com
+License: BSD-3-Clause
+Project-URL: Donate, https://palletsprojects.com/donate
+Project-URL: Documentation, https://markupsafe.palletsprojects.com/
+Project-URL: Changes, https://markupsafe.palletsprojects.com/changes/
+Project-URL: Source Code, https://github.com/pallets/markupsafe/
+Project-URL: Issue Tracker, https://github.com/pallets/markupsafe/issues/
+Project-URL: Chat, https://discord.gg/pallets
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Text Processing :: Markup :: HTML
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE.rst
+
+MarkupSafe
+==========
+
+MarkupSafe implements a text object that escapes characters so it is
+safe to use in HTML and XML. Characters that have special meanings are
+replaced so that they display as the actual characters. This mitigates
+injection attacks, meaning untrusted user input can safely be displayed
+on a page.
+
+
+Installing
+----------
+
+Install and update using `pip`_:
+
+.. code-block:: text
+
+    pip install -U MarkupSafe
+
+.. _pip: https://pip.pypa.io/en/stable/getting-started/
+
+
+Examples
+--------
+
+.. code-block:: pycon
+
+    >>> from markupsafe import Markup, escape
+
+    >>> # escape replaces special characters and wraps in Markup
+    >>> escape("<script>alert(document.cookie);</script>")
+    Markup('&lt;script&gt;alert(document.cookie);&lt;/script&gt;')
+
+    >>> # wrap in Markup to mark text "safe" and prevent escaping
+    >>> Markup("<strong>Hello</strong>")
+    Markup('<strong>hello</strong>')
+
+    >>> escape(Markup("<strong>Hello</strong>"))
+    Markup('<strong>hello</strong>')
+
+    >>> # Markup is a str subclass
+    >>> # methods and operators escape their arguments
+    >>> template = Markup("Hello <em>{name}</em>")
+    >>> template.format(name='"World"')
+    Markup('Hello <em>&#34;World&#34;</em>')
+
+
+Donate
+------
+
+The Pallets organization develops and supports MarkupSafe and other
+popular packages. In order to grow the community of contributors and
+users, and allow the maintainers to devote more time to the projects,
+`please donate today`_.
+
+.. _please donate today: https://palletsprojects.com/donate
+
+
+Links
+-----
+
+-   Documentation: https://markupsafe.palletsprojects.com/
+-   Changes: https://markupsafe.palletsprojects.com/changes/
+-   PyPI Releases: https://pypi.org/project/MarkupSafe/
+-   Source Code: https://github.com/pallets/markupsafe/
+-   Issue Tracker: https://github.com/pallets/markupsafe/issues/
+-   Chat: https://discord.gg/pallets

evalkit_tf437/lib/python3.10/site-packages/fastapi-0.103.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Sebastián Ramírez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

evalkit_tf437/lib/python3.10/site-packages/fontTools/misc/plistlib/__init__.py

@@ -0,0 +1,681 @@
+import collections.abc
+import re
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+    Mapping,
+    MutableMapping,
+    Optional,
+    Sequence,
+    Type,
+    Union,
+    IO,
+)
+import warnings
+from io import BytesIO
+from datetime import datetime
+from base64 import b64encode, b64decode
+from numbers import Integral
+from types import SimpleNamespace
+from functools import singledispatch
+
+from fontTools.misc import etree
+
+from fontTools.misc.textTools import tostr
+
+
+# By default, we
+#  - deserialize <data> elements as bytes and
+#  - serialize bytes as <data> elements.
+# Before, on Python 2, we
+#  - deserialized <data> elements as plistlib.Data objects, in order to
+#    distinguish them from the built-in str type (which is bytes on python2)
+#  - serialized bytes as <string> elements (they must have only contained
+#    ASCII characters in this case)
+# You can pass use_builtin_types=[True|False] to the load/dump etc. functions
+# to enforce a specific treatment.
+# NOTE that unicode type always maps to <string> element, and plistlib.Data
+# always maps to <data> element, regardless of use_builtin_types.
+USE_BUILTIN_TYPES = True
+
+XML_DECLARATION = b"""<?xml version='1.0' encoding='UTF-8'?>"""
+
+PLIST_DOCTYPE = (
+    b'<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" '
+    b'"http://www.apple.com/DTDs/PropertyList-1.0.dtd">'
+)
+
+
+# Date should conform to a subset of ISO 8601:
+# YYYY '-' MM '-' DD 'T' HH ':' MM ':' SS 'Z'
+_date_parser = re.compile(
+    r"(?P<year>\d\d\d\d)"
+    r"(?:-(?P<month>\d\d)"
+    r"(?:-(?P<day>\d\d)"
+    r"(?:T(?P<hour>\d\d)"
+    r"(?::(?P<minute>\d\d)"
+    r"(?::(?P<second>\d\d))"
+    r"?)?)?)?)?Z",
+    re.ASCII,
+)
+
+
+def _date_from_string(s: str) -> datetime:
+    order = ("year", "month", "day", "hour", "minute", "second")
+    m = _date_parser.match(s)
+    if m is None:
+        raise ValueError(f"Expected ISO 8601 date string, but got '{s:r}'.")
+    gd = m.groupdict()
+    lst = []
+    for key in order:
+        val = gd[key]
+        if val is None:
+            break
+        lst.append(int(val))
+    # NOTE: mypy doesn't know that lst is 6 elements long.
+    return datetime(*lst)  # type:ignore
+
+
+def _date_to_string(d: datetime) -> str:
+    return "%04d-%02d-%02dT%02d:%02d:%02dZ" % (
+        d.year,
+        d.month,
+        d.day,
+        d.hour,
+        d.minute,
+        d.second,
+    )
+
+
+class Data:
+    """Represents binary data when ``use_builtin_types=False.``
+
+    This class wraps binary data loaded from a plist file when the
+    ``use_builtin_types`` argument to the loading function (:py:func:`fromtree`,
+    :py:func:`load`, :py:func:`loads`) is false.
+
+    The actual binary data is retrieved using the ``data`` attribute.
+    """
+
+    def __init__(self, data: bytes) -> None:
+        if not isinstance(data, bytes):
+            raise TypeError("Expected bytes, found %s" % type(data).__name__)
+        self.data = data
+
+    @classmethod
+    def fromBase64(cls, data: Union[bytes, str]) -> "Data":
+        return cls(b64decode(data))
+
+    def asBase64(self, maxlinelength: int = 76, indent_level: int = 1) -> bytes:
+        return _encode_base64(
+            self.data, maxlinelength=maxlinelength, indent_level=indent_level
+        )
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, self.__class__):
+            return self.data == other.data
+        elif isinstance(other, bytes):
+            return self.data == other
+        else:
+            return NotImplemented
+
+    def __repr__(self) -> str:
+        return "%s(%s)" % (self.__class__.__name__, repr(self.data))
+
+
+def _encode_base64(
+    data: bytes, maxlinelength: Optional[int] = 76, indent_level: int = 1
+) -> bytes:
+    data = b64encode(data)
+    if data and maxlinelength:
+        # split into multiple lines right-justified to 'maxlinelength' chars
+        indent = b"\n" + b"  " * indent_level
+        max_length = max(16, maxlinelength - len(indent))
+        chunks = []
+        for i in range(0, len(data), max_length):
+            chunks.append(indent)
+            chunks.append(data[i : i + max_length])
+        chunks.append(indent)
+        data = b"".join(chunks)
+    return data
+
+
+# Mypy does not support recursive type aliases as of 0.782, Pylance does.
+# https://github.com/python/mypy/issues/731
+# https://devblogs.microsoft.com/python/pylance-introduces-five-new-features-that-enable-type-magic-for-python-developers/#1-support-for-recursive-type-aliases
+PlistEncodable = Union[
+    bool,
+    bytes,
+    Data,
+    datetime,
+    float,
+    Integral,
+    Mapping[str, Any],
+    Sequence[Any],
+    str,
+]
+
+
+class PlistTarget:
+    """Event handler using the ElementTree Target API that can be
+    passed to a XMLParser to produce property list objects from XML.
+    It is based on the CPython plistlib module's _PlistParser class,
+    but does not use the expat parser.
+
+    >>> from fontTools.misc import etree
+    >>> parser = etree.XMLParser(target=PlistTarget())
+    >>> result = etree.XML(
+    ...     "<dict>"
+    ...     "    <key>something</key>"
+    ...     "    <string>blah</string>"
+    ...     "</dict>",
+    ...     parser=parser)
+    >>> result == {"something": "blah"}
+    True
+
+    Links:
+    https://github.com/python/cpython/blob/main/Lib/plistlib.py
+    http://lxml.de/parsing.html#the-target-parser-interface
+    """
+
+    def __init__(
+        self,
+        use_builtin_types: Optional[bool] = None,
+        dict_type: Type[MutableMapping[str, Any]] = dict,
+    ) -> None:
+        self.stack: List[PlistEncodable] = []
+        self.current_key: Optional[str] = None
+        self.root: Optional[PlistEncodable] = None
+        if use_builtin_types is None:
+            self._use_builtin_types = USE_BUILTIN_TYPES
+        else:
+            if use_builtin_types is False:
+                warnings.warn(
+                    "Setting use_builtin_types to False is deprecated and will be "
+                    "removed soon.",
+                    DeprecationWarning,
+                )
+            self._use_builtin_types = use_builtin_types
+        self._dict_type = dict_type
+
+    def start(self, tag: str, attrib: Mapping[str, str]) -> None:
+        self._data: List[str] = []
+        handler = _TARGET_START_HANDLERS.get(tag)
+        if handler is not None:
+            handler(self)
+
+    def end(self, tag: str) -> None:
+        handler = _TARGET_END_HANDLERS.get(tag)
+        if handler is not None:
+            handler(self)
+
+    def data(self, data: str) -> None:
+        self._data.append(data)
+
+    def close(self) -> PlistEncodable:
+        if self.root is None:
+            raise ValueError("No root set.")
+        return self.root
+
+    # helpers
+
+    def add_object(self, value: PlistEncodable) -> None:
+        if self.current_key is not None:
+            stack_top = self.stack[-1]
+            if not isinstance(stack_top, collections.abc.MutableMapping):
+                raise ValueError("unexpected element: %r" % stack_top)
+            stack_top[self.current_key] = value
+            self.current_key = None
+        elif not self.stack:
+            # this is the root object
+            self.root = value
+        else:
+            stack_top = self.stack[-1]
+            if not isinstance(stack_top, list):
+                raise ValueError("unexpected element: %r" % stack_top)
+            stack_top.append(value)
+
+    def get_data(self) -> str:
+        data = "".join(self._data)
+        self._data = []
+        return data
+
+
+# event handlers
+
+
+def start_dict(self: PlistTarget) -> None:
+    d = self._dict_type()
+    self.add_object(d)
+    self.stack.append(d)
+
+
+def end_dict(self: PlistTarget) -> None:
+    if self.current_key:
+        raise ValueError("missing value for key '%s'" % self.current_key)
+    self.stack.pop()
+
+
+def end_key(self: PlistTarget) -> None:
+    if self.current_key or not isinstance(self.stack[-1], collections.abc.Mapping):
+        raise ValueError("unexpected key")
+    self.current_key = self.get_data()
+
+
+def start_array(self: PlistTarget) -> None:
+    a: List[PlistEncodable] = []
+    self.add_object(a)
+    self.stack.append(a)
+
+
+def end_array(self: PlistTarget) -> None:
+    self.stack.pop()
+
+
+def end_true(self: PlistTarget) -> None:
+    self.add_object(True)
+
+
+def end_false(self: PlistTarget) -> None:
+    self.add_object(False)
+
+
+def end_integer(self: PlistTarget) -> None:
+    self.add_object(int(self.get_data()))
+
+
+def end_real(self: PlistTarget) -> None:
+    self.add_object(float(self.get_data()))
+
+
+def end_string(self: PlistTarget) -> None:
+    self.add_object(self.get_data())
+
+
+def end_data(self: PlistTarget) -> None:
+    if self._use_builtin_types:
+        self.add_object(b64decode(self.get_data()))
+    else:
+        self.add_object(Data.fromBase64(self.get_data()))
+
+
+def end_date(self: PlistTarget) -> None:
+    self.add_object(_date_from_string(self.get_data()))
+
+
+_TARGET_START_HANDLERS: Dict[str, Callable[[PlistTarget], None]] = {
+    "dict": start_dict,
+    "array": start_array,
+}
+
+_TARGET_END_HANDLERS: Dict[str, Callable[[PlistTarget], None]] = {
+    "dict": end_dict,
+    "array": end_array,
+    "key": end_key,
+    "true": end_true,
+    "false": end_false,
+    "integer": end_integer,
+    "real": end_real,
+    "string": end_string,
+    "data": end_data,
+    "date": end_date,
+}
+
+
+# functions to build element tree from plist data
+
+
+def _string_element(value: str, ctx: SimpleNamespace) -> etree.Element:
+    el = etree.Element("string")
+    el.text = value
+    return el
+
+
+def _bool_element(value: bool, ctx: SimpleNamespace) -> etree.Element:
+    if value:
+        return etree.Element("true")
+    return etree.Element("false")
+
+
+def _integer_element(value: int, ctx: SimpleNamespace) -> etree.Element:
+    if -1 << 63 <= value < 1 << 64:
+        el = etree.Element("integer")
+        el.text = "%d" % value
+        return el
+    raise OverflowError(value)
+
+
+def _real_element(value: float, ctx: SimpleNamespace) -> etree.Element:
+    el = etree.Element("real")
+    el.text = repr(value)
+    return el
+
+
+def _dict_element(
+    d: Mapping[str, PlistEncodable], ctx: SimpleNamespace
+) -> etree.Element:
+    el = etree.Element("dict")
+    items = d.items()
+    if ctx.sort_keys:
+        items = sorted(items)  # type: ignore
+    ctx.indent_level += 1
+    for key, value in items:
+        if not isinstance(key, str):
+            if ctx.skipkeys:
+                continue
+            raise TypeError("keys must be strings")
+        k = etree.SubElement(el, "key")
+        k.text = tostr(key, "utf-8")
+        el.append(_make_element(value, ctx))
+    ctx.indent_level -= 1
+    return el
+
+
+def _array_element(
+    array: Sequence[PlistEncodable], ctx: SimpleNamespace
+) -> etree.Element:
+    el = etree.Element("array")
+    if len(array) == 0:
+        return el
+    ctx.indent_level += 1
+    for value in array:
+        el.append(_make_element(value, ctx))
+    ctx.indent_level -= 1
+    return el
+
+
+def _date_element(date: datetime, ctx: SimpleNamespace) -> etree.Element:
+    el = etree.Element("date")
+    el.text = _date_to_string(date)
+    return el
+
+
+def _data_element(data: bytes, ctx: SimpleNamespace) -> etree.Element:
+    el = etree.Element("data")
+    # NOTE: mypy is confused about whether el.text should be str or bytes.
+    el.text = _encode_base64(  # type: ignore
+        data,
+        maxlinelength=(76 if ctx.pretty_print else None),
+        indent_level=ctx.indent_level,
+    )
+    return el
+
+
+def _string_or_data_element(raw_bytes: bytes, ctx: SimpleNamespace) -> etree.Element:
+    if ctx.use_builtin_types:
+        return _data_element(raw_bytes, ctx)
+    else:
+        try:
+            string = raw_bytes.decode(encoding="ascii", errors="strict")
+        except UnicodeDecodeError:
+            raise ValueError(
+                "invalid non-ASCII bytes; use unicode string instead: %r" % raw_bytes
+            )
+        return _string_element(string, ctx)
+
+
+# The following is probably not entirely correct. The signature should take `Any`
+# and return `NoReturn`. At the time of this writing, neither mypy nor Pyright
+# can deal with singledispatch properly and will apply the signature of the base
+# function to all others. Being slightly dishonest makes it type-check and return
+# usable typing information for the optimistic case.
+@singledispatch
+def _make_element(value: PlistEncodable, ctx: SimpleNamespace) -> etree.Element:
+    raise TypeError("unsupported type: %s" % type(value))
+
+
+_make_element.register(str)(_string_element)
+_make_element.register(bool)(_bool_element)
+_make_element.register(Integral)(_integer_element)
+_make_element.register(float)(_real_element)
+_make_element.register(collections.abc.Mapping)(_dict_element)
+_make_element.register(list)(_array_element)
+_make_element.register(tuple)(_array_element)
+_make_element.register(datetime)(_date_element)
+_make_element.register(bytes)(_string_or_data_element)
+_make_element.register(bytearray)(_data_element)
+_make_element.register(Data)(lambda v, ctx: _data_element(v.data, ctx))
+
+
+# Public functions to create element tree from plist-compatible python
+# data structures and viceversa, for use when (de)serializing GLIF xml.
+
+
+def totree(
+    value: PlistEncodable,
+    sort_keys: bool = True,
+    skipkeys: bool = False,
+    use_builtin_types: Optional[bool] = None,
+    pretty_print: bool = True,
+    indent_level: int = 1,
+) -> etree.Element:
+    """Convert a value derived from a plist into an XML tree.
+
+    Args:
+        value: Any kind of value to be serialized to XML.
+        sort_keys: Whether keys of dictionaries should be sorted.
+        skipkeys (bool): Whether to silently skip non-string dictionary
+            keys.
+        use_builtin_types (bool): If true, byte strings will be
+            encoded in Base-64 and wrapped in a ``data`` tag; if
+            false, they will be either stored as ASCII strings or an
+            exception raised if they cannot be decoded as such. Defaults
+            to ``True`` if not present. Deprecated.
+        pretty_print (bool): Whether to indent the output.
+        indent_level (int): Level of indentation when serializing.
+
+    Returns: an ``etree`` ``Element`` object.
+
+    Raises:
+        ``TypeError``
+            if non-string dictionary keys are serialized
+            and ``skipkeys`` is false.
+        ``ValueError``
+            if non-ASCII binary data is present
+            and `use_builtin_types` is false.
+    """
+    if use_builtin_types is None:
+        use_builtin_types = USE_BUILTIN_TYPES
+    else:
+        use_builtin_types = use_builtin_types
+    context = SimpleNamespace(
+        sort_keys=sort_keys,
+        skipkeys=skipkeys,
+        use_builtin_types=use_builtin_types,
+        pretty_print=pretty_print,
+        indent_level=indent_level,
+    )
+    return _make_element(value, context)
+
+
+def fromtree(
+    tree: etree.Element,
+    use_builtin_types: Optional[bool] = None,
+    dict_type: Type[MutableMapping[str, Any]] = dict,
+) -> Any:
+    """Convert an XML tree to a plist structure.
+
+    Args:
+        tree: An ``etree`` ``Element``.
+        use_builtin_types: If True, binary data is deserialized to
+            bytes strings. If False, it is wrapped in :py:class:`Data`
+            objects. Defaults to True if not provided. Deprecated.
+        dict_type: What type to use for dictionaries.
+
+    Returns: An object (usually a dictionary).
+    """
+    target = PlistTarget(use_builtin_types=use_builtin_types, dict_type=dict_type)
+    for action, element in etree.iterwalk(tree, events=("start", "end")):
+        if action == "start":
+            target.start(element.tag, element.attrib)
+        elif action == "end":
+            # if there are no children, parse the leaf's data
+            if not len(element):
+                # always pass str, not None
+                target.data(element.text or "")
+            target.end(element.tag)
+    return target.close()
+
+
+# python3 plistlib API
+
+
+def load(
+    fp: IO[bytes],
+    use_builtin_types: Optional[bool] = None,
+    dict_type: Type[MutableMapping[str, Any]] = dict,
+) -> Any:
+    """Load a plist file into an object.
+
+    Args:
+        fp: An opened file.
+        use_builtin_types: If True, binary data is deserialized to
+            bytes strings. If False, it is wrapped in :py:class:`Data`
+            objects. Defaults to True if not provided. Deprecated.
+        dict_type: What type to use for dictionaries.
+
+    Returns:
+        An object (usually a dictionary) representing the top level of
+        the plist file.
+    """
+
+    if not hasattr(fp, "read"):
+        raise AttributeError("'%s' object has no attribute 'read'" % type(fp).__name__)
+    target = PlistTarget(use_builtin_types=use_builtin_types, dict_type=dict_type)
+    parser = etree.XMLParser(target=target)
+    result = etree.parse(fp, parser=parser)
+    # lxml returns the target object directly, while ElementTree wraps
+    # it as the root of an ElementTree object
+    try:
+        return result.getroot()
+    except AttributeError:
+        return result
+
+
+def loads(
+    value: bytes,
+    use_builtin_types: Optional[bool] = None,
+    dict_type: Type[MutableMapping[str, Any]] = dict,
+) -> Any:
+    """Load a plist file from a string into an object.
+
+    Args:
+        value: A bytes string containing a plist.
+        use_builtin_types: If True, binary data is deserialized to
+            bytes strings. If False, it is wrapped in :py:class:`Data`
+            objects. Defaults to True if not provided. Deprecated.
+        dict_type: What type to use for dictionaries.
+
+    Returns:
+        An object (usually a dictionary) representing the top level of
+        the plist file.
+    """
+
+    fp = BytesIO(value)
+    return load(fp, use_builtin_types=use_builtin_types, dict_type=dict_type)
+
+
+def dump(
+    value: PlistEncodable,
+    fp: IO[bytes],
+    sort_keys: bool = True,
+    skipkeys: bool = False,
+    use_builtin_types: Optional[bool] = None,
+    pretty_print: bool = True,
+) -> None:
+    """Write a Python object to a plist file.
+
+    Args:
+        value: An object to write.
+        fp: A file opened for writing.
+        sort_keys (bool): Whether keys of dictionaries should be sorted.
+        skipkeys (bool): Whether to silently skip non-string dictionary
+            keys.
+        use_builtin_types (bool): If true, byte strings will be
+            encoded in Base-64 and wrapped in a ``data`` tag; if
+            false, they will be either stored as ASCII strings or an
+            exception raised if they cannot be represented. Defaults
+        pretty_print (bool): Whether to indent the output.
+        indent_level (int): Level of indentation when serializing.
+
+    Raises:
+        ``TypeError``
+            if non-string dictionary keys are serialized
+            and ``skipkeys`` is false.
+        ``ValueError``
+            if non-representable binary data is present
+            and `use_builtin_types` is false.
+    """
+
+    if not hasattr(fp, "write"):
+        raise AttributeError("'%s' object has no attribute 'write'" % type(fp).__name__)
+    root = etree.Element("plist", version="1.0")
+    el = totree(
+        value,
+        sort_keys=sort_keys,
+        skipkeys=skipkeys,
+        use_builtin_types=use_builtin_types,
+        pretty_print=pretty_print,
+    )
+    root.append(el)
+    tree = etree.ElementTree(root)
+    # we write the doctype ourselves instead of using the 'doctype' argument
+    # of 'write' method, becuse lxml will force adding a '\n' even when
+    # pretty_print is False.
+    if pretty_print:
+        header = b"\n".join((XML_DECLARATION, PLIST_DOCTYPE, b""))
+    else:
+        header = XML_DECLARATION + PLIST_DOCTYPE
+    fp.write(header)
+    tree.write(  # type: ignore
+        fp,
+        encoding="utf-8",
+        pretty_print=pretty_print,
+        xml_declaration=False,
+    )
+
+
+def dumps(
+    value: PlistEncodable,
+    sort_keys: bool = True,
+    skipkeys: bool = False,
+    use_builtin_types: Optional[bool] = None,
+    pretty_print: bool = True,
+) -> bytes:
+    """Write a Python object to a string in plist format.
+
+    Args:
+        value: An object to write.
+        sort_keys (bool): Whether keys of dictionaries should be sorted.
+        skipkeys (bool): Whether to silently skip non-string dictionary
+            keys.
+        use_builtin_types (bool): If true, byte strings will be
+            encoded in Base-64 and wrapped in a ``data`` tag; if
+            false, they will be either stored as strings or an
+            exception raised if they cannot be represented. Defaults
+        pretty_print (bool): Whether to indent the output.
+        indent_level (int): Level of indentation when serializing.
+
+    Returns:
+        string: A plist representation of the Python object.
+
+    Raises:
+        ``TypeError``
+            if non-string dictionary keys are serialized
+            and ``skipkeys`` is false.
+        ``ValueError``
+            if non-representable binary data is present
+            and `use_builtin_types` is false.
+    """
+    fp = BytesIO()
+    dump(
+        value,
+        fp,
+        sort_keys=sort_keys,
+        skipkeys=skipkeys,
+        use_builtin_types=use_builtin_types,
+        pretty_print=pretty_print,
+    )
+    return fp.getvalue()

evalkit_tf437/lib/python3.10/site-packages/fontTools/varLib/interpolatable.py

@@ -0,0 +1,1148 @@
+"""
+Tool to find wrong contour order between different masters, and
+other interpolatability (or lack thereof) issues.
+
+Call as:
+$ fonttools varLib.interpolatable font1 font2 ...
+"""
+
+from .interpolatableHelpers import *
+from .interpolatableTestContourOrder import test_contour_order
+from .interpolatableTestStartingPoint import test_starting_point
+from fontTools.pens.recordingPen import (
+    RecordingPen,
+    DecomposingRecordingPen,
+    lerpRecordings,
+)
+from fontTools.pens.transformPen import TransformPen
+from fontTools.pens.statisticsPen import StatisticsPen, StatisticsControlPen
+from fontTools.pens.momentsPen import OpenContourError
+from fontTools.varLib.models import piecewiseLinearMap, normalizeLocation
+from fontTools.misc.fixedTools import floatToFixedToStr
+from fontTools.misc.transform import Transform
+from collections import defaultdict
+from types import SimpleNamespace
+from functools import wraps
+from pprint import pformat
+from math import sqrt, atan2, pi
+import logging
+import os
+
+log = logging.getLogger("fontTools.varLib.interpolatable")
+
+DEFAULT_TOLERANCE = 0.95
+DEFAULT_KINKINESS = 0.5
+DEFAULT_KINKINESS_LENGTH = 0.002  # ratio of UPEM
+DEFAULT_UPEM = 1000
+
+
+class Glyph:
+    ITEMS = (
+        "recordings",
+        "greenStats",
+        "controlStats",
+        "greenVectors",
+        "controlVectors",
+        "nodeTypes",
+        "isomorphisms",
+        "points",
+        "openContours",
+    )
+
+    def __init__(self, glyphname, glyphset):
+        self.name = glyphname
+        for item in self.ITEMS:
+            setattr(self, item, [])
+        self._populate(glyphset)
+
+    def _fill_in(self, ix):
+        for item in self.ITEMS:
+            if len(getattr(self, item)) == ix:
+                getattr(self, item).append(None)
+
+    def _populate(self, glyphset):
+        glyph = glyphset[self.name]
+        self.doesnt_exist = glyph is None
+        if self.doesnt_exist:
+            return
+
+        perContourPen = PerContourOrComponentPen(RecordingPen, glyphset=glyphset)
+        try:
+            glyph.draw(perContourPen, outputImpliedClosingLine=True)
+        except TypeError:
+            glyph.draw(perContourPen)
+        self.recordings = perContourPen.value
+        del perContourPen
+
+        for ix, contour in enumerate(self.recordings):
+            nodeTypes = [op for op, arg in contour.value]
+            self.nodeTypes.append(nodeTypes)
+
+            greenStats = StatisticsPen(glyphset=glyphset)
+            controlStats = StatisticsControlPen(glyphset=glyphset)
+            try:
+                contour.replay(greenStats)
+                contour.replay(controlStats)
+                self.openContours.append(False)
+            except OpenContourError as e:
+                self.openContours.append(True)
+                self._fill_in(ix)
+                continue
+            self.greenStats.append(greenStats)
+            self.controlStats.append(controlStats)
+            self.greenVectors.append(contour_vector_from_stats(greenStats))
+            self.controlVectors.append(contour_vector_from_stats(controlStats))
+
+            # Check starting point
+            if nodeTypes[0] == "addComponent":
+                self._fill_in(ix)
+                continue
+
+            assert nodeTypes[0] == "moveTo"
+            assert nodeTypes[-1] in ("closePath", "endPath")
+            points = SimpleRecordingPointPen()
+            converter = SegmentToPointPen(points, False)
+            contour.replay(converter)
+            # points.value is a list of pt,bool where bool is true if on-curve and false if off-curve;
+            # now check all rotations and mirror-rotations of the contour and build list of isomorphic
+            # possible starting points.
+            self.points.append(points.value)
+
+            isomorphisms = []
+            self.isomorphisms.append(isomorphisms)
+
+            # Add rotations
+            add_isomorphisms(points.value, isomorphisms, False)
+            # Add mirrored rotations
+            add_isomorphisms(points.value, isomorphisms, True)
+
+    def draw(self, pen, countor_idx=None):
+        if countor_idx is None:
+            for contour in self.recordings:
+                contour.draw(pen)
+        else:
+            self.recordings[countor_idx].draw(pen)
+
+
+def test_gen(
+    glyphsets,
+    glyphs=None,
+    names=None,
+    ignore_missing=False,
+    *,
+    locations=None,
+    tolerance=DEFAULT_TOLERANCE,
+    kinkiness=DEFAULT_KINKINESS,
+    upem=DEFAULT_UPEM,
+    show_all=False,
+    discrete_axes=[],
+):
+    if tolerance >= 10:
+        tolerance *= 0.01
+    assert 0 <= tolerance <= 1
+    if kinkiness >= 10:
+        kinkiness *= 0.01
+    assert 0 <= kinkiness
+
+    names = names or [repr(g) for g in glyphsets]
+
+    if glyphs is None:
+        # `glyphs = glyphsets[0].keys()` is faster, certainly, but doesn't allow for sparse TTFs/OTFs given out of order
+        # ... risks the sparse master being the first one, and only processing a subset of the glyphs
+        glyphs = {g for glyphset in glyphsets for g in glyphset.keys()}
+
+    parents, order = find_parents_and_order(
+        glyphsets, locations, discrete_axes=discrete_axes
+    )
+
+    def grand_parent(i, glyphname):
+        if i is None:
+            return None
+        i = parents[i]
+        if i is None:
+            return None
+        while parents[i] is not None and glyphsets[i][glyphname] is None:
+            i = parents[i]
+        return i
+
+    for glyph_name in glyphs:
+        log.info("Testing glyph %s", glyph_name)
+        allGlyphs = [Glyph(glyph_name, glyphset) for glyphset in glyphsets]
+        if len([1 for glyph in allGlyphs if glyph is not None]) <= 1:
+            continue
+        for master_idx, (glyph, glyphset, name) in enumerate(
+            zip(allGlyphs, glyphsets, names)
+        ):
+            if glyph.doesnt_exist:
+                if not ignore_missing:
+                    yield (
+                        glyph_name,
+                        {
+                            "type": InterpolatableProblem.MISSING,
+                            "master": name,
+                            "master_idx": master_idx,
+                        },
+                    )
+                continue
+
+            has_open = False
+            for ix, open in enumerate(glyph.openContours):
+                if not open:
+                    continue
+                has_open = True
+                yield (
+                    glyph_name,
+                    {
+                        "type": InterpolatableProblem.OPEN_PATH,
+                        "master": name,
+                        "master_idx": master_idx,
+                        "contour": ix,
+                    },
+                )
+            if has_open:
+                continue
+
+        matchings = [None] * len(glyphsets)
+
+        for m1idx in order:
+            glyph1 = allGlyphs[m1idx]
+            if glyph1 is None or not glyph1.nodeTypes:
+                continue
+            m0idx = grand_parent(m1idx, glyph_name)
+            if m0idx is None:
+                continue
+            glyph0 = allGlyphs[m0idx]
+            if glyph0 is None or not glyph0.nodeTypes:
+                continue
+
+            #
+            # Basic compatibility checks
+            #
+
+            m1 = glyph0.nodeTypes
+            m0 = glyph1.nodeTypes
+            if len(m0) != len(m1):
+                yield (
+                    glyph_name,
+                    {
+                        "type": InterpolatableProblem.PATH_COUNT,
+                        "master_1": names[m0idx],
+                        "master_2": names[m1idx],
+                        "master_1_idx": m0idx,
+                        "master_2_idx": m1idx,
+                        "value_1": len(m0),
+                        "value_2": len(m1),
+                    },
+                )
+                continue
+
+            if m0 != m1:
+                for pathIx, (nodes1, nodes2) in enumerate(zip(m0, m1)):
+                    if nodes1 == nodes2:
+                        continue
+                    if len(nodes1) != len(nodes2):
+                        yield (
+                            glyph_name,
+                            {
+                                "type": InterpolatableProblem.NODE_COUNT,
+                                "path": pathIx,
+                                "master_1": names[m0idx],
+                                "master_2": names[m1idx],
+                                "master_1_idx": m0idx,
+                                "master_2_idx": m1idx,
+                                "value_1": len(nodes1),
+                                "value_2": len(nodes2),
+                            },
+                        )
+                        continue
+                    for nodeIx, (n1, n2) in enumerate(zip(nodes1, nodes2)):
+                        if n1 != n2:
+                            yield (
+                                glyph_name,
+                                {
+                                    "type": InterpolatableProblem.NODE_INCOMPATIBILITY,
+                                    "path": pathIx,
+                                    "node": nodeIx,
+                                    "master_1": names[m0idx],
+                                    "master_2": names[m1idx],
+                                    "master_1_idx": m0idx,
+                                    "master_2_idx": m1idx,
+                                    "value_1": n1,
+                                    "value_2": n2,
+                                },
+                            )
+                            continue
+
+            #
+            # InterpolatableProblem.CONTOUR_ORDER check
+            #
+
+            this_tolerance, matching = test_contour_order(glyph0, glyph1)
+            if this_tolerance < tolerance:
+                yield (
+                    glyph_name,
+                    {
+                        "type": InterpolatableProblem.CONTOUR_ORDER,
+                        "master_1": names[m0idx],
+                        "master_2": names[m1idx],
+                        "master_1_idx": m0idx,
+                        "master_2_idx": m1idx,
+                        "value_1": list(range(len(matching))),
+                        "value_2": matching,
+                        "tolerance": this_tolerance,
+                    },
+                )
+                matchings[m1idx] = matching
+
+            #
+            # wrong-start-point / weight check
+            #
+
+            m0Isomorphisms = glyph0.isomorphisms
+            m1Isomorphisms = glyph1.isomorphisms
+            m0Vectors = glyph0.greenVectors
+            m1Vectors = glyph1.greenVectors
+            recording0 = glyph0.recordings
+            recording1 = glyph1.recordings
+
+            # If contour-order is wrong, adjust it
+            matching = matchings[m1idx]
+            if (
+                matching is not None and m1Isomorphisms
+            ):  # m1 is empty for composite glyphs
+                m1Isomorphisms = [m1Isomorphisms[i] for i in matching]
+                m1Vectors = [m1Vectors[i] for i in matching]
+                recording1 = [recording1[i] for i in matching]
+
+            midRecording = []
+            for c0, c1 in zip(recording0, recording1):
+                try:
+                    r = RecordingPen()
+                    r.value = list(lerpRecordings(c0.value, c1.value))
+                    midRecording.append(r)
+                except ValueError:
+                    # Mismatch because of the reordering above
+                    midRecording.append(None)
+
+            for ix, (contour0, contour1) in enumerate(
+                zip(m0Isomorphisms, m1Isomorphisms)
+            ):
+                if (
+                    contour0 is None
+                    or contour1 is None
+                    or len(contour0) == 0
+                    or len(contour0) != len(contour1)
+                ):
+                    # We already reported this; or nothing to do; or not compatible
+                    # after reordering above.
+                    continue
+
+                this_tolerance, proposed_point, reverse = test_starting_point(
+                    glyph0, glyph1, ix, tolerance, matching
+                )
+
+                if this_tolerance < tolerance:
+                    yield (
+                        glyph_name,
+                        {
+                            "type": InterpolatableProblem.WRONG_START_POINT,
+                            "contour": ix,
+                            "master_1": names[m0idx],
+                            "master_2": names[m1idx],
+                            "master_1_idx": m0idx,
+                            "master_2_idx": m1idx,
+                            "value_1": 0,
+                            "value_2": proposed_point,
+                            "reversed": reverse,
+                            "tolerance": this_tolerance,
+                        },
+                    )
+
+                # Weight check.
+                #
+                # If contour could be mid-interpolated, and the two
+                # contours have the same area sign, proceeed.
+                #
+                # The sign difference can happen if it's a weirdo
+                # self-intersecting contour; ignore it.
+                contour = midRecording[ix]
+
+                if contour and (m0Vectors[ix][0] < 0) == (m1Vectors[ix][0] < 0):
+                    midStats = StatisticsPen(glyphset=None)
+                    contour.replay(midStats)
+
+                    midVector = contour_vector_from_stats(midStats)
+
+                    m0Vec = m0Vectors[ix]
+                    m1Vec = m1Vectors[ix]
+                    size0 = m0Vec[0] * m0Vec[0]
+                    size1 = m1Vec[0] * m1Vec[0]
+                    midSize = midVector[0] * midVector[0]
+
+                    for overweight, problem_type in enumerate(
+                        (
+                            InterpolatableProblem.UNDERWEIGHT,
+                            InterpolatableProblem.OVERWEIGHT,
+                        )
+                    ):
+                        if overweight:
+                            expectedSize = max(size0, size1)
+                            continue
+                        else:
+                            expectedSize = sqrt(size0 * size1)
+
+                        log.debug(
+                            "%s: actual size %g; threshold size %g, master sizes: %g, %g",
+                            problem_type,
+                            midSize,
+                            expectedSize,
+                            size0,
+                            size1,
+                        )
+
+                        if (
+                            not overweight and expectedSize * tolerance > midSize + 1e-5
+                        ) or (overweight and 1e-5 + expectedSize / tolerance < midSize):
+                            try:
+                                if overweight:
+                                    this_tolerance = expectedSize / midSize
+                                else:
+                                    this_tolerance = midSize / expectedSize
+                            except ZeroDivisionError:
+                                this_tolerance = 0
+                            log.debug("tolerance %g", this_tolerance)
+                            yield (
+                                glyph_name,
+                                {
+                                    "type": problem_type,
+                                    "contour": ix,
+                                    "master_1": names[m0idx],
+                                    "master_2": names[m1idx],
+                                    "master_1_idx": m0idx,
+                                    "master_2_idx": m1idx,
+                                    "tolerance": this_tolerance,
+                                },
+                            )
+
+            #
+            # "kink" detector
+            #
+            m0 = glyph0.points
+            m1 = glyph1.points
+
+            # If contour-order is wrong, adjust it
+            if matchings[m1idx] is not None and m1:  # m1 is empty for composite glyphs
+                m1 = [m1[i] for i in matchings[m1idx]]
+
+            t = 0.1  # ~sin(radian(6)) for tolerance 0.95
+            deviation_threshold = (
+                upem * DEFAULT_KINKINESS_LENGTH * DEFAULT_KINKINESS / kinkiness
+            )
+
+            for ix, (contour0, contour1) in enumerate(zip(m0, m1)):
+                if (
+                    contour0 is None
+                    or contour1 is None
+                    or len(contour0) == 0
+                    or len(contour0) != len(contour1)
+                ):
+                    # We already reported this; or nothing to do; or not compatible
+                    # after reordering above.
+                    continue
+
+                # Walk the contour, keeping track of three consecutive points, with
+                # middle one being an on-curve. If the three are co-linear then
+                # check for kinky-ness.
+                for i in range(len(contour0)):
+                    pt0 = contour0[i]
+                    pt1 = contour1[i]
+                    if not pt0[1] or not pt1[1]:
+                        # Skip off-curves
+                        continue
+                    pt0_prev = contour0[i - 1]
+                    pt1_prev = contour1[i - 1]
+                    pt0_next = contour0[(i + 1) % len(contour0)]
+                    pt1_next = contour1[(i + 1) % len(contour1)]
+
+                    if pt0_prev[1] and pt1_prev[1]:
+                        # At least one off-curve is required
+                        continue
+                    if pt0_prev[1] and pt1_prev[1]:
+                        # At least one off-curve is required
+                        continue
+
+                    pt0 = complex(*pt0[0])
+                    pt1 = complex(*pt1[0])
+                    pt0_prev = complex(*pt0_prev[0])
+                    pt1_prev = complex(*pt1_prev[0])
+                    pt0_next = complex(*pt0_next[0])
+                    pt1_next = complex(*pt1_next[0])
+
+                    # We have three consecutive points. Check whether
+                    # they are colinear.
+                    d0_prev = pt0 - pt0_prev
+                    d0_next = pt0_next - pt0
+                    d1_prev = pt1 - pt1_prev
+                    d1_next = pt1_next - pt1
+
+                    sin0 = d0_prev.real * d0_next.imag - d0_prev.imag * d0_next.real
+                    sin1 = d1_prev.real * d1_next.imag - d1_prev.imag * d1_next.real
+                    try:
+                        sin0 /= abs(d0_prev) * abs(d0_next)
+                        sin1 /= abs(d1_prev) * abs(d1_next)
+                    except ZeroDivisionError:
+                        continue
+
+                    if abs(sin0) > t or abs(sin1) > t:
+                        # Not colinear / not smooth.
+                        continue
+
+                    # Check the mid-point is actually, well, in the middle.
+                    dot0 = d0_prev.real * d0_next.real + d0_prev.imag * d0_next.imag
+                    dot1 = d1_prev.real * d1_next.real + d1_prev.imag * d1_next.imag
+                    if dot0 < 0 or dot1 < 0:
+                        # Sharp corner.
+                        continue
+
+                    # Fine, if handle ratios are similar...
+                    r0 = abs(d0_prev) / (abs(d0_prev) + abs(d0_next))
+                    r1 = abs(d1_prev) / (abs(d1_prev) + abs(d1_next))
+                    r_diff = abs(r0 - r1)
+                    if abs(r_diff) < t:
+                        # Smooth enough.
+                        continue
+
+                    mid = (pt0 + pt1) / 2
+                    mid_prev = (pt0_prev + pt1_prev) / 2
+                    mid_next = (pt0_next + pt1_next) / 2
+
+                    mid_d0 = mid - mid_prev
+                    mid_d1 = mid_next - mid
+
+                    sin_mid = mid_d0.real * mid_d1.imag - mid_d0.imag * mid_d1.real
+                    try:
+                        sin_mid /= abs(mid_d0) * abs(mid_d1)
+                    except ZeroDivisionError:
+                        continue
+
+                    # ...or if the angles are similar.
+                    if abs(sin_mid) * (tolerance * kinkiness) <= t:
+                        # Smooth enough.
+                        continue
+
+                    # How visible is the kink?
+
+                    cross = sin_mid * abs(mid_d0) * abs(mid_d1)
+                    arc_len = abs(mid_d0 + mid_d1)
+                    deviation = abs(cross / arc_len)
+                    if deviation < deviation_threshold:
+                        continue
+                    deviation_ratio = deviation / arc_len
+                    if deviation_ratio > t:
+                        continue
+
+                    this_tolerance = t / (abs(sin_mid) * kinkiness)
+
+                    log.debug(
+                        "kink: deviation %g; deviation_ratio %g; sin_mid %g; r_diff %g",
+                        deviation,
+                        deviation_ratio,
+                        sin_mid,
+                        r_diff,
+                    )
+                    log.debug("tolerance %g", this_tolerance)
+                    yield (
+                        glyph_name,
+                        {
+                            "type": InterpolatableProblem.KINK,
+                            "contour": ix,
+                            "master_1": names[m0idx],
+                            "master_2": names[m1idx],
+                            "master_1_idx": m0idx,
+                            "master_2_idx": m1idx,
+                            "value": i,
+                            "tolerance": this_tolerance,
+                        },
+                    )
+
+            #
+            # --show-all
+            #
+
+            if show_all:
+                yield (
+                    glyph_name,
+                    {
+                        "type": InterpolatableProblem.NOTHING,
+                        "master_1": names[m0idx],
+                        "master_2": names[m1idx],
+                        "master_1_idx": m0idx,
+                        "master_2_idx": m1idx,
+                    },
+                )
+
+
+@wraps(test_gen)
+def test(*args, **kwargs):
+    problems = defaultdict(list)
+    for glyphname, problem in test_gen(*args, **kwargs):
+        problems[glyphname].append(problem)
+    return problems
+
+
+def recursivelyAddGlyph(glyphname, glyphset, ttGlyphSet, glyf):
+    if glyphname in glyphset:
+        return
+    glyphset[glyphname] = ttGlyphSet[glyphname]
+
+    for component in getattr(glyf[glyphname], "components", []):
+        recursivelyAddGlyph(component.glyphName, glyphset, ttGlyphSet, glyf)
+
+
+def ensure_parent_dir(path):
+    dirname = os.path.dirname(path)
+    if dirname:
+        os.makedirs(dirname, exist_ok=True)
+    return path
+
+
+def main(args=None):
+    """Test for interpolatability issues between fonts"""
+    import argparse
+    import sys
+
+    parser = argparse.ArgumentParser(
+        "fonttools varLib.interpolatable",
+        description=main.__doc__,
+    )
+    parser.add_argument(
+        "--glyphs",
+        action="store",
+        help="Space-separate name of glyphs to check",
+    )
+    parser.add_argument(
+        "--show-all",
+        action="store_true",
+        help="Show all glyph pairs, even if no problems are found",
+    )
+    parser.add_argument(
+        "--tolerance",
+        action="store",
+        type=float,
+        help="Error tolerance. Between 0 and 1. Default %s" % DEFAULT_TOLERANCE,
+    )
+    parser.add_argument(
+        "--kinkiness",
+        action="store",
+        type=float,
+        help="How aggressively report kinks. Default %s" % DEFAULT_KINKINESS,
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output report in JSON format",
+    )
+    parser.add_argument(
+        "--pdf",
+        action="store",
+        help="Output report in PDF format",
+    )
+    parser.add_argument(
+        "--ps",
+        action="store",
+        help="Output report in PostScript format",
+    )
+    parser.add_argument(
+        "--html",
+        action="store",
+        help="Output report in HTML format",
+    )
+    parser.add_argument(
+        "--quiet",
+        action="store_true",
+        help="Only exit with code 1 or 0, no output",
+    )
+    parser.add_argument(
+        "--output",
+        action="store",
+        help="Output file for the problem report; Default: stdout",
+    )
+    parser.add_argument(
+        "--ignore-missing",
+        action="store_true",
+        help="Will not report glyphs missing from sparse masters as errors",
+    )
+    parser.add_argument(
+        "inputs",
+        metavar="FILE",
+        type=str,
+        nargs="+",
+        help="Input a single variable font / DesignSpace / Glyphs file, or multiple TTF/UFO files",
+    )
+    parser.add_argument(
+        "--name",
+        metavar="NAME",
+        type=str,
+        action="append",
+        help="Name of the master to use in the report. If not provided, all are used.",
+    )
+    parser.add_argument("-v", "--verbose", action="store_true", help="Run verbosely.")
+    parser.add_argument("--debug", action="store_true", help="Run with debug output.")
+
+    args = parser.parse_args(args)
+
+    from fontTools import configLogger
+
+    configLogger(level=("INFO" if args.verbose else "ERROR"))
+    if args.debug:
+        configLogger(level="DEBUG")
+
+    glyphs = args.glyphs.split() if args.glyphs else None
+
+    from os.path import basename
+
+    fonts = []
+    names = []
+    locations = []
+    discrete_axes = set()
+    upem = DEFAULT_UPEM
+
+    original_args_inputs = tuple(args.inputs)
+
+    if len(args.inputs) == 1:
+        designspace = None
+        if args.inputs[0].endswith(".designspace"):
+            from fontTools.designspaceLib import DesignSpaceDocument
+
+            designspace = DesignSpaceDocument.fromfile(args.inputs[0])
+            args.inputs = [master.path for master in designspace.sources]
+            locations = [master.location for master in designspace.sources]
+            discrete_axes = {
+                a.name for a in designspace.axes if not hasattr(a, "minimum")
+            }
+            axis_triples = {
+                a.name: (a.minimum, a.default, a.maximum)
+                for a in designspace.axes
+                if a.name not in discrete_axes
+            }
+            axis_mappings = {a.name: a.map for a in designspace.axes}
+            axis_triples = {
+                k: tuple(piecewiseLinearMap(v, dict(axis_mappings[k])) for v in vv)
+                for k, vv in axis_triples.items()
+            }
+
+        elif args.inputs[0].endswith((".glyphs", ".glyphspackage")):
+            from glyphsLib import GSFont, to_designspace
+
+            gsfont = GSFont(args.inputs[0])
+            upem = gsfont.upm
+            designspace = to_designspace(gsfont)
+            fonts = [source.font for source in designspace.sources]
+            names = ["%s-%s" % (f.info.familyName, f.info.styleName) for f in fonts]
+            args.inputs = []
+            locations = [master.location for master in designspace.sources]
+            axis_triples = {
+                a.name: (a.minimum, a.default, a.maximum) for a in designspace.axes
+            }
+            axis_mappings = {a.name: a.map for a in designspace.axes}
+            axis_triples = {
+                k: tuple(piecewiseLinearMap(v, dict(axis_mappings[k])) for v in vv)
+                for k, vv in axis_triples.items()
+            }
+
+        elif args.inputs[0].endswith(".ttf"):
+            from fontTools.ttLib import TTFont
+
+            font = TTFont(args.inputs[0])
+            upem = font["head"].unitsPerEm
+            if "gvar" in font:
+                # Is variable font
+
+                fvar = font["fvar"]
+                axisMapping = {}
+                for axis in fvar.axes:
+                    axisMapping[axis.axisTag] = {
+                        -1: axis.minValue,
+                        0: axis.defaultValue,
+                        1: axis.maxValue,
+                    }
+                normalized = False
+                if "avar" in font:
+                    avar = font["avar"]
+                    if getattr(avar.table, "VarStore", None):
+                        axisMapping = {tag: {-1: -1, 0: 0, 1: 1} for tag in axisMapping}
+                        normalized = True
+                    else:
+                        for axisTag, segments in avar.segments.items():
+                            fvarMapping = axisMapping[axisTag].copy()
+                            for location, value in segments.items():
+                                axisMapping[axisTag][value] = piecewiseLinearMap(
+                                    location, fvarMapping
+                                )
+
+                gvar = font["gvar"]
+                glyf = font["glyf"]
+                # Gather all glyphs at their "master" locations
+                ttGlyphSets = {}
+                glyphsets = defaultdict(dict)
+
+                if glyphs is None:
+                    glyphs = sorted(gvar.variations.keys())
+                for glyphname in glyphs:
+                    for var in gvar.variations[glyphname]:
+                        locDict = {}
+                        loc = []
+                        for tag, val in sorted(var.axes.items()):
+                            locDict[tag] = val[1]
+                            loc.append((tag, val[1]))
+
+                        locTuple = tuple(loc)
+                        if locTuple not in ttGlyphSets:
+                            ttGlyphSets[locTuple] = font.getGlyphSet(
+                                location=locDict, normalized=True, recalcBounds=False
+                            )
+
+                        recursivelyAddGlyph(
+                            glyphname, glyphsets[locTuple], ttGlyphSets[locTuple], glyf
+                        )
+
+                names = ["''"]
+                fonts = [font.getGlyphSet()]
+                locations = [{}]
+                axis_triples = {a: (-1, 0, +1) for a in sorted(axisMapping.keys())}
+                for locTuple in sorted(glyphsets.keys(), key=lambda v: (len(v), v)):
+                    name = (
+                        "'"
+                        + " ".join(
+                            "%s=%s"
+                            % (
+                                k,
+                                floatToFixedToStr(
+                                    piecewiseLinearMap(v, axisMapping[k]), 14
+                                ),
+                            )
+                            for k, v in locTuple
+                        )
+                        + "'"
+                    )
+                    if normalized:
+                        name += " (normalized)"
+                    names.append(name)
+                    fonts.append(glyphsets[locTuple])
+                    locations.append(dict(locTuple))
+                args.ignore_missing = True
+                args.inputs = []
+
+    if not locations:
+        locations = [{} for _ in fonts]
+
+    for filename in args.inputs:
+        if filename.endswith(".ufo"):
+            from fontTools.ufoLib import UFOReader
+
+            font = UFOReader(filename)
+            info = SimpleNamespace()
+            font.readInfo(info)
+            upem = info.unitsPerEm
+            fonts.append(font)
+        else:
+            from fontTools.ttLib import TTFont
+
+            font = TTFont(filename)
+            upem = font["head"].unitsPerEm
+            fonts.append(font)
+
+        names.append(basename(filename).rsplit(".", 1)[0])
+
+    glyphsets = []
+    for font in fonts:
+        if hasattr(font, "getGlyphSet"):
+            glyphset = font.getGlyphSet()
+        else:
+            glyphset = font
+        glyphsets.append({k: glyphset[k] for k in glyphset.keys()})
+
+    if args.name:
+        accepted_names = set(args.name)
+        glyphsets = [
+            glyphset
+            for name, glyphset in zip(names, glyphsets)
+            if name in accepted_names
+        ]
+        locations = [
+            location
+            for name, location in zip(names, locations)
+            if name in accepted_names
+        ]
+        names = [name for name in names if name in accepted_names]
+
+    if not glyphs:
+        glyphs = sorted(set([gn for glyphset in glyphsets for gn in glyphset.keys()]))
+
+    glyphsSet = set(glyphs)
+    for glyphset in glyphsets:
+        glyphSetGlyphNames = set(glyphset.keys())
+        diff = glyphsSet - glyphSetGlyphNames
+        if diff:
+            for gn in diff:
+                glyphset[gn] = None
+
+    # Normalize locations
+    locations = [
+        {
+            **normalizeLocation(loc, axis_triples),
+            **{k: v for k, v in loc.items() if k in discrete_axes},
+        }
+        for loc in locations
+    ]
+    tolerance = args.tolerance or DEFAULT_TOLERANCE
+    kinkiness = args.kinkiness if args.kinkiness is not None else DEFAULT_KINKINESS
+
+    try:
+        log.info("Running on %d glyphsets", len(glyphsets))
+        log.info("Locations: %s", pformat(locations))
+        problems_gen = test_gen(
+            glyphsets,
+            glyphs=glyphs,
+            names=names,
+            locations=locations,
+            upem=upem,
+            ignore_missing=args.ignore_missing,
+            tolerance=tolerance,
+            kinkiness=kinkiness,
+            show_all=args.show_all,
+            discrete_axes=discrete_axes,
+        )
+        problems = defaultdict(list)
+
+        f = (
+            sys.stdout
+            if args.output is None
+            else open(ensure_parent_dir(args.output), "w")
+        )
+
+        if not args.quiet:
+            if args.json:
+                import json
+
+                for glyphname, problem in problems_gen:
+                    problems[glyphname].append(problem)
+
+                print(json.dumps(problems), file=f)
+            else:
+                last_glyphname = None
+                for glyphname, p in problems_gen:
+                    problems[glyphname].append(p)
+
+                    if glyphname != last_glyphname:
+                        print(f"Glyph {glyphname} was not compatible:", file=f)
+                        last_glyphname = glyphname
+                        last_master_idxs = None
+
+                    master_idxs = (
+                        (p["master_idx"],)
+                        if "master_idx" in p
+                        else (p["master_1_idx"], p["master_2_idx"])
+                    )
+                    if master_idxs != last_master_idxs:
+                        master_names = (
+                            (p["master"],)
+                            if "master" in p
+                            else (p["master_1"], p["master_2"])
+                        )
+                        print(f"  Masters: %s:" % ", ".join(master_names), file=f)
+                        last_master_idxs = master_idxs
+
+                    if p["type"] == InterpolatableProblem.MISSING:
+                        print(
+                            "    Glyph was missing in master %s" % p["master"], file=f
+                        )
+                    elif p["type"] == InterpolatableProblem.OPEN_PATH:
+                        print(
+                            "    Glyph has an open path in master %s" % p["master"],
+                            file=f,
+                        )
+                    elif p["type"] == InterpolatableProblem.PATH_COUNT:
+                        print(
+                            "    Path count differs: %i in %s, %i in %s"
+                            % (
+                                p["value_1"],
+                                p["master_1"],
+                                p["value_2"],
+                                p["master_2"],
+                            ),
+                            file=f,
+                        )
+                    elif p["type"] == InterpolatableProblem.NODE_COUNT:
+                        print(
+                            "    Node count differs in path %i: %i in %s, %i in %s"
+                            % (
+                                p["path"],
+                                p["value_1"],
+                                p["master_1"],
+                                p["value_2"],
+                                p["master_2"],
+                            ),
+                            file=f,
+                        )
+                    elif p["type"] == InterpolatableProblem.NODE_INCOMPATIBILITY:
+                        print(
+                            "    Node %o incompatible in path %i: %s in %s, %s in %s"
+                            % (
+                                p["node"],
+                                p["path"],
+                                p["value_1"],
+                                p["master_1"],
+                                p["value_2"],
+                                p["master_2"],
+                            ),
+                            file=f,
+                        )
+                    elif p["type"] == InterpolatableProblem.CONTOUR_ORDER:
+                        print(
+                            "    Contour order differs: %s in %s, %s in %s"
+                            % (
+                                p["value_1"],
+                                p["master_1"],
+                                p["value_2"],
+                                p["master_2"],
+                            ),
+                            file=f,
+                        )
+                    elif p["type"] == InterpolatableProblem.WRONG_START_POINT:
+                        print(
+                            "    Contour %d start point differs: %s in %s, %s in %s; reversed: %s"
+                            % (
+                                p["contour"],
+                                p["value_1"],
+                                p["master_1"],
+                                p["value_2"],
+                                p["master_2"],
+                                p["reversed"],
+                            ),
+                            file=f,
+                        )
+                    elif p["type"] == InterpolatableProblem.UNDERWEIGHT:
+                        print(
+                            "    Contour %d interpolation is underweight: %s, %s"
+                            % (
+                                p["contour"],
+                                p["master_1"],
+                                p["master_2"],
+                            ),
+                            file=f,
+                        )
+                    elif p["type"] == InterpolatableProblem.OVERWEIGHT:
+                        print(
+                            "    Contour %d interpolation is overweight: %s, %s"
+                            % (
+                                p["contour"],
+                                p["master_1"],
+                                p["master_2"],
+                            ),
+                            file=f,
+                        )
+                    elif p["type"] == InterpolatableProblem.KINK:
+                        print(
+                            "    Contour %d has a kink at %s: %s, %s"
+                            % (
+                                p["contour"],
+                                p["value"],
+                                p["master_1"],
+                                p["master_2"],
+                            ),
+                            file=f,
+                        )
+                    elif p["type"] == InterpolatableProblem.NOTHING:
+                        print(
+                            "    Showing %s and %s"
+                            % (
+                                p["master_1"],
+                                p["master_2"],
+                            ),
+                            file=f,
+                        )
+        else:
+            for glyphname, problem in problems_gen:
+                problems[glyphname].append(problem)
+
+        problems = sort_problems(problems)
+
+        for p in "ps", "pdf":
+            arg = getattr(args, p)
+            if arg is None:
+                continue
+            log.info("Writing %s to %s", p.upper(), arg)
+            from .interpolatablePlot import InterpolatablePS, InterpolatablePDF
+
+            PlotterClass = InterpolatablePS if p == "ps" else InterpolatablePDF
+
+            with PlotterClass(
+                ensure_parent_dir(arg), glyphsets=glyphsets, names=names
+            ) as doc:
+                doc.add_title_page(
+                    original_args_inputs, tolerance=tolerance, kinkiness=kinkiness
+                )
+                if problems:
+                    doc.add_summary(problems)
+                doc.add_problems(problems)
+                if not problems and not args.quiet:
+                    doc.draw_cupcake()
+                if problems:
+                    doc.add_index()
+                    doc.add_table_of_contents()
+
+        if args.html:
+            log.info("Writing HTML to %s", args.html)
+            from .interpolatablePlot import InterpolatableSVG
+
+            svgs = []
+            glyph_starts = {}
+            with InterpolatableSVG(svgs, glyphsets=glyphsets, names=names) as svg:
+                svg.add_title_page(
+                    original_args_inputs,
+                    show_tolerance=False,
+                    tolerance=tolerance,
+                    kinkiness=kinkiness,
+                )
+                for glyph, glyph_problems in problems.items():
+                    glyph_starts[len(svgs)] = glyph
+                    svg.add_problems(
+                        {glyph: glyph_problems},
+                        show_tolerance=False,
+                        show_page_number=False,
+                    )
+                if not problems and not args.quiet:
+                    svg.draw_cupcake()
+
+            import base64
+
+            with open(ensure_parent_dir(args.html), "wb") as f:
+                f.write(b"<!DOCTYPE html>\n")
+                f.write(
+                    b'<html><body align="center" style="font-family: sans-serif; text-color: #222">\n'
+                )
+                f.write(b"<title>fonttools varLib.interpolatable report</title>\n")
+                for i, svg in enumerate(svgs):
+                    if i in glyph_starts:
+                        f.write(f"<h1>Glyph {glyph_starts[i]}</h1>\n".encode("utf-8"))
+                    f.write("<img src='data:image/svg+xml;base64,".encode("utf-8"))
+                    f.write(base64.b64encode(svg))
+                    f.write(b"' />\n")
+                    f.write(b"<hr>\n")
+                f.write(b"</body></html>\n")
+
+    except Exception as e:
+        e.args += original_args_inputs
+        log.error(e)
+        raise
+
+    if problems:
+        return problems
+
+
+if __name__ == "__main__":
+    import sys
+
+    problems = main()
+    sys.exit(int(bool(problems)))

evalkit_tf437/lib/python3.10/site-packages/fontTools/varLib/interpolatableHelpers.py

@@ -0,0 +1,396 @@
+from fontTools.ttLib.ttGlyphSet import LerpGlyphSet
+from fontTools.pens.basePen import AbstractPen, BasePen, DecomposingPen
+from fontTools.pens.pointPen import AbstractPointPen, SegmentToPointPen
+from fontTools.pens.recordingPen import RecordingPen, DecomposingRecordingPen
+from fontTools.misc.transform import Transform
+from collections import defaultdict, deque
+from math import sqrt, copysign, atan2, pi
+from enum import Enum
+import itertools
+
+import logging
+
+log = logging.getLogger("fontTools.varLib.interpolatable")
+
+
+class InterpolatableProblem:
+    NOTHING = "nothing"
+    MISSING = "missing"
+    OPEN_PATH = "open_path"
+    PATH_COUNT = "path_count"
+    NODE_COUNT = "node_count"
+    NODE_INCOMPATIBILITY = "node_incompatibility"
+    CONTOUR_ORDER = "contour_order"
+    WRONG_START_POINT = "wrong_start_point"
+    KINK = "kink"
+    UNDERWEIGHT = "underweight"
+    OVERWEIGHT = "overweight"
+
+    severity = {
+        MISSING: 1,
+        OPEN_PATH: 2,
+        PATH_COUNT: 3,
+        NODE_COUNT: 4,
+        NODE_INCOMPATIBILITY: 5,
+        CONTOUR_ORDER: 6,
+        WRONG_START_POINT: 7,
+        KINK: 8,
+        UNDERWEIGHT: 9,
+        OVERWEIGHT: 10,
+        NOTHING: 11,
+    }
+
+
+def sort_problems(problems):
+    """Sort problems by severity, then by glyph name, then by problem message."""
+    return dict(
+        sorted(
+            problems.items(),
+            key=lambda _: -min(
+                (
+                    (InterpolatableProblem.severity[p["type"]] + p.get("tolerance", 0))
+                    for p in _[1]
+                ),
+            ),
+            reverse=True,
+        )
+    )
+
+
+def rot_list(l, k):
+    """Rotate list by k items forward.  Ie. item at position 0 will be
+    at position k in returned list.  Negative k is allowed."""
+    return l[-k:] + l[:-k]
+
+
+class PerContourPen(BasePen):
+    def __init__(self, Pen, glyphset=None):
+        BasePen.__init__(self, glyphset)
+        self._glyphset = glyphset
+        self._Pen = Pen
+        self._pen = None
+        self.value = []
+
+    def _moveTo(self, p0):
+        self._newItem()
+        self._pen.moveTo(p0)
+
+    def _lineTo(self, p1):
+        self._pen.lineTo(p1)
+
+    def _qCurveToOne(self, p1, p2):
+        self._pen.qCurveTo(p1, p2)
+
+    def _curveToOne(self, p1, p2, p3):
+        self._pen.curveTo(p1, p2, p3)
+
+    def _closePath(self):
+        self._pen.closePath()
+        self._pen = None
+
+    def _endPath(self):
+        self._pen.endPath()
+        self._pen = None
+
+    def _newItem(self):
+        self._pen = pen = self._Pen()
+        self.value.append(pen)
+
+
+class PerContourOrComponentPen(PerContourPen):
+    def addComponent(self, glyphName, transformation):
+        self._newItem()
+        self.value[-1].addComponent(glyphName, transformation)
+
+
+class SimpleRecordingPointPen(AbstractPointPen):
+    def __init__(self):
+        self.value = []
+
+    def beginPath(self, identifier=None, **kwargs):
+        pass
+
+    def endPath(self) -> None:
+        pass
+
+    def addPoint(self, pt, segmentType=None):
+        self.value.append((pt, False if segmentType is None else True))
+
+
+def vdiff_hypot2(v0, v1):
+    s = 0
+    for x0, x1 in zip(v0, v1):
+        d = x1 - x0
+        s += d * d
+    return s
+
+
+def vdiff_hypot2_complex(v0, v1):
+    s = 0
+    for x0, x1 in zip(v0, v1):
+        d = x1 - x0
+        s += d.real * d.real + d.imag * d.imag
+        # This does the same but seems to be slower:
+        # s += (d * d.conjugate()).real
+    return s
+
+
+def matching_cost(G, matching):
+    return sum(G[i][j] for i, j in enumerate(matching))
+
+
+def min_cost_perfect_bipartite_matching_scipy(G):
+    n = len(G)
+    rows, cols = linear_sum_assignment(G)
+    assert (rows == list(range(n))).all()
+    # Convert numpy array and integer to Python types,
+    # to ensure that this is JSON-serializable.
+    cols = list(int(e) for e in cols)
+    return list(cols), matching_cost(G, cols)
+
+
+def min_cost_perfect_bipartite_matching_munkres(G):
+    n = len(G)
+    cols = [None] * n
+    for row, col in Munkres().compute(G):
+        cols[row] = col
+    return cols, matching_cost(G, cols)
+
+
+def min_cost_perfect_bipartite_matching_bruteforce(G):
+    n = len(G)
+
+    if n > 6:
+        raise Exception("Install Python module 'munkres' or 'scipy >= 0.17.0'")
+
+    # Otherwise just brute-force
+    permutations = itertools.permutations(range(n))
+    best = list(next(permutations))
+    best_cost = matching_cost(G, best)
+    for p in permutations:
+        cost = matching_cost(G, p)
+        if cost < best_cost:
+            best, best_cost = list(p), cost
+    return best, best_cost
+
+
+try:
+    from scipy.optimize import linear_sum_assignment
+
+    min_cost_perfect_bipartite_matching = min_cost_perfect_bipartite_matching_scipy
+except ImportError:
+    try:
+        from munkres import Munkres
+
+        min_cost_perfect_bipartite_matching = (
+            min_cost_perfect_bipartite_matching_munkres
+        )
+    except ImportError:
+        min_cost_perfect_bipartite_matching = (
+            min_cost_perfect_bipartite_matching_bruteforce
+        )
+
+
+def contour_vector_from_stats(stats):
+    # Don't change the order of items here.
+    # It's okay to add to the end, but otherwise, other
+    # code depends on it. Search for "covariance".
+    size = sqrt(abs(stats.area))
+    return (
+        copysign((size), stats.area),
+        stats.meanX,
+        stats.meanY,
+        stats.stddevX * 2,
+        stats.stddevY * 2,
+        stats.correlation * size,
+    )
+
+
+def matching_for_vectors(m0, m1):
+    n = len(m0)
+
+    identity_matching = list(range(n))
+
+    costs = [[vdiff_hypot2(v0, v1) for v1 in m1] for v0 in m0]
+    (
+        matching,
+        matching_cost,
+    ) = min_cost_perfect_bipartite_matching(costs)
+    identity_cost = sum(costs[i][i] for i in range(n))
+    return matching, matching_cost, identity_cost
+
+
+def points_characteristic_bits(points):
+    bits = 0
+    for pt, b in reversed(points):
+        bits = (bits << 1) | b
+    return bits
+
+
+_NUM_ITEMS_PER_POINTS_COMPLEX_VECTOR = 4
+
+
+def points_complex_vector(points):
+    vector = []
+    if not points:
+        return vector
+    points = [complex(*pt) for pt, _ in points]
+    n = len(points)
+    assert _NUM_ITEMS_PER_POINTS_COMPLEX_VECTOR == 4
+    points.extend(points[: _NUM_ITEMS_PER_POINTS_COMPLEX_VECTOR - 1])
+    while len(points) < _NUM_ITEMS_PER_POINTS_COMPLEX_VECTOR:
+        points.extend(points[: _NUM_ITEMS_PER_POINTS_COMPLEX_VECTOR - 1])
+    for i in range(n):
+        # The weights are magic numbers.
+
+        # The point itself
+        p0 = points[i]
+        vector.append(p0)
+
+        # The vector to the next point
+        p1 = points[i + 1]
+        d0 = p1 - p0
+        vector.append(d0 * 3)
+
+        # The turn vector
+        p2 = points[i + 2]
+        d1 = p2 - p1
+        vector.append(d1 - d0)
+
+        # The angle to the next point, as a cross product;
+        # Square root of, to match dimentionality of distance.
+        cross = d0.real * d1.imag - d0.imag * d1.real
+        cross = copysign(sqrt(abs(cross)), cross)
+        vector.append(cross * 4)
+
+    return vector
+
+
+def add_isomorphisms(points, isomorphisms, reverse):
+    reference_bits = points_characteristic_bits(points)
+    n = len(points)
+
+    # if points[0][0] == points[-1][0]:
+    #   abort
+
+    if reverse:
+        points = points[::-1]
+        bits = points_characteristic_bits(points)
+    else:
+        bits = reference_bits
+
+    vector = points_complex_vector(points)
+
+    assert len(vector) % n == 0
+    mult = len(vector) // n
+    mask = (1 << n) - 1
+
+    for i in range(n):
+        b = ((bits << (n - i)) & mask) | (bits >> i)
+        if b == reference_bits:
+            isomorphisms.append(
+                (rot_list(vector, -i * mult), n - 1 - i if reverse else i, reverse)
+            )
+
+
+def find_parents_and_order(glyphsets, locations, *, discrete_axes=set()):
+    parents = [None] + list(range(len(glyphsets) - 1))
+    order = list(range(len(glyphsets)))
+    if locations:
+        # Order base master first
+        bases = [
+            i
+            for i, l in enumerate(locations)
+            if all(v == 0 for k, v in l.items() if k not in discrete_axes)
+        ]
+        if bases:
+            logging.info("Found %s base masters: %s", len(bases), bases)
+        else:
+            logging.warning("No base master location found")
+
+        # Form a minimum spanning tree of the locations
+        try:
+            from scipy.sparse.csgraph import minimum_spanning_tree
+
+            graph = [[0] * len(locations) for _ in range(len(locations))]
+            axes = set()
+            for l in locations:
+                axes.update(l.keys())
+            axes = sorted(axes)
+            vectors = [tuple(l.get(k, 0) for k in axes) for l in locations]
+            for i, j in itertools.combinations(range(len(locations)), 2):
+                i_discrete_location = {
+                    k: v for k, v in zip(axes, vectors[i]) if k in discrete_axes
+                }
+                j_discrete_location = {
+                    k: v for k, v in zip(axes, vectors[j]) if k in discrete_axes
+                }
+                if i_discrete_location != j_discrete_location:
+                    continue
+                graph[i][j] = vdiff_hypot2(vectors[i], vectors[j])
+
+            tree = minimum_spanning_tree(graph, overwrite=True)
+            rows, cols = tree.nonzero()
+            graph = defaultdict(set)
+            for row, col in zip(rows, cols):
+                graph[row].add(col)
+                graph[col].add(row)
+
+            # Traverse graph from the base and assign parents
+            parents = [None] * len(locations)
+            order = []
+            visited = set()
+            queue = deque(bases)
+            while queue:
+                i = queue.popleft()
+                visited.add(i)
+                order.append(i)
+                for j in sorted(graph[i]):
+                    if j not in visited:
+                        parents[j] = i
+                        queue.append(j)
+            assert len(order) == len(
+                parents
+            ), "Not all masters are reachable; report an issue"
+
+        except ImportError:
+            pass
+
+        log.info("Parents: %s", parents)
+        log.info("Order: %s", order)
+    return parents, order
+
+
+def transform_from_stats(stats, inverse=False):
+    # https://cookierobotics.com/007/
+    a = stats.varianceX
+    b = stats.covariance
+    c = stats.varianceY
+
+    delta = (((a - c) * 0.5) ** 2 + b * b) ** 0.5
+    lambda1 = (a + c) * 0.5 + delta  # Major eigenvalue
+    lambda2 = (a + c) * 0.5 - delta  # Minor eigenvalue
+    theta = atan2(lambda1 - a, b) if b != 0 else (pi * 0.5 if a < c else 0)
+    trans = Transform()
+
+    if lambda2 < 0:
+        # XXX This is a hack.
+        # The problem is that the covariance matrix is singular.
+        # This happens when the contour is a line, or a circle.
+        # In that case, the covariance matrix is not a good
+        # representation of the contour.
+        # We should probably detect this earlier and avoid
+        # computing the covariance matrix in the first place.
+        # But for now, we just avoid the division by zero.
+        lambda2 = 0
+
+    if inverse:
+        trans = trans.translate(-stats.meanX, -stats.meanY)
+        trans = trans.rotate(-theta)
+        trans = trans.scale(1 / sqrt(lambda1), 1 / sqrt(lambda2))
+    else:
+        trans = trans.scale(sqrt(lambda1), sqrt(lambda2))
+        trans = trans.rotate(theta)
+        trans = trans.translate(stats.meanX, stats.meanY)
+
+    return trans

evalkit_tf437/lib/python3.10/site-packages/fontTools/varLib/interpolatablePlot.py

@@ -0,0 +1,1269 @@
+from .interpolatableHelpers import *
+from fontTools.ttLib import TTFont
+from fontTools.ttLib.ttGlyphSet import LerpGlyphSet
+from fontTools.pens.recordingPen import (
+    RecordingPen,
+    DecomposingRecordingPen,
+    RecordingPointPen,
+)
+from fontTools.pens.boundsPen import ControlBoundsPen
+from fontTools.pens.cairoPen import CairoPen
+from fontTools.pens.pointPen import (
+    SegmentToPointPen,
+    PointToSegmentPen,
+    ReverseContourPointPen,
+)
+from fontTools.varLib.interpolatableHelpers import (
+    PerContourOrComponentPen,
+    SimpleRecordingPointPen,
+)
+from itertools import cycle
+from functools import wraps
+from io import BytesIO
+import cairo
+import math
+import os
+import logging
+
+log = logging.getLogger("fontTools.varLib.interpolatable")
+
+
+class OverridingDict(dict):
+    def __init__(self, parent_dict):
+        self.parent_dict = parent_dict
+
+    def __missing__(self, key):
+        return self.parent_dict[key]
+
+
+class InterpolatablePlot:
+    width = 8.5 * 72
+    height = 11 * 72
+    pad = 0.1 * 72
+    title_font_size = 24
+    font_size = 16
+    page_number = 1
+    head_color = (0.3, 0.3, 0.3)
+    label_color = (0.2, 0.2, 0.2)
+    border_color = (0.9, 0.9, 0.9)
+    border_width = 0.5
+    fill_color = (0.8, 0.8, 0.8)
+    stroke_color = (0.1, 0.1, 0.1)
+    stroke_width = 1
+    oncurve_node_color = (0, 0.8, 0, 0.7)
+    oncurve_node_diameter = 6
+    offcurve_node_color = (0, 0.5, 0, 0.7)
+    offcurve_node_diameter = 4
+    handle_color = (0, 0.5, 0, 0.7)
+    handle_width = 0.5
+    corrected_start_point_color = (0, 0.9, 0, 0.7)
+    corrected_start_point_size = 7
+    wrong_start_point_color = (1, 0, 0, 0.7)
+    start_point_color = (0, 0, 1, 0.7)
+    start_arrow_length = 9
+    kink_point_size = 7
+    kink_point_color = (1, 0, 1, 0.7)
+    kink_circle_size = 15
+    kink_circle_stroke_width = 1
+    kink_circle_color = (1, 0, 1, 0.7)
+    contour_colors = ((1, 0, 0), (0, 0, 1), (0, 1, 0), (1, 1, 0), (1, 0, 1), (0, 1, 1))
+    contour_alpha = 0.5
+    weight_issue_contour_color = (0, 0, 0, 0.4)
+    no_issues_label = "Your font's good! Have a cupcake..."
+    no_issues_label_color = (0, 0.5, 0)
+    cupcake_color = (0.3, 0, 0.3)
+    cupcake = r"""
+                          ,@.
+                        ,@.@@,.
+                  ,@@,.@@@.  @.@@@,.
+                ,@@. @@@.     @@. @@,.
+        ,@@@.@,.@.              @.  @@@@,.@.@@,.
+   ,@@.@.     @@.@@.            @,.    .@' @'  @@,
+ ,@@. @.          .@@.@@@.  @@'                  @,
+,@.  @@.                                          @,
+@.     @,@@,.     ,                             .@@,
+@,.       .@,@@,.         .@@,.  ,       .@@,  @, @,
+@.                             .@. @ @@,.    ,      @
+ @,.@@.     @,.      @@,.      @.           @,.    @'
+  @@||@,.  @'@,.       @@,.  @@ @,.        @'@@,  @'
+     \\@@@@'  @,.      @'@@@@'   @@,.   @@@' //@@@'
+      |||||||| @@,.  @@' |||||||  |@@@|@||  ||
+       \\\\\\\  ||@@@||  |||||||  |||||||  //
+        |||||||  ||||||  ||||||   ||||||  ||
+         \\\\\\  ||||||  ||||||  ||||||  //
+          ||||||  |||||  |||||   |||||  ||
+           \\\\\  |||||  |||||  |||||  //
+            |||||  ||||  |||||  ||||  ||
+             \\\\  ||||  ||||  ||||  //
+              ||||||||||||||||||||||||
+"""
+    emoticon_color = (0, 0.3, 0.3)
+    shrug = r"""\_(")_/"""
+    underweight = r"""
+ o
+/|\
+/ \
+"""
+    overweight = r"""
+ o
+/O\
+/ \
+"""
+    yay = r""" \o/ """
+
+    def __init__(self, out, glyphsets, names=None, **kwargs):
+        self.out = out
+        self.glyphsets = glyphsets
+        self.names = names or [repr(g) for g in glyphsets]
+        self.toc = {}
+
+        for k, v in kwargs.items():
+            if not hasattr(self, k):
+                raise TypeError("Unknown keyword argument: %s" % k)
+            setattr(self, k, v)
+
+        self.panel_width = self.width / 2 - self.pad * 3
+        self.panel_height = (
+            self.height / 2 - self.pad * 6 - self.font_size * 2 - self.title_font_size
+        )
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, type, value, traceback):
+        pass
+
+    def show_page(self):
+        self.page_number += 1
+
+    def add_title_page(
+        self, files, *, show_tolerance=True, tolerance=None, kinkiness=None
+    ):
+        pad = self.pad
+        width = self.width - 3 * self.pad
+        height = self.height - 2 * self.pad
+        x = y = pad
+
+        self.draw_label(
+            "Problem report for:",
+            x=x,
+            y=y,
+            bold=True,
+            width=width,
+            font_size=self.title_font_size,
+        )
+        y += self.title_font_size
+
+        import hashlib
+
+        for file in files:
+            base_file = os.path.basename(file)
+            y += self.font_size + self.pad
+            self.draw_label(base_file, x=x, y=y, bold=True, width=width)
+            y += self.font_size + self.pad
+
+            try:
+                h = hashlib.sha1(open(file, "rb").read()).hexdigest()
+                self.draw_label("sha1: %s" % h, x=x + pad, y=y, width=width)
+                y += self.font_size
+            except IsADirectoryError:
+                pass
+
+            if file.endswith(".ttf"):
+                ttFont = TTFont(file)
+                name = ttFont["name"] if "name" in ttFont else None
+                if name:
+                    for what, nameIDs in (
+                        ("Family name", (21, 16, 1)),
+                        ("Version", (5,)),
+                    ):
+                        n = name.getFirstDebugName(nameIDs)
+                        if n is None:
+                            continue
+                        self.draw_label(
+                            "%s: %s" % (what, n), x=x + pad, y=y, width=width
+                        )
+                        y += self.font_size + self.pad
+            elif file.endswith((".glyphs", ".glyphspackage")):
+                from glyphsLib import GSFont
+
+                f = GSFont(file)
+                for what, field in (
+                    ("Family name", "familyName"),
+                    ("VersionMajor", "versionMajor"),
+                    ("VersionMinor", "_versionMinor"),
+                ):
+                    self.draw_label(
+                        "%s: %s" % (what, getattr(f, field)),
+                        x=x + pad,
+                        y=y,
+                        width=width,
+                    )
+                    y += self.font_size + self.pad
+
+        self.draw_legend(
+            show_tolerance=show_tolerance, tolerance=tolerance, kinkiness=kinkiness
+        )
+        self.show_page()
+
+    def draw_legend(self, *, show_tolerance=True, tolerance=None, kinkiness=None):
+        cr = cairo.Context(self.surface)
+
+        x = self.pad
+        y = self.height - self.pad - self.font_size * 2
+        width = self.width - 2 * self.pad
+
+        xx = x + self.pad * 2
+        xxx = x + self.pad * 4
+
+        if show_tolerance:
+            self.draw_label(
+                "Tolerance: badness; closer to zero the worse", x=xxx, y=y, width=width
+            )
+            y -= self.pad + self.font_size
+
+        self.draw_label("Underweight contours", x=xxx, y=y, width=width)
+        cr.rectangle(xx - self.pad * 0.7, y, 1.5 * self.pad, self.font_size)
+        cr.set_source_rgb(*self.fill_color)
+        cr.fill_preserve()
+        if self.stroke_color:
+            cr.set_source_rgb(*self.stroke_color)
+            cr.set_line_width(self.stroke_width)
+            cr.stroke_preserve()
+        cr.set_source_rgba(*self.weight_issue_contour_color)
+        cr.fill()
+        y -= self.pad + self.font_size
+
+        self.draw_label(
+            "Colored contours: contours with the wrong order", x=xxx, y=y, width=width
+        )
+        cr.rectangle(xx - self.pad * 0.7, y, 1.5 * self.pad, self.font_size)
+        if self.fill_color:
+            cr.set_source_rgb(*self.fill_color)
+            cr.fill_preserve()
+        if self.stroke_color:
+            cr.set_source_rgb(*self.stroke_color)
+            cr.set_line_width(self.stroke_width)
+            cr.stroke_preserve()
+        cr.set_source_rgba(*self.contour_colors[0], self.contour_alpha)
+        cr.fill()
+        y -= self.pad + self.font_size
+
+        self.draw_label("Kink artifact", x=xxx, y=y, width=width)
+        self.draw_circle(
+            cr,
+            x=xx,
+            y=y + self.font_size * 0.5,
+            diameter=self.kink_circle_size,
+            stroke_width=self.kink_circle_stroke_width,
+            color=self.kink_circle_color,
+        )
+        y -= self.pad + self.font_size
+
+        self.draw_label("Point causing kink in the contour", x=xxx, y=y, width=width)
+        self.draw_dot(
+            cr,
+            x=xx,
+            y=y + self.font_size * 0.5,
+            diameter=self.kink_point_size,
+            color=self.kink_point_color,
+        )
+        y -= self.pad + self.font_size
+
+        self.draw_label("Suggested new contour start point", x=xxx, y=y, width=width)
+        self.draw_dot(
+            cr,
+            x=xx,
+            y=y + self.font_size * 0.5,
+            diameter=self.corrected_start_point_size,
+            color=self.corrected_start_point_color,
+        )
+        y -= self.pad + self.font_size
+
+        self.draw_label(
+            "Contour start point in contours with wrong direction",
+            x=xxx,
+            y=y,
+            width=width,
+        )
+        self.draw_arrow(
+            cr,
+            x=xx - self.start_arrow_length * 0.3,
+            y=y + self.font_size * 0.5,
+            color=self.wrong_start_point_color,
+        )
+        y -= self.pad + self.font_size
+
+        self.draw_label(
+            "Contour start point when the first two points overlap",
+            x=xxx,
+            y=y,
+            width=width,
+        )
+        self.draw_dot(
+            cr,
+            x=xx,
+            y=y + self.font_size * 0.5,
+            diameter=self.corrected_start_point_size,
+            color=self.start_point_color,
+        )
+        y -= self.pad + self.font_size
+
+        self.draw_label("Contour start point and direction", x=xxx, y=y, width=width)
+        self.draw_arrow(
+            cr,
+            x=xx - self.start_arrow_length * 0.3,
+            y=y + self.font_size * 0.5,
+            color=self.start_point_color,
+        )
+        y -= self.pad + self.font_size
+
+        self.draw_label("Legend:", x=x, y=y, width=width, bold=True)
+        y -= self.pad + self.font_size
+
+        if kinkiness is not None:
+            self.draw_label(
+                "Kink-reporting aggressiveness: %g" % kinkiness,
+                x=xxx,
+                y=y,
+                width=width,
+            )
+            y -= self.pad + self.font_size
+
+        if tolerance is not None:
+            self.draw_label(
+                "Error tolerance: %g" % tolerance,
+                x=xxx,
+                y=y,
+                width=width,
+            )
+            y -= self.pad + self.font_size
+
+        self.draw_label("Parameters:", x=x, y=y, width=width, bold=True)
+        y -= self.pad + self.font_size
+
+    def add_summary(self, problems):
+        pad = self.pad
+        width = self.width - 3 * self.pad
+        height = self.height - 2 * self.pad
+        x = y = pad
+
+        self.draw_label(
+            "Summary of problems",
+            x=x,
+            y=y,
+            bold=True,
+            width=width,
+            font_size=self.title_font_size,
+        )
+        y += self.title_font_size
+
+        glyphs_per_problem = defaultdict(set)
+        for glyphname, problems in sorted(problems.items()):
+            for problem in problems:
+                glyphs_per_problem[problem["type"]].add(glyphname)
+
+        if "nothing" in glyphs_per_problem:
+            del glyphs_per_problem["nothing"]
+
+        for problem_type in sorted(
+            glyphs_per_problem, key=lambda x: InterpolatableProblem.severity[x]
+        ):
+            y += self.font_size
+            self.draw_label(
+                "%s: %d" % (problem_type, len(glyphs_per_problem[problem_type])),
+                x=x,
+                y=y,
+                width=width,
+                bold=True,
+            )
+            y += self.font_size
+
+            for glyphname in sorted(glyphs_per_problem[problem_type]):
+                if y + self.font_size > height:
+                    self.show_page()
+                    y = self.font_size + pad
+                self.draw_label(glyphname, x=x + 2 * pad, y=y, width=width - 2 * pad)
+                y += self.font_size
+
+        self.show_page()
+
+    def _add_listing(self, title, items):
+        pad = self.pad
+        width = self.width - 2 * self.pad
+        height = self.height - 2 * self.pad
+        x = y = pad
+
+        self.draw_label(
+            title, x=x, y=y, bold=True, width=width, font_size=self.title_font_size
+        )
+        y += self.title_font_size + self.pad
+
+        last_glyphname = None
+        for page_no, (glyphname, problems) in items:
+            if glyphname == last_glyphname:
+                continue
+            last_glyphname = glyphname
+            if y + self.font_size > height:
+                self.show_page()
+                y = self.font_size + pad
+            self.draw_label(glyphname, x=x + 5 * pad, y=y, width=width - 2 * pad)
+            self.draw_label(str(page_no), x=x, y=y, width=4 * pad, align=1)
+            y += self.font_size
+
+        self.show_page()
+
+    def add_table_of_contents(self):
+        self._add_listing("Table of contents", sorted(self.toc.items()))
+
+    def add_index(self):
+        self._add_listing("Index", sorted(self.toc.items(), key=lambda x: x[1][0]))
+
+    def add_problems(self, problems, *, show_tolerance=True, show_page_number=True):
+        for glyph, glyph_problems in problems.items():
+            last_masters = None
+            current_glyph_problems = []
+            for p in glyph_problems:
+                masters = (
+                    p["master_idx"]
+                    if "master_idx" in p
+                    else (p["master_1_idx"], p["master_2_idx"])
+                )
+                if masters == last_masters:
+                    current_glyph_problems.append(p)
+                    continue
+                # Flush
+                if current_glyph_problems:
+                    self.add_problem(
+                        glyph,
+                        current_glyph_problems,
+                        show_tolerance=show_tolerance,
+                        show_page_number=show_page_number,
+                    )
+                    self.show_page()
+                    current_glyph_problems = []
+                last_masters = masters
+                current_glyph_problems.append(p)
+            if current_glyph_problems:
+                self.add_problem(
+                    glyph,
+                    current_glyph_problems,
+                    show_tolerance=show_tolerance,
+                    show_page_number=show_page_number,
+                )
+                self.show_page()
+
+    def add_problem(
+        self, glyphname, problems, *, show_tolerance=True, show_page_number=True
+    ):
+        if type(problems) not in (list, tuple):
+            problems = [problems]
+
+        self.toc[self.page_number] = (glyphname, problems)
+
+        problem_type = problems[0]["type"]
+        problem_types = set(problem["type"] for problem in problems)
+        if not all(pt == problem_type for pt in problem_types):
+            problem_type = ", ".join(sorted({problem["type"] for problem in problems}))
+
+        log.info("Drawing %s: %s", glyphname, problem_type)
+
+        master_keys = (
+            ("master_idx",)
+            if "master_idx" in problems[0]
+            else ("master_1_idx", "master_2_idx")
+        )
+        master_indices = [problems[0][k] for k in master_keys]
+
+        if problem_type == InterpolatableProblem.MISSING:
+            sample_glyph = next(
+                i for i, m in enumerate(self.glyphsets) if m[glyphname] is not None
+            )
+            master_indices.insert(0, sample_glyph)
+
+        x = self.pad
+        y = self.pad
+
+        self.draw_label(
+            "Glyph name: " + glyphname,
+            x=x,
+            y=y,
+            color=self.head_color,
+            align=0,
+            bold=True,
+            font_size=self.title_font_size,
+        )
+        tolerance = min(p.get("tolerance", 1) for p in problems)
+        if tolerance < 1 and show_tolerance:
+            self.draw_label(
+                "tolerance: %.2f" % tolerance,
+                x=x,
+                y=y,
+                width=self.width - 2 * self.pad,
+                align=1,
+                bold=True,
+            )
+        y += self.title_font_size + self.pad
+        self.draw_label(
+            "Problems: " + problem_type,
+            x=x,
+            y=y,
+            width=self.width - 2 * self.pad,
+            color=self.head_color,
+            bold=True,
+        )
+        y += self.font_size + self.pad * 2
+
+        scales = []
+        for which, master_idx in enumerate(master_indices):
+            glyphset = self.glyphsets[master_idx]
+            name = self.names[master_idx]
+
+            self.draw_label(
+                name,
+                x=x,
+                y=y,
+                color=self.label_color,
+                width=self.panel_width,
+                align=0.5,
+            )
+            y += self.font_size + self.pad
+
+            if glyphset[glyphname] is not None:
+                scales.append(
+                    self.draw_glyph(glyphset, glyphname, problems, which, x=x, y=y)
+                )
+            else:
+                self.draw_emoticon(self.shrug, x=x, y=y)
+            y += self.panel_height + self.font_size + self.pad
+
+        if any(
+            pt
+            in (
+                InterpolatableProblem.NOTHING,
+                InterpolatableProblem.WRONG_START_POINT,
+                InterpolatableProblem.CONTOUR_ORDER,
+                InterpolatableProblem.KINK,
+                InterpolatableProblem.UNDERWEIGHT,
+                InterpolatableProblem.OVERWEIGHT,
+            )
+            for pt in problem_types
+        ):
+            x = self.pad + self.panel_width + self.pad
+            y = self.pad
+            y += self.title_font_size + self.pad * 2
+            y += self.font_size + self.pad
+
+            glyphset1 = self.glyphsets[master_indices[0]]
+            glyphset2 = self.glyphsets[master_indices[1]]
+
+            # Draw the mid-way of the two masters
+
+            self.draw_label(
+                "midway interpolation",
+                x=x,
+                y=y,
+                color=self.head_color,
+                width=self.panel_width,
+                align=0.5,
+            )
+            y += self.font_size + self.pad
+
+            midway_glyphset = LerpGlyphSet(glyphset1, glyphset2)
+            self.draw_glyph(
+                midway_glyphset,
+                glyphname,
+                [{"type": "midway"}]
+                + [
+                    p
+                    for p in problems
+                    if p["type"]
+                    in (
+                        InterpolatableProblem.KINK,
+                        InterpolatableProblem.UNDERWEIGHT,
+                        InterpolatableProblem.OVERWEIGHT,
+                    )
+                ],
+                None,
+                x=x,
+                y=y,
+                scale=min(scales),
+            )
+
+            y += self.panel_height + self.font_size + self.pad
+
+        if any(
+            pt
+            in (
+                InterpolatableProblem.WRONG_START_POINT,
+                InterpolatableProblem.CONTOUR_ORDER,
+                InterpolatableProblem.KINK,
+            )
+            for pt in problem_types
+        ):
+            # Draw the proposed fix
+
+            self.draw_label(
+                "proposed fix",
+                x=x,
+                y=y,
+                color=self.head_color,
+                width=self.panel_width,
+                align=0.5,
+            )
+            y += self.font_size + self.pad
+
+            overriding1 = OverridingDict(glyphset1)
+            overriding2 = OverridingDict(glyphset2)
+            perContourPen1 = PerContourOrComponentPen(
+                RecordingPen, glyphset=overriding1
+            )
+            perContourPen2 = PerContourOrComponentPen(
+                RecordingPen, glyphset=overriding2
+            )
+            glyphset1[glyphname].draw(perContourPen1)
+            glyphset2[glyphname].draw(perContourPen2)
+
+            for problem in problems:
+                if problem["type"] == InterpolatableProblem.CONTOUR_ORDER:
+                    fixed_contours = [
+                        perContourPen2.value[i] for i in problems[0]["value_2"]
+                    ]
+                    perContourPen2.value = fixed_contours
+
+            for problem in problems:
+                if problem["type"] == InterpolatableProblem.WRONG_START_POINT:
+                    # Save the wrong contours
+                    wrongContour1 = perContourPen1.value[problem["contour"]]
+                    wrongContour2 = perContourPen2.value[problem["contour"]]
+
+                    # Convert the wrong contours to point pens
+                    points1 = RecordingPointPen()
+                    converter = SegmentToPointPen(points1, False)
+                    wrongContour1.replay(converter)
+                    points2 = RecordingPointPen()
+                    converter = SegmentToPointPen(points2, False)
+                    wrongContour2.replay(converter)
+
+                    proposed_start = problem["value_2"]
+
+                    # See if we need reversing; fragile but worth a try
+                    if problem["reversed"]:
+                        new_points2 = RecordingPointPen()
+                        reversedPen = ReverseContourPointPen(new_points2)
+                        points2.replay(reversedPen)
+                        points2 = new_points2
+                        proposed_start = len(points2.value) - 2 - proposed_start
+
+                    # Rotate points2 so that the first point is the same as in points1
+                    beginPath = points2.value[:1]
+                    endPath = points2.value[-1:]
+                    pts = points2.value[1:-1]
+                    pts = pts[proposed_start:] + pts[:proposed_start]
+                    points2.value = beginPath + pts + endPath
+
+                    # Convert the point pens back to segment pens
+                    segment1 = RecordingPen()
+                    converter = PointToSegmentPen(segment1, True)
+                    points1.replay(converter)
+                    segment2 = RecordingPen()
+                    converter = PointToSegmentPen(segment2, True)
+                    points2.replay(converter)
+
+                    # Replace the wrong contours
+                    wrongContour1.value = segment1.value
+                    wrongContour2.value = segment2.value
+                    perContourPen1.value[problem["contour"]] = wrongContour1
+                    perContourPen2.value[problem["contour"]] = wrongContour2
+
+            for problem in problems:
+                # If we have a kink, try to fix it.
+                if problem["type"] == InterpolatableProblem.KINK:
+                    # Save the wrong contours
+                    wrongContour1 = perContourPen1.value[problem["contour"]]
+                    wrongContour2 = perContourPen2.value[problem["contour"]]
+
+                    # Convert the wrong contours to point pens
+                    points1 = RecordingPointPen()
+                    converter = SegmentToPointPen(points1, False)
+                    wrongContour1.replay(converter)
+                    points2 = RecordingPointPen()
+                    converter = SegmentToPointPen(points2, False)
+                    wrongContour2.replay(converter)
+
+                    i = problem["value"]
+
+                    # Position points to be around the same ratio
+                    # beginPath / endPath dance
+                    j = i + 1
+                    pt0 = points1.value[j][1][0]
+                    pt1 = points2.value[j][1][0]
+                    j_prev = (i - 1) % (len(points1.value) - 2) + 1
+                    pt0_prev = points1.value[j_prev][1][0]
+                    pt1_prev = points2.value[j_prev][1][0]
+                    j_next = (i + 1) % (len(points1.value) - 2) + 1
+                    pt0_next = points1.value[j_next][1][0]
+                    pt1_next = points2.value[j_next][1][0]
+
+                    pt0 = complex(*pt0)
+                    pt1 = complex(*pt1)
+                    pt0_prev = complex(*pt0_prev)
+                    pt1_prev = complex(*pt1_prev)
+                    pt0_next = complex(*pt0_next)
+                    pt1_next = complex(*pt1_next)
+
+                    # Find the ratio of the distance between the points
+                    r0 = abs(pt0 - pt0_prev) / abs(pt0_next - pt0_prev)
+                    r1 = abs(pt1 - pt1_prev) / abs(pt1_next - pt1_prev)
+                    r_mid = (r0 + r1) / 2
+
+                    pt0 = pt0_prev + r_mid * (pt0_next - pt0_prev)
+                    pt1 = pt1_prev + r_mid * (pt1_next - pt1_prev)
+
+                    points1.value[j] = (
+                        points1.value[j][0],
+                        (((pt0.real, pt0.imag),) + points1.value[j][1][1:]),
+                        points1.value[j][2],
+                    )
+                    points2.value[j] = (
+                        points2.value[j][0],
+                        (((pt1.real, pt1.imag),) + points2.value[j][1][1:]),
+                        points2.value[j][2],
+                    )
+
+                    # Convert the point pens back to segment pens
+                    segment1 = RecordingPen()
+                    converter = PointToSegmentPen(segment1, True)
+                    points1.replay(converter)
+                    segment2 = RecordingPen()
+                    converter = PointToSegmentPen(segment2, True)
+                    points2.replay(converter)
+
+                    # Replace the wrong contours
+                    wrongContour1.value = segment1.value
+                    wrongContour2.value = segment2.value
+
+            # Assemble
+            fixed1 = RecordingPen()
+            fixed2 = RecordingPen()
+            for contour in perContourPen1.value:
+                fixed1.value.extend(contour.value)
+            for contour in perContourPen2.value:
+                fixed2.value.extend(contour.value)
+            fixed1.draw = fixed1.replay
+            fixed2.draw = fixed2.replay
+
+            overriding1[glyphname] = fixed1
+            overriding2[glyphname] = fixed2
+
+            try:
+                midway_glyphset = LerpGlyphSet(overriding1, overriding2)
+                self.draw_glyph(
+                    midway_glyphset,
+                    glyphname,
+                    {"type": "fixed"},
+                    None,
+                    x=x,
+                    y=y,
+                    scale=min(scales),
+                )
+            except ValueError:
+                self.draw_emoticon(self.shrug, x=x, y=y)
+            y += self.panel_height + self.pad
+
+        else:
+            emoticon = self.shrug
+            if InterpolatableProblem.UNDERWEIGHT in problem_types:
+                emoticon = self.underweight
+            elif InterpolatableProblem.OVERWEIGHT in problem_types:
+                emoticon = self.overweight
+            elif InterpolatableProblem.NOTHING in problem_types:
+                emoticon = self.yay
+            self.draw_emoticon(emoticon, x=x, y=y)
+
+        if show_page_number:
+            self.draw_label(
+                str(self.page_number),
+                x=0,
+                y=self.height - self.font_size - self.pad,
+                width=self.width,
+                color=self.head_color,
+                align=0.5,
+            )
+
+    def draw_label(
+        self,
+        label,
+        *,
+        x=0,
+        y=0,
+        color=(0, 0, 0),
+        align=0,
+        bold=False,
+        width=None,
+        height=None,
+        font_size=None,
+    ):
+        if width is None:
+            width = self.width
+        if height is None:
+            height = self.height
+        if font_size is None:
+            font_size = self.font_size
+        cr = cairo.Context(self.surface)
+        cr.select_font_face(
+            "@cairo:",
+            cairo.FONT_SLANT_NORMAL,
+            cairo.FONT_WEIGHT_BOLD if bold else cairo.FONT_WEIGHT_NORMAL,
+        )
+        cr.set_font_size(font_size)
+        font_extents = cr.font_extents()
+        font_size = font_size * font_size / font_extents[2]
+        cr.set_font_size(font_size)
+        font_extents = cr.font_extents()
+
+        cr.set_source_rgb(*color)
+
+        extents = cr.text_extents(label)
+        if extents.width > width:
+            # Shrink
+            font_size *= width / extents.width
+            cr.set_font_size(font_size)
+            font_extents = cr.font_extents()
+            extents = cr.text_extents(label)
+
+        # Center
+        label_x = x + (width - extents.width) * align
+        label_y = y + font_extents[0]
+        cr.move_to(label_x, label_y)
+        cr.show_text(label)
+
+    def draw_glyph(self, glyphset, glyphname, problems, which, *, x=0, y=0, scale=None):
+        if type(problems) not in (list, tuple):
+            problems = [problems]
+
+        midway = any(problem["type"] == "midway" for problem in problems)
+        problem_type = problems[0]["type"]
+        problem_types = set(problem["type"] for problem in problems)
+        if not all(pt == problem_type for pt in problem_types):
+            problem_type = "mixed"
+        glyph = glyphset[glyphname]
+
+        recording = RecordingPen()
+        glyph.draw(recording)
+        decomposedRecording = DecomposingRecordingPen(glyphset)
+        glyph.draw(decomposedRecording)
+
+        boundsPen = ControlBoundsPen(glyphset)
+        decomposedRecording.replay(boundsPen)
+        bounds = boundsPen.bounds
+        if bounds is None:
+            bounds = (0, 0, 0, 0)
+
+        glyph_width = bounds[2] - bounds[0]
+        glyph_height = bounds[3] - bounds[1]
+
+        if glyph_width:
+            if scale is None:
+                scale = self.panel_width / glyph_width
+            else:
+                scale = min(scale, self.panel_height / glyph_height)
+        if glyph_height:
+            if scale is None:
+                scale = self.panel_height / glyph_height
+            else:
+                scale = min(scale, self.panel_height / glyph_height)
+        if scale is None:
+            scale = 1
+
+        cr = cairo.Context(self.surface)
+        cr.translate(x, y)
+        # Center
+        cr.translate(
+            (self.panel_width - glyph_width * scale) / 2,
+            (self.panel_height - glyph_height * scale) / 2,
+        )
+        cr.scale(scale, -scale)
+        cr.translate(-bounds[0], -bounds[3])
+
+        if self.border_color:
+            cr.set_source_rgb(*self.border_color)
+            cr.rectangle(bounds[0], bounds[1], glyph_width, glyph_height)
+            cr.set_line_width(self.border_width / scale)
+            cr.stroke()
+
+        if self.fill_color or self.stroke_color:
+            pen = CairoPen(glyphset, cr)
+            decomposedRecording.replay(pen)
+
+            if self.fill_color and problem_type != InterpolatableProblem.OPEN_PATH:
+                cr.set_source_rgb(*self.fill_color)
+                cr.fill_preserve()
+
+            if self.stroke_color:
+                cr.set_source_rgb(*self.stroke_color)
+                cr.set_line_width(self.stroke_width / scale)
+                cr.stroke_preserve()
+
+            cr.new_path()
+
+        if (
+            InterpolatableProblem.UNDERWEIGHT in problem_types
+            or InterpolatableProblem.OVERWEIGHT in problem_types
+        ):
+            perContourPen = PerContourOrComponentPen(RecordingPen, glyphset=glyphset)
+            recording.replay(perContourPen)
+            for problem in problems:
+                if problem["type"] in (
+                    InterpolatableProblem.UNDERWEIGHT,
+                    InterpolatableProblem.OVERWEIGHT,
+                ):
+                    contour = perContourPen.value[problem["contour"]]
+                    contour.replay(CairoPen(glyphset, cr))
+                    cr.set_source_rgba(*self.weight_issue_contour_color)
+                    cr.fill()
+
+        if any(
+            t in problem_types
+            for t in {
+                InterpolatableProblem.NOTHING,
+                InterpolatableProblem.NODE_COUNT,
+                InterpolatableProblem.NODE_INCOMPATIBILITY,
+            }
+        ):
+            cr.set_line_cap(cairo.LINE_CAP_ROUND)
+
+            # Oncurve nodes
+            for segment, args in decomposedRecording.value:
+                if not args:
+                    continue
+                x, y = args[-1]
+                cr.move_to(x, y)
+                cr.line_to(x, y)
+            cr.set_source_rgba(*self.oncurve_node_color)
+            cr.set_line_width(self.oncurve_node_diameter / scale)
+            cr.stroke()
+
+            # Offcurve nodes
+            for segment, args in decomposedRecording.value:
+                if not args:
+                    continue
+                for x, y in args[:-1]:
+                    cr.move_to(x, y)
+                    cr.line_to(x, y)
+            cr.set_source_rgba(*self.offcurve_node_color)
+            cr.set_line_width(self.offcurve_node_diameter / scale)
+            cr.stroke()
+
+            # Handles
+            for segment, args in decomposedRecording.value:
+                if not args:
+                    pass
+                elif segment in ("moveTo", "lineTo"):
+                    cr.move_to(*args[0])
+                elif segment == "qCurveTo":
+                    for x, y in args:
+                        cr.line_to(x, y)
+                    cr.new_sub_path()
+                    cr.move_to(*args[-1])
+                elif segment == "curveTo":
+                    cr.line_to(*args[0])
+                    cr.new_sub_path()
+                    cr.move_to(*args[1])
+                    cr.line_to(*args[2])
+                    cr.new_sub_path()
+                    cr.move_to(*args[-1])
+                else:
+                    continue
+
+            cr.set_source_rgba(*self.handle_color)
+            cr.set_line_width(self.handle_width / scale)
+            cr.stroke()
+
+        matching = None
+        for problem in problems:
+            if problem["type"] == InterpolatableProblem.CONTOUR_ORDER:
+                matching = problem["value_2"]
+                colors = cycle(self.contour_colors)
+                perContourPen = PerContourOrComponentPen(
+                    RecordingPen, glyphset=glyphset
+                )
+                recording.replay(perContourPen)
+                for i, contour in enumerate(perContourPen.value):
+                    if matching[i] == i:
+                        continue
+                    color = next(colors)
+                    contour.replay(CairoPen(glyphset, cr))
+                    cr.set_source_rgba(*color, self.contour_alpha)
+                    cr.fill()
+
+        for problem in problems:
+            if problem["type"] in (
+                InterpolatableProblem.NOTHING,
+                InterpolatableProblem.WRONG_START_POINT,
+            ):
+                idx = problem.get("contour")
+
+                # Draw suggested point
+                if idx is not None and which == 1 and "value_2" in problem:
+                    perContourPen = PerContourOrComponentPen(
+                        RecordingPen, glyphset=glyphset
+                    )
+                    decomposedRecording.replay(perContourPen)
+                    points = SimpleRecordingPointPen()
+                    converter = SegmentToPointPen(points, False)
+                    perContourPen.value[
+                        idx if matching is None else matching[idx]
+                    ].replay(converter)
+                    targetPoint = points.value[problem["value_2"]][0]
+                    cr.save()
+                    cr.translate(*targetPoint)
+                    cr.scale(1 / scale, 1 / scale)
+                    self.draw_dot(
+                        cr,
+                        diameter=self.corrected_start_point_size,
+                        color=self.corrected_start_point_color,
+                    )
+                    cr.restore()
+
+                # Draw start-point arrow
+                if which == 0 or not problem.get("reversed"):
+                    color = self.start_point_color
+                else:
+                    color = self.wrong_start_point_color
+                first_pt = None
+                i = 0
+                cr.save()
+                for segment, args in decomposedRecording.value:
+                    if segment == "moveTo":
+                        first_pt = args[0]
+                        continue
+                    if first_pt is None:
+                        continue
+                    if segment == "closePath":
+                        second_pt = first_pt
+                    else:
+                        second_pt = args[0]
+
+                    if idx is None or i == idx:
+                        cr.save()
+                        first_pt = complex(*first_pt)
+                        second_pt = complex(*second_pt)
+                        length = abs(second_pt - first_pt)
+                        cr.translate(first_pt.real, first_pt.imag)
+                        if length:
+                            # Draw arrowhead
+                            cr.rotate(
+                                math.atan2(
+                                    second_pt.imag - first_pt.imag,
+                                    second_pt.real - first_pt.real,
+                                )
+                            )
+                            cr.scale(1 / scale, 1 / scale)
+                            self.draw_arrow(cr, color=color)
+                        else:
+                            # Draw circle
+                            cr.scale(1 / scale, 1 / scale)
+                            self.draw_dot(
+                                cr,
+                                diameter=self.corrected_start_point_size,
+                                color=color,
+                            )
+                        cr.restore()
+
+                        if idx is not None:
+                            break
+
+                    first_pt = None
+                    i += 1
+
+                cr.restore()
+
+            if problem["type"] == InterpolatableProblem.KINK:
+                idx = problem.get("contour")
+                perContourPen = PerContourOrComponentPen(
+                    RecordingPen, glyphset=glyphset
+                )
+                decomposedRecording.replay(perContourPen)
+                points = SimpleRecordingPointPen()
+                converter = SegmentToPointPen(points, False)
+                perContourPen.value[idx if matching is None else matching[idx]].replay(
+                    converter
+                )
+
+                targetPoint = points.value[problem["value"]][0]
+                cr.save()
+                cr.translate(*targetPoint)
+                cr.scale(1 / scale, 1 / scale)
+                if midway:
+                    self.draw_circle(
+                        cr,
+                        diameter=self.kink_circle_size,
+                        stroke_width=self.kink_circle_stroke_width,
+                        color=self.kink_circle_color,
+                    )
+                else:
+                    self.draw_dot(
+                        cr,
+                        diameter=self.kink_point_size,
+                        color=self.kink_point_color,
+                    )
+                cr.restore()
+
+        return scale
+
+    def draw_dot(self, cr, *, x=0, y=0, color=(0, 0, 0), diameter=10):
+        cr.save()
+        cr.set_line_width(diameter)
+        cr.set_line_cap(cairo.LINE_CAP_ROUND)
+        cr.move_to(x, y)
+        cr.line_to(x, y)
+        if len(color) == 3:
+            color = color + (1,)
+        cr.set_source_rgba(*color)
+        cr.stroke()
+        cr.restore()
+
+    def draw_circle(
+        self, cr, *, x=0, y=0, color=(0, 0, 0), diameter=10, stroke_width=1
+    ):
+        cr.save()
+        cr.set_line_width(stroke_width)
+        cr.set_line_cap(cairo.LINE_CAP_SQUARE)
+        cr.arc(x, y, diameter / 2, 0, 2 * math.pi)
+        if len(color) == 3:
+            color = color + (1,)
+        cr.set_source_rgba(*color)
+        cr.stroke()
+        cr.restore()
+
+    def draw_arrow(self, cr, *, x=0, y=0, color=(0, 0, 0)):
+        cr.save()
+        if len(color) == 3:
+            color = color + (1,)
+        cr.set_source_rgba(*color)
+        cr.translate(self.start_arrow_length + x, y)
+        cr.move_to(0, 0)
+        cr.line_to(
+            -self.start_arrow_length,
+            -self.start_arrow_length * 0.4,
+        )
+        cr.line_to(
+            -self.start_arrow_length,
+            self.start_arrow_length * 0.4,
+        )
+        cr.close_path()
+        cr.fill()
+        cr.restore()
+
+    def draw_text(self, text, *, x=0, y=0, color=(0, 0, 0), width=None, height=None):
+        if width is None:
+            width = self.width
+        if height is None:
+            height = self.height
+
+        text = text.splitlines()
+        cr = cairo.Context(self.surface)
+        cr.set_source_rgb(*color)
+        cr.set_font_size(self.font_size)
+        cr.select_font_face(
+            "@cairo:monospace", cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_NORMAL
+        )
+        text_width = 0
+        text_height = 0
+        font_extents = cr.font_extents()
+        font_font_size = font_extents[2]
+        font_ascent = font_extents[0]
+        for line in text:
+            extents = cr.text_extents(line)
+            text_width = max(text_width, extents.x_advance)
+            text_height += font_font_size
+        if not text_width:
+            return
+        cr.translate(x, y)
+        scale = min(width / text_width, height / text_height)
+        # center
+        cr.translate(
+            (width - text_width * scale) / 2, (height - text_height * scale) / 2
+        )
+        cr.scale(scale, scale)
+
+        cr.translate(0, font_ascent)
+        for line in text:
+            cr.move_to(0, 0)
+            cr.show_text(line)
+            cr.translate(0, font_font_size)
+
+    def draw_cupcake(self):
+        self.draw_label(
+            self.no_issues_label,
+            x=self.pad,
+            y=self.pad,
+            color=self.no_issues_label_color,
+            width=self.width - 2 * self.pad,
+            align=0.5,
+            bold=True,
+            font_size=self.title_font_size,
+        )
+
+        self.draw_text(
+            self.cupcake,
+            x=self.pad,
+            y=self.pad + self.font_size,
+            width=self.width - 2 * self.pad,
+            height=self.height - 2 * self.pad - self.font_size,
+            color=self.cupcake_color,
+        )
+
+    def draw_emoticon(self, emoticon, x=0, y=0):
+        self.draw_text(
+            emoticon,
+            x=x,
+            y=y,
+            color=self.emoticon_color,
+            width=self.panel_width,
+            height=self.panel_height,
+        )
+
+
+class InterpolatablePostscriptLike(InterpolatablePlot):
+    def __exit__(self, type, value, traceback):
+        self.surface.finish()
+
+    def show_page(self):
+        super().show_page()
+        self.surface.show_page()
+
+
+class InterpolatablePS(InterpolatablePostscriptLike):
+    def __enter__(self):
+        self.surface = cairo.PSSurface(self.out, self.width, self.height)
+        return self
+
+
+class InterpolatablePDF(InterpolatablePostscriptLike):
+    def __enter__(self):
+        self.surface = cairo.PDFSurface(self.out, self.width, self.height)
+        self.surface.set_metadata(
+            cairo.PDF_METADATA_CREATOR, "fonttools varLib.interpolatable"
+        )
+        self.surface.set_metadata(cairo.PDF_METADATA_CREATE_DATE, "")
+        return self
+
+
+class InterpolatableSVG(InterpolatablePlot):
+    def __enter__(self):
+        self.sink = BytesIO()
+        self.surface = cairo.SVGSurface(self.sink, self.width, self.height)
+        return self
+
+    def __exit__(self, type, value, traceback):
+        if self.surface is not None:
+            self.show_page()
+
+    def show_page(self):
+        super().show_page()
+        self.surface.finish()
+        self.out.append(self.sink.getvalue())
+        self.sink = BytesIO()
+        self.surface = cairo.SVGSurface(self.sink, self.width, self.height)

evalkit_tf437/lib/python3.10/site-packages/fontTools/varLib/plot.py

@@ -0,0 +1,238 @@
+"""Visualize DesignSpaceDocument and resulting VariationModel."""
+
+from fontTools.varLib.models import VariationModel, supportScalar
+from fontTools.designspaceLib import DesignSpaceDocument
+from matplotlib import pyplot
+from mpl_toolkits.mplot3d import axes3d
+from itertools import cycle
+import math
+import logging
+import sys
+
+log = logging.getLogger(__name__)
+
+
+def stops(support, count=10):
+    a, b, c = support
+
+    return (
+        [a + (b - a) * i / count for i in range(count)]
+        + [b + (c - b) * i / count for i in range(count)]
+        + [c]
+    )
+
+
+def _plotLocationsDots(locations, axes, subplot, **kwargs):
+    for loc, color in zip(locations, cycle(pyplot.cm.Set1.colors)):
+        if len(axes) == 1:
+            subplot.plot([loc.get(axes[0], 0)], [1.0], "o", color=color, **kwargs)
+        elif len(axes) == 2:
+            subplot.plot(
+                [loc.get(axes[0], 0)],
+                [loc.get(axes[1], 0)],
+                [1.0],
+                "o",
+                color=color,
+                **kwargs,
+            )
+        else:
+            raise AssertionError(len(axes))
+
+
+def plotLocations(locations, fig, names=None, **kwargs):
+    n = len(locations)
+    cols = math.ceil(n**0.5)
+    rows = math.ceil(n / cols)
+
+    if names is None:
+        names = [None] * len(locations)
+
+    model = VariationModel(locations)
+    names = [names[model.reverseMapping[i]] for i in range(len(names))]
+
+    axes = sorted(locations[0].keys())
+    if len(axes) == 1:
+        _plotLocations2D(model, axes[0], fig, cols, rows, names=names, **kwargs)
+    elif len(axes) == 2:
+        _plotLocations3D(model, axes, fig, cols, rows, names=names, **kwargs)
+    else:
+        raise ValueError("Only 1 or 2 axes are supported")
+
+
+def _plotLocations2D(model, axis, fig, cols, rows, names, **kwargs):
+    subplot = fig.add_subplot(111)
+    for i, (support, color, name) in enumerate(
+        zip(model.supports, cycle(pyplot.cm.Set1.colors), cycle(names))
+    ):
+        if name is not None:
+            subplot.set_title(name)
+        subplot.set_xlabel(axis)
+        pyplot.xlim(-1.0, +1.0)
+
+        Xs = support.get(axis, (-1.0, 0.0, +1.0))
+        X, Y = [], []
+        for x in stops(Xs):
+            y = supportScalar({axis: x}, support)
+            X.append(x)
+            Y.append(y)
+        subplot.plot(X, Y, color=color, **kwargs)
+
+        _plotLocationsDots(model.locations, [axis], subplot)
+
+
+def _plotLocations3D(model, axes, fig, rows, cols, names, **kwargs):
+    ax1, ax2 = axes
+
+    axis3D = fig.add_subplot(111, projection="3d")
+    for i, (support, color, name) in enumerate(
+        zip(model.supports, cycle(pyplot.cm.Set1.colors), cycle(names))
+    ):
+        if name is not None:
+            axis3D.set_title(name)
+        axis3D.set_xlabel(ax1)
+        axis3D.set_ylabel(ax2)
+        pyplot.xlim(-1.0, +1.0)
+        pyplot.ylim(-1.0, +1.0)
+
+        Xs = support.get(ax1, (-1.0, 0.0, +1.0))
+        Ys = support.get(ax2, (-1.0, 0.0, +1.0))
+        for x in stops(Xs):
+            X, Y, Z = [], [], []
+            for y in Ys:
+                z = supportScalar({ax1: x, ax2: y}, support)
+                X.append(x)
+                Y.append(y)
+                Z.append(z)
+            axis3D.plot(X, Y, Z, color=color, **kwargs)
+        for y in stops(Ys):
+            X, Y, Z = [], [], []
+            for x in Xs:
+                z = supportScalar({ax1: x, ax2: y}, support)
+                X.append(x)
+                Y.append(y)
+                Z.append(z)
+            axis3D.plot(X, Y, Z, color=color, **kwargs)
+
+        _plotLocationsDots(model.locations, [ax1, ax2], axis3D)
+
+
+def plotDocument(doc, fig, **kwargs):
+    doc.normalize()
+    locations = [s.location for s in doc.sources]
+    names = [s.name for s in doc.sources]
+    plotLocations(locations, fig, names, **kwargs)
+
+
+def _plotModelFromMasters2D(model, masterValues, fig, **kwargs):
+    assert len(model.axisOrder) == 1
+    axis = model.axisOrder[0]
+
+    axis_min = min(loc.get(axis, 0) for loc in model.locations)
+    axis_max = max(loc.get(axis, 0) for loc in model.locations)
+
+    import numpy as np
+
+    X = np.arange(axis_min, axis_max, (axis_max - axis_min) / 100)
+    Y = []
+
+    for x in X:
+        loc = {axis: x}
+        v = model.interpolateFromMasters(loc, masterValues)
+        Y.append(v)
+
+    subplot = fig.add_subplot(111)
+    subplot.plot(X, Y, "-", **kwargs)
+
+
+def _plotModelFromMasters3D(model, masterValues, fig, **kwargs):
+    assert len(model.axisOrder) == 2
+    axis1, axis2 = model.axisOrder[0], model.axisOrder[1]
+
+    axis1_min = min(loc.get(axis1, 0) for loc in model.locations)
+    axis1_max = max(loc.get(axis1, 0) for loc in model.locations)
+    axis2_min = min(loc.get(axis2, 0) for loc in model.locations)
+    axis2_max = max(loc.get(axis2, 0) for loc in model.locations)
+
+    import numpy as np
+
+    X = np.arange(axis1_min, axis1_max, (axis1_max - axis1_min) / 100)
+    Y = np.arange(axis2_min, axis2_max, (axis2_max - axis2_min) / 100)
+    X, Y = np.meshgrid(X, Y)
+    Z = []
+
+    for row_x, row_y in zip(X, Y):
+        z_row = []
+        Z.append(z_row)
+        for x, y in zip(row_x, row_y):
+            loc = {axis1: x, axis2: y}
+            v = model.interpolateFromMasters(loc, masterValues)
+            z_row.append(v)
+    Z = np.array(Z)
+
+    axis3D = fig.add_subplot(111, projection="3d")
+    axis3D.plot_surface(X, Y, Z, **kwargs)
+
+
+def plotModelFromMasters(model, masterValues, fig, **kwargs):
+    """Plot a variation model and set of master values corresponding
+    to the locations to the model into a pyplot figure.  Variation
+    model must have axisOrder of size 1 or 2."""
+    if len(model.axisOrder) == 1:
+        _plotModelFromMasters2D(model, masterValues, fig, **kwargs)
+    elif len(model.axisOrder) == 2:
+        _plotModelFromMasters3D(model, masterValues, fig, **kwargs)
+    else:
+        raise ValueError("Only 1 or 2 axes are supported")
+
+
+def main(args=None):
+    from fontTools import configLogger
+
+    if args is None:
+        args = sys.argv[1:]
+
+    # configure the library logger (for >= WARNING)
+    configLogger()
+    # comment this out to enable debug messages from logger
+    # log.setLevel(logging.DEBUG)
+
+    if len(args) < 1:
+        print("usage: fonttools varLib.plot source.designspace", file=sys.stderr)
+        print("  or")
+        print("usage: fonttools varLib.plot location1 location2 ...", file=sys.stderr)
+        print("  or")
+        print(
+            "usage: fonttools varLib.plot location1=value1 location2=value2 ...",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    fig = pyplot.figure()
+    fig.set_tight_layout(True)
+
+    if len(args) == 1 and args[0].endswith(".designspace"):
+        doc = DesignSpaceDocument()
+        doc.read(args[0])
+        plotDocument(doc, fig)
+    else:
+        axes = [chr(c) for c in range(ord("A"), ord("Z") + 1)]
+        if "=" not in args[0]:
+            locs = [dict(zip(axes, (float(v) for v in s.split(",")))) for s in args]
+            plotLocations(locs, fig)
+        else:
+            locations = []
+            masterValues = []
+            for arg in args:
+                loc, v = arg.split("=")
+                locations.append(dict(zip(axes, (float(v) for v in loc.split(",")))))
+                masterValues.append(float(v))
+            model = VariationModel(locations, axes[: len(locations[0])])
+            plotModelFromMasters(model, masterValues, fig)
+
+    pyplot.show()
+
+
+if __name__ == "__main__":
+    import sys
+
+    sys.exit(main())

evalkit_tf437/lib/python3.10/site-packages/google_crc32c/__config__.py

@@ -0,0 +1,38 @@
+# Copyright 2018 Google LLC
+#
+# 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
+#
+#     https://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 os
+
+
+def modify_path():
+    """Modify the module search path."""
+    # Only modify path on Windows.
+    if os.name != "nt":
+        return
+
+    path = os.environ.get("PATH")
+    if path is None:
+        return
+
+    try:
+        from importlib.resources import files as _resources_files
+
+        extra_dll_dir = str(_resources_files("google_crc32c") / "extra-dll")
+        if os.path.isdir(extra_dll_dir):
+            # Python 3.8+ uses add_dll_directory.
+            os.add_dll_directory(extra_dll_dir)
+    except ImportError:
+        pass
+
+modify_path()