fontforge-variable-font 0.3.0__tar.gz → 0.4.1__tar.gz

{fontforge_variable_font-0.3.0/fontforge_variable_font.egg-info → fontforge_variable_font-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fontforge_variable_font
-Version: 0.3.0
+Version: 0.4.1
 Summary: A FontForge_plugin to create a variable font
 Home-page: https://github.com/MihailJP/fontforge-variable-font
 Author: MihailJP
@@ -17,6 +17,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: fonttools
 Requires-Dist: fontmake
+Requires-Dist: fontforge_plugin_helper
 Dynamic: license-file
 
 Fontforge Variable Font Plugin

fontforge_variable_font-0.4.1/fontforgeVF/__init__.py

@@ -0,0 +1,50 @@
+"""FontForge plugin to create a variable font"""
+
+from .delete import deleteVFInfo
+from .design_axes import getAxisValue
+from .export import exportVariableFont
+from .language import languageCodeIterator, languageCodeLookup, languageCodeReverseLookup, getLanguageList
+from .load import openVariableFont
+from .utils import (
+    intOrFloat,
+    initPersistentDict,
+    vfInfoExists,
+    getVFValue,
+    setVFValue,
+    deleteEmptyDicts,
+    deleteVFValue,
+    setOrDeleteVFValue,
+    checkExtensionTtfOrWoff2,
+)
+
+
+__all__ = [
+    # delete
+    "deleteVFInfo",
+
+    # design_axes
+    "getAxisValue",
+
+    # export
+    "exportVariableFont",
+
+    # language
+    'languageCodeIterator',
+    'languageCodeLookup',
+    'languageCodeReverseLookup',
+    'getLanguageList',
+
+    # load
+    "openVariableFont",
+
+    # utils
+    "intOrFloat",
+    "initPersistentDict",
+    "vfInfoExists",
+    "getVFValue",
+    "setVFValue",
+    "deleteEmptyDicts",
+    "deleteVFValue",
+    "setOrDeleteVFValue",
+    "checkExtensionTtfOrWoff2",
+]

{fontforge_variable_font-0.3.0 → fontforge_variable_font-0.4.1}/fontforgeVF/__main__.py

@@ -1,3 +1,5 @@
+import fontforge
+
 from fontforgeVF import (
     delete,
     design_axes,
@@ -5,25 +7,7 @@ from fontforgeVF import (
     instance,
     load
 )
-import fontforge
-from typing import Literal, Callable
-
-
-def _addHook(
-    name: Literal['newFontHook', 'loadFontHook'],
-    hook: Callable[[fontforge.font], None]
-):
-    assert isinstance(fontforge.hooks, dict)
-    if name in fontforge.hooks:
-        currentHook = fontforge.hooks[name]
-
-        def chainHook(font: fontforge.font):
-            currentHook(font)
-            hook(font)
-
-        fontforge.hooks[name] = chainHook
-    else:
-        fontforge.hooks[name] = hook
+from fontforge_plugin_helper import addSystemHook
 
 
 def fontforge_plugin_init(**kw):
@@ -50,6 +34,13 @@ def fontforge_plugin_init(**kw):
         submenu="_Variable Font",
         name="_Generate a variable font..."
     )
+
+    fontforge.registerMenuItem(
+        divider=True,
+        context="Font",
+        submenu="_Variable Font",
+    )
+
     fontforge.registerMenuItem(
         callback=design_axes.designAxesMenu,
         enable=None,
@@ -73,5 +64,5 @@ def fontforge_plugin_init(**kw):
     )
 
     if fontforge.hasUserInterface:
-        _addHook('loadFontHook', load.loadHook)
-        _addHook('newFontHook', load.newFontHook)
+        addSystemHook('loadFontHook', load.loadHook)
+        addSystemHook('newFontHook', load.newFontHook)

{fontforge_variable_font-0.3.0 → fontforge_variable_font-0.4.1}/fontforgeVF/delete.py

@@ -1,10 +1,6 @@
-from fontforgeVF import utils
 import fontforge
 
-
-__all__ = [
-    "deleteVFInfo",
-]
+from . import utils
 
 
 def deleteVFInfo(font: fontforge.font) -> bool:
@@ -17,6 +13,7 @@ def deleteVFInfo(font: fontforge.font) -> bool:
     :return: ``True`` if the key was deleted, ``False`` otherwise.
     """
     if utils.vfInfoExists(font):
+        assert isinstance(font.persistent, dict)
         del font.persistent['VF']
         if len(font.persistent) == 0:
             font.persistent = None
@@ -25,13 +22,13 @@ def deleteVFInfo(font: fontforge.font) -> bool:
         return False
 
 
-def deleteVFInfoMenu(u, glyph):
+def deleteVFInfoMenu(u, font: fontforge.font):
     """Menu emtry to delete VF info from UI
 
     This menu is enabled if active font has VF info.
     """
-    deleteVFInfo(fontforge.activeFont())
+    deleteVFInfo(font)
 
 
-def deleteVFInfoEnable(u, glyph):
-    return utils.vfInfoExists(fontforge.activeFont())
+def deleteVFInfoEnable(u, font: fontforge.font):
+    return utils.vfInfoExists(font)

{fontforge_variable_font-0.3.0 → fontforge_variable_font-0.4.1}/fontforgeVF/design_axes.py

@@ -1,10 +1,6 @@
-from fontforgeVF import utils
 import fontforge
 
-
-__all__ = [
-    "getAxisValue",
-]
+from . import utils
 
 
 def _getWidthFromOS2Width(font: fontforge.font) -> int | float:
@@ -28,7 +24,7 @@ def _searchCustomAxis(font: fontforge.font, tag: str) -> str | None:
         return tag
     else:
         for k, v in designAxes.items():
-            if k.startswith('custom') and utils.getVFValue(font, 'axes.' + k + '.tag', '').rstrip() == tag.rstrip():
+            if k.startswith('custom') and str(utils.getVFValue(font, 'axes.' + k + '.tag', '')).rstrip() == tag.rstrip():
                 return k
         return None
 
@@ -60,21 +56,21 @@ def _getFlags(font: fontforge.font, labelAddr: str) -> int:
 
 def _loadLabels(tag: str, lang=None):
     font = fontforge.activeFont()
+    assert font is not None
     addr = 'axes.' + tag + '.labels'
-    if label := utils.getVFValue(font, addr):
+    if label := utils.getVFValueAsDict(font, addr):
         text = ''
-        assert isinstance(label, dict)
         for k, v in label.items():
             labelAddr = addr + '.' + str(k).replace('.', ',')  # escape decimal point
             if lang:
                 text += str(k) + ',' + \
-                    utils.getVFValue(font, labelAddr + '.localNames.' + hex(lang), '') + \
+                    str(utils.getVFValue(font, labelAddr + '.localNames.' + hex(lang), '')) + \
                     ', '
             else:
                 text += str(k) + ',' + \
                     str(_getFlags(font, labelAddr)) + \
                     ',' + str(utils.getVFValue(font, labelAddr + '.linkedValue', '')) + \
-                    ',' + utils.getVFValue(font, labelAddr + '.name', '') + \
+                    ',' + str(utils.getVFValue(font, labelAddr + '.name', '')) + \
                     ', '
         return text[:-2]
     elif utils.vfInfoExists(font):
@@ -105,9 +101,10 @@ def _loadLabels(tag: str, lang=None):
 def _prepareQuestions_languages(questions):
     from fontforgeVF.language import getLanguageList
     font = fontforge.activeFont()
+    assert font is not None
     languages = set()
     for k, v in designAxes.items():
-        languages |= set(utils.getVFValue(font, 'axes.' + k + '.localNames', {}).keys())
+        languages |= set(utils.getVFValueAsDict(font, 'axes.' + k + '.localNames').keys())
     languages = tuple(languages)
     localNameCategory = len(questions)
     localNameRange = range(1, max(((len(languages) + 7) // 4) * 4, 8)+1)
@@ -120,6 +117,7 @@ def _prepareQuestions_languages(questions):
 
 def _prepareQuestions_values(questions, k, v):
     font = fontforge.activeFont()
+    assert font is not None
     tagStat = 1 if utils.getVFValue(font, 'axes.' + k + '.active', False) else 0
     if tagStat == 1 and not k.startswith('custom') and utils.getVFValue(font, 'axes.' + k + '.useDefault', False):
         tagStat = 2
@@ -159,19 +157,21 @@ def _prepareQuestions_values(questions, k, v):
 
 def _prepareQuestions_map(questions, k, v):
     font = fontforge.activeFont()
+    assert font is not None
     questions[2]["questions"].append({
         'type': 'string',
         'question': v["name"] + ':',
         'tag': k + 'map',
         'default': ', '.join(list(map(
             lambda x: str(x[0]) + ',' + str(x[1]),
-            utils.getVFValue(font, 'axes.' + k + '.map', [])
+            utils.getVFValueAsList(font, 'axes.' + k + '.map')
         ))),
     })
 
 
 def _prepareQuestions_order(questions, k, v):
     font = fontforge.activeFont()
+    assert font is not None
     questions[3]["questions"].append({
         'type': 'string',
         'question': v["name"] + ':',
@@ -182,6 +182,7 @@ def _prepareQuestions_order(questions, k, v):
 
 def _prepareQuestions_names(questions, k, v):
     font = fontforge.activeFont()
+    assert font is not None
     questions[4]["questions"].append({
         'type': 'string',
         'question': v["name"] + ':',
@@ -202,6 +203,7 @@ def _prepareQuestions_names(questions, k, v):
 
 def _prepareQuestions_localNames(questions, k, v, languages, localNameRange, localNameCategory):
     font = fontforge.activeFont()
+    assert font is not None
     for i in localNameRange:
         questions[localNameCategory + i - 1]["questions"].append({
             'type': 'string',
@@ -221,6 +223,7 @@ def _prepareQuestions_localNames(questions, k, v, languages, localNameRange, loc
 
 def _prepareQuestions_custom(questions, k, v):
     font = fontforge.activeFont()
+    assert font is not None
     if k.startswith('custom'):
         questions[1]["questions"].append({
             'type': 'string',
@@ -253,6 +256,7 @@ def _prepareQuestions():
 # Save result
 def _saveResult_values(result, k, v):
     font = fontforge.activeFont()
+    assert font is not None
     utils.setVFValue(font, 'axes.' + k + '.active', result[k] != 'unset')
     if not k.startswith('custom') and result[k] != 'unset':
         utils.setVFValue(font, 'axes.' + k + '.useDefault', result[k] == 'auto')
@@ -270,6 +274,7 @@ def _saveResult_values(result, k, v):
 
 def _saveResult_labels(result, k, v):
     font = fontforge.activeFont()
+    assert font is not None
     utils.setOrDeleteVFValue(font, 'axes.' + k + '.order', int(result[k + 'order']) if result[k + 'order'] else None)
     utils.deleteVFValue(font, 'axes.' + k + '.labels')
     if result[k + 'labels']:
@@ -280,9 +285,9 @@ def _saveResult_labels(result, k, v):
             val = val.replace('.', ',')  # escape decimal point
             valAddr = 'axes.' + k + '.labels.' + val
             utils.setOrDeleteVFValue(font, valAddr + '.olderSibling',
-                                     None if el == '' else bool(utils.intOrFloat(el) & 1))
+                                     None if el == '' else bool(int(el) & 1))
             utils.setOrDeleteVFValue(font, valAddr + '.elidable',
-                                     None if el == '' else bool(utils.intOrFloat(el) & 2))
+                                     None if el == '' else bool(int(el) & 2))
             utils.setOrDeleteVFValue(font, valAddr + '.linkedValue',
                                      None if lv == '' else utils.intOrFloat(lv))
             utils.setOrDeleteVFValue(font, valAddr + '.name',
@@ -299,6 +304,7 @@ def _saveResult_labels(result, k, v):
 
 def _saveResult_localNames(result, k, v):
     font = fontforge.activeFont()
+    assert font is not None
     utils.setOrDeleteVFValue(font, 'axes.' + k + '.name', result[k + 'name'])
     utils.deleteVFValue(font, 'axes.' + k + '.localNames')
     for i in (x.replace('lang', '') for x in result if x.startswith('lang')):
@@ -421,6 +427,6 @@ def designAxesMenu(u, glyph):
       * Axis value
       * Name
     """
-    result = fontforge.askMulti("Design axes", _prepareQuestions())
+    result = fontforge.askMulti("Design axes", _prepareQuestions())  # type: ignore
     if result:
         _saveResult(result)

{fontforge_variable_font-0.3.0 → fontforge_variable_font-0.4.1}/fontforgeVF/export.py

@@ -1,8 +1,8 @@
-from fontforgeVF import utils, language
-from fontforgeVF.design_axes import designAxes, getAxisValue
-import fontforge
-import tempfile
 from os import PathLike
+import tempfile
+
+import fontforge
+from fontTools import ttLib
 from fontTools.designspaceLib import (
     DesignSpaceDocument,
     SourceDescriptor,
@@ -11,12 +11,9 @@ from fontTools.designspaceLib import (
     AxisLabelDescriptor,
     InstanceDescriptor,
 )
-from fontTools import ttLib
-
 
-__all__ = [
-    "exportVariableFont",
-]
+from . import utils, language
+from .design_axes import designAxes, getAxisValue
 
 
 def _getSourceFonts(defaultFont: fontforge.font, filterItalicRoman: bool | None = None) -> list[fontforge.font]:
@@ -33,7 +30,7 @@ def _axisMinValue(defaultFont: fontforge.font, tag: str, filterItalicRoman: bool
             getAxisValue(f, tag) for f
             in _getSourceFonts(defaultFont, filterItalicRoman)
             if getAxisValue(f, tag) is not None
-        )
+        )  # type: ignore
     )
 
 
