Update app.py

app.py

@@ -1,144 +1,126 @@
 import os
 import streamlit as st
 from openai import OpenAI
-import random
-import json
-import re
+import traceback
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.DEBUG)
 
 class QuizEngine:
     def __init__(self, api_key):
-        self.client = OpenAI(
-            api_key=api_key,
-            base_url="https://api.x.ai/v1"
-        )
-        self.subject = ""
-        self.difficulty = ""
-        self.num_questions = 0
-        self.questions = []
+        try:
+            self.client = OpenAI(
+                api_key=api_key,
+                base_url="https://api.x.ai/v1"
+            )
+        except Exception as e:
+            st.error(f"Error initializing OpenAI client: {e}")
+            logging.error(f"Client initialization error: {traceback.format_exc()}")
 
-    def parse_quiz_response(self, response_text):
+    def generate_quiz(self, subject, difficulty, num_questions):
+        """
+        Simplified quiz generation with extensive error handling
         """
-        Parse the quiz response text into a structured format with enhanced debugging
+        st.write("Starting quiz generation...")
+        
+        # Simplified prompt
+        prompt = f"""
+        Create a {difficulty} level quiz about {subject} with {num_questions} multiple-choice questions.
+        
+        For each question, provide:
+        Question: [Question text]
+        A) [Option A]
+        B) [Option B]
+        C) [Option C]
+        D) [Option D]
+        Correct Answer: [A/B/C/D]
         """
-        st.write("Raw Response Text:")
-        st.code(response_text)
 
-        # Multiple parsing strategies
-        parsing_strategies = [
-            # Strategy 1: Detailed regex parsing
-            r'(\d+)\.\s*(.+?)\n+A\.\s*(.+?)\n+B\.\s*(.+?)\n+C\.\s*(.+?)\n+D\.\s*(.+?)\n+Correct\s*[Aa]nswer:\s*([ABCD])',
+        try:
+            st.write("Sending request to Grok API...")
             
-            # Strategy 2: More flexible parsing
-            r'(Question:)\s*(.+?)\n+(?:Options:)?\s*A\.\s*(.+?)\n+B\.\s*(.+?)\n+C\.\s*(.+?)\n+D\.\s*(.+?)\n+(?:Correct\s*[Aa]nswer:)?\s*([ABCD])',
-        ]
-
-        questions = []
-        for pattern in parsing_strategies:
-            matches = re.findall(pattern, response_text, re.DOTALL | re.IGNORECASE)
+            # Use a more basic API call
+            response = self.client.chat.completions.create(
+                model="grok-beta",
+                messages=[
+                    {"role": "system", "content": "You are a quiz generator."},
+                    {"role": "user", "content": prompt}
+                ],
+                max_tokens=1000  # Limit response length
+            )
             
