def inherit_vertical_metrics(ttFonts, family_name=None):
"""Inherit the vertical metrics from the same family which is
hosted on Google Fonts.
Args:
ttFonts: a list of TTFont instances which belong to a family
family_name: Optional string which allows users to specify a
different family to inherit from e.g "Maven Pro".
"""
family_name = (
font_familyname(ttFonts[0])
if not family_name
else family_name
)
gf_fonts = list(map(TTFont, download_family_from_Google_Fonts(family_name)))
gf_fonts = {font_stylename(f): f for f in gf_fonts}
# TODO (Marc F) use Regular font instead. If VF use font which has Regular
# instance
gf_fallback = list(gf_fonts.values())[0]
fonts = {font_stylename(f): f for f in ttFonts}
for style, font in fonts.items():
if style in gf_fonts:
src_font = gf_fonts[style]
else:
src_font = gf_fallback
copy_vertical_metrics(src_font, font)
if typo_metrics_enabled(src_font):
font["OS/2"].fsSelection |= 1 << 7
def main():
parser = ArgumentParser(description=__doc__)
parser.add_argument('family', help='Name of font family')
parser.add_argument('-wc',
'--web-compare',
help='Compare against a web url .zip family')
parser.add_argument('-lc',
'--local-compare',
nargs='+',
help='Compare against a set of local ttfs')
args = parser.parse_args()
google_family = download_family_from_Google_Fonts(args.family)
google_family_fonts = [TTFont(f) for f in google_family]
google_family_version = parse_version_head(google_family_fonts)
if args.web_compare:
if args.web_compare.endswith('.zip'):
web_family_zip = ZipFile(download_file(args.web_compare))
web_family = fonts_from_zip(web_family_zip)
web_family_fonts = [
TTFont(f) for f in web_family if f.name.endswith(".ttf")
]
web_family_name = set(
f.reader.file.name.split('-')[0] for f in web_family)
web_family_version = parse_version_head(web_family_fonts)
print('Google Fonts Version of %s is v%s' %
(args.family, google_family_version))
print('Web Version of %s is v%s' %
(', '.join(web_family_name), web_family_version))
elif args.local_compare:
local_family = [TTFont(f) for f in args.local_compare]
local_family_version = parse_version_head(local_family)
local_fonts_name = set(
basename(f.split('-')[0]) for f in args.local_compare)
print('Google Fonts Version of %s is v%s' %
(args.family, google_family_version))
print('Local Version of %s is v%s' %
(','.join(local_fonts_name), local_family_version))
else:
print('Google Fonts Version of %s is v%s' %
(args.family, google_family_version))
def main():
parser = argparse.ArgumentParser(
description=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter)
font_group = parser.add_argument_group(title="Fonts to qa")
font_input_group = font_group.add_mutually_exclusive_group(required=True)
font_input_group.add_argument("-f",
"--fonts",
nargs="+",
help="Paths to fonts")
font_input_group.add_argument("-pr",
"--pull-request",
help="Get fonts from a Github pull request")
font_input_group.add_argument("-gh",
"--github-dir",
help="Get fonts from a Github directory")
font_input_group.add_argument("-gf",
"--googlefonts",
help="Get fonts from Google Fonts")
font_before_group = parser.add_argument_group(title="Fonts before input")
font_before_input_group = font_before_group.add_mutually_exclusive_group(
required=False)
font_before_input_group.add_argument("-fb",
"--fonts-before",
nargs="+",
help="Paths to previous fonts")
font_before_input_group.add_argument(
"-prb",
"--pull-request-before",
help="Get previous fonts from a Github pull request")
font_before_input_group.add_argument(
"-ghb",
"--github-dir-before",
help="Get previous fonts from a Github dir")
font_before_input_group.add_argument(
"-gfb",
"--googlefonts-before",
action="store_true",
help="Get previous fonts from Google Fonts",
)
check_group = parser.add_argument_group(title="QA checks")
check_group.add_argument(
"-a",
"--auto-qa",
action="store_true",
help=
"Check fonts against against the same fonts hosted on Google Fonts",
)
check_group.add_argument("--diffenator",
action="store_true",
help="Run Fontdiffenator")
check_group.add_argument("--diffbrowsers",
action="store_true",
help="Run Diffbrowsers")
check_group.add_argument("--fontbakery",
action="store_true",
help="Run FontBakery")
check_group.add_argument(
"--plot-glyphs",
action="store_true",
help="Gen images of full charset, useful for new familes",
)
check_group.add_argument(
"--browser-previews",
action="store_true",
help="Gen images on diff browsers, useful for new families",
)
check_group.add_argument("-dm",
"--diff-mode",
choices=("weak", "normal", "strict"),
default="normal")
parser.add_argument("-re", "--filter-fonts", help="Filter fonts by regex")
parser.add_argument("-o",
"--out",
default="out",
help="Output path for check results")
parser.add_argument(
"-ogh",
"--out-github",
action="store_true",
help=("Post report data to either the pull request as a comment "
"open a new issue. This can only be used if fonts have been "
"fetched from either a pull request or github dir."),
)
parser.add_argument(
"--out-url",
help=(
"Post report data to a github pr. This can be used with any font "
"fetching method."))
parser.add_argument("--version", action="version", version=__version__)
args = parser.parse_args()
if args.out_github and not any([args.pull_request, args.github_dir]):
raise Exception(
"Cannot upload results to a github issue or pr. "
"Font input must either a github dir or a pull request")
if not any([
args.auto_qa, args.fontbakery, args.plot_glyphs, args.diffbrowsers,
args.diffenator, args.browser_previews
]):
raise Exception("Terminating. No checks selected. Run gftools qa "
"--help to see all possible commands.")
# Retrieve fonts and store in out dir
mkdir(args.out)
fonts_dir = os.path.join(args.out, "fonts")
mkdir(fonts_dir)
if args.fonts:
[shutil.copy(f, fonts_dir) for f in args.fonts]
fonts = args.fonts
elif args.pull_request:
fonts = download_files_in_github_pr(
args.pull_request,
fonts_dir,
ignore_static_dir=False,
)
if not fonts:
logger.info("No fonts found in pull request. Skipping")
return
elif args.github_dir:
fonts = download_files_in_github_dir(args.github_dir, fonts_dir)
if not fonts:
logger.info("No fonts found in github dir. Skipping")
return
elif args.googlefonts:
fonts = download_family_from_Google_Fonts(args.googlefonts, fonts_dir)
if args.filter_fonts:
re_filter = re.compile(args.filter_fonts)
fonts = [f for f in fonts if re_filter.search(f)]
ttfonts = [
TTFont(f) for f in fonts
if f.endswith((".ttf", ".otf")) and "static" not in f
]
family_name = family_name_from_fonts(ttfonts)
family_on_gf = Google_Fonts_has_family(family_name)
# Retrieve fonts_before and store in out dir
fonts_before = None
if any([args.fonts_before, args.pull_request_before, args.github_dir_before]) or \
(args.googlefonts_before and family_on_gf):
fonts_before_dir = os.path.join(args.out, "fonts_before")
mkdir(fonts_before_dir, overwrite=False)
if args.fonts_before:
[shutil.copy(f, fonts_before_dir) for f in args.fonts_before]
fonts_before = args.fonts_before
elif args.pull_request_before:
fonts_before = download_files_in_github_pr(args.pull_request_before,
fonts_before_dir,
ignore_static_dir=False)
elif args.github_dir_before:
fonts_before = download_files_in_github_dir(args.github_dir_before,
fonts_before_dir)
elif args.googlefonts_before and family_on_gf:
fonts_before = download_family_from_Google_Fonts(
family_name, fonts_before_dir)
if fonts_before:
ttfonts_before = [
TTFont(f) for f in fonts_before
if f.endswith((".ttf", ".otf")) and "static" not in f
]
qa = FontQA(ttfonts, ttfonts_before, args.out)
else:
qa = FontQA(ttfonts, out=args.out)
if args.auto_qa and family_on_gf:
qa.googlefonts_upgrade()
elif args.auto_qa and not family_on_gf:
qa.googlefonts_new()
if args.plot_glyphs:
qa.plot_glyphs()
if args.browser_previews:
qa.browser_previews()
if args.fontbakery:
qa.fontbakery()
if args.diffenator:
qa.diffenator()
if args.diffbrowsers:
qa.diffbrowsers()
if args.out_url:
qa.post_to_github(args.out_url)
elif args.out_github and args.pull_request:
qa.post_to_github(args.pull_request)
elif args.out_github and args.github_dir:
qa.post_to_github(args.github_dir)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("fonts", nargs="+")
before_group = parser.add_argument_group(title="Fonts before input")
before_input_group = before_group.add_mutually_exclusive_group(
required=False)
before_input_group.add_argument('-fb',
'--fonts-before',
nargs="+",
help="Fonts before paths")
before_input_group.add_argument(
'-gf',
'--from-googlefonts',
action='store_true',
help="Diff against GoogleFonts instead of fonts_before")
parser.add_argument("-o", "--out", default="out")
parser.add_argument("-a",
"--auto-qa",
action="store_true",
help="Determine which QA tools to run for fonts")
parser.add_argument("--diffenator",
action="store_true",
help="Run Fontdiffenator")
parser.add_argument("--diffbrowsers",
action="store_true",
help="Run diffbrowsers")
parser.add_argument("--fontbakery",
action="store_true",
help="Run FontBakery")
parser.add_argument(
"--plot-glyphs",
action="store_true",
help="Gen images of full charset, useful for new familes")
parser.add_argument(
"--browser-previews",
action="store_true",
help="Gen images on diff platforms, useful for new families")
parser.add_argument("-dm",
"--diff-mode",
choices=("weak", "normal", "strict"),
default="normal")
parser.add_argument("-l",
"--gfr-is-local",
action="store_true",
default=False)
parser.add_argument("-rd",
"--render-diffs",
action="store_true",
default=False)
args = parser.parse_args()
mkdir(args.out, overwrite=False)
fonts_to_check = args.fonts
fonts_previous = any([args.fonts_before, args.from_googlefonts])
if args.gfr_is_local:
gfr_url = "http://0.0.0.0:5000"
else:
# This instance of GFR can only view waterfalls and all glyphs views.
# To view font diffs in a browser, run GFR locally. This script gens
# font diffs using diffenator's to_gifs method, which relies on the
# free rendering stack.
gfr_url = "http://35.188.158.120/"
bstack_credentials = get_bstack_credentials()
fonts_to_check_ttfonts = [TTFont(f) for f in fonts_to_check]
family_name = family_name_from_fonts(fonts_to_check_ttfonts)
if fonts_previous:
if args.from_googlefonts:
fonts_before = download_family_from_Google_Fonts(
family_name, tempfile.mkdtemp())
else:
fonts_before = args.fonts_before
# auto-qa
family_on_gf = Google_Fonts_has_family(family_name)
if args.auto_qa and family_on_gf:
logging.info("Family exists on GF. Running regression checks")
fonts_before = download_family_from_Google_Fonts(
family_name, tempfile.mkdtemp())
fb_out_dir = os.path.join(args.out, "Fontbakery")
mkdir(fb_out_dir)
run_fontbakery(fonts_to_check, fb_out_dir)
diff_out_dir = os.path.join(args.out, "Diffenator")
mkdir(diff_out_dir)
run_diffenator(fonts_before,
fonts_to_check,
diff_out_dir,
thresholds=DIFFENATOR_THRESHOLDS[args.diff_mode])
if not bstack_credentials:
logger.warning(("Skipping Diffbrowsers. No browserstack "
"credentials found. See diffbrowsers readme"))
else:
browser_out_dir = os.path.join(args.out, "Diffbrowsers")
mkdir(browser_out_dir)
run_diffbrowsers(fonts_before,
fonts_to_check,
browser_out_dir,
bstack_credentials,
args.gfr_is_local,
gfr_url=gfr_url)
return
elif args.auto_qa and not family_on_gf:
logging.info(("Family does not exist on GF. Running plot_glyphs and "
"browser_previews"))
fb_out_dir = os.path.join(args.out, "Fontbakery")
mkdir(fb_out_dir)
run_fontbakery(fonts_to_check, fb_out_dir)
glyphs_out_dir = os.path.join(args.out, "Plot_Glyphs")
mkdir(glyphs_out_dir)
run_plot_glyphs(fonts_to_check, glyphs_out_dir)
if not bstack_credentials:
logger.warning(("Skipping Browser Previews. No browserstack "
"credentials found. See diffbrowsers readme"))
else:
browser_out_dir = os.path.join(args.out, "Browser_Previews")
mkdir(browser_out_dir)
run_browser_previews(fonts_to_check,
browser_out_dir,
bstack_credentials,
args.gfr_is_local,
gfr_url=gfr_url)
return
# Run FB
if args.fontbakery:
fb_out_dir = os.path.join(args.out, "Fontbakery")
mkdir(fb_out_dir)
run_fontbakery(fonts_to_check, fb_out_dir)
else:
logger.info("Skipping fontbakery")
# Font Diffenator
if args.diffenator and fonts_previous:
diff_out_dir = os.path.join(args.out, "Diffenator")
mkdir(diff_out_dir)
run_diffenator(fonts_before,
fonts_to_check,
diff_out_dir,
thresholds=DIFFENATOR_THRESHOLDS[args.diff_mode])
else:
logger.info("Skipping diffenator")
# Run DiffBrowsers
if all([args.diffbrowsers, fonts_previous, bstack_credentials]):
browser_out_dir = os.path.join(args.out, "Diffbrowsers")
mkdir(browser_out_dir)
run_diffbrowsers(fonts_before,
fonts_to_check,
browser_out_dir,
bstack_credentials,
args.gfr_is_local,
gfr_url=gfr_url)
elif args.diffbrowsers and not bstack_credentials:
logger.warning(("Skipping Diffbrowsers. No browserstack credentials "
"found. See diffbrowsers readme"))
else:
logger.info("Skipping Diffbrowsers")
# Plot Glyphs
if args.plot_glyphs:
glyphs_out_dir = os.path.join(args.out, "Plot_Glyphs")
mkdir(glyphs_out_dir)
run_plot_glyphs(fonts_to_check, glyphs_out_dir)
else:
logger.info("Skipping Glyphs plot")
# Browser Previews
if args.browser_previews and bstack_credentials:
browser_out_dir = os.path.join(args.out, "Browser_Previews")
mkdir(browser_out_dir)
run_browser_previews(fonts_to_check,
browser_out_dir,
bstack_credentials,
args.gfr_is_local,
gfr_url=gfr_url)
elif args.browser_previews and not bstack_credentials:
logger.warning(
("Skipping Browser Previews. No browserstack credentials "
"found. See diffbrowsers readme"))
else:
logger.info("Skipping browser_previews")