def run_ufolib_import_validation(self):
"""
ufoLib UFOReader.getLayerNames method validates the layercontents.plist file
:return: (list) list of test failure Result objects
"""
res = Result(self.testpath)
ss = StdStreamer(self.ufopath)
if file_exists(
self.testpath
) is False: # should only meet this condition if not a mandatory file (runner.py checks)
res.test_failed = False
ss.stream_result(res)
return self.test_fail_list
try:
# read layercontents.plist with ufoLib - the ufoLib library performs type validations on values on read
ufolib_reader = UFOReader(self.ufopath, validate=True)
ufolib_reader.getLayerNames()
res.test_failed = False
ss.stream_result(res)
except Exception as e:
if self.testpath in self.mandatory_filepaths_list: # if part of mandatory file spec for UFO version, fail early
res.test_failed = True
res.exit_failure = True # fail early b/c it is mandatory part of spec
else:
res.test_failed = True # fail the test, but wait to report until all other tests complete
res.test_long_stdstream_string = self.testpath + " failed ufoLib import test with error: " + str(
e)
self.test_fail_list.append(res)
ss.stream_result(res)
return self.test_fail_list
def reloadLayers(self, layerData):
"""
Reload the layers. This should not be called externally.
"""
reader = UFOReader(self.font.path)
# handle the layers
currentLayerOrder = self.layerOrder
for layerName, l in list(layerData.get("layers", {}).items()):
# new layer
if layerName not in currentLayerOrder:
glyphSet = reader.getGlyphSet(layerName)
self.newLayer(layerName, glyphSet)
# get the layer
layer = self[layerName]
# reload the layer info
if l.get("info"):
layer.color = None
layer.lib.clear()
layer._glyphSet.readLayerInfo(layer)
self._stampLayerInfoDataState(layer)
# reload the glyphs
glyphNames = l.get("glyphNames", [])
if glyphNames:
layer.reloadGlyphs(glyphNames)
# handle the order
if layerData.get("order", False):
newLayerOrder = reader.getLayerNames()
for layerName in self.layerOrder:
if layerName not in newLayerOrder:
newLayerOrder.append(layerName)
self.layerOrder = newLayerOrder
# handle the default layer
if layerData.get("default", False):
newDefaultLayerName = reader.getDefaultLayerName()
self.defaultLayer = self[newDefaultLayerName]
def reloadLayers(self, layerData):
"""
Reload the layers. This should not be called externally.
"""
reader = UFOReader(self.font.path)
# handle the layers
currentLayerOrder = self.layerOrder
for layerName, l in list(layerData.get("layers", {}).items()):
# new layer
if layerName not in currentLayerOrder:
glyphSet = reader.getGlyphSet(layerName)
self.newLayer(layerName, glyphSet)
# get the layer
layer = self[layerName]
# reload the layer info
if l.get("info"):
layer.color = None
layer.lib.clear()
layer._glyphSet.readLayerInfo(layer)
self._stampLayerInfoDataState(layer)
# reload the glyphs
glyphNames = l.get("glyphNames", [])
if glyphNames:
layer.reloadGlyphs(glyphNames)
# handle the order
if layerData.get("order", False):
newLayerOrder = reader.getLayerNames()
for layerName in self.layerOrder:
if layerName not in newLayerOrder:
newLayerOrder.append(layerName)
self.layerOrder = newLayerOrder
# handle the default layer
if layerData.get("default", False):
newDefaultLayerName = reader.getDefaultLayerName()
self.defaultLayer = self[newDefaultLayerName]
class UFOFontData:
def __init__(self, path, log_only, allow_decimal_coords,
write_to_default_layer):
self._reader = UFOReader(path, validate=False)
self.path = path
self.glyphMap = {}
self.processedLayerGlyphMap = {}
self.newGlyphMap = {}
self.glyphList = []
self._fontInfo = None
self._glyphsets = {}
# If True, we are running in report mode and not doing any changes, so
# we skip the hash map and process all glyphs.
self.log_only = log_only
# Used to store the hash of glyph data of already processed glyphs. If
# the stored hash matches the calculated one, we skip the glyph.
self._hashmap = None
self.fontDict = None
self.hashMapChanged = False
# If True, then write data to the default layer
self.writeToDefaultLayer = write_to_default_layer
# if True, do NOT round x,y values when processing.
self.allowDecimalCoords = allow_decimal_coords
self._load_glyphmap()
def getUnitsPerEm(self):
return self.fontInfo.get("unitsPerEm", 1000)
def getPSName(self):
return self.fontInfo.get("postscriptFontName", "PSName-Undefined")
@staticmethod
def isCID():
return False
def convertToBez(self, glyphName, read_hints, doAll=False):
# We do not yet support reading hints, so read_hints is ignored.
width, bez, skip = self._get_or_skip_glyph(glyphName, doAll)
if skip:
return None, width
bezString = "\n".join(bez)
bezString = "\n".join(["% " + glyphName, "sc", bezString, "ed", ""])
return bezString, width
def updateFromBez(self, bezData, name, width):
# For UFO font, we don't use the width parameter:
# it is carried over from the input glif file.
layer = None
if name in self.processedLayerGlyphMap:
layer = PROCESSED_LAYER_NAME
glyphset = self._get_glyphset(layer)
glyph = BezGlyph(bezData)
glyphset.readGlyph(name, glyph)
self.newGlyphMap[name] = glyph
# updateFromBez is called only if the glyph has been autohinted which
# might also change its outline data. We need to update the edit status
# in the hash map entry. I assume that convertToBez has been run
# before, which will add an entry for this glyph.
self.updateHashEntry(name)
def save(self, path):
if path is None:
path = self.path
if os.path.abspath(self.path) != os.path.abspath(path):
# If user has specified a path other than the source font path,
# then copy the entire UFO font, and operate on the copy.
log.info("Copying from source UFO font to output UFO font before "
"processing...")
if os.path.exists(path):
shutil.rmtree(path)
shutil.copytree(self.path, path)
writer = UFOWriter(path, self._reader.formatVersion, validate=False)
if self.hashMapChanged:
self.writeHashMap(writer)
self.hashMapChanged = False
layer = PROCESSED_LAYER_NAME
if self.writeToDefaultLayer:
layer = None
# Write glyphs.
glyphset = writer.getGlyphSet(layer, defaultLayer=layer is None)
for name, glyph in self.newGlyphMap.items():
filename = self.glyphMap[name]
if not self.writeToDefaultLayer and \
name in self.processedLayerGlyphMap:
filename = self.processedLayerGlyphMap[name]
glyphset.contents[name] = filename
glyphset.writeGlyph(name, glyph, glyph.drawPoints)
glyphset.writeContents()
# Write layer contents.
layers = {DEFAULT_LAYER_NAME: DEFAULT_GLYPHS_DIRNAME}
if self.processedLayerGlyphMap:
layers[PROCESSED_LAYER_NAME] = PROCESSED_GLYPHS_DIRNAME
writer.layerContents.update(layers)
writer.writeLayerContents([DEFAULT_LAYER_NAME, PROCESSED_LAYER_NAME])
@property
def hashMap(self):
if self._hashmap is None:
data = self._reader.readBytesFromPath(
os.path.join(DATA_DIRNAME, HASHMAP_NAME))
if data:
hashmap = ast.literal_eval(data.decode("utf-8"))
else:
hashmap = {HASHMAP_VERSION_NAME: HASHMAP_VERSION}
version = (0, 0)
if HASHMAP_VERSION_NAME in hashmap:
version = hashmap[HASHMAP_VERSION_NAME]
if version[0] > HASHMAP_VERSION[0]:
raise FontParseError("Hash map version is newer than "
"psautohint. Please update.")
elif version[0] < HASHMAP_VERSION[0]:
log.info("Updating hash map: was older version")
hashmap = {HASHMAP_VERSION_NAME: HASHMAP_VERSION}
self._hashmap = hashmap
return self._hashmap
def writeHashMap(self, writer):
hashMap = self.hashMap
if not hashMap:
return # no glyphs were processed.
hasMapKeys = hashMap.keys()
hasMapKeys = sorted(hasMapKeys)
data = ["{"]
for gName in hasMapKeys:
data.append("'%s': %s," % (gName, hashMap[gName]))
data.append("}")
data.append("")
data = "\n".join(data)
writer.writeBytesToPath(os.path.join(DATA_DIRNAME, HASHMAP_NAME),
data.encode("utf-8"))
def updateHashEntry(self, glyphName):
# srcHash has already been set: we are fixing the history list.
# Get hash entry for glyph
srcHash, historyList = self.hashMap[glyphName]
self.hashMapChanged = True
# If the program is not in the history list, add it.
if AUTOHINT_NAME not in historyList:
historyList.append(AUTOHINT_NAME)
def checkSkipGlyph(self, glyphName, newSrcHash, doAll):
skip = False
if self.log_only:
return skip
srcHash = None
historyList = []
# Get hash entry for glyph
if glyphName in self.hashMap:
srcHash, historyList = self.hashMap[glyphName]
if srcHash == newSrcHash:
if AUTOHINT_NAME in historyList:
# The glyph has already been autohinted, and there have been no
# changes since.
skip = not doAll
if not skip and AUTOHINT_NAME not in historyList:
historyList.append(AUTOHINT_NAME)
else:
if CHECKOUTLINE_NAME in historyList:
log.error("Glyph '%s' has been edited. You must first "
"run '%s' before running '%s'. Skipping.",
glyphName, CHECKOUTLINE_NAME, AUTOHINT_NAME)
skip = True
# If the source hash has changed, we need to delete the processed
# layer glyph.
self.hashMapChanged = True
self.hashMap[glyphName] = [newSrcHash, [AUTOHINT_NAME]]
if glyphName in self.processedLayerGlyphMap:
del self.processedLayerGlyphMap[glyphName]
return skip
def _get_glyphset(self, layer_name=None):
if layer_name not in self._glyphsets:
glyphset = None
if layer_name is None or layer_name in \
self._reader.getLayerNames():
glyphset = self._reader.getGlyphSet(layer_name)
self._glyphsets[layer_name] = glyphset
return self._glyphsets[layer_name]
def get_glyph_bez(self, glyph):
pen = BezPen(glyph.glyphSet, self)
glyph.draw(pen)
if not hasattr(glyph, "width"):
glyph.width = 1000
return pen.bez
def _get_or_skip_glyph(self, name, doAll):
# Get default glyph layer data, so we can check if the glyph
# has been edited since this program was last run.
# If the program name is in the history list, and the srcHash
# matches the default glyph layer data, we can skip.
glyphset = self._get_glyphset()
glyph = glyphset[name]
bez = self.get_glyph_bez(glyph)
# Hash is always from the default glyph layer.
hash_pen = HashPointPen(glyph)
glyph.drawPoints(hash_pen)
skip = self.checkSkipGlyph(name, hash_pen.getHash(), doAll)
# If there is a glyph in the processed layer, get the outline from it.
if name in self.processedLayerGlyphMap:
glyphset = self._get_glyphset(PROCESSED_LAYER_NAME)
glyph = glyphset[name]
bez = self.get_glyph_bez(glyph)
return glyph.width, bez, skip
def getGlyphList(self):
return self.glyphList
def _load_glyphmap(self):
# Need to both get the list of glyphs in the font, and also the glyph
# order. The latter is taken from the public.glyphOrder key in the lib,
# if it exists, else it is taken from the contents. Any existing
# glyphs which are not named in the public.glyphOrder are sorted after
# all glyphs which are named in the public.glyphOrder, in the order
# that they occurred in contents.plist.
glyphset = self._get_glyphset()
self.glyphMap = glyphset.contents
self.glyphList = glyphset.keys()
self.orderMap = {}
fontlib = self._reader.readLib()
glyphOrder = fontlib.get(PUBLIC_GLYPH_ORDER, self.glyphList)
for i, name in enumerate(glyphOrder):
self.orderMap[name] = i
# If there are glyphs in the font which are not named in the
# public.glyphOrder entry, add them in the order of the
# contents.plist file.
for name in self.glyphList:
if name not in self.orderMap:
self.orderMap[name] = len(self.orderMap)
self.glyphList = sorted(list(self.orderMap.keys()))
# I also need to get the glyph map for the processed layer,
# and use this when the glyph is read from the processed layer.
# glyph file names that differ from what is in the default glyph layer.
# Because checkOutliensUFO used the defcon library, it can write
glyphset = self._get_glyphset(PROCESSED_LAYER_NAME)
if glyphset is not None:
self.processedLayerGlyphMap = glyphset.contents
@property
def fontInfo(self):
if self._fontInfo is None:
info = SimpleNamespace()
self._reader.readInfo(info)
self._fontInfo = vars(info)
return self._fontInfo
def getFontInfo(self, allow_no_blues, noFlex,
vCounterGlyphs, hCounterGlyphs, fdIndex=0):
if self.fontDict is not None:
return self.fontDict
fdDict = fdTools.FDDict()
# should be 1 if the glyphs are ideographic, else 0.
fdDict.LanguageGroup = self.fontInfo.get("languagegroup", "0")
fdDict.OrigEmSqUnits = self.getUnitsPerEm()
fdDict.FontName = self.getPSName()
upm = self.getUnitsPerEm()
low = min(-upm * 0.25,
self.fontInfo.get("openTypeOS2WinDescent", 0) - 200)
high = max(upm * 1.25,
self.fontInfo.get("openTypeOS2WinAscent", 0) + 200)
# Make a set of inactive alignment zones: zones outside of the font
# bbox so as not to affect hinting. Used when src font has no
# BlueValues or has invalid BlueValues. Some fonts have bad BBox
# values, so I don't let this be smaller than -upm*0.25, upm*1.25.
inactiveAlignmentValues = [low, low, high, high]
blueValues = self.fontInfo.get("postscriptBlueValues", [])
numBlueValues = len(blueValues)
if numBlueValues < 4:
if allow_no_blues:
blueValues = inactiveAlignmentValues
numBlueValues = len(blueValues)
else:
raise FontParseError(
"Font must have at least four values in its "
"BlueValues array for PSAutoHint to work!")
blueValues.sort()
# The first pair only is a bottom zone, where the first value is the
# overshoot position; the rest are top zones, and second value of the
# pair is the overshoot position.
blueValues[0] = blueValues[0] - blueValues[1]
for i in range(3, numBlueValues, 2):
blueValues[i] = blueValues[i] - blueValues[i - 1]
blueValues = [str(v) for v in blueValues]
numBlueValues = min(numBlueValues, len(fdTools.kBlueValueKeys))
for i in range(numBlueValues):
key = fdTools.kBlueValueKeys[i]
value = blueValues[i]
setattr(fdDict, key, value)
otherBlues = self.fontInfo.get("postscriptOtherBlues", [])
numBlueValues = len(otherBlues)
if len(otherBlues) > 0:
i = 0
numBlueValues = len(otherBlues)
otherBlues.sort()
for i in range(0, numBlueValues, 2):
otherBlues[i] = otherBlues[i] - otherBlues[i + 1]
otherBlues = [str(v) for v in otherBlues]
numBlueValues = min(numBlueValues,
len(fdTools.kOtherBlueValueKeys))
for i in range(numBlueValues):
key = fdTools.kOtherBlueValueKeys[i]
value = otherBlues[i]
setattr(fdDict, key, value)
vstems = self.fontInfo.get("postscriptStemSnapV", [])
if not vstems:
if allow_no_blues:
# dummy value. Needs to be larger than any hint will likely be,
# as the autohint program strips out any hint wider than twice
# the largest global stem width.
vstems = [fdDict.OrigEmSqUnits]
else:
raise FontParseError("Font does not have postscriptStemSnapV!")
vstems.sort()
if not vstems or (len(vstems) == 1 and vstems[0] < 1):
# dummy value that will allow PyAC to run
vstems = [fdDict.OrigEmSqUnits]
log.warning("There is no value or 0 value for DominantV.")
fdDict.DominantV = "[" + " ".join([str(v) for v in vstems]) + "]"
hstems = self.fontInfo.get("postscriptStemSnapH", [])
if not hstems:
if allow_no_blues:
# dummy value. Needs to be larger than any hint will likely be,
# as the autohint program strips out any hint wider than twice
# the largest global stem width.
hstems = [fdDict.OrigEmSqUnits]
else:
raise FontParseError("Font does not have postscriptStemSnapH!")
hstems.sort()
if not hstems or (len(hstems) == 1 and hstems[0] < 1):
# dummy value that will allow PyAC to run
hstems = [fdDict.OrigEmSqUnits]
log.warning("There is no value or 0 value for DominantH.")
fdDict.DominantH = "[" + " ".join([str(v) for v in hstems]) + "]"
if noFlex:
fdDict.FlexOK = "false"
else:
fdDict.FlexOK = "true"
# Add candidate lists for counter hints, if any.
if vCounterGlyphs:
temp = " ".join(vCounterGlyphs)
fdDict.VCounterChars = "( %s )" % (temp)
if hCounterGlyphs:
temp = " ".join(hCounterGlyphs)
fdDict.HCounterChars = "( %s )" % (temp)
fdDict.BlueFuzz = self.fontInfo.get("postscriptBlueFuzz", 1)
# postscriptBlueShift
# postscriptBlueScale
self.fontDict = fdDict
return fdDict
def getfdInfo(self, allow_no_blues, noFlex, vCounterGlyphs, hCounterGlyphs,
glyphList, fdIndex=0):
fdGlyphDict = None
fdDict = self.getFontInfo(allow_no_blues, noFlex,
vCounterGlyphs, hCounterGlyphs, fdIndex)
fontDictList = [fdDict]
# Check the fontinfo file, and add any other font dicts
srcFontInfo = os.path.dirname(self.path)
srcFontInfo = os.path.join(srcFontInfo, "fontinfo")
maxX = self.getUnitsPerEm() * 2
maxY = maxX
minY = -self.getUnitsPerEm()
if os.path.exists(srcFontInfo):
with open(srcFontInfo, "r", encoding="utf-8") as fi:
fontInfoData = fi.read()
fontInfoData = re.sub(r"#[^\r\n]+", "", fontInfoData)
if "FDDict" in fontInfoData:
fdGlyphDict, fontDictList, finalFDict = \
fdTools.parseFontInfoFile(
fontDictList, fontInfoData, glyphList, maxY, minY,
self.getPSName())
if finalFDict is None:
# If a font dict was not explicitly specified for the
# output font, use the first user-specified font dict.
fdTools.mergeFDDicts(fontDictList[1:], self.fontDict)
else:
fdTools.mergeFDDicts([finalFDict], self.fontDict)
return fdGlyphDict, fontDictList
def getGlyphID(self, glyphName):
try:
gid = self.orderMap[glyphName]
except IndexError:
raise FontParseError(
"Could not find glyph name '%s' in UFO font contents plist. "
"'%s'. " % (glyphName, self.path))
return gid
@staticmethod
def close():
return