Update app.py

app.py

@@ -1,133 +1,152 @@
 import gradio as gr
 import random
-import pandas as pd
-import ssl
-import os
-from datetime import datetime
-import requests
-
-# Workaround for SSL issues in some environments
-ssl._create_default_https_context = ssl._create_unverified_context
-
-# Global Variables
-vocabulary = []
-matches = {}
-score = 0
-remaining_pairs = 0
-selected_pairs = []
-
-# Helper Functions for Matching Game
-def parse_csv(file):
-    global remaining_pairs
-    try:
-        data = pd.read_csv(file.name, header=None)
-        vocab = data.dropna().values.tolist()
-        vocabulary.clear()
-        vocabulary.extend([{"word": row[0].strip(), "definition": row[1].strip()} for row in vocab])
-        remaining_pairs = len(vocabulary)
-        return f"Uploaded successfully! {remaining_pairs} pairs added.", vocabulary
-    except Exception as e:
-        return "Error reading the file. Ensure it's a valid CSV.", vocabulary
-
-def start_game():
-    global matches, score, remaining_pairs, selected_pairs
-    if len(vocabulary) < 1:
-        return "Please upload a vocabulary file or add words first.", [], []
-    
-    score = 0
-    remaining_pairs = len(vocabulary)
+import csv
+import io
+
+# Global states (to be stored in Gradio states)
+# vocabulary: list of dicts [{'word': '...', 'definition': '...'}, ...]
+# matched: number of correct matches made
+# available_words: list of words currently un-matched
+# available_definitions: list of definitions currently un-matched
+
+def parse_csv(file, vocabulary):
+    if file is None:
+        return vocabulary
+    file_content = file.read().decode('utf-8').strip()
+    reader = csv.reader(io.StringIO(file_content))
+    for row in reader:
+        if len(row) >= 2:
+            word = row[0].strip()
+            definition = ",".join(row[1:]).strip()
+            if word and definition:
+                vocabulary.append({"word": word, "definition": definition})
+    return vocabulary
+
+def add_manual_word(vocabulary, word, definition):
+    word = word.strip()
+    definition = definition.strip()
+    if word and definition:
+        vocabulary.append({"word": word, "definition": definition})
+    return vocabulary, f'Added "{word}" to your vocabulary.' if word and definition else "Please enter both a word and a definition."
+
+def start_quiz(vocabulary):
+    if not vocabulary:
+        return gr.update(visible=False), "No vocabulary available. Please upload CSV or add words.", None, None, None, None
+    # Shuffle the vocabulary for a quiz
     random.shuffle(vocabulary)
-    words = [item['word'] for item in vocabulary]
-    definitions = [item['definition'] for item in vocabulary]
-    random.shuffle(definitions)
+    words = [v["word"] for v in vocabulary]
+    defs = [v["definition"] for v in vocabulary]
+    random.shuffle(defs)
+    return gr.update(visible=True), "Quiz started! Match words with definitions.", vocabulary, words, defs, 0
 
-    matches = {item['word']: item['definition'] for item in vocabulary}
-    selected_pairs = []  # Reset selected pairs
+def check_match(selected_word, selected_def, vocabulary, words, defs, matched):
+    if not selected_word or not selected_def:
+        return "Please select both a word and a definition.", words, defs, matched
+    # Find the correct definition for the selected word
+    correct_def = None
+    for v in vocabulary:
+        if v["word"] == selected_word:
+            correct_def = v["definition"]
+            break
+    if correct_def is None:
+        return "Error: Word not found in vocabulary.", words, defs, matched
     
-    word_cards = [{'label': w, 'value': w} for w in words]
-    definition_cards = [{'label': d, 'value': d} for d in definitions]
-    
-    return "Match words with their definitions to eliminate pairs.", word_cards, definition_cards
-
-def check_match(word, definition):
-    global matches, score, remaining_pairs, vocabulary, selected_pairs
-    if matches.get(word) == definition:
-        score += 1
-        remaining_pairs -= 1
-        # Mark the matched pair as selected
-        selected_pairs.append((word, definition))
-        
-        # Remove the matched pair from the game
-        vocabulary = [item for item in vocabulary if item['word'] != word]
-        if remaining_pairs == 0:
-            return "Correct! You've matched all pairs! 🎉 Game Over.", score, [], []
-        
-        # Update words and definitions for remaining pairs
-        words = [{'label': item['word'], 'value': item['word']} for item in vocabulary]
-        definitions = [{'label': item['definition'], 'value': item['definition']} for item in vocabulary]
-        
-        return f"Correct! {word} matches {definition}. Remaining pairs: {remaining_pairs}", score, words, definitions
+    if correct_def == selected_def:
+        # Correct match
+        matched += 1
+        # Remove matched word and definition
+        words = [w for w in words if w != selected_word]
+        defs = [d for d in defs if d != selected_def]
+        if matched == len(vocabulary):
+            return f"Correct! All {matched} matches completed!", words, defs, matched
+        else:
+            return f"Correct! {matched}/{len(vocabulary)} matched.", words, defs, matched
     else:
