update upload logic

app.py

@@ -873,6 +873,22 @@ with gr.Blocks(css=APP_CSS, title="LLM GeoGuessr") as demo:
                 rnd['ai_score'] = score_from_distance_km(ai_dist_km)
             # Store the AI analysis text for later recording
             rnd['ai_analysis'] = last_text
+            
+            # Record this round's data immediately to prevent abuse
+            sess = user_sessions.get(username, {})
+            round_idx = next((i for i, rr in enumerate(sess.get('rounds', [])) if rr['id'] == rid), 0) + 1
+            round_record = {
+                "round_number": round_idx,
+                "actual_location": {"lat": rnd.get('lat'), "lng": rnd.get('lng')},
+                "human_guess": rnd.get('human_guess'),
+                "human_distance_km": rnd.get('human_distance_km'),
+                "human_score": rnd.get('human_score'),
+                "ai_guess": rnd.get('ai_guess'),
+                "ai_distance_km": rnd.get('ai_distance_km'),
+                "ai_score": rnd.get('ai_score'),
+                "ai_analysis": rnd.get('ai_analysis', ''),
+            }
+            data_manager.update_game_record(username, round_data=round_record)
         except Exception as e:
             yield "", txt + f"\n\n[Error] {e}"
             return
@@ -946,23 +962,8 @@ with gr.Blocks(css=APP_CSS, title="LLM GeoGuessr") as demo:
             total_human = sum(float(r.get('human_score', 0.0)) for r in sess.get('rounds', []))
             total_ai = sum(float(r.get('ai_score', 0.0)) for r in sess.get('rounds', []))
             
-            # Prepare detailed rounds data for recording
-            rounds_data = []
-            for i, r in enumerate(sess.get('rounds', [])):
-                round_record = {
-                    "round_number": i + 1,
-                    "actual_location": {"lat": r.get('lat'), "lng": r.get('lng')},
-                    "human_guess": r.get('human_guess'),
-                    "human_distance_km": r.get('human_distance_km'),
-                    "human_score": r.get('human_score'),
-                    "ai_guess": r.get('ai_guess'),
-                    "ai_distance_km": r.get('ai_distance_km'),
-                    "ai_score": r.get('ai_score'),
-                    "ai_analysis": r.get('ai_analysis', ''),
-                }
-                rounds_data.append(round_record)
-            
-            data_manager.record_game(username, total_human, rounds_data)
+            # Update the final score (rounds already recorded incrementally)
+            data_manager.update_game_record(username, final_score=total_human)
 
             winner_message = "It's a tie!"
             if total_human > total_ai:

data_manager.py

@@ -41,46 +41,60 @@ def get_todays_games(token: str) -> list:
         return []
 
 def has_user_played_today(username: str, todays_games: list) -> bool:
-    """Checks if a user's record already exists in today's games."""
-    return any(game.get("username") == username for game in todays_games)
+    """Checks if a user has completed a game today."""
+    for game in todays_games:
+        if game.get("username") == username and game.get("completed", False):
+            return True
+    return False
 
-def record_game(username: str, score: float, rounds_data: list = None):
+def get_user_game_today(username: str, todays_games: list) -> dict:
+    """Gets the user's game record for today, if it exists."""
+    for game in todays_games:
+        if game.get("username") == username:
+            return game
+    return None
+
+def update_game_record(username: str, round_data: dict = None, final_score: float = None):
     """
-    Records a completed game to the daily records file on the HF Hub.
-    This function reads the existing file, appends the new record, and uploads it back.
-    It uses the server's write token from environment variables.
+    Updates or creates a game record for a user after each round.
+    This ensures data is recorded incrementally and prevents abuse.
     
     Args:
         username: The player's username
-        score: Total score for the game
-        rounds_data: List of round details including guesses, scores, and AI analysis
+        round_data: Single round details to append to the record
+        final_score: Final total score (only set when game is complete)
     """
     write_token = os.getenv("HF_TOKEN", "")
     if not write_token:
-        print("Warning: Server HF_TOKEN not set. Cannot record game score.")
+        print("Warning: Server HF_TOKEN not set. Cannot record game data.")
         return
 
     try:
-        # Fetch the latest records using the write token to ensure we have the most recent data
+        # Fetch the latest records
         todays_games = get_todays_games(token=write_token)
-
-        # Final check to prevent duplicate entries in case of concurrent games
-        # Only check if BLOCK_MULTIPLE_GAMES is enabled
-        if BLOCK_MULTIPLE_GAMES and has_user_played_today(username, todays_games):
-            print(f"User {username} has already played today. Skipping record.")
-            return
-
-        game_record = {
-            "username": username,
-            "score": score,
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-        }
         
-        # Add detailed rounds data if provided
-        if rounds_data:
-            game_record["rounds"] = rounds_data
-
-        todays_games.append(game_record)
+        # Find existing game record for this user today
+        existing_game = get_user_game_today(username, todays_games)
+        
+        if existing_game:
+            # Update existing record
+            if round_data:
+                if "rounds" not in existing_game:
+                    existing_game["rounds"] = []
+                existing_game["rounds"].append(round_data)
+            if final_score is not None:
+                existing_game["score"] = final_score
+                existing_game["completed"] = True
+        else:
+            # Create new game record
+            game_record = {
+                "username": username,
+                "score": 0,  # Will be updated when game completes
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "rounds": [round_data] if round_data else [],
+                "completed": False
+            }
+            todays_games.append(game_record)
 
         filepath_in_repo = get_todays_records_path()
 
@@ -94,12 +108,19 @@ def record_game(username: str, score: float, rounds_data: list = None):
             repo_id=DATASET_REPO,
             repo_type="dataset",
             token=write_token,
-            commit_message=f"Game result for {username}"
+            commit_message=f"Update game for {username}"
         )
-        print(f"Successfully recorded game for {username} with score {score}")
+        print(f"Successfully updated game record for {username}")
 
     except Exception as e:
-        print(f"Error recording game for {username}: {e}")
+        print(f"Error updating game record for {username}: {e}")
     finally:
         if 'tmp_file_path' in locals() and os.path.exists(tmp_file_path):
             os.remove(tmp_file_path)
+
+def record_game(username: str, score: float, rounds_data: list = None):
+    """
+    Legacy function - now just calls update_game_record with final score.
+    Kept for backwards compatibility.
+    """
+    update_game_record(username, final_score=score)