Update app.py

app.py

@@ -1,123 +1,97 @@
 import gradio as gr
+import pandas as pd
 import random
-import csv
-import io
-
-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()
+
+vocabulary = []
+matches = {}
+score = 0
+
+
+def parse_csv(file):
+    global vocabulary
+    try:
+        df = pd.read_csv(file.name, header=None)
+        vocabulary = df.to_dict('records')
+        for item in vocabulary:
+            item['word'] = item[0]
+            item['definition'] = item[1]
+        return "CSV file successfully uploaded! Ready to start the quiz!"
+    except Exception as e:
+        return f"Error parsing file: {e}"
+
+
+def add_word(word, definition):
+    global vocabulary
     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."
+        vocabulary.append({'word': word.strip(), 'definition': definition.strip()})
+        return f'Word "{word}" added to vocabulary!'
+    return "Please provide both word and definition."
+
 
-def start_quiz(vocabulary):
+def start_quiz():
     if not vocabulary:
-        return gr.update(visible=False), "No vocabulary available. Please upload CSV or add words.", None, None, None, None
-    random.shuffle(vocabulary)
-    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
-
-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
-    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
-    
-    if correct_def == selected_def:
-        matched += 1
-        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! '{selected_word}' does not match the selected definition.", words, defs, matched
+        return "Vocabulary is empty. Please upload a file or add words manually.", [], []
+
+    shuffle_vocabulary = vocabulary[:]
+    random.shuffle(shuffle_vocabulary)
+    words = [item['word'] for item in shuffle_vocabulary]
+    definitions = [item['definition'] for item in shuffle_vocabulary]
+    random.shuffle(definitions)
+    return "Quiz started! Match words to definitions.", words, definitions
+
+
+def check_match(word, definition):
+    global score
+    for item in vocabulary:
+        if item['word'] == word and item['definition'] == definition:
+            score += 1
+            return f"Correct! '{word}' matches its definition. Total score: {score}", True
+    return f"Incorrect! '{word}' does not match the definition.", False
+
 
 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.Group():
-        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.Group():
-        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("")
+    global vocabulary, matches, score
+    vocabulary = []
+    matches = {}
+    score = 0
+    return "Quiz reset! Ready for a new start."
+
+
+with gr.Blocks() as app:
+    with gr.Row():
+        gr.Markdown("# 📚 Personal English Vocabulary App")
+
+    with gr.Tab("Upload Vocabulary"):
         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 interactions
-    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_
+            file_input = gr.File(label="Upload Vocabulary CSV")
+            file_output = gr.Textbox(label="Upload Status")
+            upload_button = gr.Button("Upload")
+
+        upload_button.click(parse_csv, inputs=file_input, outputs=file_output)
+
+    with gr.Tab("Add Vocabulary"):
+        word_input = gr.Textbox(label="Word")
+        definition_input = gr.Textbox(label="Definition")
+        add_button = gr.Button("Add Word")
+        add_status = gr.Textbox(label="Status")
+
+        add_button.click(add_word, inputs=[word_input, definition_input], outputs=add_status)
+
+    with gr.Tab("Quiz"):
+        quiz_status = gr.Textbox(label="Status")
+        start_button = gr.Button("Start Quiz")
+        words_list = gr.Dropdown(label="Select Word")
+        definitions_list = gr.Dropdown(label="Select Definition")
+        check_button = gr.Button("Check Match")
+        match_status = gr.Textbox(label="Result")
+
+        start_button.click(start_quiz, inputs=None, outputs=[quiz_status, words_list, definitions_list])
+        check_button.click(check_match, inputs=[words_list, definitions_list], outputs=match_status)
+
+    with gr.Row():
+        reset_button = gr.Button("Reset Quiz")
+        reset_status = gr.Textbox(label="Reset Status")
+
+        reset_button.click(reset_quiz, inputs=None, outputs=reset_status)
+
+app.launch()