Update app.py

app.py

@@ -1,19 +1,25 @@
 import gradio as gr
 import pandas as pd
+from huggingface_hub import HfApi, HfFolder
+import os
+import uuid
+from pathlib import Path
 
-# --- Konstanten für die Berechnung ---
-# These constants are fine as they don't represent a changing state.
+# --- Constants for the Calculation ---
 GRUNDWERTE = {"Karo": 9, "Herz": 10, "Pik": 11, "Kreuz": 12, "Grand": 24}
 NULL_SPIELE = {"Null": 23, "Null Hand": 35, "Null Ouvert": 46, "Null Hand Ouvert": 59}
 SPIELER = ["Kirsten", "Robert", "Samuel"]
 HISTORY_DF_HEADERS = ["Kirsten", "Robert", "Samuel", "Spielwert", "Spielart", "Alleinspieler", "Details", "Verloren"]
 
+# --- Hugging Face Configuration ---
+# Define a more descriptive local folder for saving tournament files before upload.
+LOCAL_TOURNAMENT_DIR = Path("saved_tournaments/")
+LOCAL_TOURNAMENT_DIR.mkdir(exist_ok=True) # Ensure the directory exists
 
-# --- Hauptfunktionen ---
+# --- Core Functions ---
 
 def calculate_spielwert(spielart, spitzen_str, hand, schneider, schwarz, schneider_angesagt, schwarz_angesagt, offen):
-    """Berechnet den reinen Spielwert (Reizwert) basierend auf den Spielregeln."""
-    # This function had no side effects and remains unchanged.
+    """Calculates the pure game value (Reizwert) based on the game rules."""
     if spielart in NULL_SPIELE:
         return NULL_SPIELE[spielart]
     if spielart not in GRUNDWERTE or not spitzen_str:
