Files
alkane-benchmarks/ci/validate_site.py
T
noahandClaude Opus 5.5 35b96c493f Hand the toolkit benchmarks to the toolkit's own site
The toolkit repository is public and now publishes its own Pages site
(benchmarks, badges, quality dashboard), so this site covers only the
private SDK and OS.

- validate_site: drop the toolkit page; the index may link to the
  toolkit's bench page.
- check_live_pages: /alkane-toolkit/ and its bench page must be public;
  only the SDK and OS sites must stay closed.
- metrics: grade coverage on the toolkit's bands instead of a fixed
  green A.
- README: one CI badge plus the license; the script metrics no longer
  pose as SDK or OS metrics.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 11:03:55 -06:00

131 lines
5.1 KiB
Python

#!/usr/bin/env python3
"""Validate the generated public benchmark pages before publication."""
import argparse
from html.parser import HTMLParser
from pathlib import Path
import re
PAGES = ("index.html", "sdk/index.html", "os/index.html")
# The toolkit is public and publishes its own site; the index links to it.
TOOLKIT_SITE = "https://blueflare.gitea.bluefla.re/alkane-toolkit/bench/"
ALLOWED_TAGS = {"html", "head", "meta", "title", "style", "body", "h1",
"p", "a", "ul", "li", "div", "small", "table", "thead",
"tbody", "tr", "th", "td"}
ALLOWED_ATTRIBUTES = {"html": {"lang"}, "a": {"href"},
"div": {"class"}, "th": {"scope"}}
LOCAL_LINKS = {"sdk/", "os/", "../", TOOLKIT_SITE}
FORBIDDEN_TEXT = ("BEGIN PRIVATE KEY", "GITEA_TOKEN", "ghp_", "glpat-")
COMMIT_LINK = re.compile(
r"https://gitea\.bluefla\.re/blueflare/alkane-(?:sdk|os|toolkit)/commit/[0-9a-f]{40}"
)
class PageParser(HTMLParser):
def __init__(self):
super().__init__(convert_charrefs=True)
self.title = False
self.heading = False
self.tables = 0
self.links = set()
self.errors = []
self.in_style = False
def handle_starttag(self, tag, attrs):
if tag not in ALLOWED_TAGS:
self.errors.append(f"forbidden tag: {tag}")
if tag == "title":
self.title = True
if tag == "h1":
self.heading = True
if tag == "table":
self.tables += 1
if tag == "style":
self.in_style = True
names = [name for name, _ in attrs]
if len(names) != len(set(names)):
self.errors.append(f"duplicate attribute on {tag}")
if tag == "meta" and attrs not in (
[("charset", "utf-8")],
[("name", "viewport"), ("content", "width=device-width, initial-scale=1")],
):
self.errors.append("unexpected meta directive")
for name, value in attrs:
value = value or ""
if tag != "meta" and name not in ALLOWED_ATTRIBUTES.get(tag, set()):
self.errors.append(f"forbidden attribute on {tag}: {name}")
if tag == "a" and name == "href":
if value not in LOCAL_LINKS and not COMMIT_LINK.fullmatch(value):
self.errors.append(f"external or active reference: {value}")
self.links.add(value)
def handle_endtag(self, tag):
if tag == "style":
self.in_style = False
def handle_data(self, data):
if self.in_style and (re.search(r"url\s*\(|@import", data, re.IGNORECASE)
or "\\" in data):
self.errors.append("external CSS reference is not allowed")
def validate_page(path: Path, relative: str) -> list[str]:
if not path.is_file() or path.is_symlink():
return [f"{relative}: missing regular page"]
if path.stat().st_size > 2_000_000:
return [f"{relative}: page exceeds 2 MB"]
text = path.read_text(encoding="utf-8")
parser = PageParser()
parser.feed(text)
errors = [f"{relative}: {item}" for item in parser.errors]
if not text.lstrip().lower().startswith("<!doctype html>"):
errors.append(f"{relative}: missing HTML doctype")
if not parser.title or not parser.heading:
errors.append(f"{relative}: missing title or heading")
if any(token in text for token in FORBIDDEN_TEXT):
errors.append(f"{relative}: credential marker in public output")
if re.search(r"url\s*\(|@import", text, re.IGNORECASE):
errors.append(f"{relative}: external CSS reference is not allowed")
if relative == "index.html":
if not {"sdk/", "os/"}.issubset(parser.links):
errors.append("index.html: missing project links")
elif not parser.tables and "Waiting for a completed measured CI run." not in text:
errors.append(f"{relative}: no measurements or pending notice")
return errors
def validate(root: Path) -> list[str]:
if not root.is_dir() or root.is_symlink():
return ["site root is not a directory"]
paths = {p.relative_to(root).as_posix() for p in root.rglob("*") if p.is_file()}
errors = []
if any(p.is_symlink() for p in root.rglob("*")):
errors.append("published site contains a symlink")
for relative in PAGES:
errors.extend(validate_page(root / relative, relative))
unexpected = paths - set(PAGES)
if unexpected:
errors.append("unexpected published files: " + ", ".join(sorted(unexpected)))
return errors
def main() -> int:
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("site", type=Path)
parser.add_argument("--page", choices=("sdk", "os"),
help="validate one generated report before publication")
args = parser.parse_args()
errors = (validate_page(args.site, f"{args.page}/index.html")
if args.page else validate(args.site))
for error in errors:
print(error)
if errors:
return 1
print(f"Validated {args.page or len(PAGES)} public benchmark pages")
return 0
if __name__ == "__main__":
raise SystemExit(main())