Update app.py

import json
import os
import re
import threading
import time
from concurrent.futures import ThreadPoolExecutor, as_completed

import gradio as gr
import pandas as pd
import requests
from smolagents import (
CodeAgent,
DuckDuckGoSearchTool,
InferenceClientModel,
LiteLLMModel,
VisitWebpageTool,
tool,
)

# ZeroGPU 하드웨어에서 시작 오류를 막기 위한 더미 함수 (CPU 하드웨어에서는 무시됨)
try:
import spaces

@spaces.GPU
def _gpu_placeholder():
return "ok"
except ImportError:
pass

# ---------------------------------------------------------------------------
# 설정 (Space의 Variables에서 조정 가능)
# ---------------------------------------------------------------------------
DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
FILES_DIR = "/tmp/task_files"
CACHE_PATH = "/tmp/answers_cache.json"
os.makedirs(FILES_DIR, exist_ok=True)

WORKERS = int(os.getenv("WORKERS", "3")) # 동시 실행 문항 수
QUESTION_TIMEOUT = int(os.getenv("QUESTION_TIMEOUT", "240")) # 문항당 제한 시간(초)
MAX_STEPS = int(os.getenv("MAX_STEPS", "8")) # 에이전트 최대 단계

ANSWER_RULES = """
You are a careful research and reasoning agent solving GAIA-style questions.
Rules:
1. Use the tools (web search, webpage visit, file reading, python code) whenever the
question needs facts you are not 100% sure about. Do not guess.
2. The final answer is graded by EXACT MATCH. Return ONLY the answer value, with no
explanation, no units unless asked, no trailing period, no "FINAL ANSWER:" prefix.
3. If the answer is a number: no thousands separators, no currency/percent symbols
unless the question asks for them.
4. If the answer is a list: comma-separated, in the order the question requests.
5. If the answer is a string: no articles (a, an, the) and no abbreviations unless
the question asks for them.
6. If a file path is given, read it with the read_local_file tool or with python code.
7. Be efficient: stop researching as soon as you have a reliable answer.
8. Finish by calling final_answer(...) with the answer only.
"""

# ---------------------------------------------------------------------------
# 캐시 (끊겨도 푼 답은 보존. 컨테이너가 재시작되면 초기화됨)
# ---------------------------------------------------------------------------
_cache_lock = threading.Lock()


def load_cache() -> dict:
try:
with open(CACHE_PATH, "r", encoding="utf-8") as f:
return json.load(f)
except Exception: # noqa: BLE001
return {}


def save_cache_entry(task_id: str, answer: str):
with _cache_lock:
cache = load_cache()
cache[task_id] = answer
with open(CACHE_PATH, "w", encoding="utf-8") as f:
json.dump(cache, f, ensure_ascii=False)


# ---------------------------------------------------------------------------
# 도구
# ---------------------------------------------------------------------------
@tool
def read_local_file(path: str) -> str:
"""Reads a local file (txt, csv, json, py, md, xlsx) and returns its content as text.

Args:
path: Absolute path of the file to read.
"""
try:
lower = path.lower()
if lower.endswith((".xlsx", ".xls")):
sheets = pd.read_excel(path, sheet_name=None)
return "\n\n".join(
f"## Sheet: {n}\n{df.to_string(max_rows=200)}" for n, df in sheets.items()
)
if lower.endswith(".csv"):
return pd.read_csv(path).to_string(max_rows=200)
with open(path, "r", encoding="utf-8", errors="ignore") as f:
return f.read()[:20000]
except Exception as e: # noqa: BLE001
return f"Could not read file: {e}"


# ---------------------------------------------------------------------------
# 에이전트
# ---------------------------------------------------------------------------
def build_model():
gemini_key = os.getenv("GEMINI_API_KEY")
if gemini_key:
model_id = os.getenv("GEMINI_MODEL", "gemini-2.5-flash")
return LiteLLMModel(model_id=f"gemini/{model_id}", api_key=gemini_key)
openai_key = os.getenv("OPENAI_API_KEY")
if openai_key:
model_id = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
return LiteLLMModel(model_id=f"openai/{model_id}", api_key=openai_key)
model_id = os.getenv("HF_MODEL", "Qwen/Qwen2.5-Coder-32B-Instruct")
return InferenceClientModel(model_id=model_id, token=os.getenv("HF_TOKEN"))


