Add application file

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

admin_interface.py

@@ -0,0 +1,231 @@
+import gradio as gr
+import pandas as pd
+import os
+from quiz_manager import quiz_manager
+
+class AdminInterface:
+    def __init__(self):
+        self.current_game_pin = None
+
+    def create_new_quiz(self, quiz_name):
+        """Create a new quiz and generate a game pin."""
+        try:
+            game_pin = quiz_manager.create_quiz(quiz_name)
+            self.current_game_pin = game_pin
+            return f"Quiz created successfully! Game Pin: {game_pin}", game_pin
+        except Exception as e:
+            return f"Error creating quiz: {str(e)}", None
+
+    def set_current_quiz(self, game_pin):
+        """Set the current game pin."""
+        if game_pin in quiz_manager.quizzes:
+            self.current_game_pin = game_pin
+            return f"Current quiz set to: {game_pin}"
+        else:
+            return f"Invalid Game Pin: {game_pin}"
+
+    def add_question(self, question_text, option1, option2, option3, option4, correct_answer):
+        """Add a question to the current quiz."""
+        if not self.current_game_pin:
+            return "Please create or select a quiz first!"
+
+        try:
+            options = [option1.strip(), option2.strip(), option3.strip(), option4.strip()]
+            if correct_answer not in options:
+                return "Correct answer must be one of the options."
+            quiz_manager.add_question(self.current_game_pin, question_text, options, correct_answer)
+            return "Question added successfully!"
+        except Exception as e:
+            return f"Error adding question: {str(e)}"
+
+    def load_questions_from_csv(self, csv_file):
+        """Load questions from a CSV file for the current quiz."""
+        if not self.current_game_pin:
+            return "Please create or select a quiz first!"
+
+        try:
+            df = pd.read_csv(csv_file.name)
+            if 'question' not in df.columns or 'option1' not in df.columns or 'option2' not in df.columns or 'option3' not in df.columns or 'option4' not in df.columns or 'correct_answer' not in df.columns:
+                return "CSV file must contain columns: question, option1, option2, option3, option4, correct_answer"
+
+            success_count = 0
+            fail_count = 0
+            fail_reasons = []
+
+            for index, row in df.iterrows():
+                question_text = row['question']
+                options = [row['option1'].strip(), row['option2'].strip(), row['option3'].strip(), row['option4'].strip()]
+                correct_answer = row['correct_answer'].strip()
+
+                if correct_answer not in options:
+                    fail_count += 1
+                    fail_reasons.append(f"Row {index + 2}: Correct answer '{correct_answer}' not in options.")
+                    continue
+
+                try:
+                    quiz_manager.add_question(self.current_game_pin, question_text, options, correct_answer)
+                    success_count += 1
+                except Exception as e:
+                    fail_count += 1
+                    fail_reasons.append(f"Row {index + 2}: Error adding question - {str(e)}")
+
+            message = f"Successfully added {success_count} questions. Failed to add {fail_count} questions."
+            if fail_reasons:
+                message += "\nDetails:\n" + "\n".join(fail_reasons)
+            return message
+        except Exception as e:
+            return f"Error loading CSV file: {str(e)}"
+        finally:
+            if csv_file:
+                os.remove(csv_file.name) # Clean up temporary file
+
+    def add_contestant(self, contestant_name):
+        """Add a contestant to the current quiz."""
+        if not self.current_game_pin:
+            return "Please create or select a quiz first!"
+
+        try:
+            quiz_manager.initialize_player_score(self.current_game_pin, contestant_name)
+            return f"{contestant_name} added to the quiz!"
+        except Exception as e:
+            return f"Error adding contestant: {str(e)}"
+
+    def record_contestant_answer(self, contestant_name, question_number, selected_answer):
+        """Record a contestant's answer."""
+        if not self.current_game_pin:
+            return "Please create or select a quiz first!"
+
+        try:
+            quiz = quiz_manager.get_quiz(self.current_game_pin)
+            if not quiz or not quiz['questions'] or question_number > len(quiz['questions']) or question_number < 1:
+                return "Invalid question number."
+
+            correct_answer = quiz['questions'][question_number - 1]['correct_answer']
+            is_correct = selected_answer == correct_answer
+            quiz_manager.record_answer(self.current_game_pin, contestant_name, is_correct)
+            return f"Answer recorded for {contestant_name} for Question {question_number}."
+        except Exception as e:
+            return f"Error recording answer: {str(e)}"
+
+    def get_leaderboard(self):
+        """Retrieve the current leaderboard."""
+        if not self.current_game_pin:
+            return "Please create or select a quiz first!"
+
+        try:
+            leaderboard = quiz_manager.get_leaderboard(self.current_game_pin)
+            if not leaderboard:
+                return "No scores recorded yet."
+            # Format leaderboard for display
+            leaderboard_str = "Current Leaderboard:\n"
+            for i, (name, data) in enumerate(leaderboard, 1):
+                leaderboard_str += f"{i}. {name}: {data['score']} points\n"
+            return leaderboard_str
+        except Exception as e:
+            return f"Error retrieving leaderboard: {str(e)}"
+
+    def create_admin_interface(self):
+        """Create the Gradio interface for admin."""
+        with gr.Blocks() as admin_interface:
+            gr.Markdown("## Quiz Admin Panel")
+
+            current_game_pin_state = gr.State(None)
+
+            with gr.Row():
+                with gr.Column():
+                    with gr.Accordion("Create New Quiz"):
+                        quiz_name_input = gr.Textbox(label="Quiz Name")
+                        create_quiz_btn = gr.Button("Create Quiz")
+                        create_quiz_output = gr.Textbox(label="Quiz Creation Status")
+                        game_pin_output = gr.Textbox(label="Game Pin", interactive=False)
+
+                        create_quiz_results = create_quiz_btn.click(
+                            fn=self.create_new_quiz,
+                            inputs=quiz_name_input,
+                            outputs=[create_quiz_output, game_pin_output]
+                        )
+                        create_quiz_results.then(lambda pin: pin, inputs=game_pin_output, outputs=current_game_pin_state)
+
+                    with gr.Accordion("Select Existing Quiz"):
+                        existing_pin_input = gr.Textbox(label="Enter Game Pin")
+                        select_quiz_btn = gr.Button("Select Quiz")
+                        select_quiz_output = gr.Textbox(label="Quiz Selection Status")
+                        select_quiz_btn.click(
+                            fn=self.set_current_quiz,
+                            inputs=existing_pin_input,
+                            outputs=select_quiz_output
+                        ).then(lambda pin: pin, inputs=existing_pin_input, outputs=current_game_pin_state)
+
+                    
+
+                with gr.Column():
+                    with gr.Accordion("Add Question"):
+                        question_text = gr.Textbox(label="Question Text")
+                        option1 = gr.Textbox(label="Option 1")
+                        option2 = gr.Textbox(label="Option 2")
+                        option3 = gr.Textbox(label="Option 3")
+                        option4 = gr.Textbox(label="Option 4")
+                        correct_answer = gr.Dropdown(
+                            choices=["Option 1", "Option 2", "Option 3", "Option 4"],
+                            label="Correct Answer"
+                        )
+                        add_question_btn = gr.Button("Add Question")
+                        add_question_output = gr.Textbox(label="Add Question Status")
+
+                        add_question_btn.click(
+                            fn=self.add_question,
+                            inputs=[question_text, option1, option2, option3, option4, correct_answer],
+                            outputs=add_question_output,
+                            # requires=current_game_pin_state # Conditional execution based on state
+                        )
+
+                    with gr.Accordion("Upload Questions from CSV"):
+                        csv_upload = gr.File(file_types=[".csv"])
+                        upload_btn = gr.Button("Upload CSV")
+                        upload_output = gr.Textbox(label="CSV Upload Status")
+                        upload_btn.click(
+                            fn=self.load_questions_from_csv,
+                            inputs=csv_upload,
+                            outputs=upload_output,
+                            # requires=current_game_pin_state
+                        )
+
+            with gr.Accordion("Manage Contestants"):
+                with gr.Row():
+                    contestant_name = gr.Textbox(label="Contestant Name")
+                    add_contestant_btn = gr.Button("Add Contestant")
+                    add_contestant_output = gr.Textbox(label="Add Contestant Status")
+                    add_contestant_btn.click(
+                        fn=self.add_contestant,
+                        inputs=contestant_name,
+                        outputs=add_contestant_output,
+                        # requires=current_game_pin_state
+                    )
+
+                with gr.Row():
+                    answer_contestant_name = gr.Textbox(label="Contestant Name")
+                    question_number = gr.Number(label="Question Number", precision=0)
+                    selected_answer = gr.Textbox(label="Selected Answer")
+                    record_answer_btn = gr.Button("Record Answer")
+                    record_answer_output = gr.Textbox(label="Record Answer Status")
+                    record_answer_btn.click(
+                        fn=self.record_contestant_answer,
+                        inputs=[answer_contestant_name, question_number, selected_answer],
+                        outputs=record_answer_output,
+                        # requires=current_game_pin_state
+                    )
+
+            with gr.Accordion("Leaderboard"):
+                get_leaderboard_btn = gr.Button("Get Leaderboard")
+                leaderboard_output = gr.Textbox(label="Leaderboard")
+                get_leaderboard_btn.click(
+                    fn=self.get_leaderboard,
+                    outputs=leaderboard_output,
+                    # requires=current_game_pin_state
+                )
+
+        return admin_interface
+
+# Create and launch the admin interface
+admin_interface = AdminInterface()
+admin_gradio_interface = admin_interface.create_admin_interface()

