fonttools 4.59.1__cp39-cp39-win32.whl → 4.60.0__cp39-cp39-win32.whl

fontTools/__init__.py

@@ -3,6 +3,6 @@ from fontTools.misc.loggingTools import configLogger
 
 log = logging.getLogger(__name__)
 
-version = __version__ = "4.59.1"
+version = __version__ = "4.60.0"
 
 __all__ = ["version", "log", "configLogger"]

fontTools/annotations.py

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

fontTools/cu2qu/cu2qu.py

@@ -37,7 +37,7 @@ NAN = float("NaN")
 @cython.cfunc
 @cython.inline
 @cython.returns(cython.double)
-@cython.locals(v1=cython.complex, v2=cython.complex)
+@cython.locals(v1=cython.complex, v2=cython.complex, result=cython.double)
 def dot(v1, v2):
     """Return the dot product of two vectors.
 
@@ -48,7 +48,33 @@ def dot(v1, v2):
     Returns:
         double: Dot product.
     """
-    return (v1 * v2.conjugate()).real
+    result = (v1 * v2.conjugate()).real
+    # When vectors are perpendicular (i.e. dot product is 0), the above expression may
+    # yield slightly different results when running in pure Python vs C/Cython,
+    # both of which are correct within IEEE-754 floating-point precision.
+    # It's probably due to the different order of operations and roundings in each
+    # implementation. Because we are using the result in a denominator and catching
+    # ZeroDivisionError (see `calc_intersect`), it's best to normalize the result here.
+    if abs(result) < 1e-15:
+        result = 0.0
+    return result
+
+
+@cython.cfunc
+@cython.locals(z=cython.complex, den=cython.double)
+@cython.locals(zr=cython.double, zi=cython.double)
+def _complex_div_by_real(z, den):
+    """Divide complex by real using Python's method (two separate divisions).
+
+    This ensures bit-exact compatibility with Python's complex division,
+    avoiding C's multiply-by-reciprocal optimization that can cause 1 ULP differences
+    on some platforms/compilers (e.g. clang on macOS arm64).
+
+    https://github.com/fonttools/fonttools/issues/3928
+    """
+    zr = z.real
+    zi = z.imag
+    return complex(zr / den, zi / den)
 
 
 @cython.cfunc
@@ -59,8 +85,8 @@ def dot(v1, v2):
 )
 def calc_cubic_points(a, b, c, d):
     _1 = d
-    _2 = (c / 3.0) + d
-    _3 = (b + c) / 3.0 + _2
+    _2 = _complex_div_by_real(c, 3.0) + d
+    _3 = _complex_div_by_real(b + c, 3.0) + _2
     _4 = a + d + c + b
     return _1, _2, _3, _4
 
@@ -273,6 +299,12 @@ def calc_intersect(a, b, c, d):
     try:
         h = dot(p, a - c) / dot(p, cd)
     except ZeroDivisionError:
+        # if 3 or 4 points are equal, we do have an intersection despite the zero-div:
+        # return one of the off-curves so that the algorithm can attempt a one-curve
+        # solution if it's within tolerance:
+        # https://github.com/linebender/kurbo/pull/484
+        if b == c and (a == b or c == d):
+            return b
         return complex(NAN, NAN)
     return c + cd * h
 

fontTools/feaLib/builder.py

@@ -32,6 +32,7 @@ from fontTools.otlLib.builder import (
     AnySubstBuilder,
 )
 from fontTools.otlLib.error import OpenTypeLibError
+from fontTools.varLib.errors import VarLibError
 from fontTools.varLib.varStore import OnlineVarStoreBuilder
 from fontTools.varLib.builder import buildVarDevTable
 from fontTools.varLib.featureVars import addFeatureVariationsRaw
@@ -1728,9 +1729,14 @@ class Builder(object):
         if not varscalar.does_vary:
             return varscalar.default, None
 
