robotools · benkiel · Sep 24, 2024 · Oct 3, 2024 · Nov 8, 2024 · Nov 14, 2024
diff --git a/.github/workflows/run-tests.yml b/.github/workflows/run-tests.yml
@@ -18,17 +18,21 @@ jobs:
     if: "! contains(toJSON(github.event.commits.*.message), '[skip ci]')"
     strategy:
       matrix:
-        python-version: ['3.8', '3.9', '3.10', '3.11']
+        python-version: ['3.9', '3.10', '3.11', '3.12', '3.13']
         platform: [ubuntu-latest, macos-latest, windows-latest]
         exclude: # Only test on the oldest and latest supported stable Python on macOS and Windows.
-          - platform: macos-latest
-            python-version: 3.9
-          - platform: windows-latest
-            python-version: 3.9
           - platform: macos-latest
             python-version: 3.10
           - platform: windows-latest
             python-version: 3.10
+          - platform: macos-latest
+            python-version: 3.11
+          - platform: windows-latest
+            python-version: 3.11
+          - platform: macos-latest
+            python-version: 3.13
+          - platform: windows-latest
+            python-version: 3.13
     steps:
     - uses: actions/checkout@v3.5.3
     - name: Set up Python ${{ matrix.python-version }}

diff --git a/.gitignore b/.gitignore
@@ -11,6 +11,7 @@ build/*
 dist/*
 .eggs/
 .vscode
+*-venv/
 
 documentation/build/*
 documentation/.sass-cache/*
@@ -22,4 +23,4 @@ doc/*
 htmlcov
 
 # scm version
-Lib/fontParts/_version.py
+Lib/fontParts/_version.py
diff --git a/Lib/fontParts/base/base.py b/Lib/fontParts/base/base.py
@@ -216,8 +216,7 @@ def copyData(self, source):
             if isinstance(selfValue, BaseObject):
                 selfValue.copyData(sourceValue)
             else:
-                setattr(self, attr, sourceValue)
-
+                setattr(self, attr, deepcopy(sourceValue))
     # ----------
     # Exceptions
     # ----------
@@ -260,6 +259,18 @@ class BaseDict(BaseObject):
     keyNormalizer = None
     valueNormalizer = None
 
+    @classmethod
+    def _normalizeKey(cls, key):
+        if callable(cls.keyNormalizer):
+            return cls.keyNormalizer(key)
+        return key
+
+    @classmethod
+    def _normalizeValue(cls, value):
+        if callable(cls.valueNormalizer):
+            return cls.valueNormalizer(value)
+        return value
+
     def copyData(self, source):
         super(BaseDict, self).copyData(source)
         self.update(source)
@@ -276,8 +287,8 @@ def _len(self):
 
     def keys(self):
         keys = self._keys()
-        if self.keyNormalizer is not None:
-            keys = [self.keyNormalizer.__func__(key) for key in keys]
+        if self._normalizeKey is not None:
+            keys = [self._normalizeKey(key) for key in keys]
         return keys
 
     def _keys(self):
@@ -288,13 +299,11 @@ def _keys(self):
 
     def items(self):
         items = self._items()
-        if self.keyNormalizer is not None and self.valueNormalizer is not None:
-            values = [
-                (self.keyNormalizer.__func__(key),
-                 self.valueNormalizer.__func__(value))
-                for (key, value) in items
+        return [
+            (self._normalizeKey(key), self._normalizeValue(value))
+            for (key, value) in items
             ]
-        return values
+
 
     def _items(self):
         """
@@ -304,8 +313,8 @@ def _items(self):
 
     def values(self):
         values = self._values()
-        if self.valueNormalizer is not None:
-            values = [self.valueNormalizer.__func__(value) for value in values]
+        if self._normalizeValue is not None:
+            values = [self._normalizeValue(value) for value in values]
         return values
 
     def _values(self):
@@ -315,8 +324,8 @@ def _values(self):
         return [v for k, v in self.items()]
 
     def __contains__(self, key):
-        if self.keyNormalizer is not None:
-            key = self.keyNormalizer.__func__(key)
+        if self._normalizeKey is not None:
+            key = self._normalizeKey(key)
         return self._contains(key)
 
     def _contains(self, key):
@@ -328,10 +337,10 @@ def _contains(self, key):
     has_key = __contains__
 
     def __setitem__(self, key, value):
-        if self.keyNormalizer is not None:
-            key = self.keyNormalizer.__func__(key)
-        if self.valueNormalizer is not None:
-            value = self.valueNormalizer.__func__(value)
+        if self._normalizeKey is not None:
+            key = self._normalizeKey(key)
+        if self._normalizeValue is not None:
+            value = self._normalizeValue(value)
         self._setItem(key, value)
 
     def _setItem(self, key, value):
@@ -341,11 +350,11 @@ def _setItem(self, key, value):
         self.raiseNotImplementedError()
 
     def __getitem__(self, key):
-        if self.keyNormalizer is not None:
-            key = self.keyNormalizer.__func__(key)
+        if self._normalizeKey is not None:
+            key = self._normalizeKey(key)
         value = self._getItem(key)
-        if self.valueNormalizer is not None:
-            value = self.valueNormalizer.__func__(value)
+        if self._normalizeValue is not None:
+            value = self._normalizeValue(value)
         return value
 
     def _getItem(self, key):
@@ -355,13 +364,13 @@ def _getItem(self, key):
         self.raiseNotImplementedError()
 
     def get(self, key, default=None):
-        if self.keyNormalizer is not None:
-            key = self.keyNormalizer.__func__(key)
-        if default is not None and self.valueNormalizer is not None:
-            default = self.valueNormalizer.__func__(default)
+        if self._normalizeKey is not None:
+            key = self._normalizeKey(key)
+        if default is not None and self._normalizeValue is not None:
+            default = self._normalizeValue(default)
         value = self._get(key, default=default)
-        if value is not default and self.valueNormalizer is not None:
-            value = self.valueNormalizer.__func__(value)
+        if value is not default and self._normalizeValue is not None:
+            value = self._normalizeValue(value)
         return value
 
     def _get(self, key, default=None):
@@ -373,8 +382,8 @@ def _get(self, key, default=None):
         return default
 
     def __delitem__(self, key):
-        if self.keyNormalizer is not None:
-            key = self.keyNormalizer.__func__(key)
+        if self._normalizeKey is not None:
+            key = self._normalizeKey(key)
         self._delItem(key)
 
     def _delItem(self, key):
@@ -384,13 +393,13 @@ def _delItem(self, key):
         self.raiseNotImplementedError()
 
     def pop(self, key, default=None):
-        if self.keyNormalizer is not None:
-            key = self.keyNormalizer.__func__(key)
-        if default is not None and self.valueNormalizer is not None:
-            default = self.valueNormalizer.__func__(default)
+        if self._normalizeKey is not None:
+            key = self._normalizeKey(key)
+        if default is not None and self._normalizeValue is not None:
+            default = self._normalizeValue(default)
         value = self._pop(key, default=default)
-        if self.valueNormalizer is not None:
-            value = self.valueNormalizer.__func__(value)
+        if self._normalizeValue is not None:
+            value = self._normalizeValue(value)
         return value
 
     def _pop(self, key, default=None):
@@ -418,11 +427,11 @@ def _iter(self):
 
     def update(self, other):
         other = deepcopy(other)
-        if self.keyNormalizer is not None and self.valueNormalizer is not None:
+        if self._normalizeKey is not None and self._normalizeValue is not None:
             d = {}
             for key, value in other.items():
-                key = self.keyNormalizer.__func__(key)
-                value = self.valueNormalizer.__func__(value)
+                key = self._normalizeKey(key)
+                value = self._normalizeValue(value)
                 d[key] = value
             value = d
         self._update(other)
@@ -830,8 +839,14 @@ def _setIdentifier(self, value):
 
 
 def reference(obj):
-    # import weakref
-    # return weakref.ref(obj)
+    """
+    This code returns a simple function that returns the given object.
+    This is a backwards compatibility function that is under review.
+    See #749. We used to use weak references, but they proved
+    problematic (see issue #71), so this function was put in place to
+    make sure existing code continued to function. The need for it is
+    questionable, so it may be deleted soon.
+    """
     def wrapper():
         return obj
     return wrapper

diff --git a/Lib/fontParts/base/font.py b/Lib/fontParts/base/font.py
@@ -95,8 +95,8 @@ def copyData(self, source):
             else:
                 layer = self.newLayer(layerName)
             layer.copyData(source.getLayer(layerName))
-        for guideline in self.guidelines:
-            self.appendGuideline(guideline)
+        for guideline in source.guidelines:
+            self.appendGuideline(guideline=guideline)
         super(BaseFont, self).copyData(source)
 
     # ---------------

diff --git a/Lib/fontParts/base/glyph.py b/Lib/fontParts/base/glyph.py
@@ -1696,7 +1696,7 @@ def _fromMathGlyph(self, mathGlyph, toThisGlyph=False, filterRedundantPoints=Tru
             a = copied.appendAnchor(
                 name=anchor.get("name"),
                 position=(anchor["x"], anchor["y"]),
-                color=anchor["color"]
+                color=anchor.get("color")
             )
             identifier = anchor.get("identifier")
             if identifier is not None:
@@ -1705,8 +1705,8 @@ def _fromMathGlyph(self, mathGlyph, toThisGlyph=False, filterRedundantPoints=Tru
             g = copied.appendGuideline(
                 position=(guideline["x"], guideline["y"]),
                 angle=guideline["angle"],
-                name=guideline["name"],
-                color=guideline["color"]
+                name=guideline.get("name"),
+                color=guideline.get("color")
             )
             identifier = guideline.get("identifier")
             if identifier is not None:

diff --git a/Lib/fontParts/base/groups.py b/Lib/fontParts/base/groups.py
@@ -68,7 +68,7 @@ def findGlyph(self, glyphName):
         """
         glyphName = normalizers.normalizeGlyphName(glyphName)
         groupNames = self._findGlyph(glyphName)
-        groupNames = [self.keyNormalizer.__func__(
+        groupNames = [self._normalizeKey(
             groupName) for groupName in groupNames]
         return groupNames
 

diff --git a/Lib/fontParts/base/guideline.py b/Lib/fontParts/base/guideline.py
@@ -504,5 +504,9 @@ def _round(self, **kwargs):
 
         Subclasses may override this method.
         """
-        self.x = normalizers.normalizeVisualRounding(self.x)
-        self.y = normalizers.normalizeVisualRounding(self.y)
+        x = self._get_x()
+        if x is not None:
+            self.x = normalizers.normalizeVisualRounding(normalizers.normalizeX(x))
+        y = self._get_y()
+        if y is not None:
+            self.y = normalizers.normalizeVisualRounding(normalizers.normalizeY(y))
diff --git a/Lib/fontParts/base/kerning.py b/Lib/fontParts/base/kerning.py
@@ -119,7 +119,7 @@ def _round(self, multiple=1):
     # -------------
 
     def interpolate(self, factor, minKerning, maxKerning, round=True, suppressError=True):
-        """
+        r"""
         Interpolates all pairs between two :class:`BaseKerning` objects:
 
             >>> myKerning.interpolate(kerningOne, kerningTwo)
@@ -221,7 +221,7 @@ def _testKerningGroupCompatibility(minKerning, maxKerning, suppressError=False):
     # ---------------------
 
     def remove(self, pair):
-        """
+        r"""
         Removes a pair from the Kerning. **pair** will
         be a ``tuple`` of two :ref:`type-string`\s.
 
@@ -245,7 +245,7 @@ def asDict(self, returnIntegers=True):
     # -------------------
 
     def __contains__(self, pair):
-        """
+        r"""
         Tests to see if a pair is in the Kerning.
         **pair** will be a ``tuple`` of two :ref:`type-string`\s.
 
@@ -258,7 +258,7 @@ def __contains__(self, pair):
         return super(BaseKerning, self).__contains__(pair)
 
     def __delitem__(self, pair):
-        """
+        r"""
         Removes **pair** from the Kerning. **pair** is a ``tuple`` of two
         :ref:`type-string`\s.::
 
@@ -267,7 +267,7 @@ def __delitem__(self, pair):
         super(BaseKerning, self).__delitem__(pair)
 
     def __getitem__(self, pair):
-        """
+        r"""
         Returns the kerning value of the pair. **pair** is a ``tuple`` of
         two :ref:`type-string`\s.
 
@@ -309,7 +309,7 @@ def __len__(self):
         return super(BaseKerning, self).__len__()
 
     def __setitem__(self, pair, value):
-        """
+        r"""
         Sets the **pair** to the list of **value**. **pair** is the
         pair as a ``tuple`` of two :ref:`type-string`\s and **value**
 
@@ -330,7 +330,7 @@ def clear(self):
         super(BaseKerning, self).clear()
 
     def get(self, pair, default=None):
-        """
+        r"""
         Returns the value for the kerning pair.
         **pair** is a ``tuple`` of two :ref:`type-string`\s, and the returned
         values will either be :ref:`type-int-float` or ``None``
@@ -350,7 +350,7 @@ def get(self, pair, default=None):
         return super(BaseKerning, self).get(pair, default)
 
     def find(self, pair, default=None):
-        """
+        r"""
         Returns the value for the kerning pair - even if the pair only exists
         implicitly (one or both sides may be members of a kerning group).
 
@@ -379,7 +379,7 @@ def _find(self, pair, default=None):
         return lookupKerningValue(pair, self, groups, fallback=default)
 
     def items(self):
-        """
+        r"""
         Returns a list of ``tuple``\s of each pair and value. Pairs are a
         ``tuple`` of two :ref:`type-string`\s and values are :ref:`type-int-float`.
 
@@ -401,7 +401,7 @@ def keys(self):
         return super(BaseKerning, self).keys()
 
     def pop(self, pair, default=None):
-        """
+        r"""
         Removes the **pair** from the Kerning and returns the value as an ``int``.
         If no pair is found, **default** is returned. **pair** is a
         ``tuple`` of two :ref:`type-string`\s. This must return either
@@ -428,7 +428,7 @@ def update(self, otherKerning):
         super(BaseKerning, self).update(otherKerning)
 
     def values(self):
-        """
+        r"""
         Returns a ``list`` of each pair's values, the values will be
         :ref:`type-int-float`\s.