app.py

@@ -0,0 +1,25 @@
+import gradio as gr
+from admin_interface import admin_gradio_interface
+from player_interface import player_gradio_interface
+from leaderboards import leaderboard_gradio_interface
+
+def main():
+    # Create a tabbed interface with Admin and Player interfaces
+    with gr.Blocks() as app:
+        gr.Markdown("# Quiz Game")
+        
+        with gr.Tabs():
+            with gr.TabItem("Player", id="player"):
+                player_gradio_interface.render()
+        
+            with gr.TabItem("Admin", id="admin"):
+                admin_gradio_interface.render()
+            
+            with gr.TabItem("Leaderboard", id="leaderboard"):
+                leaderboard_gradio_interface.render()    
+    
+    # Launch the app
+    app.launch(share=True)
+
+if __name__ == "__main__":
+    main()

leaderboards.py

@@ -0,0 +1,250 @@
+# leaderboards.py
+import gradio as gr
+import pandas as pd
+# Assuming quiz_manager is in a separate file named quiz_manager.py
+# and has a 'quizzes' attribute and 'get_leaderboard' method.
+from quiz_manager import quiz_manager
+
+class LeaderboardInterface:
+    def __init__(self):
+        self.current_game_pin = None
+        # Create the interface once and store it
+        self.leaderboard_gradio_interface = self.create_leaderboard_interface()
+
+    def set_current_quiz(self, game_pin):
+        """Set the current game pin."""
+        # Assuming quiz_manager.quizzes is a dictionary holding quiz data
+        if game_pin in quiz_manager.quizzes:
+            self.current_game_pin = game_pin
+            # Update the dropdown choices after setting quiz
+            return f"Current quiz set to: {game_pin}"
+        else:
+            # Reset current_game_pin if the pin is invalid
+            self.current_game_pin = None
+            return f"Invalid Game Pin: {game_pin}"
+            
+    def get_current_contestants(self):
+        """Get list of contestants for the current quiz."""
+        if not self.current_game_pin:
+            return []
+        try:
+            # Try getting the leaderboard first, which seems to have the player data
+            leaderboard = quiz_manager.get_leaderboard(self.current_game_pin)
+            if isinstance(leaderboard, dict):
+                # If leaderboard is a dictionary of player names to scores
+                return list(leaderboard.keys())
+            elif isinstance(leaderboard, list):
+                # If leaderboard is a list of player data
+                players = []
+                if leaderboard and isinstance(leaderboard[0], dict):
+                    # If list of dicts with 'name' key
+                    if 'name' in leaderboard[0]:
+                        return [player['name'] for player in leaderboard]
+                    # If list of dicts with player name as keys
+                    else:
+                        for player_data in leaderboard:
+                            players.extend(list(player_data.keys()))
+                elif leaderboard and isinstance(leaderboard[0], (list, tuple)):
+                    # If list of tuples/lists with [name, score_data]
+                    return [player[0] for player in leaderboard]
+                
+                return players
+            
+            # Fallback to original method if leaderboard approach doesn't work
+            quiz = quiz_manager.get_quiz(self.current_game_pin)
+            if quiz and 'players' in quiz:
+                return list(quiz['players'].keys())
+                
+            # If no players found, return empty list
+            return []
+        except Exception as e:
+            print(f"Error getting contestants: {e}")
+            return []
+            
+    def add_contestant(self, contestant_name):
+        """Add a contestant to the current quiz."""
+        if not self.current_game_pin:
+            return "Please create or select a quiz first!"
+
+        try:
+            quiz_manager.initialize_player_score(self.current_game_pin, contestant_name)
+            return f"{contestant_name} added to the quiz!"
+        except Exception as e:
+            return f"Error adding contestant: {str(e)}"
+        
+    def record_contestant_answer(self, contestant_name, question_number, selected_answer):
+        """Record a contestant's answer."""
+        if not self.current_game_pin:
+            return "Please create or select a quiz first!"
+
+        try:
+            quiz = quiz_manager.get_quiz(self.current_game_pin)
+            if not quiz or not quiz['questions'] or question_number > len(quiz['questions']) or question_number < 1:
+                return "Invalid question number."
+
+            correct_answer = quiz['questions'][question_number - 1]['correct_answer']
+            is_correct = selected_answer == correct_answer
+            quiz_manager.record_answer(self.current_game_pin, contestant_name, is_correct)
+            return f"Answer recorded for {contestant_name} for Question {question_number}."
+        except Exception as e:
+            return f"Error recording answer: {str(e)}"
+        
+    def get_leaderboard(self):
+        """Retrieve the current leaderboard."""
+        if not self.current_game_pin:
+            return "Please select a quiz first!"
+
+        try:
+            # quiz_manager needs a get_leaderboard method that takes the game_pin
+            leaderboard = quiz_manager.get_leaderboard(self.current_game_pin)
+            if not leaderboard:
+                return f"No scores recorded yet for Game Pin: {self.current_game_pin}"
+
+            # Format leaderboard for display
+            leaderboard_str = f"Leaderboard for Game Pin: {self.current_game_pin}\n\n"
+            
+            # Check if leaderboard is a dictionary or a list
+            if isinstance(leaderboard, dict):
+                # If it's a dictionary, process it the original way
+                sorted_leaderboard = sorted(leaderboard.items(), key=lambda item: item[1]['score'], reverse=True)
+                for i, (name, data) in enumerate(sorted_leaderboard, 1):
+                    leaderboard_str += f"{i}. {name}: {data['score']} points\n"
+            elif isinstance(leaderboard, list):
+                # If it's a list, assuming it's a list of dictionaries with 'name' and 'score' keys
+                # or a list of tuples/lists with [name, score_data]
+                sorted_leaderboard = []
+                
+                # Handle different possible formats of list items
+                if leaderboard and isinstance(leaderboard[0], dict):
+                    # If list of dicts with 'name' and 'score' keys
+                    if 'name' in leaderboard[0] and 'score' in leaderboard[0]:
+                        sorted_leaderboard = sorted(leaderboard, key=lambda item: item['score'], reverse=True)
+                        for i, player in enumerate(sorted_leaderboard, 1):
+                            leaderboard_str += f"{i}. {player['name']}: {player['score']} points\n"
+                    # If list of dicts with player name as key and score data as value
+                    else:
+                        for i, player_data in enumerate(leaderboard, 1):
+                            for name, data in player_data.items():
+                                if isinstance(data, dict) and 'score' in data:
+                                    leaderboard_str += f"{i}. {name}: {data['score']} points\n"
+                                else:
+                                    leaderboard_str += f"{i}. {name}: {data} points\n"
+                elif leaderboard and isinstance(leaderboard[0], (list, tuple)):
+                    # If list of tuples/lists with [name, score_data]
+                    sorted_leaderboard = sorted(leaderboard, key=lambda item: item[1]['score'] if isinstance(item[1], dict) else item[1], reverse=True)
+                    for i, (name, data) in enumerate(sorted_leaderboard, 1):
+                        if isinstance(data, dict) and 'score' in data:
+                            leaderboard_str += f"{i}. {name}: {data['score']} points\n"
+                        else:
+                            leaderboard_str += f"{i}. {name}: {data} points\n"
+                else:
+                    # Fallback for other list formats
+                    leaderboard_str += "Leaderboard format not recognized.\n"
+                    leaderboard_str += f"Raw data: {leaderboard}\n"
+            else:
+                leaderboard_str += "Leaderboard format not recognized.\n"
+                leaderboard_str += f"Raw data: {leaderboard}\n"
+                
+            return leaderboard_str
+        except Exception as e:
+            return f"Error retrieving leaderboard: {str(e)}"
+
+    # Function to update dropdown choices
+    def refresh_contestant_dropdown(self):
+        """Return an update for the contestant dropdown."""
+        contestants = self.get_current_contestants()
+        # Add some debug info
+        print(f"Found contestants: {contestants}")
+        return gr.update(choices=contestants)
+
+    def create_leaderboard_interface(self):
+        """Create the Gradio interface for the leaderboard."""
+        with gr.Blocks() as leaderboard_interface:
+            gr.Markdown("## Leaderboard")
+
+            # Section to Select Quiz to View Leaderboard (already exists)
+            with gr.Accordion("Select Quiz to View Leaderboard"):
+                existing_pin_input = gr.Textbox(label="Enter Game Pin")
+                select_quiz_btn = gr.Button("Select Quiz")
+                select_quiz_output = gr.Textbox(label="Quiz Selection Status", interactive=False)
+
+                select_quiz_btn.click(
+                    fn=self.set_current_quiz,
+                    inputs=existing_pin_input,
+                    outputs=select_quiz_output
+                )
+
+            # Section to Add Contestant
+            with gr.Accordion("Add Contestant", open=False): # Start closed
+                contestant_name_input = gr.Textbox(label="Contestant Name")
+                add_contestant_btn = gr.Button("Add Contestant")
+                add_contestant_output = gr.Textbox(label="Add Contestant Status", interactive=False)
+
+                add_contestant_btn.click(
+                    fn=self.add_contestant,
+                    inputs=contestant_name_input,
+                    outputs=add_contestant_output
+                )
+
+            # Section to Record Contestant Answer
+            with gr.Accordion("Record Answer", open=False): # Start closed
+                # Changed from Textbox to Dropdown with initial empty list
+                record_contestant_name_input = gr.Dropdown(
+                    label="Contestant Name",
+                    choices=[],  # Start with empty list
+                    interactive=True
+                )
+                question_number_input = gr.Number(label="Question Number", precision=0) # Use Number for question number
+                selected_answer_input = gr.Textbox(label="Selected Answer")
+                record_answer_btn = gr.Button("Record Answer")
+                record_answer_output = gr.Textbox(label="Record Answer Status", interactive=False)
+                
+                # Refresh button to update contestant list
+                refresh_btn = gr.Button("Refresh Contestant List")
+                
+                refresh_btn.click(
+                    fn=self.refresh_contestant_dropdown,
+                    outputs=record_contestant_name_input
+                )
+
+                record_answer_btn.click(
+                    fn=self.record_contestant_answer,
+                    inputs=[record_contestant_name_input, question_number_input, selected_answer_input],
+                    outputs=record_answer_output
+                )
+                
+                # Also update dropdown when selecting a quiz
+                select_quiz_btn.click(
+                    fn=self.refresh_contestant_dropdown,
+                    outputs=record_contestant_name_input
+                )
+                
+                # Also update dropdown when adding a contestant
+                add_contestant_btn.click(
+                    fn=self.refresh_contestant_dropdown,
+                    outputs=record_contestant_name_input
+                )
+
+            # Section to View Leaderboard (already exists)
+            leaderboard_output = gr.Textbox(label="Current Leaderboard", interactive=False)
+            view_leaderboard_btn = gr.Button("View Leaderboard")
+
+            view_leaderboard_btn.click(
+                fn=self.get_leaderboard,
+                outputs=leaderboard_output
+            )
+
+        return leaderboard_interface
+
+# This automatically creates the Gradio interface within the instance
+leaderboard_interface_instance = LeaderboardInterface()
+
+# To access the Gradio interface object:
+leaderboard_gradio_interface = leaderboard_interface_instance.leaderboard_gradio_interface
+
+# You can now use leaderboard_gradio_interface, for example, to launch it:
+# leaderboard_gradio_interface.launch()
+
+# If this file is imported into another script that launches the main app,
+# you would typically just use leaderboard_gradio_interface
+# as one of the blocks to include in the main layout.

