Open Materials Challenge season 1 - solid-state electrolyte

Dockerfile

@@ -0,0 +1,12 @@
+# HF Spaces runs the container as a non-root user; write only under paths we own.
+FROM python:3.11-slim
+RUN useradd -m -u 1000 user
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+RUN mkdir -p /app/data && chown -R user:user /app
+USER user
+ENV OMC_LEDGER=/app/data/ledger.jsonl
+EXPOSE 7860
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,13 @@
 ---
 title: Open Materials Challenge
-emoji: 📉
-colorFrom: gray
-colorTo: red
+emoji: 🔋
+colorFrom: green
+colorTo: gray
 sdk: docker
+app_port: 7860
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Open Materials Challenge
+
+시즌 1 — 전고체 배터리 전해질. **비공개 준비 중.**

app.py

@@ -0,0 +1,327 @@
+# -*- coding: utf-8 -*-
+"""Open Materials Challenge — 접수와 순위표.
+
+**이 서비스가 하지 않는 일**: 채점. 스페이스에는 Materials Project 자료도 GPU 도 없다.
+제출을 받아 원장(비공개 데이터셋)에 적고, 워커가 채점해 넣은 결과를 보여줄 뿐이다.
+여기서 물성을 판정하는 척하면 참가자는 근거 없는 반려를 받게 된다.
+
+순위표는 TTL 당 한 번만 만들어 미리 압축해 두고, 캐시는 단일 갱신자로 돌린다.
+첫 페이지는 async 로 서빙하고, 표는 500 행씩 나눠 그린다.
+"""
+import base64
+import gzip
+import hashlib
+import hmac
+import json
+import os
+import secrets
+import time
+import urllib.parse
+import urllib.request
+import uuid
+
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.middleware.gzip import GZipMiddleware
+from fastapi.responses import (FileResponse, JSONResponse, RedirectResponse,
+                               Response)
+from pydantic import BaseModel
+
+import gates
+import seasons
+import store
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+DATA = os.path.join(HERE, "data")
+# 페이지 폴링 주기(20초)보다 크게 잡는다.
+CACHE = store.Cached(ttl=int(os.environ.get("OMC_CACHE_TTL", "60")))
+SALT = os.environ.get("OMC_SALT", "omc-season1")
+
+OAUTH_ID = os.environ.get("OAUTH_CLIENT_ID", "")
+OAUTH_SECRET = os.environ.get("OAUTH_CLIENT_SECRET", "")
+OAUTH_ISS = os.environ.get("OPENID_PROVIDER_URL", "https://huggingface.co")
+SPACE_HOST = os.environ.get("SPACE_HOST", "")
+COOKIE = "omc_session"
+IN_FRAME = bool(SPACE_HOST)
+COOKIE_KW = ({"samesite": "none", "secure": True} if IN_FRAME
+             else {"samesite": "lax", "secure": False})
+SESSION_KEY = os.environ.get("OMC_SESSION_KEY") or secrets.token_hex(16)
+
+DAILY_CAP = int(os.environ.get("OMC_DAILY_CAP", "30"))
+CAP_TZ_OFFSET = 9 * 3600          # 참가자가 가정할 하루 경계 (KST)
+
+app = FastAPI(title="Open Materials Challenge")
+app.add_middleware(GZipMiddleware, minimum_size=1024)
+
+
+class Submission(BaseModel):
+    formula: str                  # 조성. 예: Li3YCl6, LiZr2(PO4)3
+    display_name: str             # 순위표에 표시될 이름
+    model_name: str = ""          # 어떤 모델이 제안했는지. 자유 기재
+    rationale: str = ""           # 설계 근거 (선택)
+    structure: str = ""           # CIF (선택) - 내면 채점이 빠르고 정확해진다
+    season: int = 0
+    # 조성을 공개할지는 제출자가 정한다. 되돌릴 수 없는 쪽이 기본값이어야 한다 -
+    # 한 번 공개된 조성은 되감을 수 없고, 공개는 특허성을 깎는다.
+    visibility: str = "private"
+
+
+# ---------------------------------------------------------------- 원장 접근
+def _submissions(s):
+    return CACHE.get("ids:%d" % s["number"],
+                     lambda: store.listdir(seasons.path(s, "submissions")))
+
+
+def _board(s):
+    return CACHE.get("board:%d" % s["number"],
+                     lambda: store.read(seasons.path(s, "leaderboard.json"),
+                                        default={}) or {})
+
+
+def public_id(key):
+    return "OMC-" + hashlib.sha256((SALT + key).encode()).hexdigest()[:10].upper()
+
+
+def mask(rec):
+    """비공개 제출에서 조성을 가린다. 원소 종류까지는 보여준다 - 그것만으로는
+    조성을 되돌릴 수 없고, 어떤 화학계가 상위인지는 대회의 공개 지식이어야 한다."""
+    out = dict(rec)
+    if rec.get("visibility") != "public":
+        comp = rec.get("composition") or {}
+        out["formula"] = "·".join(sorted(comp)) if comp else "비공개"
+        out["masked"] = True
+        out.pop("structure", None)
+    return out
+
+
+# ---------------------------------------------------------------- 세션
+def _sign(payload):
+    raw = base64.urlsafe_b64encode(json.dumps(payload).encode()).decode().rstrip("=")
+    sig = hmac.new(SESSION_KEY.encode(), raw.encode(), hashlib.sha256).hexdigest()[:32]
+    return raw + "." + sig
+
+
+def _unsign(token):
+    try:
+        raw, sig = (token or "").rsplit(".", 1)
+    except ValueError:
+        return None
+    good = hmac.new(SESSION_KEY.encode(), raw.encode(), hashlib.sha256).hexdigest()[:32]
+    if not hmac.compare_digest(sig, good):
+        return None
+    pad = "=" * (-len(raw) % 4)
+    try:
+        return json.loads(base64.urlsafe_b64decode(raw + pad))
+    except Exception:
+        return None
+
+
+def current_user(request: Request):
+    return _unsign(request.cookies.get(COOKIE))
+
+
+def _redirect_uri(request: Request):
+    if SPACE_HOST:
+        return "https://%s/auth/callback" % SPACE_HOST
+    return str(request.base_url).rstrip("/") + "/auth/callback"
+
+
+# ---------------------------------------------------------------- 화면
+@app.get("/")
+async def index():
+    # async 인 이유: sync 라우트는 요청 스���드풀에서 돈다. 그 풀이 Hub I/O 로 막히면
+    # 정적 페이지까지 뒤에 줄을 서서 사이트가 죽은 것처럼 보인다.
+    return FileResponse(os.path.join(HERE, "index.html"))
+
+
+@app.get("/api/me")
+def me(request: Request):
+    u = current_user(request)
+    return {"signed_in": bool(u), "user": u,
+            "oauth_configured": bool(OAUTH_ID and OAUTH_SECRET)}
+
+
+@app.get("/login")
+def login(request: Request):
+    if not (OAUTH_ID and OAUTH_SECRET):
+        raise HTTPException(503, "OAuth 가 설정되지 않았습니다.")
+    state = secrets.token_urlsafe(16)
+    q = urllib.parse.urlencode({
+        "client_id": OAUTH_ID, "redirect_uri": _redirect_uri(request),
+        "response_type": "code", "scope": "openid profile", "state": state})
+    r = RedirectResponse("%s/oauth/authorize?%s" % (OAUTH_ISS, q))
+    r.set_cookie("omc_state", state, max_age=600, httponly=True, **COOKIE_KW)
+    return r
+
+
+@app.get("/auth/callback")
+def callback(request: Request, code: str = "", state: str = ""):
+    if not code or state != request.cookies.get("omc_state"):
+        return RedirectResponse("/?auth=failed")
+    body = urllib.parse.urlencode({
+        "client_id": OAUTH_ID, "client_secret": OAUTH_SECRET,
+        "grant_type": "authorization_code", "code": code,
+        "redirect_uri": _redirect_uri(request)}).encode()
+    try:
+        req = urllib.request.Request("%s/oauth/token" % OAUTH_ISS, data=body)
+        with urllib.request.urlopen(req, timeout=30) as x:
+            tok = json.loads(x.read())
+        req = urllib.request.Request(
+            "%s/oauth/userinfo" % OAUTH_ISS,
+            headers={"Authorization": "Bearer " + tok["access_token"]})
+        with urllib.request.urlopen(req, timeout=30) as x:
+            info = json.loads(x.read())
+    except Exception:
+        return RedirectResponse("/?auth=failed")
+    u = {"sub": info.get("sub"), "name": info.get("preferred_username") or info.get("name"),
+         "picture": info.get("picture")}
+    r = RedirectResponse("/?auth=ok")
+    r.set_cookie(COOKIE, _sign(u), max_age=30 * 86400, httponly=True, **COOKIE_KW)
+    r.delete_cookie("omc_state")
+    return r
+
+
+@app.get("/logout")
+def logout():
+    r = RedirectResponse("/")
+    r.delete_cookie(COOKIE)
+    return r
+
+
+@app.get("/api/seasons")
+def season_list():
+    return {"seasons": seasons.all_public()}
+
+
+@app.get("/api/season")
+def season(request: Request):
+    return seasons.public(seasons.get(request.query_params.get("season")))
+
+
+# ---------------------------------------------------------------- 제출
+@app.post("/api/submit")
+def submit(s: Submission, request: Request):
+    season = seasons.get(s.season or None)
+    if not season.get("open"):
+        raise HTTPException(400, "이 시즌은 제출을 받지 않습니다.")
+    user = current_user(request)
+    if (OAUTH_ID and OAUTH_SECRET) and not user:
+        raise HTTPException(401, "제출하려면 Hugging Face 로그인이 필요합니다.")
+
+    g = seasons.gate(season)
+    ok, why, info = gates.check(s.formula, cif=s.structure or None,
+                                require_elements=g.get("require_elements", ("Li",)),
+                                max_atoms=g.get("max_atoms", 60))
+    if not ok:
+        raise HTTPException(400, why)
+
+    comp = info["composition"]
+    # 열쇠는 **기약 조성**으로 만든다. Li3YCl6 와 Li9Y3Cl18 은 같은 물질이다.
+    # 원본 조성으로 만들면 배수만 바꿔 같은 물질을 몇 번이고 올릴 수 있다.
+    red = info.get("reduced") or comp
+    key = "-".join("%s%g" % (k, red[k]) for k in sorted(red))
+    cid = public_id(key)
+
+    ids = _submissions(season)
+    if cid in ids:
+        raise HTTPException(409, "이미 제출된 조성입니다 (%s)." % cid)
+
+    if user:
+        today = int((time.time() + CAP_TZ_OFFSET) // 86400)
+        mine = CACHE.get("cap:%s:%d:%d" % (user.get("sub"), season["number"], today),
+                         lambda: 0)
+        if mine >= DAILY_CAP:
+            raise HTTPException(429, "하루 제출 상한(%d건)에 도달했습니다." % DAILY_CAP)
+
+    rec = {"candidate_id": cid, "formula": s.formula.strip(),
+           "composition": comp, "n_atoms": info["n_atoms"],
+           "display_name": (s.display_name or "").strip()[:60],
+           "model_name": (s.model_name or "").strip()[:80],
+           "rationale": (s.rationale or "").strip()[:1000],
+           "visibility": "public" if s.visibility == "public" else "private",
+           "has_structure": bool(s.structure),
+           "hf_user": (user or {}).get("name", ""),
+           "hf_sub": (user or {}).get("sub", ""),
+           "season": season["number"],
+           "submitted_at": int(time.time()),
+           "uuid": uuid.uuid4().hex}
+    store.write(seasons.path(season, "submissions/%s.json" % cid), rec,
+                summary="submit %s" % cid)
+    if s.structure:
+        # 구조는 따로 둔다. 목록을 훑을 때 같이 끌려오면 순위표가 무거워진다.
+        store.write(seasons.path(season, "structures/%s.json" % cid),
+                    {"candidate_id": cid, "cif": s.structure[:400_000]},
+                    summary="structure %s" % cid)
+    CACHE.drop("ids:%d" % season["number"])
+
+    scored = set((_board(season).get("entries") or {}).keys())
+    ahead = len([i for i in _submissions(season) if i not in scored])
+    return {"accepted": True, "candidate_id": cid, "queue_position": ahead,
+            "note": "채점은 별도 계산 작업으로 처리되며 완료까지 시간이 걸립니다."}
+
+
+# ---------------------------------------------------------------- 순위표
+def _anchors(season):
+    p = os.path.join(DATA, season.get("anchors") or "")
+    if not os.path.exists(p):
+        return []
+    out = []
+    for a in json.load(open(p, encoding="utf-8")):
+        if not a.get("admitted"):
+            continue
+        out.append({"candidate_id": a["label"], "is_anchor": True,
+                    "display_name": "기준물질", "model_name": "",
+                    "formula": a.get("formula", ""),
+                    "total": a.get("total"), "total_max": a.get("total_max"),
+                    "tier": a.get("tier", 1),
+                    "axes": {k: v["points"] for k, v in (a.get("axes") or {}).items()},
+                    "detail": {k: v["detail"] for k, v in (a.get("axes") or {}).items()},
+                    "note": a.get("note", "")})
+    return out
+
+
+def _leaderboard_body(season):
+    rows = [mask(r) for r in (_board(season).get("entries") or {}).values()]
+    anchors = _anchors(season)
+    merged = rows + anchors
+    merged.sort(key=lambda e: (e.get("tier", 1), -(e.get("total") if e.get("total") is not None else -1)))
+    n = 0
+    for e in merged:
+        if e.get("is_anchor") or e.get("tier", 1) != 1:
+            e["rank"] = None          # 기준물질은 척도를 표시할 뿐 등수를 갖지 않는다
+        else:
+            n += 1
+            e["rank"] = n
+    return {"season": seasons.public(season), "entries": merged,
+            "counts": {"scored": len(rows), "anchors": len(anchors)}}
+
+
+def _leaderboard_bytes(season):
+    raw = json.dumps(_leaderboard_body(season), ensure_ascii=False).encode("utf-8")
+    return raw, gzip.compress(raw, 6)
+
+
+@app.get("/api/leaderboard")
+def leaderboard(request: Request):
+    """응답은 시즌에만 의존하므로 TTL 당 한 번만 만들고 한 번만 압축한다."""
+    season = seasons.get(request.query_params.get("season"))
+    raw, gz = CACHE.get("lbresp:%d" % season["number"],
+                        lambda: _leaderboard_bytes(season))
+    if "gzip" in (request.headers.get("accept-encoding") or ""):
+        return Response(content=gz, media_type="application/json",
+                        headers={"Content-Encoding": "gzip", "Vary": "Accept-Encoding"})
+    return Response(content=raw, media_type="application/json",
+                    headers={"Vary": "Accept-Encoding"})
+
+
+@app.get("/api/queue")
+def queue(request: Request):
+    season = seasons.get(request.query_params.get("season"))
+    ids = _submissions(season)
+    scored = set((_board(season).get("entries") or {}).keys())
+    return {"queued": len([i for i in ids if i not in scored]),
+            "scored": len(scored), "total": len(ids)}
+
+
+@app.get("/api/health")
+def health():
+    return {"ok": True, "seasons": [s["number"] for s in seasons.SEASONS]}

data/anchor_scores.json

@@ -0,0 +1,226 @@
+[
+ {
+  "label": "LGPS",
+  "formula": "Li10GeP2S12",
+  "admitted": true,
+  "tier": 1,
+  "axes": {
+   "oxidation": {
+    "points": 2.73,
+    "detail": "산화한계 2.30 V · 상위 92%"
+   },
+   "li_stability": {
+    "points": 13.81,
+    "detail": "Li분해 +1.3035 eV/atom · 상위 54%"
+   },
+   "migration": {
+    "points": null,
+    "detail": "미평가(G2 대기)"
+   },
+   "novelty": {
+    "points": null,
+    "detail": "용도 신규성 미판정"
+   }
+  },
+  "total": 16.54,
+  "total_max": 65,
+  "note": "황화물. 이온전도도 12 mS/cm 로 최고 수준이나 산화창이 좁고 리튬금속과 반응한다.",
+  "measured": {
+   "ox": 2.2974683544303796,
+   "li": 1.3035463196661523,
+   "ea": null
+  }
+ },
+ {
+  "label": "아지로다이트",
+  "formula": "Li6PS5Cl",
+  "admitted": true,
+  "tier": 1,
+  "axes": {
+   "oxidation": {
+    "points": 2.04,
+    "detail": "산화한계 2.13 V · 상위 94%"
+   },
+   "li_stability": {
+    "points": 19.57,
+    "detail": "Li분해 +0.9958 eV/atom · 상위 35%"
+   },
+   "migration": {
+    "points": 14.05,
+    "detail": "이동장벽 0.293 eV · 상위 6%"
+   },
+   "novelty": {
+    "points": null,
+    "detail": "용도 신규성 미판정"
+   }
+  },
+  "total": 35.66,
+  "total_max": 80,
+  "note": "황화물. 상용화가 가장 앞선 계열.",
+  "measured": {
+   "ox": 2.132911392405063,
+   "li": 0.9958406943041193,
+   "ea": 0.293
+  }
+ },
+ {
+  "label": "LPS",
+  "formula": "Li3PS4",
+  "admitted": true,
+  "tier": 1,
+  "axes": {
+   "oxidation": {
+    "points": 7.15,
+    "detail": "산화한계 2.71 V · 상위 80%"
+   },
+   "li_stability": {
+    "points": 10.54,
+    "detail": "Li분해 +1.4918 eV/atom · 상위 65%"
+   },
+   "migration": {
+    "points": 12.21,
+    "detail": "이동장벽 0.420 eV · 상위 19%"
+   },
+   "novelty": {
+    "points": null,
+    "detail": "용도 신규성 미판정"
+   }
+  },
+  "total": 29.9,
+  "total_max": 80,
+  "note": "황화물 기본형.",
+  "measured": {
+   "ox": 2.7088607594936707,
+   "li": 1.4918371727514401,
+   "ea": 0.4199
+  }
+ },
+ {
+  "label": "LLZO",
+  "formula": "Li7La3Zr2O12",
+  "admitted": true,
+  "tier": 1,
+  "axes": {
+   "oxidation": {
+    "points": 11.89,
+    "detail": "산화한계 3.12 V · 상위 66%"
+   },
+   "li_stability": {
+    "points": 29.63,
+    "detail": "Li분해 +0.0221 eV/atom · 상위 1% · **불확실**(|값|<σ=0.467)"
+   },
+   "migration": {
+    "points": 11.23,
+    "detail": "이동장벽 0.459 eV · 상위 25%"
+   },
+   "novelty": {
+    "points": null,
+    "detail": "용도 신규성 미판정"
+   }
+  },
+  "total": 52.75,
+  "total_max": 80,
+  "note": "산화물 가넷. 리튬금속에 가장 안정한 축에 든다.",
+  "measured": {
+   "ox": 3.120253164556962,
+   "li": 0.022097652991613963,
+   "ea": 0.459
+  }
+ },
+ {
+  "label": "LIC",
+  "formula": "Li3InCl6",
+  "admitted": true,
+  "tier": 1,
+  "axes": {
+   "oxidation": {
+    "points": 28.74,
+    "detail": "산화한계 4.27 V · 상위 18%"
+   },
+   "li_stability": {
+    "points": 22.62,
+    "detail": "Li분해 +0.8328 eV/atom · 상위 25%"
+   },
+   "migration": {
+    "points": 11.95,
+    "detail": "이동장벽 0.430 eV · 상위 20%"
+   },
+   "novelty": {
+    "points": null,
+    "detail": "용도 신규성 미판정"
+   }
+  },
+  "total": 63.31,
+  "total_max": 80,
+  "note": "할라이드. 4V 급 산화 안정성.",
+  "measured": {
+   "ox": 4.272151898734177,
+   "li": 0.8327522978304368,
+   "ea": 0.4297
+  }
+ },
+ {
+  "label": "LZP",
+  "formula": "LiZr2(PO4)3",
+  "admitted": true,
+  "tier": 1,
+  "axes": {
+   "oxidation": {
+    "points": 31.36,
+    "detail": "산화한계 4.60 V · 상위 10%"
+   },
+   "li_stability": {
+    "points": 10.07,
+    "detail": "Li분해 +1.5212 eV/atom · 상위 66%"
+   },
+   "migration": {
+    "points": 14.83,
+    "detail": "이동장벽 0.185 eV · 상위 1%"
+   },
+   "novelty": {
+    "points": null,
+    "detail": "용도 신규성 미판정"
+   }
+  },
+  "total": 56.26,
+  "total_max": 80,
+  "note": "NASICON. 산화 안정성이 높다.",
+  "measured": {
+   "ox": 4.60126582278481,
+   "li": 1.521223317414708,
+   "ea": 0.1855
+  }
+ },
+ {
+  "label": "LATP 모체",
+  "formula": "LiTi2(PO4)3",
+  "admitted": true,
+  "tier": 1,
+  "axes": {
+   "oxidation": {
+    "points": 32.07,
+    "detail": "산화한계 4.68 V · 상위 8%"
+   },
+   "li_stability": {
+    "points": 7.25,
+    "detail": "Li분해 +1.6956 eV/atom · 상위 76%"
+   },
+   "migration": {
+    "points": 14.3,
+    "detail": "이동장벽 0.264 eV · 상위 5%"
+   },
+   "novelty": {
+    "points": null,
+    "detail": "용도 신규성 미판정"
+   }
+  },
+  "total": 53.62,
+  "total_max": 80,
+  "note": "NASICON. Ti(4+) 가 리튬금속에 환원되어 리튬금속 전지에는 그대로 못 쓴다.",
+  "measured": {
+   "ox": 4.6835443037974684,
+   "li": 1.6956100674601606,
+   "ea": 0.2637
+  }
+ }
+]

data/reference_dist.json

@@ -0,0 +1 @@
+{"_meta": {"n_ox": 8749, "n_li": 8749, "n_ea": 1603, "frozen": "2026-08-21", "source": "Materials Project G1 공간 스크리닝", "note": "시즌 중 변경 금지. 바꾸면 이전 제출의 점수가 소급해 달라진다."}, "oxidation": [-0.5, 0.981, 1.2278, 1.6392, 1.8038, 1.9684, 2.1329, 2.2152, 2.2975, 2.2975, 2.2975, 2.2975, 2.3797, 2.3797, 2.3797, 2.462, 2.5443, 2.5443, 2.6266, 2.6266, 2.6266, 2.7089, 2.7089, 2.7911, 2.7911, 2.7911, 2.7911, 2.8734, 2.8734, 2.8734, 2.8734, 2.9557, 3.038, 3.038, 3.1203, 3.1203, 3.1203, 3.2025, 3.2025, 3.2025, 3.2025, 3.2848, 3.2848, 3.2848, 3.2848, 3.3671, 3.3671, 3.3671, 3.3671, 3.4494, 3.4494, 3.4494, 3.5316, 3.5316, 3.5316, 3.6139, 3.6139, 3.6962, 3.6962, 3.7785, 3.7785, 3.7785, 3.7785, 3.7785, 3.7785, 3.8608, 3.8608, 3.8608, 3.8608, 3.943, 3.943, 4.0253, 4.0253, 4.0253, 4.1076, 4.1076, 4.1076, 4.1076, 4.1076, 4.1899, 4.1899, 4.1899, 4.1899, 4.2722, 4.2722, 4.2722, 4.3544, 4.4367, 4.4367, 4.519, 4.6013, 4.6013, 4.6835, 4.7658, 4.8481, 4.9304, 5.1772, 5.8354, 6.0, 6.0, 6.0], "li_stability": [-1.3264, 0.0128, 0.0891, 0.1591, 0.2003, 0.2461, 0.2763, 0.3195, 0.3667, 0.4065, 0.4432, 0.4815, 0.5182, 0.5603, 0.5886, 0.6209, 0.6486, 0.6757, 0.6962, 0.7252, 0.7574, 0.7824, 0.7961, 0.8092, 0.8271, 0.8397, 0.8553, 0.8728, 0.8876, 0.9044, 0.9219, 0.9409, 0.9588, 0.9719, 0.9855, 1.0017, 1.0246, 1.0468, 1.0665, 1.086, 1.1111, 1.1292, 1.1524, 1.1672, 1.1857, 1.198, 1.2137, 1.2238, 1.2329, 1.244, 1.2545, 1.264, 1.2784, 1.2897, 1.3038, 1.323, 1.344, 1.3591, 1.3794, 1.3998, 1.4163, 1.4341, 1.4491, 1.4614, 1.4762, 1.4945, 1.5133, 1.531, 1.5529, 1.5739, 1.5926, 1.6131, 1.6309, 1.6495, 1.6697, 1.6822, 1.6993, 1.7188, 1.744, 1.7772, 1.8053, 1.8165, 1.8329, 1.8594, 1.8874, 1.9164, 1.9534, 1.9768, 2.0106, 2.0504, 2.0878, 2.1101, 2.166, 2.2003, 2.2512, 2.2814, 2.3346, 2.3905, 2.5073, 2.7434, 3.8359], "migration": [0.0781, 0.1758, 0.2051, 0.2344, 0.2441, 0.2637, 0.2832, 0.3027, 0.3125, 0.3223, 0.332, 0.3418, 0.3516, 0.3613, 0.3711, 0.3809, 0.3906, 0.4004, 0.4102, 0.4199, 0.4199, 0.4297, 0.4297, 0.4395, 0.4492, 0.4492, 0.459, 0.459, 0.4688, 0.4785, 0.4883, 0.498, 0.5078, 0.5078, 0.5176, 0.5273, 0.5371, 0.5371, 0.5469, 0.5566, 0.5664, 0.5664, 0.5762, 0.5859, 0.5945, 0.5957, 0.6055, 0.6244, 0.6348, 0.6348, 0.6445, 0.6543, 0.6641, 0.6836, 0.6836, 0.6934, 0.7031, 0.7129, 0.7227, 0.7324, 0.7422, 0.7422, 0.752, 0.7617, 0.7715, 0.7812, 0.791, 0.8008, 0.8203, 0.8398, 0.8496, 0.8691, 0.8789, 0.8984, 0.918, 0.9424, 0.9668, 0.9863, 1.0156, 1.0352, 1.0645, 1.084, 1.1035, 1.123, 1.1426, 1.1816, 1.2012, 1.2207, 1.2574, 1.2793, 1.3281, 1.3947, 1.4551, 1.543, 1.6699, 1.7676, 1.8449, 2.1967, 2.4203, 2.7822, 3.584]}

data/weights.json

@@ -0,0 +1,8 @@
+{
+ "weights": {
+  "oxidation": 35,
+  "li_stability": 30,
+  "novelty": 20,
+  "migration": 15
+ }
+}

gates.py

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+"""접수 단계 검사.
+
+여기서 보는 것은 **형식과 자격**뿐이다. 실제 채점(전기화학창·리튬 이동)은 워커가 한다.
+스페이스는 MP 데이터도 GPU 도 없으므로, 여기서 물성을 판정하는 척하면 안 된다.
+
+거절은 참가자가 **고칠 수 있는 것**에만 쓴다. 값을 얻지 못한 항목은 거절이 아니라 보류로 둔다.
+"""
+import re
+
+# 채점 대상 원소.
+SUPPORTED = set("""
+H Li Be B C N O F Na Mg Al Si P S Cl K Ca Sc Ti V Cr Mn Fe Co Ni Cu Zn
+Ga Ge As Se Br Rb Sr Y Zr Nb Mo Tc Ru Rh Pd Ag Cd In Sn Sb Te I Cs Ba
+La Ce Pr Nd Pm Sm Eu Gd Tb Dy Ho Er Tm Yb Lu Hf Ta W Re Os Ir Pt Au Hg
+Tl Pb Bi Ac Th Pa U Np Pu
+""".split())
+
+_CIF_HINT = ("data_", "_cell_length_a", "_atom_site")
+
+
+def parse_formula(text):
+    """화학식을 조성으로. **괄호를 반드시 처리한다.**
+
+    직접 정규식으로 훑으면 `LiZr2(PO4)3` 가 P1O4 가 되어 조성이 통째로 틀린다.
+    Materials Project 자신이 LGPS 를 `Li10Ge(PS6)2` 로 적으므로 이건 예외가 아니라 기본이다.
+    """
+    from pymatgen.core import Composition
+    c = Composition(str(text).strip())
+    return {str(k): float(v) for k, v in c.get_el_amt_dict().items()}
+
+
+def check(text, cif=None, require_elements=("Li",), max_atoms=60,
+          supported=None, max_elements=6):
+    """접수 판정. (ok, reason, info) 를 돌려준다."""
+    supported = supported or SUPPORTED
+    raw = (text or "").strip()
+    if not raw:
+        return False, "화학식을 입력해 주세요.", {}
+    if len(raw) > 120:
+        return False, "화학식이 너무 깁니다.", {}
+    if not re.match(r"^[A-Za-z0-9()\[\]\.\s]+$", raw):
+        return False, "화학식에 쓸 수 없는 문자가 있습니다.", {}
+
+    try:
+        comp = parse_formula(raw)
+    except Exception:
+        return False, "화학식을 해석하지 못했습니다. 예: Li3YCl6, LiZr2(PO4)3", {}
+    if not comp:
+        return False, "화학식을 해석하지 못했습니다.", {}
+
+    for el in require_elements:
+        if el not in comp:
+            return False, "리튬 전해질 시즌입니다. %s 를 포함해야 합니다." % el, {}
+
+    bad = sorted(e for e in comp if e not in supported)
+    if bad:
+        return False, ("계산 기준 상태가 없는 원소입니다: %s" % ", ".join(bad)), {}
+
+    if len(comp) > max_elements:
+        return False, "원소가 %d 종을 넘습니다 (현재 %d 종)." % (max_elements, len(comp)), {}
+
+    # **기약 조성**을 기준으로 삼는다. Li3YCl6 와 Li9Y3Cl18 은 같은 물질이므로 같은 것으로
+    # 세야 한다. 원본 조성으로 열쇠를 만들면 배수만 바꿔 같은 물질을 몇 번이고 올릴 수 있다.
+    from math import gcd
+    from functools import reduce
+    integral = all(abs(v - round(v)) < 1e-6 for v in comp.values())
+    if integral:
+        ints = {k: int(round(v)) for k, v in comp.items()}
+        g = reduce(gcd, ints.values()) or 1
+        reduced = {k: v // g for k, v in ints.items()}
+    else:
+        reduced = dict(comp)          # 비정수 조성(도핑 등)은 그대로 둔다
+    n_atom = sum(reduced.values())
+    if n_atom > max_atoms:
+        return False, ("기약 조성의 원자 수가 %d 개로 상한 %d 를 넘습니다."
+                       % (n_atom, max_atoms)), {}
+
+    info = {"composition": comp, "reduced": reduced,
+            "n_atoms": n_atom, "n_elements": len(comp)}
+
+    if cif:
+        c = str(cif)
+        if len(c) > 400_000:
+            return False, "구조 파일이 너무 큽니다 (400KB 상한).", {}
+        if not any(h in c for h in _CIF_HINT):
+            return False, "구조 파일이 CIF 형식으로 보이지 않습니다.", {}
+        info["has_structure"] = True
+
+    return True, "", info

index.html

@@ -0,0 +1,424 @@
+<!doctype html>
+<html lang="ko">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>Open Materials Challenge #1 전고체 전해질</title>
+<!-- <head> 는 선택이 아니다: 플랫폼이 자기 태그를 문서에 주입하는데, 받을 head 가 없으면
+     그것들이 doctype 앞에 놓이고 페이지 전체가 쿼크 모드로 떨어진다. -->
+<style>
+  :root{
+    --bg:#f7f8fa; --card:#fff; --ink:#16181d; --muted:#6b7280; --line:#e5e7eb;
+    --accent:#1f6f4a; --accent-soft:#e8f3ed; --warn:#9a6700; --warn-soft:#fff8e1;
+    --anchor:#fffbe6; --anchor-line:#f2e3a8;
+  }
+  :root:not([data-theme="light"]){}
+  @media (prefers-color-scheme: dark){
+    :root:not([data-theme="light"]){
+      --bg:#101215; --card:#171a1f; --ink:#e8eaed; --muted:#9aa1ab; --line:#2a2f37;
+      --accent:#4bbb87; --accent-soft:#16281f; --warn:#e0b23c; --warn-soft:#2a2312;
+      --anchor:#241f10; --anchor-line:#4a4022;
+    }
+  }
+  :root[data-theme="dark"]{
+    --bg:#101215; --card:#171a1f; --ink:#e8eaed; --muted:#9aa1ab; --line:#2a2f37;
+    --accent:#4bbb87; --accent-soft:#16281f; --warn:#e0b23c; --warn-soft:#2a2312;
+    --anchor:#241f10; --anchor-line:#4a4022;
+  }
+  *{box-sizing:border-box}
+  body{margin:0;background:var(--bg);color:var(--ink);
+    font:15px/1.65 -apple-system,BlinkMacSystemFont,"Segoe UI","Noto Sans KR",sans-serif}
+  .wrap{max-width:1120px;margin:0 auto;padding:20px 16px 80px}
+  header{display:flex;align-items:baseline;gap:12px;flex-wrap:wrap;margin:8px 0 4px}
+  h1{font-size:22px;margin:0;letter-spacing:-.3px}
+  h2{font-size:17px;margin:0 0 10px;display:flex;align-items:baseline;gap:10px}
+  .sub{color:var(--muted);font-size:14px}
+  .card{background:var(--card);border:1px solid var(--line);border-radius:14px;
+    padding:18px 20px;margin:14px 0}
+  .grid{display:grid;grid-template-columns:1fr 360px;gap:14px;align-items:start}
+  @media (max-width:900px){.grid{grid-template-columns:1fr}}
+  .cnt{color:var(--muted);font-size:13px;font-weight:400;margin-left:auto}
+  #langbar,#seasonbar{display:flex;gap:6px;flex-wrap:wrap}
+  #langbar{margin-left:auto}
+  #langbar button,#seasonbar button{border:1px solid var(--line);background:var(--card);
+    color:var(--muted);border-radius:8px;padding:5px 12px;cursor:pointer;font:inherit;font-size:13px}
+  #langbar button.on,#seasonbar button.on{background:var(--accent);color:#fff;border-color:var(--accent)}
+  .scroll{overflow-x:auto}
+  table{width:100%;border-collapse:collapse;font-size:13.5px;min-width:780px}
+  th,td{padding:8px 10px;text-align:left;border-bottom:1px solid var(--line);white-space:nowrap}
+  th{color:var(--muted);font-weight:600;font-size:12.5px;cursor:pointer;user-select:none}
+  th .ar{opacity:.4;margin-left:3px;font-size:10px}
+  th.sorted{color:var(--accent)} th.sorted .ar{opacity:1}
+  tr.anchor{background:var(--anchor)}
+  tr.anchor td{border-bottom-color:var(--anchor-line)}
+  td.num{text-align:right;font-variant-numeric:tabular-nums}
+  .pill{display:inline-block;padding:1px 7px;border-radius:999px;font-size:11.5px;
+    background:var(--accent-soft);color:var(--accent);border:1px solid transparent}
+  .note{color:var(--muted);font-size:12.5px;margin-top:12px;line-height:1.7}
+  .pager{display:flex;align-items:center;justify-content:center;gap:6px;flex-wrap:wrap;
+    padding:14px 4px 2px;font-size:13px}
+  .pager button{border:1px solid var(--line);background:var(--card);color:var(--muted);
+    border-radius:8px;padding:5px 11px;cursor:pointer;font:inherit;min-width:36px}
+  .pager button.on{background:var(--accent);color:#fff;border-color:var(--accent)}
+  .pager button:disabled{opacity:.4;cursor:default}
+  .pager .pinfo{color:var(--muted);margin:0 8px}
+  .pager .gap{color:var(--muted);padding:0 2px}
+  label{display:block;font-size:13px;color:var(--muted);margin:12px 0 5px}
+  input,textarea,select{width:100%;padding:9px 11px;border:1px solid var(--line);
+    border-radius:9px;background:var(--bg);color:var(--ink);font:inherit;font-size:14px}
+  textarea{resize:vertical;min-height:64px}
+  .radio{display:flex;gap:8px;margin-top:6px}
+  .radio label{flex:1;display:flex;align-items:center;gap:7px;margin:0;padding:10px;
+    border:1px solid var(--line);border-radius:9px;cursor:pointer;font-size:13px;color:var(--ink)}
+  .radio label.on{border-color:var(--accent);background:var(--accent-soft)}
+  .go{width:100%;margin-top:16px;padding:12px;border:0;border-radius:10px;
+    background:var(--accent);color:#fff;font:inherit;font-size:15px;font-weight:600;cursor:pointer}
+  .go:disabled{opacity:.5;cursor:default}
+  .msg{margin-top:10px;padding:10px 12px;border-radius:9px;font-size:13px;display:none}
+  .msg.ok{display:block;background:var(--accent-soft);color:var(--accent)}
+  .msg.bad{display:block;background:var(--warn-soft);color:var(--warn)}
+  .callout{background:var(--warn-soft);border:1px solid var(--anchor-line);
+    border-radius:10px;padding:12px 14px;font-size:13px;color:var(--ink);margin:12px 0}
+  .axes{display:flex;gap:8px;flex-wrap:wrap;margin:10px 0 2px}
+  .axes span{font-size:12.5px;color:var(--muted);background:var(--bg);
+    border:1px solid var(--line);border-radius:999px;padding:3px 10px}
+  .axes b{color:var(--ink)}
+  a{color:var(--accent)}
+  .badges{display:flex;gap:8px;flex-wrap:wrap;margin-top:6px}
+  .badges img{height:22px}
+</style>
+</head>
+<body>
+<div class="wrap">
+
+<header>
+  <h1 id="t_title">Open Materials Challenge</h1>
+  <span class="sub" id="t_sub"></span>
+  <div id="langbar">
+    <button data-lang="ko" class="on">한국어</button>
+    <button data-lang="en">English</button>
+  </div>
+</header>
+<div class="badges" id="badges"></div>
+
+<div id="seasonbar" style="margin:14px 0 0"></div>
+
+<div class="card">
+  <h2 id="t_about_h"></h2>
+  <div id="t_about"></div>
+  <div class="axes" id="wts"></div>
+  <div class="callout" id="t_honest"></div>
+</div>
+
+<div class="grid">
+  <div class="card">
+    <h2><span id="t_board_h"></span><span class="cnt" id="counts"></span></h2>
+    <div class="scroll">
+      <table>
+        <thead><tr id="head"></tr></thead>
+        <tbody id="rows"></tbody>
+      </table>
+    </div>
+    <div class="pager" id="pager"></div>
+    <div class="note" id="t_boardnote"></div>
+  </div>
+
+  <div class="card">
+    <h2 id="t_submit_h"></h2>
+    <div id="gate" class="callout" style="display:none"></div>
+    <label id="l_formula"></label>
+    <input id="f_formula" placeholder="Li3YCl6">
+    <label id="l_name"></label>
+    <input id="f_name" placeholder="">
+    <label id="l_model"></label>
+    <input id="f_model" placeholder="anthropic/claude-…, Qwen/…">
+    <label id="l_cif"></label>
+    <textarea id="f_cif" placeholder="# generated using pymatgen&#10;data_…"></textarea>
+    <div class="note" id="t_cifnote" style="margin-top:4px"></div>
+    <label id="l_why"></label>
+    <textarea id="f_why"></textarea>
+    <label id="l_vis"></label>
+    <div class="radio" id="visbox">
+      <label class="on"><input type="radio" name="vis" value="private" checked><span id="t_priv"></span></label>
+      <label><input type="radio" name="vis" value="public"><span id="t_pub"></span></label>
+    </div>
+    <button class="go" id="go"></button>
+    <div class="msg" id="msg"></div>
+  </div>
+</div>
+
+<div class="card">
+  <h2 id="t_broker_h"></h2>
+  <div id="t_broker"></div>
+</div>
+
+</div>
+<script>
+const T = {
+ ko:{
+  sub:"인류의 난제를 AI 와 함께 — 개인이 참여하는 신소재 탐색",
+  about_h:"이 대회는 무엇인가",
+  about:`<p>전고체 배터리는 리튬이온 전지의 액체 전해질을 고체로 바꾼 것입니다. 더 안전하고 더 오래 갈 수 있지만,
+    <b>고체이면서 리튬만 잘 통과시키는 물질</b>을 찾는 일이 아직 풀리지 않았습니다.</p>
+   <p>이 대회는 그 후보 물질을 찾습니다. 참가자는 <b>조성 하나</b>를 냅니다 — 예: <code>Li3YCl6</code>.
+    저희가 계산으로 채점해 순위표에 올립니다. 상금은 없습니다.</p>`,
+  honest:`<b>이 시즌이 채점하는 것.</b> <b>전기화학적 강건성</b>입니다 — 높은 전압을 견디는지,
+    리튬 금속에 닿아도 버티는지, 리튬이 지나갈 길이 뚫려 있는지.
+    <b>이온전도도는 이번 시즌의 채점 항목이 아닙니다.</b> 따라서 전도도가 높은 계열이라도
+    산화창이 좁거나 리튬 금속과 반응하면 낮게 나옵니다 — 그 두 가지가 이 시즌이 묻는 문제입니다.
+    모든 값은 <b>계산 추정치</b>이며 실제 성능이나 안전성을 뜻하지 않습니다.`,
+  board_h:"순위표",
+  boardnote:`<b>기준물질(노란 행)</b>은 점수를 받되 등수를 갖지 않습니다. 실제로 쓰이는 전해질이 몇 점인지
+    눈으로 비교하시라고 넣었습니다.<br>
+    비공개 제출은 조성을 가리고 <b>원소 종류만</b> 표시합니다. 원본은 비공개로 보관됩니다.<br>
+    열 제목을 눌러 정렬할 수 있습니다.`,
+  submit_h:"제출",
+  l_formula:"조성 (화학식)", l_name:"표시 ID (이름·소속·닉네임)", l_model:"사용 모델명 (선택)",
+  l_cif:"구조 파일 CIF (선택)", l_why:"설계 근거 (선택)", l_vis:"공개 여부",
+  cifnote:`구조를 함께 내면 채점이 더 빠르고 정확합니다. 없으면 저희가 구조를 추정하며,
+    추정 구조를 얻지 못한 조성은 결과가 <b>보류</b>로 표시됩니다.`,
+  priv:"🔒 비공개 (기본)", pub:"🔓 조성 공개",
+  go:"제출하기",
+  gate:"제출하려면 <b>Hugging Face 로그인</b>이 필요합니다. 제출자 계정이 순위표에 함께 표시되며, 이는 다른 사람 이름으로 올리는 것을 막습니다.",
+  broker_h:"제출 기록과 제3자 연결",
+  broker:`<p>제출은 시각과 함께 저희 원장에 기록됩니다. 조성을 <b>비공개</b>로 두면 저희만 보관하며,
+    공개하지 않는 한 외부에 드러나지 않습니다. 이 기록이 향후 권리 주장에 참고가 될 수 있으나,
+    <b>특허 출원을 대신하지 않으며 법적 효력을 보장하지 않습니다.</b> 출원은 전문가와 상의하십시오.</p>
+   <p>제3자가 특정 제출에 대해 협의를 요청하는 경우, 운영자가 <b>중개</b>합니다.
+    제출자의 신원이나 연락처는 <b>본인 동의 없이 전달하지 않습니다.</b></p>`,
+  cols:{rank:"#",cand:"후보",user:"제출자",who:"모델",date:"제출일",
+        oxidation:"산화",li_stability:"Li안정",migration:"이동",novelty:"신규",total:"총점"},
+  counts:(a,b)=>`제출 ${a} · 기준물질 ${b}`,
+  prange:(a,b,n)=>`${a.toLocaleString()}–${b.toLocaleString()} / 전체 ${n.toLocaleString()}`,
+  empty:"아직 채점된 제출이 없습니다.",
+  fail:"순위표를 불러오지 못했습니다: ",
+  ok:(id,q)=>`접수되었습니다. 후보 ID <b>${id}</b> · 대기 ${q}건`,
+  need:"조성과 표시 ID를 입력해 주세요.",
+  hold:"보류"
+ },
+ en:{
+  sub:"Open problems, worked on together — materials discovery anyone can join",
+  about_h:"What this is",
+  about:`<p>A solid-state battery replaces the liquid electrolyte of a lithium-ion cell with a solid.
+    It can be safer and last longer, but finding a material that is <b>solid and still lets lithium through</b>
+    remains unsolved.</p>
+   <p>This challenge looks for candidates. You submit <b>one composition</b> — for example <code>Li3YCl6</code>.
+    We score it computationally and place it on the board. There is no prize.</p>`,
+  honest:`<b>What this season scores.</b> <b>Electrochemical robustness</b>: whether the material holds up at
+    high voltage, survives contact with lithium metal, and has a path for lithium to move through.
+    <b>Ionic conductivity is not a scored axis this season.</b> A highly conductive family therefore still
+    scores low if its oxidation window is narrow or it reacts with lithium metal — those two are the problem
+    this season puts to you.
+    Every value is a <b>computational estimate</b> and implies nothing about real performance or safety.`,
+  board_h:"Leaderboard",
+  boardnote:`<b>Reference materials (amber rows)</b> are scored but hold no rank. They are there so you can see
+    where materials in actual use land.<br>
+    Private entries show <b>elements only</b>; the composition is held back.<br>
+    Click a column header to sort.`,
+  submit_h:"Submit",
+  l_formula:"Composition (formula)", l_name:"Display ID (name, affiliation or handle)",
+  l_model:"Model used (optional)", l_cif:"Structure file, CIF (optional)",
+  l_why:"Design rationale (optional)", l_vis:"Visibility",
+  cifnote:`Including a structure makes scoring faster and more accurate. Without one we estimate the
+    structure; where no estimated structure is obtained, the result is marked <b>held</b>.`,
+  priv:"🔒 Private (default)", pub:"🔓 Show composition",
+  go:"Submit",
+  gate:"Submitting requires a <b>Hugging Face sign-in</b>. Your account appears alongside the entry, which stops anyone posting under another person's name.",
+  broker_h:"Record of submission, and third-party contact",
+  broker:`<p>Entries are recorded with a timestamp in our ledger. A <b>private</b> composition stays with us and
+    is not disclosed unless you choose to publish it. This record may serve as a reference later, but it
+    <b>is not a patent filing and carries no guaranteed legal effect.</b> Consult a professional before filing.</p>
+   <p>If a third party asks to discuss a specific entry, we pass the request along. We never share a
+    submitter's identity or contact details <b>without their consent.</b></p>`,
+  cols:{rank:"#",cand:"Entry",user:"Submitter",who:"Model",date:"Date",
+        oxidation:"Oxid.",li_stability:"Li-stab.",migration:"Migration",novelty:"Novelty",total:"Total"},
+  counts:(a,b)=>`${a} entries · ${b} references`,
+  prange:(a,b,n)=>`${a.toLocaleString()}–${b.toLocaleString()} of ${n.toLocaleString()}`,
+  empty:"No entries have been scored yet.",
+  fail:"Could not load the leaderboard: ",
+  ok:(id,q)=>`Accepted. Entry <b>${id}</b> · ${q} in queue`,
+  need:"Please enter a composition and a display ID.",
+  hold:"held"
+ }
+};
+
+const $ = s => document.querySelector(s);
+const COLS = ["rank","cand","user","who","date","oxidation","li_stability","migration","novelty","total"];
+// 표가 커지면 한꺼번에 그리지 않고 한 페이지씩 그린다.
+const PAGE_SIZE = 500;
+let LANG = "ko", DATA = null, SEASONS = [], SEASON = 1;
+let sortKey = "total", sortDir = -1, page = 0;
+const t = () => T[LANG];
+
+function esc(s){ return String(s ?? "").replace(/[&<>"']/g,c=>({"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"}[c])); }
+
+function setLang(l){
+  LANG = l;
+  document.documentElement.lang = l;
+  document.querySelectorAll("#langbar button").forEach(b=>b.classList.toggle("on", b.dataset.lang===l));
+  const d = t();
+  $("#t_sub").textContent = d.sub;
+  $("#t_about_h").textContent = d.about_h;
+  $("#t_about").innerHTML = d.about;
+  $("#t_honest").innerHTML = d.honest;
+  $("#t_board_h").textContent = d.board_h;
+  $("#t_boardnote").innerHTML = d.boardnote;
+  $("#t_submit_h").textContent = d.submit_h;
+  $("#t_broker_h").textContent = d.broker_h;
+  $("#t_broker").innerHTML = d.broker;
+  $("#t_cifnote").innerHTML = d.cifnote;
+  $("#t_priv").textContent = d.priv;
+  $("#t_pub").textContent = d.pub;
+  $("#go").textContent = d.go;
+  for(const k of ["formula","name","model","cif","why","vis"]) $("#l_"+k).textContent = d["l_"+k];
+  const g = $("#gate"); if(g.style.display !== "none") g.innerHTML = d.gate;
+  renderSeasonBar();
+  if(DATA) render();
+}
+document.querySelectorAll("#langbar button").forEach(b=>b.onclick=()=>setLang(b.dataset.lang));
+
+function renderSeasonBar(){
+  $("#seasonbar").innerHTML = SEASONS.slice().sort((a,b)=>b.number-a.number).map(s=>{
+    const nm = LANG==="ko" ? (s.topic_ko||s.topic) : s.topic;
+    return `<button data-season="${s.number}" class="${s.number===SEASON?"on":""}">
+      #${s.number} ${esc(nm)}</button>`;
+  }).join("");
+  document.querySelectorAll("#seasonbar button").forEach(b=>
+    b.onclick=()=>{ SEASON=parseInt(b.dataset.season,10); page=0; renderSeasonBar(); load(); });
+}
+
+function sortVal(e,k){
+  if(k==="rank")  return e.rank ?? 1e9;
+  if(k==="cand")  return String(e.candidate_id||"").toLowerCase();
+  if(k==="user")  return String(e.hf_user||e.display_name||"").toLowerCase();
+  if(k==="who")   return String(e.model_name||"").toLowerCase();
+  if(k==="date")  return e.submitted_at ?? 0;
+  if(k==="total") return e.total ?? -1;
+  return (e.axes||{})[k] ?? -1;
+}
+
+function renderPager(total,pages){
+  const host = $("#pager"), d = t();
+  if(pages<=1){ host.innerHTML=""; return; }
+  const from = page*PAGE_SIZE+1, to = Math.min(total,(page+1)*PAGE_SIZE);
+  let nums=[];
+  if(pages<=9){ for(let i=0;i<pages;i++) nums.push(i); }
+  else{
+    const near=[page-1,page,page+1].filter(i=>i>0&&i<pages-1);
+    nums=[...new Set([0,...near,pages-1])].sort((a,b)=>a-b);
+  }
+  let out=`<button ${page===0?"disabled":""} data-p="${page-1}">‹</button>`, prev=-1;
+  for(const i of nums){
+    if(i-prev>1) out+=`<span class="gap">…</span>`;
+    out+=`<button class="${i===page?"on":""}" data-p="${i}">${i+1}</button>`; prev=i;
+  }
+  out+=`<button ${page>=pages-1?"disabled":""} data-p="${page+1}">›</button>`;
+  out+=`<span class="pinfo">${d.prange(from,to,total)}</span>`;
+  host.innerHTML=out;
+  host.querySelectorAll("button[data-p]").forEach(b=>b.onclick=()=>{
+    if(b.disabled) return;
+    page=parseInt(b.dataset.p,10); render();
+    const c=document.querySelector(".card .scroll");
+    if(c) window.scrollTo({top:c.getBoundingClientRect().top+window.scrollY-80,behavior:"smooth"});
+  });
+}
+
+function render(){
+  const d = t(), W = (DATA.season && DATA.season.weights) || {};
+  $("#wts").innerHTML = Object.entries(W)
+    .map(([k,v])=>`<span>${esc(d.cols[k]||k)} <b>${v}</b></span>`).join("");
+  $("#counts").textContent = d.counts(DATA.counts.scored, DATA.counts.anchors);
+
+  $("#head").innerHTML = COLS.map(k=>{
+    const on = sortKey===k, ar = on ? (sortDir<0?"▼":"▲") : "▾";
+    return `<th data-k="${k}" class="${on?"sorted":""}">${esc(d.cols[k]||k)}<span class="ar">${ar}</span></th>`;
+  }).join("");
+  document.querySelectorAll("#head th").forEach(th=>th.onclick=()=>{
+    const k=th.dataset.k;
+    if(sortKey===k) sortDir=-sortDir;
+    else { sortKey=k; sortDir=(k==="rank"||k==="cand"||k==="who")?1:-1; }
+    page=0; render();
+  });
+
+  const all = DATA.entries.slice().sort((a,b)=>{
+    const x=sortVal(a,sortKey), y=sortVal(b,sortKey);
+    if(x<y) return -sortDir; if(x>y) return sortDir; return 0;
+  });
+  const pages = Math.max(1, Math.ceil(all.length/PAGE_SIZE));
+  if(page>=pages) page=pages-1;
+  if(page<0) page=0;
+  const rows = all.slice(page*PAGE_SIZE, page*PAGE_SIZE+PAGE_SIZE);
+  renderPager(all.length, pages);
+
+  $("#rows").innerHTML = rows.length ? rows.map(e=>{
+    const a = e.axes||{};
+    const cls = e.is_anchor ? "anchor" : "";
+    const who = e.is_anchor ? esc(e.display_name) : esc(e.hf_user||e.display_name||"");
+    const num = k => {
+      const v = a[k];
+      return `<td class="num">${v==null?`<span class="pill">${d.hold}</span>`:v.toFixed(1)}</td>`;
+    };
+    const dt = e.submitted_at ? new Date(e.submitted_at*1000).toISOString().slice(0,10) : "";
+    const tot = e.total==null ? `<span class="pill">${d.hold}</span>`
+              : `${e.total.toFixed(1)}${e.total_max?`<span class="sub" style="font-size:11px"> /${e.total_max}</span>`:""}`;
+    return `<tr class="${cls}">
+      <td class="num">${e.rank ?? "—"}</td>
+      <td>${esc(e.formula||e.candidate_id||"")}${e.masked?' <span class="pill">🔒</span>':""}</td>
+      <td>${who}</td><td>${esc(e.model_name||"")}</td><td>${dt}</td>
+      ${num("oxidation")}${num("li_stability")}${num("migration")}${num("novelty")}
+      <td class="num"><b>${tot}</b></td></tr>`;
+  }).join("") : `<tr><td colspan="${COLS.length}" class="sub">${d.empty}</td></tr>`;
+}
+
+async function load(){
+  try{
+    const r = await fetch(`/api/leaderboard?season=${SEASON}`);
+    DATA = await r.json();
+    render();
+  }catch(e){
+    $("#rows").innerHTML = `<tr><td colspan="${COLS.length}" class="sub">${t().fail}${esc(e)}</td></tr>`;
+  }
+}
+
+document.querySelectorAll('input[name="vis"]').forEach(r=>r.onchange=()=>{
+  document.querySelectorAll("#visbox label").forEach(l=>l.classList.toggle("on", l.querySelector("input").checked));
+});
+
+$("#go").onclick = async () => {
+  const d = t(), m = $("#msg");
+  const formula = $("#f_formula").value.trim(), name = $("#f_name").value.trim();
+  if(!formula || !name){ m.className="msg bad"; m.textContent=d.need; return; }
+  $("#go").disabled = true;
+  try{
+    const r = await fetch("/api/submit",{method:"POST",headers:{"Content-Type":"application/json"},
+      body:JSON.stringify({formula, display_name:name, model_name:$("#f_model").value.trim(),
+        rationale:$("#f_why").value.trim(), structure:$("#f_cif").value.trim(),
+        visibility:document.querySelector('input[name="vis"]:checked').value, season:SEASON})});
+    const j = await r.json();
+    if(!r.ok){ m.className="msg bad"; m.textContent = j.detail || ("HTTP "+r.status); }
+    else{ m.className="msg ok"; m.innerHTML = d.ok(j.candidate_id, j.queue_position);
+          $("#f_formula").value=""; $("#f_cif").value=""; load(); }
+  }catch(e){ m.className="msg bad"; m.textContent=String(e); }
+  $("#go").disabled = false;
+};
+
+(async function boot(){
+  try{
+    const s = await (await fetch("/api/seasons")).json();
+    SEASONS = s.seasons || [];
+    const open = SEASONS.filter(x=>x.open);
+    SEASON = (open.length?open:SEASONS).slice(-1)[0]?.number || 1;
+  }catch(e){}
+  try{
+    const me = await (await fetch("/api/me")).json();
+    if(me.oauth_configured && !me.signed_in){
+      const g=$("#gate"); g.style.display="block"; g.innerHTML=t().gate;
+    }
+  }catch(e){}
+  setLang("ko");
+  await load();
+  setInterval(load, 20000);
+})();
+</script>
+</body>
+</html>

requirements.txt

@@ -0,0 +1,4 @@
+fastapi==0.115.0
+uvicorn[standard]==0.30.6
+pydantic==2.9.2
+pymatgen==2024.8.9

seasons.py

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+"""시즌 등록부.
+
+시즌마다 대상 물질군·게이트·배점이 다르다. 한 프로세스가 모든 시즌을 서빙하므로
+설정은 **환경변수가 아니라 인자**로 흐른다 - 환경변수로 두면 시즌 하나의 설정이
+다른 시즌 요청에 새어 들어간다 (ODC 에서 실제로 그럴 뻔했다).
+"""
+
+SEASONS = [
+    {
+        "number": 1,
+        "name": "Open Materials Challenge",
+        "topic": "Solid-State Battery Electrolyte",
+        "topic_ko": "전고체 배터리 전해질",
+        "mobile_ion": "Li",
+        "opens": "2026-08-21",
+        "closes": "2026-11-30",
+        "prize": 0,
+        "open": True,
+        "prefix": "",
+        "anchors": "anchor_scores.json",
+
+        # 게이트는 자격만 본다. 성능은 점수로 반영한다.
+        "gate": {
+            "gap_min": 1.0,      # 전자전도체는 전지를 단락시킨다 - 진짜 요건
+            "hull_max": 0.10,    # 합성 가능성 상한
+            "ea_max": 1.0,       # 리튬 관통 경로 존재 여부. 이진 판정
+            "max_atoms": 60,
+            "require_elements": ("Li",),
+        },
+        "weights": {
+            "oxidation": 35,     # 산화 안정성
+            "li_stability": 30,  # 리튬금속 안정성
+            "novelty": 20,       # 용도 신규성 (조성 신규성이 아니다)
+            "migration": 15,     # 리튬 이동 용이성
+        },
+    },
+]
+
+BY_NUMBER = {s["number"]: s for s in SEASONS}
+DEFAULT = SEASONS[-1]
+
+# 공개면에 내보내지 않는 키. 채점기 내부 사정이 새면 표적화된 제출이 들어온다.
+_PRIVATE = ("prefix", "anchors", "gate")
+
+
+def get(n=None):
+    if n in (None, ""):
+        return DEFAULT
+    try:
+        return BY_NUMBER.get(int(n), DEFAULT)
+    except (TypeError, ValueError):
+        return DEFAULT
+
+
+def gate(s):
+    return dict(s.get("gate") or {})
+
+
+def path(s, name):
+    return (s.get("prefix") or "") + name
+
+
+def public(s):
+    out = {k: v for k, v in s.items() if k not in _PRIVATE}
+    g = s.get("gate") or {}
+    # 참가자가 알아야 반려를 피할 수 있는 값만 공개한다.
+    out["limits"] = {"max_atoms": g.get("max_atoms"),
+                     "hull_max": g.get("hull_max"),
+                     "gap_min": g.get("gap_min")}
+    return out
+
+
+def all_public():
+    return [public(s) for s in SEASONS]

store.py

@@ -0,0 +1,187 @@
+# -*- coding: utf-8 -*-
+"""The submission ledger, kept in a private Hugging Face dataset.
+
+A Space's container filesystem is ephemeral. Every rebuild, restart or sleep wipes it,
+and with it every submission and every score. That is survivable for a demo and not
+survivable for a contest with a prize attached, so the ledger lives outside the container
+in a dataset repo that the entrant's work outlives the service.
+
+Layout - one file per record, never appended to:
+
+    submissions/<id>.json   written by the web service when an entry is accepted
+    results/<id>.json       written by the GPU worker when it finishes scoring
+    leaderboard.json        rolled up by the worker so the page reads one file
+
+One file per record is what makes concurrent writers safe. Two entrants submitting at the
+same moment touch different paths, so neither commit can clobber the other - which an
+append to a shared JSONL absolutely would.
+
+The rollup exists because a page load must not fan out into one request per entry. The
+worker already holds every score at the moment it writes one, so it is the natural place
+to rebuild the table.
+"""
+import base64
+import json
+import os
+import threading
+import time
+import urllib.error
+import urllib.request
+
+REPO = os.environ.get("OMC_DATASET", "FINAL-Bench/omc-submissions")
+TOKEN = os.environ.get("HF_TOKEN", "")
+API = "https://huggingface.co/api/datasets/%s" % REPO
+RESOLVE = "https://huggingface.co/datasets/%s/resolve/main" % REPO
+
+
+def _hdr(extra=None):
+    h = {"User-Agent": "VIDRAFT-OMC/1.0"}
+    if TOKEN:
+        h["Authorization"] = "Bearer " + TOKEN
+    if extra:
+        h.update(extra)
+    return h
+
+
+def _get_json(url, timeout=30):
+    req = urllib.request.Request(url, headers=_hdr())
+    with urllib.request.urlopen(req, timeout=timeout) as r:
+        return json.loads(r.read().decode())
+
+
+def read(path, default=None):
+    """Fetch one record. Missing files are a normal state, not an error."""
+    try:
+        return _get_json("%s/%s" % (RESOLVE, path))
+    except urllib.error.HTTPError as e:
+        if e.code in (404, 401, 403):
+            return default
+        raise
+    except Exception:
+        return default
+
+
+def write(path, obj, summary=None):
+    """Commit one record. NDJSON is the format this endpoint takes - a plain JSON body
+    is accepted and then quietly does nothing, which is a long way to debug."""
+    blob = base64.b64encode(json.dumps(obj, ensure_ascii=False).encode()).decode()
+    lines = [
+        json.dumps({"key": "header", "value": {"summary": summary or ("write " + path)}}),
+        json.dumps({"key": "file", "value": {"path": path, "content": blob,
+                                             "encoding": "base64"}}),
+    ]
+    body = ("\n".join(lines) + "\n").encode()
+    req = urllib.request.Request(API + "/commit/main", data=body,
+                                 headers=_hdr({"Content-Type": "application/x-ndjson"}))
+    with urllib.request.urlopen(req, timeout=60) as r:
+        return json.loads(r.read().decode())
+
+
+MAX_PAGES = int(os.environ.get("OMC_MAX_PAGES", "200"))
+
+
+def _tree_pages(prefix):
+    """Every page of a tree listing, following the Link cursor.
+
+    The Hub caps a page at 1,000 entries. Reading only the first page was silent while
+    the dataset was small and started dropping records the moment it was not."""
+    url = "%s/tree/main/%s" % (API, prefix)
+    seen = 0
+    for _ in range(MAX_PAGES):
+        req = urllib.request.Request(url, headers=_hdr())
+        with urllib.request.urlopen(req, timeout=60) as r:
+            page = json.loads(r.read().decode())
+            link = r.headers.get("Link") or ""
+        yield page
+        seen += len(page)
+        nxt = ""
+        for part in link.split(","):
+            if 'rel="next"' in part and "<" in part:
+                nxt = part[part.index("<") + 1:part.index(">")]
+        if not nxt:
+            return
+        url = nxt
+    raise RuntimeError("tree listing exceeded %d pages at %s (%d entries)"
+                       % (MAX_PAGES, prefix, seen))
+
+
+def listdir(prefix):
+    """Record ids under a prefix. Absent directory means nothing has been written yet."""
+    out = []
+    try:
+        for page in _tree_pages(prefix):
+            for e in page:
+                q = e.get("path", "")
+                if q.endswith(".json") and not os.path.basename(q).startswith("_"):
+                    out.append(os.path.basename(q)[:-5])
+    except urllib.error.HTTPError as e:
+        if e.code == 404:
+            return []
+        raise
+    except Exception:
+        # a partial listing is worse than none: the caller would treat the missing ids as
+        # unscored and the rollup would drop them, which is exactly the failure this fixes
+        raise
+    return out
+
+
+class Cached:
+    """A small TTL cache so a page refresh does not become a round trip to the Hub.
+
+    Staleness is bounded and harmless here: the worst case is a leaderboard a few seconds
+    behind, and the page polls anyway.
+
+    **Single flight.** The first version had no lock, so every concurrent request that
+    arrived after the TTL expired saw a miss and every one of them re-ran produce(). With
+    a few thousand entries that is a full paginated tree listing each, and on a 2-vCPU
+    container the request threadpool fills with blocked Hub I/O - at which point even the
+    static index page queues behind it and the site stops answering. One refresher at a
+    time; everyone else is served the value we already have.
+
+    **Stale beats blocking, and stale beats an error.** A leaderboard a minute old is a
+    working page. A timeout is not.
+    """
+
+    def __init__(self, ttl=20):
+        self.ttl = ttl
+        self._v = {}
+        self._locks = {}
+        self._guard = threading.Lock()
+
+    def _lock_for(self, key):
+        with self._guard:
+            lk = self._locks.get(key)
+            if lk is None:
+                lk = self._locks[key] = threading.Lock()
+            return lk
+
+    def get(self, key, produce):
+        hit = self._v.get(key)
+        if hit and time.time() - hit[0] < self.ttl:
+            return hit[1]
+
+        lk = self._lock_for(key)
+        # Block only when there is nothing at all to serve. If a refresh is already in
+        # flight and we hold a stale value, hand that back instead of joining the queue.
+        if not lk.acquire(blocking=(hit is None)):
+            return hit[1]
+        try:
+            hit = self._v.get(key)          # the winner may have filled it while we waited
+            if hit and time.time() - hit[0] < self.ttl:
+                return hit[1]
+            try:
+                val = produce()
+            except Exception:
+                if hit:
+                    return hit[1]
+                raise
+            self._v[key] = (time.time(), val)
+            return val
+        finally:
+            lk.release()
+
+    def drop(self, key=None):
+        if key is None:
+            self._v.clear()
+        else:
+            self._v.pop(key, None)