@@ -43,7 +40,7 @@ def _axisMaxValue(defaultFont: fontforge.font, tag: str, filterItalicRoman: bool
             getAxisValue(f, tag) for f
             in _getSourceFonts(defaultFont, filterItalicRoman)
             if getAxisValue(f, tag) is not None
-        )
+        )  # type: ignore
     )
 
 
@@ -133,7 +130,7 @@ def _outputUfo(font: fontforge.font, outputDir: str | PathLike, outputFile: str
     import re
     # import shutil  # for debug
 
-    assert outputFile.endswith('.ufo')
+    assert str(outputFile).endswith('.ufo')
     ufoPath = str(outputDir) + '/' + str(outputFile)
     changed = font.changed
     unlinkRmOvrlpSave = {}
@@ -151,10 +148,10 @@ def _outputUfo(font: fontforge.font, outputDir: str | PathLike, outputFile: str
         info = _ufoInfo()
         ufo.readInfo(info)
         if _isFixedPitch(font):
-            ufo.postscriptIsFixedPitch = True
-        ufo.styleMapFamilyName = _getFontFamilyName(font)
-        ufo.styleMapStyleName = _getFontSubFamilyName(font)
-        ufo.writeInfo(info)
+            ufo.postscriptIsFixedPitch = True  # type: ignore
+        ufo.styleMapFamilyName = _getFontFamilyName(font)  # type: ignore
+        ufo.styleMapStyleName = _getFontSubFamilyName(font)  # type: ignore
+        ufo.writeInfo(info)  # type: ignore
 
         if _aaltExists(font) or _allGSUBTags(font):
             feat = ufo.readFeatures()
@@ -172,7 +169,7 @@ def _outputUfo(font: fontforge.font, outputDir: str | PathLike, outputFile: str
             if aaltInclude or existingAalt:
                 newAalt = "feature aalt {\n" + aaltInclude + existingAalt + "} aalt;\n\n"
             feat = re.sub(featPosPattern, newAalt, feat, count=1)
-            ufo.writeFeatures(feat)
+            ufo.writeFeatures(feat)  # type: ignore
 
     font.changed = changed
 
@@ -185,6 +182,7 @@ def _designSpaceSources(font: fontforge.font, doc: DesignSpaceDocument, filterIt
     # print(_getSourceFonts(font))
     for f in _getSourceFonts(font, filterItalicRoman):
         s = SourceDescriptor()
+        assert isinstance(f.temporary, dict)
         s.path = f.temporary['ufo']
         if f is font:
             s.copyLib = True
@@ -197,11 +195,15 @@ def _designSpaceSources(font: fontforge.font, doc: DesignSpaceDocument, filterIt
         for k, v in designAxes.items():
             active = 'axes.' + k + '.active'
             if utils.getVFValue(font, active, False) and utils.getVFValue(f, active, False):
-                tag = utils.getVFValue(font, 'axes.' + k + '.tag', '????') \
+                tag = str(
+                    utils.getVFValue(font, 'axes.' + k + '.tag', '????')
                     if k.startswith('custom') else k
-                name = utils.getVFValue(font, 'axes.' + k + '.name', v['name']) \
+                )
+                name = str(
+                    utils.getVFValue(font, 'axes.' + k + '.name', v['name'])
                     if k.startswith('custom') else v['name']
-                s.location[name] = getAxisValue(f, tag)
+                )
+                s.location[name] = getAxisValue(f, tag)  # type: ignore
         s.familyName = _getFontFamilyName(f)
         s.styleName = _getFontSubFamilyName(f)
         doc.addSource(s)
@@ -210,7 +212,7 @@ def _designSpaceSources(font: fontforge.font, doc: DesignSpaceDocument, filterIt
 def _designSpaceAxes_labels(labels, a: AxisDescriptor | DiscreteAxisDescriptor):
     L = []
     for u, d in labels.items():
-        if not (a.minimum <= u <= a.maximum):
+        if not (a.minimum <= u <= a.maximum):  # type: ignore
             fontforge.logWarning('Ignored label {0} = {1} because out of range'.format(
                 a.name, str(u)))
         elif 'name' not in d:
@@ -232,15 +234,17 @@ def _designSpaceAxes(font: fontforge.font, doc: DesignSpaceDocument, filterItali
     for k, v in designAxes.items():
         if utils.getVFValue(font, 'axes.' + k + '.active', False):
             a = DiscreteAxisDescriptor() if k == 'ital' else AxisDescriptor()
-            a.tag = utils.getVFValue(font, 'axes.' + k + '.tag', '????') \
+            a.tag = str(
+                utils.getVFValue(font, 'axes.' + k + '.tag', '????')
                 if k.startswith('custom') else k
+            )
             if k == 'ital' and filterItalicRoman is not None:
-                a.minimum = 1 if filterItalicRoman else _axisMinValue(font, a.tag)
-                a.maximum = 0 if not filterItalicRoman else _axisMaxValue(font, a.tag)
+                a.minimum = 1 if filterItalicRoman else _axisMinValue(font, a.tag)  # type: ignore
+                a.maximum = 0 if not filterItalicRoman else _axisMaxValue(font, a.tag)  # type: ignore
             else:
-                a.minimum = _axisMinValue(font, a.tag)
-                a.maximum = _axisMaxValue(font, a.tag)
-            a.default = getAxisValue(font, a.tag)
+                a.minimum = _axisMinValue(font, a.tag)  # type: ignore
+                a.maximum = _axisMaxValue(font, a.tag)  # type: ignore
+            a.default = getAxisValue(font, a.tag)  # type: ignore
             a.name = utils.getVFValue(font, 'axes.' + k + '.name', v['name'])
             if val := utils.getVFValue(font, 'axes.' + k + '.map'):
                 a.map = val
@@ -252,7 +256,8 @@ def _designSpaceAxes(font: fontforge.font, doc: DesignSpaceDocument, filterItali
 
 
 def _designSpaceInstances(font: fontforge.font, doc: DesignSpaceDocument, filterItalicRoman: bool | None = None):
-    for instance in utils.getVFValue(font, 'instances', []):
+    instances = utils.getVFValueAsList(font, 'instances')
+    for instance in instances:
         i = InstanceDescriptor()
         i.styleName = instance['name']
         i.postScriptFontName = instance['psName']
@@ -325,7 +330,7 @@ def _fixTtf_axes(font: fontforge.font, ttf: ttLib.TTFont):
             if k.startswith('custom') else k
         )
         if utils.getVFValue(font, 'axes.' + k + '.active', False):
-            localNames = utils.getVFValue(font, 'axes.' + k + '.localNames', {})
+            localNames = utils.getVFValueAsDict(font, 'axes.' + k + '.localNames')
             for lang, name in localNames.items():
                 axis = [a for a in ttf["fvar"].axes if a.axisTag == tag]
                 if axis:
@@ -337,9 +342,9 @@ def _fixTtf_labels(font: fontforge.font, ttf: ttLib.TTFont):
         axisIndex = axisLabel.AxisIndex
         tag = ttf['STAT'].table.DesignAxisRecord.Axis[axisIndex].AxisTag
         value = axisLabel.Value
-        localNames = utils.getVFValue(
+        localNames = utils.getVFValueAsDict(
             font, 'axes.' + tag + '.labels.' + str(int(value)) + '.localNames',
-            utils.getVFValue(
+            utils.getVFValueAsDict(
                 font, 'axes.' + tag + '.labels.' + str(float(value)).replace('.', ',') + '.localNames',
                 {}
             )
@@ -351,7 +356,7 @@ def _fixTtf_labels(font: fontforge.font, ttf: ttLib.TTFont):
 def _fixTtf_instances(font: fontforge.font, ttf: ttLib.TTFont):
     for i, instance in enumerate(ttf['fvar'].instances):
         subfamilyNameID = instance.subfamilyNameID
-        localNames = utils.getVFValue(
+        localNames = utils.getVFValueAsDict(
             font, 'instances[' + str(i) + '].localNames', {}
         )
         for lang, name in localNames.items():
@@ -362,8 +367,12 @@ def _fixTtf(font: fontforge.font, filename: str | PathLike):
     with ttLib.TTFont(str(filename)) as ttf:
         for i in font.sfnt_names:
             if i[0] != 'English (US)':
+                if isinstance(i[0], str):  # likely
+                    langCode = language.languageCodeReverseLookup(i[0])
+                else:  # unlikely
+                    langCode = i[0]
                 if i[1] in _fields:
-                    ttf['name'].setName(i[2], _fields[i[1]], 3, 1, language.languageCodeReverseLookup(i[0]))
+                    ttf['name'].setName(i[2], _fields[i[1]], 3, 1, langCode)
         _fixTtf_axes(font, ttf)
         _fixTtf_labels(font, ttf)
         _fixTtf_instances(font, ttf)
@@ -543,7 +552,7 @@ def _exportVariableFont(font: fontforge.font, dialogResult: dict[str, str]):
 
 def _saveMenuDialog(font: fontforge.font) -> dict | None:
     if _hasBothRomanAndItalic(font):
-        questions = [
+        questions: list = [
             {
                 'type': 'savepath', 'question': '_Roman VF:', 'tag': 'file',
                 'default':
@@ -560,7 +569,7 @@ def _saveMenuDialog(font: fontforge.font) -> dict | None:
             },
         ]
     else:
-        questions = [
+        questions: list = [
             {
                 'type': 'savepath', 'question': '_Save as:', 'tag': 'file',
                 'default':
@@ -583,10 +592,10 @@ def _saveMenuDialog(font: fontforge.font) -> dict | None:
     return fontforge.askMulti("Save variable font", questions)
 
 
-def saveMenu(u, glyph):
-    if result := _saveMenuDialog(fontforge.activeFont()):
-        _exportVariableFont(fontforge.activeFont(), result)
+def saveMenu(u, font: fontforge.font):
+    if result := _saveMenuDialog(font):
+        _exportVariableFont(font, result)
 
 
-def saveEnable(u, glyph):
-    return utils.vfInfoExists(fontforge.activeFont())
+def saveEnable(u, font: fontforge.font):
+    return utils.vfInfoExists(font)

{fontforge_variable_font-0.3.0 → fontforge_variable_font-0.4.1}/fontforgeVF/instance.py

@@ -1,10 +1,11 @@
 import fontforge
-from fontforgeVF import utils
-from fontforgeVF.design_axes import designAxes
+
+from . import utils
+from .design_axes import designAxes
 
 
 def _instances_getval(font: fontforge.font, cnt: int, key: str, defaultVal):
-    instances = utils.getVFValue(font, 'instances', [])
+    instances = utils.getVFValueAsList(font, 'instances')
     if (cnt - 1) < len(instances):
         if isinstance(instances[cnt - 1], dict):
             if key in instances[cnt - 1]:
@@ -14,6 +15,7 @@ def _instances_getval(font: fontforge.font, cnt: int, key: str, defaultVal):
 
 def _prepareQuestions_instances(cnt: int):
     font = fontforge.activeFont()
+    assert font is not None
     questions = [
         {
             'type': 'string',
@@ -57,13 +59,16 @@ def _prepareQuestions_instanceLocalNames(questions: list):
     from math import ceil
 
     font = fontforge.activeFont()
-    numberOfInstances = max(((len(utils.getVFValue(font, 'instances', [])) + 7) // 4) * 4, 8)
+    assert font is not None
+    instances = utils.getVFValueAsList(font, 'instances')
+    numberOfInstances = max(((len(instances) + 7) // 4) * 4, 8)
 
     languages = set()
     numberOfLanguages = 8
-    for i in range(len(utils.getVFValue(font, 'instances', []))):
+    for i in range(len(instances)):
         for k, v in designAxes.items():
-            languages |= set(utils.getVFValue(font, 'instances[' + str(i) + '].localNames', {}).keys())
+            langdict = utils.getVFValueAsDict(font, 'instances[' + str(i) + '].localNames')
+            languages |= set(langdict.keys())
     languages = tuple(languages)
     numberOfLanguages = max(((len(languages) + 7) // 4) * 4, 8)
 
@@ -100,8 +105,10 @@ def _prepareQuestions_instanceLocalNames(questions: list):
 
 def _prepareQuestions():
     font = fontforge.activeFont()
+    assert font is not None
     questions = []
-    numberOfInstances = max(((len(utils.getVFValue(font, 'instances', [])) + 7) // 4) * 4, 8)
+    instances = utils.getVFValueAsList(font, 'instances')
+    numberOfInstances = max(((len(instances) + 7) // 4) * 4, 8)
 
     for i in range(numberOfInstances):
         questions.append({
@@ -115,6 +122,7 @@ def _prepareQuestions():
 
 def _saveInstances(result: dict):
     font = fontforge.activeFont()
+    assert font is not None
     instanceList = []
     cnt = 1
     while 'psName' + str(cnt) in result:

{fontforge_variable_font-0.3.0 → fontforge_variable_font-0.4.1}/fontforgeVF/language.py

@@ -1,10 +1,3 @@
-__all__ = [
-    'languageCodeIterator',
-    'languageCodeLookup',
-    'languageCodeReverseLookup',
-    'getLanguageList',
-]
-
 languageData = {
     1: {
         'name': 'Arabic',
@@ -832,7 +825,7 @@ def getLanguageList(listNumber: int, defaultCode: int | None = None):
     for langId, langCode, langName in sorted(languageCodeIterator(), key=lambda x: x[2]):
         languageList.append({'name': langName, 'tag': hex(langId), 'default': langId == defaultCode})
     questions = {
-        'category': 'Localized names ' + (
+        'category': 'Localized names ' + str(
             languageCodeLookup(defaultCode) if defaultCode else str(listNumber)
         ),
         'questions': [

{fontforge_variable_font-0.3.0 → fontforge_variable_font-0.4.1}/fontforgeVF/load.py

@@ -1,14 +1,11 @@
-import fontforge
-from fontforgeVF.utils import intOrFloat, checkExtensionTtfOrWoff2
-from os import PathLike
-from fontTools import ttLib
 import faulthandler
-from typing import Literal, Callable
+from os import PathLike
 
+import fontforge
+from fontTools import ttLib
 
-__all__ = [
-    "openVariableFont",
-]
+from .utils import intOrFloat, checkExtensionTtfOrWoff2, ensureTuple
+from fontforge_plugin_helper import addFontGenerateHook
 
 
 def _checkAxisValue(ttf: ttLib.TTFont, axisValues: dict[str, int | float]):
@@ -64,7 +61,7 @@ def _denormalize(minimum, default, maximum, value):
 def _getVFData_fvar_axes(ttf: ttLib.TTFont, axisValues: dict[str, int | float], vfData: dict):
     for axis in ttf['fvar'].axes:
         tag = axis.axisTag
-        axisData = {'active': True}
+        axisData: dict[str, str | int | float] = {'active': True}
         if tag in axisValues:
             axisData['useDefault'] = False
             axisData['value'] = intOrFloat(axisValues[tag])
@@ -211,6 +208,7 @@ def _doOpenVariableFont(
         partial.save(instancePath)
     font = fontforge.open(instancePath)
     initPersistentDict(font)
+    assert isinstance(font.persistent, dict)
     font.persistent['VF'] = vfData
     return font
 
@@ -222,12 +220,12 @@ def _openVF(
 ) -> fontforge.font:
     with ttLib.TTFont(filename) as ttf:
         if 'fvar' not in ttf:
-            return fontforge.open(filename)
+            return fontforge.open(str(filename))
         elif isinstance(axisValuesOrInstance, dict):
             if [axis for axis in ttf['fvar'].axes if axis.minValue != axis.maxValue]:
                 return _doOpenVariableFont(filename, axisValuesOrInstance, ttf, tmpdir)
             else:
-                return fontforge.open(filename)
+                return fontforge.open(str(filename))
         elif isinstance(axisValuesOrInstance, int):
             return _doOpenVariableFont(
                 filename,
@@ -290,10 +288,11 @@ def openVariableFont(
     filetype = checkExtensionTtfOrWoff2(filename)
     with tempfile.TemporaryDirectory() as tmpdir:
         if filetype == 'ttf':
-            _openVF(filename, axisValuesOrInstance, tmpdir)
+            font = _openVF(filename, axisValuesOrInstance, tmpdir)
         else:  # woff2
             ttFile = _woff2Decompress(filename, tmpdir)
-            _openVF(ttFile, axisValuesOrInstance, tmpdir)
+            font = _openVF(ttFile, axisValuesOrInstance, tmpdir)
+    return font
 
 
 def _setParameterDialog(filename: str | PathLike, ttf: ttLib.TTFont, tmpdir: str | PathLike):
@@ -314,8 +313,8 @@ def _setParameterDialog(filename: str | PathLike, ttf: ttLib.TTFont, tmpdir: str
 
     if result := fontforge.askMulti('Please specify an instance to open', questions):
         for key in result:
-            result[key] = intOrFloat(result[key])
-        _doOpenVariableFont(filename, result, ttf, tmpdir)
+            result[key] = intOrFloat(result[key])  # type: ignore
+        _doOpenVariableFont(filename, result, ttf, tmpdir)  # type: ignore
 
 
 def _chooseInstanceDialog(filename: str | PathLike, ttf: ttLib.TTFont, tmpdir: str | PathLike):
@@ -323,10 +322,10 @@ def _chooseInstanceDialog(filename: str | PathLike, ttf: ttLib.TTFont, tmpdir: s
     result = fontforge.askChoices(
         'Choose instance(s) to open',
         'Instances in this font',
-        [str(ttf['name'].getName(i.subfamilyNameID, 3, 1, 0x409)) for i in ttf['fvar'].instances],
+        tuple([str(ttf['name'].getName(i.subfamilyNameID, 3, 1, 0x409)) for i in ttf['fvar'].instances]),
         multiple=True
     )
-    for i in (x[1] for x in zip(result, ttf['fvar'].instances) if x[0]):
+    for i in (x[1] for x in zip(ensureTuple(result), ttf['fvar'].instances) if x[0]):
         _doOpenVariableFont(filename, i.coordinates, ttf, tmpdir)
 
 
@@ -370,6 +369,7 @@ def loadMenu(u, glyph):
 def _generatePreHook(font: fontforge.font, target: str):
     from fontforgeVF.utils import vfInfoExists
 
+    assert isinstance(font.temporary, dict)
     changed = font.changed
     if vfInfoExists(font):
         if target.endswith('.ttf') or target.endswith('.woff2'):
@@ -378,7 +378,7 @@ def _generatePreHook(font: fontforge.font, target: str):
                 "This font has variable font metadata in its persistent dict.\n"
                 "Did you intend to output a variable font?\n"
                 "(all masters need to be opened beforehand)",
-                ["_Yes", "_No"],
+                ["_Yes", "_No"],  # type: ignore
             )
             font.temporary['generateVF'] = (ans == 0)
             font.changed = changed
@@ -388,6 +388,7 @@ def _generatePostHook(font: fontforge.font, target: str):
     from fontforgeVF.utils import vfInfoExists
     from fontforgeVF.export import exportVariableFont
 
+    assert isinstance(font.temporary, dict)
     changed = font.changed
     if vfInfoExists(font):
         if 'generateVF' in font.temporary:
@@ -401,29 +402,11 @@ def _generatePostHook(font: fontforge.font, target: str):
             font.changed = changed
 
 
-def _addHook(
-    font: fontforge.font,
-    name: Literal['generateFontPreHook', 'generateFontPostHook'],
-    hook: Callable[[fontforge.font, str], None]
-):
-    assert isinstance(font.temporary, dict)
-    if name in font.temporary:
-        currentHook = font.temporary[name]
-
-        def chainHook(font: fontforge.font, target: str):
-            currentHook(font, target)
-            hook(font, target)
-
-        font.temporary[name] = chainHook
-    else:
-        font.temporary[name] = hook
-
-
 def _addGenerateHook(font: fontforge.font):
     if not isinstance(font.temporary, dict):
         font.temporary = {}
-    _addHook(font, 'generateFontPreHook', _generatePreHook)
-    _addHook(font, 'generateFontPostHook', _generatePostHook)
+    addFontGenerateHook(font, 'generateFontPreHook', _generatePreHook)
+    addFontGenerateHook(font, 'generateFontPostHook', _generatePostHook)
 
 
 def _loadHook_ttf(font: fontforge.font):
@@ -442,13 +425,14 @@ def _loadHook_ttf(font: fontforge.font):
                         "_Yes",
                         "Open with _parameters",
                         "_No",
-                    ]
+                    ]  # type: ignore
                 )
                 if ans == 0 or ans == 1:
                     _selectInstanceDialog(font.path, ttf, ans)
             else:
                 _selectInstanceDialog(font.path, ttf, 1)
             initPersistentDict(font)
+            assert isinstance(font.persistent, dict)
             vfData = _getVFData(ttf, {})
             font.persistent['VF'] = vfData
 

{fontforge_variable_font-0.3.0 → fontforge_variable_font-0.4.1}/fontforgeVF/utils.py

@@ -1,22 +1,10 @@
-import fontforge
-import re
 from os import PathLike
+import re
 
-
-__all__ = [
-    "intOrFloat",
-    "initPersistentDict",
-    "vfInfoExists",
-    "getVFValue",
-    "setVFValue",
-    "deleteEmptyDicts",
-    "deleteVFValue",
-    "setOrDeleteVFValue",
-    "checkExtensionTtfOrWoff2",
-]
+import fontforge
 
 
-def intOrFloat(val):
+def intOrFloat(val: str | int | float):
     """Convert to ``int`` or ``float`` if possible
 
     If parameter represents an integer, returns it converted to ``int``
@@ -43,6 +31,33 @@ def intOrFloat(val):
         return f
 
 
+def ensureList(obj) -> list:
+    if obj is None:
+        return []
+    elif isinstance(obj, list):
+        return obj
+    else:
+        return list(obj)
+
+
+def ensureTuple(obj) -> tuple:
+    if obj is None:
+        return ()
+    elif isinstance(obj, tuple):
+        return obj
+    else:
+        return tuple(obj)
+
+
+def ensureDict(obj) -> dict:
+    if obj is None:
+        return {}
+    elif isinstance(obj, dict):
+        return obj
+    else:
+        return dict(obj)
+
+
 def initPersistentDict(font: fontforge.font):
     """Make sure ``font.persistent`` is a ``dict``
 
@@ -135,6 +150,7 @@ def getVFValue(font: fontforge.font, key: str, default=None):
     if not vfInfoExists(font):
         return default
     else:
+        assert isinstance(font.persistent, dict)
         info = font.persistent["VF"]
         for part in _checkVFAddr(key):
             c, k = part
@@ -149,6 +165,34 @@ def getVFValue(font: fontforge.font, key: str, default=None):
         return info
 
 
+def getVFValueAsList(font: fontforge.font, key: str, default: list = []) -> list:
+    """Gets a value from VF info
+
+    Same as ``getVFValue()`` but ensures returning a list
+
+    :param font: Fontforge font object
+    :param key: Name of key
+    :param default: Optional. Returns this value if ``key`` does not \
+    exist. Without this parameter defaults to ``[]``.
+    :return: the value for ``key``, or ``default`` if no such ``key``.
+    """
+    return ensureList(getVFValue(font, key, default))
+
+
+def getVFValueAsDict(font: fontforge.font, key: str, default: dict = {}) -> dict:
+    """Gets a value from VF info
+
+    Same as ``getVFValue()`` but ensures returning a dict
+
+    :param font: Fontforge font object
+    :param key: Name of key
+    :param default: Optional. Returns this value if ``key`` does not \
+    exist. Without this parameter defaults to ``{}``.
+    :return: the value for ``key``, or ``default`` if no such ``key``.
+    """
+    return ensureDict(getVFValue(font, key, default))
+
+
 def _makeSureKeyExists(container, key):
     if isinstance(container, list):
         while len(container) <= key:
@@ -179,6 +223,7 @@ def setVFValue(font: fontforge.font, key: str, val):
     :raises ``RuntimeError``: user refused ``initPersistentDict``.
     """
     initPersistentDict(font)
+    assert isinstance(font.persistent, dict)
     parent = font.persistent
     info = parent["VF"]
     prevk = "VF"
@@ -200,7 +245,7 @@ def setVFValue(font: fontforge.font, key: str, val):
     parent[k] = val
 
 
-def _deleteEmptyLists(d: dict):
+def _deleteEmptyLists(d: dict | list):
     if isinstance(d, list):
         for i in range(len(d)):
             if isinstance(d[i], dict):
@@ -253,6 +298,7 @@ def deleteVFValue(font: fontforge.font, key: str) -> bool:
     :return: ``True`` if the key was deleted, ``False`` otherwise.
     """
     if vfInfoExists(font):
+        assert isinstance(font.persistent, dict)
         parent = font.persistent
         info = parent["VF"]
         for part in _checkVFAddr(key):

{fontforge_variable_font-0.3.0 → fontforge_variable_font-0.4.1/fontforge_variable_font.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fontforge_variable_font
-Version: 0.3.0
+Version: 0.4.1
 Summary: A FontForge_plugin to create a variable font
 Home-page: https://github.com/MihailJP/fontforge-variable-font
 Author: MihailJP
@@ -17,6 +17,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: fonttools
 Requires-Dist: fontmake
+Requires-Dist: fontforge_plugin_helper
 Dynamic: license-file
 
 Fontforge Variable Font Plugin

fontforge_variable_font-0.4.1/fontforge_variable_font.egg-info/requires.txt

@@ -0,0 +1,3 @@
+fonttools
+fontmake
+fontforge_plugin_helper

{fontforge_variable_font-0.3.0 → fontforge_variable_font-0.4.1}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = fontforge_variable_font
-version = 0.3.0
+version = 0.4.1
 author = MihailJP
 author_email = mihailjp@gmail.com
 description = A FontForge_plugin to create a variable font
@@ -24,6 +24,7 @@ python_requires = >=3.10
 install_requires = 
 	fonttools
 	fontmake
+	fontforge_plugin_helper
 
 [options.entry_points]
 fontforge_plugin = 

{fontforge_variable_font-0.3.0 → fontforge_variable_font-0.4.1}/test/test_export.py

@@ -1,5 +1,6 @@
-import pytest
 import fontforge
+import pytest
+
 from fontforgeVF.utils import setVFValue
 
 

fontforge_variable_font-0.3.0/fontforgeVF/__init__.py

@@ -1,6 +0,0 @@
-from fontforgeVF.delete import *
-from fontforgeVF.design_axes import *
-from fontforgeVF.export import *
-from fontforgeVF.language import *
-from fontforgeVF.load import *
-from fontforgeVF.utils import *

fontforge_variable_font-0.3.0/fontforge_variable_font.egg-info/requires.txt

@@ -1,2 +0,0 @@
-fonttools
-fontmake

{fontforge_variable_font-0.3.0 → fontforge_variable_font-0.4.1}/test/test_design_axes.py

@@ -1,5 +1,5 @@
-import pytest
 import fontforge
+import pytest
 
 
 def axisTestFont(useDefault):

{fontforge_variable_font-0.3.0 → fontforge_variable_font-0.4.1}/test/test_utils.py

@@ -1,5 +1,5 @@
-import pytest
 import fontforge
+import pytest
 
 
 @pytest.mark.parametrize(('param', 'expectedVal', 'expectedType'), [