player_interface.py

@@ -0,0 +1,454 @@
+# player_interface.py
+import gradio as gr
+import pandas as pd
+from quiz_manager import quiz_manager # Assuming quiz_manager exists and is accessible
+
+class PlayerInterface:
+    def __init__(self):
+        self.current_game_pin = None
+        self.current_question_index = -1
+        self.current_quiz_data = None
+        self.player_name = None
+        self.total_questions = 0
+
+    def join_game(self, game_pin, player_name):
+        """Validate the game pin and allow player to join."""
+        try:
+            if game_pin not in quiz_manager.quizzes:
+                print("JOIN_GAME: Invalid pin")
+                # Return updates for all relevant components on failure
+                return (
+                    f"Invalid game pin: {game_pin}. Please try again.",
+                    gr.update(choices=[], visible=False), # Hide and clear dropdown
+                    gr.update(visible=False), # Hide next button row
+                    gr.update(visible=False), # Hide question area
+                    gr.update(visible=False)  # Hide leaderboard area initially (added this output)
+                )
+            self.current_game_pin = game_pin
+            self.current_quiz_data = quiz_manager.quizzes[game_pin]
+            self.player_name = player_name
+            # Assuming initialize_player_score is a method in quiz_manager
+            quiz_manager.initialize_player_score(game_pin, player_name)
+            self.total_questions = len(self.current_quiz_data.get('questions', [])) # Safely get questions
+            question_numbers = list(range(1, self.total_questions + 1))
+            print("JOIN_GAME: Success")
+            print(f"JOIN_GAME: current_game_pin = {self.current_game_pin}")
+            print(f"JOIN_GAME: current_quiz_data = {self.current_quiz_data}")
+            print(f"JOIN_GAME: total_questions = {self.total_questions}")
+
+            # Return updates for all relevant components on success
+            return (
+                f"Joined game {game_pin} successfully, {player_name}!",
+                gr.update(choices=question_numbers, visible=True, value=None), # Update choices, make visible, reset value
+                gr.update(visible=True),  # Show next button row
+                gr.update(visible=False), # Keep question area hidden initially
+                gr.update(visible=True)   # Show leaderboard area (assuming it should appear after joining)
+            )
+        except Exception as e:
+            print(f"JOIN_GAME: Error - {str(e)}")
+             # Return updates for all relevant components on error
+            return (
+                f"Error joining game: {str(e)}",
+                gr.update(choices=[], visible=False),
+                gr.update(visible=False),
+                gr.update(visible=False),
+                gr.update(visible=False)
+            )
+
+
+    def show_question(self):
+        """Prepare updates for displaying the current question."""
+        print("SHOW_QUESTION: Called")
+        # Prepare default updates for components
+        default_question_text = "No question loaded."
+        default_options_update = gr.update(choices=[], value=None)
+        default_prompt_label_update = gr.update(value="")
+        default_question_area_update = gr.update(visible=True)
+        default_submit_btn_update = gr.update(visible=True)
+        default_answer_output_update = gr.update(value="")
+
+
+        if not self.current_quiz_data or self.current_question_index == -1:
+            print("SHOW_QUESTION: No quiz data or invalid index")
+            # Return default updates
+            return (
+                default_question_text,
+                default_options_update,
+                default_prompt_label_update,
+                default_question_area_update,
+                default_submit_btn_update,
+                default_answer_output_update # Include update for answer_output
+            )
+
+        # Ensure questions key exists and index is valid
+        questions = self.current_quiz_data.get('questions', [])
+        if not questions or self.current_question_index < 0 or self.current_question_index >= len(questions):
+             print("SHOW_QUESTION: Invalid question data or index out of bounds")
+             return (
+                "Error loading question data.",
+                default_options_update,
+                default_prompt_label_update,
+                default_question_area_update,
+                default_submit_btn_update,
+                default_answer_output_update
+             )
+
+
+        question_data = questions[self.current_question_index]
+        options = question_data.get('options', [])
+        question_text = question_data.get('text', 'Error loading question text')
+        print(f"SHOW_QUESTION: Displaying question - index: {self.current_question_index}, text: {question_text}")
+        print(f"SHOW_QUESTION: Options: {options}")
+
+        # Return specific updates for the current question
+        return (
+            f"Question {self.current_question_index + 1}: {question_text}", # Update question_display value
+            gr.update(choices=options, value=None, label="Answer Choices"), # Update options_radio choices, reset value, set static label
+            gr.update(value="Select your answer:"), # Update options_prompt_label value
+            gr.update(visible=True),  # Update question_area visibility
+            gr.update(visible=True),  # Update submit_btn visibility
+            gr.update(value="")       # Clear answer_output value
+        )
+
+    # The methods next_step, next_question, previous_question, and
+    # select_question_by_number now just need to call show_question
+    # and return its result, as show_question prepares all the necessary updates.
+
+    def next_step(self):
+        print("NEXT_STEP: Called")
+        if self.current_quiz_data and self.total_questions > 0:
+            self.current_question_index = 0
+            result = self.show_question()
+            print(f"NEXT_STEP: Showing question - index: {self.current_question_index}")
+            # show_question now returns 6 updates, return them directly
+            return result
+        else:
+            print("NEXT_STEP: No questions available")
+            # Return default updates if no questions
+            return (
+                "No questions available.",
+                gr.update(choices=[], value=None, label="Answer Choices"),
+                gr.update(value=""),
+                gr.update(visible=False),
+                gr.update(visible=False),
+                gr.update(value="")
+            )
+
+
+    def next_question(self):
+        """Move to the next question."""
+        print("NEXT_QUESTION: Called")
+        if not self.current_quiz_data:
+            print("NEXT_QUESTION: No quiz data")
+            # Return default updates
+            return (
+                "Please join a game first.",
+                gr.update(choices=[], value=None, label="Answer Choices"),
+                gr.update(value=""),
+                gr.update(visible=False),
+                gr.update(visible=False),
+                gr.update(value="")
+            )
+        if self.current_question_index < len(self.current_quiz_data.get('questions', [])) - 1:
+            self.current_question_index += 1
+            result = self.show_question()
+            print(f"NEXT_QUESTION: Showing question - index: {self.current_question_index}")
+            # show_question now returns 6 updates, return them directly
+            return result
+        else:
+            print("NEXT_QUESTION: Quiz finished")
+            # Return updates for quiz finished state
+            return (
+                "Quiz finished!",
+                gr.update(choices=[], value=None, label="Answer Choices"),
+                gr.update(value=""),
+                gr.update(visible=False), # Hide question area
+                gr.update(visible=False), # Hide submit button
+                gr.update(value="")
+            )
+
+    def previous_question(self):
+        """Move to the previous question."""
+        print("PREVIOUS_QUESTION: Called")
+        if not self.current_quiz_data:
+            print("PREVIOUS_QUESTION: No quiz data")
+            # Return default updates
+            return (
+                "Please join a game first.",
+                gr.update(choices=[], value=None, label="Answer Choices"),
+                gr.update(value=""),
+                gr.update(visible=False),
+                gr.update(visible=False),
+                gr.update(value="")
+            )
+        if self.current_question_index > 0:
+            self.current_question_index -= 1
+            result = self.show_question()
+            print(f"PREVIOUS_QUESTION: Showing question - index: {self.current_question_index}")
+            # show_question now returns 6 updates, return them directly
+            return result
+        else:
+            print("PREVIOUS_QUESTION: First question")
+            # Return updates for first question state
+            return (
+                "This is the first question.",
+                gr.update(choices=[], value=None, label="Answer Choices"),
+                gr.update(value=""),
+                gr.update(visible=False),
+                gr.update(visible=False),
+                gr.update(value="")
+            )
+
+
+    def select_question_by_number(self, question_number):
+        """Select a specific question by its number."""
+        print(f"SELECT_QUESTION_BY_NUMBER: Called with {question_number}")
+        # Handle case where question_number might be None from dropdown reset
+        if question_number is None:
+             print("SELECT_QUESTION_BY_NUMBER: question_number is None")
+             return (
+                "", # Clear question text
+                gr.update(choices=[], value=None, label="Answer Choices"), # Clear options
+                gr.update(value=""), # Clear prompt label
+                gr.update(visible=False), # Hide question area
+                gr.update(visible=False), # Hide submit button
+                gr.update(value="") # Clear answer output
+            )
+
+        if not self.current_quiz_data:
+            print("SELECT_QUESTION_BY_NUMBER: No quiz data")
+            # Return default updates
+            return (
+                "Please join a game first.",
+                gr.update(choices=[], value=None, label="Answer Choices"),
+                gr.update(value=""),
+                gr.update(visible=False),
+                gr.update(visible=False),
+                gr.update(value="")
+            )
+
+        questions = self.current_quiz_data.get('questions', [])
+        index = question_number - 1
+        if 0 <= index < len(questions):
+            self.current_question_index = index
+            result = self.show_question()
+            print(f"SELECT_QUESTION_BY_NUMBER: Showing question - index: {self.current_question_index}")
+            # show_question now returns 6 updates, return them directly
+            return result
+        else:
+            print("SELECT_QUESTION_BY_NUMBER: Invalid question number")
+            # Return updates for invalid number
+            return (
+                "Invalid question number.",
+                gr.update(choices=[], value=None, label="Answer Choices"),
+                gr.update(value=""),
+                gr.update(visible=False),
+                gr.update(visible=False),
+                gr.update(value="")
+            )
+
+
+    def submit_answer(self, selected_option):
+        """Submit the player's answer for the current question."""
+        if not self.current_quiz_data or self.current_question_index == -1:
+            return "Please select a question first."
+         # Ensure selected_option is not None if the user submits without selecting
+        if selected_option is None:
+             return "Please select an answer."
+
+
+        questions = self.current_quiz_data.get('questions', [])
+        if not questions or self.current_question_index < 0 or self.current_question_index >= len(questions):
+             return "Error submitting answer: Invalid question data."
+
+        current_question = questions[self.current_question_index]
+        correct_answer = current_question.get('correct_answer')
+        # Handle cases where correct_answer might be missing
+        if correct_answer is None:
+             return "Error submitting answer: Correct answer not defined for this question."
+
+        is_correct = selected_option == correct_answer
+
+        # Assuming record_answer is a method in quiz_manager
+        if self.current_game_pin and self.player_name:
+            quiz_manager.record_answer(self.current_game_pin, self.player_name, is_correct)
+
+        return "Correct!" if is_correct else f"Incorrect. The correct answer was: {correct_answer}"
+
+    def get_leaderboard(self):
+        """Retrieve and display the leaderboard."""
+        print("GET_LEADERBOARD: Called")
+        if not self.current_game_pin:
+            print("GET_LEADERBOARD: No game pin")
+            return "Please join a game first."
+        # Assuming get_leaderboard is a method in quiz_manager that returns a LIST of tuples or lists
+        # where each element is something like (player_name, {'score': score_value, ...})
+        leaderboard = quiz_manager.get_leaderboard(self.current_game_pin)
+
+        if not leaderboard:
+            print("GET_LEADERBOARD: No scores recorded")
+            return "No scores recorded yet."
+
+        leaderboard_str = "### Leaderboard:\n"
+        # Sort leaderboard by score in descending order
+        # Removed .items() because 'leaderboard' is a list
+        try:
+            sorted_leaderboard = sorted(leaderboard, key=lambda item: item[1].get('score', 0), reverse=True)
+            for i, (name, data) in enumerate(sorted_leaderboard, 1):
+                score = data.get('score', 0) # Safely get score
+                leaderboard_str += f"{i}. {name}: {score} points\n"
+            print("GET_LEADERBOARD: Leaderboard generated")
+            return leaderboard_str
+        except (TypeError, IndexError, AttributeError) as e:
+            # Catch potential errors if the list elements are not in the expected format
+            print(f"GET_LEADERBOARD: Error processing leaderboard data - {str(e)}")
+            return f"Error displaying leaderboard data: {str(e)}. Please check the format returned by quiz_manager.get_leaderboard."
+
+    def create_player_interface(self):
+        """Create the Gradio interface for players with a step-by-step layout."""
+        with gr.Blocks() as player_interface:
+            gr.Markdown("## Quiz Player Dashboard")
+
+            # --- Join Game Section ---
+            with gr.Row():
+                game_pin_input = gr.Textbox(label="Enter Game Pin")
+                player_name_input = gr.Textbox(label="Your Name")
+                join_btn = gr.Button("Join Game")
+                join_output = gr.Textbox(label="Join Status", interactive=False)
+                # question_dropdown visibility and choices updated by join_game
+                question_dropdown = gr.Dropdown(label="Select Question", choices=[], visible=False, interactive=True)
+
+            # --- Initial Next Button (to start the quiz) ---
+            # Initially hidden, made visible after joining
+            next_button_row = gr.Row(visible=False)
+            with next_button_row:
+                # This button will trigger showing the first question via next_step
+                next_btn = gr.Button("Start Quiz")
+
+            # --- Question Area (initially hidden) ---
+            # Made visible when a question is loaded
+            question_area = gr.Column(visible=False)
+            with question_area:
+                question_display = gr.Markdown(label="Question Text") # Label can be static here
+                options_prompt_label = gr.Label(label="") # Label to show "Select your answer:"
+                options_radio = gr.Radio(label="Answer Choices") # Static label for the radio group
+                submit_btn = gr.Button("Submit Answer")
+                answer_output = gr.Textbox(label="Answer Result", interactive=False)
+
+
+                # --- Navigation Buttons ---
+                with gr.Row():
+                    prev_question_btn = gr.Button("Previous Question")
+                    next_question_btn = gr.Button("Next Question")
+
+            # --- Leaderboard Area (initially hidden, shown after joining) ---
+            leaderboard_area = gr.Column(visible=False)
+            with leaderboard_area:
+                leaderboard_output = gr.Markdown(label="Leaderboard Results")
+                get_leaderboard_btn = gr.Button("Refresh Leaderboard")
+
+            # --- Interactions ---
+
+            # Join Game interaction
+            # join_game returns 5 outputs: join_status, dropdown_update, next_btn_row_update, question_area_update (initial hide), leaderboard_area_update
+            join_btn.click(
+                fn=self.join_game,
+                inputs=[game_pin_input, player_name_input],
+                outputs=[
+                    join_output,
+                    question_dropdown,
+                    next_button_row,
+                    question_area,
+                    leaderboard_area # Map to the leaderboard area visibility
+                ]
+            )
+
+            # Start Quiz button interaction (uses next_step to show the first question)
+            # next_step calls show_question, which returns 6 updates
+            next_btn.click(
+                fn=self.next_step,
+                outputs=[
+                    question_display,       # Updates with question text
+                    options_radio,          # Updates with choices and value=None
+                    options_prompt_label,   # Updates with "Select your answer:"
+                    question_area,          # Updates visibility
+                    submit_btn,             # Updates visibility
+                    answer_output           # Clears answer output
+                ]
+            )
+
+            # Question Dropdown interaction
+            # select_question_by_number calls show_question, which returns 6 updates
+            question_dropdown.change(
+                fn=self.select_question_by_number,
+                inputs=question_dropdown,
+                 outputs=[
+                    question_display,
+                    options_radio,
+                    options_prompt_label,
+                    question_area,
+                    submit_btn,
+                    answer_output
+                ]
+            )
+
+            # Next Question button interaction
+            # next_question calls show_question, which returns 6 updates
+            next_question_btn.click(
+                fn=self.next_question,
+                 outputs=[
+                    question_display,
+                    options_radio,
+                    options_prompt_label,
+                    question_area,
+                    submit_btn,
+                    answer_output
+                ]
+            )
+
+            # Previous Question button interaction
+            # previous_question calls show_question, which returns 6 updates
+            prev_question_btn.click(
+                fn=self.previous_question,
+                 outputs=[
+                    question_display,
+                    options_radio,
+                    options_prompt_label,
+                    question_area,
+                    submit_btn,
+                    answer_output
+                ]
+            )
+
+            # Submit Answer button interaction
+            submit_btn.click(
+                fn=self.submit_answer,
+                inputs=options_radio, # Input is the selected value from the radio button
+                outputs=answer_output, # Output is the result of the submission
+            )
+
+            # Refresh Leaderboard button interaction
+            get_leaderboard_btn.click(
+                fn=self.get_leaderboard,
+                outputs=leaderboard_output,
+            )
+
+            # The leaderboard visibility is handled by the join_game outputs now,
+            # so the separate .then() listener is not needed here.
+
+        return player_interface
+
+# --- How to use this class ---
+
+# Create the PlayerInterface instance
+player_interface_instance = PlayerInterface()
+
+# To access the Gradio interface object:
+player_gradio_interface = player_interface_instance.create_player_interface()
+
+# You can now use player_gradio_interface, for example, to launch it:
+# player_gradio_interface.launch()
+
+# If this file is imported into another script that launches the main app,
+# you would typically just use player_gradio_interface
+# as one of the blocks to include in the main layout.

