Update app.py

app.py

@@ -1,186 +1,479 @@
 """
-Minimal Gradio interface for a simple AI assistant without smolagents
+GAIA Test Application for Hugging Face Agents Course Certification
 
-This is a standalone version that uses only Hugging Face Inference API directly.
-It creates a simple Gradio interface for text generation.
+This application provides a simulated GAIA benchmark test environment with 20 questions
+from Level 1 of the GAIA benchmark. It allows users to practice for the certification
+test and automatically calculates their score.
 """
 
 import os
-import sys
 import json
-import requests
 import gradio as gr
+import requests
+from typing import List, Dict, Any, Tuple
 
-# Check if running in Hugging Face Spaces
-IS_HF_SPACES = os.environ.get("SPACE_ID") is not None
+# Sample GAIA Level 1 questions (20 questions for certification practice)
+GAIA_SAMPLE_QUESTIONS = [
+    {
+        "id": "gaia_l1_001",
+        "question": "What is the capital city of Japan?",
+        "answer": "Tokyo",
+        "category": "factual",
+        "difficulty": "easy"
+    },
+    {
+        "id": "gaia_l1_002",
+        "question": "Calculate the area of a circle with radius 5 cm. Express your answer in square centimeters with one decimal place.",
+        "answer": "78.5",
+        "category": "mathematical",
+        "difficulty": "easy"
+    },
+    {
+        "id": "gaia_l1_003",
+        "question": "Who wrote the novel '1984'?",
+        "answer": "George Orwell",
+        "category": "factual",
+        "difficulty": "easy"
+    },
+    {
+        "id": "gaia_l1_004",
+        "question": "What is the chemical symbol for gold?",
+        "answer": "Au",
+        "category": "factual",
+        "difficulty": "easy"
+    },
+    {
+        "id": "gaia_l1_005",
+        "question": "If a train travels at 60 miles per hour, how far will it travel in 2.5 hours?",
+        "answer": "150 miles",
+        "category": "mathematical",
+        "difficulty": "easy"
+    },
+    {
+        "id": "gaia_l1_006",
+        "question": "What is the largest planet in our solar system?",
+        "answer": "Jupiter",
+        "category": "factual",
+        "difficulty": "easy"
+    },
+    {
+        "id": "gaia_l1_007",
+        "question": "Calculate 15% of 240.",
+        "answer": "36",
+        "category": "mathematical",
+        "difficulty": "easy"
+    },
+    {
+        "id": "gaia_l1_008",
+        "question": "Who painted the Mona Lisa?",
+        "answer": "Leonardo da Vinci",
+        "category": "factual",
+        "difficulty": "easy"
+    },
+    {
+        "id": "gaia_l1_009",
+        "question": "What is the boiling point of water in degrees Celsius at standard atmospheric pressure?",
+        "answer": "100",
+        "category": "factual",
+        "difficulty": "easy"
+    },
+    {
+        "id": "gaia_l1_010",
+        "question": "If x + 3 = 8, what is the value of x?",
+        "answer": "5",
+        "category": "mathematical",
+        "difficulty": "easy"
+    },
+    {
+        "id": "gaia_l1_011",
+        "question": "What is the main ingredient in guacamole?",
+        "answer": "Avocado",
+        "category": "factual",
+        "difficulty": "medium"
+    },
+    {
+        "id": "gaia_l1_012",
+        "question": "If a rectangle has a length of 12 cm and a width of 8 cm, what is its perimeter?",
+        "answer": "40 cm",
+        "category": "mathematical",
+        "difficulty": "medium"
+    },
+    {
+        "id": "gaia_l1_013",
+        "question": "Who was the first person to walk on the moon?",
+        "answer": "Neil Armstrong",
+        "category": "factual",
+        "difficulty": "medium"
+    },
+    {
+        "id": "gaia_l1_014",
+        "question": "What is the square root of 144?",
+        "answer": "12",
+        "category": "mathematical",
+        "difficulty": "medium"
+    },
+    {
+        "id": "gaia_l1_015",
+        "question": "Which element has the chemical symbol 'O'?",
+        "answer": "Oxygen",
+        "category": "factual",
+        "difficulty": "medium"
+    },
+    {
+        "id": "gaia_l1_016",
+        "question": "A store is having a 30% off sale. If an item originally costs $85, what is the sale price?",
+        "answer": "$59.50",
+        "category": "mathematical",
+        "difficulty": "medium"
+    },
+    {
+        "id": "gaia_l1_017",
+        "question": "What is the largest ocean on Earth?",
+        "answer": "Pacific Ocean",
+        "category": "factual",
+        "difficulty": "medium"
+    },
+    {
+        "id": "gaia_l1_018",
+        "question": "If 3x - 7 = 14, what is the value of x?",
+        "answer": "7",
+        "category": "mathematical",
+        "difficulty": "medium"
+    },
+    {
+        "id": "gaia_l1_019",
+        "question": "Who wrote 'Romeo and Juliet'?",
+        "answer": "William Shakespeare",
+        "category": "factual",
+        "difficulty": "medium"
+    },
+    {
+        "id": "gaia_l1_020",
+        "question": "What is the capital of Australia?",
+        "answer": "Canberra",
+        "category": "factual",
+        "difficulty": "medium"
+    }
+]
 
