fonttools 4.55.6__cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

fontTools/ufoLib/kerning.py

@@ -0,0 +1,91 @@
+def lookupKerningValue(
+    pair, kerning, groups, fallback=0, glyphToFirstGroup=None, glyphToSecondGroup=None
+):
+    """
+    Note: This expects kerning to be a flat dictionary
+    of kerning pairs, not the nested structure used
+    in kerning.plist.
+
+    >>> groups = {
+    ...     "public.kern1.O" : ["O", "D", "Q"],
+    ...     "public.kern2.E" : ["E", "F"]
+    ... }
+    >>> kerning = {
+    ...     ("public.kern1.O", "public.kern2.E") : -100,
+    ...     ("public.kern1.O", "F") : -200,
+    ...     ("D", "F") : -300
+    ... }
+    >>> lookupKerningValue(("D", "F"), kerning, groups)
+    -300
+    >>> lookupKerningValue(("O", "F"), kerning, groups)
+    -200
+    >>> lookupKerningValue(("O", "E"), kerning, groups)
+    -100
+    >>> lookupKerningValue(("O", "O"), kerning, groups)
+    0
+    >>> lookupKerningValue(("E", "E"), kerning, groups)
+    0
+    >>> lookupKerningValue(("E", "O"), kerning, groups)
+    0
+    >>> lookupKerningValue(("X", "X"), kerning, groups)
+    0
+    >>> lookupKerningValue(("public.kern1.O", "public.kern2.E"),
+    ...     kerning, groups)
+    -100
+    >>> lookupKerningValue(("public.kern1.O", "F"), kerning, groups)
+    -200
+    >>> lookupKerningValue(("O", "public.kern2.E"), kerning, groups)
+    -100
+    >>> lookupKerningValue(("public.kern1.X", "public.kern2.X"), kerning, groups)
+    0
+    """
+    # quickly check to see if the pair is in the kerning dictionary
+    if pair in kerning:
+        return kerning[pair]
+    # create glyph to group mapping
+    if glyphToFirstGroup is not None:
+        assert glyphToSecondGroup is not None
+    if glyphToSecondGroup is not None:
+        assert glyphToFirstGroup is not None
+    if glyphToFirstGroup is None:
+        glyphToFirstGroup = {}
+        glyphToSecondGroup = {}
+        for group, groupMembers in groups.items():
+            if group.startswith("public.kern1."):
+                for glyph in groupMembers:
+                    glyphToFirstGroup[glyph] = group
+            elif group.startswith("public.kern2."):
+                for glyph in groupMembers:
+                    glyphToSecondGroup[glyph] = group
+    # get group names and make sure first and second are glyph names
+    first, second = pair
+    firstGroup = secondGroup = None
+    if first.startswith("public.kern1."):
+        firstGroup = first
+        first = None
+    else:
+        firstGroup = glyphToFirstGroup.get(first)
+    if second.startswith("public.kern2."):
+        secondGroup = second
+        second = None
+    else:
+        secondGroup = glyphToSecondGroup.get(second)
+    # make an ordered list of pairs to look up
+    pairs = [
+        (first, second),
+        (first, secondGroup),
+        (firstGroup, second),
+        (firstGroup, secondGroup),
+    ]
+    # look up the pairs and return any matches
+    for pair in pairs:
+        if pair in kerning:
+            return kerning[pair]
+    # use the fallback value
+    return fallback
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

fontTools/ufoLib/plistlib.py

@@ -0,0 +1,47 @@
+"""DEPRECATED - This module is kept here only as a backward compatibility shim
+for the old `ufoLib.plistlib` module, which was moved to :class:`fontTools.misc.plistlib`.
+Please use the latter instead.
+"""
+
+from fontTools.misc.plistlib import dump, dumps, load, loads
+from fontTools.misc.textTools import tobytes
+
+# The following functions were part of the old py2-like ufoLib.plistlib API.
+# They are kept only for backward compatiblity.
+from fontTools.ufoLib.utils import deprecated
+
+
+@deprecated("Use 'fontTools.misc.plistlib.load' instead")
+def readPlist(path_or_file):
+    did_open = False
+    if isinstance(path_or_file, str):
+        path_or_file = open(path_or_file, "rb")
+        did_open = True
+    try:
+        return load(path_or_file, use_builtin_types=False)
+    finally:
+        if did_open:
+            path_or_file.close()
+
+
+@deprecated("Use 'fontTools.misc.plistlib.dump' instead")
+def writePlist(value, path_or_file):
+    did_open = False
+    if isinstance(path_or_file, str):
+        path_or_file = open(path_or_file, "wb")
+        did_open = True
+    try:
+        dump(value, path_or_file, use_builtin_types=False)
+    finally:
+        if did_open:
+            path_or_file.close()
+
+
+@deprecated("Use 'fontTools.misc.plistlib.loads' instead")
+def readPlistFromString(data):
+    return loads(tobytes(data, encoding="utf-8"), use_builtin_types=False)
+
+
+@deprecated("Use 'fontTools.misc.plistlib.dumps' instead")
+def writePlistToString(value):
+    return dumps(value, use_builtin_types=False)

fontTools/ufoLib/pointPen.py

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

fontTools/ufoLib/utils.py

@@ -0,0 +1,76 @@
+"""The module contains miscellaneous helpers.
+It's not considered part of the public ufoLib API.
+"""
+
+import warnings
+import functools
+
+
+numberTypes = (int, float)
+
+
+def deprecated(msg=""):
+    """Decorator factory to mark functions as deprecated with given message.
+
+    >>> @deprecated("Enough!")
+    ... def some_function():
+    ...    "I just print 'hello world'."
+    ...    print("hello world")
+    >>> some_function()
+    hello world
+    >>> some_function.__doc__ == "I just print 'hello world'."
+    True
+    """
+
+    def deprecated_decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            warnings.warn(
+                f"{func.__name__} function is a deprecated. {msg}",
+                category=DeprecationWarning,
+                stacklevel=2,
+            )
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return deprecated_decorator
+
+
+# To be mixed with enum.Enum in UFOFormatVersion and GLIFFormatVersion
+class _VersionTupleEnumMixin:
+    @property
+    def major(self):
+        return self.value[0]
+
+    @property
+    def minor(self):
+        return self.value[1]
+
+    @classmethod
+    def _missing_(cls, value):
+        # allow to initialize a version enum from a single (major) integer
+        if isinstance(value, int):
+            return cls((value, 0))
+        # or from None to obtain the current default version
+        if value is None:
+            return cls.default()
+        return super()._missing_(value)
+
+    def __str__(self):
+        return f"{self.major}.{self.minor}"
+
+    @classmethod
+    def default(cls):
+        # get the latest defined version (i.e. the max of all versions)
+        return max(cls.__members__.values())
+
+    @classmethod
+    def supported_versions(cls):
+        return frozenset(cls.__members__.values())
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()