fonttools 4.57.0__cp312-cp312-win_amd64.whl → 4.58.1__cp312-cp312-win_amd64.whl

fontTools/pens/pointPen.py

@@ -12,12 +12,14 @@ This allows the caller to provide more data for each point.
 For instance, whether or not a point is smooth, and its name.
 """
 
+from __future__ import annotations
+
 import math
-from typing import Any, Optional, Tuple, Dict
+from typing import Any, Dict, List, Optional, Tuple
 
 from fontTools.misc.loggingTools import LogMixin
-from fontTools.pens.basePen import AbstractPen, MissingComponentError, PenError
 from fontTools.misc.transform import DecomposedTransform, Identity
+from fontTools.pens.basePen import AbstractPen, MissingComponentError, PenError
 
 __all__ = [
     "AbstractPointPen",
@@ -28,6 +30,14 @@ __all__ = [
     "ReverseContourPointPen",
 ]
 
+# Some type aliases to make it easier below
+Point = Tuple[float, float]
+PointName = Optional[str]
+# [(pt, smooth, name, kwargs)]
+SegmentPointList = List[Tuple[Optional[Point], bool, PointName, Any]]
+SegmentType = Optional[str]
+SegmentList = List[Tuple[SegmentType, SegmentPointList]]
+
 
 class AbstractPointPen:
     """Baseclass for all PointPens."""
@@ -88,7 +98,7 @@ class BasePointToSegmentPen(AbstractPointPen):
     care of all the edge cases.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.currentPath = None
 
     def beginPath(self, identifier=None, **kwargs):
@@ -96,7 +106,7 @@ class BasePointToSegmentPen(AbstractPointPen):
             raise PenError("Path already begun.")
         self.currentPath = []
 
-    def _flushContour(self, segments):
+    def _flushContour(self, segments: SegmentList) -> None:
         """Override this method.
 
         It will be called for each non-empty sub path with a list
@@ -124,7 +134,7 @@ class BasePointToSegmentPen(AbstractPointPen):
         """
         raise NotImplementedError
 
-    def endPath(self):
+    def endPath(self) -> None:
         if self.currentPath is None:
             raise PenError("Path not begun.")
         points = self.currentPath
@@ -134,7 +144,7 @@ class BasePointToSegmentPen(AbstractPointPen):
         if len(points) == 1:
             # Not much more we can do than output a single move segment.
             pt, segmentType, smooth, name, kwargs = points[0]
-            segments = [("move", [(pt, smooth, name, kwargs)])]
+            segments: SegmentList = [("move", [(pt, smooth, name, kwargs)])]
             self._flushContour(segments)
             return
         segments = []
@@ -162,7 +172,7 @@ class BasePointToSegmentPen(AbstractPointPen):
             else:
                 points = points[firstOnCurve + 1 :] + points[: firstOnCurve + 1]
 
-        currentSegment = []
+        currentSegment: SegmentPointList = []
         for pt, segmentType, smooth, name, kwargs in points:
             currentSegment.append((pt, smooth, name, kwargs))
             if segmentType is None:
@@ -189,7 +199,7 @@ class PointToSegmentPen(BasePointToSegmentPen):
     and kwargs.
     """
 
-    def __init__(self, segmentPen, outputImpliedClosingLine=False):
+    def __init__(self, segmentPen, outputImpliedClosingLine: bool = False) -> None:
         BasePointToSegmentPen.__init__(self)
         self.pen = segmentPen
         self.outputImpliedClosingLine = outputImpliedClosingLine
@@ -271,14 +281,14 @@ class SegmentToPointPen(AbstractPen):
     PointPen protocol.
     """
 
-    def __init__(self, pointPen, guessSmooth=True):
+    def __init__(self, pointPen, guessSmooth=True) -> None:
         if guessSmooth:
             self.pen = GuessSmoothPointPen(pointPen)
         else:
             self.pen = pointPen
-        self.contour = None
+        self.contour: Optional[List[Tuple[Point, SegmentType]]] = None
 
-    def _flushContour(self):
+    def _flushContour(self) -> None:
         pen = self.pen
         pen.beginPath()
         for pt, segmentType in self.contour:
@@ -594,7 +604,6 @@ class DecomposingPointPen(LogMixin, AbstractPointPen):
                 # if the transformation has a negative determinant, it will
                 # reverse the contour direction of the component
                 a, b, c, d = transformation[:4]
-                det = a * d - b * c
                 if a * d - b * c < 0:
                     pen = ReverseContourPointPen(pen)
             glyph.drawPoints(pen)

fontTools/pens/t2CharStringPen.py

@@ -1,10 +1,14 @@
 # Copyright (c) 2009 Type Supply LLC
 # Author: Tal Leming
 
-from fontTools.misc.roundTools import otRound, roundFunc
+from __future__ import annotations
+
+from typing import Any, Dict, List, Tuple
+
+from fontTools.cffLib.specializer import commandsToProgram, specializeCommands
 from fontTools.misc.psCharStrings import T2CharString
+from fontTools.misc.roundTools import otRound, roundFunc
 from fontTools.pens.basePen import BasePen
-from fontTools.cffLib.specializer import specializeCommands, commandsToProgram
 
 
 class T2CharStringPen(BasePen):
@@ -18,36 +22,52 @@ class T2CharStringPen(BasePen):
     which are close to their integral part within the tolerated range.
     """
 
-    def __init__(self, width, glyphSet, roundTolerance=0.5, CFF2=False):
+    def __init__(
+        self,
+        width: float | None,
+        glyphSet: Dict[str, Any] | None,
+        roundTolerance: float = 0.5,
+        CFF2: bool = False,
+    ) -> None:
         super(T2CharStringPen, self).__init__(glyphSet)
         self.round = roundFunc(roundTolerance)
         self._CFF2 = CFF2
         self._width = width
-        self._commands = []
+        self._commands: List[Tuple[str | bytes, List[float]]] = []
         self._p0 = (0, 0)
 
-    def _p(self, pt):
+    def _p(self, pt: Tuple[float, float]) -> List[float]:
         p0 = self._p0
         pt = self._p0 = (self.round(pt[0]), self.round(pt[1]))
         return [pt[0] - p0[0], pt[1] - p0[1]]
 
-    def _moveTo(self, pt):
+    def _moveTo(self, pt: Tuple[float, float]) -> None:
         self._commands.append(("rmoveto", self._p(pt)))
 
-    def _lineTo(self, pt):
+    def _lineTo(self, pt: Tuple[float, float]) -> None:
         self._commands.append(("rlineto", self._p(pt)))
 
-    def _curveToOne(self, pt1, pt2, pt3):
+    def _curveToOne(
+        self,
+        pt1: Tuple[float, float],
+        pt2: Tuple[float, float],
+        pt3: Tuple[float, float],
+    ) -> None:
         _p = self._p
         self._commands.append(("rrcurveto", _p(pt1) + _p(pt2) + _p(pt3)))
 
-    def _closePath(self):
+    def _closePath(self) -> None:
         pass
 
-    def _endPath(self):
+    def _endPath(self) -> None:
         pass
 
-    def getCharString(self, private=None, globalSubrs=None, optimize=True):
+    def getCharString(
+        self,
+        private: Dict | None = None,
+        globalSubrs: List | None = None,
+        optimize: bool = True,
+    ) -> T2CharString:
         commands = self._commands
         if optimize:
             maxstack = 48 if not self._CFF2 else 513