fonttools 4.60.2__cp311-cp311-win32.whl

fontTools/ufoLib/converters.py

@@ -0,0 +1,407 @@
+from __future__ import annotations
+
+from typing import Mapping, Any
+from collections.abc import Container
+
+from fontTools.annotations import KerningNested
+
+"""
+Functions for converting UFO1 or UFO2 files into UFO3 format.
+
+Currently provides functionality for converting kerning rules
+and kerning groups. Conversion is only supported _from_ UFO1
+or UFO2, and _to_ UFO3.
+"""
+
+# adapted from the UFO spec
+
+
+def convertUFO1OrUFO2KerningToUFO3Kerning(
+    kerning: KerningNested, groups: dict[str, list[str]], glyphSet: Container[str] = ()
+) -> tuple[KerningNested, dict[str, list[str]], dict[str, dict[str, str]]]:
+    """Convert kerning data in UFO1 or UFO2 syntax into UFO3 syntax.
+
+    Args:
+      kerning:
+          A dictionary containing the kerning rules defined in
+          the UFO font, as used in :class:`.UFOReader` objects.
+      groups:
+          A dictionary containing the groups defined in the UFO
+          font, as used in :class:`.UFOReader` objects.
+      glyphSet:
+        Optional; a set of glyph objects to skip (default: None).
+
+    Returns:
+      1. A dictionary representing the converted kerning data.
+      2. A copy of the groups dictionary, with all groups renamed to UFO3 syntax.
+      3. A dictionary containing the mapping of old group names to new group names.
+
+    """
+    # gather known kerning groups based on the prefixes
+    firstReferencedGroups, secondReferencedGroups = findKnownKerningGroups(groups)
+    # Make lists of groups referenced in kerning pairs.
+    for first, seconds in list(kerning.items()):
+        if first in groups and first not in glyphSet:
+            if not first.startswith("public.kern1."):
+                firstReferencedGroups.add(first)
+        for second in list(seconds.keys()):
+            if second in groups and second not in glyphSet:
+                if not second.startswith("public.kern2."):
+                    secondReferencedGroups.add(second)
+    # Create new names for these groups.
+    firstRenamedGroups: dict[str, str] = {}
+    for first in firstReferencedGroups:
+        # Make a list of existing group names.
+        existingGroupNames = list(groups.keys()) + list(firstRenamedGroups.keys())
+        # Remove the old prefix from the name
+        newName = first.replace("@MMK_L_", "")
+        # Add the new prefix to the name.
+        newName = "public.kern1." + newName
+        # Make a unique group name.
+        newName = makeUniqueGroupName(newName, existingGroupNames)
+        # Store for use later.
+        firstRenamedGroups[first] = newName
+    secondRenamedGroups: dict[str, str] = {}
+    for second in secondReferencedGroups:
+        # Make a list of existing group names.
+        existingGroupNames = list(groups.keys()) + list(secondRenamedGroups.keys())
+        # Remove the old prefix from the name
+        newName = second.replace("@MMK_R_", "")
+        # Add the new prefix to the name.
+        newName = "public.kern2." + newName
+        # Make a unique group name.
+        newName = makeUniqueGroupName(newName, existingGroupNames)
+        # Store for use later.
+        secondRenamedGroups[second] = newName
+    # Populate the new group names into the kerning dictionary as needed.
+    newKerning = {}
+    for first, seconds in list(kerning.items()):
+        first = firstRenamedGroups.get(first, first)
+        newSeconds = {}
+        for second, value in list(seconds.items()):
+            second = secondRenamedGroups.get(second, second)
+            newSeconds[second] = value
+        newKerning[first] = newSeconds
+    # Make copies of the referenced groups and store them
+    # under the new names in the overall groups dictionary.
+    allRenamedGroups = list(firstRenamedGroups.items())
+    allRenamedGroups += list(secondRenamedGroups.items())
+    for oldName, newName in allRenamedGroups:
+        group = list(groups[oldName])
+        groups[newName] = group
+    # Return the kerning and the groups.
+    return newKerning, groups, dict(side1=firstRenamedGroups, side2=secondRenamedGroups)
+
+
+def findKnownKerningGroups(groups: Mapping[str, Any]) -> tuple[set[str], set[str]]:
+    """Find all kerning groups in a UFO1 or UFO2 font that use known prefixes.
+
+    In some cases, not all kerning groups will be referenced
+    by the kerning pairs in a UFO. The algorithm for locating
+    groups in :func:`convertUFO1OrUFO2KerningToUFO3Kerning` will
+    miss these unreferenced groups. By scanning for known prefixes,
+    this function will catch all of the prefixed groups.
+
+    The prefixes and sides by this function are:
+
+    @MMK_L_ - side 1
+    @MMK_R_ - side 2
+
+    as defined in the UFO1 specification.
+
+    Args:
+        groups:
+          A dictionary containing the groups defined in the UFO
+          font, as read by :class:`.UFOReader`.
+
+    Returns:
+        Two sets; the first containing the names of all
+        first-side kerning groups identified in the ``groups``
+        dictionary, and the second containing the names of all
+        second-side kerning groups identified.
+
+        "First-side" and "second-side" are with respect to the
+        writing direction of the script.
+
+        Example::
+
+          >>> testGroups = {
+          ...     "@MMK_L_1" : None,
+          ...     "@MMK_L_2" : None,
+          ...     "@MMK_L_3" : None,
+          ...     "@MMK_R_1" : None,
+          ...     "@MMK_R_2" : None,
+          ...     "@MMK_R_3" : None,
+          ...     "@MMK_l_1" : None,
+          ...     "@MMK_r_1" : None,
+          ...     "@MMK_X_1" : None,
+          ...     "foo" : None,
+          ... }
+          >>> first, second = findKnownKerningGroups(testGroups)
+          >>> sorted(first) == ['@MMK_L_1', '@MMK_L_2', '@MMK_L_3']
+          True
+          >>> sorted(second) == ['@MMK_R_1', '@MMK_R_2', '@MMK_R_3']
+          True
+    """
+    knownFirstGroupPrefixes = ["@MMK_L_"]
+    knownSecondGroupPrefixes = ["@MMK_R_"]
+    firstGroups = set()
+    secondGroups = set()
+    for groupName in list(groups.keys()):
+        for firstPrefix in knownFirstGroupPrefixes:
+            if groupName.startswith(firstPrefix):
+                firstGroups.add(groupName)
+                break
+        for secondPrefix in knownSecondGroupPrefixes:
+            if groupName.startswith(secondPrefix):
+                secondGroups.add(groupName)
+                break
+    return firstGroups, secondGroups
+
+
+def makeUniqueGroupName(name: str, groupNames: list[str], counter: int = 0) -> str:
+    """Make a kerning group name that will be unique within the set of group names.
+
+    If the requested kerning group name already exists within the set, this
+    will return a new name by adding an incremented counter to the end
+    of the requested name.
+
+    Args:
+        name:
+          The requested kerning group name.
+        groupNames:
+          A list of the existing kerning group names.
+        counter:
+          Optional; a counter of group names already seen (default: 0). If
+          :attr:`.counter` is not provided, the function will recurse,
+          incrementing the value of :attr:`.counter` until it finds the
+          first unused ``name+counter`` combination, and return that result.
+
+    Returns:
+        A unique kerning group name composed of the requested name suffixed
+        by the smallest available integer counter.
+    """
+    # Add a number to the name if the counter is higher than zero.
+    newName = name
+    if counter > 0:
+        newName = "%s%d" % (newName, counter)
+    # If the new name is in the existing group names, recurse.
+    if newName in groupNames:
+        return makeUniqueGroupName(name, groupNames, counter + 1)
+    # Otherwise send back the new name.
+    return newName
+
+
+def test():
+    """
+    Tests for :func:`.convertUFO1OrUFO2KerningToUFO3Kerning`.
+
+    No known prefixes.
+
+    >>> testKerning = {
+    ...     "A" : {
+    ...         "A" : 1,
+    ...         "B" : 2,
+    ...         "CGroup" : 3,
+    ...         "DGroup" : 4
+    ...     },
+    ...     "BGroup" : {
+    ...         "A" : 5,
+    ...         "B" : 6,
+    ...         "CGroup" : 7,
+    ...         "DGroup" : 8
+    ...     },
+    ...     "CGroup" : {
+    ...         "A" : 9,
+    ...         "B" : 10,
+    ...         "CGroup" : 11,
+    ...         "DGroup" : 12
+    ...     },
+    ... }
+    >>> testGroups = {
+    ...     "BGroup" : ["B"],
+    ...     "CGroup" : ["C"],
+    ...     "DGroup" : ["D"],
+    ... }
+    >>> kerning, groups, maps = convertUFO1OrUFO2KerningToUFO3Kerning(
+    ...     testKerning, testGroups, [])
+    >>> expected = {
+    ...     "A" : {
+    ...         "A": 1,
+    ...         "B": 2,
+    ...         "public.kern2.CGroup": 3,
+    ...         "public.kern2.DGroup": 4
+    ...     },
+    ...     "public.kern1.BGroup": {
+    ...         "A": 5,
+    ...         "B": 6,
+    ...         "public.kern2.CGroup": 7,
+    ...         "public.kern2.DGroup": 8
+    ...     },
+    ...     "public.kern1.CGroup": {
+    ...         "A": 9,
+    ...         "B": 10,
+    ...         "public.kern2.CGroup": 11,
+    ...         "public.kern2.DGroup": 12
+    ...     }
+    ... }
+    >>> kerning == expected
+    True
+    >>> expected = {
+    ...     "BGroup": ["B"],
+    ...     "CGroup": ["C"],
+    ...     "DGroup": ["D"],
+    ...     "public.kern1.BGroup": ["B"],
+    ...     "public.kern1.CGroup": ["C"],
+    ...     "public.kern2.CGroup": ["C"],
+    ...     "public.kern2.DGroup": ["D"],
+    ... }
+    >>> groups == expected
+    True
+
+    Known prefixes.
+
+    >>> testKerning = {
+    ...     "A" : {
+    ...         "A" : 1,
+    ...         "B" : 2,
+    ...         "@MMK_R_CGroup" : 3,
+    ...         "@MMK_R_DGroup" : 4
+    ...     },
+    ...     "@MMK_L_BGroup" : {
+    ...         "A" : 5,
+    ...         "B" : 6,
+    ...         "@MMK_R_CGroup" : 7,
+    ...         "@MMK_R_DGroup" : 8
+    ...     },
+    ...     "@MMK_L_CGroup" : {
+    ...         "A" : 9,
+    ...         "B" : 10,
+    ...         "@MMK_R_CGroup" : 11,
+    ...         "@MMK_R_DGroup" : 12
+    ...     },
+    ... }
+    >>> testGroups = {
+    ...     "@MMK_L_BGroup" : ["B"],
+    ...     "@MMK_L_CGroup" : ["C"],
+    ...     "@MMK_L_XGroup" : ["X"],
+    ...     "@MMK_R_CGroup" : ["C"],
+    ...     "@MMK_R_DGroup" : ["D"],
+    ...     "@MMK_R_XGroup" : ["X"],
+    ... }
+    >>> kerning, groups, maps = convertUFO1OrUFO2KerningToUFO3Kerning(
+    ...     testKerning, testGroups, [])
+    >>> expected = {
+    ...     "A" : {
+    ...         "A": 1,
+    ...         "B": 2,
+    ...         "public.kern2.CGroup": 3,
+    ...         "public.kern2.DGroup": 4
+    ...     },
+    ...     "public.kern1.BGroup": {
+    ...         "A": 5,
+    ...         "B": 6,
+    ...         "public.kern2.CGroup": 7,
+    ...         "public.kern2.DGroup": 8
+    ...     },
+    ...     "public.kern1.CGroup": {
+    ...         "A": 9,
+    ...         "B": 10,
+    ...         "public.kern2.CGroup": 11,
+    ...         "public.kern2.DGroup": 12
+    ...     }
+    ... }
+    >>> kerning == expected
+    True
+    >>> expected = {
+    ...     "@MMK_L_BGroup": ["B"],
+    ...     "@MMK_L_CGroup": ["C"],
+    ...     "@MMK_L_XGroup": ["X"],
+    ...     "@MMK_R_CGroup": ["C"],
+    ...     "@MMK_R_DGroup": ["D"],
+    ...     "@MMK_R_XGroup": ["X"],
+    ...     "public.kern1.BGroup": ["B"],
+    ...     "public.kern1.CGroup": ["C"],
+    ...     "public.kern1.XGroup": ["X"],
+    ...     "public.kern2.CGroup": ["C"],
+    ...     "public.kern2.DGroup": ["D"],
+    ...     "public.kern2.XGroup": ["X"],
+    ... }
+    >>> groups == expected
+    True
+
+    >>> from .validators import kerningValidator
+    >>> kerningValidator(kerning)
+    (True, None)
+
+    Mixture of known prefixes and groups without prefixes.
+
+    >>> testKerning = {
+    ...     "A" : {
+    ...         "A" : 1,
+    ...         "B" : 2,
+    ...         "@MMK_R_CGroup" : 3,
+    ...         "DGroup" : 4
+    ...     },
+    ...     "BGroup" : {
+    ...         "A" : 5,
+    ...         "B" : 6,
+    ...         "@MMK_R_CGroup" : 7,
+    ...         "DGroup" : 8
+    ...     },
+    ...     "@MMK_L_CGroup" : {
+    ...         "A" : 9,
+    ...         "B" : 10,
+    ...         "@MMK_R_CGroup" : 11,
+    ...         "DGroup" : 12
+    ...     },
+    ... }
+    >>> testGroups = {
+    ...     "BGroup" : ["B"],
+    ...     "@MMK_L_CGroup" : ["C"],
+    ...     "@MMK_R_CGroup" : ["C"],
+    ...     "DGroup" : ["D"],
+    ... }
+    >>> kerning, groups, maps = convertUFO1OrUFO2KerningToUFO3Kerning(
+    ...     testKerning, testGroups, [])
+    >>> expected = {
+    ...     "A" : {
+    ...         "A": 1,
+    ...         "B": 2,
+    ...         "public.kern2.CGroup": 3,
+    ...         "public.kern2.DGroup": 4
+    ...     },
+    ...     "public.kern1.BGroup": {
+    ...         "A": 5,
+    ...         "B": 6,
+    ...         "public.kern2.CGroup": 7,
+    ...         "public.kern2.DGroup": 8
+    ...     },
+    ...     "public.kern1.CGroup": {
+    ...         "A": 9,
+    ...         "B": 10,
+    ...         "public.kern2.CGroup": 11,
+    ...         "public.kern2.DGroup": 12
+    ...     }
+    ... }
+    >>> kerning == expected
+    True
+    >>> expected = {
+    ...     "BGroup": ["B"],
+    ...     "@MMK_L_CGroup": ["C"],
+    ...     "@MMK_R_CGroup": ["C"],
+    ...     "DGroup": ["D"],
+    ...     "public.kern1.BGroup": ["B"],
+    ...     "public.kern1.CGroup": ["C"],
+    ...     "public.kern2.CGroup": ["C"],
+    ...     "public.kern2.DGroup": ["D"],
+    ... }
+    >>> groups == expected
+    True
+    """
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

fontTools/ufoLib/errors.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+
+class UFOLibError(Exception):
+    pass
+
+
+class UnsupportedUFOFormat(UFOLibError):
+    pass
+
+
+class GlifLibError(UFOLibError):
+    """An error raised by glifLib.
+
+    This class is a loose backport of PEP 678, adding a :attr:`.note`
+    attribute that can hold additional context for errors encountered.
+
+    It will be maintained until only Python 3.11-and-later are supported.
+    """
+
+    def _add_note(self, note: str) -> None:
+        # Loose backport of PEP 678 until we only support Python 3.11+, used for
+        # adding additional context to errors.
+        # TODO: Replace with https://docs.python.org/3.11/library/exceptions.html#BaseException.add_note
+        (message, *rest) = self.args
+        self.args = ((message + "\n" + note), *rest)
+
+
+class UnsupportedGLIFFormat(GlifLibError):
+    pass

fontTools/ufoLib/etree.py

@@ -0,0 +1,6 @@
+"""DEPRECATED - This module is kept here only as a backward compatibility shim
+for the old ufoLib.etree module, which was moved to :mod:`fontTools.misc.etree`.
+Please use the latter instead.
+"""
+
+from fontTools.misc.etree import *