def build_agent() -> CodeAgent:
# 스레드 안전을 위해 문항마다 새 에이전트를 만듭니다.
return CodeAgent(
tools=[DuckDuckGoSearchTool(), VisitWebpageTool(), read_local_file],
model=build_model(),
additional_authorized_imports=[
"pandas", "numpy", "re", "json", "math", "datetime",
"collections", "itertools", "statistics", "requests", "bs4",
],
max_steps=MAX_STEPS,
verbosity_level=1,
)


def clean_answer(answer) -> str:
text = str(answer).strip()
text = re.sub(r"^\s*final answer\s*:\s*", "", text, flags=re.IGNORECASE)
return text.strip().rstrip(".").strip()


# ---------------------------------------------------------------------------
# 채점 서버 통신
# ---------------------------------------------------------------------------
def fetch_questions(api_url: str) -> list[dict]:
resp = requests.get(f"{api_url}/questions", timeout=30)
resp.raise_for_status()
data = resp.json()
if not data:
raise ValueError("질문 목록이 비어 있습니다.")
return data


def download_task_file(api_url: str, task_id: str, file_name: str):
if not file_name:
return None
try:
resp = requests.get(f"{api_url}/files/{task_id}", timeout=60)
resp.raise_for_status()
path = os.path.join(FILES_DIR, f"{task_id}_{file_name}")
with open(path, "wb") as f:
f.write(resp.content)
return path
except Exception as e: # noqa: BLE001
print(f"파일 다운로드 실패 ({task_id}): {e}")
return None


# ---------------------------------------------------------------------------
# 문항 풀이 (캐시 + 시간 제한)
# ---------------------------------------------------------------------------
def solve_one(item: dict, api_url: str) -> str:
prompt = ANSWER_RULES + "\n\nQuestion:\n" + item["question"]
file_path = download_task_file(api_url, item["task_id"], item.get("file_name", ""))
if file_path:
prompt += f"\n\nAn attached file is available at: {file_path}"
return clean_answer(build_agent().run(prompt))


def solve_with_timeout(item: dict, api_url: str) -> tuple[str, bool]:
"""(답변, 성공 여부)를 반환합니다. 성공한 답만 캐시에 저장합니다."""
task_id = item["task_id"]
cached = load_cache().get(task_id)
if cached:
print(f"[cache] {task_id} -> {cached}")
return cached, True

box: dict = {}

def target():
try:
box["answer"] = solve_one(item, api_url)
except Exception as e: # noqa: BLE001
box["error"] = str(e)

print(f"[start] {task_id}")
t = threading.Thread(target=target, daemon=True)
t.start()
t.join(QUESTION_TIMEOUT)

if t.is_alive():
print(f"[timeout] {task_id}")
return "unknown", False
if "error" in box:
print(f"[error] {task_id}: {box['error']}")
return "unknown", False
save_cache_entry(task_id, box["answer"])
print(f"[done] {task_id} -> {box['answer']}")
return box["answer"], True


def iter_solve(questions: list[dict], api_url: str):
"""문항을 병렬로 풀면서, 끝나는 대로 (item, answer, ok)를 내보냅니다."""
valid = [q for q in questions if q.get("task_id") and q.get("question") is not None]
with ThreadPoolExecutor(max_workers=WORKERS) as pool:
futures = {pool.submit(solve_with_timeout, q, api_url): q for q in valid}
for fut in as_completed(futures):
answer, ok = fut.result()
yield futures[fut], answer, ok


def make_df(rows: dict, order: list[str]) -> pd.DataFrame:
data = [rows[tid] for tid in order if tid in rows]
return pd.DataFrame(data, columns=["Task ID", "Question", "Submitted Answer", "OK"])


# ---------------------------------------------------------------------------
# Gradio 콜백 (제너레이터: 진행 상황이 실시간으로 화면에 표시됨)
# ---------------------------------------------------------------------------
def run_and_submit_all(profile: gr.OAuthProfile | None):
space_id = os.getenv("SPACE_ID")
if not profile:
yield "먼저 Hugging Face 로그인 버튼으로 로그인해 주세요.", None
return
if not space_id:
yield "SPACE_ID를 찾을 수 없습니다. Space 안에서 실행해야 합니다.", None
return
username = profile.username
api_url = DEFAULT_API_URL
agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"

yield "질문을 가져오는 중...", None
try:
questions = fetch_questions(api_url)
except Exception as e: # noqa: BLE001
yield f"질문 가져오기 오류: {e}", None
return