-        default, index = varscalar.add_to_variation_store(
-            self.varstorebuilder, self.model_cache, self.font.get("avar")
-        )
+        try:
+            default, index = varscalar.add_to_variation_store(
+                self.varstorebuilder, self.model_cache, self.font.get("avar")
+            )
+        except VarLibError as e:
+            raise FeatureLibError(
+                "Failed to compute deltas for variable scalar", location
+            ) from e
 
         device = None
         if index is not None and index != 0xFFFFFFFF:

fontTools/feaLib/parser.py

@@ -2198,7 +2198,7 @@ class Parser(object):
                 raise FeatureLibError(
                     "Expected an equals sign", self.cur_token_location_
                 )
-            value = self.expect_number_()
+            value = self.expect_integer_or_float_()
             location[axis] = value
             if self.next_token_type_ is Lexer.NAME and self.next_token_[0] == ":":
                 # Lexer has just read the value as a glyph name. We'll correct it later
@@ -2230,6 +2230,16 @@ class Parser(object):
             "Expected a floating-point number", self.cur_token_location_
         )
 
+    def expect_integer_or_float_(self):
+        if self.next_token_type_ == Lexer.FLOAT:
+            return self.expect_float_()
+        elif self.next_token_type_ is Lexer.NUMBER:
+            return self.expect_number_()
+        else:
+            raise FeatureLibError(
+                "Expected an integer or floating-point number", self.cur_token_location_
+            )
+
     def expect_decipoint_(self):
         if self.next_token_type_ == Lexer.FLOAT:
             return self.expect_float_()

fontTools/feaLib/variableScalar.py

@@ -17,7 +17,12 @@ class VariableScalar:
     def __repr__(self):
         items = []
         for location, value in self.values.items():
-            loc = ",".join(["%s=%i" % (ax, loc) for ax, loc in location])
+            loc = ",".join(
+                [
+                    f"{ax}={int(coord) if float(coord).is_integer() else coord}"
+                    for ax, coord in location
+                ]
+            )
             items.append("%s:%i" % (loc, value))
         return "(" + (" ".join(items)) + ")"
 

fontTools/misc/enumTools.py

@@ -0,0 +1,23 @@
+"""Enum-related utilities, including backports for older Python versions."""
+
+from __future__ import annotations
+
+from enum import Enum
+
+
+__all__ = ["StrEnum"]
+
+# StrEnum is only available in Python 3.11+
+try:
+    from enum import StrEnum
+except ImportError:
+
+    class StrEnum(str, Enum):
+        """
+        Minimal backport of Python 3.11's StrEnum for older versions.
+
+        An Enum where all members are also strings.
+        """
+
+        def __str__(self) -> str:
+            return self.value

fontTools/misc/textTools.py

@@ -1,5 +1,7 @@
 """fontTools.misc.textTools.py -- miscellaneous routines."""
 
+from __future__ import annotations
+
 import ast
 import string
 
@@ -118,14 +120,14 @@ def pad(data, size):
     return data
 
 
-def tostr(s, encoding="ascii", errors="strict"):
+def tostr(s: str | bytes, encoding: str = "ascii", errors: str = "strict") -> str:
     if not isinstance(s, str):
         return s.decode(encoding, errors)
     else:
         return s
 
 
-def tobytes(s, encoding="ascii", errors="strict"):
+def tobytes(s: str | bytes, encoding: str = "ascii", errors: str = "strict") -> bytes:
     if isinstance(s, str):
         return s.encode(encoding, errors)
     else:

fontTools/pens/filterPen.py

@@ -1,7 +1,11 @@
 from __future__ import annotations
 
 from fontTools.pens.basePen import AbstractPen, DecomposingPen
-from fontTools.pens.pointPen import AbstractPointPen, DecomposingPointPen
+from fontTools.pens.pointPen import (
+    AbstractPointPen,
+    DecomposingPointPen,
+    ReverseFlipped,
+)
 from fontTools.pens.recordingPen import RecordingPen
 
 
@@ -155,26 +159,61 @@ class FilterPointPen(_PassThruComponentsMixin, AbstractPointPen):
     def __init__(self, outPen):
         self._outPen = outPen
 