-        return f"Incorrect! {word} does not match {definition}. Try again.", score, [], []
-
-def reset_game():
-    global vocabulary, matches, score, remaining_pairs, selected_pairs
-    vocabulary.clear()
-    matches.clear()
-    score = 0
-    remaining_pairs = 0
-    selected_pairs.clear()
-    return "Game reset. Upload a new file or add words to start again.", vocabulary
-
-# Gradio Interface
-def main():
-    with gr.Blocks() as app:
-        gr.Markdown("# Vocabulary Matching Game")
-
-        with gr.Tab("Upload Vocabulary"):
-            csv_upload = gr.File(label="Upload CSV (word, definition)")
-            upload_button = gr.Button("Upload File")
-            upload_output = gr.Textbox(label="Upload Status")
-
-        with gr.Tab("Play Matching Game"):
-            game_status = gr.Textbox(label="Game Status")
-            start_button = gr.Button("Start Game")
-            word_cards = gr.Gallery(label="Word Cards", height=300)
-            definition_cards = gr.Gallery(label="Definition Cards", height=300)
-            
-            selected_word = gr.Textbox(label="Selected Word", interactive=False)
-            selected_definition = gr.Textbox(label="Selected Definition", interactive=False)
-            
-            match_button = gr.Button("Check Match")
-            match_output = gr.Textbox(label="Match Result")
-            score_output = gr.Textbox(label="Score")
-            remaining_output = gr.Textbox(label="Remaining Pairs")
-            
-            def select_word(word):
-                return word
-            
-            def select_definition(definition):
-                return definition
-            
-            word_cards.select(select_word, inputs=[], outputs=[selected_word])
-            definition_cards.select(select_definition, inputs=[], outputs=[selected_definition])
-            
-            match_button.click(
-                check_match, 
-                inputs=[selected_word, selected_definition], 
-                outputs=[match_output, score_output, word_cards, definition_cards]
-            )
-        
-        with gr.Tab("Reset Game"):
-            reset_button = gr.Button("Reset")
-            reset_output = gr.Textbox(label="Reset Status")
-
-        upload_button.click(parse_csv, inputs=[csv_upload], outputs=[upload_output])
-        start_button.click(start_game, outputs=[game_status, word_cards, definition_cards])
-        reset_button.click(reset_game, outputs=[reset_output])
-
-    return app
-
-if __name__ == "__main__":
-    app = main()
-    app.launch()
+        return f"Incorrect! '{selected_word}' does not match the selected definition.", words, defs, matched
+
+def reset_quiz():
+    return gr.update(visible=False), None, [], [], [], 0, None
+
+with gr.Blocks() as demo:
+    gr.Markdown("# 📚 Personal English Vocabulary App")
+
+    vocabulary_state = gr.State([])
+    words_state = gr.State([])
+    defs_state = gr.State([])
+    matched_state = gr.State(0)
+
+    with gr.Box():
+        gr.Markdown("## Upload Your Vocabulary (CSV format: word, definition)")
+        file_input = gr.File(label="Upload CSV")
+        upload_btn = gr.Button("Parse CSV")
+        status_text = gr.Markdown("")
+
+    with gr.Box():
+        gr.Markdown("## Add a Vocabulary Word Manually")
+        manual_word = gr.Textbox(label="Word:")
+        manual_def = gr.Textbox(label="Definition:")
+        add_word_btn = gr.Button("Add Word")
+        add_status = gr.Markdown("")
+
+    start_quiz_btn = gr.Button("Start Quiz")
+
+    quiz_section = gr.Group(visible=False)
+    with quiz_section:
+        quiz_status = gr.Markdown("")
+        with gr.Row():
+            selected_word = gr.Dropdown(label="Words")
+            selected_def = gr.Dropdown(label="Definitions")
+        match_btn = gr.Button("Check Match")
+        match_result = gr.Markdown("")
+        reset_btn = gr.Button("Reset Quiz")
+
+    # Button actions
+    upload_btn.click(
+        parse_csv,
+        inputs=[file_input, vocabulary_state],
+        outputs=[vocabulary_state]
+    ).then(
+        lambda v: f"{len(v)} words loaded." if v else "No words loaded.",
+        inputs=[vocabulary_state],
+        outputs=status_text
+    )
+
+    add_word_btn.click(
+        add_manual_word,
+        inputs=[vocabulary_state, manual_word, manual_def],
+        outputs=[vocabulary_state, add_status]
+    )
+
+    start_quiz_btn.click(
+        start_quiz,
+        inputs=[vocabulary_state],
+        outputs=[quiz_section, quiz_status, vocabulary_state, words_state, defs_state, matched_state]
+    ).then(
+        lambda words, defs: (gr.update(choices=words, value=None), gr.update(choices=defs, value=None)),
+        inputs=[words_state, defs_state],
+        outputs=[selected_word, selected_def]
+    )
+
+    match_btn.click(
+        check_match,
+        inputs=[selected_word, selected_def, vocabulary_state, words_state, defs_state, matched_state],
+        outputs=[match_result, words_state, defs_state, matched_state]
+    ).then(
+        lambda words, defs: (gr.update(choices=words, value=None), gr.update(choices=defs, value=None)),
+        inputs=[words_state, defs_state],
+        outputs=[selected_word, selected_def]
+    )
+
+    reset_btn.click(
+        reset_quiz,
+        inputs=[],
+        outputs=[quiz_section, quiz_status, vocabulary_state, words_state, defs_state, matched_state, match_result]
+    ).then(
+        lambda: "",
+        outputs=add_status
+    ).then(
+        lambda: "",
+        outputs=status_text
+    )
+
+demo.launch()