squash history

Co-authored-by: ryancll <ryancll@users.noreply.huggingface.co>
Co-authored-by: claude opus 4.6 <claude opus 4.6@users.noreply.huggingface.co>
Co-authored-by: ryancll118 <ryancll118@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,6 @@
+# Ignore metric.py - it's uploaded to dataset repo, not server repo
+metric.py
+
+metric_old.py
+*.zip
+*.csv

Dockerfile

@@ -0,0 +1,22 @@
+# Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
+# you will also find guides on how best to write your Dockerfile
+
+FROM python:3.9
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:/usr/local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade --extra-index-url https://pypi.nvidia.com -r requirements.txt && \
+    pip uninstall -y opencv-python opencv-python-headless 2>/dev/null || true && \
+    pip install --no-cache-dir opencv-python-headless
+
+COPY --chown=user . /app
+
+# Create necessary directories
+RUN mkdir -p /app/uploads /app/database
+
+CMD ["sh", "-lc", "python worker.py & exec uvicorn app:app --host 0.0.0.0 --port 7860"]

README.md

@@ -0,0 +1,10 @@
+---
+title: ICRA26WM
+emoji: 💻
+colorFrom: purple
+colorTo: purple
+sdk: docker
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,728 @@
+"""
+ICRA26 Workshop Competition Test Server
+
+主应用文件，使用 FastAPI 构建。
+"""
+import asyncio
+import json
+import os
+import shutil
+import uuid
+import random
+import fcntl
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Optional, Dict
+
+# 修复 HuggingFace Space 中的 OMP_NUM_THREADS 问题
+# HuggingFace 会设置这个变量但值可能无效（空或0），导致 OpenMP 报错
+_omp_val = os.environ.get('OMP_NUM_THREADS', '')
+if not _omp_val or _omp_val == '0':
+    os.environ['OMP_NUM_THREADS'] = '1'
+
+from fastapi import FastAPI, Request, UploadFile, File, HTTPException
+from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from pydantic import BaseModel
+
+from dataset_storage import init_storage, DatasetStorage
+
+# ============== 配置 ==============
+UPLOAD_DIR = Path(__file__).parent / "uploads"
+UPLOAD_DIR.mkdir(exist_ok=True)
+
+# 从环境变量获取配置
+HF_TOKEN = os.environ.get("HF_TOKEN", "")
+RESEND_KEY = os.environ.get("RESEND_KEY", "")
+REGISTRATION_URL = "https://huggingface.co/datasets/agibot-world/IROSChallengeWMTrack/resolve/main/icra_form.csv"
+HF_DATASET_REPO = "agibot-world/IROSChallengeWMTrack"
+
+# 验证配置
+MAX_DAILY_VALIDATIONS = 2  # 每队每天验证次数
+
+app = FastAPI(title="ICRA26 Workshop Competition")
+
+# 静态文件和模板
+app.mount("/static", StaticFiles(directory="static"), name="static")
+templates = Jinja2Templates(directory="templates")
+
+# 初始化存储
+storage: Optional[DatasetStorage] = None
+
+
+def get_storage() -> DatasetStorage:
+    """获取存储实例"""
+    global storage
+    if storage is None:
+        storage = init_storage(HF_DATASET_REPO, HF_TOKEN)
+    return storage
+
+
+# ============== 串行队列处理 ==============
+SUBMISSIONS_LOCK_FILE = "/tmp/icra26wm_submissions.lock"
+
+# ============== Metric 模块 ==============
+metric_module = None
+
+
+def load_metric_module():
+    """从 dataset repo 下载并加载 metric.py"""
+    global metric_module
+    # 强制重新加载（每次都重新下载）
+    metric_module = None
+
+    if not HF_TOKEN:
+        print("HF_TOKEN not configured, using mock evaluation")
+        return None
+
+    try:
+        from huggingface_hub import hf_hub_download
+        import importlib.util
+
+        # 下载 metric.py
+        print("Downloading metric.py from dataset repo...")
+        metric_path = hf_hub_download(
+            repo_id=HF_DATASET_REPO,
+            filename="metric.py",
+            token=HF_TOKEN,
+            repo_type="dataset"
+        )
+        print(f"Downloaded metric.py to: {metric_path}")
+
+        # 动态加载模块
+        spec = importlib.util.spec_from_file_location("metric", metric_path)
+        metric_module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(metric_module)
+
+        print(f"Loaded metric.py, has evaluate_submission: {hasattr(metric_module, 'evaluate_submission')}")
+        return metric_module
+    except Exception as e:
+        import traceback
+        print(f"Failed to load metric.py: {e}")
+        traceback.print_exc()
+        return None
+
+
+# ============== 验证码管理 ==============
+
+verification_codes: Dict = {}
+
+
+def load_registration():
+    """从 Hugging Face datasets 加载报名名单（新格式字段映射）"""
+    registration = {}
+    try:
+        import urllib.request
+        import csv
+        from io import StringIO
+
+        headers = {'User-Agent': 'Mozilla/5.0'}
+        if HF_TOKEN:
+            headers['Authorization'] = f'Bearer {HF_TOKEN}'
+        req = urllib.request.Request(REGISTRATION_URL, headers=headers)
+
+        with urllib.request.urlopen(req, timeout=10) as response:
+            content = response.read().decode('utf-8-sig')
+            reader = csv.DictReader(StringIO(content))
+            for row in reader:
+                email = (row.get('Contact Email') or '').strip().lower()
+                team_name = (row.get('Team Name') or '').strip()
+                if email:
+                    registration[email] = team_name
+
+        print(f"Loaded {len(registration)} registrations from Hugging Face dataset")
+    except Exception as e:
+        print(f"Failed to load registration from Hugging Face: {e}")
+    return registration
+
+
+def generate_verification_code() -> str:
+    """生成6位数字验证码"""
+    return ''.join([str(random.randint(0, 9)) for _ in range(6)])
+
+
+def send_verification_code(email: str, code: str, team_name: str):
+    """发送验证码到邮箱"""
+    if not RESEND_KEY:
+        print(f"\n{'='*50}")
+        print(f"验证码发送（调试模式）- ICRA26 Workshop")
+        print(f"收件人: {email}")
+        print(f"队伍名: {team_name}")
+        print(f"验证码: {code}")
+        print(f"有效期: 5 分钟")
+        print(f"{'='*50}\n")
+        return True
+
+    try:
+        import resend
+        resend.api_key = RESEND_KEY
+        html_content = f"""
+        <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
+            <h2 style="color: #6366f1;">AgiBot World Challenge 2026</h2>
+            <h3>World Model Track - Verification Code</h3>
+            <p style="color: #374151;">This email is for submission system verification.</p>
+            <p>Your team: <strong>{team_name}</strong></p>
+            <div style="background: #f3f4f6; padding: 20px; text-align: center; border-radius: 8px; margin: 20px 0;">
+                <span style="font-size: 32px; letter-spacing: 8px; font-weight: bold;">{code}</span>
+            </div>
+            <p style="color: #6b7280; font-size: 14px;">This code expires in 5 minutes.</p>
+            <p style="color: #9ca3af; font-size: 13px;">If you did not request this code, please ignore this email.</p>
+        </div>
+        """
+        resend.Emails.send({
+            "from": "AgiBot World Challenge 2026 <onboarding@resend.dev>",
+            "to": email,
+            "subject": "AgiBot World Challenge 2026 - World Model Track Verification Code",
+            "html": html_content
+        })
+        print(f"Verification code sent to {email}")
+        return True
+    except Exception as e:
+        print(f"Failed to send email: {e}")
+        return False
+
+
+# ============== 数据操作函数 ==============
+
+def get_teams() -> dict:
+    """获取所有队伍"""
+    try:
+        return get_storage().download_json("teams.json")
+    except:
+        return {"teams": {}}
+
+
+def save_teams(data: dict):
+    """保存队伍数据"""
+    get_storage().upload_json("teams.json", data)
+
+
+def get_submissions() -> dict:
+    """获取所有提交"""
+    try:
+        return get_storage().download_json("submissions.json")
+    except:
+        return {"submissions": []}
+
+
+def save_submissions(data: dict):
+    """保存提交数据"""
+    get_storage().upload_json("submissions.json", data)
+
+
+async def update_submissions(mutator):
+    """
+    统一的 submissions.json 更新入口（进程内串行化）。
+    mutator 接收 data 并原地修改。
+    """
+    def _update():
+        # 跨进程文件锁，避免 web/worker 同时读改写 submissions.json
+        with open(SUBMISSIONS_LOCK_FILE, "w") as lock_f:
+            fcntl.flock(lock_f.fileno(), fcntl.LOCK_EX)
+            data = get_submissions()
+            mutator(data)
+            save_submissions(data)
+            fcntl.flock(lock_f.fileno(), fcntl.LOCK_UN)
+            return data
+
+    return await asyncio.to_thread(_update)
+
+
+async def append_submission_record(remote_path: str, email: str, team_name: str) -> int:
+    """在锁内生成 submission_id 并追加记录，避免并发重复 id。"""
+    def _append():
+        with open(SUBMISSIONS_LOCK_FILE, "w") as lock_f:
+            fcntl.flock(lock_f.fileno(), fcntl.LOCK_EX)
+            data = get_submissions()
+            submission_id = max([s.get("id", 0) for s in data.get("submissions", [])], default=0) + 1
+            new_submission = {
+                "id": submission_id,
+                "email": email,
+                "team_name": team_name,
+                "file_path": remote_path,
+                "submit_time": datetime.now().isoformat(),
+                "score": None,
+                "status": "pending",
+                "error_message": None
+            }
+            data.setdefault("submissions", []).append(new_submission)
+            save_submissions(data)
+            fcntl.flock(lock_f.fileno(), fcntl.LOCK_UN)
+            return submission_id
+
+    return await asyncio.to_thread(_append)
+
+
+def get_daily_limits() -> dict:
+    """获取每日限制"""
+    try:
+        return get_storage().download_json("daily_limits.json")
+    except:
+        return {}
+
+
+def save_daily_limits(data: dict):
+    """保存每日限制"""
+    get_storage().upload_json("daily_limits.json", data)
+
+
+def check_daily_limit(email: str, date: str) -> tuple[bool, int]:
+    """检查是否超过每日限制"""
+    limits = get_daily_limits()
+    current = limits.get(email, {}).get(date, 0)
+    return current >= MAX_DAILY_VALIDATIONS, current
+
+
+def increment_daily_limit(email: str, date: str):
+    """增加每日验证计数"""
+    limits = get_daily_limits()
+    if email not in limits:
+        limits[email] = {}
+    if date not in limits[email]:
+        limits[email][date] = 0
+    limits[email][date] += 1
+    save_daily_limits(limits)
+
+
+def upload_submission_to_hf(local_path: Path, timestamp: str) -> str:
+    """上传提交文件到 HF dataset"""
+    filename = f"submissions/{timestamp}.zip"
+    get_storage().upload_file(str(local_path), filename)
+    return filename
+
+
+# ============== 后台验证任务 ==============
+
+async def process_submissions():
+    """后台任务：处理待验证的提交"""
+    print("Background process_submissions started")
+    while True:
+        try:
+            data = await asyncio.to_thread(get_submissions)
+            submissions = data.get("submissions", [])
+
+            # 找出 pending 状态的提交
+            pending = [s for s in submissions if s.get("status") == "pending"]
+            print(f"Found {len(pending)} pending submissions")
+
+            if pending:
+                # 按时间排序，取最早的
+                pending.sort(key=lambda x: x.get("submit_time", ""))
+                sub = pending[0]
+                print(f"Processing submission {sub.get('id')}")
+
+                print(f"Starting evaluation for submission {sub.get('id')}")
+                # 串行执行：当前任务完成后再处理下一个
+                await run_evaluation(sub)
+            else:
+                await asyncio.sleep(3)
+
+        except Exception as e:
+            print(f"Error in process_submissions: {e}")
+            import traceback
+            traceback.print_exc()
+            await asyncio.sleep(5)
+
+
+async def run_evaluation(submission: dict):
+    """执行单个验证"""
+    submission_id = submission.get("id")
+    email = submission.get("email")
+    team_name = submission.get("team_name")
+
+    # 串行模式：任务开始即切到 processing
+    await update_submissions(
+        lambda data: [
+            s.update({"status": "processing"})
+            for s in data.get("submissions", [])
+            if s.get("id") == submission_id
+        ]
+    )
+
+    print(f"[EVAL:{submission_id}] status set to processing")
+
+    try:
+        # 调用 metric.py 执行验证
+        print(f"Loading metric module for submission {submission_id}...")
+        metric = await asyncio.to_thread(load_metric_module)
+
+        if not metric or not hasattr(metric, 'evaluate_submission'):
+            raise RuntimeError("metric.py not found in dataset repo. Please upload metric.py to the dataset.")
+
+        print(f"[EVAL:{submission_id}] metric loaded, starting evaluate_submission...")
+        # 使用真实的 metric.py，返回 (score, error, email, team_name)
+        score, error, validated_email, validated_team = await asyncio.get_event_loop().run_in_executor(
+            None, metric.evaluate_submission, submission, HF_DATASET_REPO
+        )
+        print(f"[EVAL:{submission_id}] evaluation complete: score={score}, error={error}, email={validated_email}, team={validated_team}")
+
+        # === 处理校验失败（邮箱验证未通过）===
+        if error and error.startswith("VALIDATION_FAILED:"):
+            validation_error = error.replace("VALIDATION_FAILED:", "")
+            print(f"Validation failed for submission {submission_id}: {validation_error}")
+
+            # 根据错误类型设置状态
+            # 超过每日上限显示 overlimit，其他显示 error
+            if "Daily validation limit exceeded" in validation_error:
+                status = "overlimit"
+                # overlimit 时保留文件，记录也保留
+            else:
+                status = "error"
+                # 其他错误删除远程上传的文件
+                file_path = submission.get("file_path", "")
+                if file_path:
+                    try:
+                        await asyncio.to_thread(get_storage().delete_file, file_path)
+                        print(f"Deleted remote file: {file_path}")
+                    except Exception as del_err:
+                        print(f"Failed to delete remote file: {del_err}")
+
+            print(f"[EVAL:{submission_id}] writing validation failure status={status}")
+            # 更新状态，显示错误信息，同时更新邮箱和队名
+            await update_submissions(
+                lambda data: [
+                    s.update({
+                        "status": status,
+                        "error_message": validation_error,
+                        **({"email": validated_email} if validated_email else {}),
+                        **({"team_name": validated_team} if validated_team else {}),
+                    })
+                    for s in data.get("submissions", [])
+                    if s.get("id") == submission_id
+                ]
+            )
+            print(f"[EVAL:{submission_id}] writeback done (validation failed)")
+            return
+        # === 结束 ===
+
+        print(f"[EVAL:{submission_id}] preparing final writeback")
+        # 更新结果
+        await update_submissions(
+            lambda data: [
+                s.update(
+                    {
+                        "status": "error" if error else "completed",
+                        **({"error_message": error} if error else {}),
+                        **({"score": round(score, 4), "evaluation_time": datetime.now().isoformat()} if not error else {}),
+                        **({"email": validated_email} if validated_email else {}),
+                        **({"team_name": validated_team} if validated_team else {}),
+                    }
+                )
+                for s in data.get("submissions", [])
+                if s.get("id") == submission_id
+            ]
+        )
+        print(f"[EVAL:{submission_id}] final writeback done")
+
+        # 只有成功才增加每日计数
+        if not error:
+            date = datetime.now().strftime("%Y-%m-%d")
+            print(f"[EVAL:{submission_id}] incrementing daily limit for {validated_email} on {date}")
+            await asyncio.to_thread(increment_daily_limit, validated_email, date)
+        if error:
+            print(f"[EVAL:{submission_id}] completed with error: {error}")
+        else:
+            print(f"[EVAL:{submission_id}] completed successfully: score={score}")
+
+    except Exception as e:
+        # 更新为 error
+        await update_submissions(
+            lambda data: [
+                s.update({"status": "error", "error_message": str(e)})
+                for s in data.get("submissions", [])
+                if s.get("id") == submission_id
+            ]
+        )
+        print(f"[EVAL:{submission_id}] exception during evaluation/writeback: {e}")
+
+
+# ============== 启动事件 ==============
+
+@app.on_event("startup")
+async def startup_event():
+    """启动时仅做轻量初始化；评测队列由独立 worker 进程处理"""
+    if HF_TOKEN:
+        await asyncio.to_thread(get_storage)
+    print("Web app startup complete (evaluation worker runs in separate process)")
+
+
+# ============== API 端点 ==============
+
+class SendCodeRequest(BaseModel):
+    email: str
+
+
+class VerifyCodeRequest(BaseModel):
+    email: str
+    code: str
+
+
+class SubmitResponse(BaseModel):
+    submission_id: int
+    status: str
+    message: str
+
+
+class StatusResponse(BaseModel):
+    submission_id: int
+    status: str
+    score: Optional[float] = None
+    error_message: Optional[str] = None
+    submit_time: Optional[str] = None
+
+
+@app.post("/api/validate-email")
+async def validate_email_api(request: SendCodeRequest):
+    """校验邮箱是否在报名名单中（无验证码流程）"""
+    email = request.email.strip().lower()
+    registration = await asyncio.to_thread(load_registration)
+
+    if len(registration) == 0:
+        return JSONResponse(
+            status_code=404,
+            content={"detail": "Registration system temporarily unavailable. Please try again later."}
+        )
+
+    if email not in registration:
+        return JSONResponse(
+            status_code=404,
+            content={"detail": "Email not found in registration list. Please check your email address."}
+        )
+
+    return {
+        "success": True,
+        "message": "Email verified",
+        "email": email,
+        "team_name": registration[email]
+    }
+
+
+@app.post("/api/send-verification-code")
+async def send_verification_code_api(request: SendCodeRequest):
+    """发送验证码到邮箱"""
+    email = request.email.strip().lower()
+
+    # 检查邮箱是否在报名名单中
+    registration = await asyncio.to_thread(load_registration)
+    if len(registration) == 0:
+        return JSONResponse(
+            status_code=404,
+            content={"detail": "Registration system temporarily unavailable. Please try again later."}
+        )
+
+    if email not in registration:
+        return JSONResponse(
+            status_code=404,
+            content={"detail": "Email not found in registration list. Please check your email address."}
+        )
+
+    team_name = registration[email]
+
+    # 检查是否已有有效的验证码
+    if email in verification_codes:
+        code_info = verification_codes[email]
+        if code_info["expires_at"] > datetime.now():
+            return JSONResponse(
+                status_code=400,
+                content={"detail": "Verification code already sent. Please check your email or wait for it to expire."}
+            )
+
+    # 生成新验证码
+    code = generate_verification_code()
+    expires_at = datetime.now() + timedelta(minutes=5)
+
+    verification_codes[email] = {
+        "code": code,
+        "expires_at": expires_at,
+        "team_name": team_name
+    }
+
+    await asyncio.to_thread(send_verification_code, email, code, team_name)
+
+    return {
+        "success": True,
+        "message": "Verification code sent",
+        "expires_in": 300
+    }
+
+
+@app.post("/api/verify-code")
+async def verify_code_api(request: VerifyCodeRequest):
+    """校验验证码"""
+    email = request.email.strip().lower()
+    code = request.code.strip()
+
+    if email not in verification_codes:
+        return {
+            "success": False,
+            "message": "No verification code found. Please request a new code."
+        }
+
+    code_info = verification_codes[email]
+
+    if code_info["expires_at"] < datetime.now():
+        del verification_codes[email]
+        return {
+            "success": False,
+            "message": "Verification code expired. Please request a new code."
+        }
+
+    if code_info["code"] != code:
+        return {
+            "success": False,
+            "message": "Invalid verification code."
+        }
+
+    team_name = code_info["team_name"]
+    del verification_codes[email]
+
+    return {
+        "success": True,
+        "message": "Verification successful",
+        "team_name": team_name
+    }
+
+
+@app.post("/api/submit", response_model=SubmitResponse)
+async def submit_file(file: UploadFile = File(...)):
+    """提交 zip 文件进行验证"""
+    print(f"Submit request received: {file.filename}")
+
+    if not HF_TOKEN:
+        raise HTTPException(status_code=500, detail="HF_TOKEN not configured")
+
+    if not file.filename.endswith('.zip'):
+        raise HTTPException(status_code=400, detail="Only .zip files are allowed")
+
+    # 提取邮箱（从表单或从 zip）
+    # TODO: 从 zip 的 team_info.json 提取
+
+    # 保存临时文件
+    temp_path = UPLOAD_DIR / f"temp_{uuid.uuid4().hex}.zip"
+    try:
+        print("Reading file content...")
+        content = await file.read()
+        with open(temp_path, 'wb') as f:
+            f.write(content)
+        print(f"File saved to temp: {temp_path}, size: {len(content)} bytes")
+
+        # 上传到 HF dataset - 用时间戳+随机字符串命名
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f") + "_" + uuid.uuid4().hex[:8]
+        email = "unknown"
+        team_name = "unknown"
+
+        print(f"Uploading to HF with timestamp: {timestamp}")
+        remote_path = await asyncio.to_thread(upload_submission_to_hf, temp_path, timestamp)
+        print(f"Uploaded to: {remote_path}")
+
+        submission_id = await append_submission_record(remote_path, email, team_name)
+        print(f"Submissions saved, assigned submission_id: {submission_id}")
+
+        # 删除临时文件
+        temp_path.unlink()
+
+        return SubmitResponse(
+            submission_id=submission_id,
+            status="pending",
+            message="Submission received and queued for evaluation"
+        )
+
+    except Exception as e:
+        import traceback
+        print(f"Submit error: {e}")
+        traceback.print_exc()
+        if temp_path.exists():
+            temp_path.unlink()
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/status/{submission_id}", response_model=StatusResponse)
+async def get_status(submission_id: int):
+    """获取提交状态"""
+    data = await asyncio.to_thread(get_submissions)
+    for sub in data.get("submissions", []):
+        if sub.get("id") == submission_id:
+            return StatusResponse(
+                submission_id=submission_id,
+                status=sub.get("status", "unknown"),
+                score=sub.get("score"),
+                error_message=sub.get("error_message"),
+                submit_time=sub.get("submit_time")
+            )
+    raise HTTPException(status_code=404, detail="Submission not found")
+
+
+@app.get("/api/leaderboard")
+async def get_leaderboard_api():
+    """获取排行榜"""
+    data = await asyncio.to_thread(get_submissions)
+    submissions = data.get("submissions", [])
+
+    # 按队伍分组，取最优成绩
+    team_scores = {}
+    for sub in submissions:
+        if sub.get("status") != "completed":
+            continue
+        email = sub.get("email")
+        team_name = sub.get("team_name")
+        score = sub.get("score", 0)
+
+        if email not in team_scores or score > team_scores[email]["best_score"]:
+            team_scores[email] = {
+                "team_name": team_name,
+                "best_score": score,
+                "last_submit_time": sub.get("submit_time")
+            }
+
+    # 转换为列表并排序
+    leaderboard = [
+        {
+            "team_name": v["team_name"],
+            "best_score": v["best_score"],
+            "last_submit_time": v["last_submit_time"]
+        }
+        for k, v in team_scores.items()
+    ]
+    leaderboard.sort(key=lambda x: x["best_score"] or 0, reverse=True)
+
+    return JSONResponse(content=leaderboard)
+
+
+@app.get("/api/submissions/{identifier}")
+async def get_team_submissions_api(identifier: str):
+    """获取队伍的提交记录，支持按邮箱或队名查询"""
+    identifier = identifier.replace("_at_", "@")  # URL 编码还原
+    identifier = identifier.lower()
+    data = await asyncio.to_thread(get_submissions)
+    submissions = [
+        s for s in data.get("submissions", [])
+        if s.get("email", "").lower() == identifier
+        or s.get("team_name", "").lower() == identifier
+    ]
+    return JSONResponse(content=submissions)
+
+
+# ============== 页面路由 ==============
+
+@app.get("/", response_class=HTMLResponse)
+async def index(request: Request):
+    """Challenge Description 页面"""
+    return templates.TemplateResponse("index.html", {"request": request})
+
+
+@app.get("/submit", response_class=HTMLResponse)
+async def submit_page(request: Request):
+    """Submission 页面"""
+    return templates.TemplateResponse("submit.html", {"request": request})
+
+
+@app.get("/leaderboard", response_class=HTMLResponse)
+async def leaderboard_page(request: Request):
+    """Leaderboard 页面"""
+    return templates.TemplateResponse("leaderboard.html", {"request": request})
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

