feat: Add optional HF dataset sync for leaderboard

README.md

@@ -48,6 +48,8 @@ hf_oauth: true
 - Hugging Face Dataset repo
   - 기준 데이터: `FRESHQA_DATA_REPO_ID` / `FRESHQA_DATA_FILENAME`
   - (옵션) 제출 추적 저장소: `SUBMISSION_TRACKER_REPO_ID`
+  - (옵션) 리더보드를 Hugging Face dataset에 백업하려면 `UPLOAD_LEADERBOARD_TO_HF=true` 설정
+
 
 설치:
 ```bash
@@ -76,6 +78,10 @@ cp env.example .env
 - UPSTAGE_API_KEY 또는 UPSTAGE_API_KEYS(콤마 구분)
 - ENABLE_SUBMISSION_LIMIT (기본: true)
 - SUBMISSION_TRACKER_REPO_ID (제출 제한 사용 시 필요)
+- UPLOAD_LEADERBOARD_TO_HF  
+  - true: 리더보드를 HF Private Dataset에도 백업(권장: 운영 환경)
+  - false: 로컬 CSV에만 저장(권장: 로컬 개발)
+
 
 검증: 앱 시작 시 `Config.validate_required_configs()`가 누락된 필수 설정을 검사합니다.
 
@@ -108,6 +114,8 @@ Docker(옵션):
 
 3) 리더보드 탭
 - 제출 결과가 `data/leaderboard_results.csv`에 누적
+  - (옵션) `UPLOAD_LEADERBOARD_TO_HF=true`인 경우 Hugging Face Dataset에도  
+  `leaderboard_results.csv`로 자동 업로드됩니다.
 - 검색/새로고침 가능
 
 ---
@@ -122,6 +130,7 @@ Docker(옵션):
    - `freshqa/freshqa_acc.py::calculate_accuracy`, `process_freshqa_dataframe`
 5) 저장:
    - 리더보드: `src/leaderboard_manager.py::append_to_leaderboard_data`
+      - (옵션) 리더보드 HF 저장소 백업: `UPLOAD_LEADERBOARD_TO_HF=true`일 때만
    - (옵션) 제출 이력: `src/submission_tracker.py` (ENABLE_SUBMISSION_LIMIT=true 일 때만)
 
 주의: `ENABLE_SUBMISSION_LIMIT=false`인 경우, 제출 이력 추적용 Hugging Face 저장소 접근을 시도하지 않도록 코드가 반영되어 있습니다.

app.py

@@ -40,7 +40,8 @@ def create_interface():
         with gr.Tabs():
             # 리더보드 탭
             with gr.Tab("🏆 리더보드"):
-                create_leaderboard_tab()
+                # ✅ 리더보드 컴포넌트와 새로고침 함수 받아오기
+                relaxed_table, strict_table, refresh_leaderboard = create_leaderboard_tab()
             
             # 제출 및 평가 탭
             with gr.Tab("📤 제출 및 평가"):
@@ -49,6 +50,13 @@ def create_interface():
             # 데이터셋 다운로드 탭
             with gr.Tab("💾 데이터셋"):
                 create_dataset_tab()
+        
+        # ✅ 앱이 로드될 때마다(사용자가 페이지 처음 열 때마다) 한 번 자동으로 새로고침
+        app.load(
+            fn=refresh_leaderboard,
+            inputs=None,
+            outputs=[relaxed_table, strict_table],
+        )
     
     return app
 

config.py

@@ -49,6 +49,9 @@ class Config:
     ENABLE_SUBMISSION_LIMIT = os.getenv('ENABLE_SUBMISSION_LIMIT', 'true').lower() == 'true'
     SUBMISSION_TRACKER_REPO_ID = os.getenv('SUBMISSION_TRACKER_REPO_ID')
     
+    # 리더보드 HF 업로드 설정
+    UPLOAD_LEADERBOARD_TO_HF = os.getenv('UPLOAD_LEADERBOARD_TO_HF', 'true').lower() == 'true'
+    
     # 환경 설정
     IS_HUGGINGFACE_SPACES = os.getenv("SPACE_ID") is not None
     

env.example

@@ -40,6 +40,17 @@ SUBMISSION_TRACKER_REPO_ID=james-demo-leaderboard-backend/submission-tracker
 # - false: 제출 제한 기능 비활성화 (로컬 테스트용)
 ENABLE_SUBMISSION_LIMIT=true
 
+# ===========================================
+# 리더보드 저장 설정
+# ===========================================
+
+# 리더보드를 HuggingFace private dataset에도 저장할지 여부
+# - true : 로컬 CSV 저장 + HF dataset에도 업로드 (권장: 운영/배포 환경)
+# - false: 로컬 CSV에만 저장 (권장: 로컬 개발 환경)
+UPLOAD_LEADERBOARD_TO_HF=false
+
+# (참고) 리더보드는 기준 데이터와 동일한 Repository(FRESHQA_DATA_REPO_ID)에 leaderboard_results.csv 파일명으로 저장됩니다.
+
 # ===========================================
 # AI 평가 API 설정
 # ===========================================

src/leaderboard_manager.py

@@ -1,228 +1,346 @@
 """
 리더보드 관리 모듈
 리더보드 데이터의 로드, 저장, 표시 준비를 담당합니다.
+
+- 로컬 CSV: 프로젝트 루트의 data/leaderboard_results.csv
+- 선택적 HF 연동:
+    - repo_id: Config.FRESHQA_DATA_REPO_ID
+    - token  : Config.HF_TOKEN
+    - 파일명 : leaderboard_results.csv (repo 루트)
+- Config.UPLOAD_LEADERBOARD_TO_HF == True 일 때만 HF를 읽고/쓴다.
 """
 
-import pandas as pd
 import os
+import time
+import tempfile
+from typing import Optional
+
+import pandas as pd
+from huggingface_hub import HfApi, hf_hub_download
+
+from config import Config
 from src.utils import file_lock
 
-def load_leaderboard_data():
-    """리더보드 데이터 로드"""
+
+# -------------------------
+# 상수 및 설정
+# -------------------------
+
+HF_LEADERBOARD_FILENAME = "leaderboard_results.csv"          # HF dataset 내 파일명 (루트)
+LOCAL_LEADERBOARD_FILENAME = "leaderboard_results.csv"      # 로컬 data 폴더 내 파일명 (기존 유지)
+
+HF_REPO_ID = Config.FRESHQA_DATA_REPO_ID
+HF_ADMIN_TOKEN = Config.HF_TOKEN
+UPLOAD_LEADERBOARD_TO_HF = Config.UPLOAD_LEADERBOARD_TO_HF
+
+hf_api = HfApi()
+
+
+# -------------------------
+# 경로/초기 스키마/정규화 헬퍼
+# -------------------------
+
+def _get_local_leaderboard_path() -> str:
+    """프로젝트 루트 기준 로컬 리더보드 CSV 경로 반환."""
+    current_dir = os.path.dirname(os.path.abspath(__file__))  # src/ 폴더
+    project_root = os.path.dirname(current_dir)               # 프로젝트 루트
+    return os.path.join(project_root, "data", LOCAL_LEADERBOARD_FILENAME)
+
+
+def _init_empty_leaderboard_df() -> pd.DataFrame:
+    """초기 빈 리더보드 스키마 DataFrame."""
+    return pd.DataFrame({
+        "id": [],
+        "model": [],
+        "description": [],
+        "accuracy": [],
+        "fast_changing_accuracy": [],
+        "slow_changing_accuracy": [],
+        "never_changing_accuracy": [],
+        "acc_vp": [],
+        "acc_fp": [],
+        "acc_vp_one_hop": [],
+        "acc_vp_two_hop": [],
+        "acc_fp_one_hop": [],
+        "acc_fp_two_hop": [],
+        "acc_vp_old": [],
+        "acc_vp_new": [],
+        "acc_fp_old": [],
+        "acc_fp_new": [],
+        "acc_politics": [],
+        "acc_sports": [],
+        "acc_entertainment": [],
+        "acc_weather": [],
+        "acc_world": [],
+        "acc_economy": [],
+        "acc_society": [],
+        "acc_it_science": [],
+        "acc_life_culture": [],
+        "acc_unknown": [],
+        "total_questions": [],
+        "evaluation_date": [],
+        "evaluation_mode": [],
+    })
+
+
+def _normalize_leaderboard_df(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    리더보드 DF를 스키마/정렬/컬럼 순서 기준에 맞춰 정규화한다.
+    (기존 load_leaderboard_data의 로직을 함수로 분리)
+    """
+    if df is None or df.empty:
+        return _init_empty_leaderboard_df()
+
+    df = df.copy()
+
+    # evaluation_mode가 없으면 추가
+    if "evaluation_mode" not in df.columns:
+        df["evaluation_mode"] = "Unknown"
+
+    # 텍스트 컬럼 보정
+    text_columns = ["model", "description"]
+    for col in text_columns:
+        if col not in df.columns:
+            df[col] = pd.Series(dtype="object")
+
+    # 상세 분석 컬럼 없으면 추가
+    detailed_columns = [
+        "acc_test", "acc_dev", "acc_vp", "acc_fp", "acc_vp_one_hop", "acc_vp_two_hop",
+        "acc_fp_one_hop", "acc_fp_two_hop", "acc_vp_old", "acc_vp_new", "acc_fp_old", "acc_fp_new",
+    ]
+    for col in detailed_columns:
+        if col not in df.columns:
+            df[col] = 0.0
+
+    # 도메인별 정확도 컬럼 없으면 추가
+    domain_columns = [
+        "acc_politics", "acc_sports", "acc_entertainment",
+        "acc_weather", "acc_world", "acc_economy",
+        "acc_society", "acc_it_science", "acc_life_culture", "acc_unknown",
+    ]
+    for col in domain_columns:
+        if col not in df.columns:
+            df[col] = 0.0
+
+    # accuracy 기준 정렬
+    if "accuracy" in df.columns and not df.empty:
+        df = df.sort_values("accuracy", ascending=False).reset_index(drop=True)
+
+    # 컬럼 순서 정렬 (rank 제외)
+    column_order = [
+        "id", "model", "description", "accuracy", "fast_changing_accuracy",
+        "slow_changing_accuracy", "never_changing_accuracy", "acc_vp", "acc_fp",
+        "acc_vp_one_hop", "acc_vp_two_hop", "acc_fp_one_hop", "acc_fp_two_hop",
+        "acc_vp_old", "acc_vp_new", "acc_fp_old", "acc_fp_new",
+        "acc_politics", "acc_sports", "acc_entertainment", "acc_weather",
+        "acc_world", "acc_economy", "acc_society", "acc_it_science",
+        "acc_life_culture", "acc_unknown", "total_questions",
+        "evaluation_date", "evaluation_mode",
+    ]
+    available_columns = [col for col in column_order if col in df.columns]
+    df = df[available_columns]
+
+    return df
+
+
+def _load_local_leaderboard_df() -> pd.DataFrame:
+    """로컬 CSV에서 리더보드 로드 (없으면 빈 ��키마)."""
+    data_path = _get_local_leaderboard_path()
     try:
-        # 프로젝트 루트에서 data 디렉토리 찾기
-        current_dir = os.path.dirname(os.path.abspath(__file__))  # src/ 폴더
-        project_root = os.path.dirname(current_dir)  # 프로젝트 루트
-        data_path = os.path.join(project_root, 'data', 'leaderboard_results.csv')
         df = pd.read_csv(data_path)
-        
-        # 기존 데이터에 evaluation_mode 컬럼이 없으면 추가
-        if 'evaluation_mode' not in df.columns:
-            df['evaluation_mode'] = 'Unknown'
-        
-        text_columns = ['model', 'description']
-        for col in text_columns:
-            if col not in df.columns:
-                df[col] = pd.Series(dtype='object')
-        
-        
-        # 새로운 상세 분석 컬럼들이 없으면 추가
-        detailed_columns = [
-            'acc_test', 'acc_dev', 'acc_vp', 'acc_fp', 'acc_vp_one_hop', 'acc_vp_two_hop',
-            'acc_fp_one_hop', 'acc_fp_two_hop', 'acc_vp_old', 'acc_vp_new', 'acc_fp_old', 'acc_fp_new'
-        ]
-        
-        for col in detailed_columns:
-            if col not in df.columns:
-                df[col] = 0.0
-        
-        # 도메인별 정확도 컬럼들이 없으면 추가 (freshqa_acc.py와 일치)
-        domain_columns = [
-            'acc_politics', 'acc_sports', 'acc_entertainment', 
-            'acc_weather', 'acc_world', 'acc_economy', 
-            'acc_society', 'acc_it_science', 'acc_life_culture', 'acc_unknown'
-        ]
-        
-        for col in domain_columns:
-            if col not in df.columns:
-                df[col] = 0.0
-        
-        # accuracy 기준으로 정렬 (랭킹 기준) - 빈 데이터프레임이 아닐 때만
-        if not df.empty and 'accuracy' in df.columns:
-            df = df.sort_values('accuracy', ascending=False).reset_index(drop=True)
-        
-        # rank 컬럼은 저장하지 않고 표시 시에만 계산
-        # 숫자 컬럼들은 원본 그대로 저장 (반올림하지 않음)
-        
-        # 컬럼 순서를 헤더와 맞춰서 정렬 (rank 제외)
-        column_order = [
-            'id', 'model', 'description', 'accuracy', 'fast_changing_accuracy', 
-            'slow_changing_accuracy', 'never_changing_accuracy', 'acc_vp', 'acc_fp', 
-            'acc_vp_one_hop', 'acc_vp_two_hop', 'acc_fp_one_hop', 'acc_fp_two_hop',
-            'acc_vp_old', 'acc_vp_new', 'acc_fp_old', 'acc_fp_new',
-            'acc_politics', 'acc_sports', 'acc_entertainment', 'acc_weather', 
-            'acc_world', 'acc_economy', 'acc_society', 'acc_it_science', 
-            'acc_life_culture', 'acc_unknown', 'total_questions', 'evaluation_date', 'evaluation_mode'
-        ]
-        
-        # 존재하는 컬럼만 선택하여 순서대로 정렬
-        available_columns = [col for col in column_order if col in df.columns]
-        df = df[available_columns]
-            
-        return df
+        return _normalize_leaderboard_df(df)
     except FileNotFoundError:
-        # 초기 데이터 (rank 제외)
-        return pd.DataFrame({
-            'id': [],
-            'model': [],
-            'description': [],
-            'accuracy': [],
-            'fast_changing_accuracy': [],
-            'slow_changing_accuracy': [],
-            'never_changing_accuracy': [],
-            'acc_vp': [],
-            'acc_fp': [],
-            'acc_vp_one_hop': [],
-            'acc_vp_two_hop': [],
-            'acc_fp_one_hop': [],
-            'acc_fp_two_hop': [],
-            'acc_vp_old': [],
-            'acc_vp_new': [],
-            'acc_fp_old': [],
-            'acc_fp_new': [],
-            'acc_politics': [],
-            'acc_sports': [],
-            'acc_entertainment': [],
-            'acc_weather': [],
-            'acc_world': [],
-            'acc_economy': [],
-            'acc_society': [],
-            'acc_it_science': [],
-            'acc_life_culture': [],
-            'acc_unknown': [],
-            'total_questions': [],
-            'evaluation_date': [],
-            'evaluation_mode': []
-        })
+        return _init_empty_leaderboard_df()
+    except Exception as e:
+        print(f"⚠️ 로컬 리더보드 로드 실패: {e}")
+        return _init_empty_leaderboard_df()
+
+
+# -------------------------
+# HF 연동 헬퍼
+# -------------------------
+
+def _can_use_hf() -> bool:
+    """HF 연동이 가능한 상태인지 여부 (Config 기반)."""
+    if not UPLOAD_LEADERBOARD_TO_HF:
+        return False
+    if not HF_REPO_ID or not HF_ADMIN_TOKEN:
+        # 설정이 없으면 HF는 건너뜀
+        return False
+    return True
+
+
+def _load_leaderboard_from_hf(retries: int = 3, delay: float = 1.0) -> Optional[pd.DataFrame]:
+    """
+    HF dataset에서 리더보드 CSV를 다운로드하여 DataFrame으로 반환.
+    실패 시 None 반환. 재시도 로직 포함.
+    """
+    if not _can_use_hf():
+        return None
+
+    last_err: Optional[Exception] = None
+    for attempt in range(1, retries + 1):
+        try:
+            with tempfile.TemporaryDirectory() as tmpdir:
+                file_path = hf_hub_download(
+                    repo_id=HF_REPO_ID,
+                    filename=HF_LEADERBOARD_FILENAME,
+                    repo_type="dataset",
+                    local_dir=tmpdir,
+                    token=HF_ADMIN_TOKEN,
+                )
+                df = pd.read_csv(file_path)
+                return _normalize_leaderboard_df(df)
+        except Exception as e:
+            last_err = e
+            print(f"⚠️ HF 리더보드 로드 실패 (시도 {attempt}/{retries}): {e}")
+            if attempt < retries:
+                time.sleep(delay)
+                delay *= 2
+    print("❌ HF 리더보드 로드 재시도 모두 실패")
+    return None
+
+
+def _save_leaderboard_to_hf(df: pd.DataFrame, retries: int = 3, delay: float = 1.0) -> bool:
+    """
+    HF dataset에 리더보드 CSV 업로드.
+    실패 시 False 반환. 재시도 로직 포함.
+    """
+    if not _can_use_hf():
+        return False
+
+    df = _normalize_leaderboard_df(df)
+
+    last_err: Optional[Exception] = None
+    for attempt in range(1, retries + 1):
+        try:
+            with tempfile.NamedTemporaryFile(
+                mode="w",
+                encoding="utf-8",
+                suffix=".csv",
+                delete=False,
+            ) as tmpfile:
+                df.to_csv(tmpfile.name, index=False)
+                tmp_path = tmpfile.name
+
+            hf_api.upload_file(
+                path_or_fileobj=tmp_path,
+                path_in_repo=HF_LEADERBOARD_FILENAME,
+                repo_id=HF_REPO_ID,
+                repo_type="dataset",
+                token=HF_ADMIN_TOKEN,
+                commit_message="Update leaderboard results",
+            )
+
+            os.unlink(tmp_path)
+            return True
+
+        except Exception as e:
+            last_err = e
+            print(f"⚠️ HF 리더보드 업로드 실패 (시도 {attempt}/{retries}): {e}")
+            if attempt < retries:
+                time.sleep(delay)
+                delay *= 2
+
+    print(f"❌ HF 리더보드 업로드 재시도 모두 실패: {last_err}")
+    return False
+
+
+# -------------------------
+# 공개 API: 로드 / 추가
+# -------------------------
+
+def load_leaderboard_data() -> pd.DataFrame:
+    """
+    리더보드 데이터 로드.
+
+    동작 우선순위:
+    1) Config.UPLOAD_LEADERBOARD_TO_HF == True && HF 설정 OK:
+        - HF에서 최신 리더보드 로드 시도
+        - 성공 시: 그 내용을 로컬 CSV에 덮어쓴 뒤 반환
+        - 실패 시: 로컬 CSV를 사용 (없으면 빈 스키마)
+    2) 그 외:
+        - 로컬 CSV만 사용 (없으면 빈 스키마)
+    """
+    data_path = _get_local_leaderboard_path()
+    lock_path = data_path + ".lock"
+
+    # HF를 사용할 수 있는 경우에만 HF 우선 시도
+    if _can_use_hf():
+        with file_lock(lock_path):
+            hf_df = _load_leaderboard_from_hf()
+            if hf_df is not None:
+                # HF가 소스 오브 트루스: 로컬 CSV도 HF 기준으로 동기화
+                try:
+                    os.makedirs(os.path.dirname(data_path), exist_ok=True)
+                    hf_df.to_csv(data_path, index=False)
+                except Exception as e:
+                    print(f"⚠️ 로컬 리더보드 동기화 실패: {e}")
+                return hf_df
+
+            # HF에서 못 가져오면 로컬로 폴백
+            local_df = _load_local_leaderboard_df()
+            return local_df
+
+    # HF를 사용하지 않는 경우: 로컬만
+    return _load_local_leaderboard_df()
+
 
 def append_to_leaderboard_data(new_data_list):
-    """리더보드 데이터에 새로운 결과 추가 (파일 잠금 사용)"""
-    current_dir = os.path.dirname(os.path.abspath(__file__))  # src/ 폴더
-    project_root = os.path.dirname(current_dir)  # 프로젝트 루트
-    data_path = os.path.join(project_root, 'data', 'leaderboard_results.csv')
-    
-    # 파일 잠금을 사용하여 안전하게 읽기 -> 수정 -> 쓰기
-    with file_lock(data_path + '.lock'):
-        # 파일이 존재하면 읽기
+    """
+    리더보드 데이터에 새로운 결과 추가 (파일 잠금 사용).
+
+    - 항상 로컬 CSV를 업데이트
+    - Config.UPLOAD_LEADERBOARD_TO_HF == True 이고 HF 설정이 유효하면,
+      업데이트된 전체 DF를 HF에도 업로드 (재시도 포함).
+    """
+    data_path = _get_local_leaderboard_path()
+    lock_path = data_path + ".lock"
+
+    with file_lock(lock_path):
+        # 1) 로컬 기존 데이터 로드
         if os.path.exists(data_path):
-            existing_df = pd.read_csv(data_path)
-            for col in ['model', 'description']:
-                if col not in existing_df.columns:
-                    existing_df[col] = pd.Series(dtype='object')
+            try:
+                existing_df = pd.read_csv(data_path)
+            except Exception as e:
+                print(f"⚠️ 로컬 리더보드 읽��� 실패, 빈 스키마로 진행: {e}")
+                existing_df = _init_empty_leaderboard_df()
         else:
-            # 파일이 없으면 빈 DataFrame 생성
-            existing_df = load_leaderboard_data()  # 초기 스키마 반환
-        
-        # 새로운 데이터 추가
+            existing_df = _init_empty_leaderboard_df()
+
+        existing_df = _normalize_leaderboard_df(existing_df)
+
+        # 2) 새로운 데이터 추가
         new_df = pd.DataFrame(new_data_list)
+        if not new_df.empty:
+            new_df = _normalize_leaderboard_df(new_df)
 
-        # FutureWarning 방지: 빈 DataFrame은 제외하고 결합
         frames_to_concat = []
-        if isinstance(existing_df, pd.DataFrame) and not existing_df.empty:
+        if not existing_df.empty:
             frames_to_concat.append(existing_df)
-        if isinstance(new_df, pd.DataFrame) and not new_df.empty:
+        if not new_df.empty:
             frames_to_concat.append(new_df)
-        
+
         if len(frames_to_concat) == 0:
-            # 둘 다 비어있으면 기존 스키마 유지
             combined_df = existing_df.copy()
         elif len(frames_to_concat) == 1:
             combined_df = frames_to_concat[0].copy()
         else:
             combined_df = pd.concat(frames_to_concat, ignore_index=True)
-        
-        # 정렬 (accuracy 기준)
-        if not combined_df.empty and 'accuracy' in combined_df.columns:
-            combined_df = combined_df.sort_values('accuracy', ascending=False).reset_index(drop=True)
-
-        desired_order = [
-            'id', 'model', 'description', 'accuracy', 'fast_changing_accuracy',
-            'slow_changing_accuracy', 'never_changing_accuracy', 'acc_vp', 'acc_fp',
-            'acc_vp_one_hop', 'acc_vp_two_hop', 'acc_fp_one_hop', 'acc_fp_two_hop',
-            'acc_vp_old', 'acc_vp_new', 'acc_fp_old', 'acc_fp_new',
-            'acc_politics', 'acc_sports', 'acc_entertainment', 'acc_weather',
-            'acc_world', 'acc_economy', 'acc_society', 'acc_it_science',
-            'acc_life_culture', 'acc_unknown', 'total_questions', 'evaluation_date', 'evaluation_mode'
-        ]
-        combined_df = combined_df.reindex(columns=[col for col in desired_order if col in combined_df.columns])
-        
-        # 저장
-        combined_df.to_csv(data_path, index=False)
-        
-        return combined_df
-    
-def prepare_display_data(df, global_ranking=None):
-    """테이블 표시용 데이터 준비 (rank 계산 및 반올림 적용)"""
-    # 빈 데이터프레임인 경우 그대로 반환
-    if df.empty:
-        return df
-    
-    display_df = df.copy()
-    if 'model' in display_df.columns:
-        display_df['model'] = display_df['model'].fillna('Anonymous Model')
-        display_df['model'] = display_df['model'].replace('', 'Anonymous Model')
-    if 'description' in display_df.columns:
-        display_df['description'] = display_df['description'].replace({None: '', pd.NA: ''}).fillna('')
-    
-    # rank 컬럼 추가
-    if 'accuracy' in display_df.columns:
-        if global_ranking is not None:
-            # 전체 랭킹 정보가 제공된 경우 사용
-            display_df['rank'] = display_df.index.map(global_ranking)
-        else:
-            # 전체 랭킹 정보가 없는 경우 accuracy 기준으로 정렬하여 rank 계산
-            display_df = display_df.sort_values('accuracy', ascending=False).reset_index(drop=True)
-            
-            # rank 컬럼 추가 (1~3위는 아이콘, 나머지는 숫자)
-            def get_rank_display(rank):
-                if rank == 1:
-                    return "🥇"
-                elif rank == 2:
-                    return "🥈"
-                elif rank == 3:
-                    return "🥉"
-                else:
-                    return str(rank)
-            
-            display_df['rank'] = [get_rank_display(i+1) for i in range(len(display_df))]
-    
-    # 숫자 컬럼들을 소숫점 2번째에서 반올림 (표시용으로만)
-    numeric_columns = [
-        'accuracy', 'fast_changing_accuracy', 'slow_changing_accuracy', 'never_changing_accuracy', 
-        'acc_vp', 'acc_fp', 'acc_vp_one_hop', 'acc_vp_two_hop', 'acc_fp_one_hop', 'acc_fp_two_hop',
-        'acc_vp_old', 'acc_vp_new', 'acc_fp_old', 'acc_fp_new',
-        'acc_politics', 'acc_sports', 'acc_entertainment', 'acc_weather', 
-        'acc_world', 'acc_economy', 'acc_society', 'acc_it_science', 
-        'acc_life_culture', 'acc_unknown'
-    ]
-    
-    for col in numeric_columns:
-        if col in display_df.columns:
-            display_df[col] = display_df[col].round(2)
-    
-    # 컬럼 순서 재정렬 (rank를 맨 앞에)
-    column_order = [
-        'rank', 'id', 'model', 'description', 'accuracy', 'fast_changing_accuracy', 
-        'slow_changing_accuracy', 'never_changing_accuracy', 'acc_vp', 'acc_fp', 
-        'acc_vp_one_hop', 'acc_vp_two_hop', 'acc_fp_one_hop', 'acc_fp_two_hop',
-        'acc_vp_old', 'acc_vp_new', 'acc_fp_old', 'acc_fp_new',
-        'acc_politics', 'acc_sports', 'acc_entertainment', 'acc_weather', 
-        'acc_world', 'acc_economy', 'acc_society', 'acc_it_science', 
-        'acc_life_culture', 'acc_unknown', 'total_questions', 'evaluation_date', 'evaluation_mode'
-    ]
-    
-    # 존재하는 컬럼만 선택하여 순서대로 정렬
-    available_columns = [col for col in column_order if col in display_df.columns]
-    display_df = display_df[available_columns]
-    
-    return display_df
+
+        combined_df = _normalize_leaderboard_df(combined_df)
+
+        # 3) 로컬 저장
+        try:
+            os.makedirs(os.path.dirname(data_path), exist_ok=True)
+            combined_df.to_csv(data_path, index=False)
+        except Exception as e:
+            print(f"❌ 로컬 리더보드 저장 실패: {e}")
+
+        # 4) HF에도 업로드 (옵션)
+        if _can_use_hf():
+            ok = _save_leaderboard_to_hf(combined_df)
+            if not ok:
+                print("⚠️ 리더보드 HF 업로드 실패 (로컬에는 저장됨)")
+
+        return combined_df

ui/leaderboard_tab.py

@@ -6,7 +6,7 @@
 
 import gradio as gr
 import pandas as pd
-from src.leaderboard_manager import load_leaderboard_data, prepare_display_data
+from src.leaderboard_manager import load_leaderboard_data
 
 
 def create_leaderboard_tab():
@@ -91,6 +91,83 @@ def create_leaderboard_tab():
         'acc_life_culture': 'Life/Culture',
         'acc_unknown': 'Unknown'
     }
+
+    def prepare_display_data(df: pd.DataFrame, global_ranking=None) -> pd.DataFrame:
+        """테이블 표시용 데이터 준비 (rank 계산 및 반올림 적용)"""
+        # 빈 데이터프레임인 경우 그대로 반환
+        if df is None or df.empty:
+            return df if df is not None else pd.DataFrame()
+
+        display_df = df.copy()
+
+        # model / description 기본값 처리
+        if "model" in display_df.columns:
+            display_df["model"] = display_df["model"].fillna("Anonymous Model")
+            display_df["model"] = display_df["model"].replace("", "Anonymous Model")
+        if "description" in display_df.columns:
+            display_df["description"] = (
+                display_df["description"]
+                .replace({None: "", pd.NA: ""})
+                .fillna("")
+            )
+
+        # rank 컬럼 추가
+        if "accuracy" in display_df.columns:
+            if global_ranking is not None:
+                # 외부에서 전체 랭킹 정보를 제공하는 경우
+                display_df["rank"] = display_df.index.map(global_ranking)
+            else:
+                # accuracy 기준으로 정렬하여 rank 계산
+                display_df = display_df.sort_values("accuracy", ascending=False).reset_index(
+                    drop=True
+                )
+
+                def get_rank_display(rank: int) -> str:
+                    if rank == 1:
+                        return "🥇"
+                    elif rank == 2:
+                        return "🥈"
+                    elif rank == 3:
+                        return "🥉"
+                    else:
+                        return str(rank)
+
+                display_df["rank"] = [get_rank_display(i + 1) for i in range(len(display_df))]
+
+        # 숫자 컬럼들을 소숫점 2번째에서 반올림 (표시용으로만)
+        numeric_columns = [
+            "accuracy",
+            "fast_changing_accuracy",
+            "slow_changing_accuracy",
+            "never_changing_accuracy",
+            "acc_vp",
+            "acc_fp",
+            "acc_vp_one_hop",
+            "acc_vp_two_hop",
+            "acc_fp_one_hop",
+            "acc_fp_two_hop",
+            "acc_vp_old",
+            "acc_vp_new",
+            "acc_fp_old",
+            "acc_fp_new",
+            "acc_politics",
+            "acc_sports",
+            "acc_entertainment",
+            "acc_weather",
+            "acc_world",
+            "acc_economy",
+            "acc_society",
+            "acc_it_science",
+            "acc_life_culture",
+            "acc_unknown",
+        ]
+
+        for col in numeric_columns:
+            if col in display_df.columns:
+                display_df[col] = display_df[col].round(2)
+
+        return display_df
+
     
     def format_leaderboard(df: pd.DataFrame) -> pd.DataFrame:
         """리더보드에 노출할 컬럼 선택 및 헤더명 변환"""
@@ -122,6 +199,7 @@ def create_leaderboard_tab():
         is_empty = relaxed_df.empty and strict_df.empty
         return formatted_relaxed, formatted_strict, is_empty
 
+    # ✅ 초기 값 (앱 빌드 시점 기준)
     leaderboard_data = load_leaderboard_data()
     relaxed_initial, strict_initial, is_initial_empty = build_leaderboard_state(leaderboard_data)
 
@@ -166,7 +244,6 @@ def create_leaderboard_tab():
         """)
 
 
-    
     # 통합 검색 필터 함수 (Relaxed와 Strict 모드 모두 필터링)
     def filter_leaderboard_data(search_text):
         """Relaxed와 Strict 모드 리더보드 데이터 필터링 (CSV 기반)"""
@@ -216,7 +293,6 @@ def create_leaderboard_tab():
         try:
             all_df = load_leaderboard_data()
             formatted_relaxed, formatted_strict, is_empty = build_leaderboard_state(all_df)
-
             return formatted_relaxed, formatted_strict
         except Exception as e:
             print(f"❌ 리더보드 새로고침 실패: {e}")
@@ -227,3 +303,6 @@ def create_leaderboard_tab():
         fn=refresh_leaderboard,
         outputs=[relaxed_leaderboard_table, strict_leaderboard_table]
     )
+
+    # ✅ app.py에서 초기 로딩 시에도 재사용할 수 있도록 return
+    return relaxed_leaderboard_table, strict_leaderboard_table, refresh_leaderboard