-class MinimalAIAssistant:
+class GAIATestSimulator:
     """
-    Minimal AI Assistant using Hugging Face Inference API directly
+    Simulates the GAIA benchmark test for certification practice
     """
-    def __init__(self, api_key=None, model_id="mistralai/Mixtral-8x7B-Instruct-v0.1"):
+    def __init__(self, questions: List[Dict[str, Any]] = None):
         """
-        Initialize the minimal AI assistant
+        Initialize the GAIA test simulator
         
         Args:
-            api_key: Hugging Face API key
-            model_id: Model ID to use
+            questions: List of question dictionaries (optional)
         """
-        self.api_key = api_key or os.environ.get("HF_API_KEY", "")
-        self.model_id = model_id
-        self.api_url = f"https://api-inference.huggingface.co/models/{model_id}"
-        self.headers = {"Authorization": f"Bearer {self.api_key}"}
-        
-        # System prompt
-        self.system_prompt = """
-You are an advanced AI assistant designed to help with various tasks.
-You can answer questions, provide information, and assist with problem-solving.
-Always be helpful, accurate, and concise in your responses.
-"""
-
-    def query(self, prompt):
+        self.questions = questions or GAIA_SAMPLE_QUESTIONS
+        self.user_answers = {}
+        self.current_question_idx = 0
+        self.total_questions = len(self.questions)
+        self.results = None
+    
+    def get_current_question(self) -> Dict[str, Any]:
         """
-        Query the model with a prompt
+        Get the current question
+        
+        Returns:
+            Current question dictionary
+        """
+        if self.current_question_idx < self.total_questions:
+            return self.questions[self.current_question_idx]
+        return None
+    
+    def submit_answer(self, answer: str) -> Tuple[str, int, int]:
+        """
+        Submit an answer for the current question
         
         Args:
-            prompt: User prompt
+            answer: User's answer
             
         Returns:
-            Model response
+            Tuple of (status message, current question index, total questions)
         """