-            if matches:
-                for match in matches:
-                    # Handling different match lengths based on regex capture groups
-                    if len(match) == 7:
-                        question = {
-                            "question": match[1].strip(),
-                            "options": [match[2].strip(), match[3].strip(), match[4].strip(), match[5].strip()],
-                            "correct_answer": match[6].strip()
-                        }
-                    elif len(match) == 6:
-                        question = {
-                            "question": match[1].strip(),
-                            "options": [match[2].strip(), match[3].strip(), match[4].strip(), match[5].strip()],
-                            "correct_answer": "A"  # Default if not specified
-                        }
-                    
-                    questions.append(question)
-                
-                break  # Stop if we find any matches
-
-        st.write("Parsed Questions:")
-        st.json(questions)
-
-        return questions
-
-    def generate_quiz(self, subject, difficulty, num_questions):
-        """
-        Generate a quiz using Grok AI with multiple prompt strategies
-        """
-        self.subject = subject
-        self.difficulty = difficulty
-        self.num_questions = num_questions
-
-        # Multiple prompt strategies
-        prompt_strategies = [
-            f"""
-            Create a {difficulty} level educational quiz about {subject}. 
-            Generate {num_questions} multiple-choice questions.
-
-            For each question, provide:
-            Question: [Question text]
-            A. [Option A]
-            B. [Option B]
-            C. [Option C]
-            D. [Option D]
-            Correct Answer: [A/B/C/D]
-
-            Ensure questions test deep understanding and are challenging.
-            """,
+            # Extract and display full response
+            full_response = response.choices[0].message.content
+            st.write("API Response:")
+            st.code(full_response)
             
-            f"""
-            Design a comprehensive {difficulty} level quiz on {subject}.
-            Create {num_questions} thought-provoking multiple-choice questions.
-
-            Format:
-            1. [Question number]
-            Question: [Detailed question text]
-            Options:
-            A. [First option]
-            B. [Second option]
-            C. [Third option]
-            D. [Fourth option]
-            Answer: [Correct option letter]
-            """,
+            return full_response
+        
+        except Exception as e:
+            st.error(f"Error generating quiz: {e}")
+            logging.error(f"Quiz generation error: {traceback.format_exc()}")
+            return None
+
+def main():
+    # Set page configuration
+    st.set_page_config(page_title="Grok Quiz Generator", page_icon="🧠")
+    
+    # Main title
+    st.title("🤖 Grok AI Quiz Generator")
+    
+    # Add debug information about environment
+    st.write("### System Diagnostics")
+    
+    try:
+        # OpenAI version check
+        import openai
+        st.write(f"OpenAI Library Version: {openai.__version__}")
+    except Exception as e:
+        st.error(f"Error checking OpenAI version: {e}")
+    
+    # Sidebar for configuration
+    st.sidebar.title("Quiz Configuration")
+    
+    # API Key input
+    api_key = st.sidebar.text_input("Enter Grok API Key", type="password")
+    
+    # Subject and difficulty selection
+    subjects = [
+        "Mathematics", "Science", "History", 
+        "Computer Science", "Literature", "Geography"
+    ]
+    subject = st.sidebar.selectbox("Select Subject", subjects)
+    
+    difficulties = ["Easy", "Medium", "Hard"]
+    difficulty = st.sidebar.selectbox("Select Difficulty", difficulties)
+    
+    # Number of questions
+    num_questions = st.sidebar.slider("Number of Questions", 3, 10, 5)
+    
+    # Generate Quiz Button
+    if st.sidebar.button("Generate Quiz"):
+        # Validate API Key
+        if not api_key:
+            st.error("Please enter your Grok API Key")
+            return
+        
+        try:
+            # Initialize Quiz Engine
+            quiz_engine = QuizEngine(api_key)
             
-            f"""
-            Develop an educational quiz covering {subject} at {difficulty} level.
-            Number of questions: {num_questions}
-
-            Quiz Structure:
-            - Varied, challenging questions
-            - 4 multiple-choice options per question
-            - Clear indication of correct answer
-            - Focus on comprehensive understanding
-            """
-        ]
-
-        # Try different prompt strategies
-        for prompt in prompt_strategies:
-            try:
-                response = self.client.chat.completions.create(
-                    model="grok-beta",
-                    messages=[
-                        {"role": "system", "content": "You are an expert educational quiz generator."},
-                        {"role": "user", "content": prompt}
-                    ]
-                )
-
-                # Extract response text
-                response_text = response.choices[0].message.content
-                
-                # Parse the response
-                self.questions = self.parse_quiz_response(response_text)
-                
-                if self.questions:
-                    return self.questions
-                
-            except Exception as e:
-                st.error(f"Error with prompt strategy: {e}")
-
-        st.error("Could not generate quiz with any prompt strategy.")
-        return []
-
-    # ... [Rest of the code remains the same as in the previous version]
-
-# The main() function and other parts of the code remain unchanged
+            # Generate Quiz
+            quiz_content = quiz_engine.generate_quiz(subject, difficulty, num_questions)
+            
+            if quiz_content:
+                st.write("### Generated Quiz")
+                st.text_area("Quiz Content", quiz_content, height=300)
+            else:
+                st.error("Failed to generate quiz. Check the error messages above.")
+        
+        except Exception as e:
+            st.error(f"Unexpected error: {e}")
+            logging.error(f"Unexpected error: {traceback.format_exc()}")
+
+if __name__ == "__main__":
+    main()