python-fontbro 0.28.1__tar.gz → 0.29.0__tar.gz

{python_fontbro-0.28.1/python_fontbro.egg-info → python_fontbro-0.29.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-fontbro
-Version: 0.28.1
+Version: 0.29.0
 Summary: friendly font operations on top of fontTools.
 Author-email: Fabio Caccamo <fabio.caccamo@gmail.com>
 Maintainer-email: Fabio Caccamo <fabio.caccamo@gmail.com>
@@ -138,6 +138,7 @@ with open("fonts/MyFont.ttf") as fh:
 -   [`get_variable_instance_by_style_name`](#get_variable_instance_by_style_name)
 -   [`get_variable_instance_closest_to_coordinates`](#get_variable_instance_closest_to_coordinates)
 -   [`get_version`](#get_version)
+-   [`get_version_formatted`](#get_version_formatted)
 -   [`get_vertical_metrics`](#get_vertical_metrics)
 -   [`get_weight`](#get_weight)
 -   [`get_width`](#get_width)
@@ -163,6 +164,7 @@ with open("fonts/MyFont.ttf") as fh:
 -   [`set_style_flags`](#set_style_flags)
 -   [`set_style_flags_by_subfamily_name`](#set_style_flags_by_subfamily_name)
 -   [`set_style_name`](#set_style_name)
+-   [`set_version`](#set_version)
 -   [`set_vertical_metrics`](#set_vertical_metrics)
 -   [`subset`](#subset)
 -   [`to_sliced_variable`](#to_sliced_variable)
@@ -784,13 +786,48 @@ instance = font.get_variable_instance_closest_to_coordinates(
 #### `get_version`
 ```python
 """
-Gets the font version.
+Gets the font version reading it from head.fontRevision,
+with fallback on the version name record (name id 5) parsed value,
+eg. "Version 1.015;git-0a5106e0b" -> 1.015.
 
-:returns: The font version value.
+:param use_head_revision: If True, the head.fontRevision value is used (if set).
+:type use_head_revision: bool
+:param use_name_record: If True, the version name record value is used as fallback.
+:type use_name_record: bool
+
+:returns: The font version value, 0.0 if the version cannot be read.
 :rtype: float
+
+:raises ArgumentError: If both options are False.
 """
 
-version = font.get_version()
+version = font.get_version(use_head_revision=True, use_name_record=True)
+```
+
+#### `get_version_formatted`
+```python
+"""
+Gets the font version formatted using the version name record convention,
+with the given prefix and a minimum of 3 decimal digits, eg. "v1.015".
+
+:param use_head_revision: If True, the head.fontRevision value is used (if set).
+:type use_head_revision: bool
+:param use_name_record: If True, the version name record value is used as fallback.
+:type use_name_record: bool
+:param prefix: The prefix to prepend to the version value.
+:type prefix: str
+
+:returns: The formatted font version value, eg. "v0.000" if the version cannot be read.
+:rtype: str
+
+:raises ArgumentError: If both source options are False.
+"""
+
+version = font.get_version_formatted(
+    use_head_revision=True,
+    use_name_record=True,
+    prefix="v",
+)
 ```
 
 #### `get_vertical_metrics`
@@ -1240,6 +1277,28 @@ Sets the style name updating the related font names records.
 font.set_style_name(name="Bold Italic")
 ```
 
+#### `set_version`
+```python
+"""
+Sets the font version, the version value can be a number (eg. 1.015)
+or a version string (eg. "Version 1.015"), parsed the same way the
+version name record value is parsed when read.
+The head.fontRevision and the version name record (name id 5) are
+updated, the latter is overwritten with the canonical "Version X.YYY"
+form (any extra info it contained is dropped).
+The unique identifier name record (name id 3) is updated only if its
+first ";" separated part holds the current version value, and only in
+that part. The CFF version is updated only if the font already has it.
+
+:param version: The version value, eg. 1.015 or "Version 1.015"
+:type version: float or str
+
+:raises ArgumentError: If the version value is not valid.
+"""
+
+font.set_version(1.015)
+```
+
 #### `set_vertical_metrics`
 ```python
 """

{python_fontbro-0.28.1 → python_fontbro-0.29.0}/README.md

@@ -74,6 +74,7 @@ with open("fonts/MyFont.ttf") as fh:
 -   [`get_variable_instance_by_style_name`](#get_variable_instance_by_style_name)
 -   [`get_variable_instance_closest_to_coordinates`](#get_variable_instance_closest_to_coordinates)
 -   [`get_version`](#get_version)
+-   [`get_version_formatted`](#get_version_formatted)
 -   [`get_vertical_metrics`](#get_vertical_metrics)
 -   [`get_weight`](#get_weight)
 -   [`get_width`](#get_width)
@@ -99,6 +100,7 @@ with open("fonts/MyFont.ttf") as fh:
 -   [`set_style_flags`](#set_style_flags)
 -   [`set_style_flags_by_subfamily_name`](#set_style_flags_by_subfamily_name)
 -   [`set_style_name`](#set_style_name)
+-   [`set_version`](#set_version)
 -   [`set_vertical_metrics`](#set_vertical_metrics)
 -   [`subset`](#subset)
 -   [`to_sliced_variable`](#to_sliced_variable)
@@ -720,13 +722,48 @@ instance = font.get_variable_instance_closest_to_coordinates(
 #### `get_version`
 ```python
 """
-Gets the font version.
+Gets the font version reading it from head.fontRevision,
+with fallback on the version name record (name id 5) parsed value,
+eg. "Version 1.015;git-0a5106e0b" -> 1.015.
 
-:returns: The font version value.
+:param use_head_revision: If True, the head.fontRevision value is used (if set).
+:type use_head_revision: bool
+:param use_name_record: If True, the version name record value is used as fallback.
+:type use_name_record: bool
+
+:returns: The font version value, 0.0 if the version cannot be read.
 :rtype: float
+
+:raises ArgumentError: If both options are False.
 """
 
-version = font.get_version()
+version = font.get_version(use_head_revision=True, use_name_record=True)
+```
+
+#### `get_version_formatted`
+```python
+"""
+Gets the font version formatted using the version name record convention,
+with the given prefix and a minimum of 3 decimal digits, eg. "v1.015".
+
+:param use_head_revision: If True, the head.fontRevision value is used (if set).
+:type use_head_revision: bool
+:param use_name_record: If True, the version name record value is used as fallback.
+:type use_name_record: bool
+:param prefix: The prefix to prepend to the version value.
+:type prefix: str
+
+:returns: The formatted font version value, eg. "v0.000" if the version cannot be read.
+:rtype: str
+
+:raises ArgumentError: If both source options are False.
+"""
+
+version = font.get_version_formatted(
+    use_head_revision=True,
+    use_name_record=True,
+    prefix="v",
+)
 ```
 
 #### `get_vertical_metrics`
@@ -1176,6 +1213,28 @@ Sets the style name updating the related font names records.
 font.set_style_name(name="Bold Italic")
 ```
 
+#### `set_version`
+```python
+"""
+Sets the font version, the version value can be a number (eg. 1.015)
+or a version string (eg. "Version 1.015"), parsed the same way the
+version name record value is parsed when read.
+The head.fontRevision and the version name record (name id 5) are
+updated, the latter is overwritten with the canonical "Version X.YYY"
+form (any extra info it contained is dropped).
+The unique identifier name record (name id 3) is updated only if its
+first ";" separated part holds the current version value, and only in
+that part. The CFF version is updated only if the font already has it.
+
+:param version: The version value, eg. 1.015 or "Version 1.015"
+:type version: float or str
+
+:raises ArgumentError: If the version value is not valid.
+"""
+
+font.set_version(1.015)
+```
+
 #### `set_vertical_metrics`
 ```python
 """

{python_fontbro-0.28.1 → python_fontbro-0.29.0}/fontbro/files.py

@@ -93,14 +93,3 @@ def get_filename(
     extension = get_format(ttfont)
     filename = f"{basename}.{extension}"
     return filename
-
-
-def get_version(
-    ttfont: TTFont,
-) -> float:
-    """
-    Gets the version of the given font (head.fontRevision).
-    """
-    head = ttfont.get("head")
-    version = float(head.fontRevision)
-    return version

{python_fontbro-0.28.1 → python_fontbro-0.29.0}/fontbro/font.py

@@ -29,6 +29,7 @@ from fontbro import support as _support
 from fontbro import tables as _tables
 from fontbro import unicode as _unicode
 from fontbro import variable as _variable
+from fontbro import version as _version
 from fontbro.exceptions import (
     ArgumentError,
     OperationError,
@@ -1027,15 +1028,62 @@ class Font:
 
     def get_version(
         self,
+        *,
+        use_head_revision: bool = True,
+        use_name_record: bool = True,
     ) -> float:
         """
-        Gets the font version.
+        Gets the font version reading it from head.fontRevision,
+        with fallback on the version name record (name id 5) parsed value,
+        eg. "Version 1.015;git-0a5106e0b" -> 1.015.
+
+        :param use_head_revision: If True, the head.fontRevision value is used (if set).
+        :type use_head_revision: bool
+        :param use_name_record: If True, the version name record value is used as fallback.
+        :type use_name_record: bool
 
-        :returns: The font version value.
+        :returns: The font version value, 0.0 if the version cannot be read.
         :rtype: float
+
+        :raises ArgumentError: If both options are False.
+        """
+        ttfont = self.get_ttfont()
+        return _version.get_version(
+            ttfont,
+            use_head_revision=use_head_revision,
+            use_name_record=use_name_record,
+        )
+
+    def get_version_formatted(
+        self,
+        *,
+        use_head_revision: bool = True,
+        use_name_record: bool = True,
+        prefix: str = "v",
+    ) -> str:
+        """
+        Gets the font version formatted using the version name record convention,
+        with the given prefix and a minimum of 3 decimal digits, eg. "v1.015".
+
+        :param use_head_revision: If True, the head.fontRevision value is used (if set).
+        :type use_head_revision: bool
+        :param use_name_record: If True, the version name record value is used as fallback.
+        :type use_name_record: bool
+        :param prefix: The prefix to prepend to the version value.
+        :type prefix: str
+
+        :returns: The formatted font version value, eg. "v0.000" if the version cannot be read.
+        :rtype: str
+
+        :raises ArgumentError: If both source options are False.
         """
         ttfont = self.get_ttfont()
-        return _files.get_version(ttfont)
+        return _version.get_version_formatted(
+            ttfont,
+            use_head_revision=use_head_revision,
+            use_name_record=use_name_record,
+            prefix=prefix,
+        )
 
     def get_vertical_metrics(
         self,
@@ -1670,6 +1718,29 @@ class Font:
             style_name=name,
         )
 
+    def set_version(
+        self,
+        version: float | str,
+    ) -> None:
+        """
+        Sets the font version, the version value can be a number (eg. 1.015)
+        or a version string (eg. "Version 1.015"), parsed the same way the
+        version name record value is parsed when read.
+        The head.fontRevision and the version name record (name id 5) are
+        updated, the latter is overwritten with the canonical "Version X.YYY"
+        form (any extra info it contained is dropped).
+        The unique identifier name record (name id 3) is updated only if its
+        first ";" separated part holds the current version value, and only in
+        that part. The CFF version is updated only if the font already has it.
+
+        :param version: The version value, eg. 1.015 or "Version 1.015"
+        :type version: float or str
+
+        :raises ArgumentError: If the version value is not valid.
+        """
+        ttfont = self.get_ttfont()
+        _version.set_version(ttfont, version)
+
     def set_vertical_metrics(
         self,
         **vertical_metrics: Any,

{python_fontbro-0.28.1 → python_fontbro-0.29.0}/fontbro/metadata.py

@@ -4,4 +4,4 @@ __description__ = "friendly font operations on top of fontTools."
 __email__ = "fabio.caccamo@gmail.com"
 __license__ = "MIT"
 __title__ = "python-fontbro"
-__version__ = "0.28.1"
+__version__ = "0.29.0"

{python_fontbro-0.28.1 → python_fontbro-0.29.0}/fontbro/names.py

@@ -72,6 +72,8 @@ _NAMES_BY_KEY: dict[str, dict[str, Any]] = {item["key"]: item for item in _NAMES
 _NAMES_WIN_IDS: dict[str, Any] = {"platformID": 3, "platEncID": 1, "langID": 0x409}
 # macintosh: platform 1, encoding 0 (roman), language 0 (english)
 _NAMES_MAC_IDS: dict[str, Any] = {"platformID": 1, "platEncID": 0, "langID": 0x0}
+# unicode: platform 0, encoding 3 (unicode bmp), language 0 (no language)
+_NAMES_UNI_IDS: dict[str, Any] = {"platformID": 0, "platEncID": 3, "langID": 0x0}
 
 
 def _get_name_id(
@@ -101,6 +103,10 @@ def _is_encodable(
         platform_ids["platEncID"],
         platform_ids["langID"],
     )
+    if not encoding:
+        # the encoding of the name records is unknown (eg. the macintosh
+        # "uninterpreted" script), so the value cannot be written to them
+        return False
     try:
         value.encode(encoding)
     except UnicodeEncodeError:
@@ -108,6 +114,31 @@ def _is_encodable(
     return True
 
 
+def _get_name_records_ids(
+    name_table: Any,
+    name_id: int,
+    platform_ids: dict[str, Any],
+) -> list[dict[str, Any]]:
+    """
+    Gets the ids of the existing name records with the given name id, matching
+    the platform and the language of the given platform ids. The encoding is
+    not matched: the same name id can have more than one record with different
+    encodings (eg. a windows symbol record and a windows unicode one).
+    Records in other languages are not matched, so they are never overwritten.
+    """
+    return [
+        {
+            "platformID": record.platformID,
+            "platEncID": record.platEncID,
+            "langID": record.langID,
+        }
+        for record in name_table.names
+        if record.nameID == name_id
+        and record.platformID == platform_ids["platformID"]
+        and record.langID == platform_ids["langID"]
+    ]
+
+
 def get_name(
     ttfont: TTFont,
     key: int | str,
@@ -160,19 +191,21 @@ def set_name(
     # https://github.com/fonttools/fonttools/blob/main/Lib/fontTools/ttLib/tables/_n_a_m_e.py#L568
     # the windows record is always written, it's the one read first by get_name
     name_table.setName(value, name_id, **_NAMES_WIN_IDS)
-    # mac records are legacy (modern tools don't produce them anymore),
-    # so they are updated only if the font already has some of them
-    mac_platform_id = _NAMES_MAC_IDS["platformID"]
-    if not any(record.platformID == mac_platform_id for record in name_table.names):
-        return
-    # the mac roman encoding can't encode many characters (eg. greek, cyrillic, cjk),
-    # in that case the mac name record is removed (as fontTools addMultilingualName
-    # does), otherwise the font would raise UnicodeEncodeError when saved;
-    # removing it is safe because the windows record has just been written
-    if _is_encodable(value, _NAMES_MAC_IDS):
-        name_table.setName(value, name_id, **_NAMES_MAC_IDS)
-    else:
-        name_table.removeNames(nameID=name_id, **_NAMES_MAC_IDS)
+    # the other records of the same name id are updated only if the font
+    # already has them (mac and unicode records are legacy, modern tools don't
+    # produce them anymore, so they are never added): a record left with its
+    # previous value would contradict the record just written
+    for platform_ids in (_NAMES_WIN_IDS, _NAMES_UNI_IDS, _NAMES_MAC_IDS):
+        for record_ids in _get_name_records_ids(name_table, name_id, platform_ids):
+            # the value is written only if the record encoding can encode it
+            # (eg. mac roman can't encode greek, cyrillic, cjk), otherwise the
+            # record is removed (as fontTools addMultilingualName does),
+            # because the font would raise UnicodeEncodeError when saved;
+            # removing it is safe because the windows record has just been written
+            if _is_encodable(value, record_ids):
+                name_table.setName(value, name_id, **record_ids)
+            else:
+                name_table.removeNames(nameID=name_id, **record_ids)
 
 
 def set_names(

python_fontbro-0.29.0/fontbro/version.py

@@ -0,0 +1,253 @@
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from fontTools.misc.fixedTools import fixedToStr, floatToFixed
+from fontTools.ttLib import TTFont
+
+from fontbro import names as _names
+from fontbro.exceptions import ArgumentError
+
+# the version name record conventionally starts with the version value,
+# optionally prefixed by "Version" or "v", and it can be followed by
+# extra info, eg. "Version 3.019;git-0a5106e0b"
+# https://learn.microsoft.com/en-us/typography/opentype/spec/name#name-ids
+_VERSION_PATTERN: re.Pattern[str] = re.compile(
+    r"^(?:version|v\.?)?[\s\:]*(\d+)\.(\d+)",
+    flags=re.IGNORECASE,
+)
+
+# head.fontRevision is a 16.16 fixed-point value
+_VERSION_PRECISION_BITS: int = 16
+
+# head.fontRevision is encoded as a signed 32 bits integer, so this is the
+# greatest value it can hold: greater values cannot be stored in a font
+# (and they would make fontTools fail when saving it)
+_VERSION_MAX_VALUE: float = ((2**31) - 1) / (1 << _VERSION_PRECISION_BITS)
+
+
+def _get_version_str(
+    version: float,
+) -> str:
+    """
+    Gets the shortest decimal representation of the given version value
+    that converts back to the same head.fontRevision fixed-point value.
+    """
+    version_fixed = floatToFixed(version, precisionBits=_VERSION_PRECISION_BITS)
+    return str(fixedToStr(version_fixed, precisionBits=_VERSION_PRECISION_BITS))
+
+
+def normalize_version(
+    version: float,
+) -> float:
+    """
+    Normalizes the given version value to the shortest decimal representation
+    that converts back to the same head.fontRevision fixed-point value,
+    eg. 1.0149993896484375 -> 1.015 (both are stored as 66519 in the head table).
+    """
+    return float(_get_version_str(version))
+
+
+def _get_version_parts(
+    version: float,
+) -> tuple[str, str]:
+    """
+    Gets the (major, minor) parts of the given version value as digit strings,
+    with the minor part padded to a minimum of 3 digits, eg. 1.1 -> ("1", "100").
+    """
+    major, _, minor = _get_version_str(version).partition(".")
+    return major, minor.ljust(3, "0")
+
+
+def format_version(
+    version: float,
+    *,
+    prefix: str = "v",
+) -> str:
+    """
+    Formats the given version value using the version name record convention,
+    with the given prefix and a minimum of 3 decimal digits, eg. 1.1 -> "v1.100".
+    More decimal digits are kept if the value needs them, eg. 1.0001 -> "v1.0001".
+    """
+    major, minor = _get_version_parts(version)
+    return f"{prefix}{major}.{minor}"
+
+
+def parse_version(
+    value: str | None,
+) -> float:
+    """
+    Parses the version value from the given version name record value,
+    eg. "Version 1.015;git-0a5106e0b" -> 1.015.
+    The value is matched from the beginning of the string to avoid reading
+    unrelated numbers (eg. a date or a tool version).
+    Returns 0.0 if the value cannot be parsed, or if it holds a value that
+    cannot be stored as a font version.
+    """
+    match = _VERSION_PATTERN.match((value or "").strip())
+    if not match:
+        return 0.0
+    version = float(f"{match[1]}.{match[2]}")
+    if not 0 < version <= _VERSION_MAX_VALUE:
+        return 0.0
+    return normalize_version(version)
+
+
+def get_version(
+    ttfont: TTFont,
+    *,
+    use_head_revision: bool = True,
+    use_name_record: bool = True,
+) -> float:
+    """
+    Gets the version of the given font reading it from head.fontRevision,
+    with fallback on the version name record (name id 5) parsed value.
+    The value is normalized to its shortest decimal representation,
+    so that it doesn't depend on the source it has been read from.
+    """
+    if not use_head_revision and not use_name_record:
+        raise ArgumentError(
+            "Invalid arguments: at least one of 'use_head_revision' "
+            "and 'use_name_record' options must be True."
+        )
+    if use_head_revision:
+        # the head table is read only if the font has it
+        head = ttfont.get("head")
+        if head is not None:
+            # fontRevision is 0.0 when it has not been set
+            version = float(getattr(head, "fontRevision", None) or 0.0)
+            if 0 < version <= _VERSION_MAX_VALUE:
+                return normalize_version(version)
+    if use_name_record:
+        version = parse_version(_names.get_name(ttfont, _names.NAME_VERSION))
+        if version > 0:
+            return version
+    return 0.0
+
+
+def get_version_formatted(
+    ttfont: TTFont,
+    *,
+    use_head_revision: bool = True,
+    use_name_record: bool = True,
+    prefix: str = "v",
+) -> str:
+    """
+    Gets the formatted version of the given font, eg. "v1.015".
+    """
+    version = get_version(
+        ttfont,
+        use_head_revision=use_head_revision,
+        use_name_record=use_name_record,
+    )
+    return format_version(version, prefix=prefix)
+
+
+def _get_cff_top_dict(
+    ttfont: TTFont,
+) -> Any | None:
+    """
+    Gets the CFF top dict of the given font, None if the font has no CFF table,
+    or if its CFF holds no font, or if it holds more than one font (eg. in a
+    font collection) and the one matching the font postscript name is not found.
+    """
+    cff_table = ttfont.get("CFF ")
+    if cff_table is None:
+        return None
+    cff = cff_table.cff
+    font_names = list(cff.fontNames)
+    if len(font_names) == 1:
+        font_index = 0
+    else:
+        # a cff can hold more than one font, in that case the font is looked up
+        # by its postscript name, to avoid writing to the wrong one
+        postscript_name = _names.get_name(ttfont, _names.NAME_POSTSCRIPT_NAME) or ""
+        if postscript_name not in font_names:
+            return None
+        font_index = font_names.index(postscript_name)
+    top_dict_index = cff.topDictIndex
+    if font_index >= len(top_dict_index):
+        return None
+    return top_dict_index[font_index]
+
+
+def _format_cff_version(
+    version: float,
+) -> str:
+    """
+    Formats the given version value using the CFF top dict convention,
+    eg. 1.015 -> "001.015".
+    """
+    major, minor = _get_version_parts(version)
+    return f"{int(major):03d}.{minor}"
+
+
+def set_version(
+    ttfont: TTFont,
+    version: float | str,
+) -> None:
+    """
+    Sets the version of the given font, the version value can be a number
+    (eg. 1.015) or a version string (eg. "Version 1.015"), parsed the same
+    way the version name record value is parsed when read.
+    The head.fontRevision and the version name record (name id 5) are updated,
+    the latter is overwritten with the canonical "Version X.YYY" form
+    (any extra info it contained is dropped).
+    The unique identifier name record (name id 3) is updated only if its first
+    ";" separated part holds the current version value, and only in that part.
+    The CFF version is updated only if the font already has it.
+    Each value is written only if the font has the table holding it.
+    """
+    if isinstance(version, str):
+        # a version string is parsed as the version name record value
+        version_value = parse_version(version)
+    elif isinstance(version, (int, float)):
+        version_value = float(version)
+    else:
+        version_type = type(version).__name__
+        raise ArgumentError(
+            f"Invalid version type, expected float or str, found '{version_type}'."
+        )
+    new_version = 0.0
+    if 0 < version_value <= _VERSION_MAX_VALUE:
+        # a value too small to be stored is rounded to 0.0, ie. no version set,
+        # so it is rejected as well
+        new_version = normalize_version(version_value)
+    if new_version <= 0:
+        raise ArgumentError(
+            f"Invalid version value: {version!r}, expected a number greater than 0"
+            f" and not greater than {_VERSION_MAX_VALUE} (head.fontRevision is a"
+            " 16.16 fixed-point value), or a parsable version string,"
+            ' eg. 1.015 or "Version 1.015".'
+        )
+    old_version = get_version(ttfont)
+    # head.fontRevision (only if the font has the head table)
+    head = ttfont.get("head")
+    if head is not None:
+        head.fontRevision = new_version
+    # name records (only if the font has the name table)
+    if ttfont.get("name") is not None:
+        # version name record (name id 5)
+        _names.set_name(
+            ttfont,
+            _names.NAME_VERSION,
+            format_version(new_version, prefix="Version "),
+        )
+        # unique identifier name record (name id 3): it has no canonical form,
+        # it conventionally holds the version value in its first ";" separated
+        # part, eg. "1.015;ETCO;Tourney-Regular", so only that part is replaced,
+        # and only if it holds the current version value
+        unique_id = _names.get_name(ttfont, _names.NAME_UNIQUE_IDENTIFIER) or ""
+        unique_id_version, separator, unique_id_info = unique_id.partition(";")
+        if old_version > 0 and parse_version(unique_id_version) == old_version:
+            unique_id_version = format_version(new_version, prefix="")
+            _names.set_name(
+                ttfont,
+                _names.NAME_UNIQUE_IDENTIFIER,
+                f"{unique_id_version}{separator}{unique_id_info}",
+            )
+    # cff version (only otf fonts that already have it)
+    top_dict = _get_cff_top_dict(ttfont)
+    if top_dict is not None and "version" in top_dict.rawDict:
+        top_dict.version = _format_cff_version(new_version)