quiz_data/quiz_193449.json

@@ -0,0 +1,225 @@
+{
+    "name": "KL",
+    "questions": [
+        {
+            "text": "What is the capital of France?",
+            "options": [
+                "London",
+                "Berlin",
+                "Paris",
+                "Madrid"
+            ],
+            "correct_answer": "Paris"
+        },
+        {
+            "text": "Which planet is known as the Red Planet?",
+            "options": [
+                "Mars",
+                "Jupiter",
+                "Venus",
+                "Saturn"
+            ],
+            "correct_answer": "Mars"
+        },
+        {
+            "text": "What is the chemical symbol for water?",
+            "options": [
+                "Wa",
+                "H2O",
+                "Wo",
+                "HO2"
+            ],
+            "correct_answer": "H2O"
+        },
+        {
+            "text": "Who painted the Mona Lisa?",
+            "options": [
+                "Vincent van Gogh",
+                "Leonardo da Vinci",
+                "Pablo Picasso",
+                "Claude Monet"
+            ],
+            "correct_answer": "Leonardo da Vinci"
+        },
+        {
+            "text": "What is the largest mammal in the world?",
+            "options": [
+                "African Elephant",
+                "Blue Whale",
+                "Giraffe",
+                "Polar Bear"
+            ],
+            "correct_answer": "Blue Whale"
+        },
+        {
+            "text": "How many continents are there?",
+            "options": [
+                "Five",
+                "Six",
+                "Seven",
+                "Eight"
+            ],
+            "correct_answer": "Seven"
+        },
+        {
+            "text": "What is the currency of Japan?",
+            "options": [
+                "Yuan",
+                "Won",
+                "Dollar",
+                "Yen"
+            ],
+            "correct_answer": "Yen"
+        },
+        {
+            "text": "What is the tallest mountain in the world?",
+            "options": [
+                "K2",
+                "Mount Everest",
+                "Kangchenjunga",
+                "Lhotse"
+            ],
+            "correct_answer": "Mount Everest"
+        },
+        {
+            "text": "What is the speed of light in a vacuum (approximately)?",
+            "options": [
+                "300000 km/s",
+                "150000 km/s",
+                "450000 km/s",
+                "200000 km/s"
+            ],
+            "correct_answer": "300000 km/s"
+        },
+        {
+            "text": "What is the powerhouse of the cell?",
+            "options": [
+                "Nucleus",
+                "Mitochondria",
+                "Ribosome",
+                "Endoplasmic Reticulum"
+            ],
+            "correct_answer": "Mitochondria"
+        },
+        {
+            "text": "What is the chemical symbol for gold?",
+            "options": [
+                "Au",
+                "Ag",
+                "Go",
+                "Gd"
+            ],
+            "correct_answer": "Au"
+        },
+        {
+            "text": "Who wrote the play \"Hamlet\"?",
+            "options": [
+                "William Shakespeare",
+                "Jane Austen",
+                "Charles Dickens",
+                "George Orwell"
+            ],
+            "correct_answer": "William Shakespeare"
+        },
+        {
+            "text": "What is the largest ocean on Earth?",
+            "options": [
+                "Atlantic Ocean",
+                "Indian Ocean",
+                "Arctic Ocean",
+                "Pacific Ocean"
+            ],
+            "correct_answer": "Pacific Ocean"
+        },
+        {
+            "text": "What is the boiling point of water at standard pressure?",
+            "options": [
+                "100\u00b0C",
+                "0\u00b0C",
+                "50\u00b0C",
+                "212\u00b0F"
+            ],
+            "correct_answer": "100\u00b0C"
+        },
+        {
+            "text": "What is the main gas in Earth's atmosphere?",
+            "options": [
+                "Oxygen",
+                "Carbon Dioxide",
+                "Nitrogen",
+                "Hydrogen"
+            ],
+            "correct_answer": "Nitrogen"
+        },
+        {
+            "text": "Who developed the theory of relativity?",
+            "options": [
+                "Isaac Newton",
+                "Albert Einstein",
+                "Galileo Galilei",
+                "Stephen Hawking"
+            ],
+            "correct_answer": "Albert Einstein"
+        },
+        {
+            "text": "What is the smallest prime number?",
+            "options": [
+                "0",
+                "1",
+                "2",
+                "3"
+            ],
+            "correct_answer": "2"
+        },
+        {
+            "text": "What is the capital of Australia?",
+            "options": [
+                "Sydney",
+                "Melbourne",
+                "Canberra",
+                "Perth"
+            ],
+            "correct_answer": "Canberra"
+        },
+        {
+            "text": "What type of animal is a dolphin?",
+            "options": [
+                "Fish",
+                "Mammal",
+                "Reptile",
+                "Amphibian"
+            ],
+            "correct_answer": "Mammal"
+        },
+        {
+            "text": "What is the name of Earth's natural satellite?",
+            "options": [
+                "Mars",
+                "Venus",
+                "Moon",
+                "Titan"
+            ],
+            "correct_answer": "Moon"
+        }
+    ],
+    "leaderboard": {
+        "John": {
+            "score": 6
+        },
+        "Johhnn": {
+            "score": 0
+        },
+        "Jommk": {
+            "score": 0
+        },
+        "": {
+            "score": 0
+        },
+        "hjjjh": {
+            "score": 1
+        },
+        "JOHN": {
+            "score": 0
+        }
+    }
+}

