python-fontbro 0.30.0__tar.gz → 0.31.0__tar.gz

{python_fontbro-0.30.0/python_fontbro.egg-info → python_fontbro-0.31.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-fontbro
-Version: 0.30.0
+Version: 0.31.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>
@@ -149,6 +149,7 @@ with open("fonts/MyFont.ttf") as fh:
 -   [`is_static`](#is_static)
 -   [`is_variable`](#is_variable)
 -   [`rename`](#rename)
+-   [`rename_variable_instances`](#rename_variable_instances)
 -   [`sanitize`](#sanitize)
 -   [`save`](#save)
 -   [`save_as_woff`](#save_as_woff)
@@ -966,6 +967,8 @@ variable = font.is_variable()
 """
 Renames the font names records (1, 2, 4, 6, 16, 17) according to
 the given family_name and style_name (subfamily_name).
+The names records (18, 25), the fvar named instances PostScript names
+and the CFF table names are updated too, only if already defined.
 
 If family_name is not defined it will be auto-detected.
 If style_name is not defined it will be auto-detected.
@@ -985,6 +988,39 @@ font.rename(
 )
 ```
 
+#### `rename_variable_instances`
+```python
+"""
+Renames the named instances of the variable font.
+
+The family_name replaces the family part of the instances PostScript names
+(and of the variations PostScript name prefix, if defined).
+The style_names replace the instances style names and the style part
+of their PostScript names. The axes names are unchanged.
+The default instance style name must match the font style name,
+so renaming it renames the font style too.
+
+If family_name is not defined it will be auto-detected.
+
+:param family_name: The family name
+:type family_name: str
+:param style_names: The new style names mapped by the old ones (case-insensitive),
+    eg. {"Thin": "Hairline"}
+:type style_names: dict or None
+:param update_style_flags: if True the style flags will be updated by subfamily name
+    (only if the default instance style name is renamed)
+:type update_style_flags: bool
+
+:raises OperationError: if the font is not a variable font.
+"""
+
+font.rename_variable_instances(
+    family_name="My Font New",
+    style_names={"Thin": "Hairline"},
+    update_style_flags=True,
+)
+```
+
 #### `sanitize`
 ```python
 """
@@ -1360,6 +1396,12 @@ If an axis min and max values are equal, the axis will be pinned.
     {'wdth':100, 'wght':[100,600], 'ital':[30,65,70]} or
     {'wdth':100, 'wght':{'min':100,'max':600}, 'ital':{'min':30,'default':65,'max':70}}
 :type coordinates: dict
+:param update_names: if True the name records will be updated based on
+    the closest instance to the new default coordinates (only if changed)
+:type update_names: bool
+:param update_style_flags: if True the style flags will be updated based on
+    the closest instance to the new default coordinates (only if changed)
+:type update_style_flags: bool
 :param options: The options for the fontTools.varLib.instancer
 :type options: dictionary
 
@@ -1368,7 +1410,12 @@ If an axis min and max values are equal, the axis will be pinned.
 :raises ValueError: If the coordinates axes are all pinned
 """
 
-font.to_sliced_variable(coordinates, **options)
+font.to_sliced_variable(
+    coordinates,
+    update_names=True,
+    update_style_flags=True,
+    **options,
+)
 ```
 
 #### `to_static`

{python_fontbro-0.30.0 → python_fontbro-0.31.0}/README.md

@@ -85,6 +85,7 @@ with open("fonts/MyFont.ttf") as fh:
 -   [`is_static`](#is_static)
 -   [`is_variable`](#is_variable)
 -   [`rename`](#rename)
+-   [`rename_variable_instances`](#rename_variable_instances)
 -   [`sanitize`](#sanitize)
 -   [`save`](#save)
 -   [`save_as_woff`](#save_as_woff)
@@ -902,6 +903,8 @@ variable = font.is_variable()
 """
 Renames the font names records (1, 2, 4, 6, 16, 17) according to
 the given family_name and style_name (subfamily_name).
+The names records (18, 25), the fvar named instances PostScript names
+and the CFF table names are updated too, only if already defined.
 
 If family_name is not defined it will be auto-detected.
 If style_name is not defined it will be auto-detected.
@@ -921,6 +924,39 @@ font.rename(
 )
 ```
 
+#### `rename_variable_instances`
+```python
+"""
+Renames the named instances of the variable font.
+
+The family_name replaces the family part of the instances PostScript names
+(and of the variations PostScript name prefix, if defined).
+The style_names replace the instances style names and the style part
+of their PostScript names. The axes names are unchanged.
+The default instance style name must match the font style name,
+so renaming it renames the font style too.
+
+If family_name is not defined it will be auto-detected.
+
+:param family_name: The family name
+:type family_name: str
+:param style_names: The new style names mapped by the old ones (case-insensitive),
+    eg. {"Thin": "Hairline"}
+:type style_names: dict or None
+:param update_style_flags: if True the style flags will be updated by subfamily name
+    (only if the default instance style name is renamed)
+:type update_style_flags: bool
+
+:raises OperationError: if the font is not a variable font.
+"""
+
+font.rename_variable_instances(
+    family_name="My Font New",
+    style_names={"Thin": "Hairline"},
+    update_style_flags=True,
+)
+```
+
 #### `sanitize`
 ```python
 """
@@ -1296,6 +1332,12 @@ If an axis min and max values are equal, the axis will be pinned.
     {'wdth':100, 'wght':[100,600], 'ital':[30,65,70]} or
     {'wdth':100, 'wght':{'min':100,'max':600}, 'ital':{'min':30,'default':65,'max':70}}
 :type coordinates: dict
+:param update_names: if True the name records will be updated based on
+    the closest instance to the new default coordinates (only if changed)
+:type update_names: bool
+:param update_style_flags: if True the style flags will be updated based on
+    the closest instance to the new default coordinates (only if changed)
+:type update_style_flags: bool
 :param options: The options for the fontTools.varLib.instancer
 :type options: dictionary
 
@@ -1304,7 +1346,12 @@ If an axis min and max values are equal, the axis will be pinned.
 :raises ValueError: If the coordinates axes are all pinned
 """
 
-font.to_sliced_variable(coordinates, **options)
+font.to_sliced_variable(
+    coordinates,
+    update_names=True,
+    update_style_flags=True,
+    **options,
+)
 ```
 
 #### `to_static`

{python_fontbro-0.30.0 → python_fontbro-0.31.0}/fontbro/font.py

@@ -1227,6 +1227,8 @@ class Font:
         """
         Renames the font names records (1, 2, 4, 6, 16, 17) according to
         the given family_name and style_name (subfamily_name).
+        The names records (18, 25), the fvar named instances PostScript names
+        and the CFF table names are updated too, only if already defined.
 
         If family_name is not defined it will be auto-detected.
         If style_name is not defined it will be auto-detected.
@@ -1247,6 +1249,48 @@ class Font:
         if update_style_flags:
             self.set_style_flags_by_subfamily_name()
 
+    def rename_variable_instances(
+        self,
+        *,
+        family_name: str = "",
+        style_names: dict[str, str] | None = None,
+        update_style_flags: bool = True,
+    ) -> None:
+        """
+        Renames the named instances of the variable font.
+
+        The family_name replaces the family part of the instances PostScript names
+        (and of the variations PostScript name prefix, if defined).
+        The style_names replace the instances style names and the style part
+        of their PostScript names. The axes names are unchanged.
+        The default instance style name must match the font style name,
+        so renaming it renames the font style too.
+
+        If family_name is not defined it will be auto-detected.
+
+        :param family_name: The family name
+        :type family_name: str
+        :param style_names: The new style names mapped by the old ones (case-insensitive),
+            eg. {"Thin": "Hairline"}
+        :type style_names: dict or None
+        :param update_style_flags: if True the style flags will be updated by subfamily name
+            (only if the default instance style name is renamed)
+        :type update_style_flags: bool
+
+        :raises OperationError: if the font is not a variable font.
+        :return: None
+        """
+        ttfont = self.get_ttfont()
+        style_name = self.get_style_name()
+        _names.rename_variable_instances(
+            ttfont,
+            family_name=family_name,
+            style_names=style_names,
+        )
+
+        if update_style_flags and self.get_style_name() != style_name:
+            self.set_style_flags_by_subfamily_name()
+
     def sanitize(
         self,
         *,
@@ -1791,6 +1835,8 @@ class Font:
         self,
         *,
         coordinates: dict[str, Any],
+        update_names: bool = True,
+        update_style_flags: bool = True,
         **options: Any,
     ) -> None:
         """
@@ -1805,6 +1851,12 @@ class Font:
             {'wdth':100, 'wght':[100,600], 'ital':[30,65,70]} or
             {'wdth':100, 'wght':{'min':100,'max':600}, 'ital':{'min':30,'default':65,'max':70}}
         :type coordinates: dict
+        :param update_names: if True the name records will be updated based on
+            the closest instance to the new default coordinates (only if changed)
+        :type update_names: bool
+        :param update_style_flags: if True the style flags will be updated based on
+            the closest instance to the new default coordinates (only if changed)
+        :type update_style_flags: bool
         :param options: The options for the fontTools.varLib.instancer
         :type options: dictionary
 
@@ -1813,7 +1865,13 @@ class Font:
         :raises ValueError: If the coordinates axes are all pinned
         """
         ttfont = self.get_ttfont()
-        _variable.to_sliced_variable(ttfont, coordinates=coordinates, **options)
+        _variable.to_sliced_variable(
+            ttfont,
+            coordinates=coordinates,
+            update_names=update_names,
+            update_style_flags=update_style_flags,
+            **options,
+        )
 
     def to_static(
         self,

{python_fontbro-0.30.0 → python_fontbro-0.31.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.30.0"
+__version__ = "0.31.0"

{python_fontbro-0.30.0 → python_fontbro-0.31.0}/fontbro/names.py

@@ -6,7 +6,7 @@ from typing import Any
 from fontTools.misc.encodingTools import getEncoding
 from fontTools.ttLib import TTFont
 
-from fontbro.exceptions import ArgumentError
+from fontbro.exceptions import ArgumentError, OperationError
 from fontbro.utils import concat_names, remove_spaces
 
 # Names:
@@ -182,26 +182,41 @@ def set_name(
     ttfont: TTFont,
     key: int | str,
     value: str,
+    *,
+    windows: bool = True,
+    mac: bool = True,
+    unicode: bool = True,
 ) -> None:
     """
-    Sets the name by its identifier in the name table of the given font.
+    Sets the name by its identifier in the name table of the given font,
+    only in the records of the platforms enabled by the windows, mac
+    and unicode flags.
     """
     name_id = _get_name_id(key)
     name_table = ttfont["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)
+    if windows:
+        # 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)
     # 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):
+    platforms = [
+        platform_ids
+        for platform_ids, enabled in (
+            (_NAMES_WIN_IDS, windows),
+            (_NAMES_UNI_IDS, unicode),
+            (_NAMES_MAC_IDS, mac),
+        )
+        if enabled
+    ]
+    for platform_ids in platforms:
         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
+            # because the font would raise UnicodeEncodeError when saved
             if _is_encodable(value, record_ids):
                 name_table.setName(value, name_id, **record_ids)
             else:
@@ -249,6 +264,185 @@ def get_style_name(
     )
 
 
+def _get_postscript_name(
+    value: str,
+) -> str:
+    """
+    Gets a PostScript name from the given value,
+    replacing the characters not allowed with hyphens.
+    """
+    # keep only printable ASCII subset:
+    # https://learn.microsoft.com/en-us/typography/opentype/spec/name#name-ids
+    # postscript_name_allowed_chars = {chr(code) for code in range(33, 127)}
+    # !"#$&'*+,-.0123456789:;=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\^_`abcdefghijklmnopqrstuvwxyz|~
+    postscript_name_pattern = (
+        r"[^0-9A-Za-z\!\"\#\$\&\'\*\+\,\-\.\:\;\=\?\@\\\^\_\`\|\~]"
+    )
+    postscript_name = re.sub(postscript_name_pattern, "-", value)
+    postscript_name = re.sub(r"[\-]+", "-", postscript_name).strip("-")
+    return postscript_name
+
+
+def _get_default_instance_style_name(
+    ttfont: TTFont,
+) -> str:
+    """
+    Gets the style name of the fvar named instance at the default coordinates.
+    """
+    fvar = ttfont["fvar"]
+    coordinates = {axis.axisTag: axis.defaultValue for axis in fvar.axes}
+    for instance in fvar.instances:
+        if instance.coordinates == coordinates:
+            return get_name(ttfont, instance.subfamilyNameID) or ""
+    return ""
+
+
+def rename_variable_instances(
+    ttfont: TTFont,
+    *,
+    family_name: str = "",
+    style_names: dict[str, str] | None = None,
+) -> None:
+    """
+    Renames the named instances of the given variable font: the family_name
+    replaces the family part of the instances PostScript names (and of the
+    variations PostScript name prefix, 25), the style_names (old style name
+    to new style name) replace the instances style names and the style part
+    of their PostScript names. The axes names are unchanged.
+    The default instance style name must match the font style name,
+    so renaming it renames the font style too.
+    """
+    if "fvar" not in ttfont:
+        raise OperationError("Only the instances of a variable font can be renamed.")
+    # style names are matched case-insensitively
+    style_names = {key.lower(): value for key, value in (style_names or {}).items()}
+    default_style_name = _get_default_instance_style_name(ttfont).lower()
+    default_style_name_new = style_names.get(default_style_name, "")
+    if default_style_name_new:
+        rename(ttfont, style_name=default_style_name_new)
+    family_name = (family_name or "").strip() or get_family_name(ttfont)
+    _rename_variable_instances(ttfont, family_name, style_names)
+
+
+def _get_instance_postscript_name(
+    prefix: str,
+    style_name: str,
+) -> str:
+    """
+    Gets the PostScript name of a variable font named instance, the "Italic"
+    style suffix is omitted if the prefix already ends with it
+    (eg. "TourneyItalic-Thin" instead of "TourneyItalic-ThinItalic").
+    """
+    style_name = remove_spaces(style_name)
+    if prefix.lower().endswith("italic"):
+        style_name = re.sub(r"italic$", "", style_name, flags=re.IGNORECASE)
+        style_name = style_name or "Regular"
+    return _get_postscript_name(f"{prefix}-{style_name}")
+
+
+def _rename_variable_instances(
+    ttfont: TTFont,
+    family_name: str,
+    style_names: dict[str, str],
+) -> None:
+    """
+    Renames the named instances of the given variable font,
+    the style_names keys must be lowercase.
+    """
+    name_table = ttfont["name"]
+
+    # the old family name is read before updating it (rename calls this function
+    # before updating the name records), the old prefixes are computed from it
+    family_name_old = get_family_name(ttfont)
+    prefix_old = get_name(ttfont, NAME_VARIATIONS_POSTSCRIPT_NAME_PREFIX) or ""
+    if prefix_old:
+        # variations postscript name prefix: only ASCII letters and digits allowed,
+        # its suffix is kept (eg. "Roman", "Italic") to avoid the same instances
+        # postscript names in the roman and italic fonts
+        suffix = ""
+        family_name_old_prefix = re.sub(r"[^0-9A-Za-z]", "", family_name_old)
+        if family_name_old_prefix and prefix_old.startswith(family_name_old_prefix):
+            suffix = prefix_old[len(family_name_old_prefix) :]
+        elif "italic" in get_style_name(ttfont).lower() and not (
+            family_name.lower().endswith("italic")
+        ):
+            suffix = "Italic"
+        prefix = re.sub(r"[^0-9A-Za-z]", "", f"{family_name}{suffix}")
+        # the windows record is written only if the font already has it
+        name_id = _get_name_id(NAME_VARIATIONS_POSTSCRIPT_NAME_PREFIX)
+        windows = bool(name_table.getName(name_id, **_NAMES_WIN_IDS))
+        set_name(
+            ttfont, NAME_VARIATIONS_POSTSCRIPT_NAME_PREFIX, prefix, windows=windows
+        )
+    else:
+        prefix_old = _get_postscript_name(remove_spaces(family_name_old))
+        prefix = _get_postscript_name(remove_spaces(family_name))
+
+    # the style names are read before updating them,
+    # because the same name record can be shared by more instances
+    instances = ttfont["fvar"].instances
+    instances_style_names = [
+        get_name(ttfont, instance.subfamilyNameID) or "" for instance in instances
+    ]
+    for instance, style_name in zip(instances, instances_style_names, strict=True):
+        style_name_new = style_names.get(style_name.lower(), "")
+        if style_name_new and instance.subfamilyNameID < 256:
+            # name ids 2 and 17 are the font style names (updated by rename),
+            # so a new name record is added for the instance
+            instance.subfamilyNameID = name_table.addName(
+                style_name_new, platforms=((3, 1, 0x409),)
+            )
+        elif style_name_new:
+            # the existing name record is updated, also where it is shared
+            # (eg. the STAT table axis values), the windows record is written
+            # only if the font already has it
+            name_id = instance.subfamilyNameID
+            windows = bool(name_table.getName(name_id, **_NAMES_WIN_IDS))
+            set_name(ttfont, name_id, style_name_new, windows=windows)
+        name_id = instance.postscriptNameID
+        name = get_name(ttfont, name_id) if 255 < name_id < 0xFFFF else None
+        if not name:
+            continue
+        if not style_name_new and prefix_old and name.startswith(prefix_old):
+            # only the prefix is replaced, to keep the font naming convention
+            name = prefix + name[len(prefix_old) :]
+        else:
+            # the name is generated if the style is renamed,
+            # or if it doesn't start with the old prefix (inconsistent font)
+            name = _get_instance_postscript_name(prefix, style_name_new or style_name)
+        set_name(ttfont, name_id, name)
+
+
+def _rename_cff(
+    ttfont: TTFont,
+    postscript_name: str,
+    full_name: str,
+    family_name: str,
+    weight: str,
+) -> None:
+    """
+    Renames the CFF table names (otf fonts): the font name and the FDArray
+    font names (CID-keyed fonts) prefixed by it, FullName, FamilyName and
+    Weight (only if not empty) only if already defined.
+    """
+    if "CFF " not in ttfont:
+        return
+    cff = ttfont["CFF "].cff
+    postscript_name_old = cff.fontNames[0]
+    cff.fontNames[0] = postscript_name
+    top_dict = cff.topDictIndex[0]
+    for font_dict in getattr(top_dict, "FDArray", []):
+        font_name = getattr(font_dict, "FontName", None)
+        if font_name and font_name.startswith(postscript_name_old):
+            font_dict.FontName = postscript_name + font_name[len(postscript_name_old) :]
+    if getattr(top_dict, "FullName", None):
+        top_dict.FullName = full_name
+    if getattr(top_dict, "FamilyName", None):
+        top_dict.FamilyName = family_name
+    if weight and getattr(top_dict, "Weight", None):
+        top_dict.Weight = weight
+
+
 def rename(
     ttfont: TTFont,
     *,
@@ -259,6 +453,8 @@ def rename(
     Renames the names records (1, 2, 3, 4, 6, 16, 17, 21, 22) of the given font
     according to the given family_name and style_name (subfamily_name),
     if not defined they will be auto-detected.
+    The records 18 and 25, the fvar instances PostScript names and the CFF
+    names are updated only if already defined.
     """
     family_name = (family_name or "").strip() or get_family_name(ttfont)
     style_name = (style_name or "").strip() or get_style_name(ttfont)
@@ -289,15 +485,7 @@ def rename(
         remove_spaces(typographic_subfamily_name),
     )
 
-    # keep only printable ASCII subset:
-    # https://learn.microsoft.com/en-us/typography/opentype/spec/name#name-ids
-    # postscript_name_allowed_chars = {chr(code) for code in range(33, 127)}
-    # !"#$&'*+,-.0123456789:;=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\^_`abcdefghijklmnopqrstuvwxyz|~
-    postscript_name_pattern = (
-        r"[^0-9A-Za-z\!\"\#\$\&\'\*\+\,\-\.\:\;\=\?\@\\\^\_\`\|\~]"
-    )
-    postscript_name = re.sub(postscript_name_pattern, "-", postscript_name)
-    postscript_name = re.sub(r"[\-]+", "-", postscript_name).strip("-")
+    postscript_name = _get_postscript_name(postscript_name)
     postscript_name_length = len(postscript_name)
     if postscript_name_length > 63:
         raise ArgumentError(
@@ -325,4 +513,52 @@ def rename(
         NAME_WWS_FAMILY_NAME: wws_family_name,
         NAME_WWS_SUBFAMILY_NAME: wws_subfamily_name,
     }
+
+    # compatible full name: if it's not the full name (eg. a designer-defined
+    # short menu name), only the family name in it is replaced
+    compatible_full_name = get_name(ttfont, NAME_COMPATIBLE_FULL) or ""
+    if compatible_full_name:
+        family_name_old = get_family_name(ttfont)
+        full_name_old = concat_names(family_name_old, get_style_name(ttfont))
+        if (
+            compatible_full_name == full_name_old
+            or not family_name_old
+            or family_name_old not in compatible_full_name
+        ):
+            compatible_full_name = full_name
+        else:
+            compatible_full_name = compatible_full_name.replace(
+                family_name_old, typographic_family_name, 1
+            )
+
+    # cff weight (eg. "Bold" for "Bold Italic"), updated only if the style changes
+    style_name_old = get_style_name(ttfont)
+    weight = ""
+    if style_name_old != typographic_subfamily_name:
+        weight = re.sub(
+            r"\s*italic$", "", typographic_subfamily_name, flags=re.IGNORECASE
+        )
+        weight = weight or "Regular"
+
+    # fvar instances (and name id 25) need the old postscript name
+    if "fvar" in ttfont:
+        # the default instance style name must match the font style name, it's
+        # renamed only if it matches the old one (otherwise a family rename of
+        # an inconsistent font would rename it, and the STAT values sharing it)
+        style_names = {}
+        if (
+            style_name_old != typographic_subfamily_name
+            and _get_default_instance_style_name(ttfont) == style_name_old
+        ):
+            style_names[style_name_old.lower()] = typographic_subfamily_name
+        _rename_variable_instances(ttfont, typographic_family_name, style_names)
+
     set_names(ttfont, names)
+    # name id 18 (macintosh only) is updated only if already defined,
+    # the windows record is written only if the font already has it
+    if compatible_full_name:
+        name_id = _get_name_id(NAME_COMPATIBLE_FULL)
+        windows = bool(ttfont["name"].getName(name_id, **_NAMES_WIN_IDS))
+        set_name(ttfont, NAME_COMPATIBLE_FULL, compatible_full_name, windows=windows)
+
+    _rename_cff(ttfont, postscript_name, full_name, typographic_family_name, weight)

{python_fontbro-0.30.0 → python_fontbro-0.31.0}/fontbro/variable.py

@@ -301,10 +301,18 @@ def _remove_stat_table(
     return False
 
 
+def _get_default_coordinates(
+    ttfont: TTFont,
+) -> dict[str, float]:
+    return {axis.axisTag: axis.defaultValue for axis in ttfont["fvar"].axes}
+
+
 def to_sliced_variable(
     ttfont: TTFont,
     *,
     coordinates: dict[str, Any],
+    update_names: bool = True,
+    update_style_flags: bool = True,
     **options: Any,
 ) -> None:
     """
@@ -322,8 +330,25 @@ def to_sliced_variable(
     options.setdefault("updateFontNames", False)
 
     # instantiate the sliced variable font
+    default_coordinates = _get_default_coordinates(ttfont)
     instancer.instantiateVariableFont(ttfont, coordinates, inplace=True, **options)
 
+    # update name records and style flags if the default instance changed
+    # (unless they have been updated by fontTools using the STAT table)
+    default_coordinates_new = _get_default_coordinates(ttfont)
+    if (
+        update_names
+        and default_coordinates_new != default_coordinates
+        and not options["updateFontNames"]
+    ):
+        instance = get_variable_instance_closest_to_coordinates(
+            ttfont, default_coordinates_new
+        )
+        if instance:
+            _names.rename(ttfont, style_name=instance["style_name"])
+            if update_style_flags:
+                _style_flags.set_style_flags_by_subfamily_name(ttfont)
+
 
 def to_static(
     ttfont: TTFont,
@@ -363,6 +388,13 @@ def to_static(
     # not useful in static fonts and after instancing it may contain incorrect values
     _remove_stat_table(ttfont)
 
+    # remove variations postscript name prefix (25), used only by variable fonts
+    # (as fontTools does when instancing with updateFontNames=True)
+    # and the names used only by the removed fvar and STAT tables
+    if "name" in ttfont:
+        ttfont["name"].removeNames(nameID=25)
+        ttfont["name"].removeUnusedNames(ttfont)
+
     # update name records and style flags based on instance style name
     if instance and update_names:
         _names.rename(ttfont, style_name=instance["style_name"])