-    def beginPath(self, **kwargs):
+    def beginPath(self, identifier=None, **kwargs):
+        kwargs = dict(kwargs)
+        if identifier is not None:
+            kwargs["identifier"] = identifier
         self._outPen.beginPath(**kwargs)
 
     def endPath(self):
         self._outPen.endPath()
 
-    def addPoint(self, pt, segmentType=None, smooth=False, name=None, **kwargs):
+    def addPoint(
+        self,
+        pt,
+        segmentType=None,
+        smooth=False,
+        name=None,
+        identifier=None,
+        **kwargs,
+    ):
+        kwargs = dict(kwargs)
+        if identifier is not None:
+            kwargs["identifier"] = identifier
         self._outPen.addPoint(pt, segmentType, smooth, name, **kwargs)
 
 
-class _DecomposingFilterPenMixin:
-    """Mixin class that decomposes components as regular contours.
+class _DecomposingFilterMixinBase:
+    """Base mixin class with common `addComponent` logic for decomposing filter pens."""
+
+    def addComponent(self, baseGlyphName, transformation, **kwargs):
+        # only decompose the component if it's included in the set
+        if self.include is None or baseGlyphName in self.include:
+            # if we're decomposing nested components, temporarily set include to None
+            include_bak = self.include
+            if self.decomposeNested and self.include:
+                self.include = None
+            try:
+                super().addComponent(baseGlyphName, transformation, **kwargs)
+            finally:
+                if self.include != include_bak:
+                    self.include = include_bak
+        else:
+            _PassThruComponentsMixin.addComponent(
+                self, baseGlyphName, transformation, **kwargs
+            )
+
+
+class _DecomposingFilterPenMixin(_DecomposingFilterMixinBase):
+    """Mixin class that decomposes components as regular contours for segment pens.
 
-    Shared by both DecomposingFilterPen and DecomposingFilterPointPen.
+    Used by DecomposingFilterPen.
 
-    Takes two required parameters, another (segment or point) pen 'outPen' to draw
+    Takes two required parameters, another segment pen 'outPen' to draw
     with, and a 'glyphSet' dict of drawable glyph objects to draw components from.
 
     The 'skipMissingComponents' and 'reverseFlipped' optional arguments work the
-    same as in the DecomposingPen/DecomposingPointPen. Both are False by default.
+    same as in the DecomposingPen. reverseFlipped is bool only (True/False).
 
     In addition, the decomposing filter pens also take the following two options:
 
@@ -196,35 +235,69 @@ class _DecomposingFilterPenMixin:
         outPen,
         glyphSet,
         skipMissingComponents=None,
-        reverseFlipped=False,
+        reverseFlipped: bool = False,
         include: set[str] | None = None,
         decomposeNested: bool = True,
+        **kwargs,
     ):
+        assert isinstance(
+            reverseFlipped, bool
+        ), f"Expected bool, got {type(reverseFlipped).__name__}"
         super().__init__(
             outPen=outPen,
             glyphSet=glyphSet,
             skipMissingComponents=skipMissingComponents,
             reverseFlipped=reverseFlipped,
+            **kwargs,
         )
         self.include = include
         self.decomposeNested = decomposeNested
 
