blob: e36198e6571dfac085bf6761d28d61c2ad6c61a4 [file] [log] [blame]
# Copyright 2020 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Quick and dirty utility to download latest icon assets for github."""
from absl import app
from absl import flags
import icons
import json
from pathlib import Path
import re
import requests
import time
from typing import NamedTuple, Set, Sequence, Tuple
from zipfile import ZipFile
FLAGS = flags.FLAGS
flags.DEFINE_bool(
"skip_existing",
False,
"Do not download if local file exists, even if an update is available.",
)
flags.DEFINE_bool("fetch", True, "Whether we can attempt to download assets.")
flags.DEFINE_bool("explode_zip_files", True, "Whether to unzip any zip assets.")
flags.DEFINE_integer("icon_limit", 0, "If > 0, the max # of icons to process.")
_METADATA_URL = "http://fonts.google.com/metadata/icons?incomplete=1"
class Asset(NamedTuple):
src_url_pattern: str
dest_dir_pattern: str
class Fetch(NamedTuple):
src_url: str
dest_file: Path
class Icon(NamedTuple):
name: str
category: str
version: int
sizes_px: Tuple[int, ...]
stylistic_sets: Set[str]
_ICON_ASSETS = (
Asset(
"https://{host}/s/i/{stylistic_set_snake}/{icon.name}/v{icon.version}/{size_px}px.svg",
"src/{icon.category}/{icon.name}/{stylistic_set_snake}/{size_px}px.svg",
),
Asset(
"https://{host}/s/i/{stylistic_set_snake}/{icon.name}/v{icon.version}/black-android.zip",
"android/{icon.category}/{icon.name}/{stylistic_set_snake}/black.zip",
),
Asset(
"https://{host}/s/i/{stylistic_set_snake}/{icon.name}/v{icon.version}/black-ios.zip",
"ios/{icon.category}/{icon.name}/{stylistic_set_snake}/black.zip",
),
Asset(
"https://{host}/s/i/{stylistic_set_snake}/{icon.name}/v{icon.version}/black-18dp.zip",
"png/{icon.category}/{icon.name}/{stylistic_set_snake}/18dp.zip",
),
Asset(
"https://{host}/s/i/{stylistic_set_snake}/{icon.name}/v{icon.version}/black-24dp.zip",
"png/{icon.category}/{icon.name}/{stylistic_set_snake}/24dp.zip",
),
Asset(
"https://{host}/s/i/{stylistic_set_snake}/{icon.name}/v{icon.version}/black-36dp.zip",
"png/{icon.category}/{icon.name}/{stylistic_set_snake}/36dp.zip",
),
Asset(
"https://{host}/s/i/{stylistic_set_snake}/{icon.name}/v{icon.version}/black-48dp.zip",
"png/{icon.category}/{icon.name}/{stylistic_set_snake}/48dp.zip",
),
)
_SET_ASSETS = (
# Fonts are acquired by abusing the Google Fonts web api. Nobody tell them :D
Asset(
"https://fonts.googleapis.com/css2?family={stylistic_set_url}",
"font/{stylistic_set_font}.css",
),
)
def _latest_metadata():
resp = requests.get(_METADATA_URL)
resp.raise_for_status()
raw_json = resp.text[5:]
return json.loads(raw_json)
def _current_versions():
return Path("current_versions.json")
def _version_key(icon: Icon):
return f"{icon.category}::{icon.name}"
def _icons(metadata):
all_sets = set(metadata["families"])
for raw_icon in metadata["icons"]:
unsupported = set(raw_icon["unsupported_families"])
yield Icon(
raw_icon["name"],
raw_icon["categories"][0],
raw_icon["version"],
tuple(raw_icon["sizes_px"]),
all_sets - unsupported,
)
def _create_fetch(asset, args):
src_url = asset.src_url_pattern.format(**args)
dest_file = asset.dest_dir_pattern.format(**args)
dest_file = (Path(__file__) / "../.." / dest_file).resolve()
return Fetch(src_url, dest_file)
def _do_fetch(fetch):
resp = requests.get(fetch.src_url)
resp.raise_for_status()
fetch.dest_file.parent.mkdir(parents=True, exist_ok=True)
fetch.dest_file.write_bytes(resp.content)
def _do_fetches(fetches):
print(f"Starting {len(fetches)} fetches")
start_t = time.monotonic()
print_t = start_t
for idx, fetch in enumerate(fetches):
_do_fetch(fetch)
t = time.monotonic()
if t - print_t > 5:
print_t = t
est_complete = (t - start_t) * (len(fetches) / (idx + 1))
print(f"{idx}/{len(fetches)}, estimating {int(est_complete)}s left")
def _unzip_target(zip_path: Path):
return zip_path.parent.resolve() / zip_path.stem
def _explode_zip_files(zips: Sequence[Path]):
for zip_path in zips:
assert zip_path.suffix == ".zip", zip_path
if not zip_path.is_file():
continue
unzip_target = _unzip_target(zip_path)
print(f"Unzip {zip_path} => {unzip_target}")
with ZipFile(zip_path) as zip_file:
zip_file.extractall(unzip_target)
zip_path.unlink()
def _fetch_fonts(css_files: Sequence[Path]):
for css_file in css_files:
css = css_file.read_text()
url = re.search(r"src:\s+url\(([^)]+)\)", css).group(1)
assert url.endswith(".otf") or url.endswith(".ttf")
fetch = Fetch(url, css_file.parent / (css_file.stem + url[-4:]))
_do_fetch(fetch)
css_file.unlink()
with open(fetch.dest_file.with_suffix(".codepoints"), "w") as f:
for name, codepoint in sorted(icons.enumerate(fetch.dest_file)):
f.write(f"{name} {codepoint:04x}\n")
def _is_css(p: Path):
return p.suffix == ".css"
def _is_zip(p: Path):
return p.suffix == ".zip"
def _files(fetches: Sequence[Fetch], pred):
return [f.dest_file for f in fetches if pred(f.dest_file)]
def _should_skip(fetch: Fetch):
if not FLAGS.skip_existing:
return False
if _is_zip(fetch.dest_file):
return _unzip_target(fetch.dest_file).is_dir()
return fetch.dest_file.is_file()
def _pattern_args(metadata, stylistic_set):
return {
"host": metadata["host"],
"stylistic_set_snake": stylistic_set.replace(" ", "").lower(),
"stylistic_set_url": stylistic_set.replace(" ", "+"),
"stylistic_set_font": stylistic_set.replace(" ", "") + "-Regular",
}
def main(_):
current_versions = json.loads(_current_versions().read_text())
metadata = _latest_metadata()
stylistic_sets = tuple(metadata["families"])
fetches = []
skips = []
num_changed = 0
icons = tuple(_icons(metadata))
if FLAGS.icon_limit > 0:
icons = icons[: FLAGS.icon_limit]
for icon in icons:
ver_key = _version_key(icon)
if icon.version <= current_versions.get(ver_key, 0):
continue
current_versions[ver_key] = icon.version
num_changed += 1
for size_px in icon.sizes_px:
for stylistic_set in stylistic_sets:
if stylistic_set not in icon.stylistic_sets:
continue
pattern_args = _pattern_args(metadata, stylistic_set)
pattern_args["icon"] = icon
pattern_args["size_px"] = size_px
for asset in _ICON_ASSETS:
fetch = _create_fetch(asset, pattern_args)
if _should_skip(fetch):
skips.append(fetch)
else:
fetches.append(fetch)
for stylistic_set in stylistic_sets:
for asset in _SET_ASSETS:
pattern_args = _pattern_args(metadata, stylistic_set)
fetch = _create_fetch(asset, pattern_args)
fetches.append(fetch)
print(f"{num_changed}/{len(icons)} icons have changed")
if skips:
print(f"{len(skips)} fetches skipped because assets exist")
if fetches:
if FLAGS.fetch:
_do_fetches(fetches)
else:
print(f"fetch disabled; not fetching {len(fetches)} assets")
if FLAGS.explode_zip_files:
_explode_zip_files(_files(fetches + skips, _is_zip))
_fetch_fonts(_files(fetches + skips, _is_css))
with open(_current_versions(), "w") as f:
json.dump(current_versions, f, indent=4, sort_keys=True)
if __name__ == "__main__":
app.run(main)