quiz_data/quiz_620321.json

@@ -0,0 +1,5 @@
+{
+    "name": "193449",
+    "questions": [],
+    "leaderboard": {}
+}

quiz_data/quiz_655067.json

@@ -0,0 +1,5 @@
+{
+    "name": "193449",
+    "questions": [],
+    "leaderboard": {}
+}

quiz_data/quiz_772319.json

@@ -0,0 +1,9 @@
+{
+    "name": "quiz",
+    "questions": [],
+    "leaderboard": {
+        "John": {
+            "score": 0
+        }
+    }
+}

quiz_data/quiz_854464.json

@@ -0,0 +1,228 @@
+{
+    "name": "JOHN",
+    "questions": [
+        {
+            "text": "What is the capital of France?",
+            "options": [
+                "London",
+                "Berlin",
+                "Paris",
+                "Madrid"
+            ],
+            "correct_answer": "Paris"
+        },
+        {
+            "text": "Which planet is known as the Red Planet?",
+            "options": [
+                "Mars",
+                "Jupiter",
+                "Venus",
+                "Saturn"
+            ],
+            "correct_answer": "Mars"
+        },
+        {
+            "text": "What is the chemical symbol for water?",
+            "options": [
+                "Wa",
+                "H2O",
+                "Wo",
+                "HO2"
+            ],
+            "correct_answer": "H2O"
+        },
+        {
+            "text": "Who painted the Mona Lisa?",
+            "options": [
+                "Vincent van Gogh",
+                "Leonardo da Vinci",
+                "Pablo Picasso",
+                "Claude Monet"
+            ],
+            "correct_answer": "Leonardo da Vinci"
+        },
+        {
+            "text": "What is the largest mammal in the world?",
+            "options": [
+                "African Elephant",
+                "Blue Whale",
+                "Giraffe",
+                "Polar Bear"
+            ],
+            "correct_answer": "Blue Whale"
+        },
+        {
+            "text": "How many continents are there?",
+            "options": [
+                "Five",
+                "Six",
+                "Seven",
+                "Eight"
+            ],
+            "correct_answer": "Seven"
+        },
+        {
+            "text": "What is the currency of Japan?",
+            "options": [
+                "Yuan",
+                "Won",
+                "Dollar",
+                "Yen"
+            ],
+            "correct_answer": "Yen"
+        },
+        {
+            "text": "What is the tallest mountain in the world?",
+            "options": [
+                "K2",
+                "Mount Everest",
+                "Kangchenjunga",
+                "Lhotse"
+            ],
+            "correct_answer": "Mount Everest"
+        },
+        {
+            "text": "What is the speed of light in a vacuum (approximately)?",
+            "options": [
+                "300000 km/s",
+                "150000 km/s",
+                "450000 km/s",
+                "200000 km/s"
+            ],
+            "correct_answer": "300000 km/s"
+        },
+        {
+            "text": "What is the powerhouse of the cell?",
+            "options": [
+                "Nucleus",
+                "Mitochondria",
+                "Ribosome",
+                "Endoplasmic Reticulum"
+            ],
+            "correct_answer": "Mitochondria"
+        },
+        {
+            "text": "What is the chemical symbol for gold?",
+            "options": [
+                "Au",
+                "Ag",
+                "Go",
+                "Gd"
+            ],
+            "correct_answer": "Au"
+        },
+        {
+            "text": "Who wrote the play \"Hamlet\"?",
+            "options": [
+                "William Shakespeare",
+                "Jane Austen",
+                "Charles Dickens",
+                "George Orwell"
+            ],
+            "correct_answer": "William Shakespeare"
+        },
+        {
+            "text": "What is the largest ocean on Earth?",
+            "options": [
+                "Atlantic Ocean",
+                "Indian Ocean",
+                "Arctic Ocean",
+                "Pacific Ocean"
+            ],
+            "correct_answer": "Pacific Ocean"
+        },
+        {
+            "text": "What is the boiling point of water at standard pressure?",
+            "options": [
+                "100\u00b0C",
+                "0\u00b0C",
+                "50\u00b0C",
+                "212\u00b0F"
+            ],
+            "correct_answer": "100\u00b0C"
+        },
+        {
+            "text": "What is the main gas in Earth's atmosphere?",
+            "options": [
+                "Oxygen",
+                "Carbon Dioxide",
+                "Nitrogen",
+                "Hydrogen"
+            ],
+            "correct_answer": "Nitrogen"
+        },
+        {
+            "text": "Who developed the theory of relativity?",
+            "options": [
+                "Isaac Newton",
+                "Albert Einstein",
+                "Galileo Galilei",
+                "Stephen Hawking"
+            ],
+            "correct_answer": "Albert Einstein"
+        },
+        {
+            "text": "What is the smallest prime number?",
+            "options": [
+                "0",
+                "1",
+                "2",
+                "3"
+            ],
+            "correct_answer": "2"
+        },
+        {
+            "text": "What is the capital of Australia?",
+            "options": [
+                "Sydney",
+                "Melbourne",
+                "Canberra",
+                "Perth"
+            ],
+            "correct_answer": "Canberra"
+        },
+        {
+            "text": "What type of animal is a dolphin?",
+            "options": [
+                "Fish",
+                "Mammal",
+                "Reptile",
+                "Amphibian"
+            ],
+            "correct_answer": "Mammal"
+        },
+        {
+            "text": "What is the name of Earth's natural satellite?",
+            "options": [
+                "Mars",
+                "Venus",
+                "Moon",
+                "Titan"
+            ],
+            "correct_answer": "Moon"
+        }
+    ],
+    "leaderboard": {
+        "GKJ": {
+            "score": 0
+        },
+        "JOHN": {
+            "score": 0
+        },
+        "JOOHN": {
+            "score": 0
+        },
+        "hffd": {
+            "score": 0
+        },
+        "g": {
+            "score": 0
+        },
+        "t": {
+            "score": 0
+        },
+        "": {
+            "score": 0
+        }
+    }
+}

