Add type annotations, conform to protocols

.github/workflows/pytest.yml

@@ -18,20 +18,28 @@ jobs:
 
     steps:
       - uses: actions/checkout@v4
+
       - name: Set up Python ${{ matrix.python-version }}
         uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
+
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
           python -m pip install . --no-deps
           python -m pip install -r requirements.txt
           python -m pip install -r requirements-dev.txt
+
       - name: Run pre-commit
         uses: pre-commit/action@v3.0.0
         with:
           extra_args: --all-files --verbose --show-diff-on-failure
+
       - name: Test with pytest
         run: |
           pytest -vv
+
+      - name: Run mypy
+        run: |
+          mypy src/ tests/

pyproject.toml

@@ -61,3 +61,19 @@ testpaths = [
     "tests",
 ]
 asyncio_mode = "auto"
+
+[[tool.mypy.overrides]]
+module = "fontTools.*"
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "glyphsLib.glyphdata"
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "urllib3"
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "requests"
+ignore_missing_imports = true

requirements-dev.txt

@@ -1,3 +1,4 @@
+mypy==1.7.1
 pre-commit==3.5.0
 pytest==7.4.3
 pytest-asyncio==0.23.2

src/fontra_rcjk/backend_fs.py

@@ -4,12 +4,20 @@
 import pathlib
 import shutil
 from functools import cached_property
+from os import PathLike
+from typing import Any
 
 import watchfiles
 from fontra.backends.designspace import cleanupWatchFilesChanges
 from fontra.backends.ufo_utils import extractGlyphNameAndUnicodes
-from fontra.core.classes import unstructure
+from fontra.core.classes import (
+    GlobalAxis,
+    GlobalDiscreteAxis,
+    VariableGlyph,
+    unstructure,
+)
 from fontra.core.instancer import mapLocationFromUserToSource
+from fontra.core.protocols import WritableFontBackend
 from fontTools.ufoLib.filenames import userNameToFileName
 
 from .base import (
@@ -33,14 +41,14 @@
 
 class RCJKBackend:
     @classmethod
-    def fromPath(cls, path):
+    def fromPath(cls, path: PathLike) -> WritableFontBackend:
         return cls(path)
 
     @classmethod
-    def createFromPath(cls, path):
+    def createFromPath(cls, path: PathLike) -> WritableFontBackend:
         return cls(path, create=True)
 
-    def __init__(self, path, *, create=False):
+    def __init__(self, path: PathLike, *, create: bool = False):
         self.path = pathlib.Path(path).resolve()
         if create:
             if self.path.is_dir():
@@ -49,9 +57,7 @@ def __init__(self, path, *, create=False):
                 self.path.unlink()
             cgPath = self.path / "characterGlyph"
             cgPath.mkdir(exist_ok=True, parents=True)
-            self.characterGlyphGlyphSet = (
-                RCJKGlyphSet(cgPath, self.registerWrittenPath),
-            )
+            self.characterGlyphGlyphSet = RCJKGlyphSet(cgPath, self.registerWrittenPath)
 
         for name in glyphSetNames:
             setattr(
@@ -69,7 +75,7 @@ def __init__(self, path, *, create=False):
         else:
             self.designspace = {}
 
-        self._glyphMap = {}
+        self._glyphMap: dict[str, list[int]] = {}
         for gs, hasEncoding in self._iterGlyphSets():
             glyphMap = gs.getGlyphMap(not hasEncoding)
             for glyphName, unicodes in glyphMap.items():
@@ -78,7 +84,7 @@ def __init__(self, path, *, create=False):
                     assert not unicodes
                 self._glyphMap[glyphName] = unicodes
 
-        self._recentlyWrittenPaths = {}
+        self._recentlyWrittenPaths: dict[str, Any] = {}
         self._tempGlyphCache = TimedCache()
 
     def close(self):
@@ -111,13 +117,16 @@ def _defaultLocation(self):
         }
         return mapLocationFromUserToSource(userLoc, axes)
 
-    async def getGlyphMap(self):
+    async def getGlyphMap(self) -> dict[str, list[int]]:
         return dict(self._glyphMap)
 
-    async def getGlobalAxes(self):
+    async def putGlyphMap(self, glyphMap: dict[str, list[int]]) -> None:
+        pass
+
+    async def getGlobalAxes(self) -> list[GlobalAxis | GlobalDiscreteAxis]:
         return unpackAxes(self.designspace.get("axes", ()))
 
-    async def putGlobalAxes(self, axes):
+    async def putGlobalAxes(self, axes: list[GlobalAxis | GlobalDiscreteAxis]) -> None:
         self.designspace["axes"] = unstructure(axes)
         if hasattr(self, "_defaultLocation"):
             del self._defaultLocation
@@ -129,10 +138,13 @@ def _writeDesignSpaceFile(self):
             json.dumps(self.designspace, indent=2), encoding="utf-8"
         )
 
-    async def getUnitsPerEm(self):
+    async def getUnitsPerEm(self) -> int:
         return 1000
 
-    async def getGlyph(self, glyphName):
+    async def putUnitsPerEm(self, value: int) -> None:
+        pass
+
+    async def getGlyph(self, glyphName: str) -> VariableGlyph | None:
         layerGlyphs = self._getLayerGlyphs(glyphName)
         return buildVariableGlyphFromLayerGlyphs(layerGlyphs)
 
@@ -168,7 +180,9 @@ def _getLayerGLIFData(self, glyphName):
                 return gs.getGlyphLayerData(glyphName)
         return None
 
-    async def putGlyph(self, glyphName, glyph, unicodes):
+    async def putGlyph(
+        self, glyphName: str, glyph: VariableGlyph, unicodes: list[int]
+    ) -> None:
         if glyphName not in self._glyphMap:
             existingLayerGlyphs = {}
         else:
@@ -194,14 +208,14 @@ async def deleteGlyph(self, glyphName):
 
         del self._glyphMap[glyphName]
 
-    async def getCustomData(self):
+    async def getCustomData(self) -> dict[str, Any]:
         customData = {}
         customDataPath = self.path / FONTLIB_FILENAME
         if customDataPath.is_file():
             customData = json.loads(customDataPath.read_text(encoding="utf-8"))
         return customData | standardCustomDataItems
 
-    async def putCustomData(self, customData):
+    async def putCustomData(self, customData: dict[str, Any]) -> None:
         customDataPath = self.path / FONTLIB_FILENAME
         customData = {
             k: v