-    def addComponent(self, baseGlyphName, transformation, **kwargs):
-        # only decompose the component if it's included in the set
-        if self.include is None or baseGlyphName in self.include:
-            # if we're decomposing nested components, temporarily set include to None
-            include_bak = self.include
-            if self.decomposeNested and self.include:
-                self.include = None
-            try:
-                super().addComponent(baseGlyphName, transformation, **kwargs)
-            finally:
-                if self.include != include_bak:
-                    self.include = include_bak
-        else:
-            _PassThruComponentsMixin.addComponent(
-                self, baseGlyphName, transformation, **kwargs
-            )
+
+class _DecomposingFilterPointPenMixin(_DecomposingFilterMixinBase):
+    """Mixin class that decomposes components as regular contours for point pens.
+
+    Takes two required parameters, another point pen 'outPen' to draw
+    with, and a 'glyphSet' dict of drawable glyph objects to draw components from.
+
+    The 'skipMissingComponents' and 'reverseFlipped' optional arguments work the
+    same as in the DecomposingPointPen. reverseFlipped accepts bool | ReverseFlipped
+    (see DecomposingPointPen).
+
+    In addition, the decomposing filter pens also take the following two options:
+
+    'include' is an optional set of component base glyph names to consider for
+    decomposition; the default include=None means decompose all components no matter
+    the base glyph name).
+
+    'decomposeNested' (bool) controls whether to recurse decomposition into nested
+    components of components (this only matters when 'include' was also provided);
+    if False, only decompose top-level components included in the set, but not
+    also their children.
+    """
+
+    # raises MissingComponentError if base glyph is not found in glyphSet
+    skipMissingComponents = False
+
+    def __init__(
+        self,
+        outPen,
+        glyphSet,
+        skipMissingComponents=None,
+        reverseFlipped: bool | ReverseFlipped = False,
+        include: set[str] | None = None,
+        decomposeNested: bool = True,
+        **kwargs,
+    ):
+        super().__init__(
+            outPen=outPen,
+            glyphSet=glyphSet,
+            skipMissingComponents=skipMissingComponents,
+            reverseFlipped=reverseFlipped,
+            **kwargs,
+        )
+        self.include = include
+        self.decomposeNested = decomposeNested
 
 
 class DecomposingFilterPen(_DecomposingFilterPenMixin, DecomposingPen, FilterPen):