quiz_data/quiz_925005.json

@@ -0,0 +1,210 @@
+{
+    "name": "Mol",
+    "questions": [
+        {
+            "text": "What is the capital of France?",
+            "options": [
+                "London",
+                "Berlin",
+                "Paris",
+                "Madrid"
+            ],
+            "correct_answer": "Paris"
+        },
+        {
+            "text": "Which planet is known as the Red Planet?",
+            "options": [
+                "Mars",
+                "Jupiter",
+                "Venus",
+                "Saturn"
+            ],
+            "correct_answer": "Mars"
+        },
+        {
+            "text": "What is the chemical symbol for water?",
+            "options": [
+                "Wa",
+                "H2O",
+                "Wo",
+                "HO2"
+            ],
+            "correct_answer": "H2O"
+        },
+        {
+            "text": "Who painted the Mona Lisa?",
+            "options": [
+                "Vincent van Gogh",
+                "Leonardo da Vinci",
+                "Pablo Picasso",
+                "Claude Monet"
+            ],
+            "correct_answer": "Leonardo da Vinci"
+        },
+        {
+            "text": "What is the largest mammal in the world?",
+            "options": [
+                "African Elephant",
+                "Blue Whale",
+                "Giraffe",
+                "Polar Bear"
+            ],
+            "correct_answer": "Blue Whale"
+        },
+        {
+            "text": "How many continents are there?",
+            "options": [
+                "Five",
+                "Six",
+                "Seven",
+                "Eight"
+            ],
+            "correct_answer": "Seven"
+        },
+        {
+            "text": "What is the currency of Japan?",
+            "options": [
+                "Yuan",
+                "Won",
+                "Dollar",
+                "Yen"
+            ],
+            "correct_answer": "Yen"
+        },
+        {
+            "text": "What is the tallest mountain in the world?",
+            "options": [
+                "K2",
+                "Mount Everest",
+                "Kangchenjunga",
+                "Lhotse"
+            ],
+            "correct_answer": "Mount Everest"
+        },
+        {
+            "text": "What is the speed of light in a vacuum (approximately)?",
+            "options": [
+                "300000 km/s",
+                "150000 km/s",
+                "450000 km/s",
+                "200000 km/s"
+            ],
+            "correct_answer": "300000 km/s"
+        },
+        {
+            "text": "What is the powerhouse of the cell?",
+            "options": [
+                "Nucleus",
+                "Mitochondria",
+                "Ribosome",
+                "Endoplasmic Reticulum"
+            ],
+            "correct_answer": "Mitochondria"
+        },
+        {
+            "text": "What is the chemical symbol for gold?",
+            "options": [
+                "Au",
+                "Ag",
+                "Go",
+                "Gd"
+            ],
+            "correct_answer": "Au"
+        },
+        {
+            "text": "Who wrote the play \"Hamlet\"?",
+            "options": [
+                "William Shakespeare",
+                "Jane Austen",
+                "Charles Dickens",
+                "George Orwell"
+            ],
+            "correct_answer": "William Shakespeare"
+        },
+        {
+            "text": "What is the largest ocean on Earth?",
+            "options": [
+                "Atlantic Ocean",
+                "Indian Ocean",
+                "Arctic Ocean",
+                "Pacific Ocean"
+            ],
+            "correct_answer": "Pacific Ocean"
+        },
+        {
+            "text": "What is the boiling point of water at standard pressure?",
+            "options": [
+                "100\u00b0C",
+                "0\u00b0C",
+                "50\u00b0C",
+                "212\u00b0F"
+            ],
+            "correct_answer": "100\u00b0C"
+        },
+        {
+            "text": "What is the main gas in Earth's atmosphere?",
+            "options": [
+                "Oxygen",
+                "Carbon Dioxide",
+                "Nitrogen",
+                "Hydrogen"
+            ],
+            "correct_answer": "Nitrogen"
+        },
+        {
+            "text": "Who developed the theory of relativity?",
+            "options": [
+                "Isaac Newton",
+                "Albert Einstein",
+                "Galileo Galilei",
+                "Stephen Hawking"
+            ],
+            "correct_answer": "Albert Einstein"
+        },
+        {
+            "text": "What is the smallest prime number?",
+            "options": [
+                "0",
+                "1",
+                "2",
+                "3"
+            ],
+            "correct_answer": "2"
+        },
+        {
+            "text": "What is the capital of Australia?",
+            "options": [
+                "Sydney",
+                "Melbourne",
+                "Canberra",
+                "Perth"
+            ],
+            "correct_answer": "Canberra"
+        },
+        {
+            "text": "What type of animal is a dolphin?",
+            "options": [
+                "Fish",
+                "Mammal",
+                "Reptile",
+                "Amphibian"
+            ],
+            "correct_answer": "Mammal"
+        },
+        {
+            "text": "What is the name of Earth's natural satellite?",
+            "options": [
+                "Mars",
+                "Venus",
+                "Moon",
+                "Titan"
+            ],
+            "correct_answer": "Moon"
+        }
+    ],
+    "leaderboard": {
+        "John": {
+            "score": 0
+        }
+    }
+}

