fonttools 4.59.2__cp313-cp313-win_amd64.whl → 4.60.1__cp313-cp313-win_amd64.whl

fontTools/cu2qu/cu2qu.py

@@ -60,6 +60,23 @@ def dot(v1, v2):
     return result
 
 
+@cython.cfunc
+@cython.locals(z=cython.complex, den=cython.double)
+@cython.locals(zr=cython.double, zi=cython.double)
+def _complex_div_by_real(z, den):
+    """Divide complex by real using Python's method (two separate divisions).
+
+    This ensures bit-exact compatibility with Python's complex division,
+    avoiding C's multiply-by-reciprocal optimization that can cause 1 ULP differences
+    on some platforms/compilers (e.g. clang on macOS arm64).
+
+    https://github.com/fonttools/fonttools/issues/3928
+    """
+    zr = z.real
+    zi = z.imag
+    return complex(zr / den, zi / den)
+
+
 @cython.cfunc
 @cython.inline
 @cython.locals(a=cython.complex, b=cython.complex, c=cython.complex, d=cython.complex)
@@ -68,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
 

fontTools/feaLib/lexer.c

@@ -1,4 +1,4 @@
-/* Generated by Cython 3.1.3 */
+/* Generated by Cython 3.1.4 */
 
 /* BEGIN: Cython Metadata
 {
@@ -26,8 +26,8 @@ END: Cython Metadata */
 #elif PY_VERSION_HEX < 0x03080000
     #error Cython requires Python 3.8+.
 #else
-#define __PYX_ABI_VERSION "3_1_3"
-#define CYTHON_HEX_VERSION 0x030103F0
+#define __PYX_ABI_VERSION "3_1_4"
+#define CYTHON_HEX_VERSION 0x030104F0
 #define CYTHON_FUTURE_DIVISION 1
 /* CModulePreamble */
 #include <stddef.h>
@@ -10825,15 +10825,16 @@ static int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate) {
   return -1;
 }
 /* #### Code section: init_codeobjects ### */
-typedef struct {
-    unsigned int argcount : 2;
-    unsigned int num_posonly_args : 1;
-    unsigned int num_kwonly_args : 1;
-    unsigned int nlocals : 4;
-    unsigned int flags : 10;
-    unsigned int first_line : 9;
-    unsigned int line_table_length : 15;
-} __Pyx_PyCode_New_function_description;
+\
+        typedef struct {
+            unsigned int argcount : 2;
+            unsigned int num_posonly_args : 1;
+            unsigned int num_kwonly_args : 1;
+            unsigned int nlocals : 4;
+            unsigned int flags : 10;
+            unsigned int first_line : 9;
+            unsigned int line_table_length : 15;
+        } __Pyx_PyCode_New_function_description;
 /* NewCodeObj.proto */
 static PyObject* __Pyx_PyCode_New(
         const __Pyx_PyCode_New_function_description descr,
@@ -14312,6 +14313,7 @@ static int __pyx_CommonTypesMetaclass_init(PyObject *module) {
         return -1;
     }
     mstate->__pyx_CommonTypesMetaclassType = __Pyx_FetchCommonTypeFromSpec(NULL, module, &__pyx_CommonTypesMetaclass_spec, bases);
+    Py_DECREF(bases);
     if (unlikely(mstate->__pyx_CommonTypesMetaclassType == NULL)) {
         return -1;
     }
@@ -16695,6 +16697,10 @@ static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt
         PyCode_NewWithPosOnlyArgs
       #endif
         (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, __pyx_mstate_global->__pyx_empty_bytes);
+    #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030c00A1
+    if (likely(result))
+        result->_co_firsttraceable = 0;
+    #endif
     return result;
   }
 #elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY

fontTools/misc/bezierTools.c

@@ -1,4 +1,4 @@
-/* Generated by Cython 3.1.3 */
+/* Generated by Cython 3.1.4 */
 
 /* BEGIN: Cython Metadata
 {
@@ -26,8 +26,8 @@ END: Cython Metadata */
 #elif PY_VERSION_HEX < 0x03080000
     #error Cython requires Python 3.8+.
 #else
-#define __PYX_ABI_VERSION "3_1_3"
-#define CYTHON_HEX_VERSION 0x030103F0
+#define __PYX_ABI_VERSION "3_1_4"
+#define CYTHON_HEX_VERSION 0x030104F0
 #define CYTHON_FUTURE_DIVISION 1
 /* CModulePreamble */
 #include <stddef.h>
@@ -31615,15 +31615,16 @@ static int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate) {
   return -1;
 }
 /* #### Code section: init_codeobjects ### */
-typedef struct {
-    unsigned int argcount : 3;
-    unsigned int num_posonly_args : 1;
-    unsigned int num_kwonly_args : 1;
-    unsigned int nlocals : 6;
-    unsigned int flags : 10;
-    unsigned int first_line : 11;
-    unsigned int line_table_length : 14;
-} __Pyx_PyCode_New_function_description;
+\
+        typedef struct {
+            unsigned int argcount : 3;
+            unsigned int num_posonly_args : 1;
+            unsigned int num_kwonly_args : 1;
+            unsigned int nlocals : 6;
+            unsigned int flags : 10;
+            unsigned int first_line : 11;
+            unsigned int line_table_length : 14;
+        } __Pyx_PyCode_New_function_description;
 /* NewCodeObj.proto */
 static PyObject* __Pyx_PyCode_New(
         const __Pyx_PyCode_New_function_description descr,
@@ -34352,6 +34353,7 @@ static int __pyx_CommonTypesMetaclass_init(PyObject *module) {
         return -1;
     }
     mstate->__pyx_CommonTypesMetaclassType = __Pyx_FetchCommonTypeFromSpec(NULL, module, &__pyx_CommonTypesMetaclass_spec, bases);
+    Py_DECREF(bases);
     if (unlikely(mstate->__pyx_CommonTypesMetaclassType == NULL)) {
         return -1;
     }
@@ -39495,6 +39497,10 @@ static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt
         PyCode_NewWithPosOnlyArgs
       #endif
         (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, __pyx_mstate_global->__pyx_empty_bytes);
+    #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030c00A1
+    if (likely(result))
+        result->_co_firsttraceable = 0;
+    #endif
     return result;
   }
 #elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY

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/visitor.py