@@ -234,8 +307,127 @@ class DecomposingFilterPen(_DecomposingFilterPenMixin, DecomposingPen, FilterPen
 
 
 class DecomposingFilterPointPen(
-    _DecomposingFilterPenMixin, DecomposingPointPen, FilterPointPen
+    _DecomposingFilterPointPenMixin, DecomposingPointPen, FilterPointPen
 ):
     """Filter point pen that draws components as regular contours."""
 
     pass
+
+
+class ContourFilterPointPen(_PassThruComponentsMixin, AbstractPointPen):
+    """A "buffered" filter point pen that accumulates contour data, passes
+    it through a ``filterContour`` method when the contour is closed or ended,
+    and finally draws the result with the output point pen.
+
+    Components are passed through unchanged.
+
+    The ``filterContour`` method can modify the contour in-place (return None)
+    or return a new contour to replace it.
+    """
+
+    def __init__(self, outPen):
+        self._outPen = outPen
+        self.currentContour = None
+        self.currentContourKwargs = None
+
+    def beginPath(self, identifier=None, **kwargs):
+        if self.currentContour is not None:
+            raise ValueError("Path already begun")
+        kwargs = dict(kwargs)
+        if identifier is not None:
+            kwargs["identifier"] = identifier
+        self.currentContour = []
+        self.currentContourKwargs = kwargs
+
+    def endPath(self):
+        if self.currentContour is None:
+            raise ValueError("Path not begun")
+        self._flushContour()
+        self.currentContour = None
+        self.currentContourKwargs = None
+
+    def _flushContour(self):
+        """Flush the current contour to the output pen."""
+        result = self.filterContour(self.currentContour)
+        if result is not None:
+            self.currentContour = result
+
+        # Draw the filtered contour
+        self._outPen.beginPath(**self.currentContourKwargs)
+        for pt, segmentType, smooth, name, kwargs in self.currentContour:
+            self._outPen.addPoint(pt, segmentType, smooth, name, **kwargs)
+        self._outPen.endPath()
+
+    def filterContour(self, contour):
+        """Subclasses must override this to perform the filtering.
+
+        The contour is a list of (pt, segmentType, smooth, name, kwargs) tuples.
+        If the method doesn't return a value (i.e. returns None), it's
+        assumed that the contour was modified in-place.
+        Otherwise, the return value replaces the original contour.
+        """
+        return  # or return contour
+
+    def addPoint(
+        self,
+        pt,
+        segmentType=None,
+        smooth=False,
+        name=None,
+        identifier=None,
+        **kwargs,
+    ):
+        if self.currentContour is None:
+            raise ValueError("Path not begun")
+        kwargs = dict(kwargs)
+        if identifier is not None:
+            kwargs["identifier"] = identifier
+        self.currentContour.append((pt, segmentType, smooth, name, kwargs))
+
+
+class OnCurveFirstPointPen(ContourFilterPointPen):
+    """Filter point pen that ensures closed contours start with an on-curve point.
+
+    If a closed contour starts with an off-curve point (segmentType=None), it rotates
+    the points list so that the first on-curve point (segmentType != None) becomes
+    the start point. Open contours and contours already starting with on-curve points
+    are passed through unchanged.
+
+    >>> from fontTools.pens.recordingPen import RecordingPointPen
+    >>> rec = RecordingPointPen()
+    >>> pen = OnCurveFirstPointPen(rec)
+    >>> # Closed contour starting with off-curve - will be rotated
+    >>> pen.beginPath()
+    >>> pen.addPoint((0, 0), None)  # off-curve
+    >>> pen.addPoint((100, 100), "line")  # on-curve - will become start
+    >>> pen.addPoint((200, 0), None)  # off-curve
+    >>> pen.addPoint((300, 100), "curve")  # on-curve
+    >>> pen.endPath()
+    >>> # The contour should now start with (100, 100) "line"
+    >>> rec.value[0]
+    ('beginPath', (), {})
+    >>> rec.value[1]
+    ('addPoint', ((100, 100), 'line', False, None), {})
+    >>> rec.value[2]
+    ('addPoint', ((200, 0), None, False, None), {})
+    >>> rec.value[3]
+    ('addPoint', ((300, 100), 'curve', False, None), {})
+    >>> rec.value[4]
+    ('addPoint', ((0, 0), None, False, None), {})
+    """
+
+    def filterContour(self, contour):
+        """Rotate closed contour to start with first on-curve point if needed."""
+        if not contour:
+            return
+
+        # Check if it's a closed contour (no "move" segmentType)
+        is_closed = contour[0][1] != "move"
+
+        if is_closed and contour[0][1] is None:
+            # Closed contour starting with off-curve - need to rotate
+            # Find the first on-curve point
+            for i, (pt, segmentType, smooth, name, kwargs) in enumerate(contour):
+                if segmentType is not None:
+                    # Rotate the points list so it starts with the first on-curve point
+                    return contour[i:] + contour[:i]

fontTools/pens/pointPen.py

@@ -17,6 +17,7 @@ from __future__ import annotations
 import math
 from typing import Any, Dict, List, Optional, Tuple
 
+from fontTools.misc.enumTools import StrEnum
 from fontTools.misc.loggingTools import LogMixin
 from fontTools.misc.transform import DecomposedTransform, Identity
 from fontTools.pens.basePen import AbstractPen, MissingComponentError, PenError
@@ -28,6 +29,7 @@ __all__ = [
     "SegmentToPointPen",
     "GuessSmoothPointPen",
     "ReverseContourPointPen",
+    "ReverseFlipped",
 ]
 
 # Some type aliases to make it easier below
@@ -39,6 +41,19 @@ SegmentType = Optional[str]
 SegmentList = List[Tuple[SegmentType, SegmentPointList]]
 
 
+class ReverseFlipped(StrEnum):
+    """How to handle flipped components during decomposition.
+
+    NO: Don't reverse flipped components
+    KEEP_START: Reverse flipped components, keeping original starting point
+    ON_CURVE_FIRST: Reverse flipped components, ensuring first point is on-curve
+    """
+
+    NO = "no"
+    KEEP_START = "keep_start"
+    ON_CURVE_FIRST = "on_curve_first"
+
+
 class AbstractPointPen:
     """Baseclass for all PointPens."""
 
@@ -559,15 +574,20 @@ class DecomposingPointPen(LogMixin, AbstractPointPen):
         glyphSet,
         *args,
         skipMissingComponents=None,
-        reverseFlipped=False,
+        reverseFlipped: bool | ReverseFlipped = False,
         **kwargs,
     ):
         """Takes a 'glyphSet' argument (dict), in which the glyphs that are referenced
         as components are looked up by their name.
 
-        If the optional 'reverseFlipped' argument is True, components whose transformation
-        matrix has a negative determinant will be decomposed with a reversed path direction
-        to compensate for the flip.
+        If the optional 'reverseFlipped' argument is True or a ReverseFlipped enum value,
+        components whose transformation matrix has a negative determinant will be decomposed
+        with a reversed path direction to compensate for the flip.
+
+        The reverseFlipped parameter can be:
+        - False or ReverseFlipped.NO: Don't reverse flipped components
+        - True or ReverseFlipped.KEEP_START: Reverse, keeping original starting point
+        - ReverseFlipped.ON_CURVE_FIRST: Reverse, ensuring first point is on-curve
 
         The optional 'skipMissingComponents' argument can be set to True/False to
         override the homonymous class attribute for a given pen instance.
@@ -579,7 +599,13 @@ class DecomposingPointPen(LogMixin, AbstractPointPen):
             if skipMissingComponents is None
             else skipMissingComponents
         )
-        self.reverseFlipped = reverseFlipped
+        # Handle backward compatibility and validate string inputs
+        if reverseFlipped is False:
+            self.reverseFlipped = ReverseFlipped.NO
+        elif reverseFlipped is True:
+            self.reverseFlipped = ReverseFlipped.KEEP_START
+        else:
+            self.reverseFlipped = ReverseFlipped(reverseFlipped)
 
     def addComponent(self, baseGlyphName, transformation, identifier=None, **kwargs):
         """Transform the points of the base glyph and draw it onto self.