quiz_manager.py

@@ -0,0 +1,106 @@
+import random
+import json
+import os
+from collections import defaultdict
+
+class QuizManager:
+    def __init__(self, data_dir="quiz_data"):
+        self.quizzes = self.load_quizzes(data_dir)
+        self.data_dir = data_dir
+        os.makedirs(self.data_dir, exist_ok=True)
+
+    def _get_quiz_file_path(self, game_pin):
+        return os.path.join(self.data_dir, f"quiz_{game_pin}.json")
+
+    def _get_leaderboard_file_path(self, game_pin):
+        return os.path.join(self.data_dir, f"leaderboard_{game_pin}.json")
+
+    def _generate_unique_pin(self):
+        """Generates a unique 6-digit game pin."""
+        while True:
+            pin = str(random.randint(100000, 999999))
+            if pin not in self.quizzes:
+                return pin
+
+    def create_quiz(self, name):
+        """Creates a new quiz and returns a unique game pin."""
+        game_pin = self._generate_unique_pin()
+        self.quizzes[game_pin] = {"name": name, "questions": [], "leaderboard": defaultdict(lambda: {"score": 0})}
+        self._save_quiz_data(game_pin)
+        return game_pin
+
+    def add_question(self, game_pin, text, options, correct_answer):
+        """Adds a question to a specific quiz."""
+        if game_pin in self.quizzes:
+            self.quizzes[game_pin]["questions"].append({
+                "text": text,
+                "options": options,
+                "correct_answer": correct_answer
+            })
+            self._save_quiz_data(game_pin)
+        else:
+            raise ValueError("Invalid game pin.")
+
+    def get_quiz(self, game_pin):
+        """Retrieves a quiz by its game pin."""
+        return self.quizzes.get(game_pin)
+
+    def load_quizzes(self, data_dir):
+        """Loads quiz data from JSON files in the specified directory."""
+        quizzes = {}
+        os.makedirs(data_dir, exist_ok=True)
+        for filename in os.listdir(data_dir):
+            if filename.startswith("quiz_") and filename.endswith(".json"):
+                filepath = os.path.join(data_dir, filename)
+                try:
+                    with open(filepath, 'r') as f:
+                        data = json.load(f)
+                        pin = filename.split("_")[1].split(".")[0]
+                        quizzes[pin] = data
+                except Exception as e:
+                    print(f"Error loading quiz from {filename}: {e}")
+        return quizzes
+
+    def _save_quiz_data(self, game_pin):
+        """Saves the quiz data to a JSON file."""
+        filepath = self._get_quiz_file_path(game_pin)
+        try:
+            with open(filepath, 'w') as f:
+                json.dump(self.quizzes[game_pin], f, indent=4)
+        except Exception as e:
+            print(f"Error saving quiz data for {game_pin}: {e}")
+
+    def initialize_player_score(self, game_pin, player_name):
+        """Initializes a player's score for a given quiz."""
+        if game_pin in self.quizzes:
+            if player_name not in self.quizzes[game_pin]["leaderboard"]:
+                self.quizzes[game_pin]["leaderboard"][player_name] = {"score": 0}
+                self._save_quiz_data(game_pin)
+        else:
+            raise ValueError("Invalid game pin.")
+
+    def record_answer(self, game_pin, player_name, is_correct):
+        """Records a player's answer and updates their score."""
+        if game_pin in self.quizzes and player_name in self.quizzes[game_pin]["leaderboard"]:
+            if is_correct:
+                self.quizzes[game_pin]["leaderboard"][player_name]["score"] += 1
+            self._save_quiz_data(game_pin)
+        elif game_pin not in self.quizzes:
+            raise ValueError("Invalid game pin.")
+        elif player_name not in self.quizzes[game_pin]["leaderboard"]:
+            raise ValueError(f"Player '{player_name}' not found in game '{game_pin}'.")
+
+    def get_leaderboard(self, game_pin):
+        """Retrieves the leaderboard for a given quiz, sorted by score."""
+        if game_pin in self.quizzes:
+            leaderboard = sorted(
+                self.quizzes[game_pin]["leaderboard"].items(),
+                key=lambda item: item[1]["score"],
+                reverse=True
+            )
+            return leaderboard
+        else:
+            raise ValueError("Invalid game pin.")
+
+# Instantiate the quiz manager
+quiz_manager = QuizManager()

