Font catalog

README.md

@@ -0,0 +1 @@
+# Font

catalog.db

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:14784001628833d8e462d8f092feb6991815c684653408ad22ec81d00a6d391b
+size 79814656

catalog.db.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e4fb7b2dd84d78eb81b77adafd2d63a2bc635762e904c51e96e2068ad89b5c79
+size 23732907

catalog.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fd41ee0a5295ec6aa66d17964616475d12eaa2c06ffff8e6b134356620831d33
+size 126628208

catalog_manifest.json

@@ -0,0 +1,22 @@
+{
+  "schema_version": 1,
+  "title": "Font",
+  "kind": "font",
+  "repository": "Visecall/font",
+  "asset_revision": "8179534f88e816963ac8dfd46e1eb7a66b8d0f76",
+  "asset_base_url": "https://huggingface.co/datasets/Visecall/font/resolve/8179534f88e816963ac8dfd46e1eb7a66b8d0f76/",
+  "fonts": 6275,
+  "files": 2635,
+  "faces": 2635,
+  "scalable": 6257,
+  "path_fonts": 1,
+  "atlas_fonts": 17,
+  "bytes": 3476269890,
+  "catalog_bytes": 79814656,
+  "catalog_sha256": "14784001628833d8e462d8f092feb6991815c684653408ad22ec81d00a6d391b",
+  "compressed_catalog": {
+    "bytes": 23732907,
+    "sha256": "e4fb7b2dd84d78eb81b77adafd2d63a2bc635762e904c51e96e2068ad89b5c79",
+    "url": "https://huggingface.co/datasets/Visecall/font/resolve/main/catalog.db.gz"
+  }
+}

catalog_schema.sql

@@ -0,0 +1,18 @@
+
+PRAGMA foreign_keys=ON;
+CREATE TABLE meta(key TEXT PRIMARY KEY,value TEXT NOT NULL);
+CREATE TABLE files(sha256 TEXT PRIMARY KEY,path TEXT NOT NULL,format TEXT NOT NULL,bytes INTEGER NOT NULL,
+ download_url TEXT NOT NULL,metadata_json TEXT NOT NULL);
+CREATE TABLE fonts(id TEXT PRIMARY KEY,name TEXT NOT NULL,family TEXT NOT NULL,style TEXT NOT NULL,
+ weight INTEGER NOT NULL,italic INTEGER NOT NULL,kind TEXT NOT NULL,position INTEGER NOT NULL,
+ primary_file TEXT NOT NULL REFERENCES files(sha256),primary_face INTEGER NOT NULL,metadata_json TEXT NOT NULL);
+CREATE TABLE font_files(font_id TEXT REFERENCES fonts(id),sha256 TEXT REFERENCES files(sha256),
+ position INTEGER NOT NULL,PRIMARY KEY(font_id,sha256));
+CREATE TABLE faces(sha256 TEXT REFERENCES files(sha256),face_index INTEGER NOT NULL,family TEXT NOT NULL,
+ style TEXT NOT NULL,weight INTEGER NOT NULL,italic INTEGER NOT NULL,glyphs INTEGER NOT NULL,
+ languages_json TEXT NOT NULL,unicode_ranges_json TEXT NOT NULL,metadata_json TEXT NOT NULL,
+ PRIMARY KEY(sha256,face_index));
+CREATE INDEX font_names ON fonts(name COLLATE NOCASE);
+CREATE INDEX font_families ON fonts(family COLLATE NOCASE,weight,italic);
+CREATE VIEW available_fonts AS SELECT fonts.*,files.download_url,files.format,files.bytes,files.sha256
+ FROM fonts JOIN files ON files.sha256=fonts.primary_file;

download_font.py