order = [q["task_id"] for q in questions if q.get("task_id")]
total = len(order)
rows: dict = {}
start = time.time()

for item, answer, ok in iter_solve(questions, api_url):
rows[item["task_id"]] = {
"Task ID": item["task_id"],
"Question": item["question"],
"Submitted Answer": answer,
"OK": "O" if ok else "X",
}
elapsed = int(time.time() - start)
yield f"진행 {len(rows)}/{total} 완료 (경과 {elapsed}초)", make_df(rows, order)

answers_payload = [
{"task_id": tid, "submitted_answer": rows[tid]["Submitted Answer"]}
for tid in order if tid in rows
]
failed = sum(1 for r in rows.values() if r["OK"] == "X")
yield f"풀이 완료 (실패/시간초과 {failed}개). 제출 중...", make_df(rows, order)

submission = {

app.py

@@ -1,7 +1,9 @@
-import spaces
+import json
 import os
 import re
+import threading
 import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
 
 import gradio as gr
 import pandas as pd
@@ -15,17 +17,28 @@ from smolagents import (
     tool,
 )
 
+# ZeroGPU 하드웨어에서 시작 오류를 막기 위한 더미 함수 (CPU 하드웨어에서는 무시됨)
+try:
+    import spaces
+
+    @spaces.GPU
+    def _gpu_placeholder():
+        return "ok"
+except ImportError:
+    pass
+
 # ---------------------------------------------------------------------------
-# 상수
+# 설정 (Space의 Variables에서 조정 가능)
 # ---------------------------------------------------------------------------
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 FILES_DIR = "/tmp/task_files"
+CACHE_PATH = "/tmp/answers_cache.json"
 os.makedirs(FILES_DIR, exist_ok=True)
 
-# 질문 사이 대기 시간(초). 무료 API의 rate limit 방지용
-SLEEP_BETWEEN_QUESTIONS = float(os.getenv("SLEEP_BETWEEN_QUESTIONS", "2"))
+WORKERS = int(os.getenv("WORKERS", "3"))                      # 동시 실행 문항 수
+QUESTION_TIMEOUT = int(os.getenv("QUESTION_TIMEOUT", "240"))  # 문항당 제한 시간(초)
+MAX_STEPS = int(os.getenv("MAX_STEPS", "8"))                  # 에이전트 최대 단계
 
-# 채점이 '정확히 일치(exact match)' 방식이므로 답변 형식 규칙이 매우 중요합니다.
 ANSWER_RULES = """
 You are a careful research and reasoning agent solving GAIA-style questions.
 Rules:
@@ -39,9 +52,31 @@ Rules:
 5. If the answer is a string: no articles (a, an, the) and no abbreviations unless
    the question asks for them.
 6. If a file path is given, read it with the read_local_file tool or with python code.
-7. Finish by calling final_answer(...) with the answer only.
+7. Be efficient: stop researching as soon as you have a reliable answer.
+8. Finish by calling final_answer(...) with the answer only.
 """
 
+# ---------------------------------------------------------------------------
+# 캐시 (끊겨도 푼 답은 보존. 컨테이너가 재시작되면 초기화됨)
+# ---------------------------------------------------------------------------
+_cache_lock = threading.Lock()
+
+
+def load_cache() -> dict:
+    try:
+        with open(CACHE_PATH, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:  # noqa: BLE001
+        return {}
+
+
+def save_cache_entry(task_id: str, answer: str):
+    with _cache_lock:
+        cache = load_cache()
+        cache[task_id] = answer
+        with open(CACHE_PATH, "w", encoding="utf-8") as f:
+            json.dump(cache, f, ensure_ascii=False)
+
 
 # ---------------------------------------------------------------------------
 # 도구
@@ -57,10 +92,9 @@ def read_local_file(path: str) -> str:
         lower = path.lower()
         if lower.endswith((".xlsx", ".xls")):
             sheets = pd.read_excel(path, sheet_name=None)
-            parts = []
-            for name, df in sheets.items():
-                parts.append(f"## Sheet: {name}\n{df.to_string(max_rows=200)}")
-            return "\n\n".join(parts)
+            return "\n\n".join(
+                f"## Sheet: {n}\n{df.to_string(max_rows=200)}" for n, df in sheets.items()
+            )
         if lower.endswith(".csv"):
             return pd.read_csv(path).to_string(max_rows=200)
         with open(path, "r", encoding="utf-8", errors="ignore") as f:
@@ -73,57 +107,40 @@ def read_local_file(path: str) -> str:
 # 에이전트
 # ---------------------------------------------------------------------------
 def build_model():
-    """환경변수(Secrets)에 따라 사용할 LLM을 선택합니다.
-
-    우선순위: GEMINI_API_KEY > OPENAI_API_KEY > HF_TOKEN(기본)
-    """
     gemini_key = os.getenv("GEMINI_API_KEY")
     if gemini_key:
         model_id = os.getenv("GEMINI_MODEL", "gemini-2.5-flash")
-        print(f"[model] Gemini: {model_id}")
         return LiteLLMModel(model_id=f"gemini/{model_id}", api_key=gemini_key)
-
     openai_key = os.getenv("OPENAI_API_KEY")
     if openai_key:
         model_id = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
-        print(f"[model] OpenAI: {model_id}")
         return LiteLLMModel(model_id=f"openai/{model_id}", api_key=openai_key)
-
     model_id = os.getenv("HF_MODEL", "Qwen/Qwen2.5-Coder-32B-Instruct")
-    print(f"[model] HF Inference: {model_id}")
     return InferenceClientModel(model_id=model_id, token=os.getenv("HF_TOKEN"))
 
 
-class BasicAgent:
-    def __init__(self):
-        print("BasicAgent 초기화 중...")
-        self.agent = CodeAgent(
-            tools=[DuckDuckGoSearchTool(), VisitWebpageTool(), read_local_file],
-            model=build_model(),
-            additional_authorized_imports=[
-                "pandas", "numpy", "re", "json", "math", "datetime",
-                "collections", "itertools", "statistics", "requests", "bs4",
-            ],
-            max_steps=int(os.getenv("MAX_STEPS", "12")),
-            verbosity_level=1,
-        )
+def build_agent() -> CodeAgent:
+    # 스레드 안전을 위해 문항마다 새 에이전트를 만듭니다.
+    return CodeAgent(
+        tools=[DuckDuckGoSearchTool(), VisitWebpageTool(), read_local_file],
+        model=build_model(),
+        additional_authorized_imports=[
+            "pandas", "numpy", "re", "json", "math", "datetime",
+            "collections", "itertools", "statistics", "requests", "bs4",
+        ],
+        max_steps=MAX_STEPS,
+        verbosity_level=1,
+    )
 
-    @staticmethod
-    def _clean(answer) -> str:
-        text = str(answer).strip()
-        text = re.sub(r"^\s*final answer\s*:\s*", "", text, flags=re.IGNORECASE)
-        return text.strip().rstrip(".").strip()
 
-    def __call__(self, question: str, file_path: str | None = None) -> str:
-        prompt = ANSWER_RULES + "\n\nQuestion:\n" + question
-        if file_path:
-            prompt += f"\n\nAn attached file is available at: {file_path}"
-        result = self.agent.run(prompt)
-        return self._clean(result)
+def clean_answer(answer) -> str:
+    text = str(answer).strip()
+    text = re.sub(r"^\s*final answer\s*:\s*", "", text, flags=re.IGNORECASE)
+    return text.strip().rstrip(".").strip()
 
 
 # ---------------------------------------------------------------------------
-# 채점 서버 통신 유틸
+# 채점 서버 통신
 # ---------------------------------------------------------------------------
 def fetch_questions(api_url: str) -> list[dict]:
     resp = requests.get(f"{api_url}/questions", timeout=30)
@@ -134,8 +151,7 @@ def fetch_questions(api_url: str) -> list[dict]:
     return data
 
 
-def download_task_file(api_url: str, task_id: str, file_name: str) -> str | None:
-    """질문에 첨부 파일이 있으면 내려받아 경로를 반환합니다."""
+def download_task_file(api_url: str, task_id: str, file_name: str):
     if not file_name:
         return None
     try:
@@ -150,57 +166,107 @@ def download_task_file(api_url: str, task_id: str, file_name: str) -> str | None
         return None
 
 
-def run_questions(agent: BasicAgent, questions: list[dict], api_url: str):
-    answers_payload, results_log = [], []
-    for i, item in enumerate(questions, start=1):
-        task_id = item.get("task_id")
-        question_text = item.get("question")
-        if not task_id or question_text is None:
-            continue
-        print(f"\n===== [{i}/{len(questions)}] task_id={task_id} =====")
-        file_path = download_task_file(api_url, task_id, item.get("file_name", ""))
+# ---------------------------------------------------------------------------
+# 문항 풀이 (캐시 + 시간 제한)
+# ---------------------------------------------------------------------------
+def solve_one(item: dict, api_url: str) -> str:
+    prompt = ANSWER_RULES + "\n\nQuestion:\n" + item["question"]
+    file_path = download_task_file(api_url, item["task_id"], item.get("file_name", ""))
+    if file_path:
+        prompt += f"\n\nAn attached file is available at: {file_path}"
+    return clean_answer(build_agent().run(prompt))
+
+
+def solve_with_timeout(item: dict, api_url: str) -> tuple[str, bool]:
+    """(답변, 성공 여부)를 반환합니다. 성공한 답만 캐시에 저장합니다."""
+    task_id = item["task_id"]
+    cached = load_cache().get(task_id)
+    if cached:
+        print(f"[cache] {task_id} -> {cached}")
+        return cached, True
+
+    box: dict = {}
+
+    def target():
         try:
-            answer = agent(question_text, file_path)
+            box["answer"] = solve_one(item, api_url)
         except Exception as e:  # noqa: BLE001
-            print(f"에이전트 오류: {e}")
-            answer = f"AGENT ERROR: {e}"
-        answers_payload.append({"task_id": task_id, "submitted_answer": answer})
-        results_log.append(
-            {"Task ID": task_id, "Question": question_text, "Submitted Answer": answer}
-        )
-        time.sleep(SLEEP_BETWEEN_QUESTIONS)
-    return answers_payload, results_log
+            box["error"] = str(e)
+
+    print(f"[start] {task_id}")
+    t = threading.Thread(target=target, daemon=True)
+    t.start()
+    t.join(QUESTION_TIMEOUT)
+
+    if t.is_alive():
+        print(f"[timeout] {task_id}")
+        return "unknown", False
+    if "error" in box:
+        print(f"[error] {task_id}: {box['error']}")
+        return "unknown", False
+    save_cache_entry(task_id, box["answer"])
+    print(f"[done] {task_id} -> {box['answer']}")
+    return box["answer"], True
+
+
+def iter_solve(questions: list[dict], api_url: str):
+    """문항을 병렬로 풀면서, 끝나는 대로 (item, answer, ok)를 내보냅니다."""
+    valid = [q for q in questions if q.get("task_id") and q.get("question") is not None]
+    with ThreadPoolExecutor(max_workers=WORKERS) as pool:
+        futures = {pool.submit(solve_with_timeout, q, api_url): q for q in valid}
+        for fut in as_completed(futures):
+            answer, ok = fut.result()
+            yield futures[fut], answer, ok
+
+
+def make_df(rows: dict, order: list[str]) -> pd.DataFrame:
+    data = [rows[tid] for tid in order if tid in rows]
+    return pd.DataFrame(data, columns=["Task ID", "Question", "Submitted Answer", "OK"])
 
 
 # ---------------------------------------------------------------------------
-# Gradio 콜백
+# Gradio 콜백 (제너레이터: 진행 상황이 실시간으로 화면에 표시됨)
 # ---------------------------------------------------------------------------
 def run_and_submit_all(profile: gr.OAuthProfile | None):
-    """전체 질문 실행 -> 제출 -> 점수 확인"""
     space_id = os.getenv("SPACE_ID")
     if not profile:
-        return "먼저 Hugging Face 로그인 버튼으로 로그인해 주세요.", None
+        yield "먼저 Hugging Face 로그인 버튼으로 로그인해 주세요.", None
+        return
+    if not space_id:
+        yield "SPACE_ID를 찾을 수 없습니다. Space 안에서 실행해야 합니다.", None
+        return
     username = profile.username
     api_url = DEFAULT_API_URL
-
-    if not space_id:
-        return "SPACE_ID를 찾을 수 없습니다. Space 안에서 실행해야 합니다.", None
     agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
 
-    try:
-        agent = BasicAgent()
-    except Exception as e:  # noqa: BLE001
-        return f"에이전트 초기화 오류: {e}", None
-
+    yield "질문을 가져오는 중...", None
     try:
         questions = fetch_questions(api_url)
     except Exception as e:  # noqa: BLE001
-        return f"질문 가져오기 오류: {e}", None
-
-    answers_payload, results_log = run_questions(agent, questions, api_url)
-    results_df = pd.DataFrame(results_log)
-    if not answers_payload:
-        return "제출할 답변이 없습니다.", results_df
+        yield f"질문 가져오기 오류: {e}", None
+        return
+
+    order = [q["task_id"] for q in questions if q.get("task_id")]
+    total = len(order)
+    rows: dict = {}
+    start = time.time()
+
+    for item, answer, ok in iter_solve(questions, api_url):
+        rows[item["task_id"]] = {
+            "Task ID": item["task_id"],
+            "Question": item["question"],
+            "Submitted Answer": answer,
+            "OK": "O" if ok else "X",
+        }
+        elapsed = int(time.time() - start)
+        yield f"진행 {len(rows)}/{total} 완료 (경과 {elapsed}초)", make_df(rows, order)
+
+    answers_payload = [
+        {"task_id": tid, "submitted_answer": rows[tid]["Submitted Answer"]}
+        for tid in order if tid in rows
+    ]
+    failed = sum(1 for r in rows.values() if r["OK"] == "X")
+    yield f"풀이 완료 (실패/시간초과 {failed}개). 제출 중...", make_df(rows, order)
 
     submission = {
         "username": username.strip(),
@@ -218,24 +284,46 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             f"({r.get('correct_count', '?')}/{r.get('total_attempted', '?')} 정답)\n"
             f"메시지: {r.get('message', '')}"
         )
-        return status, results_df
     except requests.exceptions.HTTPError as e:
         detail = e.response.text[:500] if e.response is not None else str(e)
-        return f"제출 실패: {detail}", results_df
+        status = f"제출 실패: {detail}"
     except Exception as e:  # noqa: BLE001
-        return f"제출 중 오류: {e}", results_df
+        status = f"제출 중 오류: {e}"
+    yield status, make_df(rows, order)
 
 
 def run_test_only(n_questions: int):
-    """제출 없이 앞의 N개 질문만 실행해 보는 테스트 (점수에 영향 없음)"""
+    """제출 없이 앞의 N개 문항만 실행 (점수에 영향 없음)"""
     api_url = DEFAULT_API_URL
+    yield "질문을 가져오는 중...", None
     try:
-        agent = BasicAgent()
         questions = fetch_questions(api_url)[: int(n_questions)]
     except Exception as e:  # noqa: BLE001
-        return f"준비 중 오류: {e}", None
-    _, results_log = run_questions(agent, questions, api_url)
-    return f"테스트 완료: {len(results_log)}개 질문 실행 (제출하지 않음)", pd.DataFrame(results_log)
+        yield f"준비 중 오류: {e}", None
+        return
+    order = [q["task_id"] for q in questions if q.get("task_id")]
+    rows: dict = {}
+    start = time.time()
+    for item, answer, ok in iter_solve(questions, api_url):
+        rows[item["task_id"]] = {
+            "Task ID": item["task_id"],
+            "Question": item["question"],
+            "Submitted Answer": answer,
+            "OK": "O" if ok else "X",
+        }
+        yield (
+            f"테스트 진행 {len(rows)}/{len(order)} (경과 {int(time.time() - start)}초)",
+            make_df(rows, order),
+        )
+    yield f"테스트 완료 ({int(time.time() - start)}초, 제출 안 함)", make_df(rows, order)
+
+
+def clear_cache():
+    try:
+        os.remove(CACHE_PATH)
+        return "캐시를 삭제했습니다."
+    except FileNotFoundError:
+        return "삭제할 캐시가 없습니다."
 
 
 # ---------------------------------------------------------------------------
@@ -256,6 +344,7 @@ with gr.Blocks() as demo:
     with gr.Row():
         test_n = gr.Number(value=2, label="테스트할 문항 수 (제출 안 함)", precision=0)
         test_button = gr.Button("테스트 실행 (제출 안 함)")
+        cache_button = gr.Button("캐시 초기화")
     run_button = gr.Button("Run Evaluation & Submit All Answers")
 
     status_output = gr.Textbox(label="Run Status / Submission Result", lines=6, interactive=False)
@@ -263,11 +352,8 @@ with gr.Blocks() as demo:
 
     test_button.click(fn=run_test_only, inputs=[test_n], outputs=[status_output, results_table])
     run_button.click(fn=run_and_submit_all, outputs=[status_output, results_table])
-
-@spaces.GPU
-def dummy():
-    return "ok"
+    cache_button.click(fn=clear_cache, outputs=[status_output])
 
 if __name__ == "__main__":
-    demo.launch(debug=True, share=False)
+    demo.queue().launch(debug=True, share=False)