qursioms.csv

@@ -0,0 +1,21 @@
+question,option1,option2,option3,option4,correct_answer
+What is the capital of France?,London,Berlin,Paris,Madrid,Paris
+Which planet is known as the Red Planet?,Mars,Jupiter,Venus,Saturn,Mars
+What is the chemical symbol for water?,Wa,H2O,Wo,HO2,H2O
+Who painted the Mona Lisa?,Vincent van Gogh,Leonardo da Vinci,Pablo Picasso,Claude Monet,Leonardo da Vinci
+What is the largest mammal in the world?,African Elephant,Blue Whale,Giraffe,Polar Bear,Blue Whale
+How many continents are there?,Five,Six,Seven,Eight,Seven
+What is the currency of Japan?,Yuan,Won,Dollar,Yen,Yen
+What is the tallest mountain in the world?,K2,Mount Everest,Kangchenjunga,Lhotse,Mount Everest
+What is the speed of light in a vacuum (approximately)?,300000 km/s,150000 km/s,450000 km/s,200000 km/s,300000 km/s
+What is the powerhouse of the cell?,Nucleus,Mitochondria,Ribosome,Endoplasmic Reticulum,Mitochondria
+What is the chemical symbol for gold?,Au,Ag,Go,Gd,Au
+Who wrote the play "Hamlet"?,William Shakespeare,Jane Austen,Charles Dickens,George Orwell,William Shakespeare
+What is the largest ocean on Earth?,Atlantic Ocean,Indian Ocean,Arctic Ocean,Pacific Ocean,Pacific Ocean
+What is the boiling point of water at standard pressure?,100°C,0°C,50°C,212°F,100°C
+What is the main gas in Earth's atmosphere?,Oxygen,Carbon Dioxide,Nitrogen,Hydrogen,Nitrogen
+Who developed the theory of relativity?,Isaac Newton,Albert Einstein,Galileo Galilei,Stephen Hawking,Albert Einstein
+What is the smallest prime number?,0,1,2,3,2
+What is the capital of Australia?,Sydney,Melbourne,Canberra,Perth,Canberra
+What type of animal is a dolphin?,Fish,Mammal,Reptile,Amphibian,Mammal
+What is the name of Earth's natural satellite?,Mars,Venus,Moon,Titan,Moon

requirements.txt

@@ -0,0 +1 @@
+gradio