daily_limits.json

@@ -0,0 +1 @@
+{}

database/__init__.py

@@ -0,0 +1,180 @@
+import aiosqlite
+import os
+from pathlib import Path
+
+DATABASE_PATH = Path(__file__).parent.parent / "database" / "submission.db"
+DATABASE_PATH.parent.mkdir(exist_ok=True)
+
+
+async def get_db():
+    """获取数据库连接"""
+    db = await aiosqlite.connect(str(DATABASE_PATH))
+    db.row_factory = aiosqlite.Row
+    return db
+
+
+async def init_db():
+    """初始化数据库"""
+    db = await aiosqlite.connect(str(DATABASE_PATH))
+    with open(Path(__file__).parent / "schema.sql", "r") as f:
+        await db.executescript(f.read())
+    await db.commit()
+    await db.close()
+
+
+async def get_or_create_team(db, team_name: str) -> int:
+    """获取或创建队伍，返回 team_id"""
+    cursor = await db.execute(
+        "SELECT id FROM teams WHERE name = ?", (team_name,)
+    )
+    row = await cursor.fetchone()
+    if row:
+        return row["id"]
+    await db.execute(
+        "INSERT INTO teams (name) VALUES (?)", (team_name,)
+    )
+    await db.commit()
+    cursor = await db.execute(
+        "SELECT id FROM teams WHERE name = ?", (team_name,)
+    )
+    row = await cursor.fetchone()
+    return row["id"]
+
+
+async def check_daily_limit(db, team_id: int) -> tuple[bool, int]:
+    """
+    检查每日限制，返回 (是否超限, 当日提交数)
+    """
+    today = date.today().isoformat()
+    cursor = await db.execute(
+        "SELECT count FROM daily_limits WHERE team_id = ? AND date = ?",
+        (team_id, today)
+    )
+    row = await cursor.fetchone()
+    if row:
+        return row["count"] >= 1, row["count"]
+    return False, 0
+
+
+async def increment_daily_limit(db, team_id: int):
+    """增加当日提交计数"""
+    today = date.today().isoformat()
+    await db.execute(
+        """INSERT INTO daily_limits (team_id, date, count)
+           VALUES (?, ?, 1)
+           ON CONFLICT(team_id, date) DO UPDATE SET count = count + 1""",
+        (team_id, today)
+    )
+    await db.commit()
+
+
+async def create_submission(db, team_id: int, file_path: str) -> int:
+    """创建提交记录，返回 submission_id"""
+    cursor = await db.execute(
+        """INSERT INTO submissions (team_id, file_path, status)
+           VALUES (?, ?, 'pending')""",
+        (team_id, file_path)
+    )
+    await db.commit()
+    return cursor.lastrowid
+
+
+async def get_submission(submission_id: int):
+    """获取单个提交记录"""
+    db = await get_db()
+    cursor = await db.execute(
+        """SELECT s.*, t.name as team_name
+           FROM submissions s
+           JOIN teams t ON s.team_id = t.id
+           WHERE s.id = ?""",
+        (submission_id,)
+    )
+    row = await cursor.fetchone()
+    await db.close()
+    return dict(row) if row else None
+
+
+async def update_submission_status(
+    submission_id: int,
+    status: str,
+    score: float = None,
+    error_message: str = None
+):
+    """更新提交状态"""
+    db = await get_db()
+    if score is not None:
+        await db.execute(
+            "UPDATE submissions SET status = ?, score = ?, error_message = ? WHERE id = ?",
+            (status, score, error_message, submission_id)
+        )
+    else:
+        await db.execute(
+            "UPDATE submissions SET status = ?, error_message = ? WHERE id = ?",
+            (status, error_message, submission_id)
+        )
+    await db.commit()
+    await db.close()
+
+
+async def get_oldest_pending_submission():
+    """获取最老的 pending 提交"""
+    db = await get_db()
+    cursor = await db.execute(
+        """SELECT s.*, t.name as team_name
+           FROM submissions s
+           JOIN teams t ON s.team_id = t.id
+           WHERE s.status = 'pending'
+           ORDER BY s.submit_time ASC
+           LIMIT 1"""
+    )
+    row = await cursor.fetchone()
+    await db.close()
+    return dict(row) if row else None
+
+
+async def get_team_submissions(team_id: int):
+    """获取队伍的所有提交记录"""
+    db = await get_db()
+    cursor = await db.execute(
+        """SELECT s.*, t.name as team_name
+           FROM submissions s
+           JOIN teams t ON s.team_id = t.id
+           WHERE s.team_id = ?
+           ORDER BY s.submit_time DESC""",
+        (team_id,)
+    )
+    rows = await cursor.fetchall()
+    await db.close()
+    return [dict(row) for row in rows]
+
+
+async def get_leaderboard():
+    """获取排行榜数据（每队最优成绩）"""
+    db = await get_db()
+    cursor = await db.execute(
+        """SELECT t.name as team_name,
+                  MAX(s.score) as best_score,
+                  MAX(s.submit_time) as last_submit_time
+           FROM teams t
+           LEFT JOIN submissions s ON t.id = s.team_id AND s.status = 'completed'
+           GROUP BY t.id
+           ORDER BY best_score DESC NULLS LAST,
+                    last_submit_time ASC"""
+    )
+    rows = await cursor.fetchall()
+    await db.close()
+    return [dict(row) for row in rows]
+
+
+async def get_team_by_name(team_name: str):
+    """根据队名获取队伍信息"""
+    db = await get_db()
+    cursor = await db.execute(
+        "SELECT * FROM teams WHERE name = ?", (team_name,)
+    )
+    row = await cursor.fetchone()
+    await db.close()
+    return dict(row) if row else None
+
+
+from datetime import date

database/schema.sql

@@ -0,0 +1,33 @@
+-- Teams table
+CREATE TABLE IF NOT EXISTS teams (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Submissions table
+CREATE TABLE IF NOT EXISTS submissions (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    team_id INTEGER NOT NULL,
+    file_path TEXT NOT NULL,
+    submit_time DATETIME DEFAULT CURRENT_TIMESTAMP,
+    score REAL,
+    status TEXT DEFAULT 'pending' CHECK(status IN ('pending', 'processing', 'completed', 'error', 'overlimit')),
+    error_message TEXT,
+    FOREIGN KEY (team_id) REFERENCES teams(id)
+);
+
+-- Daily limits tracking
+CREATE TABLE IF NOT EXISTS daily_limits (
+    team_id INTEGER NOT NULL,
+    date DATE NOT NULL,
+    count INTEGER DEFAULT 0,
+    PRIMARY KEY (team_id, date),
+    FOREIGN KEY (team_id) REFERENCES teams(id)
+);
+
+-- Indexes for faster queries
+CREATE INDEX IF NOT EXISTS idx_submissions_team_id ON submissions(team_id);
+CREATE INDEX IF NOT EXISTS idx_submissions_status ON submissions(status);
+CREATE INDEX IF NOT EXISTS idx_submissions_submit_time ON submissions(submit_time);
+CREATE INDEX IF NOT EXISTS idx_daily_limits_team_date ON daily_limits(team_id, date);

dataset_storage.py

@@ -0,0 +1,112 @@
+"""
+Dataset Storage Module
+
+用于操作 Hugging Face Dataset Repo 中的 JSON 文件。
+"""
+import json
+import os
+import tempfile
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+try:
+    from huggingface_hub import hf_hub_download, HfApi
+except ImportError:
+    hf_hub_download = None
+    HfApi = None
+
+
+class DatasetStorage:
+    """HF Dataset 存储操作类"""
+
+    def __init__(self, repo_id: str, token: str):
+        self.repo_id = repo_id
+        self.token = token
+        if token:
+            self.api = HfApi(token=token)
+        else:
+            self.api = None
+
+    def download_json(self, filename: str) -> Dict[str, Any]:
+        """下载 JSON 文件"""
+        if not hf_hub_download or not self.token:
+            raise ValueError("HF_TOKEN not configured")
+
+        try:
+            local_path = hf_hub_download(
+                repo_id=self.repo_id,
+                filename=filename,
+                token=self.token,
+                repo_type="dataset"
+            )
+            with open(local_path, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except Exception as e:
+            print(f"Failed to download {filename}: {e}")
+            # 返回默认空结构
+            return self._get_default_structure(filename)
+
+    def _get_default_structure(self, filename: str) -> Dict:
+        """返回默认空结构"""
+        if filename == "teams.json":
+            return {"teams": {}}
+        elif filename == "submissions.json":
+            return {"submissions": []}
+        elif filename == "daily_limits.json":
+            return {}
+        return {}
+
+    def upload_json(self, filename: str, data: Dict[str, Any]):
+        """上传 JSON 文件"""
+        if not self.api or not self.token:
+            raise ValueError("HF_TOKEN not configured")
+
+        # 创建临时文件
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False, encoding='utf-8') as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+            temp_path = f.name
+
+        try:
+            self.api.upload_file(
+                path_or_fileobj=temp_path,
+                path_in_repo=filename,
+                repo_id=self.repo_id,
+                repo_type="dataset"
+            )
+        finally:
+            if os.path.exists(temp_path):
+                os.unlink(temp_path)
+
+    def upload_file(self, local_path: str, remote_path: str):
+        """上传任意文件"""
+        if not self.api or not self.token:
+            raise ValueError("HF_TOKEN not configured")
+
+        self.api.upload_file(
+            path_or_fileobj=local_path,
+            path_in_repo=remote_path,
+            repo_id=self.repo_id,
+            repo_type="dataset"
+        )
+
+    def delete_file(self, path_in_repo: str):
+        """删除 dataset repo 中的文件"""
+        if not self.api or not self.token:
+            raise ValueError("HF_TOKEN not configured")
+
+        self.api.delete_file(
+            path_in_repo,
+            repo_id=self.repo_id,
+            repo_type="dataset"
+        )
+
+
+# 全局存储实例（需要初始化）
+storage: Optional[DatasetStorage] = None
+
+
+def init_storage(repo_id: str, token: str):
+    """初始化存储实例"""
+    global storage
+    storage = DatasetStorage(repo_id, token)
+    return storage

registration.csv

@@ -0,0 +1,9 @@
+# ICRA26 Workshop Registration
+# Format: email,team_name
+# 每行: 邮箱,队伍名
+# 请在此文件中添加参赛队伍的邮箱和队名映射
+
+# 示例（请替换为真实数据）：
+test@example.com,TestTeamAlpha
+demo@icra.org,RoboChampions
+participant2026@workshop.org,NeuralNinjas

requirements.txt

@@ -0,0 +1,22 @@
+fastapi
+uvicorn
+jinja2
+python-multipart
+aiofiles
+aiosqlite
+sqlalchemy
+resend
+huggingface_hub
+numpy
+
+# For evaluation metrics
+torch
+torchvision
+opencv-python-headless
+pillow
+omegaconf
+scikit-image
+scipy
+ultralytics
+fastdtw
+lap

scoring/__init__.py

@@ -0,0 +1 @@
+# Scoring module exports

scoring/scorer.py

@@ -0,0 +1,112 @@
+"""
+评分模块
+
+用于评估参赛队伍提交的 zip 文件中的结果。
+当前为 Mock 实现，待后续替换为真实评分逻辑。
+"""
+import json
+import zipfile
+import random
+import time
+from pathlib import Path
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class ScoreResult:
+    """评分结果"""
+    score: float
+    error: Optional[str] = None
+
+
+def validate_zip_contents(zip_path: str) -> tuple[bool, Optional[str]]:
+    """
+    验证 zip 文件内容是否合法
+    返回 (是否合法, 错误信息)
+    """
+    try:
+        with zipfile.ZipFile(zip_path, 'r') as zf:
+            # 检查必要的文件
+            names = zf.namelist()
+            # 检查是否存在 team_info.json
+            if 'team_info.json' not in names:
+                return False, "Missing team_info.json in zip root"
+
+            # 读取并验证 team_info.json
+            try:
+                info = json.loads(zf.read('team_info.json').decode('utf-8'))
+                if 'team_name' not in info:
+                    return False, "team_info.json must contain 'team_name' field"
+            except json.JSONDecodeError as e:
+                return False, f"Invalid team_info.json format: {e}"
+
+        return True, None
+    except zipfile.BadZipFile:
+        return False, "Invalid zip file"
+    except Exception as e:
+        return False, f"Unexpected error: {e}"
+
+
+def extract_team_name(zip_path: str) -> Optional[str]:
+    """
+    从 zip 文件中提取队伍名
+    """
+    try:
+        with zipfile.ZipFile(zip_path, 'r') as zf:
+            info = json.loads(zf.read('team_info.json').decode('utf-8'))
+            return info.get('team_name')
+    except Exception:
+        return None
+
+
+def score_submission(zip_path: str, team_name: str) -> ScoreResult:
+    """
+    评分函数
+
+    Args:
+        zip_path: zip 文件路径
+        team_name: 队伍名（从 zip 中提取）
+
+    Returns:
+        ScoreResult: 包含分数或错误信息
+    """
+    # 1. 验证 zip 内容
+    is_valid, error = validate_zip_contents(zip_path)
+    if not is_valid:
+        return ScoreResult(score=0.0, error=error)
+
+    # 2. Mock 评分逻辑
+    # TODO: 替换为真实评分逻辑
+    #
+    # 真实评分可能包含：
+    # - 解压 zip 文件
+    # - 运行验证脚本
+    # - 计算指标（如 Accuracy, F1, mAP 等）
+    # - 考虑推理时间等因素
+
+    # 模拟耗时操作（实际评分可能需要更长时间）
+    # time.sleep(2)  # 取消注释用于测试等待效果
+
+    # Mock: 随机生成 0-100 之间的分数
+    score = random.uniform(0, 100)
+
+    # 也可以根据队伍名生成确定性的分数（用于测试）
+    # hash_value = hash(team_name) % 101
+    # score = float(hash_value)
+
+    return ScoreResult(score=round(score, 4))
+
+
+def evaluate_submission(zip_path: str) -> tuple[float, Optional[str]]:
+    """
+    评估提交并返回分数和错误信息
+
+    这是主要调用的接口
+    """
+    team_name = extract_team_name(zip_path)
+    if team_name is None:
+        return 0.0, "Could not extract team name from zip"
+
+    result = score_submission(zip_path, team_name)
+    return result.score, result.error

static/css/style.css

@@ -0,0 +1,595 @@
+/* Base Styles */
+:root {
+    --primary-color: #6366f1;
+    --primary-hover: #4f46e5;
+    --secondary-color: #64748b;
+    --success-color: #22c55e;
+    --warning-color: #f59e0b;
+    --error-color: #ef4444;
+    --bg-color: #f8fafc;
+    --card-bg: #ffffff;
+    --sidebar-bg: #1e293b;
+    --sidebar-text: #e2e8f0;
+    --text-color: #1e293b;
+    --text-muted: #64748b;
+    --border-color: #e2e8f0;
+    --shadow-sm: 0 1px 2px rgba(0, 0, 0, 0.05);
+    --shadow-md: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
+    --radius-sm: 6px;
+    --radius-md: 8px;
+    --radius-lg: 12px;
+}
+
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+    background: var(--bg-color);
+    color: var(--text-color);
+    line-height: 1.6;
+}
+
+/* Layout */
+.container {
+    display: flex;
+    min-height: 100vh;
+}
+
+/* Sidebar */
+.sidebar {
+    width: 280px;
+    background: var(--sidebar-bg);
+    color: var(--sidebar-text);
+    display: flex;
+    flex-direction: column;
+    position: fixed;
+    height: 100vh;
+    z-index: 100;
+}
+
+.sidebar-header {
+    padding: 24px;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.sidebar-header h1 {
+    font-size: 1.5rem;
+    font-weight: 700;
+    margin-bottom: 4px;
+}
+
+.sidebar-header .subtitle {
+    font-size: 0.85rem;
+    color: var(--secondary-color);
+}
+
+.sidebar-nav {
+    flex: 1;
+    padding: 16px 12px;
+}
+
+.nav-item {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    padding: 12px 16px;
+    color: var(--sidebar-text);
+    text-decoration: none;
+    border-radius: var(--radius-md);
+    margin-bottom: 4px;
+    transition: all 0.2s ease;
+}
+
+.nav-item:hover {
+    background: rgba(255, 255, 255, 0.1);
+}
+
+.nav-item.active {
+    background: var(--primary-color);
+    color: white;
+}
+
+.nav-icon {
+    font-size: 1.2rem;
+}
+
+.sidebar-footer {
+    padding: 16px 24px;
+    border-top: 1px solid rgba(255, 255, 255, 0.1);
+    font-size: 0.85rem;
+    color: var(--secondary-color);
+}
+
+/* Main Content */
+.main-content {
+    flex: 1;
+    margin-left: 280px;
+    padding: 32px;
+    max-width: 1200px;
+}
+
+/* Page Header */
+.page-header {
+    margin-bottom: 32px;
+}
+
+.page-header h1 {
+    font-size: 2rem;
+    font-weight: 700;
+    margin-bottom: 8px;
+}
+
+.page-subtitle {
+    color: var(--text-muted);
+}
+
+/* Content Card */
+.content-card {
+    background: var(--card-bg);
+    border-radius: var(--radius-lg);
+    padding: 24px;
+    margin-bottom: 24px;
+    box-shadow: var(--shadow-sm);
+    border: 1px solid var(--border-color);
+}
+
+.content-card h2 {
+    font-size: 1.25rem;
+    font-weight: 600;
+    margin-bottom: 16px;
+    color: var(--text-color);
+}
+
+.content-card h3 {
+    font-size: 1rem;
+    font-weight: 600;
+    margin: 24px 0 12px;
+}
+
+.content-card p {
+    margin-bottom: 12px;
+    color: var(--text-color);
+}
+
+/* Buttons */
+.btn {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    padding: 10px 20px;
+    border-radius: var(--radius-md);
+    font-size: 0.9rem;
+    font-weight: 500;
+    cursor: pointer;
+    border: none;
+    transition: all 0.2s ease;
+    text-decoration: none;
+}
+
+.btn-primary {
+    background: var(--primary-color);
+    color: white;
+}
+
+.btn-primary:hover {
+    background: var(--primary-hover);
+}
+
+.btn-secondary {
+    background: var(--border-color);
+    color: var(--text-color);
+}
+
+.btn-secondary:hover {
+    background: #cbd5e1;
+}
+
+.btn-large {
+    padding: 14px 32px;
+    font-size: 1rem;
+}
+
+.btn:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+/* Upload Area */
+.upload-area {
+    border: 2px dashed var(--border-color);
+    border-radius: var(--radius-lg);
+    padding: 48px;
+    text-align: center;
+    transition: all 0.2s ease;
+    cursor: pointer;
+    margin-bottom: 24px;
+}
+
+.upload-area:hover,
+.upload-area.dragover {
+    border-color: var(--primary-color);
+    background: rgba(99, 102, 241, 0.05);
+}
+
+.upload-icon {
+    font-size: 3rem;
+    margin-bottom: 16px;
+}
+
+.upload-hint {
+    color: var(--text-muted);
+    margin: 12px 0;
+}
+
+.file-name {
+    margin-top: 16px;
+    font-weight: 500;
+    color: var(--primary-color);
+}
+
+/* Progress Bar */
+.upload-progress {
+    margin-bottom: 24px;
+}
+
+.progress-bar {
+    height: 8px;
+    background: var(--border-color);
+    border-radius: 4px;
+    overflow: hidden;
+    margin-bottom: 8px;
+}
+
+.progress-fill {
+    height: 100%;
+    background: var(--primary-color);
+    width: 0%;
+    transition: width 0.3s ease;
+}
+
+/* Submit Result */
+.submit-result {
+    padding: 16px;
+    border-radius: var(--radius-md);
+    margin-bottom: 24px;
+    display: flex;
+    align-items: center;
+    gap: 12px;
+}
+
+.submit-result.success {
+    background: rgba(34, 197, 94, 0.1);
+    color: var(--success-color);
+    border: 1px solid rgba(34, 197, 94, 0.3);
+}
+
+.submit-result.error {
+    background: rgba(239, 68, 68, 0.1);
+    color: var(--error-color);
+    border: 1px solid rgba(239, 68, 68, 0.3);
+}
+
+.submit-result.warning {
+    background: rgba(245, 158, 11, 0.1);
+    color: var(--warning-color);
+    border: 1px solid rgba(245, 158, 11, 0.3);
+}
+
+.result-icon {
+    font-size: 1.25rem;
+}
+
+/* Form */
+.form-group {
+    margin-bottom: 20px;
+}
+
+.form-group label {
+    display: block;
+    font-weight: 500;
+    margin-bottom: 8px;
+}
+
+.form-group input[type="text"] {
+    width: 100%;
+    padding: 12px;
+    border: 1px solid var(--border-color);
+    border-radius: var(--radius-md);
+    font-size: 1rem;
+}
+
+.form-hint {
+    font-size: 0.85rem;
+    color: var(--text-muted);
+    margin-top: 8px;
+}
+
+/* Tables */
+.submissions-table-container {
+    overflow-x: auto;
+}
+
+.submissions-table,
+.leaderboard-table {
+    width: 100%;
+    border-collapse: collapse;
+}
+
+.submissions-table th,
+.submissions-table td,
+.leaderboard-table th,
+.leaderboard-table td {
+    padding: 12px 16px;
+    text-align: left;
+    border-bottom: 1px solid var(--border-color);
+}
+
+.submissions-table th,
+.leaderboard-table th {
+    font-weight: 600;
+    color: var(--text-muted);
+    font-size: 0.85rem;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+}
+
+.submissions-table tbody tr:hover,
+.leaderboard-table tbody tr:hover {
+    background: rgba(99, 102, 241, 0.02);
+}
+
+.empty-message {
+    text-align: center;
+    color: var(--text-muted);
+    padding: 32px;
+}
+
+/* Status Badges */
+.status-badge {
+    display: inline-block;
+    padding: 4px 12px;
+    border-radius: 20px;
+    font-size: 0.8rem;
+    font-weight: 500;
+}
+
+.status-pending {
+    background: rgba(100, 116, 139, 0.15);
+    color: var(--secondary-color);
+}
+
+.status-processing {
+    background: rgba(99, 102, 241, 0.15);
+    color: var(--primary-color);
+}
+
+.status-completed {
+    background: rgba(34, 197, 94, 0.15);
+    color: var(--success-color);
+}
+
+.status-error {
+    background: rgba(239, 68, 68, 0.15);
+    color: var(--error-color);
+}
+
+.status-overlimit {
+    background: rgba(245, 158, 11, 0.15);
+    color: var(--warning-color);
+}
+
+/* Leaderboard Specific */
+.leaderboard-table .rank-col {
+    width: 80px;
+    text-align: center;
+}
+
+.leaderboard-table .team-col {
+    text-align: left;
+}
+
+.leaderboard-table .score-col {
+    width: 150px;
+    text-align: right;
+}
+
+.leaderboard-table .time-col {
+    width: 200px;
+    text-align: right;
+}
+
+.rank-badge {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 36px;
+    height: 36px;
+    border-radius: 50%;
+    font-weight: 700;
+    font-size: 1rem;
+    background: var(--border-color);
+    color: var(--text-muted);
+}
+
+.rank-gold {
+    background: linear-gradient(135deg, #ffd700, #ffb700);
+    color: #7a5c00;
+}
+
+.rank-silver {
+    background: linear-gradient(135deg, #e0e0e0, #bdbdbd);
+    color: #616161;
+}
+
+.rank-bronze {
+    background: linear-gradient(135deg, #cd7f32, #a0522d);
+    color: white;
+}
+
+.score-cell .score-value {
+    font-weight: 600;
+    font-size: 1.1rem;
+    color: var(--primary-color);
+}
+
+.rank-gold .score-value {
+    color: #7a5c00;
+}
+
+/* Loading State */
+.loading-cell {
+    text-align: center;
+    padding: 32px;
+}
+
+.loading-spinner {
+    display: inline-block;
+    width: 20px;
+    height: 20px;
+    border: 2px solid var(--border-color);
+    border-top-color: var(--primary-color);
+    border-radius: 50%;
+    animation: spin 0.8s linear infinite;
+    margin-right: 8px;
+}
+
+@keyframes spin {
+    to { transform: rotate(360deg); }
+}
+
+/* Empty State */
+.empty-state {
+    text-align: center;
+    padding: 48px 24px;
+}
+
+.empty-icon {
+    font-size: 4rem;
+    margin-bottom: 16px;
+}
+
+.empty-state h3 {
+    margin-bottom: 8px;
+}
+
+.empty-state p {
+    color: var(--text-muted);
+    margin-bottom: 24px;
+}
+
+/* Code Blocks */
+pre {
+    background: #1e293b;
+    color: #e2e8f0;
+    padding: 16px;
+    border-radius: var(--radius-md);
+    overflow-x: auto;
+    font-size: 0.9rem;
+    line-height: 1.5;
+}
+
+code {
+    font-family: 'SF Mono', Monaco, 'Cascadia Code', monospace;
+}
+
+p code,
+li code {
+    background: rgba(99, 102, 241, 0.1);
+    padding: 2px 6px;
+    border-radius: 4px;
+    font-size: 0.85rem;
+    color: var(--primary-color);
+}
+
+/* Rules List */
+.rules-list {
+    list-style: none;
+    padding: 0;
+}
+
+.rules-list li {
+    padding: 8px 0;
+    padding-left: 24px;
+    position: relative;
+}
+
+.rules-list li::before {
+    content: "✓";
+    position: absolute;
+    left: 0;
+    color: var(--success-color);
+}
+
+/* Info Box */
+.info-box {
+    background: rgba(99, 102, 241, 0.08);
+    border-left: 4px solid var(--primary-color);
+    padding: 16px;
+    border-radius: 0 var(--radius-md) var(--radius-md) 0;
+    margin: 24px 0;
+}
+
+.info-box h4 {
+    margin-bottom: 8px;
+    color: var(--primary-color);
+}
+
+/* Timeline Table */
+.timeline-table {
+    width: 100%;
+    border-collapse: collapse;
+}
+
+.timeline-table td {
+    padding: 12px 0;
+    border-bottom: 1px solid var(--border-color);
+}
+
+.timeline-table td:first-child {
+    font-weight: 500;
+    width: 200px;
+}
+
+/* CTA Section */
+.cta-section {
+    text-align: center;
+    padding: 32px 0;
+    border-top: 1px solid var(--border-color);
+    margin-top: 32px;
+}
+
+.cta-section p {
+    color: var(--text-muted);
+    margin-bottom: 16px;
+}
+
+/* Hidden */
+.hidden {
+    display: none !important;
+}
+
+/* Responsive */
+@media (max-width: 768px) {
+    .sidebar {
+        width: 100%;
+        height: auto;
+        position: relative;
+    }
+
+    .main-content {
+        margin-left: 0;
+        padding: 16px;
+    }
+
+    .container {
+        flex-direction: column;
+    }
+
+    .upload-area {
+        padding: 32px 16px;
+    }
+}

static/js/main.js

@@ -0,0 +1,226 @@
+/**
+ * ICRA26 Workshop - Main JavaScript
+ * Shared utilities for all pages
+ */
+
+// Common utility functions
+const Utils = {
+    /**
+     * Format bytes to human readable string
+     */
+    formatBytes(bytes) {
+        if (bytes < 1024) return bytes + ' B';
+        if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + ' KB';
+        return (bytes / (1024 * 1024)).toFixed(1) + ' MB';
+    },
+
+    /**
+     * Format date to local string
+     */
+    formatDate(dateString) {
+        return new Date(dateString).toLocaleString();
+    },
+
+    /**
+     * Escape HTML to prevent XSS
+     */
+    escapeHtml(text) {
+        const div = document.createElement('div');
+        div.textContent = text;
+        return div.innerHTML;
+    },
+
+    /**
+     * Show notification message
+     */
+    showNotification(message, type = 'info', duration = 5000) {
+        const container = document.getElementById('notification-container');
+        if (!container) return;
+
+        const notification = document.createElement('div');
+        notification.className = `notification notification-${type}`;
+        notification.innerHTML = `
+            <span class="notification-message">${message}</span>
+            <button class="notification-close">&times;</button>
+        `;
+
+        container.appendChild(notification);
+
+        // Close button handler
+        notification.querySelector('.notification-close').addEventListener('click', () => {
+            notification.remove();
+        });
+
+        // Auto-remove after duration
+        if (duration > 0) {
+            setTimeout(() => notification.remove(), duration);
+        }
+    },
+
+    /**
+     * Debounce function
+     */
+    debounce(func, wait) {
+        let timeout;
+        return function executedFunction(...args) {
+            const later = () => {
+                clearTimeout(timeout);
+                func(...args);
+            };
+            clearTimeout(timeout);
+            timeout = setTimeout(later, wait);
+        };
+    },
+
+    /**
+     * Check if element is in viewport
+     */
+    isInViewport(element) {
+        const rect = element.getBoundingClientRect();
+        return (
+            rect.top >= 0 &&
+            rect.left >= 0 &&
+            rect.bottom <= (window.innerHeight || document.documentElement.clientHeight) &&
+            rect.right <= (window.innerWidth || document.documentElement.clientWidth)
+        );
+    }
+};
+
+// API helper
+const API = {
+    async get(url) {
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        return response.json();
+    },
+
+    async post(url, data) {
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(data),
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ detail: 'Request failed' }));
+            throw new Error(error.detail || 'Request failed');
+        }
+        return response.json();
+    },
+
+    async upload(url, file, onProgress) {
+        return new Promise((resolve, reject) => {
+            const xhr = new XMLHttpRequest();
+            xhr.open('POST', url);
+
+            xhr.upload.addEventListener('progress', (e) => {
+                if (e.lengthComputable && onProgress) {
+                    onProgress((e.loaded / e.total) * 100);
+                }
+            });
+
+            xhr.addEventListener('load', () => {
+                if (xhr.status >= 200 && xhr.status < 300) {
+                    resolve(JSON.parse(xhr.responseText));
+                } else {
+                    try {
+                        const error = JSON.parse(xhr.responseText);
+                        reject(new Error(error.detail || 'Upload failed'));
+                    } catch {
+                        reject(new Error('Upload failed'));
+                    }
+                }
+            });
+
+            xhr.addEventListener('error', () => reject(new Error('Network error')));
+
+            const formData = new FormData();
+            formData.append('file', file);
+            xhr.send(formData);
+        });
+    }
+};
+
+// Auto-refresh helper for leaderboard
+class AutoRefresh {
+    constructor(fetchFn, interval = 30000) {
+        this.fetchFn = fetchFn;
+        this.interval = interval;
+        this.isActive = true;
+    }
+
+    start() {
+        this.isActive = true;
+        this.fetchFn();
+        this.timer = setInterval(() => {
+            if (this.isActive) {
+                this.fetchFn();
+            }
+        }, this.interval);
+    }
+
+    stop() {
+        this.isActive = false;
+        if (this.timer) {
+            clearInterval(this.timer);
+        }
+    }
+
+    refresh() {
+        if (this.isActive) {
+            this.fetchFn();
+        }
+    }
+}
+
+// Status polling helper
+class StatusPoller {
+    constructor(submissionId, onUpdate, onComplete, interval = 3000) {
+        this.submissionId = submissionId;
+        this.onUpdate = onUpdate;
+        this.onComplete = onComplete;
+        this.interval = interval;
+        this.timer = null;
+    }
+
+    start() {
+        const poll = async () => {
+            try {
+                const response = await fetch(`/api/status/${this.submissionId}`);
+                const data = await response.json();
+
+                this.onUpdate(data);
+
+                if (data.status === 'completed' || data.status === 'error') {
+                    this.stop();
+                    if (this.onComplete) {
+                        this.onComplete(data);
+                    }
+                } else {
+                    this.timer = setTimeout(poll, this.interval);
+                }
+            } catch (error) {
+                console.error('Polling error:', error);
+                this.timer = setTimeout(poll, this.interval);
+            }
+        };
+
+        poll();
+    }
+
+    stop() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+}
+
+// Export for use in inline scripts
+window.Utils = Utils;
+window.API = API;
+window.AutoRefresh = AutoRefresh;
+window.StatusPoller = StatusPoller;

submissions.json

@@ -0,0 +1,3 @@
+{
+  "submissions": []
+}

teams.json

@@ -0,0 +1,3 @@
+{
+  "teams": {}
+}

templates/base.html

@@ -0,0 +1,45 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{% block title %}ICRA26 Workshop{% endblock %}</title>
+    <link rel="stylesheet" href="/static/css/style.css">
+</head>
+<body>
+    <div class="container">
+        <!-- Sidebar -->
+        <aside class="sidebar">
+            <div class="sidebar-header">
+                <h1>AgiBot World Challenge 2026</h1>
+                <p class="subtitle">World Model Track Test Server</p>
+            </div>
+            <nav class="sidebar-nav">
+                <a href="/" class="nav-item {% if request.url.path == '/' %}active{% endif %}">
+                    <span class="nav-icon">📋</span>
+                    Challenge Description
+                </a>
+                <a href="/submit" class="nav-item {% if request.url.path == '/submit' %}active{% endif %}">
+                    <span class="nav-icon">📤</span>
+                    Submission
+                </a>
+                <a href="/leaderboard" class="nav-item {% if request.url.path == '/leaderboard' %}active{% endif %}">
+                    <span class="nav-icon">🏆</span>
+                    Leaderboard
+                </a>
+            </nav>
+            <div class="sidebar-footer">
+                <p>ICRA 2026</p>
+            </div>
+        </aside>
+
+        <!-- Main Content -->
+        <main class="main-content">
+            {% block content %}{% endblock %}
+        </main>
+    </div>
+
+    <script src="/static/js/main.js"></script>
+    {% block scripts %}{% endblock %}
+</body>
+</html>