@@ -600,10 +626,18 @@ class DecomposingPointPen(LogMixin, AbstractPointPen):
             pen = self
             if transformation != Identity:
                 pen = TransformPointPen(pen, transformation)
-            if self.reverseFlipped:
+            if self.reverseFlipped != ReverseFlipped.NO:
                 # if the transformation has a negative determinant, it will
                 # reverse the contour direction of the component
                 a, b, c, d = transformation[:4]
                 if a * d - b * c < 0:
                     pen = ReverseContourPointPen(pen)
+
+                    if self.reverseFlipped == ReverseFlipped.ON_CURVE_FIRST:
+                        from fontTools.pens.filterPen import OnCurveFirstPointPen
+
+                        # Ensure the starting point is an on-curve.
+                        # Wrap last so this filter runs first during drawPoints
+                        pen = OnCurveFirstPointPen(pen)
+
             glyph.drawPoints(pen)

fontTools/subset/__init__.py

@@ -1530,6 +1530,7 @@ def subset_glyphs(self, s):
         if self.MarkFilteringSet not in s.used_mark_sets:
             self.MarkFilteringSet = None
             self.LookupFlag &= ~0x10
+            self.LookupFlag |= 0x8
         else:
             self.MarkFilteringSet = s.used_mark_sets.index(self.MarkFilteringSet)
     return bool(self.SubTableCount)

fontTools/ttLib/tables/_a_v_a_r.py

@@ -143,7 +143,7 @@ class table__a_v_a_r(BaseTTXConverter):
         else:
             super().fromXML(name, attrs, content, ttFont)
 
-    def renormalizeLocation(self, location, font):
+    def renormalizeLocation(self, location, font, dropZeroes=True):
 
         majorVersion = getattr(self, "majorVersion", 1)
 
@@ -185,7 +185,9 @@ class table__a_v_a_r(BaseTTXConverter):
             out.append(v)
 
         mappedLocation = {
-            axis.axisTag: fi2fl(v, 14) for v, axis in zip(out, axes) if v != 0
+            axis.axisTag: fi2fl(v, 14)
+            for v, axis in zip(out, axes)
+            if v != 0 or not dropZeroes
         }
 
         return mappedLocation