@@ -79,12 +79,15 @@ class Visitor(object):
     def visitObject(self, obj, *args, **kwargs):
         """Called to visit an object. This function loops over all non-private
         attributes of the objects and calls any user-registered (via
-        @register_attr() or @register_attrs()) visit() functions.
+        ``@register_attr()`` or ``@register_attrs()``) ``visit()`` functions.
 
-        If there is no user-registered visit function, of if there is and it
-        returns True, or it returns None (or doesn't return anything) and
-        visitor.defaultStop is False (default), then the visitor will proceed
-        to call self.visitAttr()"""
+        The visitor will proceed to call ``self.visitAttr()``, unless there is a
+        user-registered visit function and:
+
+        * It returns ``False``; or
+        * It returns ``None`` (or doesn't return anything) and
+          ``visitor.defaultStop`` is ``True`` (non-default).
+        """
 
         keys = sorted(vars(obj).keys())
         _visitors = self._visitorsFor(obj)
@@ -121,19 +124,24 @@ class Visitor(object):
 
     def visit(self, obj, *args, **kwargs):
         """This is the main entry to the visitor. The visitor will visit object
-        obj.
+        ``obj``.
 
         The visitor will first determine if there is a registered (via
-        @register()) visit function for the type of object. If there is, it
-        will be called, and (visitor, obj, *args, **kwargs) will be passed to
-        the user visit function.
-
-        If there is no user-registered visit function, of if there is and it
-        returns True, or it returns None (or doesn't return anything) and
-        visitor.defaultStop is False (default), then the visitor will proceed
-        to dispatch to one of self.visitObject(), self.visitList(),
-        self.visitDict(), or self.visitLeaf() (any of which can be overriden in
-        a subclass)."""
+        ``@register()``) visit function for the type of object. If there is, it
+        will be called, and ``(visitor, obj, *args, **kwargs)`` will be passed
+        to the user visit function.
+
+        The visitor will not recurse if there is a user-registered visit
+        function and:
+
+        * It returns ``False``; or
+        * It returns ``None`` (or doesn't return anything) and
+          ``visitor.defaultStop`` is ``True`` (non-default)
+
+        Otherwise,  the visitor will proceed to dispatch to one of
+        ``self.visitObject()``, ``self.visitList()``, ``self.visitDict()``, or
+        ``self.visitLeaf()`` (any of which can be overriden in a subclass).
+        """
 
         visitorFunc = self._visitorsFor(obj).get(None, None)
         if visitorFunc is not None:

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/momentsPen.c

@@ -1,4 +1,4 @@
-/* Generated by Cython 3.1.3 */
+/* Generated by Cython 3.1.4 */
 
 /* BEGIN: Cython Metadata
 {
@@ -26,8 +26,8 @@ END: Cython Metadata */
 #elif PY_VERSION_HEX < 0x03080000
     #error Cython requires Python 3.8+.
 #else
-#define __PYX_ABI_VERSION "3_1_3"
-#define CYTHON_HEX_VERSION 0x030103F0
+#define __PYX_ABI_VERSION "3_1_4"
+#define CYTHON_HEX_VERSION 0x030104F0
 #define CYTHON_FUTURE_DIVISION 1
 /* CModulePreamble */
 #include <stddef.h>
@@ -8297,15 +8297,16 @@ static int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate) {
   return -1;
 }
 /* #### Code section: init_codeobjects ### */
-typedef struct {
-    unsigned int argcount : 3;
-    unsigned int num_posonly_args : 1;
-    unsigned int num_kwonly_args : 1;
-    unsigned int nlocals : 8;
-    unsigned int flags : 10;
-    unsigned int first_line : 9;
-    unsigned int line_table_length : 17;
-} __Pyx_PyCode_New_function_description;
+\
+        typedef struct {
+            unsigned int argcount : 3;
+            unsigned int num_posonly_args : 1;
+            unsigned int num_kwonly_args : 1;
+            unsigned int nlocals : 8;
+            unsigned int flags : 10;
+            unsigned int first_line : 9;
+            unsigned int line_table_length : 17;
+        } __Pyx_PyCode_New_function_description;
 /* NewCodeObj.proto */
 static PyObject* __Pyx_PyCode_New(
         const __Pyx_PyCode_New_function_description descr,
@@ -10389,6 +10390,7 @@ static int __pyx_CommonTypesMetaclass_init(PyObject *module) {
         return -1;
     }
     mstate->__pyx_CommonTypesMetaclassType = __Pyx_FetchCommonTypeFromSpec(NULL, module, &__pyx_CommonTypesMetaclass_spec, bases);
+    Py_DECREF(bases);
     if (unlikely(mstate->__pyx_CommonTypesMetaclassType == NULL)) {
         return -1;
     }
@@ -12810,6 +12812,10 @@ static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt
         PyCode_NewWithPosOnlyArgs
       #endif
         (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, __pyx_mstate_global->__pyx_empty_bytes);
+    #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030c00A1
+    if (likely(result))
+        result->_co_firsttraceable = 0;
+    #endif
     return result;
   }
 #elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY