Add sign-in with Hugging Face and publish-to-my-account with a provenance card

README.md

@@ -6,6 +6,10 @@ colorTo: pink
 sdk: docker
 app_port: 7860
 pinned: false
+hf_oauth: true
+hf_oauth_scopes:
+  - contribute-repos
+hf_oauth_expiration_minutes: 120
 short_description: Describe a dataset in plain words, get training rows back.
 ---
 

app/main.py

@@ -1,20 +1,25 @@
 """DataInventor: an open-source recreation of the Invent a Dataset workflow. Bring any OpenAI-compatible endpoint."""
 from __future__ import annotations
 
+import base64
 import csv
 import io
 import json
 import os
+import secrets
 import threading
+import urllib.parse
+import urllib.request
 import time
 import uuid
 from pathlib import Path
 
-from fastapi import FastAPI, HTTPException
-from fastapi.responses import FileResponse, JSONResponse, Response
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import FileResponse, JSONResponse, RedirectResponse, Response
 from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel
 
+from publish import LICENSES, publish as hub_publish, slug
 from engine import HF_BASE, HF_MODEL, Endpoint, EndpointError, Job, make_blueprint, run_job, stats
 
 ROOT = Path(__file__).resolve().parent.parent
@@ -104,7 +109,7 @@ def status(jid: str, since: int = 0):
     with j.lock:
         rows = list(j.rows)
         out = {"id": j.id, "state": j.state, "message": j.message, "target": j.target, "count": len(rows), "attempts": j.attempts,
-               "rejected": dict(j.rejected), "elapsed": round((j.finished or time.time()) - j.started, 1), "new_rows": rows[since:since + 50]}
+               "rejected": dict(j.rejected), "config": {k: j.config.get(k) for k in ("format", "request", "domains", "languages", "constraints", "rows")}, "slug": slug(j.config.get("request", "")), "elapsed": round((j.finished or time.time()) - j.started, 1), "new_rows": rows[since:since + 50]}
     if j.state in ("done", "stopped", "failed"):
         out["stats"] = stats(rows)
         out["blueprint"] = j.blueprint
@@ -138,6 +143,119 @@ def download(jid: str, format: str = "csv"):
     return Response(buf.getvalue().encode("utf-8-sig"), media_type="text/csv", headers={"Content-Disposition": f'attachment; filename="{name}.csv"'})
 
 
+
+# ---------------------------------------------------------------- sign in with Hugging Face (publishing)
+OAUTH_ID = os.environ.get("OAUTH_CLIENT_ID", "")
+OAUTH_SECRET = os.environ.get("OAUTH_CLIENT_SECRET", "")
+OAUTH_URL = os.environ.get("OPENID_PROVIDER_URL", "https://huggingface.co").rstrip("/")
+SPACE_HOST = os.environ.get("SPACE_HOST", "")
+DEV_TOKEN = os.environ.get("DI_DEV_USER_TOKEN", "")  # local testing only
+SESSIONS: dict[str, dict] = {}
+PUBLISHES: dict[str, list] = {}
+SESSION_SECONDS = 2 * 3600
+
+
+def current_session(request: Request) -> dict | None:
+    sid = request.cookies.get("di_sid")
+    s = SESSIONS.get(sid or "")
+    if s and s["exp"] > time.time():
+        return s
+    if DEV_TOKEN:
+        from huggingface_hub import HfApi
+        return {"user": HfApi(token=DEV_TOKEN).whoami()["name"], "token": DEV_TOKEN, "exp": time.time() + 600, "sid": "dev"}
+    return None
+
+
+def redirect_uri() -> str:
+    return f"https://{SPACE_HOST}/oauth/callback"
+
+
+@app.get("/api/me")
+def me(request: Request):
+    s = current_session(request)
+    return {"user": s["user"] if s else None, "can_sign_in": bool(OAUTH_ID and SPACE_HOST) or bool(DEV_TOKEN), "host": SPACE_HOST}
+
+
+@app.get("/oauth/login")
+def login(job: str = ""):
+    if not (OAUTH_ID and SPACE_HOST):
+        raise HTTPException(404, "Sign-in is not available on this host.")
+    state = secrets.token_urlsafe(24)
+    q = urllib.parse.urlencode({"client_id": OAUTH_ID, "redirect_uri": redirect_uri(), "response_type": "code", "scope": "openid profile contribute-repos", "state": state})
+    resp = RedirectResponse(f"{OAUTH_URL}/oauth/authorize?{q}")
+    resp.set_cookie("di_state", state + "|" + (job if job.isalnum() else ""), max_age=600, httponly=True, secure=True, samesite="lax")
+    return resp
+
+
+@app.get("/oauth/callback")
+def callback(request: Request, code: str = "", state: str = "", error: str = ""):
+    saved = request.cookies.get("di_state", "")
+    want, _, job = saved.partition("|")
+    if error or not code or not want or not secrets.compare_digest(want, state):
+        return RedirectResponse("/?signin=failed")
+    basic = base64.b64encode(f"{OAUTH_ID}:{OAUTH_SECRET}".encode()).decode()
+    try:
+        data = urllib.parse.urlencode({"grant_type": "authorization_code", "code": code, "redirect_uri": redirect_uri(), "client_id": OAUTH_ID}).encode()
+        tok = json.load(urllib.request.urlopen(urllib.request.Request(f"{OAUTH_URL}/oauth/token", data, {"Authorization": "Basic " + basic, "Content-Type": "application/x-www-form-urlencoded"}), timeout=30))
+        info = json.load(urllib.request.urlopen(urllib.request.Request(f"{OAUTH_URL}/oauth/userinfo", headers={"Authorization": "Bearer " + tok["access_token"]}), timeout=30))
+    except Exception:
+        return RedirectResponse("/?signin=failed")
+    sid = secrets.token_urlsafe(24)
+    SESSIONS[sid] = {"user": info.get("preferred_username") or info.get("name"), "token": tok["access_token"], "exp": time.time() + SESSION_SECONDS, "sid": sid}
+    for k in [k for k, v in SESSIONS.items() if v["exp"] < time.time()]:
+        SESSIONS.pop(k, None)
+    resp = RedirectResponse("/?signin=ok" + (f"&job={job}" if job else ""))
+    resp.set_cookie("di_sid", sid, max_age=SESSION_SECONDS, httponly=True, secure=True, samesite="lax")
+    resp.delete_cookie("di_state")
+    return resp
+
+
+@app.post("/api/signout")
+def signout(request: Request):
+    SESSIONS.pop(request.cookies.get("di_sid", ""), None)
+    resp = JSONResponse({"ok": True})
+    resp.delete_cookie("di_sid")
+    return resp
+
+
+class PublishIn(BaseModel):
+    name: str
+    private: bool = True
+    license: str = "apache-2.0"
+    confirm: bool = False
+
+
+@app.post("/api/jobs/{jid}/publish")
+def publish(jid: str, body: PublishIn, request: Request):
+    s = current_session(request)
+    if not s:
+        raise HTTPException(401, "Sign in with Hugging Face to publish.")
+    if not body.confirm:
+        raise HTTPException(400, "Confirm that you have the right to publish this data.")
+    if body.license not in LICENSES:
+        raise HTTPException(400, "Choose one of the offered licenses.")
+    j = get_job(jid)
+    if j.state not in ("done", "stopped") or not j.rows:
+        raise HTTPException(400, "Wait for the run to finish, or stop it, before publishing.")
+    now = time.time()
+    recent = [t for t in PUBLISHES.get(s["user"], []) if now - t < 3600]
+    if len(recent) >= 5:
+        raise HTTPException(429, "You have published five datasets in the last hour. Try again later.")
+    try:
+        url = hub_publish(s["token"], s["user"], body.name.strip(), body.private, body.license, j.config, list(j.rows), stats(list(j.rows)), ENDPOINTS[jid].model if jid in ENDPOINTS else "")
+    except ValueError as e:
+        raise HTTPException(400, str(e))
+    except Exception as e:
+        msg = str(e)
+        if "409" in msg or "already" in msg.lower():
+            raise HTTPException(409, "You already have a dataset with that name. Pick another name.")
+        if "403" in msg or "401" in msg:
+            raise HTTPException(403, "Hugging Face refused the request. Sign in again and allow DataInventor to create datasets.")
+        raise HTTPException(502, "Publishing failed. Try again in a moment.")
+    PUBLISHES[s["user"]] = recent + [now]
+    return {"url": url}
+
+
 @app.get("/")
 def index():
     return FileResponse(STATIC / "index.html")

