diff --git "a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/designspaceLib/__init__.py" "b/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/designspaceLib/__init__.py" deleted file mode 100644--- "a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/designspaceLib/__init__.py" +++ /dev/null @@ -1,3283 +0,0 @@ -from __future__ import annotations - -import collections -import copy -import itertools -import math -import os -import posixpath -from io import BytesIO, StringIO -from textwrap import indent -from typing import Any, Dict, List, MutableMapping, Optional, Tuple, Union, cast - -from fontTools.misc import etree as ET -from fontTools.misc import plistlib -from fontTools.misc.loggingTools import LogMixin -from fontTools.misc.textTools import tobytes, tostr - -""" - designSpaceDocument - - - read and write designspace files -""" - -__all__ = [ - "AxisDescriptor", - "AxisLabelDescriptor", - "AxisMappingDescriptor", - "BaseDocReader", - "BaseDocWriter", - "DesignSpaceDocument", - "DesignSpaceDocumentError", - "DiscreteAxisDescriptor", - "InstanceDescriptor", - "LocationLabelDescriptor", - "RangeAxisSubsetDescriptor", - "RuleDescriptor", - "SourceDescriptor", - "ValueAxisSubsetDescriptor", - "VariableFontDescriptor", -] - -# ElementTree allows to find namespace-prefixed elements, but not attributes -# so we have to do it ourselves for 'xml:lang' -XML_NS = "{http://www.w3.org/XML/1998/namespace}" -XML_LANG = XML_NS + "lang" - - -def posix(path): - """Normalize paths using forward slash to work also on Windows.""" - new_path = posixpath.join(*path.split(os.path.sep)) - if path.startswith("/"): - # The above transformation loses absolute paths - new_path = "/" + new_path - elif path.startswith(r"\\"): - # The above transformation loses leading slashes of UNC path mounts - new_path = "//" + new_path - return new_path - - -def posixpath_property(private_name): - """Generate a propery that holds a path always using forward slashes.""" - - def getter(self): - # Normal getter - return getattr(self, private_name) - - def setter(self, value): - # The setter rewrites paths using forward slashes - if value is not None: - value = posix(value) - setattr(self, private_name, value) - - return property(getter, setter) - - -class DesignSpaceDocumentError(Exception): - def __init__(self, msg, obj=None): - self.msg = msg - self.obj = obj - - def __str__(self): - return str(self.msg) + (": %r" % self.obj if self.obj is not None else "") - - -class AsDictMixin(object): - def asdict(self): - d = {} - for attr, value in self.__dict__.items(): - if attr.startswith("_"): - continue - if hasattr(value, "asdict"): - value = value.asdict() - elif isinstance(value, list): - value = [v.asdict() if hasattr(v, "asdict") else v for v in value] - d[attr] = value - return d - - -class SimpleDescriptor(AsDictMixin): - """Containers for a bunch of attributes""" - - # XXX this is ugly. The 'print' is inappropriate here, and instead of - # assert, it should simply return True/False - def compare(self, other): - # test if this object contains the same data as the other - for attr in self._attrs: - try: - assert getattr(self, attr) == getattr(other, attr) - except AssertionError: - print( - "failed attribute", - attr, - getattr(self, attr), - "!=", - getattr(other, attr), - ) - - def __repr__(self): - attrs = [f"{a}={repr(getattr(self, a))}," for a in self._attrs] - attrs = indent("\n".join(attrs), " ") - return f"{self.__class__.__name__}(\n{attrs}\n)" - - -class SourceDescriptor(SimpleDescriptor): - """Simple container for data related to the source - - .. code:: python - - doc = DesignSpaceDocument() - s1 = SourceDescriptor() - s1.path = masterPath1 - s1.name = "master.ufo1" - s1.font = defcon.Font("master.ufo1") - s1.location = dict(weight=0) - s1.familyName = "MasterFamilyName" - s1.styleName = "MasterStyleNameOne" - s1.localisedFamilyName = dict(fr="Caractère") - s1.mutedGlyphNames.append("A") - s1.mutedGlyphNames.append("Z") - doc.addSource(s1) - - """ - - flavor = "source" - _attrs = [ - "filename", - "path", - "name", - "layerName", - "location", - "copyLib", - "copyGroups", - "copyFeatures", - "muteKerning", - "muteInfo", - "mutedGlyphNames", - "familyName", - "styleName", - "localisedFamilyName", - ] - - filename = posixpath_property("_filename") - path = posixpath_property("_path") - - def __init__( - self, - *, - filename=None, - path=None, - font=None, - name=None, - location=None, - designLocation=None, - layerName=None, - familyName=None, - styleName=None, - localisedFamilyName=None, - copyLib=False, - copyInfo=False, - copyGroups=False, - copyFeatures=False, - muteKerning=False, - muteInfo=False, - mutedGlyphNames=None, - ): - self.filename = filename - """string. A relative path to the source file, **as it is in the document**. - - MutatorMath + VarLib. - """ - self.path = path - """The absolute path, calculated from filename.""" - - self.font = font - """Any Python object. Optional. Points to a representation of this - source font that is loaded in memory, as a Python object (e.g. a - ``defcon.Font`` or a ``fontTools.ttFont.TTFont``). - - The default document reader will not fill-in this attribute, and the - default writer will not use this attribute. It is up to the user of - ``designspaceLib`` to either load the resource identified by - ``filename`` and store it in this field, or write the contents of - this field to the disk and make ```filename`` point to that. - """ - - self.name = name - """string. Optional. Unique identifier name for this source. - - MutatorMath + varLib. - """ - - self.designLocation = ( - designLocation if designLocation is not None else location or {} - ) - """dict. Axis values for this source, in design space coordinates. - - MutatorMath + varLib. - - This may be only part of the full design location. - See :meth:`getFullDesignLocation()` - - .. versionadded:: 5.0 - """ - - self.layerName = layerName - """string. The name of the layer in the source to look for - outline data. Default ``None`` which means ``foreground``. - """ - self.familyName = familyName - """string. Family name of this source. Though this data - can be extracted from the font, it can be efficient to have it right - here. - - varLib. - """ - self.styleName = styleName - """string. Style name of this source. Though this data - can be extracted from the font, it can be efficient to have it right - here. - - varLib. - """ - self.localisedFamilyName = localisedFamilyName or {} - """dict. A dictionary of localised family name strings, keyed by - language code. - - If present, will be used to build localized names for all instances. - - .. versionadded:: 5.0 - """ - - self.copyLib = copyLib - """bool. Indicates if the contents of the font.lib need to - be copied to the instances. - - MutatorMath. - - .. deprecated:: 5.0 - """ - self.copyInfo = copyInfo - """bool. Indicates if the non-interpolating font.info needs - to be copied to the instances. - - MutatorMath. - - .. deprecated:: 5.0 - """ - self.copyGroups = copyGroups - """bool. Indicates if the groups need to be copied to the - instances. - - MutatorMath. - - .. deprecated:: 5.0 - """ - self.copyFeatures = copyFeatures - """bool. Indicates if the feature text needs to be - copied to the instances. - - MutatorMath. - - .. deprecated:: 5.0 - """ - self.muteKerning = muteKerning - """bool. Indicates if the kerning data from this source - needs to be muted (i.e. not be part of the calculations). - - MutatorMath only. - """ - self.muteInfo = muteInfo - """bool. Indicated if the interpolating font.info data for - this source needs to be muted. - - MutatorMath only. - """ - self.mutedGlyphNames = mutedGlyphNames or [] - """list. Glyphnames that need to be muted in the - instances. - - MutatorMath only. - """ - - @property - def location(self): - """dict. Axis values for this source, in design space coordinates. - - MutatorMath + varLib. - - .. deprecated:: 5.0 - Use the more explicit alias for this property :attr:`designLocation`. - """ - return self.designLocation - - @location.setter - def location(self, location: Optional[AnisotropicLocationDict]): - self.designLocation = location or {} - - def setFamilyName(self, familyName, languageCode="en"): - """Setter for :attr:`localisedFamilyName` - - .. versionadded:: 5.0 - """ - self.localisedFamilyName[languageCode] = tostr(familyName) - - def getFamilyName(self, languageCode="en"): - """Getter for :attr:`localisedFamilyName` - - .. versionadded:: 5.0 - """ - return self.localisedFamilyName.get(languageCode) - - def getFullDesignLocation( - self, doc: "DesignSpaceDocument" - ) -> AnisotropicLocationDict: - """Get the complete design location of this source, from its - :attr:`designLocation` and the document's axis defaults. - - .. versionadded:: 5.0 - """ - result: AnisotropicLocationDict = {} - for axis in doc.axes: - if axis.name in self.designLocation: - result[axis.name] = self.designLocation[axis.name] - else: - result[axis.name] = axis.map_forward(axis.default) - return result - - -class RuleDescriptor(SimpleDescriptor): - """Represents the rule descriptor element: a set of glyph substitutions to - trigger conditionally in some parts of the designspace. - - .. code:: python - - r1 = RuleDescriptor() - r1.name = "unique.rule.name" - r1.conditionSets.append([dict(name="weight", minimum=-10, maximum=10), dict(...)]) - r1.conditionSets.append([dict(...), dict(...)]) - r1.subs.append(("a", "a.alt")) - - .. code:: xml - - - - - - - - - - - - - - """ - - _attrs = ["name", "conditionSets", "subs"] # what do we need here - - def __init__(self, *, name=None, conditionSets=None, subs=None): - self.name = name - """string. Unique name for this rule. Can be used to reference this rule data.""" - # list of lists of dict(name='aaaa', minimum=0, maximum=1000) - self.conditionSets = conditionSets or [] - """a list of conditionsets. - - - Each conditionset is a list of conditions. - - Each condition is a dict with ``name``, ``minimum`` and ``maximum`` keys. - """ - # list of substitutions stored as tuples of glyphnames ("a", "a.alt") - self.subs = subs or [] - """list of substitutions. - - - Each substitution is stored as tuples of glyphnames, e.g. ("a", "a.alt"). - - Note: By default, rules are applied first, before other text - shaping/OpenType layout, as they are part of the - `Required Variation Alternates OpenType feature `_. - See ref:`rules-element` § Attributes. - """ - - -def evaluateRule(rule, location): - """Return True if any of the rule's conditionsets matches the given location.""" - return any(evaluateConditions(c, location) for c in rule.conditionSets) - - -def evaluateConditions(conditions, location): - """Return True if all the conditions matches the given location. - - - If a condition has no minimum, check for < maximum. - - If a condition has no maximum, check for > minimum. - """ - for cd in conditions: - value = location[cd["name"]] - if cd.get("minimum") is None: - if value > cd["maximum"]: - return False - elif cd.get("maximum") is None: - if cd["minimum"] > value: - return False - elif not cd["minimum"] <= value <= cd["maximum"]: - return False - return True - - -def processRules(rules, location, glyphNames): - """Apply these rules at this location to these glyphnames. - - Return a new list of glyphNames with substitutions applied. - - - rule order matters - """ - newNames = [] - for rule in rules: - if evaluateRule(rule, location): - for name in glyphNames: - swap = False - for a, b in rule.subs: - if name == a: - swap = True - break - if swap: - newNames.append(b) - else: - newNames.append(name) - glyphNames = newNames - newNames = [] - return glyphNames - - -AnisotropicLocationDict = Dict[str, Union[float, Tuple[float, float]]] -SimpleLocationDict = Dict[str, float] - - -class AxisMappingDescriptor(SimpleDescriptor): - """Represents the axis mapping element: mapping an input location - to an output location in the designspace. - - .. code:: python - - m1 = AxisMappingDescriptor() - m1.inputLocation = {"weight": 900, "width": 150} - m1.outputLocation = {"weight": 870} - - .. code:: xml - - - - - - - - - - - - - """ - - _attrs = ["inputLocation", "outputLocation"] - - def __init__(self, *, inputLocation=None, outputLocation=None): - self.inputLocation: SimpleLocationDict = inputLocation or {} - """dict. Axis values for the input of the mapping, in design space coordinates. - - varLib. - - .. versionadded:: 5.1 - """ - self.outputLocation: SimpleLocationDict = outputLocation or {} - """dict. Axis values for the output of the mapping, in design space coordinates. - - varLib. - - .. versionadded:: 5.1 - """ - - -class InstanceDescriptor(SimpleDescriptor): - """Simple container for data related to the instance - - - .. code:: python - - i2 = InstanceDescriptor() - i2.path = instancePath2 - i2.familyName = "InstanceFamilyName" - i2.styleName = "InstanceStyleName" - i2.name = "instance.ufo2" - # anisotropic location - i2.designLocation = dict(weight=500, width=(400,300)) - i2.postScriptFontName = "InstancePostscriptName" - i2.styleMapFamilyName = "InstanceStyleMapFamilyName" - i2.styleMapStyleName = "InstanceStyleMapStyleName" - i2.lib['com.coolDesignspaceApp.specimenText'] = 'Hamburgerwhatever' - doc.addInstance(i2) - """ - - flavor = "instance" - _defaultLanguageCode = "en" - _attrs = [ - "filename", - "path", - "name", - "locationLabel", - "designLocation", - "userLocation", - "familyName", - "styleName", - "postScriptFontName", - "styleMapFamilyName", - "styleMapStyleName", - "localisedFamilyName", - "localisedStyleName", - "localisedStyleMapFamilyName", - "localisedStyleMapStyleName", - "glyphs", - "kerning", - "info", - "lib", - ] - - filename = posixpath_property("_filename") - path = posixpath_property("_path") - - def __init__( - self, - *, - filename=None, - path=None, - font=None, - name=None, - location=None, - locationLabel=None, - designLocation=None, - userLocation=None, - familyName=None, - styleName=None, - postScriptFontName=None, - styleMapFamilyName=None, - styleMapStyleName=None, - localisedFamilyName=None, - localisedStyleName=None, - localisedStyleMapFamilyName=None, - localisedStyleMapStyleName=None, - glyphs=None, - kerning=True, - info=True, - lib=None, - ): - self.filename = filename - """string. Relative path to the instance file, **as it is - in the document**. The file may or may not exist. - - MutatorMath + VarLib. - """ - self.path = path - """string. Absolute path to the instance file, calculated from - the document path and the string in the filename attr. The file may - or may not exist. - - MutatorMath. - """ - self.font = font - """Same as :attr:`SourceDescriptor.font` - - .. seealso:: :attr:`SourceDescriptor.font` - """ - self.name = name - """string. Unique identifier name of the instance, used to - identify it if it needs to be referenced from elsewhere in the - document. - """ - self.locationLabel = locationLabel - """Name of a :class:`LocationLabelDescriptor`. If - provided, the instance should have the same location as the - LocationLabel. - - .. seealso:: - :meth:`getFullDesignLocation` - :meth:`getFullUserLocation` - - .. versionadded:: 5.0 - """ - self.designLocation: AnisotropicLocationDict = ( - designLocation if designLocation is not None else (location or {}) - ) - """dict. Axis values for this instance, in design space coordinates. - - MutatorMath + varLib. - - .. seealso:: This may be only part of the full location. See: - :meth:`getFullDesignLocation` - :meth:`getFullUserLocation` - - .. versionadded:: 5.0 - """ - self.userLocation: SimpleLocationDict = userLocation or {} - """dict. Axis values for this instance, in user space coordinates. - - MutatorMath + varLib. - - .. seealso:: This may be only part of the full location. See: - :meth:`getFullDesignLocation` - :meth:`getFullUserLocation` - - .. versionadded:: 5.0 - """ - self.familyName = familyName - """string. Family name of this instance. - - MutatorMath + varLib. - """ - self.styleName = styleName - """string. Style name of this instance. - - MutatorMath + varLib. - """ - self.postScriptFontName = postScriptFontName - """string. Postscript fontname for this instance. - - MutatorMath + varLib. - """ - self.styleMapFamilyName = styleMapFamilyName - """string. StyleMap familyname for this instance. - - MutatorMath + varLib. - """ - self.styleMapStyleName = styleMapStyleName - """string. StyleMap stylename for this instance. - - MutatorMath + varLib. - """ - self.localisedFamilyName = localisedFamilyName or {} - """dict. A dictionary of localised family name - strings, keyed by language code. - """ - self.localisedStyleName = localisedStyleName or {} - """dict. A dictionary of localised stylename - strings, keyed by language code. - """ - self.localisedStyleMapFamilyName = localisedStyleMapFamilyName or {} - """A dictionary of localised style map - familyname strings, keyed by language code. - """ - self.localisedStyleMapStyleName = localisedStyleMapStyleName or {} - """A dictionary of localised style map - stylename strings, keyed by language code. - """ - self.glyphs = glyphs or {} - """dict for special master definitions for glyphs. If glyphs - need special masters (to record the results of executed rules for - example). - - MutatorMath. - - .. deprecated:: 5.0 - Use rules or sparse sources instead. - """ - self.kerning = kerning - """ bool. Indicates if this instance needs its kerning - calculated. - - MutatorMath. - - .. deprecated:: 5.0 - """ - self.info = info - """bool. Indicated if this instance needs the interpolating - font.info calculated. - - .. deprecated:: 5.0 - """ - - self.lib = lib or {} - """Custom data associated with this instance.""" - - @property - def location(self): - """dict. Axis values for this instance. - - MutatorMath + varLib. - - .. deprecated:: 5.0 - Use the more explicit alias for this property :attr:`designLocation`. - """ - return self.designLocation - - @location.setter - def location(self, location: Optional[AnisotropicLocationDict]): - self.designLocation = location or {} - - def setStyleName(self, styleName, languageCode="en"): - """These methods give easier access to the localised names.""" - self.localisedStyleName[languageCode] = tostr(styleName) - - def getStyleName(self, languageCode="en"): - return self.localisedStyleName.get(languageCode) - - def setFamilyName(self, familyName, languageCode="en"): - self.localisedFamilyName[languageCode] = tostr(familyName) - - def getFamilyName(self, languageCode="en"): - return self.localisedFamilyName.get(languageCode) - - def setStyleMapStyleName(self, styleMapStyleName, languageCode="en"): - self.localisedStyleMapStyleName[languageCode] = tostr(styleMapStyleName) - - def getStyleMapStyleName(self, languageCode="en"): - return self.localisedStyleMapStyleName.get(languageCode) - - def setStyleMapFamilyName(self, styleMapFamilyName, languageCode="en"): - self.localisedStyleMapFamilyName[languageCode] = tostr(styleMapFamilyName) - - def getStyleMapFamilyName(self, languageCode="en"): - return self.localisedStyleMapFamilyName.get(languageCode) - - def clearLocation(self, axisName: Optional[str] = None): - """Clear all location-related fields. Ensures that - :attr:``designLocation`` and :attr:``userLocation`` are dictionaries - (possibly empty if clearing everything). - - In order to update the location of this instance wholesale, a user - should first clear all the fields, then change the field(s) for which - they have data. - - .. code:: python - - instance.clearLocation() - instance.designLocation = {'Weight': (34, 36.5), 'Width': 100} - instance.userLocation = {'Opsz': 16} - - In order to update a single axis location, the user should only clear - that axis, then edit the values: - - .. code:: python - - instance.clearLocation('Weight') - instance.designLocation['Weight'] = (34, 36.5) - - Args: - axisName: if provided, only clear the location for that axis. - - .. versionadded:: 5.0 - """ - self.locationLabel = None - if axisName is None: - self.designLocation = {} - self.userLocation = {} - else: - if self.designLocation is None: - self.designLocation = {} - if axisName in self.designLocation: - del self.designLocation[axisName] - if self.userLocation is None: - self.userLocation = {} - if axisName in self.userLocation: - del self.userLocation[axisName] - - def getLocationLabelDescriptor( - self, doc: "DesignSpaceDocument" - ) -> Optional[LocationLabelDescriptor]: - """Get the :class:`LocationLabelDescriptor` instance that matches - this instances's :attr:`locationLabel`. - - Raises if the named label can't be found. - - .. versionadded:: 5.0 - """ - if self.locationLabel is None: - return None - label = doc.getLocationLabel(self.locationLabel) - if label is None: - raise DesignSpaceDocumentError( - "InstanceDescriptor.getLocationLabelDescriptor(): " - f"unknown location label `{self.locationLabel}` in instance `{self.name}`." - ) - return label - - def getFullDesignLocation( - self, doc: "DesignSpaceDocument" - ) -> AnisotropicLocationDict: - """Get the complete design location of this instance, by combining data - from the various location fields, default axis values and mappings, and - top-level location labels. - - The source of truth for this instance's location is determined for each - axis independently by taking the first not-None field in this list: - - - ``locationLabel``: the location along this axis is the same as the - matching STAT format 4 label. No anisotropy. - - ``designLocation[axisName]``: the explicit design location along this - axis, possibly anisotropic. - - ``userLocation[axisName]``: the explicit user location along this - axis. No anisotropy. - - ``axis.default``: default axis value. No anisotropy. - - .. versionadded:: 5.0 - """ - label = self.getLocationLabelDescriptor(doc) - if label is not None: - return doc.map_forward(label.userLocation) # type: ignore - result: AnisotropicLocationDict = {} - for axis in doc.axes: - if axis.name in self.designLocation: - result[axis.name] = self.designLocation[axis.name] - elif axis.name in self.userLocation: - result[axis.name] = axis.map_forward(self.userLocation[axis.name]) - else: - result[axis.name] = axis.map_forward(axis.default) - return result - - def getFullUserLocation(self, doc: "DesignSpaceDocument") -> SimpleLocationDict: - """Get the complete user location for this instance. - - .. seealso:: :meth:`getFullDesignLocation` - - .. versionadded:: 5.0 - """ - return doc.map_backward(self.getFullDesignLocation(doc)) - - -def tagForAxisName(name): - # try to find or make a tag name for this axis name - names = { - "weight": ("wght", dict(en="Weight")), - "width": ("wdth", dict(en="Width")), - "optical": ("opsz", dict(en="Optical Size")), - "slant": ("slnt", dict(en="Slant")), - "italic": ("ital", dict(en="Italic")), - } - if name.lower() in names: - return names[name.lower()] - if len(name) < 4: - tag = name + "*" * (4 - len(name)) - else: - tag = name[:4] - return tag, dict(en=name) - - -class AbstractAxisDescriptor(SimpleDescriptor): - flavor = "axis" - - def __init__( - self, - *, - tag=None, - name=None, - labelNames=None, - hidden=False, - map=None, - axisOrdering=None, - axisLabels=None, - ): - # opentype tag for this axis - self.tag = tag - """string. Four letter tag for this axis. Some might be - registered at the `OpenType - specification `__. - Privately-defined axis tags must begin with an uppercase letter and - use only uppercase letters or digits. - """ - # name of the axis used in locations - self.name = name - """string. Name of the axis as it is used in the location dicts. - - MutatorMath + varLib. - """ - # names for UI purposes, if this is not a standard axis, - self.labelNames = labelNames or {} - """dict. When defining a non-registered axis, it will be - necessary to define user-facing readable names for the axis. Keyed by - xml:lang code. Values are required to be ``unicode`` strings, even if - they only contain ASCII characters. - """ - self.hidden = hidden - """bool. Whether this axis should be hidden in user interfaces. - """ - self.map = map or [] - """list of input / output values that can describe a warp of user space - to design space coordinates. If no map values are present, it is assumed - user space is the same as design space, as in [(minimum, minimum), - (maximum, maximum)]. - - varLib. - """ - self.axisOrdering = axisOrdering - """STAT table field ``axisOrdering``. - - See: `OTSpec STAT Axis Record `_ - - .. versionadded:: 5.0 - """ - self.axisLabels: List[AxisLabelDescriptor] = axisLabels or [] - """STAT table entries for Axis Value Tables format 1, 2, 3. - - See: `OTSpec STAT Axis Value Tables `_ - - .. versionadded:: 5.0 - """ - - -class AxisDescriptor(AbstractAxisDescriptor): - """Simple container for the axis data. - - Add more localisations? - - .. code:: python - - a1 = AxisDescriptor() - a1.minimum = 1 - a1.maximum = 1000 - a1.default = 400 - a1.name = "weight" - a1.tag = "wght" - a1.labelNames['fa-IR'] = "قطر" - a1.labelNames['en'] = "Wéíght" - a1.map = [(1.0, 10.0), (400.0, 66.0), (1000.0, 990.0)] - a1.axisOrdering = 1 - a1.axisLabels = [ - AxisLabelDescriptor(name="Regular", userValue=400, elidable=True) - ] - doc.addAxis(a1) - """ - - _attrs = [ - "tag", - "name", - "maximum", - "minimum", - "default", - "map", - "axisOrdering", - "axisLabels", - ] - - def __init__( - self, - *, - tag=None, - name=None, - labelNames=None, - minimum=None, - default=None, - maximum=None, - hidden=False, - map=None, - axisOrdering=None, - axisLabels=None, - ): - super().__init__( - tag=tag, - name=name, - labelNames=labelNames, - hidden=hidden, - map=map, - axisOrdering=axisOrdering, - axisLabels=axisLabels, - ) - self.minimum = minimum - """number. The minimum value for this axis in user space. - - MutatorMath + varLib. - """ - self.maximum = maximum - """number. The maximum value for this axis in user space. - - MutatorMath + varLib. - """ - self.default = default - """number. The default value for this axis, i.e. when a new location is - created, this is the value this axis will get in user space. - - MutatorMath + varLib. - """ - - def serialize(self): - # output to a dict, used in testing - return dict( - tag=self.tag, - name=self.name, - labelNames=self.labelNames, - maximum=self.maximum, - minimum=self.minimum, - default=self.default, - hidden=self.hidden, - map=self.map, - axisOrdering=self.axisOrdering, - axisLabels=self.axisLabels, - ) - - def map_forward(self, v): - """Maps value from axis mapping's input (user) to output (design).""" - from fontTools.varLib.models import piecewiseLinearMap - - if not self.map: - return v - return piecewiseLinearMap(v, {k: v for k, v in self.map}) - - def map_backward(self, v): - """Maps value from axis mapping's output (design) to input (user).""" - from fontTools.varLib.models import piecewiseLinearMap - - if isinstance(v, tuple): - v = v[0] - if not self.map: - return v - return piecewiseLinearMap(v, {v: k for k, v in self.map}) - - -class DiscreteAxisDescriptor(AbstractAxisDescriptor): - """Container for discrete axis data. - - Use this for axes that do not interpolate. The main difference from a - continuous axis is that a continuous axis has a ``minimum`` and ``maximum``, - while a discrete axis has a list of ``values``. - - Example: an Italic axis with 2 stops, Roman and Italic, that are not - compatible. The axis still allows to bind together the full font family, - which is useful for the STAT table, however it can't become a variation - axis in a VF. - - .. code:: python - - a2 = DiscreteAxisDescriptor() - a2.values = [0, 1] - a2.default = 0 - a2.name = "Italic" - a2.tag = "ITAL" - a2.labelNames['fr'] = "Italique" - a2.map = [(0, 0), (1, -11)] - a2.axisOrdering = 2 - a2.axisLabels = [ - AxisLabelDescriptor(name="Roman", userValue=0, elidable=True) - ] - doc.addAxis(a2) - - .. versionadded:: 5.0 - """ - - flavor = "axis" - _attrs = ("tag", "name", "values", "default", "map", "axisOrdering", "axisLabels") - - def __init__( - self, - *, - tag=None, - name=None, - labelNames=None, - values=None, - default=None, - hidden=False, - map=None, - axisOrdering=None, - axisLabels=None, - ): - super().__init__( - tag=tag, - name=name, - labelNames=labelNames, - hidden=hidden, - map=map, - axisOrdering=axisOrdering, - axisLabels=axisLabels, - ) - self.default: float = default - """The default value for this axis, i.e. when a new location is - created, this is the value this axis will get in user space. - - However, this default value is less important than in continuous axes: - - - it doesn't define the "neutral" version of outlines from which - deltas would apply, as this axis does not interpolate. - - it doesn't provide the reference glyph set for the designspace, as - fonts at each value can have different glyph sets. - """ - self.values: List[float] = values or [] - """List of possible values for this axis. Contrary to continuous axes, - only the values in this list can be taken by the axis, nothing in-between. - """ - - def map_forward(self, value): - """Maps value from axis mapping's input to output. - - Returns value unchanged if no mapping entry is found. - - Note: for discrete axes, each value must have its mapping entry, if - you intend that value to be mapped. - """ - return next((v for k, v in self.map if k == value), value) - - def map_backward(self, value): - """Maps value from axis mapping's output to input. - - Returns value unchanged if no mapping entry is found. - - Note: for discrete axes, each value must have its mapping entry, if - you intend that value to be mapped. - """ - if isinstance(value, tuple): - value = value[0] - return next((k for k, v in self.map if v == value), value) - - -class AxisLabelDescriptor(SimpleDescriptor): - """Container for axis label data. - - Analogue of OpenType's STAT data for a single axis (formats 1, 2 and 3). - All values are user values. - See: `OTSpec STAT Axis value table, format 1, 2, 3 `_ - - The STAT format of the Axis value depends on which field are filled-in, - see :meth:`getFormat` - - .. versionadded:: 5.0 - """ - - flavor = "label" - _attrs = ( - "userMinimum", - "userValue", - "userMaximum", - "name", - "elidable", - "olderSibling", - "linkedUserValue", - "labelNames", - ) - - def __init__( - self, - *, - name, - userValue, - userMinimum=None, - userMaximum=None, - elidable=False, - olderSibling=False, - linkedUserValue=None, - labelNames=None, - ): - self.userMinimum: Optional[float] = userMinimum - """STAT field ``rangeMinValue`` (format 2).""" - self.userValue: float = userValue - """STAT field ``value`` (format 1, 3) or ``nominalValue`` (format 2).""" - self.userMaximum: Optional[float] = userMaximum - """STAT field ``rangeMaxValue`` (format 2).""" - self.name: str = name - """Label for this axis location, STAT field ``valueNameID``.""" - self.elidable: bool = elidable - """STAT flag ``ELIDABLE_AXIS_VALUE_NAME``. - - See: `OTSpec STAT Flags `_ - """ - self.olderSibling: bool = olderSibling - """STAT flag ``OLDER_SIBLING_FONT_ATTRIBUTE``. - - See: `OTSpec STAT Flags `_ - """ - self.linkedUserValue: Optional[float] = linkedUserValue - """STAT field ``linkedValue`` (format 3).""" - self.labelNames: MutableMapping[str, str] = labelNames or {} - """User-facing translations of this location's label. Keyed by - ``xml:lang`` code. - """ - - def getFormat(self) -> int: - """Determine which format of STAT Axis value to use to encode this label. - - =========== ========= =========== =========== =============== - STAT Format userValue userMinimum userMaximum linkedUserValue - =========== ========= =========== =========== =============== - 1 ✅ ❌ ❌ ❌ - 2 ✅ ✅ ✅ ❌ - 3 ✅ ❌ ❌ ✅ - =========== ========= =========== =========== =============== - """ - if self.linkedUserValue is not None: - return 3 - if self.userMinimum is not None or self.userMaximum is not None: - return 2 - return 1 - - @property - def defaultName(self) -> str: - """Return the English name from :attr:`labelNames` or the :attr:`name`.""" - return self.labelNames.get("en") or self.name - - -class LocationLabelDescriptor(SimpleDescriptor): - """Container for location label data. - - Analogue of OpenType's STAT data for a free-floating location (format 4). - All values are user values. - - See: `OTSpec STAT Axis value table, format 4 `_ - - .. versionadded:: 5.0 - """ - - flavor = "label" - _attrs = ("name", "elidable", "olderSibling", "userLocation", "labelNames") - - def __init__( - self, - *, - name, - userLocation, - elidable=False, - olderSibling=False, - labelNames=None, - ): - self.name: str = name - """Label for this named location, STAT field ``valueNameID``.""" - self.userLocation: SimpleLocationDict = userLocation or {} - """Location in user coordinates along each axis. - - If an axis is not mentioned, it is assumed to be at its default location. - - .. seealso:: This may be only part of the full location. See: - :meth:`getFullUserLocation` - """ - self.elidable: bool = elidable - """STAT flag ``ELIDABLE_AXIS_VALUE_NAME``. - - See: `OTSpec STAT Flags `_ - """ - self.olderSibling: bool = olderSibling - """STAT flag ``OLDER_SIBLING_FONT_ATTRIBUTE``. - - See: `OTSpec STAT Flags `_ - """ - self.labelNames: Dict[str, str] = labelNames or {} - """User-facing translations of this location's label. Keyed by - xml:lang code. - """ - - @property - def defaultName(self) -> str: - """Return the English name from :attr:`labelNames` or the :attr:`name`.""" - return self.labelNames.get("en") or self.name - - def getFullUserLocation(self, doc: "DesignSpaceDocument") -> SimpleLocationDict: - """Get the complete user location of this label, by combining data - from the explicit user location and default axis values. - - .. versionadded:: 5.0 - """ - return { - axis.name: self.userLocation.get(axis.name, axis.default) - for axis in doc.axes - } - - -class VariableFontDescriptor(SimpleDescriptor): - """Container for variable fonts, sub-spaces of the Designspace. - - Use-cases: - - - From a single DesignSpace with discrete axes, define 1 variable font - per value on the discrete axes. Before version 5, you would have needed - 1 DesignSpace per such variable font, and a lot of data duplication. - - From a big variable font with many axes, define subsets of that variable - font that only include some axes and freeze other axes at a given location. - - .. versionadded:: 5.0 - """ - - flavor = "variable-font" - _attrs = ("filename", "axisSubsets", "lib") - - filename = posixpath_property("_filename") - - def __init__(self, *, name, filename=None, axisSubsets=None, lib=None): - self.name: str = name - """string, required. Name of this variable to identify it during the - build process and from other parts of the document, and also as a - filename in case the filename property is empty. - - VarLib. - """ - self.filename: str = filename - """string, optional. Relative path to the variable font file, **as it is - in the document**. The file may or may not exist. - - If not specified, the :attr:`name` will be used as a basename for the file. - """ - self.axisSubsets: List[ - Union[RangeAxisSubsetDescriptor, ValueAxisSubsetDescriptor] - ] = (axisSubsets or []) - """Axis subsets to include in this variable font. - - If an axis is not mentioned, assume that we only want the default - location of that axis (same as a :class:`ValueAxisSubsetDescriptor`). - """ - self.lib: MutableMapping[str, Any] = lib or {} - """Custom data associated with this variable font.""" - - -class RangeAxisSubsetDescriptor(SimpleDescriptor): - """Subset of a continuous axis to include in a variable font. - - .. versionadded:: 5.0 - """ - - flavor = "axis-subset" - _attrs = ("name", "userMinimum", "userDefault", "userMaximum") - - def __init__( - self, *, name, userMinimum=-math.inf, userDefault=None, userMaximum=math.inf - ): - self.name: str = name - """Name of the :class:`AxisDescriptor` to subset.""" - self.userMinimum: float = userMinimum - """New minimum value of the axis in the target variable font. - If not specified, assume the same minimum value as the full axis. - (default = ``-math.inf``) - """ - self.userDefault: Optional[float] = userDefault - """New default value of the axis in the target variable font. - If not specified, assume the same default value as the full axis. - (default = ``None``) - """ - self.userMaximum: float = userMaximum - """New maximum value of the axis in the target variable font. - If not specified, assume the same maximum value as the full axis. - (default = ``math.inf``) - """ - - -class ValueAxisSubsetDescriptor(SimpleDescriptor): - """Single value of a discrete or continuous axis to use in a variable font. - - .. versionadded:: 5.0 - """ - - flavor = "axis-subset" - _attrs = ("name", "userValue") - - def __init__(self, *, name, userValue): - self.name: str = name - """Name of the :class:`AxisDescriptor` or :class:`DiscreteAxisDescriptor` - to "snapshot" or "freeze". - """ - self.userValue: float = userValue - """Value in user coordinates at which to freeze the given axis.""" - - -class BaseDocWriter(object): - _whiteSpace = " " - axisDescriptorClass = AxisDescriptor - discreteAxisDescriptorClass = DiscreteAxisDescriptor - axisLabelDescriptorClass = AxisLabelDescriptor - axisMappingDescriptorClass = AxisMappingDescriptor - locationLabelDescriptorClass = LocationLabelDescriptor - ruleDescriptorClass = RuleDescriptor - sourceDescriptorClass = SourceDescriptor - variableFontDescriptorClass = VariableFontDescriptor - valueAxisSubsetDescriptorClass = ValueAxisSubsetDescriptor - rangeAxisSubsetDescriptorClass = RangeAxisSubsetDescriptor - instanceDescriptorClass = InstanceDescriptor - - @classmethod - def getAxisDecriptor(cls): - return cls.axisDescriptorClass() - - @classmethod - def getAxisMappingDescriptor(cls): - return cls.axisMappingDescriptorClass() - - @classmethod - def getSourceDescriptor(cls): - return cls.sourceDescriptorClass() - - @classmethod - def getInstanceDescriptor(cls): - return cls.instanceDescriptorClass() - - @classmethod - def getRuleDescriptor(cls): - return cls.ruleDescriptorClass() - - def __init__(self, documentPath, documentObject: DesignSpaceDocument): - self.path = documentPath - self.documentObject = documentObject - self.effectiveFormatTuple = self._getEffectiveFormatTuple() - self.root = ET.Element("designspace") - - def write(self, pretty=True, encoding="UTF-8", xml_declaration=True): - self.root.attrib["format"] = ".".join(str(i) for i in self.effectiveFormatTuple) - - if ( - self.documentObject.axes - or self.documentObject.axisMappings - or self.documentObject.elidedFallbackName is not None - ): - axesElement = ET.Element("axes") - if self.documentObject.elidedFallbackName is not None: - axesElement.attrib[ - "elidedfallbackname" - ] = self.documentObject.elidedFallbackName - self.root.append(axesElement) - for axisObject in self.documentObject.axes: - self._addAxis(axisObject) - - if self.documentObject.axisMappings: - mappingsElement = ET.Element("mappings") - self.root.findall(".axes")[0].append(mappingsElement) - for mappingObject in self.documentObject.axisMappings: - self._addAxisMapping(mappingsElement, mappingObject) - - if self.documentObject.locationLabels: - labelsElement = ET.Element("labels") - for labelObject in self.documentObject.locationLabels: - self._addLocationLabel(labelsElement, labelObject) - self.root.append(labelsElement) - - if self.documentObject.rules: - if getattr(self.documentObject, "rulesProcessingLast", False): - attributes = {"processing": "last"} - else: - attributes = {} - self.root.append(ET.Element("rules", attributes)) - for ruleObject in self.documentObject.rules: - self._addRule(ruleObject) - - if self.documentObject.sources: - self.root.append(ET.Element("sources")) - for sourceObject in self.documentObject.sources: - self._addSource(sourceObject) - - if self.documentObject.variableFonts: - variableFontsElement = ET.Element("variable-fonts") - for variableFont in self.documentObject.variableFonts: - self._addVariableFont(variableFontsElement, variableFont) - self.root.append(variableFontsElement) - - if self.documentObject.instances: - self.root.append(ET.Element("instances")) - for instanceObject in self.documentObject.instances: - self._addInstance(instanceObject) - - if self.documentObject.lib: - self._addLib(self.root, self.documentObject.lib, 2) - - tree = ET.ElementTree(self.root) - tree.write( - self.path, - encoding=encoding, - method="xml", - xml_declaration=xml_declaration, - pretty_print=pretty, - ) - - def _getEffectiveFormatTuple(self): - """Try to use the version specified in the document, or a sufficiently - recent version to be able to encode what the document contains. - """ - minVersion = self.documentObject.formatTuple - if ( - any( - hasattr(axis, "values") - or axis.axisOrdering is not None - or axis.axisLabels - for axis in self.documentObject.axes - ) - or self.documentObject.locationLabels - or any(source.localisedFamilyName for source in self.documentObject.sources) - or self.documentObject.variableFonts - or any( - instance.locationLabel or instance.userLocation - for instance in self.documentObject.instances - ) - ): - if minVersion < (5, 0): - minVersion = (5, 0) - if self.documentObject.axisMappings: - if minVersion < (5, 1): - minVersion = (5, 1) - return minVersion - - def _makeLocationElement(self, locationObject, name=None): - """Convert Location dict to a locationElement.""" - locElement = ET.Element("location") - if name is not None: - locElement.attrib["name"] = name - validatedLocation = self.documentObject.newDefaultLocation() - for axisName, axisValue in locationObject.items(): - if axisName in validatedLocation: - # only accept values we know - validatedLocation[axisName] = axisValue - for dimensionName, dimensionValue in validatedLocation.items(): - dimElement = ET.Element("dimension") - dimElement.attrib["name"] = dimensionName - if type(dimensionValue) == tuple: - dimElement.attrib["xvalue"] = self.intOrFloat(dimensionValue[0]) - dimElement.attrib["yvalue"] = self.intOrFloat(dimensionValue[1]) - else: - dimElement.attrib["xvalue"] = self.intOrFloat(dimensionValue) - locElement.append(dimElement) - return locElement, validatedLocation - - def intOrFloat(self, num): - if int(num) == num: - return "%d" % num - return ("%f" % num).rstrip("0").rstrip(".") - - def _addRule(self, ruleObject): - # if none of the conditions have minimum or maximum values, do not add the rule. - ruleElement = ET.Element("rule") - if ruleObject.name is not None: - ruleElement.attrib["name"] = ruleObject.name - for conditions in ruleObject.conditionSets: - conditionsetElement = ET.Element("conditionset") - for cond in conditions: - if cond.get("minimum") is None and cond.get("maximum") is None: - # neither is defined, don't add this condition - continue - conditionElement = ET.Element("condition") - conditionElement.attrib["name"] = cond.get("name") - if cond.get("minimum") is not None: - conditionElement.attrib["minimum"] = self.intOrFloat( - cond.get("minimum") - ) - if cond.get("maximum") is not None: - conditionElement.attrib["maximum"] = self.intOrFloat( - cond.get("maximum") - ) - conditionsetElement.append(conditionElement) - if len(conditionsetElement): - ruleElement.append(conditionsetElement) - for sub in ruleObject.subs: - subElement = ET.Element("sub") - subElement.attrib["name"] = sub[0] - subElement.attrib["with"] = sub[1] - ruleElement.append(subElement) - if len(ruleElement): - self.root.findall(".rules")[0].append(ruleElement) - - def _addAxis(self, axisObject): - axisElement = ET.Element("axis") - axisElement.attrib["tag"] = axisObject.tag - axisElement.attrib["name"] = axisObject.name - self._addLabelNames(axisElement, axisObject.labelNames) - if axisObject.map: - for inputValue, outputValue in axisObject.map: - mapElement = ET.Element("map") - mapElement.attrib["input"] = self.intOrFloat(inputValue) - mapElement.attrib["output"] = self.intOrFloat(outputValue) - axisElement.append(mapElement) - if axisObject.axisOrdering or axisObject.axisLabels: - labelsElement = ET.Element("labels") - if axisObject.axisOrdering is not None: - labelsElement.attrib["ordering"] = str(axisObject.axisOrdering) - for label in axisObject.axisLabels: - self._addAxisLabel(labelsElement, label) - axisElement.append(labelsElement) - if hasattr(axisObject, "minimum"): - axisElement.attrib["minimum"] = self.intOrFloat(axisObject.minimum) - axisElement.attrib["maximum"] = self.intOrFloat(axisObject.maximum) - elif hasattr(axisObject, "values"): - axisElement.attrib["values"] = " ".join( - self.intOrFloat(v) for v in axisObject.values - ) - axisElement.attrib["default"] = self.intOrFloat(axisObject.default) - if axisObject.hidden: - axisElement.attrib["hidden"] = "1" - self.root.findall(".axes")[0].append(axisElement) - - def _addAxisMapping(self, mappingsElement, mappingObject): - mappingElement = ET.Element("mapping") - for what in ("inputLocation", "outputLocation"): - whatObject = getattr(mappingObject, what, None) - if whatObject is None: - continue - whatElement = ET.Element(what[:-8]) - mappingElement.append(whatElement) - - for name, value in whatObject.items(): - dimensionElement = ET.Element("dimension") - dimensionElement.attrib["name"] = name - dimensionElement.attrib["xvalue"] = self.intOrFloat(value) - whatElement.append(dimensionElement) - - mappingsElement.append(mappingElement) - - def _addAxisLabel( - self, axisElement: ET.Element, label: AxisLabelDescriptor - ) -> None: - labelElement = ET.Element("label") - labelElement.attrib["uservalue"] = self.intOrFloat(label.userValue) - if label.userMinimum is not None: - labelElement.attrib["userminimum"] = self.intOrFloat(label.userMinimum) - if label.userMaximum is not None: - labelElement.attrib["usermaximum"] = self.intOrFloat(label.userMaximum) - labelElement.attrib["name"] = label.name - if label.elidable: - labelElement.attrib["elidable"] = "true" - if label.olderSibling: - labelElement.attrib["oldersibling"] = "true" - if label.linkedUserValue is not None: - labelElement.attrib["linkeduservalue"] = self.intOrFloat( - label.linkedUserValue - ) - self._addLabelNames(labelElement, label.labelNames) - axisElement.append(labelElement) - - def _addLabelNames(self, parentElement, labelNames): - for languageCode, labelName in sorted(labelNames.items()): - languageElement = ET.Element("labelname") - languageElement.attrib[XML_LANG] = languageCode - languageElement.text = labelName - parentElement.append(languageElement) - - def _addLocationLabel( - self, parentElement: ET.Element, label: LocationLabelDescriptor - ) -> None: - labelElement = ET.Element("label") - labelElement.attrib["name"] = label.name - if label.elidable: - labelElement.attrib["elidable"] = "true" - if label.olderSibling: - labelElement.attrib["oldersibling"] = "true" - self._addLabelNames(labelElement, label.labelNames) - self._addLocationElement(labelElement, userLocation=label.userLocation) - parentElement.append(labelElement) - - def _addLocationElement( - self, - parentElement, - *, - designLocation: AnisotropicLocationDict = None, - userLocation: SimpleLocationDict = None, - ): - locElement = ET.Element("location") - for axis in self.documentObject.axes: - if designLocation is not None and axis.name in designLocation: - dimElement = ET.Element("dimension") - dimElement.attrib["name"] = axis.name - value = designLocation[axis.name] - if isinstance(value, tuple): - dimElement.attrib["xvalue"] = self.intOrFloat(value[0]) - dimElement.attrib["yvalue"] = self.intOrFloat(value[1]) - else: - dimElement.attrib["xvalue"] = self.intOrFloat(value) - locElement.append(dimElement) - elif userLocation is not None and axis.name in userLocation: - dimElement = ET.Element("dimension") - dimElement.attrib["name"] = axis.name - value = userLocation[axis.name] - dimElement.attrib["uservalue"] = self.intOrFloat(value) - locElement.append(dimElement) - if len(locElement) > 0: - parentElement.append(locElement) - - def _addInstance(self, instanceObject): - instanceElement = ET.Element("instance") - if instanceObject.name is not None: - instanceElement.attrib["name"] = instanceObject.name - if instanceObject.locationLabel is not None: - instanceElement.attrib["location"] = instanceObject.locationLabel - if instanceObject.familyName is not None: - instanceElement.attrib["familyname"] = instanceObject.familyName - if instanceObject.styleName is not None: - instanceElement.attrib["stylename"] = instanceObject.styleName - # add localisations - if instanceObject.localisedStyleName: - languageCodes = list(instanceObject.localisedStyleName.keys()) - languageCodes.sort() - for code in languageCodes: - if code == "en": - continue # already stored in the element attribute - localisedStyleNameElement = ET.Element("stylename") - localisedStyleNameElement.attrib[XML_LANG] = code - localisedStyleNameElement.text = instanceObject.getStyleName(code) - instanceElement.append(localisedStyleNameElement) - if instanceObject.localisedFamilyName: - languageCodes = list(instanceObject.localisedFamilyName.keys()) - languageCodes.sort() - for code in languageCodes: - if code == "en": - continue # already stored in the element attribute - localisedFamilyNameElement = ET.Element("familyname") - localisedFamilyNameElement.attrib[XML_LANG] = code - localisedFamilyNameElement.text = instanceObject.getFamilyName(code) - instanceElement.append(localisedFamilyNameElement) - if instanceObject.localisedStyleMapStyleName: - languageCodes = list(instanceObject.localisedStyleMapStyleName.keys()) - languageCodes.sort() - for code in languageCodes: - if code == "en": - continue - localisedStyleMapStyleNameElement = ET.Element("stylemapstylename") - localisedStyleMapStyleNameElement.attrib[XML_LANG] = code - localisedStyleMapStyleNameElement.text = ( - instanceObject.getStyleMapStyleName(code) - ) - instanceElement.append(localisedStyleMapStyleNameElement) - if instanceObject.localisedStyleMapFamilyName: - languageCodes = list(instanceObject.localisedStyleMapFamilyName.keys()) - languageCodes.sort() - for code in languageCodes: - if code == "en": - continue - localisedStyleMapFamilyNameElement = ET.Element("stylemapfamilyname") - localisedStyleMapFamilyNameElement.attrib[XML_LANG] = code - localisedStyleMapFamilyNameElement.text = ( - instanceObject.getStyleMapFamilyName(code) - ) - instanceElement.append(localisedStyleMapFamilyNameElement) - - if self.effectiveFormatTuple >= (5, 0): - if instanceObject.locationLabel is None: - self._addLocationElement( - instanceElement, - designLocation=instanceObject.designLocation, - userLocation=instanceObject.userLocation, - ) - else: - # Pre-version 5.0 code was validating and filling in the location - # dict while writing it out, as preserved below. - if instanceObject.location is not None: - locationElement, instanceObject.location = self._makeLocationElement( - instanceObject.location - ) - instanceElement.append(locationElement) - if instanceObject.filename is not None: - instanceElement.attrib["filename"] = instanceObject.filename - if instanceObject.postScriptFontName is not None: - instanceElement.attrib[ - "postscriptfontname" - ] = instanceObject.postScriptFontName - if instanceObject.styleMapFamilyName is not None: - instanceElement.attrib[ - "stylemapfamilyname" - ] = instanceObject.styleMapFamilyName - if instanceObject.styleMapStyleName is not None: - instanceElement.attrib[ - "stylemapstylename" - ] = instanceObject.styleMapStyleName - if self.effectiveFormatTuple < (5, 0): - # Deprecated members as of version 5.0 - if instanceObject.glyphs: - if instanceElement.findall(".glyphs") == []: - glyphsElement = ET.Element("glyphs") - instanceElement.append(glyphsElement) - glyphsElement = instanceElement.findall(".glyphs")[0] - for glyphName, data in sorted(instanceObject.glyphs.items()): - glyphElement = self._writeGlyphElement( - instanceElement, instanceObject, glyphName, data - ) - glyphsElement.append(glyphElement) - if instanceObject.kerning: - kerningElement = ET.Element("kerning") - instanceElement.append(kerningElement) - if instanceObject.info: - infoElement = ET.Element("info") - instanceElement.append(infoElement) - self._addLib(instanceElement, instanceObject.lib, 4) - self.root.findall(".instances")[0].append(instanceElement) - - def _addSource(self, sourceObject): - sourceElement = ET.Element("source") - if sourceObject.filename is not None: - sourceElement.attrib["filename"] = sourceObject.filename - if sourceObject.name is not None: - if sourceObject.name.find("temp_master") != 0: - # do not save temporary source names - sourceElement.attrib["name"] = sourceObject.name - if sourceObject.familyName is not None: - sourceElement.attrib["familyname"] = sourceObject.familyName - if sourceObject.styleName is not None: - sourceElement.attrib["stylename"] = sourceObject.styleName - if sourceObject.layerName is not None: - sourceElement.attrib["layer"] = sourceObject.layerName - if sourceObject.localisedFamilyName: - languageCodes = list(sourceObject.localisedFamilyName.keys()) - languageCodes.sort() - for code in languageCodes: - if code == "en": - continue # already stored in the element attribute - localisedFamilyNameElement = ET.Element("familyname") - localisedFamilyNameElement.attrib[XML_LANG] = code - localisedFamilyNameElement.text = sourceObject.getFamilyName(code) - sourceElement.append(localisedFamilyNameElement) - if sourceObject.copyLib: - libElement = ET.Element("lib") - libElement.attrib["copy"] = "1" - sourceElement.append(libElement) - if sourceObject.copyGroups: - groupsElement = ET.Element("groups") - groupsElement.attrib["copy"] = "1" - sourceElement.append(groupsElement) - if sourceObject.copyFeatures: - featuresElement = ET.Element("features") - featuresElement.attrib["copy"] = "1" - sourceElement.append(featuresElement) - if sourceObject.copyInfo or sourceObject.muteInfo: - infoElement = ET.Element("info") - if sourceObject.copyInfo: - infoElement.attrib["copy"] = "1" - if sourceObject.muteInfo: - infoElement.attrib["mute"] = "1" - sourceElement.append(infoElement) - if sourceObject.muteKerning: - kerningElement = ET.Element("kerning") - kerningElement.attrib["mute"] = "1" - sourceElement.append(kerningElement) - if sourceObject.mutedGlyphNames: - for name in sourceObject.mutedGlyphNames: - glyphElement = ET.Element("glyph") - glyphElement.attrib["name"] = name - glyphElement.attrib["mute"] = "1" - sourceElement.append(glyphElement) - if self.effectiveFormatTuple >= (5, 0): - self._addLocationElement( - sourceElement, designLocation=sourceObject.location - ) - else: - # Pre-version 5.0 code was validating and filling in the location - # dict while writing it out, as preserved below. - locationElement, sourceObject.location = self._makeLocationElement( - sourceObject.location - ) - sourceElement.append(locationElement) - self.root.findall(".sources")[0].append(sourceElement) - - def _addVariableFont( - self, parentElement: ET.Element, vf: VariableFontDescriptor - ) -> None: - vfElement = ET.Element("variable-font") - vfElement.attrib["name"] = vf.name - if vf.filename is not None: - vfElement.attrib["filename"] = vf.filename - if vf.axisSubsets: - subsetsElement = ET.Element("axis-subsets") - for subset in vf.axisSubsets: - subsetElement = ET.Element("axis-subset") - subsetElement.attrib["name"] = subset.name - # Mypy doesn't support narrowing union types via hasattr() - # https://mypy.readthedocs.io/en/stable/type_narrowing.html - # TODO(Python 3.10): use TypeGuard - if hasattr(subset, "userMinimum"): - subset = cast(RangeAxisSubsetDescriptor, subset) - if subset.userMinimum != -math.inf: - subsetElement.attrib["userminimum"] = self.intOrFloat( - subset.userMinimum - ) - if subset.userMaximum != math.inf: - subsetElement.attrib["usermaximum"] = self.intOrFloat( - subset.userMaximum - ) - if subset.userDefault is not None: - subsetElement.attrib["userdefault"] = self.intOrFloat( - subset.userDefault - ) - elif hasattr(subset, "userValue"): - subset = cast(ValueAxisSubsetDescriptor, subset) - subsetElement.attrib["uservalue"] = self.intOrFloat( - subset.userValue - ) - subsetsElement.append(subsetElement) - vfElement.append(subsetsElement) - self._addLib(vfElement, vf.lib, 4) - parentElement.append(vfElement) - - def _addLib(self, parentElement: ET.Element, data: Any, indent_level: int) -> None: - if not data: - return - libElement = ET.Element("lib") - libElement.append(plistlib.totree(data, indent_level=indent_level)) - parentElement.append(libElement) - - def _writeGlyphElement(self, instanceElement, instanceObject, glyphName, data): - glyphElement = ET.Element("glyph") - if data.get("mute"): - glyphElement.attrib["mute"] = "1" - if data.get("unicodes") is not None: - glyphElement.attrib["unicode"] = " ".join( - [hex(u) for u in data.get("unicodes")] - ) - if data.get("instanceLocation") is not None: - locationElement, data["instanceLocation"] = self._makeLocationElement( - data.get("instanceLocation") - ) - glyphElement.append(locationElement) - if glyphName is not None: - glyphElement.attrib["name"] = glyphName - if data.get("note") is not None: - noteElement = ET.Element("note") - noteElement.text = data.get("note") - glyphElement.append(noteElement) - if data.get("masters") is not None: - mastersElement = ET.Element("masters") - for m in data.get("masters"): - masterElement = ET.Element("master") - if m.get("glyphName") is not None: - masterElement.attrib["glyphname"] = m.get("glyphName") - if m.get("font") is not None: - masterElement.attrib["source"] = m.get("font") - if m.get("location") is not None: - locationElement, m["location"] = self._makeLocationElement( - m.get("location") - ) - masterElement.append(locationElement) - mastersElement.append(masterElement) - glyphElement.append(mastersElement) - return glyphElement - - -class BaseDocReader(LogMixin): - axisDescriptorClass = AxisDescriptor - discreteAxisDescriptorClass = DiscreteAxisDescriptor - axisLabelDescriptorClass = AxisLabelDescriptor - axisMappingDescriptorClass = AxisMappingDescriptor - locationLabelDescriptorClass = LocationLabelDescriptor - ruleDescriptorClass = RuleDescriptor - sourceDescriptorClass = SourceDescriptor - variableFontsDescriptorClass = VariableFontDescriptor - valueAxisSubsetDescriptorClass = ValueAxisSubsetDescriptor - rangeAxisSubsetDescriptorClass = RangeAxisSubsetDescriptor - instanceDescriptorClass = InstanceDescriptor - - def __init__(self, documentPath, documentObject): - self.path = documentPath - self.documentObject = documentObject - tree = ET.parse(self.path) - self.root = tree.getroot() - self.documentObject.formatVersion = self.root.attrib.get("format", "3.0") - self._axes = [] - self.rules = [] - self.sources = [] - self.instances = [] - self.axisDefaults = {} - self._strictAxisNames = True - - @classmethod - def fromstring(cls, string, documentObject): - f = BytesIO(tobytes(string, encoding="utf-8")) - self = cls(f, documentObject) - self.path = None - return self - - def read(self): - self.readAxes() - self.readLabels() - self.readRules() - self.readVariableFonts() - self.readSources() - self.readInstances() - self.readLib() - - def readRules(self): - # we also need to read any conditions that are outside of a condition set. - rules = [] - rulesElement = self.root.find(".rules") - if rulesElement is not None: - processingValue = rulesElement.attrib.get("processing", "first") - if processingValue not in {"first", "last"}: - raise DesignSpaceDocumentError( - " processing attribute value is not valid: %r, " - "expected 'first' or 'last'" % processingValue - ) - self.documentObject.rulesProcessingLast = processingValue == "last" - for ruleElement in self.root.findall(".rules/rule"): - ruleObject = self.ruleDescriptorClass() - ruleName = ruleObject.name = ruleElement.attrib.get("name") - # read any stray conditions outside a condition set - externalConditions = self._readConditionElements( - ruleElement, - ruleName, - ) - if externalConditions: - ruleObject.conditionSets.append(externalConditions) - self.log.info( - "Found stray rule conditions outside a conditionset. " - "Wrapped them in a new conditionset." - ) - # read the conditionsets - for conditionSetElement in ruleElement.findall(".conditionset"): - conditionSet = self._readConditionElements( - conditionSetElement, - ruleName, - ) - if conditionSet is not None: - ruleObject.conditionSets.append(conditionSet) - for subElement in ruleElement.findall(".sub"): - a = subElement.attrib["name"] - b = subElement.attrib["with"] - ruleObject.subs.append((a, b)) - rules.append(ruleObject) - self.documentObject.rules = rules - - def _readConditionElements(self, parentElement, ruleName=None): - cds = [] - for conditionElement in parentElement.findall(".condition"): - cd = {} - cdMin = conditionElement.attrib.get("minimum") - if cdMin is not None: - cd["minimum"] = float(cdMin) - else: - # will allow these to be None, assume axis.minimum - cd["minimum"] = None - cdMax = conditionElement.attrib.get("maximum") - if cdMax is not None: - cd["maximum"] = float(cdMax) - else: - # will allow these to be None, assume axis.maximum - cd["maximum"] = None - cd["name"] = conditionElement.attrib.get("name") - # # test for things - if cd.get("minimum") is None and cd.get("maximum") is None: - raise DesignSpaceDocumentError( - "condition missing required minimum or maximum in rule" - + (" '%s'" % ruleName if ruleName is not None else "") - ) - cds.append(cd) - return cds - - def readAxes(self): - # read the axes elements, including the warp map. - axesElement = self.root.find(".axes") - if axesElement is not None and "elidedfallbackname" in axesElement.attrib: - self.documentObject.elidedFallbackName = axesElement.attrib[ - "elidedfallbackname" - ] - axisElements = self.root.findall(".axes/axis") - if not axisElements: - return - for axisElement in axisElements: - if ( - self.documentObject.formatTuple >= (5, 0) - and "values" in axisElement.attrib - ): - axisObject = self.discreteAxisDescriptorClass() - axisObject.values = [ - float(s) for s in axisElement.attrib["values"].split(" ") - ] - else: - axisObject = self.axisDescriptorClass() - axisObject.minimum = float(axisElement.attrib.get("minimum")) - axisObject.maximum = float(axisElement.attrib.get("maximum")) - axisObject.default = float(axisElement.attrib.get("default")) - axisObject.name = axisElement.attrib.get("name") - if axisElement.attrib.get("hidden", False): - axisObject.hidden = True - axisObject.tag = axisElement.attrib.get("tag") - for mapElement in axisElement.findall("map"): - a = float(mapElement.attrib["input"]) - b = float(mapElement.attrib["output"]) - axisObject.map.append((a, b)) - for labelNameElement in axisElement.findall("labelname"): - # Note: elementtree reads the "xml:lang" attribute name as - # '{http://www.w3.org/XML/1998/namespace}lang' - for key, lang in labelNameElement.items(): - if key == XML_LANG: - axisObject.labelNames[lang] = tostr(labelNameElement.text) - labelElement = axisElement.find(".labels") - if labelElement is not None: - if "ordering" in labelElement.attrib: - axisObject.axisOrdering = int(labelElement.attrib["ordering"]) - for label in labelElement.findall(".label"): - axisObject.axisLabels.append(self.readAxisLabel(label)) - self.documentObject.axes.append(axisObject) - self.axisDefaults[axisObject.name] = axisObject.default - - mappingsElement = self.root.find(".axes/mappings") - self.documentObject.axisMappings = [] - if mappingsElement is not None: - for mappingElement in mappingsElement.findall("mapping"): - inputElement = mappingElement.find("input") - outputElement = mappingElement.find("output") - inputLoc = {} - outputLoc = {} - for dimElement in inputElement.findall(".dimension"): - name = dimElement.attrib["name"] - value = float(dimElement.attrib["xvalue"]) - inputLoc[name] = value - for dimElement in outputElement.findall(".dimension"): - name = dimElement.attrib["name"] - value = float(dimElement.attrib["xvalue"]) - outputLoc[name] = value - axisMappingObject = self.axisMappingDescriptorClass( - inputLocation=inputLoc, outputLocation=outputLoc - ) - self.documentObject.axisMappings.append(axisMappingObject) - - def readAxisLabel(self, element: ET.Element): - xml_attrs = { - "userminimum", - "uservalue", - "usermaximum", - "name", - "elidable", - "oldersibling", - "linkeduservalue", - } - unknown_attrs = set(element.attrib) - xml_attrs - if unknown_attrs: - raise DesignSpaceDocumentError( - f"label element contains unknown attributes: {', '.join(unknown_attrs)}" - ) - - name = element.get("name") - if name is None: - raise DesignSpaceDocumentError("label element must have a name attribute.") - valueStr = element.get("uservalue") - if valueStr is None: - raise DesignSpaceDocumentError( - "label element must have a uservalue attribute." - ) - value = float(valueStr) - minimumStr = element.get("userminimum") - minimum = float(minimumStr) if minimumStr is not None else None - maximumStr = element.get("usermaximum") - maximum = float(maximumStr) if maximumStr is not None else None - linkedValueStr = element.get("linkeduservalue") - linkedValue = float(linkedValueStr) if linkedValueStr is not None else None - elidable = True if element.get("elidable") == "true" else False - olderSibling = True if element.get("oldersibling") == "true" else False - labelNames = { - lang: label_name.text or "" - for label_name in element.findall("labelname") - for attr, lang in label_name.items() - if attr == XML_LANG - # Note: elementtree reads the "xml:lang" attribute name as - # '{http://www.w3.org/XML/1998/namespace}lang' - } - return self.axisLabelDescriptorClass( - name=name, - userValue=value, - userMinimum=minimum, - userMaximum=maximum, - elidable=elidable, - olderSibling=olderSibling, - linkedUserValue=linkedValue, - labelNames=labelNames, - ) - - def readLabels(self): - if self.documentObject.formatTuple < (5, 0): - return - - xml_attrs = {"name", "elidable", "oldersibling"} - for labelElement in self.root.findall(".labels/label"): - unknown_attrs = set(labelElement.attrib) - xml_attrs - if unknown_attrs: - raise DesignSpaceDocumentError( - f"Label element contains unknown attributes: {', '.join(unknown_attrs)}" - ) - - name = labelElement.get("name") - if name is None: - raise DesignSpaceDocumentError( - "label element must have a name attribute." - ) - designLocation, userLocation = self.locationFromElement(labelElement) - if designLocation: - raise DesignSpaceDocumentError( - f'