fix: tz-naive datetime crash + initial-backup safety + English-only sweep

battle_arena.py

@@ -72,9 +72,9 @@ async def create_battle_room(
     duration_hours: 1 hour ~ 365 days (8760 hours)
     """
     if not title or len(title) < 10:
-        return False, "❌ Title must be 10+ characters", None
+        return False, "❌ Title must be at least 10 characters", None
     if not option_a or not option_b:
-        return False, "❌ Options A/B required", None
+        return False, "❌ Options A/B are required", None
     if duration_hours < 1 or duration_hours > 8760:
         return False, "❌ Duration: 1 hour ~ 365 days", None
     if is_npc and battle_type != 'opinion':
@@ -150,9 +150,9 @@ async def place_bet(
 ) -> Tuple[bool, str]:
     """Execute bet (1-100 GPU random bet)"""
     if choice not in ['A', 'B']:
-        return False, "❌ Choose A or B"
+        return False, "❌ Please select A or B"
     if bet_amount < 1 or bet_amount > 100:
-        return False, "❌ Bet 1-100 GPU"
+        return False, "❌ Please bet within 1-100 GPU range"
     
     async with aiosqlite.connect(db_path, timeout=30.0) as db:
         await db.execute("PRAGMA busy_timeout=30000")
@@ -165,12 +165,12 @@ async def place_bet(
         )
         room = await cursor.fetchone()
         if not room:
-            return False, "❌ Room not found or closed"
-        
+            return False, "❌ Battle not found or ended"
+
         room = dict(room)
         end_time = datetime.fromisoformat(room['end_time'])
         if datetime.now() >= end_time:
-            return False, "❌ Betting closed"
+            return False, "❌ Betting has closed"
         
         # Check duplicate bet
         if is_npc:
@@ -209,7 +209,7 @@ async def place_bet(
             if not user_row:
                 return False, f"❌ User not found ({bettor_id})"
             if user_row[0] < bet_amount:
-                return False, f"❌ Insufficient GPU (보유: {user_row[0]}, 필요: {bet_amount})"
+                return False, f"❌ Insufficient GPU (have: {user_row[0]}, need: {bet_amount})"
             await db.execute(
                 "UPDATE user_profiles SET gpu_dollars=gpu_dollars-? WHERE email=?",
                 (bet_amount, bettor_id)
@@ -248,7 +248,7 @@ async def place_bet(
             )
         
         await db.commit()
-        return True, f"✅ {choice} 베팅 완료! ({bet_amount} GPU)"
+        return True, f"✅ {choice} bet placed! ({bet_amount} GPU)"
 
 async def set_battle_result(
     db_path: str,
@@ -262,13 +262,13 @@ async def set_battle_result(
         db_path: Database path
         room_id: Battle room ID
         admin_email: Admin email (for verification)
-        winner: 'A', 'B', 'draw' 중 하나
-    
+        winner: One of 'A', 'B', 'draw'
+
     Returns:
         (success status, message)
     """
     if winner not in ['A', 'B', 'draw']:
-        return False, "❌ winner는 'A', 'B', 'draw' 중 하나여야 함"
+        return False, "❌ winner must be one of 'A', 'B', 'draw'"
     
     async with aiosqlite.connect(db_path, timeout=30.0) as db:
         await db.execute("PRAGMA busy_timeout=30000")
@@ -280,13 +280,13 @@ async def set_battle_result(
         )
         room = await cursor.fetchone()
         if not room:
-            return False, "❌ Active battle not found"
-        
+            return False, "❌ No active battle found"
+
         room = dict(room)
-        
+
         # Only prediction type allows admin result setting
         if room['battle_type'] != 'prediction':
-            return False, "❌ Opinion battles are auto-judged"
+            return False, "❌ Opinion battles are resolved automatically"
         
         # Save result
         await db.execute(
@@ -305,7 +305,7 @@ async def set_battle_result(
             else:
                 time_str = f"{int(remaining.seconds//3600)} hours"
             
-            return True, f"✅ 결과 설정: '{option_name}' (베팅 마감 후 자동 판정, 남은  hours: {time_str})"
+            return True, f"✅ Result set: '{option_name}' (auto-resolved after betting closes, remaining hours: {time_str})"
         
         # If after deadline, judge immediately
         return await resolve_battle(db_path, room_id)
@@ -326,8 +326,8 @@ async def resolve_battle(db_path: str, room_id: int) -> Tuple[bool, str]:
         )
         room = await cursor.fetchone()
         if not room:
-            return False, "❌ Active battle not found"
-        
+            return False, "❌ No active battle found"
+
         room = dict(room)
         end_time = datetime.fromisoformat(room['end_time'])
         if datetime.now() < end_time:
@@ -346,7 +346,7 @@ async def resolve_battle(db_path: str, room_id: int) -> Tuple[bool, str]:
                 (datetime.now().isoformat(), room_id)
             )
             await db.commit()
-            return True, "⚖️ Draw (베팅 없음)"
+            return True, "⚖️ Draw (no bets)"
         
         # Determine winner based on battle type
         if room['battle_type'] == 'prediction':
@@ -398,9 +398,9 @@ async def resolve_battle(db_path: str, room_id: int) -> Tuple[bool, str]:
                 share_ratio = w['bet_amount'] / winner_pool
                 base_payout = int(prize_pool * share_ratio)
                 bonus = int(base_payout * (underdog_bonus - 1.0))
-                payout = base_payout + bonus + w['bet_amount']  # 원금 + 기본수익 + 소수파보너스
-                
-                # GPU 지급
+                payout = base_payout + bonus + w['bet_amount']  # principal + base profit + underdog bonus
+
+                # GPU payout
                 if w['bettor_agent_id']:
                     await db.execute(
                         "UPDATE npc_agents SET gpu_dollars=gpu_dollars+? WHERE agent_id=?",
@@ -412,13 +412,13 @@ async def resolve_battle(db_path: str, room_id: int) -> Tuple[bool, str]:
                         (payout, w['bettor_email'])
                     )
                 
-                # 배당금 기록
+                # Record payout
                 await db.execute(
                     "UPDATE battle_bets SET payout=? WHERE id=?",
                     (payout, w['id'])
                 )
             
-            # 방장 수수료 지급
+            # Pay host fee
             if room['creator_agent_id']:
                 await db.execute(
                     "UPDATE npc_agents SET gpu_dollars=gpu_dollars+? WHERE agent_id=?",
@@ -430,7 +430,7 @@ async def resolve_battle(db_path: str, room_id: int) -> Tuple[bool, str]:
                     (host_fee, room['creator_email'])
                 )
         
-        # 배틀 종료 처리
+        # Mark battle as resolved
         await db.execute(
             """UPDATE battle_rooms 
                SET status='resolved', winner=?, resolved_at=? 
@@ -439,17 +439,17 @@ async def resolve_battle(db_path: str, room_id: int) -> Tuple[bool, str]:
         )
         await db.commit()
         
-        # 결과 메시지
+        # Result message
         if winner == 'draw':
             result_msg = 'Draw'
         else:
             result_msg = room['option_a'] if winner == 'A' else room['option_b']
         
         battle_type_emoji = '💭' if room['battle_type'] == 'opinion' else '🔮'
-        return True, f"✅ {battle_type_emoji} 판정 완료: {result_msg}"
+        return True, f"✅ {battle_type_emoji} Resolved: {result_msg}"
 
 async def get_active_battles(db_path: str, limit: int = 20) -> List[Dict]:
-    """진행 중인 배틀 목록"""
+    """List of in-progress battles"""
     async with aiosqlite.connect(db_path, timeout=30.0) as db:
         await db.execute("PRAGMA busy_timeout=30000")
         db.row_factory = aiosqlite.Row
@@ -470,11 +470,11 @@ async def get_active_battles(db_path: str, limit: int = 20) -> List[Dict]:
         for row in await cursor.fetchall():
             b = dict(row)
             
-            # ★ 프론트 호환 필드 추가
+            # ★ Add frontend-compatible fields
             b['bets_a'] = b.get('option_a_pool', 0)
             b['bets_b'] = b.get('option_b_pool', 0)
-            
-            # 참여자 수 조회
+
+            # Query participant count
             bet_cursor = await db.execute(
                 "SELECT COUNT(DISTINCT COALESCE(bettor_agent_id, bettor_email)) FROM battle_bets WHERE room_id=?",
                 (b['id'],)
@@ -482,7 +482,7 @@ async def get_active_battles(db_path: str, limit: int = 20) -> List[Dict]:
             bettor_count = await bet_cursor.fetchone()
             b['total_bettors'] = bettor_count[0] if bettor_count else 0
             
-            # 득표율 계산
+            # Calculate vote ratio
             total = b['total_pool']
             if total > 0:
                 b['a_ratio'] = round(b['option_a_pool'] / total * 100, 1)
@@ -491,7 +491,7 @@ async def get_active_battles(db_path: str, limit: int = 20) -> List[Dict]:
                 b['a_ratio'] = 0
                 b['b_ratio'] = 0
             
-            # 남은  hours 계산
+            # Calculate remaining time
             end_time = datetime.fromisoformat(b['end_time'])
             remaining = end_time - datetime.now()
             
@@ -505,16 +505,16 @@ async def get_active_battles(db_path: str, limit: int = 20) -> List[Dict]:
                 elif remaining.total_seconds() > 3600:
                     b['time_left'] = f"{int(remaining.total_seconds()//3600)} hours"
                 else:
-                    b['time_left'] = f"{int(remaining.total_seconds()//60)}분"
+                    b['time_left'] = f"{int(remaining.total_seconds()//60)}m"
             else:
-                b['time_left'] = "마감"
+                b['time_left'] = "Closed"
             
             battles.append(b)
         
         return battles
 
 async def auto_resolve_expired_battles(db_path: str):
-    """만료된 배틀 자동 판정"""
+    """Auto-resolve expired battles"""
     async with aiosqlite.connect(db_path, timeout=30.0) as db:
         await db.execute("PRAGMA busy_timeout=30000")
         
@@ -528,10 +528,10 @@ async def auto_resolve_expired_battles(db_path: str):
         for row in expired:
             await resolve_battle(db_path, row[0])
 
-# NPC 배틀 생성을 위한 주제 데이터
-# ★ 공통 배틀 토픽 — 주식/경제/사회/정치 (모든 NPC가 사용)
+# Topic data for NPC battle generation
+# ★ Common battle topics — stocks/economy/society/politics (used by all NPCs)
 COMMON_BATTLE_TOPICS = [
-    # 주식/투자
+    # Stocks/Investing
     ("Is $NVDA overvalued at current prices?", "Overvalued", "Still cheap"),
     ("Will $BTC hit $200K in 2026?", "Yes $200K+", "No way"),
     ("Is the AI stock rally a bubble?", "Bubble", "Just the beginning"),
@@ -542,14 +542,14 @@ COMMON_BATTLE_TOPICS = [
     ("$AAPL or $MSFT: better 5-year hold?", "AAPL", "MSFT"),
     ("Is meme coin investing smart or dumb?", "Smart alpha", "Pure gambling"),
     ("Should you DCA or time the market?", "DCA always", "Timing works"),
-    # 경제
+    # Economy
     ("Will the Fed cut rates in 2026?", "Yes, cuts coming", "No, rates stay high"),
     ("Is a US recession coming?", "Recession likely", "Soft landing"),
     ("Is inflation actually under control?", "Under control", "Still a threat"),
     ("Will the US dollar lose reserve status?", "Losing it", "Dollar stays king"),
     ("Is remote work killing the economy?", "Hurting GDP", "Boosting productivity"),
     ("Will AI cause mass unemployment?",  "Mass layoffs coming", "Creates more jobs"),
-    # 사회/정치
+    # Society/Politics
     ("Should Big Tech be broken up?", "Break them up", "Leave them alone"),
     ("Is social media a net positive?", "Net positive", "Net negative"),
     ("Should AI be regulated like nuclear?", "Heavy regulation", "Let it innovate"),
@@ -634,12 +634,12 @@ BATTLE_TOPICS_BY_IDENTITY = {
 }
 
 async def _generate_news_battle_topics(db_path: str) -> List[Tuple[str, str, str]]:
-    """최근 뉴스에서 동적 배틀 토픽 생성 — 핫이슈 중심"""
+    """Generate dynamic battle topics from recent news — focused on hot issues"""
     topics = []
     try:
         async with aiosqlite.connect(db_path, timeout=30.0) as db:
             await db.execute("PRAGMA busy_timeout=30000")
-            # 최근 24시간 뉴스 + 감성 포함
+            # Recent 24h news + sentiment
             cursor = await db.execute("""
                 SELECT ticker, title, sentiment, description
                 FROM npc_news
@@ -648,7 +648,7 @@ async def _generate_news_battle_topics(db_path: str) -> List[Tuple[str, str, str
             """)
             news_rows = await cursor.fetchall()
 
-            # 최근 가격 변동 큰 종목
+            # Recent big movers
             cursor2 = await db.execute("""
                 SELECT ticker, price, change_pct
                 FROM market_prices
@@ -657,14 +657,14 @@ async def _generate_news_battle_topics(db_path: str) -> List[Tuple[str, str, str
             """)
             movers = await cursor2.fetchall()
 
-        # 1) 뉴스 기반 토픽 생성
+        # 1) Generate news-based topics
         seen_tickers = set()
         for row in news_rows:
             ticker, title, sentiment, desc = row[0], row[1], row[2], row[3] or ''
             if ticker in seen_tickers:
                 continue
             seen_tickers.add(ticker)
-            # 뉴스 제목에서 배틀 토픽 생성
+            # Generate battle topic from news title
             short_title = title[:60] if len(title) > 60 else title
             if sentiment == 'bullish':
                 topics.append((
@@ -679,7 +679,7 @@ async def _generate_news_battle_topics(db_path: str) -> List[Tuple[str, str, str
                     f"${ticker} — {short_title}: impact on price?",
                     "Positive impact 📈", "Negative impact 📉"))
 
-        # 2) 급등락 종목 기반 토픽
+        # 2) Topics based on big movers
         for mover in movers:
             ticker, price, change = mover[0], mover[1], mover[2] or 0
             if ticker in seen_tickers:
@@ -702,15 +702,15 @@ async def _generate_news_battle_topics(db_path: str) -> List[Tuple[str, str, str
 
 
 async def npc_create_battle(db_path: str) -> Tuple[bool, str]:
-    """NPCs automatically create battle rooms — 뉴스 기반 동적 토픽 + 일일 캡 3~10개
-    20분마다 호출, 24시간 내 최소 3개~최대 10개 생성
+    """NPCs automatically create battle rooms — news-based dynamic topics + daily cap 3~10
+    Called every 20 minutes, generates min 3 ~ max 10 per 24h
     """
     results = []
 
     async with aiosqlite.connect(db_path, timeout=30.0) as db:
         await db.execute("PRAGMA busy_timeout=30000")
 
-        # ★ 일일 생성 캡 체크: 24시간 내 10개 이상이면 스킵
+        # ★ Daily creation cap check: skip if 10+ in last 24h
         cursor = await db.execute("""
             SELECT COUNT(*) FROM battle_rooms
             WHERE created_at > datetime('now', '-24 hours')
@@ -719,22 +719,22 @@ async def npc_create_battle(db_path: str) -> Tuple[bool, str]:
         if daily_count >= 10:
             return False, f"Daily cap reached ({daily_count}/10)"
 
-        # ★ 최소 보장: 24시간 내 3개 미��이면 반드시 1개 생성
+        # ★ Minimum guarantee: force create 1 if fewer than 3 in 24h
         force_create = daily_count < 3
 
-        # 확률 기반: 20분 호출 → 72회/일, 3~10개 목표 → 약 7~14% 확률로 생성
+        # Probabilistic: 20-min calls → 72/day, 3~10 target → ~7-14% chance per call
         if not force_create and random.random() > 0.14:
             return False, "Skipped by probability (saving quota)"
 
-        # active 배틀 제목 조회
+        # Query active battle titles
         cursor = await db.execute("SELECT title FROM battle_rooms WHERE status='active'")
         active_titles = {row[0] for row in await cursor.fetchall()}
 
-    # ★ 뉴스 기반 동적 토픽 (우선) + 정적 토픽 (폴백)
+    # ★ News-based dynamic topics (priority) + static topics (fallback)
     news_topics = await _generate_news_battle_topics(db_path)
     all_topics = news_topics + COMMON_BATTLE_TOPICS
 
-    # 이미 활성인 토픽 제외 (제목 유사도 체크)
+    # Exclude topics already active (title similarity check)
     available_topics = []
     for t in all_topics:
         title_lower = t[0].lower()
@@ -744,10 +744,10 @@ async def npc_create_battle(db_path: str) -> Tuple[bool, str]:
     if not available_topics:
         return False, "No available topics"
 
-    # 1개만 생성 (일일 캡 내에서)
+    # Create only 1 (within daily cap)
     num_create = 1
     if force_create:
-        num_create = min(2, len(available_topics))  # 부족 시 2개까지
+        num_create = min(2, len(available_topics))  # up to 2 if insufficient
 
     for i in range(num_create):
         if not available_topics:
@@ -756,7 +756,7 @@ async def npc_create_battle(db_path: str) -> Tuple[bool, str]:
         async with aiosqlite.connect(db_path, timeout=30.0) as db:
             await db.execute("PRAGMA busy_timeout=30000")
 
-            # 랜덤 NPC 선택
+            # Random NPC selection
             cursor = await db.execute("""
                 SELECT agent_id, ai_identity, gpu_dollars
                 FROM npc_agents
@@ -770,7 +770,7 @@ async def npc_create_battle(db_path: str) -> Tuple[bool, str]:
 
             agent_id = npc[0]
 
-        # ★ 뉴스 토픽 우선 (70%), 정적 토픽 (30%)
+        # ★ News topic priority (70%), static topic (30%)
         news_available = [t for t in available_topics if t in news_topics]
         if news_available and random.random() < 0.7:
             topic = random.choice(news_available)
@@ -780,7 +780,7 @@ async def npc_create_battle(db_path: str) -> Tuple[bool, str]:
         title, option_a, option_b = topic
         available_topics.remove(topic)
 
-        # ★ 짧은 duration: 6~48시간 (빠른 회전)
+        # ★ Short duration: 6~48 hours (fast turnover)
         duration_hours = random.choice([6, 8, 12, 18, 24, 36, 48])
 
         success, message, room_id = await create_battle_room(
@@ -803,14 +803,14 @@ async def npc_auto_bet(db_path: str) -> int:
     """NPCs automatically bet on battles (AI identity-based)
     
     Returns:
-        베팅한 NPC 수
+        Number of NPCs that bet
     """
     total_bet_count = 0
     
     async with aiosqlite.connect(db_path, timeout=30.0) as db:
         await db.execute("PRAGMA busy_timeout=30000")
         
-        # 활성 배틀 조회 (최근 10개, opinion 타입만)
+        # Query active battles (last 10, opinion type only)
         cursor = await db.execute("""
             SELECT id, title, option_a, option_b, battle_type
             FROM battle_rooms 
@@ -829,7 +829,7 @@ async def npc_auto_bet(db_path: str) -> int:
             room_id, title, option_a, option_b, battle_type = battle
             battle_bet_count = 0
             
-            # 이미 베팅한 NPC 확인
+            # Check NPCs that already bet
             cursor = await db.execute("""
                 SELECT bettor_agent_id 
                 FROM battle_bets 
@@ -837,7 +837,7 @@ async def npc_auto_bet(db_path: str) -> int:
             """, (room_id,))
             already_bet = {row[0] for row in await cursor.fetchall() if row[0]}
             
-            # 활성 NPC 중 랜덤 선택 (최대 30명)
+            # Random selection of active NPCs (max 30)
             cursor = await db.execute("""
                 SELECT agent_id, ai_identity, mbti, gpu_dollars
                 FROM npc_agents 
@@ -850,18 +850,18 @@ async def npc_auto_bet(db_path: str) -> int:
             for npc in npcs:
                 agent_id, ai_identity, mbti, gpu = npc
                 
-                # 이미 베팅했으면 스킵
+                # Skip if already bet
                 if agent_id in already_bet:
                     continue
-                
-                # AI 정체성에 따라 선택 결정
+
+                # Decide choice based on AI identity
                 choice = decide_npc_choice(ai_identity, title, option_a, option_b)
-                
-                # 베팅 금액 (보유 GPU의 40% 이내, 최대 50)
+
+                # Bet amount (within 40% of GPU balance, max 50)
                 max_bet = max(1, min(50, int(gpu * 0.4)))
                 bet_amount = random.randint(1, max_bet)
-                
-                # 베팅 실행
+
+                # Place bet
                 success, message = await place_bet(
                     db_path,
                     room_id,
@@ -875,7 +875,7 @@ async def npc_auto_bet(db_path: str) -> int:
                     battle_bet_count += 1
                     total_bet_count += 1
                 
-                # 배틀당 8-12명 정도만 베팅
+                # ~8-12 bets per battle
                 max_bets_per_battle = random.randint(8, 12)
                 if battle_bet_count >= max_bets_per_battle:
                     break