app/publish.py

@@ -0,0 +1,106 @@
+"""Publish a finished run to the user's own Hugging Face account, with a provenance card."""
+from __future__ import annotations
+
+import io
+import json
+import re
+
+from huggingface_hub import HfApi
+
+SPACE_URL = "https://huggingface.co/spaces/LocalLLaMA/data-inventor"
+LICENSES = {"apache-2.0", "cc-by-4.0", "cc-by-sa-4.0", "mit", "cc0-1.0"}
+
+
+def slug(text: str, fallback: str = "dataset") -> str:
+    s = re.sub(r"[^a-z0-9]+", "-", text.lower()).strip("-")[:48].strip("-")
+    return s or fallback
+
+
+def valid_name(name: str) -> bool:
+    return bool(re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9._-]{1,90}", name))
+
+
+def rows_to_jsonl(rows: list, pref: bool) -> bytes:
+    cols = ["prompt", "chosen", "rejected"] if pref else ["prompt", "completion"]
+    meta = ["area", "subtopic", "topic", "persona", "shape", "difficulty", "language"]
+    return ("\n".join(json.dumps({k: r.get(k) for k in cols + meta}, ensure_ascii=False) for r in rows) + "\n").encode()
+
+
+def size_category(n: int) -> str:
+    return "n<1K" if n < 1000 else "1K<n<10K"
+
+
+def dataset_card(cfg: dict, stats: dict, model: str, license_id: str, user: str, n: int) -> str:
+    pref = cfg.get("format") == "preference"
+    langs = cfg.get("languages") or ["English"]
+    domains = ", ".join(cfg.get("domains") or []) or "chosen by the description"
+    cols = "`prompt`, `chosen`, `rejected`" if pref else "`prompt`, `completion`"
+    constraints = (cfg.get("constraints") or "").strip()
+    return f"""---
+license: {license_id}
+task_categories:
+- text-generation
+tags:
+- synthetic
+- datainventor
+size_categories:
+- {size_category(n)}
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train.jsonl
+---
+
+# Synthetic dataset built with DataInventor
+
+This dataset was generated with [DataInventor]({SPACE_URL}), an open-source recreation of the Invent a Dataset workflow. Every row was written by a language model. Nothing in it comes from real people, and nothing in it has been checked by a human.
+
+## What it contains
+
+- **Request:** {cfg.get("request", "").strip()}
+- **Format:** {"preference pairs (a prompt with a chosen and a rejected reply, ranked by the model)" if pref else "instruction pairs (a prompt and a reply)"}
+- **Columns:** {cols}, plus `area`, `subtopic`, `topic`, `persona`, `shape`, `difficulty` and `language` describing how each row was planned
+- **Domains:** {domains}
+- **Languages:** {", ".join(langs)}
+- **Rows:** {n:,}
+{f"- **Rules every row had to follow:** {constraints}" + chr(10) if constraints else ""}
+## How it was made
+
+1. A blueprint was drafted from the request: topics, who asks, who answers, and the shapes a question can take.
+2. Unique combinations of topic, persona, shape, difficulty, length and language were sampled.
+3. For each combination the model wrote one message, then the reply{" (two replies, then a ranking)" if pref else ""}.
+4. Rows were rejected for cut-off or degenerate text, for asking for many items at once, and for near-duplicate questions.
+
+Model: `{model}`, served through Hugging Face Inference Providers.
+
+## Quick numbers
+
+- Distinct 3-grams in prompts: {stats.get("distinct3_prompts", "n/a")}
+- Average words per prompt: {stats.get("avg_prompt_words", "n/a")}
+- Average words per reply: {stats.get("avg_answer_words", "n/a")}
+
+## Limits
+
+- Replies can contain errors and invented facts. Check them before you train on this data or rely on it.
+- Synthetic data repeats the habits and blind spots of the model that wrote it.
+- {"The ranking of chosen against rejected comes from the same model, so it reflects that model's taste." if pref else "Questions may be less varied than real user messages."}
+
+Published by @{user} through DataInventor. The data is shared under the license above.
+"""
+
+
+def publish(token: str, user: str, name: str, private: bool, license_id: str, cfg: dict, rows: list, stats: dict, model: str) -> str:
+    if not valid_name(name):
+        raise ValueError("Use letters, numbers, dots, dashes or underscores for the dataset name.")
+    if license_id not in LICENSES:
+        raise ValueError("Choose one of the offered licenses.")
+    pref = "chosen" in rows[0]
+    repo = f"{user}/{name}"
+    api = HfApi(token=token)
+    api.create_repo(repo, repo_type="dataset", private=private, exist_ok=False)
+    api.upload_file(path_or_fileobj=io.BytesIO(rows_to_jsonl(rows, pref)), path_in_repo="data/train.jsonl", repo_id=repo, repo_type="dataset",
+                    commit_message="Add rows generated with DataInventor")
+    api.upload_file(path_or_fileobj=io.BytesIO(dataset_card(cfg, stats, model, license_id, user, len(rows)).encode()), path_in_repo="README.md",
+                    repo_id=repo, repo_type="dataset", commit_message="Add dataset card")
+    return f"https://huggingface.co/datasets/{repo}"