@@ -0,0 +1,152 @@
+"""Download a Font catalog item with SHA-256 verification."""
+from __future__ import annotations
+
+import argparse
+import gzip
+import hashlib
+import json
+from pathlib import Path, PurePosixPath
+import re
+import shutil
+import sqlite3
+import time
+from urllib.request import Request, urlopen
+import uuid
+import zipfile
+
+REPO = 'Visecall/font'
+BASE = f'https://huggingface.co/datasets/{REPO}/resolve/'
+
+
+def digest(path):
+    h = hashlib.sha256()
+    with path.open('rb') as stream:
+        for chunk in iter(lambda: stream.read(1024 * 1024), b''):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def download(url, target, sha=None, size=None):
+    if not url.startswith(BASE):
+        raise ValueError('URL outside the Font repository')
+    if sha is not None and not re.fullmatch('[0-9a-f]{64}', sha):
+        raise ValueError('Invalid SHA-256')
+    if target.is_file() and sha and target.stat().st_size == size and digest(target) == sha:
+        return target
+    target.parent.mkdir(parents=True, exist_ok=True)
+    temporary = target.with_name(target.name + '.' + uuid.uuid4().hex + '.part')
+    try:
+        for attempt in range(4):
+            try:
+                with urlopen(Request(url, headers={'User-Agent': 'Font-Catalog/1'}), timeout=120) as source, temporary.open('wb') as sink:
+                    shutil.copyfileobj(source, sink, 1024 * 1024)
+                if size is not None and temporary.stat().st_size != size:
+                    raise ValueError('Font size mismatch')
+                if sha and digest(temporary) != sha:
+                    raise ValueError('Font SHA-256 mismatch')
+                temporary.replace(target)
+                return target
+            except Exception:
+                if attempt == 3:
+                    raise
+                time.sleep(attempt + 1)
+    finally:
+        temporary.unlink(missing_ok=True)
+
+
+def refresh_catalog(output):
+    manifest = output / 'catalog_manifest.json'
+    download(BASE + 'main/catalog_manifest.json', manifest)
+    value = json.loads(manifest.read_text(encoding='utf-8'))
+    if value['schema_version'] != 1 or value['kind'] != 'font' or value['repository'] != REPO:
+        raise ValueError('Expected Font catalog version 1')
+    catalog = output / ('catalog-' + value['catalog_sha256'] + '.db')
+    if catalog.is_file() and digest(catalog) == value['catalog_sha256']:
+        return catalog
+    info = value['compressed_catalog']
+    archive = download(info['url'], output / 'catalog.db.gz', info['sha256'], info['bytes'])
+    temporary = catalog.with_suffix('.pending')
+    try:
+        with gzip.open(archive, 'rb') as source, temporary.open('wb') as sink:
+            shutil.copyfileobj(source, sink)
+        if temporary.stat().st_size != value['catalog_bytes'] or digest(temporary) != value['catalog_sha256']:
+            raise ValueError('Expanded Font catalog checksum mismatch')
+        temporary.replace(catalog)
+    finally:
+        temporary.unlink(missing_ok=True)
+    return catalog
+
+
+def install(font_id, catalog, output):
+    db = sqlite3.connect(catalog.resolve().as_uri() + '?mode=ro', uri=True)
+    try:
+        meta = dict(db.execute('SELECT key,value FROM meta'))
+        if meta['schema_version'] != '1' or meta['kind'] != 'font' or meta['repository'] != REPO:
+            raise ValueError('Expected Font catalog version 1')
+        row = db.execute('SELECT metadata_json FROM fonts WHERE id=?', (font_id,)).fetchone()
+        if row is None:
+            raise ValueError('Unknown font ID')
+        font = json.loads(row[0])
+        paths, roots = [], []
+        for sha in font['files']:
+            row = db.execute('SELECT path,bytes,download_url FROM files WHERE sha256=?', (sha,)).fetchone()
+            rel, size, url = row
+            parts = PurePosixPath(rel).parts
+            if (not parts or '\\' in rel or ':' in rel or rel.startswith('/')
+                    or any(p in ('', '.', '..') for p in rel.split('/'))):
+                raise ValueError('Unsafe font path')
+            target = output.joinpath(*parts)
+            paths.append(download(url, target, sha, size).resolve().as_posix())
+            if font['kind'] == 'atlas':
+                roots.append(install_atlas(target, output / 'assets' / sha, sha).resolve().as_posix())
+        return dict(id=font_id, name=font['name'], family=font['family'], kind=font['kind'], files=paths, asset_roots=roots)
+    finally:
+        db.close()
+
+
+def install_atlas(archive, destination, sha):
+    marker = destination / '.font-installed.json'
+    if marker.is_file() and json.loads(marker.read_text(encoding='utf-8')).get('sha256') == sha:
+        return destination
+    if destination.exists():
+        raise FileExistsError('Incomplete font destination: ' + str(destination))
+    staging = destination.with_name(destination.name[:16] + '.' + uuid.uuid4().hex[:12] + '.installing')
+    staging.mkdir(parents=True)
+    try:
+        with zipfile.ZipFile(archive) as z:
+            if len(z.infolist()) > 10000 or sum(i.file_size for i in z.infolist()) > 1024**3:
+                raise ValueError('Font atlas exceeds extraction limits')
+            seen = set()
+            for info in z.infolist():
+                name = info.filename
+                parts = name.split('/')
+                if (not name or name.startswith('/') or '\\' in name or ':' in name
+                        or any(p in ('', '.', '..') or p.endswith((' ', '.')) for p in parts)
+                        or name.casefold() in seen or ((info.external_attr >> 16) & 0o170000) == 0o120000):
+                    raise ValueError('Unsafe font atlas member')
+                seen.add(name.casefold())
+                target = staging.joinpath(*parts)
+                target.parent.mkdir(parents=True, exist_ok=True)
+                with z.open(info) as source, target.open('xb') as sink:
+                    shutil.copyfileobj(source, sink)
+        if json.loads((staging / 'content.json').read_text(encoding='utf-8'))['type'] != 'preRenderedFont':
+            raise ValueError('Invalid font atlas')
+        (staging / marker.name).write_text(json.dumps({'sha256': sha}), encoding='utf-8')
+        staging.replace(destination)
+        return destination
+    finally:
+        if staging.exists():
+            shutil.rmtree(staging)
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('id')
+    parser.add_argument('--output', type=Path, default=Path('Fonts'))
+    parser.add_argument('--catalog', type=Path)
+    args = parser.parse_args()
+    if not re.fullmatch('[0-9]{1,32}', args.id):
+        parser.error('Invalid font ID')
+    args.output.mkdir(parents=True, exist_ok=True)
+    catalog = args.catalog or refresh_catalog(args.output)
+    print(json.dumps(install(args.id, catalog, args.output), ensure_ascii=False))