-        try:
-            # Format the prompt with system message
-            formatted_prompt = f"{self.system_prompt}\n\nUser: {prompt}\n\nAssistant:"
-            
-            # Prepare the payload
-            payload = {
-                "inputs": formatted_prompt,
-                "parameters": {
-                    "max_new_tokens": 1024,
-                    "temperature": 0.7,
-                    "top_p": 0.95,
-                    "do_sample": True
-                }
+        if self.current_question_idx >= self.total_questions:
+            return "All questions have been answered.", self.current_question_idx, self.total_questions
+        
+        current_question = self.questions[self.current_question_idx]
+        self.user_answers[current_question["id"]] = answer
+        self.current_question_idx += 1
+        
+        if self.current_question_idx < self.total_questions:
+            next_question = self.questions[self.current_question_idx]
+            return f"Answer submitted. Moving to question {self.current_question_idx + 1}/{self.total_questions}.", self.current_question_idx, self.total_questions
+        else:
+            return "All questions have been answered. You can now calculate your score.", self.current_question_idx, self.total_questions
+    
+    def calculate_score(self) -> Dict[str, Any]:
+        """
+        Calculate the score based on submitted answers
+        
+        Returns:
+            Dictionary with score results
+        """
+        if not self.user_answers:
+            return {
+                "status": "error",
+                "message": "No answers have been submitted yet."
             }
-            
-            # Make the API request
-            response = requests.post(self.api_url, headers=self.headers, json=payload)
-            
-            # Check for errors
-            if response.status_code != 200:
-                return f"Error: API returned status code {response.status_code}. {response.text}"
-            
-            # Parse the response
-            result = response.json()
-            
-            # Extract the generated text
-            if isinstance(result, list) and len(result) > 0:
-                generated_text = result[0].get("generated_text", "")
-                # Remove the prompt from the response
-                if generated_text.startswith(formatted_prompt):
-                    generated_text = generated_text[len(formatted_prompt):].strip()
-                return generated_text
-            else:
-                return "Error: Unexpected response format from API"
         
-        except Exception as e:
-            return f"Error querying model: {str(e)}"
+        correct_answers = 0
+        results = []
+        
+        for question in self.questions:
+            question_id = question["id"]
+            if question_id in self.user_answers:
+                user_answer = self.user_answers[question_id].strip()
+                correct_answer = question["answer"].strip()
+                
+                # Simple string matching (case-insensitive)
+                is_correct = user_answer.lower() == correct_answer.lower()
+                
+                results.append({
+                    "question_id": question_id,
+                    "question": question["question"],
+                    "user_answer": user_answer,
+                    "correct_answer": correct_answer,
+                    "is_correct": is_correct
+                })
+                
+                if is_correct:
+                    correct_answers += 1
+        
+        answered_questions = len(self.user_answers)
+        score_percentage = (correct_answers / self.total_questions) * 100
+        passed = score_percentage >= 30
+        
+        self.results = {
+            "status": "success",
+            "total_questions": self.total_questions,
+            "answered_questions": answered_questions,
+            "correct_answers": correct_answers,
+            "score_percentage": score_percentage,
+            "passed": passed,
+            "results": results
+        }
+        
+        return self.results
+    
+    def reset_test(self) -> str:
+        """
+        Reset the test to start over
+        
+        Returns:
+            Status message
+        """
+        self.user_answers = {}
+        self.current_question_idx = 0
+        self.results = None
+        return "Test has been reset. You can start again."
 
 
-def create_gradio_interface():
+def create_gaia_test_interface():
     """
-    Create a Gradio interface for the minimal AI assistant
+    Create a Gradio interface for the GAIA test simulator
     
     Returns:
         Gradio interface
     """
-    # Initialize the assistant
-    assistant = MinimalAIAssistant()
+    # Initialize the simulator
+    simulator = GAIATestSimulator()
     
-    def process_query(query, api_key=""):
-        """
-        Process a user query
+    def get_question_text():
+        """Get the current question text"""
+        question = simulator.get_current_question()
+        if question:
+            return f"Question {simulator.current_question_idx + 1}/{simulator.total_questions}: {question['question']}"
+        return "All questions have been answered. You can now calculate your score."
+    
+    def submit_answer(answer):
+        """Submit an answer and get the next question"""
+        message, current_idx, total = simulator.submit_answer(answer)
         
-        Args:
-            query: User query
-            api_key: Hugging Face API key (optional)
-            
-        Returns:
-            Assistant's response
-        """
-        # Update API key if provided
-        if api_key:
-            assistant.api_key = api_key
-            assistant.headers = {"Authorization": f"Bearer {api_key}"}
+        # Get the next question if available
+        next_question = ""
+        if current_idx < total:
+            question = simulator.get_current_question()
+            next_question = f"Question {current_idx + 1}/{total}: {question['question']}"
+        else:
+            next_question = "All questions have been answered. You can now calculate your score."
+        
+        return message, next_question, ""  # Clear the answer input
+    
+    def calculate_score():
+        """Calculate and display the score"""
+        results = simulator.calculate_score()
+        
+        if results["status"] == "error":
+            return results["message"]
+        
+        score_message = f"""
+## GAIA Test Results
+
+- **Total Questions**: {results['total_questions']}
+- **Answered Questions**: {results['answered_questions']}
+- **Correct Answers**: {results['correct_answers']}
+- **Score**: {results['score_percentage']:.1f}%
+- **Certification Status**: {"PASSED ✅" if results['passed'] else "FAILED ❌"}
+
+{"🎉 Congratulations! You have passed the GAIA certification practice test. You can now take the official test to get your certificate." if results['passed'] else "You did not pass the certification threshold (30%). Please review your answers and try again."}
+
+### Detailed Results:
+
+| Question | Your Answer | Correct Answer | Result |
+|----------|-------------|----------------|--------|
+"""
         
-        # Check if API key is set
-        if not assistant.api_key:
-            return "Error: No API key provided. Please enter your Hugging Face API key."
+        for result in results["results"]:
+            score_message += f"| {result['question']} | {result['user_answer']} | {result['correct_answer']} | {'✓' if result['is_correct'] else '✗'} |\n"
         
-        # Process the query
-        return assistant.query(query)
+        return score_message
+    
+    def reset_test():
+        """Reset the test"""
+        message = simulator.reset_test()
+        question = simulator.get_current_question()
+        question_text = f"Question 1/{simulator.total_questions}: {question['question']}"
+        return message, question_text, ""
     
     # Create the interface
-    with gr.Blocks(title="Minimal AI Assistant") as interface:
-        gr.Markdown("# Minimal AI Assistant")
+    with gr.Blocks(title="GAIA Certification Practice Test") as interface:
+        gr.Markdown("# GAIA Certification Practice Test")
         gr.Markdown("""
-        This is a minimal AI assistant using the Hugging Face Inference API.
-        Enter your query below and the assistant will respond.
-        """)
+        This application simulates the GAIA benchmark test for Hugging Face Agents Course certification.
         
-        api_key_input = gr.Textbox(
-            label="Hugging Face API Key",
-            placeholder="Enter your Hugging Face API key here...",
-            type="password"
-        )
+        - The test consists of 20 questions from Level 1 of the GAIA benchmark
+        - You need to score at least 30% (6 correct answers) to pass
+        - Answer each question and submit to move to the next one
+        - After answering all questions, calculate your score to see if you passed
         
-        query_input = gr.Textbox(
-            label="Your Query",
-            placeholder="Enter your query here...",
-            lines=3
-        )
+        Good luck!
+        """)
         
-        submit_button = gr.Button("Submit")
+        with gr.Row():
+            with gr.Column():
+                question_text = gr.Textbox(
+                    label="Current Question",
+                    value=get_question_text(),
+                    lines=3,
+                    interactive=False
+                )
+                
+                answer_input = gr.Textbox(
+                    label="Your Answer",
+                    placeholder="Type your answer here...",
+                    lines=2
+                )
+                
+                submit_button = gr.Button("Submit Answer")
+                
+                status_text = gr.Textbox(
+                    label="Status",
+                    value="",
+                    lines=1,
+                    interactive=False
+                )
         
-        response_output = gr.Textbox(
-            label="Assistant Response",
-            lines=15
-        )
+        with gr.Row():
+            calculate_button = gr.Button("Calculate Score")
+            reset_button = gr.Button("Reset Test")
         
-        # Sample queries
-        gr.Markdown("### Sample Queries")
-        sample_queries = [
-            "What is the capital of France?",
-            "Explain the concept of machine learning in simple terms.",
-            "Write a short poem about artificial intelligence."
-        ]
-        
-        for query in sample_queries:
-            sample_button = gr.Button(f"Try: {query}")
-            sample_button.click(
-                fn=lambda q=query: q,
-                outputs=query_input
-            )
+        score_output = gr.Markdown(label="Results")
         
         # Set up event handlers
         submit_button.click(
-            fn=process_query,
-            inputs=[query_input, api_key_input],
-            outputs=response_output
+            fn=submit_answer,
+            inputs=[answer_input],
+            outputs=[status_text, question_text, answer_input]
         )
         
-        # Add examples
-        gr.Examples(
-            examples=sample_queries,
-            inputs=query_input
+        calculate_button.click(
+            fn=calculate_score,
+            inputs=[],
+            outputs=[score_output]
         )
+        
+        reset_button.click(
+            fn=reset_test,
+            inputs=[],
+            outputs=[status_text, question_text, answer_input]
+        )
+    
+    return interface
+
+
+def create_certification_guide_interface():
+    """
+    Create a Gradio interface for the certification guide
+    
+    Returns:
+        Gradio interface
+    """
+    def get_certification_instructions():
+        """Get the certification instructions"""
+        return """
+# How to Get Your Hugging Face Agents Course Certificate
+
+After practicing with this simulator and achieving at least 30% correct answers, follow these steps to get your official certificate:
+
+## Step 1: Complete the Required Course Units
+- Complete Unit 1 (Introduction to Agents)
+- Complete at least one use case from Unit 3
+- Complete the final project in Unit 4
+
+## Step 2: Take the Official GAIA Test
+1. Visit the [GAIA test page](https://huggingface.co/learn/agents-course/en/unit4/the-final-hands-on) on the Hugging Face Agents Course website
+2. Sign in with your Hugging Face account
+3. Follow the instructions to take the test
+4. Answer the 20 questions to the best of your ability
+5. Submit your answers
+
+## Step 3: Claim Your Certificate
+If you scored above 30% on the official test:
+1. Visit the [certificate page](https://huggingface.co/learn/agents-course/en/unit4/get-your-certificate)
+2. Sign in with your Hugging Face account
+3. Enter your full name (this will appear on your certificate)
+4. Click "Get My Certificate" to download your certificate
+
+## Step 4: Share Your Achievement
+- Add your certificate to your LinkedIn profile
+- Share it on social media (tag @huggingface)
+- Add it to your resume or portfolio
+
+Congratulations on completing the Hugging Face Agents Course!
+"""
+    
+    with gr.Blocks(title="GAIA Certification Guide") as interface:
+        gr.Markdown(get_certification_instructions())
+    
+    return interface
+
+
+def create_main_interface():
+    """
+    Create the main application interface with tabs
+    
+    Returns:
+        Gradio interface
+    """
+    with gr.Blocks(title="GAIA Certification Practice") as interface:
+        gr.Markdown("# GAIA Certification Practice for Hugging Face Agents Course")
+        
+        with gr.Tabs():
+            with gr.TabItem("Practice Test"):
+                test_interface = create_gaia_test_interface()
+            
+            with gr.TabItem("Certification Guide"):
+                guide_interface = create_certification_guide_interface()
     
     return interface
 
 
-# Create and launch the interface
-interface = create_gradio_interface()
+# Create and launch the application
+app = create_main_interface()
 
-# For Hugging Face Spaces
 if __name__ == "__main__":
-    interface.launch()
+    app.launch()