requirements.txt

@@ -1,3 +1,4 @@
 fastapi==0.115.*
 uvicorn[standard]==0.32.*
 pydantic>=2.7
+huggingface_hub>=0.30

static/app.js

@@ -11,7 +11,7 @@ const FORMATS = {
 
 const S = {
   step: 0, maxStep: 0, format: "instruction", domains: [], subs: {}, languages: ["English"], request: "", constraints: "", rows: 50,
-  blueprint: null, bpBusy: false, bpError: "", model: "", job: null, jobRows: [], jobState: null, drawn: 0, printed: 0, maxRows: 200, domainData: [], runError: "",
+  blueprint: null, bpBusy: false, bpError: "", model: "", job: null, me: null, pub: { name: "", priv: true, license: "apache-2.0", ok: false, busy: false, err: "", url: "" }, jobRows: [], jobState: null, drawn: 0, printed: 0, pubShown: false, maxRows: 200, domainData: [], runError: "",
 };
 const $ = (s, el = document) => el.querySelector(s);
 const esc = (t) => String(t ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c]));
@@ -123,6 +123,42 @@ function stepReview() {
   <p class="note">About <b>${e.calls.toLocaleString()}</b> model calls and <b>${e.time}</b>. Rows that fail the quality checks are rewritten, so a run can take a little longer.</p>
   <div class="actions"><button class="btn" data-act="back">Back</button><button class="btn go" data-act="next">Start writing</button></div>`;
 }
+function publishHtml() {
+  const j = S.jobState; if (!isFinal(j) || !j.count) return "";
+  const p = S.pub, me = S.me || {};
+  if (p.url) return `<div class="group"><h3>Published</h3><p class="note ok">Your dataset is on Hugging Face${p.priv ? " as a private dataset" : ""}. <a href="${esc(p.url)}" target="_blank" rel="noopener">Open it</a>.</p></div>`;
+  const head = `<h3>Publish to your Hugging Face account</h3>`;
+  if (!me.user) {
+    if (!me.can_sign_in) return `<div class="group">${head}<p class="hint">Publishing works on the hosted app. Download the CSV or JSONL instead.</p></div>`;
+    const embedded = window.top !== window.self, href = embedded && me.host ? `https://${me.host}/oauth/login?job=${j.id}` : `/oauth/login?job=${j.id}`;
+    return `<div class="group">${head}<p class="hint" style="max-width:60ch">Sign in to save this dataset to your own account, with a card that says how it was made. DataInventor can only create datasets for you. It cannot see your other repos. It is private unless you choose public.</p>
+      <div class="actions" style="margin-top:12px"><a class="btn go" href="${esc(href)}" ${embedded ? 'target="_blank" rel="noopener"' : ""} style="text-decoration:none">Sign in with Hugging Face</a></div>${embedded ? '<p class="hint" style="margin-top:8px">Sign-in opens in its own tab because browsers block it inside an embedded page.</p>' : ""}</div>`;
+  }
+  if (!p.name) p.name = "datainventor-" + (j.slug || "dataset");
+  return `<div class="group">${head}<p class="hint">Signed in as <b>${esc(me.user)}</b>. <button class="linkish" data-act="signout">Sign out</button></p>
+    <div class="row2"><label class="f"><span>Dataset name</span><input class="in" id="pub-name" value="${esc(p.name)}" spellcheck="false"></label>
+      <label class="f"><span>Who can see it</span><select class="in" id="pub-private"><option value="1" ${p.priv ? "selected" : ""}>Only me (private)</option><option value="0" ${p.priv ? "" : "selected"}>Everyone (public)</option></select></label></div>
+    <label class="f" style="max-width:320px"><span>License</span><select class="in" id="pub-license">${["apache-2.0", "cc-by-4.0", "cc-by-sa-4.0", "mit", "cc0-1.0"].map((l) => `<option ${p.license === l ? "selected" : ""}>${l}</option>`).join("")}</select></label>
+    <label class="check"><input type="checkbox" id="pub-ok" ${p.ok ? "checked" : ""}><span>I have the right to publish this data. I understand it was written by a model and has not been checked by a person.</span></label>
+    ${p.err ? `<p class="note bad">${esc(p.err)}</p>` : ""}
+    <div class="actions"><button class="btn go" data-act="publish" ${p.busy ? "disabled" : ""}>${p.busy ? "Publishing" : "Publish dataset"}</button></div></div>`;
+}
+async function loadMe() { try { S.me = await api("/api/me"); } catch (e) { S.me = { user: null, can_sign_in: false }; } const el = document.getElementById("run-publish"); if (el) el.innerHTML = publishHtml(); }
+async function doPublish() {
+  S.pub.busy = true; S.pub.err = ""; refreshPublish();
+  try { const r = await api(`/api/jobs/${S.job}/publish`, { name: S.pub.name.trim(), private: S.pub.priv, license: S.pub.license, confirm: S.pub.ok }); S.pub.url = r.url; } catch (e) { S.pub.err = e.message; }
+  S.pub.busy = false; refreshPublish();
+}
+function refreshPublish() { const el = document.getElementById("run-publish"); if (el) el.innerHTML = publishHtml(); }
+async function restoreJob(id) {
+  try {
+    let since = 0, last = null; S.jobRows = [];
+    for (let k = 0; k < 8; k++) { last = await api(`/api/jobs/${id}?since=${since}`); S.jobRows.push(...last.new_rows); since = S.jobRows.length; if (since >= last.count) break; }
+    const c = last.config || {}; S.job = id; S.jobState = last; S.format = c.format || "instruction"; S.request = c.request || ""; S.domains = c.domains || []; S.languages = c.languages || ["English"]; S.constraints = c.constraints || ""; S.rows = c.rows || S.rows;
+    S.maxStep = 6; S.step = 6; S.printed = S.jobRows.length ? S.jobRows[S.jobRows.length - 1].id : 0; render();
+    if (!isFinal(last)) poll();
+  } catch (e) { /* the job is gone; start fresh */ }
+}
 const isFinal = (j) => j && ["done", "stopped", "failed"].includes(j.state);
 function rowHtml(r) {
   const pref = S.format === "preference";
@@ -156,7 +192,7 @@ function stepRun() {
   <div class="count" id="run-count" aria-live="polite">${h.count}</div>
   <div class="bar" role="progressbar" aria-valuemin="0" aria-valuemax="100" aria-valuenow="${h.pct}"><i id="run-bar" style="width:${h.pct}%"></i></div>
   <p class="state" id="run-state">${h.state}</p><div id="run-note">${h.note}</div>
-  <div class="actions" id="run-actions">${h.actions}</div><div id="run-stats">${h.stats}</div><div id="run-filtered">${h.filtered}</div>
+  <div class="actions" id="run-actions">${h.actions}</div><div id="run-stats">${h.stats}</div><div id="run-filtered">${h.filtered}</div><div id="run-publish">${publishHtml()}</div>
   <div class="press" id="run-deck" aria-hidden="true">${deckHtml()}</div>
   <div class="table" id="run-rows">${S.jobRows.slice().reverse().map(rowHtml).join("")}</div></div>`;
 }
@@ -164,6 +200,7 @@ function stepRun() {
 function updateRun() {
   const h = headParts(), set = (id, html) => { const el = document.getElementById(id); if (el && el.innerHTML !== html) el.innerHTML = html; };
   set("run-h2", h.h2); set("run-count", h.count); set("run-state", h.state); set("run-note", h.note); set("run-actions", h.actions); set("run-stats", h.stats); set("run-filtered", h.filtered);
+  if (isFinal(S.jobState) && !S.pubShown) { S.pubShown = true; loadMe(); }
   const bar = document.getElementById("run-bar"); if (bar) { bar.style.width = h.pct + "%"; bar.parentElement.setAttribute("aria-valuenow", h.pct); }
   const deck = document.getElementById("run-deck"); if (deck) deck.innerHTML = deckHtml();
   const rows = document.getElementById("run-rows");
@@ -191,11 +228,15 @@ document.addEventListener("click", async (ev) => {
   if (act === "back") return go(Math.max(0, S.step - 1));
   if (act === "suggest") { S.request = S.request.trim() ? S.request : $("[data-suggest]").dataset.suggest; return render(); }
   if (act === "blueprint") return doBlueprint();
+  if (act === "publish") return doPublish();
+  if (act === "signout") { await api("/api/signout", {}); S.me = { ...S.me, user: null }; return refreshPublish(); }
   if (act === "stop") { if (S.job) await api(`/api/jobs/${S.job}/stop`, {}); return; }
-  if (act === "again") { S.job = null; S.jobState = null; S.jobRows = []; S.drawn = 0; S.printed = 0; S.runError = ""; return go(4); }
+  if (act === "again") { S.job = null; S.jobState = null; S.jobRows = []; S.drawn = 0; S.printed = 0; S.pubShown = false; S.pub = { name: "", priv: true, license: "apache-2.0", ok: false, busy: false, err: "", url: "" }; S.runError = ""; return go(4); }
 });
+document.addEventListener("change", (ev) => { if (ev.target.id && ev.target.id.startsWith("pub-")) { const id = ev.target.id; if (id === "pub-private") S.pub.priv = ev.target.value === "1"; else if (id === "pub-license") S.pub.license = ev.target.value; else if (id === "pub-ok") S.pub.ok = ev.target.checked; } });
 document.addEventListener("input", (ev) => {
   const id = ev.target.id;
+  if (id === "pub-name") S.pub.name = ev.target.value; else if (id === "pub-private") S.pub.priv = ev.target.value === "1"; else if (id === "pub-license") S.pub.license = ev.target.value; else if (id === "pub-ok") S.pub.ok = ev.target.checked;
   if (id === "request") { S.request = ev.target.value; S.blueprint = null; const b = $('[data-act="next"]'); if (b) b.disabled = !S.request.trim(); const bp = $('[data-act="blueprint"]'); if (bp) bp.disabled = S.bpBusy || !S.request.trim(); }
   else if (id === "constraints") { S.constraints = ev.target.value; S.blueprint = null; }
 });
@@ -206,7 +247,7 @@ async function doBlueprint() {
   S.bpBusy = false; render();
 }
 async function startRun() {
-  S.runError = ""; S.jobRows = []; S.jobState = null; S.drawn = 0; S.printed = 0;
+  S.runError = ""; S.jobRows = []; S.jobState = null; S.drawn = 0; S.printed = 0; S.pubShown = false; S.pub = { name: "", priv: true, license: "apache-2.0", ok: false, busy: false, err: "", url: "" };
   try { const r = await api("/api/jobs", spec()); S.job = r.id; poll(); } catch (e) { S.runError = e.message; }
   render();
 }
@@ -228,5 +269,6 @@ go = function (i) { const wasReview = S.step === 5; _go(i); if (i === 6 && wasRe
 (async function init() {
   try { const d = await api("/api/defaults"); S.model = d.model; S.maxRows = d.max_rows; S.configured = d.configured; if (S.rows > S.maxRows) S.rows = S.maxRows;  } catch (e) { /* offline */ }
   try { S.domainData = await api("/api/domains"); } catch (e) { S.domainData = []; }
-  render();
+  const q = new URLSearchParams(location.search), jid = q.get("job");
+  if (jid) { await loadMe(); await restoreJob(jid); history.replaceState(null, "", "/"); } else render();
 })();