templates/index.html

@@ -0,0 +1,219 @@
+{% extends "base.html" %}
+
+{% block title %}Challenge Description - ICRA26 Workshop{% endblock %}
+
+{% block content %}
+<div class="page-header">
+    <h1>Challenge Description</h1>
+</div>
+
+<div class="content-card">
+<style>
+    .content-card pre,
+    .content-card pre code {
+        color: #ffffff;
+    }
+    .content-card pre code {
+        background: transparent !important;
+        padding: 0;
+    }
+
+    /* Normalize ordered-list indentation in this page */
+    .content-card ol {
+        margin: 0 0 0 1.4rem;
+        padding-left: 0;
+    }
+
+    .content-card ol > li {
+        margin-bottom: 12px;
+        padding-left: 0.2rem;
+    }
+
+    .content-card ol > li > p {
+        margin: 8px 0 0;
+    }
+</style>
+
+    <h2>AgiBot World Challenge ICRA2026 - World Model Track</h2>
+    <p>
+        We've designed a series of challenging tasks covering scenarios including kitchen environments,
+        workbenches, dining tables, and bathroom settings, encompassing diverse robot-object interactions
+        e.g., collisions, grasping, placement, and dragging maneuvers, to thoroughly evaluate models'
+        generative capabilities.
+    </p>
+
+    <h3>🗂️ Dataset</h3>
+    <p>
+        The train, validation and test dataset for the competition can be downloaded from
+        <a href="https://huggingface.co/datasets/agibot-world/AgiBotWorldChallenge-2026/tree/main/WorldModel" target="_blank" rel="noopener noreferrer">
+            AgiBotWorld Challenge-2026 (World Model Track)
+        </a>.
+    </p>
+
+    <h3>🧪 Baseline</h3>
+    <p>
+        We've release the
+        <a href="https://github.com/AgibotTech/AgiBotWorldChallengeICRA2026-WorldModelBaseline" target="_blank" rel="noopener noreferrer">
+            baseline repo
+        </a>.
+        You can train your own world model based on the baseline repo or your own codebase.
+    </p>
+
+    <h3>📝 Rules</h3>
+
+    <p><strong>Authentication</strong>:</p>
+    <p>
+        Please register your team on the
+        <a href="https://agibot-world.com/challenge2026" target="_blank" rel="noopener noreferrer">
+            official website of AgiBotWorldChallengeICRA2026
+        </a>
+        before submitting your results. To identify the team associated with your submission, we require
+        you to include a <code>meta_info.txt</code> file in the compressed file. The first line of this file
+        must be the Email Address used during your team registration.
+    </p>
+
+    <p>A simple example of <code>meta_info.txt</code>:</p>
+    <pre><code>test@test.test</code></pre>
+
+    <p>
+        If the email address in <code>meta_info.txt</code> does not match the list of registered email addresses in
+        <a href="https://agibot-world.com/challenge2026" target="_blank" rel="noopener noreferrer">
+            official website of AgiBotWorldChallengeICRA2026
+        </a>,
+        the evaluation will fail. We update the Team Information on the Google Form daily, so you will be able to
+        submit your results normally <strong>after the day</strong> your registration.
+    </p>
+
+    <p><strong>Submission Limitation</strong>:</p>
+    <p>
+        Each team is limited to <strong>one successfully evaluated submission per calendar day</strong>.
+        The submission count resets daily at midnight, UTC time (based on Hugging Face's server time).
+        If your team exceeds the daily submission limit, the evaluation will not proceed.
+    </p>
+    <p>
+        <strong>Teams are strictly prohibited from registering multiple team accounts to gain extra evaluation attempts.
+        Any team found violating this rule will be disqualified and all related scores will be cancelled.</strong>
+    </p>
+
+    <p>
+        The size of your submitted compressed file should be less than <strong>500MB</strong>.
+        If the compressed file exceeds the size limit, the evaluation will not proceed.
+    </p>
+
+    <p><strong>Reproducibility</strong>:</p>
+    <p>
+        If your team ranking is in the top positions of the leaderboard (public score) when the competition closes,
+        we will send an email to your registered address requesting submission of relevant training and inference codes
+        for validity verification and reproducibility checks. Please be sure to check the detailed instructions in the
+        follow-up email.
+    </p>
+
+    <h3>📦 Submission</h3>
+    <ol>
+        <li>
+            As shown in the instruction of the
+            <a href="https://github.com/AgibotTech/AgiBotWorldChallengeICRA2026-WorldModelBaseline" target="_blank" rel="noopener noreferrer">
+                baseline repo
+            </a>,
+            the prediction directory should contain the following. Note that the number of prediction frames of each
+            episode should be equal to the number of actions minus one because the action array also incude the action
+            of the provided first frame. Moreover, as mentioned above, <strong>meta_info.txt</strong> should be included in
+            the submission folder. Finally, the entire size of the compression file (.zip) should be less than
+            <strong>500 MB</strong>.
+
+            <p>
+                We also provide a template submission file
+                <a href="https://huggingface.co/datasets/agibot-world/AgiBotWorldChallenge-2026/blob/main/WorldModel/template.zip" target="_blank" rel="noopener noreferrer">
+                    here
+                </a>.
+            </p>
+
+            <pre><code>PREDICTIONS/
+├── meta_info.txt
+├── task_0/
+│   ├── episode_0/
+│   │   ├── 0/
+│   │   │   └── video/
+│   │   │       ├── frame_00000.jpg
+│   │   │       ├── frame_00001.jpg
+│   │   │       ├── ...
+│   │   │       └── frame_T0.jpg
+│   │   ├── 1/
+│   │   │   └── video/
+│   │   │       ├── frame_00000.jpg
+│   │   │       ├── frame_00001.jpg
+│   │   │       ├── ...
+│   │   │       └── frame_T0.jpg
+│   │   └── 2/
+│   │       └── video/
+│   │           ├── frame_00000.jpg
+│   │           ├── frame_00001.jpg
+│   │           ├── ...
+│   │           └── frame_T0.jpg
+│   ├── episode_1/
+│   │   ├── 0/
+│   │   │   └── video/
+│   │   │       ├── frame_00000.jpg
+│   │   │       ├── frame_00001.jpg
+│   │   │       ├── ...
+│   │   │       └── frame_T1.jpg
+│   │   ├── 1/
+│   │   │   └── video/
+│   │   │       ├── frame_00000.jpg
+│   │   │       ├── frame_00001.jpg
+│   │   │       ├── ...
+│   │   │       └── frame_T1.jpg
+│   │   └── 2/
+│   │       └── video/
+│   │           ├── frame_00000.jpg
+│   │           ├── frame_00001.jpg
+│   │           ├── ...
+│   │           └── frame_T1.jpg
+│   ├── episode_2/
+│   └── ...
+├── task_1/
+└── ...</code></pre>
+        </li>
+        <li>
+            Compress and submit the predictions
+            <pre><code>cd PARENT_DIRECTORY_OF_PREDICTIONS
+zip -r ./submission.zip ./PREDICTIONS</code></pre>
+        </li>
+        <li>Upload the <code>submission.zip</code>.</li>
+    </ol>
+
+    <h3>📊 Evaluation</h3>
+    <p>
+        Before evaluation, we will resize all predicted images to (480, 640) (the same as the size of ground-truth images).
+        Then, we use <strong>PSNR, scene consistency and nDTW</strong> for evaluation. More details can be found in
+        <a href="https://github.com/AgibotTech/EWMBench" target="_blank" rel="noopener noreferrer">EWMBench</a>
+        and
+        <a href="https://github.com/AgibotTech/AgiBotWorldChallengeICRA2026-WorldModelBaseline" target="_blank" rel="noopener noreferrer">
+            baseline repo
+        </a>.
+    </p>
+
+    <p>
+        To calculate the overall score, we normalize PSNR through
+        <code>np.clip(psnr, a_min=0, a_max=35)/35</code>
+        and then average the scene consistency, nDTW and the normalized PSNR.
+    </p>
+
+    <h3>📅 Timeline</h3>
+    <table class="timeline-table">
+        <tr>
+            <td>Competition Start</td>
+            <td>2/28</td>
+        </tr>
+        <tr>
+            <td>Submission Deadline</td>
+            <td>4/20</td>
+        </tr>
+    </table>
+
+    <div class="cta-section">
+        <p>Ready to compete?</p>
+        <a href="/submit" class="btn btn-primary">Go to Submission</a>
+    </div>
+</div>
+{% endblock %}

templates/leaderboard.html

@@ -0,0 +1,123 @@
+{% extends "base.html" %}
+
+{% block title %}Leaderboard - ICRA26 Workshop{% endblock %}
+
+{% block content %}
+<div class="page-header">
+    <h1>Leaderboard</h1>
+    <p class="page-subtitle">Competition Rankings</p>
+</div>
+
+<div class="content-card">
+    <div class="leaderboard-container">
+        <table class="leaderboard-table">
+            <thead>
+                <tr>
+                    <th class="rank-col">#</th>
+                    <th class="team-col">Team</th>
+                    <th class="score-col">Best Score</th>
+                    <th class="time-col">Last Submit</th>
+                </tr>
+            </thead>
+            <tbody id="leaderboardBody">
+                <tr>
+                    <td colspan="4" class="loading-cell">
+                        <span class="loading-spinner"></span>
+                        Loading...
+                    </td>
+                </tr>
+            </tbody>
+        </table>
+    </div>
+
+    <div id="emptyState" class="empty-state hidden">
+        <div class="empty-icon">📊</div>
+        <h3>No Submissions Yet</h3>
+        <p>Be the first to submit and claim the top spot!</p>
+        <a href="/submit" class="btn btn-primary">Submit Now</a>
+    </div>
+</div>
+{% endblock %}
+
+{% block scripts %}
+<script>
+    async function loadLeaderboard() {
+        try {
+            const response = await fetch('/api/leaderboard');
+            const data = await response.json();
+
+            const tbody = document.getElementById('leaderboardBody');
+            const emptyState = document.getElementById('emptyState');
+
+            if (data.length === 0) {
+                tbody.innerHTML = '';
+                emptyState.classList.remove('hidden');
+                return;
+            }
+
+            emptyState.classList.add('hidden');
+
+            tbody.innerHTML = data.map((entry, index) => {
+                const rank = index + 1;
+                const score = entry.best_score !== null ? entry.best_score : '-';
+                const time = entry.last_submit_time
+                    ? new Date(entry.last_submit_time).toLocaleString()
+                    : '-';
+                const isTop3 = rank <= 3;
+
+                let rankClass = '';
+                let rankIcon = '';
+                if (rank === 1) {
+                    rankClass = 'rank-gold';
+                    rankIcon = '🥇';
+                } else if (rank === 2) {
+                    rankClass = 'rank-silver';
+                    rankIcon = '🥈';
+                } else if (rank === 3) {
+                    rankClass = 'rank-bronze';
+                    rankIcon = '🥉';
+                }
+
+                return `
+                    <tr class="${rankClass}">
+                        <td class="rank-cell">
+                            <span class="rank-badge ${rankClass}">
+                                ${rankIcon || rank}
+                            </span>
+                        </td>
+                        <td class="team-cell">
+                            <span class="team-name">${escapeHtml(entry.team_name)}</span>
+                        </td>
+                        <td class="score-cell">
+                            <span class="score-value">${score}</span>
+                        </td>
+                        <td class="time-cell">${time}</td>
+                    </tr>
+                `;
+            }).join('');
+
+        } catch (error) {
+            console.error('Failed to load leaderboard:', error);
+            document.getElementById('leaderboardBody').innerHTML = `
+                <tr>
+                    <td colspan="4" class="error-cell">
+                        Failed to load leaderboard. Please try again.
+                    </td>
+                </tr>
+            `;
+        }
+    }
+
+    function escapeHtml(text) {
+        const div = document.createElement('div');
+        div.textContent = text;
+        return div.innerHTML;
+    }
+
+    // Load on page load
+    loadLeaderboard();
+
+    // Auto-refresh every 30 seconds
+    setInterval(loadLeaderboard, 30000);
+</script>
+{% endblock %}

templates/submit.html

@@ -0,0 +1,492 @@
+{% extends "base.html" %}
+
+{% block title %}Submission - ICRA26 Workshop{% endblock %}
+
+{% block content %}
+<div class="page-header">
+    <h1>Submission</h1>
+</div>
+
+<!-- Upload Section -->
+<div class="content-card">
+    <h2>Submit Your Results</h2>
+
+    <div class="upload-area" id="uploadArea">
+        <div class="upload-icon">📁</div>
+        <p>Drag & drop your .zip file here</p>
+        <p class="upload-hint">or</p>
+        <label class="btn btn-secondary">
+            Browse Files
+            <input type="file" id="fileInput" accept=".zip" hidden>
+        </label>
+        <p class="file-name" id="fileName"></p>
+    </div>
+
+    <div id="uploadProgress" class="upload-progress hidden">
+        <div class="progress-bar">
+            <div class="progress-fill" id="progressFill"></div>
+        </div>
+        <p id="progressText">Uploading...</p>
+    </div>
+
+    <div id="submitResult" class="submit-result hidden"></div>
+
+    <button class="btn btn-primary btn-large" id="submitBtn" disabled>
+        Submit
+    </button>
+</div>
+
+<!-- Email Check Section -->
+<div class="content-card">
+    <h2>View My Submissions</h2>
+    <p class="section-description">
+        Enter your registered email to view submission history directly.
+    </p>
+    <p class="form-hint">
+        Note: evaluations are queued. During <strong>pending/processing</strong>, records may not appear yet.
+        This section shows submissions after validation/evaluation results are written back.
+    </p>
+
+    <!-- Email Input -->
+    <div class="verification-section" id="emailSection">
+        <div class="form-row">
+            <div class="form-group form-group-large">
+                <label for="emailInput">Email Address</label>
+                <input type="email" id="emailInput" class="input-large" placeholder="Enter your registered email">
+            </div>
+            <div class="form-group form-group-small">
+                <label>&nbsp;</label>
+                <button class="btn btn-secondary btn-full" id="sendCodeBtn">
+                    View
+                </button>
+            </div>
+        </div>
+        <p class="form-hint" id="emailHint"></p>
+    </div>
+</div>
+
+<!-- My Submissions (hidden until verified) -->
+<div class="content-card hidden" id="submissionsCard">
+    <div class="submissions-header">
+        <h2>My Submissions</h2>
+        <span class="team-badge" id="teamBadge"></span>
+    </div>
+
+    <div class="submissions-table-container">
+        <table class="submissions-table" id="submissionsTable">
+            <thead>
+                <tr>
+                    <th>Submit Time</th>
+                    <th>Status</th>
+                    <th>Score</th>
+                    <th>Details</th>
+                </tr>
+            </thead>
+            <tbody id="submissionsBody">
+            </tbody>
+        </table>
+    </div>
+
+    <div class="verified-footer">
+        <p>Queued submissions may take time to appear. Refresh later to check the latest validated results.</p>
+    </div>
+</div>
+{% endblock %}
+
+{% block scripts %}
+<script>
+    // Elements
+    const emailInput = document.getElementById('emailInput');
+    const sendCodeBtn = document.getElementById('sendCodeBtn');
+    const emailHint = document.getElementById('emailHint');
+    const emailSection = document.getElementById('emailSection');
+    const submissionsCard = document.getElementById('submissionsCard');
+    const teamBadge = document.getElementById('teamBadge');
+    const submissionsBody = document.getElementById('submissionsBody');
+
+    // Upload elements
+    const fileInput = document.getElementById('fileInput');
+    const uploadArea = document.getElementById('uploadArea');
+    const fileName = document.getElementById('fileName');
+    const submitBtn = document.getElementById('submitBtn');
+    const uploadProgress = document.getElementById('uploadProgress');
+    const progressFill = document.getElementById('progressFill');
+    const progressText = document.getElementById('progressText');
+    const submitResult = document.getElementById('submitResult');
+
+    let selectedFile = null;
+    let verifiedIdentifier = null;
+
+    // ============== Utility Functions ==============
+
+    function getErrorMessage(data, fallback) {
+        // Safely extract error message from response
+        if (typeof data === 'string') return data;
+        if (data && typeof data.detail === 'string') return data.detail;
+        if (data && typeof data.message === 'string') return data.message;
+        if (data && typeof data.detail === 'object') return JSON.stringify(data.detail);
+        return fallback;
+    }
+
+    // ============== Email Validation Logic ==============
+    sendCodeBtn.addEventListener('click', async () => {
+        const email = emailInput.value.trim().toLowerCase();
+        if (!email) {
+            showEmailHint('Please enter your email address', 'error');
+            return;
+        }
+
+        // Basic email validation
+        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        if (!emailRegex.test(email)) {
+            showEmailHint('Please enter a valid email address', 'error');
+            return;
+        }
+
+        sendCodeBtn.disabled = true;
+        sendCodeBtn.textContent = 'Checking...';
+
+        try {
+            const response = await fetch('/api/validate-email', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ email: email })
+            });
+
+            const data = await response.json();
+
+            if (response.ok) {
+                showEmailHint('Email verified.', 'success');
+                verifiedIdentifier = data.email || email;
+                teamBadge.textContent = data.team_name || verifiedIdentifier;
+                emailSection.classList.add('hidden');
+                submissionsCard.classList.remove('hidden');
+                loadSubmissions(verifiedIdentifier);
+            } else {
+                const errorMsg = getErrorMessage(data, 'Failed to verify email');
+                showEmailHint(errorMsg, 'error');
+            }
+        } catch (error) {
+            showEmailHint('Network error. Please try again.', 'error');
+        } finally {
+            sendCodeBtn.disabled = false;
+            sendCodeBtn.textContent = 'View';
+        }
+    });
+
+    function showEmailHint(message, type) {
+        emailHint.textContent = message;
+        emailHint.className = 'form-hint hint-' + type;
+    }
+
+    // ============== Load Submissions ==============
+
+    async function loadSubmissions(teamName) {
+        try {
+            const response = await fetch(`/api/submissions/${encodeURIComponent(teamName)}`);
+            const submissions = await response.json();
+
+            submissionsBody.innerHTML = '';
+
+            if (submissions.length === 0) {
+                submissionsBody.innerHTML = `
+                    <tr>
+                        <td colspan="4" class="empty-message">No submissions yet</td>
+                    </tr>
+                `;
+                return;
+            }
+
+            submissions.forEach(sub => {
+                addSubmissionToTable(sub);
+            });
+        } catch (error) {
+            console.error('Failed to load submissions:', error);
+            submissionsBody.innerHTML = `
+                <tr>
+                    <td colspan="4" class="error-cell">Failed to load submissions</td>
+                </tr>
+            `;
+        }
+    }
+
+    function addSubmissionToTable(sub) {
+        const row = document.createElement('tr');
+
+        let statusClass = '';
+        let statusText = '';
+        switch (sub.status) {
+            case 'pending':
+                statusClass = 'status-pending';
+                statusText = 'Queued';
+                break;
+            case 'processing':
+                statusClass = 'status-processing';
+                statusText = 'Processing';
+                break;
+            case 'completed':
+                statusClass = 'status-completed';
+                statusText = 'Completed';
+                break;
+            case 'error':
+                statusClass = 'status-error';
+                statusText = 'Error';
+                break;
+            case 'overlimit':
+                statusClass = 'status-overlimit';
+                statusText = 'Over Limit';
+                break;
+        }
+
+        const scoreDisplay = sub.score !== null ? sub.score : (sub.status === 'overlimit' ? '-' : '...');
+        const timeDisplay = new Date(sub.submit_time).toLocaleString();
+
+        row.innerHTML = `
+            <td>${timeDisplay}</td>
+            <td><span class="status-badge ${statusClass}">${statusText}</span></td>
+            <td class="score">${scoreDisplay}</td>
+            <td class="details">${sub.error_message || '-'}</td>
+        `;
+
+        submissionsBody.insertBefore(row, submissionsBody.firstChild);
+    }
+
+    // ============== File Upload Logic ==============
+
+    fileInput.addEventListener('change', (e) => {
+        if (e.target.files.length > 0) {
+            handleFileSelect(e.target.files[0]);
+        }
+    });
+
+    uploadArea.addEventListener('dragover', (e) => {
+        e.preventDefault();
+        uploadArea.classList.add('dragover');
+    });
+
+    uploadArea.addEventListener('dragleave', () => {
+        uploadArea.classList.remove('dragover');
+    });
+
+    uploadArea.addEventListener('drop', (e) => {
+        e.preventDefault();
+        uploadArea.classList.remove('dragover');
+        if (e.dataTransfer.files.length > 0) {
+            handleFileSelect(e.dataTransfer.files[0]);
+        }
+    });
+
+    function handleFileSelect(file) {
+        if (!file.name.endsWith('.zip')) {
+            showSubmitResult('error', 'Only .zip files are allowed');
+            return;
+        }
+
+        selectedFile = file;
+        fileName.textContent = `Selected: ${file.name} (${formatBytes(file.size)})`;
+        submitBtn.disabled = false;
+        submitResult.classList.add('hidden');
+    }
+
+    const MAX_FILE_SIZE_MB = 500;
+
+    submitBtn.addEventListener('click', async () => {
+        if (!selectedFile) return;
+
+        // Check file size before uploading
+        const fileSizeMB = selectedFile.size / (1024 * 1024);
+        if (fileSizeMB > MAX_FILE_SIZE_MB) {
+            showSubmitResult('error', `File too large: ${fileSizeMB.toFixed(2)}MB (max ${MAX_FILE_SIZE_MB}MB)`);
+            return;
+        }
+
+        const formData = new FormData();
+        formData.append('file', selectedFile);
+
+        submitBtn.disabled = true;
+        uploadProgress.classList.remove('hidden');
+        progressFill.style.width = '0%';
+        progressText.textContent = 'Uploading...';
+
+        try {
+            const xhr = new XMLHttpRequest();
+
+            xhr.upload.addEventListener('progress', (e) => {
+                if (e.lengthComputable) {
+                    const percent = (e.loaded / e.total) * 100;
+                    progressFill.style.width = `${percent}%`;
+                }
+            });
+
+            xhr.addEventListener('load', () => {
+                progressText.textContent = 'Processing...';
+                progressFill.style.width = '100%';
+
+                const response = JSON.parse(xhr.responseText);
+
+                if (response.status === 'overlimit') {
+                    showSubmitResult('warning', response.message);
+                } else if (xhr.status === 200) {
+                    showSubmitResult('success', response.message);
+                    // Clear file input after successful upload
+                    fileInput.value = '';
+                    selectedFile = null;
+                    fileName.textContent = 'No file selected';
+                    submitBtn.disabled = true;
+                    // Refresh submissions if verified
+                    if (verifiedIdentifier) {
+                        loadSubmissions(verifiedIdentifier);
+                    }
+                } else {
+                    showSubmitResult('error', response.detail || 'Submission failed');
+                }
+
+                submitBtn.disabled = false;
+                setTimeout(() => {
+                    uploadProgress.classList.add('hidden');
+                }, 1000);
+            });
+
+            xhr.addEventListener('error', () => {
+                showSubmitResult('error', 'Network error occurred');
+                submitBtn.disabled = false;
+                uploadProgress.classList.add('hidden');
+            });
+
+            xhr.open('POST', '/api/submit');
+            xhr.send(formData);
+
+        } catch (error) {
+            showSubmitResult('error', error.message);
+            submitBtn.disabled = false;
+            uploadProgress.classList.add('hidden');
+        }
+    });
+
+    function showSubmitResult(type, message) {
+        submitResult.classList.remove('hidden', 'success', 'error', 'warning');
+        submitResult.classList.add(type);
+        submitResult.innerHTML = `
+            <span class="result-icon">${type === 'success' ? '✓' : type === 'error' ? '✗' : '⚠'}</span>
+            <span>${message}</span>
+        `;
+    }
+
+    function formatBytes(bytes) {
+        if (bytes < 1024) return bytes + ' B';
+        if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + ' KB';
+        return (bytes / (1024 * 1024)).toFixed(1) + ' MB';
+    }
+
+    // Enter key handlers
+    emailInput.addEventListener('keypress', (e) => {
+        if (e.key === 'Enter') {
+            sendCodeBtn.click();
+        }
+    });
+</script>
+
+<style>
+    .section-description {
+        color: var(--text-muted);
+        margin-bottom: 20px;
+    }
+
+    .verification-section {
+        max-width: 600px;
+    }
+
+    .form-row {
+        display: flex;
+        gap: 16px;
+        align-items: flex-end;
+    }
+
+    .form-group {
+        flex: 1;
+    }
+
+    .form-group.form-group-large {
+        flex: 3;
+    }
+
+    .form-group.form-group-small {
+        flex: 1;
+    }
+
+    .input-large {
+        width: 100%;
+        padding: 14px 16px;
+        font-size: 1rem;
+        border: 1px solid var(--border-color);
+        border-radius: var(--radius-md);
+        transition: border-color 0.2s, box-shadow 0.2s;
+    }
+
+    .input-large:focus {
+        outline: none;
+        border-color: var(--primary-color);
+        box-shadow: 0 0 0 3px rgba(99, 102, 241, 0.1);
+    }
+
+    .btn-full {
+        width: 100%;
+        padding: 14px 16px;
+    }
+
+    .code-actions {
+        display: flex;
+        gap: 12px;
+        margin-top: 16px;
+    }
+
+    .code-actions .btn {
+        flex: 1;
+    }
+
+    .hint-success {
+        color: var(--success-color);
+    }
+
+    .hint-error {
+        color: var(--error-color);
+    }
+
+    .submissions-header {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        margin-bottom: 20px;
+    }
+
+    .submissions-header h2 {
+        margin-bottom: 0;
+    }
+
+    .team-badge {
+        background: var(--primary-color);
+        color: white;
+        padding: 6px 16px;
+        border-radius: 20px;
+        font-weight: 500;
+    }
+
+    .verified-footer {
+        margin-top: 20px;
+        padding-top: 16px;
+        border-top: 1px solid var(--border-color);
+        text-align: center;
+    }
+
+    .verified-footer p {
+        color: var(--text-muted);
+        font-size: 0.9rem;
+        margin: 0;
+    }
+
+    .error-cell {
+        color: var(--error-color);
+        text-align: center;
+    }
+</style>
+{% endblock %}

worker.py

@@ -0,0 +1,30 @@
+"""
+Background evaluation worker.
+
+Runs submission queue processing outside the web process so UI/API requests
+remain responsive under evaluation load.
+"""
+import asyncio
+import os
+
+from app import HF_TOKEN, get_storage, load_metric_module, process_submissions
+
+
+async def main():
+    if not HF_TOKEN:
+        print("HF_TOKEN not configured; worker exiting.")
+        return
+
+    # Heavy setup is isolated to this worker process.
+    await asyncio.to_thread(get_storage)
+    await asyncio.to_thread(load_metric_module)
+    print("Evaluation worker started")
+
+    await process_submissions()
+
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        print("Worker stopped")