@@ -29,40 +35,30 @@ def calculate_spielwert(spielart, spitzen_str, hand, schneider, schwarz, schneid
     grundwert = GRUNDWERTE[spielart]
     return (spitzen_anzahl + gewinnstufe) * grundwert
 
-# --- REFACTURED FUNCTION ---
-# No more global variables. The history_df is now passed as an argument.
 def spiel_hinzufuegen(history_df, spieler, spielart, spitzen, hand, schneider, schwarz, schneider_angesagt, schwarz_angesagt, offen, verloren):
-    """
-    Fügt ein neues Spiel zum History-DataFrame hinzu und berechnet die Gesamtstände dynamisch.
-    """
+    """Adds a new game to the history DataFrame and dynamically calculates the total scores."""
     spielwert = calculate_spielwert(spielart, spitzen, hand, schneider, schwarz, schneider_angesagt, schwarz_angesagt, offen)
-    
-    # This dictionary stores the point change for this single round.
+
     neue_punkte = {name: 0 for name in SPIELER}
 
-    if spieler: # Only if a soloist was selected
+    if spieler:
         if not verloren:
-            # Soloist wins
             neue_punkte[spieler] = 50 + spielwert
-            # Opponents get penalty points
             for p in SPIELER:
                 if p != spieler:
                     neue_punkte[p] = -40
         else:
-            # Soloist loses
-            neue_punkte[spieler] = -50 - (2 * spielwert) # The original had an error, this is the correct calculation for a lost game (-50 and -2*game_value)
-            # Opponents get points
+            neue_punkte[spieler] = -50 - (2 * spielwert)
             for p in SPIELER:
                 if p != spieler:
                     neue_punkte[p] = 40
-    
+
     details = f"Spitzen: {spitzen or 'N/A'}"
     if hand: details += ", Hand"
     if schneider_angesagt: details += ", Schneider angesagt"
     if schwarz_angesagt: details += ", Schwarz angesagt"
     if offen: details += ", Offen"
-    
-    # Create a dictionary for the new row
+
     neues_spiel_eintrag = {
         "Kirsten": neue_punkte["Kirsten"],
         "Robert": neue_punkte["Robert"],
@@ -73,56 +69,81 @@ def spiel_hinzufuegen(history_df, spieler, spielart, spitzen, hand, schneider, s
         "Details": details,
         "Verloren": "Ja" if verloren else "Nein"
     }
-    
-    # --- NEW: STATE MANAGEMENT ---
-    # Convert the new game entry into a DataFrame of a single row
+
     new_row_df = pd.DataFrame([neues_spiel_eintrag])
-    
-    # Append the new row to the existing history DataFrame
     updated_history_df = pd.concat([history_df, new_row_df], ignore_index=True)
-
-    # Calculate the totals by summing the columns of the *updated* history DataFrame
     total_scores = updated_history_df[SPIELER].sum()
-    totals_df = pd.DataFrame([total_scores]) # Convert the totals Series to a DataFrame for display
-    
-    # Return both updated DataFrames
+    totals_df = pd.DataFrame([total_scores])
+
     return totals_df, updated_history_df
 
-# --- REFACTURED FUNCTION ---
-# This function no longer needs to modify globals. It just creates and returns empty DataFrames.
 def reset_turnier():
-    """Setzt den gesamten Spielstand und die Historie zurück."""
+    """Resets the entire score and history."""
     empty_totals = pd.DataFrame([{"Kirsten": 0, "Robert": 0, "Samuel": 0}])
     empty_history = pd.DataFrame(columns=HISTORY_DF_HEADERS)
     return empty_totals, empty_history
 
-# --- UI Definition mit Gradio ---
+def save_turnier_to_hf(history_df):
+    """Saves the current tournament history to a local JSON file and immediately uploads it to the Hugging Face Hub."""
+    # Check for Hugging Face token
+    if HfFolder.get_token() is None:
+        return "Hugging Face Token nicht gefunden. Bitte via `huggingface-cli login` anmelden."
+
+    # Prevent saving an empty tournament
+    if history_df.empty:
+        return "Keine Spieldaten zum Speichern vorhanden."
+
+    # Generate a unique filename for the tournament data to avoid overwriting files.
+    tournament_filename = f"skat_tournament_{uuid.uuid4()}.jsonl"
+    local_file_path = LOCAL_TOURNAMENT_DIR / tournament_filename
+
+    # Save the DataFrame to a local JSON Lines file.
+    history_df.to_json(local_file_path, orient="records", lines=True, force_ascii=False)
+
+    # Instantiate the HfApi client to upload the file.
+    api = HfApi()
+    repo_id = "skat-scores" # A more descriptive repository name
+
+    try:
+        # Upload the file directly. The repo will be created if it doesn't exist.
+        api.upload_file(
+            path_or_fileobj=local_file_path,
+            path_in_repo=f"data/{tournament_filename}",
+            repo_id=repo_id,
+            repo_type="dataset",
+            commit_message=f"Add new skat tournament data: {tournament_filename}"
+        )
+        return f"Turnier erfolgreich nach '{repo_id}' auf Hugging Face hochgeladen."
+    except Exception as e:
+        return f"Fehler beim Upload: {e}"
+
+
+# --- UI Definition with Gradio ---
 
 with gr.Blocks() as demo:
     gr.Markdown("# Skat-Punkte-Tracker")
 
     gr.Markdown("### Gesamtpunktestand")
-    
-    # --- NEW: Initialize DataFrames for the UI ---
+
     initial_totals_df, initial_history_df = reset_turnier()
-    
+
     totals_output = gr.Dataframe(
         value=initial_totals_df,
         interactive=False,
         show_row_numbers=False
     )
-    
+
     with gr.Row():
         with gr.Column(scale=1):
             gr.Markdown("### Neues Spiel eingeben")
-            
+
             spieler_input = gr.Dropdown(SPIELER, label="Alleinspieler")
             spielart_input = gr.Dropdown(
-                choices=['Karo', 'Herz', 'Pik', 'Kreuz', 'Grand', 'Null', 'Null Hand', 'Null Ouvert', 'Null Hand Ouvert'], # Ramsch removed as it's not handled in the logic
+                choices=['Karo', 'Herz', 'Pik', 'Kreuz', 'Grand', 'Null', 'Null Hand', 'Null Ouvert', 'Null Hand Ouvert'],
                 label="Spielart"
             )
             spitzen_input = gr.Dropdown(
-                choices=[f"{m} {i}" for m in ["Mit", "Ohne"] for i in range(1, 5)], # Normal range is 1-4
+                choices=[f"{m} {i}" for m in ["Mit", "Ohne"] for i in range(1, 5)],
                 label="Spitzen"
             )
 
@@ -136,11 +157,15 @@ with gr.Blocks() as demo:
                 schneider_angesagt_input = gr.Checkbox(label="Schneider angesagt")
                 schwarz_angesagt_input = gr.Checkbox(label="Schwarz angesagt")
                 offen_input = gr.Checkbox(label="Offen / Ouvert")
-            
+
             with gr.Row():
                 speichere_spiel = gr.Button("Speichere Spiel", variant="primary", scale=2)
                 reset_button = gr.Button("Reset", variant="stop", scale=1)
 
+            save_to_hf_button = gr.Button("Turnier auf Hugging Face speichern", variant="secondary")
+            hf_status_output = gr.Label(value="", label="Upload Status")
+
+
         with gr.Column(scale=2):
             gr.Markdown("### Spielverlauf")
             turnier_output = gr.Dataframe(
@@ -150,17 +175,13 @@ with gr.Blocks() as demo:
                 wrap=True
             )
 
-    # List of all input components for a new game
     inputs_list = [
         spieler_input, spielart_input, spitzen_input,
         hand_input, schneider_input, schwarz_input,
         schneider_angesagt_input, schwarz_angesagt_input, offen_input,
         verloren_input
     ]
-    
-    # --- NEW: Updated Click Handler ---
-    # The 'turnier_output' DataFrame is now also an INPUT to the function.
-    # It carries the current state of the game history.
+
     speichere_spiel.click(
         fn=spiel_hinzufuegen,
         inputs=[turnier_output] + inputs_list,
@@ -173,5 +194,12 @@ with gr.Blocks() as demo:
         outputs=[totals_output, turnier_output]
     )
 
+    # --- Click Handler for the Hugging Face Button ---
+    save_to_hf_button.click(
+        fn=save_turnier_to_hf,
+        inputs=[turnier_output],
+        outputs=[hf_status_output]
+    )
+
 if __name__ == "__main__":
     demo.launch(share=True)