#!/usr/bin/env python
# -*- coding: utf-8 -*-
# libfv.py────────────────────────────────────────────────────────────────┐
# │ │
# │ A Python library module that supports read/modification/write of .otf │
# │ and .ttf font version strings │
# │ │
# │ Copyright 2018 Christopher Simpkins │
# │ MIT License │
# │ │
# │ Source: https://github.com/source-foundry/font-v │
# │ │
# └───────────────────────────────────────────────────────────────────────┘
from __future__ import unicode_literals
import os
import re
from fontTools import ttLib
from git import Repo
from fontv.utilities import get_git_root_path
[docs]class FontVersion(object):
"""
FontVersion is a ttf and otf font version string class that provides support for font version string reads,
reporting, modification, & writes. Support is provided for instantiation from ttf and otf fonts, as well
as from fontTools.ttLib.ttFont objects (https://github.com/fonttools/fonttools).
The class works on Python "strings". String types indicated below refer to the Python2 unicode type and Python3
string type.
PUBLIC ATTRIBUTES:
contains_metadata: (boolean) boolean for presence of metadata in version string
contains_state: (boolean) boolean for presence of state substring metadata in the version string
contains_status: (boolean) boolean for presence of development/release status substring in the version string
develop_string: (string) The string to use for development builds in the absence of git commit SHA1 string
fontpath: (string) The path to the font file
is_development: (boolean) boolean for presence of development status substring at version_string_parts[1]
is_release: (boolean) boolean for presence of release status status substring at version_string_parts[1]
metadata: (list) A list of metadata substrings in the version string. Either version_string_parts[1:] or empty list
release_string: (string) The string to use for release builds in the absence of git commit SHA1 string
sha1_develop: (string) The string to append to the git SHA1 hash string for development builds
sha1_release: (string) The string to append to the git SHA1 hash string for release builds
state: (string) The state metadata substring
ttf: (fontTools.ttLib.TTFont) for font file
version_string_parts: (list) List that maintains in memory semicolon parsed substrings of font version string
version: (string) The version number substring formatted as "Version X.XXX"
PRIVATE ATTRIBUTES
_nameID_5_dict: (dictionary) {(platformID, platEncID,langID) : fontTools.ttLib.TTFont name record ID 5 object } map
:parameter font: (string) file path to the .otf or .ttf font file OR (ttLib.TTFont) object for appropriate font file
:parameter develop: (string) the string to use for development builds in the absence of git commit SHA1 string
:parameter release: (string) the string to use for release builds in the absence of a git commit SHA1 string
:parameter sha1_develop: (string) the string to append to the git SHA1 hash string for development builds
:parameter sha1_release: (string) the string to append to the git SHA1 hash string for release builds
:raises: fontTools.ttLib.TTLibError if fontpath is not a ttf or otf font
:raises: IndexError if there are no nameID 5 records in the font name table
:raises: IOError if fontpath does not exist
"""
def __init__(
self,
font,
develop="DEV",
release="RELEASE",
sha1_develop="-dev",
sha1_release="-release",
):
try:
# assume that it is a ttLib.TTFont object and attempt to call object attributes
self.fontpath = font.reader.file.name
# if it does not raise AttributeError, we guessed correctly, can set the ttf attr here
self.ttf = font
except AttributeError:
# if above attempt to call TTFont attribute raises AttributeError (as it would with string file path)
# then instantiate a ttLib.TTFont object and define the fontpath attribute with the file path string
self.ttf = ttLib.TTFont(file=font, recalcTimestamp=False)
self.fontpath = font
self.develop_string = develop
self.release_string = release
self.sha1_develop = sha1_develop
self.sha1_release = sha1_release
# name.ID = 5 version string substring data
self.name_ID5_dict = {}
self.version_string_parts = (
[]
) # list of substring items in version string (; delimited parse to list)
self.version = ""
self.state = ""
self.metadata = []
# truth test values for version string contents, updated with self._parse() method calls following updates to
# in memory version string data with methods in this library
self.contains_metadata = False
self.contains_state = False
self.contains_status = False
self.is_development = False
self.is_release = False
# head.fontRevision data. float type
self.head_fontRevision = 0.0
# object instantiation method call (truth test values updated in the following method)
self._read_version_string()
def __eq__(self, otherfont):
"""
Equality comparison between FontVersion objects
:param otherfont: fontv.libfv.FontVersion object for comparison
:return: (boolean) True = versions are the same; False = versions are not the same
"""
if type(otherfont) is type(self):
return self.version_string_parts == otherfont.version_string_parts
return False
def __ne__(self, otherfont):
"""
Inequality comparison between FontVersion objects
:param otherfont: fontv.libfv.FontVersion object for comparison
:return: (boolean) True = versions differ; False = versions are the same
"""
return not self.__eq__(otherfont)
def __str__(self):
"""
Human readable string formatting
:return: (string)
"""
return (
"<fontv.libfv.FontVersion> "
+ os.linesep
+ self.get_name_id5_version_string()
+ os.linesep
+ "file path:"
" " + self.fontpath
)
# TODO: confirm comparisons of version numbers like "Version 1.001", "Version 1.01", "Version 1.1" as not the same
# TODO: before this is released. Will need to be documented as such because this is not obvious behavior
# def __gt__(self, otherfont):
# """
#
# :param otherfont:
#
# :return:
# """
# return self.get_version_number_tuple() > otherfont.get_version_number_tuple()
#
# def __lt__(self, otherfont):
# """
#
# :param otherfont:
#
# :return:
# """
# return self.get_version_number_tuple() < otherfont.get_version_number_tuple()
[docs] def _parse(self):
"""
Private method that parses version string data to set FontVersion object attributes. Called on FontVersion
object instantiation and at the completion of setter methods in the library in order to update object
attributes with new data.
:return: None
"""
# metadata parsing
self._parse_metadata() # parse the metadata
self._parse_state() # parse the state substring data
self._parse_status() # parse the version substring dev/rel status indicator data
[docs] def _read_version_string(self):
"""
Private method that reads OpenType name ID 5 and head.fontRevision record data from a fontTools.ttLib.ttFont
object and sets FontVersion object properties. The method is called on instantiation of a FontVersion object
:return: None
"""
# Read the name.ID=5 record
namerecord_list = self.ttf["name"].names
# read in name records
for record in namerecord_list:
if record.nameID == 5:
# map dictionary as {(platformID, platEncID, langID) : version string}
recordkey = (record.platformID, record.platEncID, record.langID)
self.name_ID5_dict[recordkey] = record.toUnicode()
# assert that at least one nameID 5 record was obtained from the font in order to instantiate
# a FontVersion object
if len(self.name_ID5_dict) == 0:
raise IndexError(
"Unable to read nameID 5 version records from the font " + self.fontpath
)
# define the version string from the dictionary
for vs in self.name_ID5_dict.values():
version_string = vs
break # take the first value that dictionary serves up
# parse version string into substrings
self._parse_version_substrings(version_string)
# define version as first substring
self.version = self.version_string_parts[0]
# Read the head.fontRevision record (stored as a float)
self.head_fontRevision = self.ttf["head"].fontRevision
self._parse() # update FontVersion object attributes based upon the data read in
[docs] def _get_repo_commit(self):
"""
Private method that makes a system git call via the GitPython library and returns a short git commit
SHA1 hash string for the commit at HEAD using `git rev-list`.
:return: (string) short git commit SHA1 hash string
"""
repo = Repo(get_git_root_path(self.fontpath))
gitpy = repo.git
# git rev-list --abbrev-commit --max-count=1 --format="%h" HEAD - abbreviated unique sha1 for the repository
# number of sha1 hex characters determined by git (addresses https://github.com/source-foundry/font-v/issues/2)
full_git_sha_string = gitpy.rev_list(
"--abbrev-commit", "--max-count=1", '--format="%h"', "HEAD"
)
unicode_full_sha_string = full_git_sha_string
sha_string_list = unicode_full_sha_string.split("\n")
final_sha_string = sha_string_list[1].replace('"', "")
return final_sha_string
[docs] def _parse_state(self):
"""
Private method that parses a font version string for [ ... ] delimited data that represents the State
substring. The result of this test is used to define State data
in the FontVersion object.
:return: None
"""
if len(self.version_string_parts) > 1:
# Test for regular expression pattern match for state substring at version string list position 1
# This method call returns tuple of (truth test for match, matched state string (or empty string))
response = self._is_state_substring_return_state_match(
self.version_string_parts[1]
)
is_state_substring = response[0]
state_substring_match = response[1]
if is_state_substring is True:
self.contains_state = True
self.state = state_substring_match
else:
self.contains_state = False
self.state = ""
else:
self.contains_state = False
self.state = ""
[docs] def _parse_status(self):
"""
Private method that parses a font version string to determine if it contains development/release Status
substring metadata. The result of this test is used to define Status
data in the FontVersion object.
:return: None
"""
if len(self.version_string_parts) > 1:
# define as list item 1
status_needle = self.version_string_parts[1]
# reset each time there is a parse attempt and let logic below define
self.contains_status = False
if self._is_development_substring(status_needle):
self.contains_status = True
self.is_development = True
else:
self.is_development = False
if self._is_release_substring(status_needle):
self.contains_status = True
self.is_release = True
else:
self.is_release = False
else:
self.contains_status = False
self.is_development = False
self.is_release = False
[docs] def _parse_version_substrings(self, version_string):
"""
Private method that splits a full semicolon delimited version string on semicolon characters to a Python list.
:param version_string: (string) the semicolon delimited version string to split
:return: None
"""
# split semicolon delimited list of version substrings
if ";" in version_string:
self.version_string_parts = version_string.split(";")
else:
self.version_string_parts = [version_string]
self.version = self.version_string_parts[0]
[docs] def _set_state_status_substring(self, state_status_string):
"""
Private method that sets the State/Status substring in the FontVersion.version_string_parts[1] list position.
The method preserves Other metadata when present in the version string.
:param state_status_string: (string) the string value to insert at the status substring position of the
self.version_string_parts list
:return: None
"""
if len(self.version_string_parts) > 1:
prestring = self.version_string_parts[1]
state_response = self._is_state_substring_return_state_match(prestring)
is_state_substring = state_response[0]
if (
self._is_release_substring(prestring)
or self._is_development_substring(prestring)
or is_state_substring
):
# directly replace when existing status substring
self.version_string_parts[1] = state_status_string
else:
# if the second item of the substring list is not a status string, save it and all subsequent list items
# then create a new list with inserted status string value
self.version_string_parts = [
self.version_string_parts[0]
] # redefine list as list with version number
self.version_string_parts.append(
state_status_string
) # define the status substring as next item
for (
item
) in (
self.metadata
): # iterate through all previous metadata substrings and append to list
self.version_string_parts.append(item)
else:
# if the version string is defined as only a version number substring (i.e. list size = 1),
# write the new status substring to the list. Nothing else required
self.version_string_parts.append(state_status_string)
# update FontVersion truth testing properties based upon the new data
self._parse()
[docs] def _is_development_substring(self, needle):
"""
Private method that returns a boolean that indicates whether the needle string meets the
definition of a Development Status metadata substring.
:param needle: (string) test string
:return: boolean True = is development substring and False = is not a development substring
"""
if (
self.develop_string == needle.strip()
or self.sha1_develop in needle[-len(self.sha1_develop) :]
):
return True
else:
return False
[docs] def _is_release_substring(self, needle):
"""
Private method that returns a boolean that indicates whether the needle string meets the
definition of a Release Status metadata substring.
:param needle: (string) test string
:return: boolean True = is release substring and False = is not a release substring
"""
if (
self.release_string == needle.strip()
or self.sha1_release in needle[-len(self.sha1_release) :]
):
return True
else:
return False
[docs] def _is_state_substring_return_state_match(self, needle):
"""
Private method that returns a tuple of boolean, string. The boolean value reflects the truth test needle is a
State substring. The match value is defined as the contents inside [ and ] delimiters as defined by the
regex pattern. If there is no match, the string item in the tuple is an empty string.
:param needle: (string) test string to attempt match for state substring
:return: (boolean, string) see full docstring for details re: interpretation of returned values
"""
regex_pattern = r"\s?\[([a-zA-Z0-9_\-\.]{1,50})\]"
p = re.compile(regex_pattern)
m = p.match(needle)
if m:
return True, m.group(1)
else:
return False, ""
[docs] def get_version_number_string(self):
"""
Public method that returns a string of the version number in XXX.XXX format. A version number match is defined
with up to three digits on either side of the period.
:return: string (Python 3) or unicode (Python 2). Empty string if unable to parse version number format
"""
match = re.search(r"\d{1,3}\.\d{1,3}", self.version)
if match:
return match.group(0)
else:
return ""
[docs] def get_version_number_tuple(self):
"""
Public method that returns a tuple of integer values with the following definition:
( major version, minor version position 1, minor version position 2, minor version position 3 )
where position is the decimal position of the integer in the minor version string.
:return: tuple of integers or None if the version number substring is inappropriately formatted
"""
match = re.search(r"\d{1,3}\.\d{1,3}", self.version)
if match:
version_number_int_list = []
version_number_string = match.group(0)
version_number_list = version_number_string.split(".")
version_number_major_int = int(version_number_list[0])
version_number_int_list.append(
version_number_major_int
) # add major version integer
for minor_int in version_number_list[1]:
version_number_int_list.append(int(minor_int))
return tuple(version_number_int_list)
else:
return None
[docs] def get_head_fontrevision_version_number(self):
"""
Public method that returns the version number that is parsed from head.fontRevision record as a float value.
:return: float
"""
return self.head_fontRevision
# TODO: remove this deprecated method (commented out in v0.7.0, deprecation warnings in v0.6.0)
# def get_version_string(self):
# """
# DEPRECATED: Please convert to use of FontVersion.get_name_id5_version_string() method
# """
# warnings.simplefilter('always')
# warnstring = "[WARNING] FontVersion.get_version_string is a deprecated method. Please convert to " \
# "FontVersion.get_name_id5_version_string."
# warnings.warn(warnstring, DeprecationWarning, stacklevel=2)
# return ";".join(self.version_string_parts)
[docs] def get_name_id5_version_string(self):
"""
Public method that returns the full version string as the semicolon delimiter joined contents of the
FontVersion.version_string_parts Python list.
:return: string (Python 3) or unicode (Python 2)
"""
return ";".join(self.version_string_parts)
[docs] def get_state_status_substring(self):
"""
Public method that returns the State and/or Status substring at position 2 of the semicolon delimited version
string. This substring may include any of the following metadata:
- "DEV"
- "RELEASE"
- "[state]-dev"
- "[state]-release"
:return: string (Python 3) or unicode (Python 2), empty string if this substring is not set in the font
"""
if len(self.version_string_parts) > 1:
if self.is_development or self.is_release or self.contains_state:
return self.version_string_parts[1]
else:
return ""
else:
return ""
[docs] def set_state_git_commit_sha1(self, development=False, release=False):
"""
Public method that adds a git commit sha1 hash label to the font version string at the State metadata position.
This can be combined with a Development/Release Status metadata substring if the calling code defines either the
development or release parameter to a value of True. Note that development and release are mutually exclusive.
ValueError is raised if both are set to True. The font source must be under git version control in order to use
this method. If the font source is not under git version control, an IOError is raised during the attempt to
locate the .git directory in the project.
:param development: (boolean) False (default) = do not add development status indicator; True = add indicator
:param release: (boolean) False (default) = do not add release status indicator; True = add indicator
:raises: IOError when the git repository root cannot be identified using the directory traversal in the
fontv.utilities.get_git_root_path() function
:raises: ValueError when calling code sets both development and release parameters to True as these are
mutually exclusive requests
:return: None
"""
git_sha1_hash = self._get_repo_commit()
git_sha1_hash_formatted = "[" + git_sha1_hash + "]"
if development and release:
raise ValueError(
"Cannot set both development parameter and release parameter to a value of True in "
"fontv.libfv.FontVersion.set_state_git_commit_sha1() method. These are mutually "
"exclusive."
)
if (
development
): # if request for development status label, append FontVersion.sha1_develop to hash digest
hash_substring = git_sha1_hash_formatted + self.sha1_develop
elif (
release
): # if request for release status label, append FontVersion.sha1_release to hash digest
hash_substring = git_sha1_hash_formatted + self.sha1_release
else: # else just use the hash digest
hash_substring = git_sha1_hash_formatted
self._set_state_status_substring(hash_substring)
[docs] def set_development_status(self):
"""
Public method that sets the in memory Development Status metadata substring for the font version string.
:return: None
"""
self._set_state_status_substring(self.develop_string)
[docs] def set_release_status(self):
"""
Public method that sets the in memory Release Status metadata substring for the font version string.
:return: None
"""
self._set_state_status_substring(self.release_string)
[docs] def set_version_number(self, version_number):
"""
Public method that sets the version number substring with the version_number parameter.
The method will raise ValueError if the version_string cannot be cast to a float type. This is mandatory
for the definition of the head table fontRevision record definition in the font binary. Attempts to add
metadata strings to the version_number violate this library's specification and are intentionally not permitted.
:param version_number: (string) version number in X.XXX format where X are integers
:return: None
"""
version_number_substring = "Version " + version_number
self.version_string_parts[0] = version_number_substring
self.version = self.version_string_parts[0] # "Version X.XXX"
self.head_fontRevision = float(version_number) # X.XXX
self._parse()
[docs] def set_version_string(self, version_string):
"""
Public method that sets the entire version string (including metadata if desired) with a version_string
parameter.
The method will raise a ValueError if the version number used in the version_string cannot be cast to a
float type. This is mandatory for the definition of the head table fontRevision record definition in the
font binary. Attempts to add metadata strings to the version_number violate this library's specification and
are intentionally not permitted.
:param version_string: (string) The version string with semicolon delimited metadata (if metadata are included)
:return: None
"""
self._parse_version_substrings(version_string)
self._parse()
self.head_fontRevision = float(self.get_version_number_string())
[docs] def write_version_string(self, fontpath=None):
"""
Public method that writes the in memory version data to:
(1) each OpenType name table ID 5 record in original font file
(2) OpenType head table fontRevision record
The name table ID 5 record(s) write is with a semicolon joined list of the items in
FontVersion.version_string_parts
The head table fontRevision record write is with the version number float value in FontVersion.head_fontRevision
The write is to a .otf file if the FontVersion object was instantiated from a .otf binary and a .ttf
file if the FontVersion object was instantiated from a .ttf binary. By default the write is to the same
file path that was used for instantiation of the FontVersion object. This write path default can be modified by
passing a new file path in the fontpath parameter.
:param fontpath: (string) optional file path to write out the font version string to a font binary
:return: None
"""
# Write to name table ID 5 record
version_string = self.get_name_id5_version_string()
namerecord_list = self.ttf["name"].names
for record in namerecord_list:
if record.nameID == 5:
# write to fonttools ttLib object name ID 5 table record for each nameID 5 record found in the font
record.string = version_string
# Write version number to head table fontRevision record
self.ttf["head"].fontRevision = self.head_fontRevision
# Write changes out to the font binary path
if fontpath is None:
self.ttf.save(self.fontpath)
else:
self.ttf.save(fontpath)