Update app.py

app.py

@@ -30,6 +30,7 @@ logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(
 # Initialize Groq client
 try:
     client = Groq(api_key=os.getenv("GROQ_API_KEY"))
+    logging.info("Groq client initialized successfully")
 except Exception as e:
     logging.error(f"Error initializing Groq client: {str(e)}")
     raise EnvironmentError("Please set the GROQ_API_KEY environment variable")
@@ -40,6 +41,7 @@ def transcribe_audio(audio):
             return ""
         
         audio_path = audio if isinstance(audio, str) else audio.name
+        logging.info(f"Transcribing audio from {audio_path}")
         
         with open(audio_path, "rb") as audio_file:
             audio_data = audio_file.read()
@@ -50,6 +52,7 @@ def transcribe_audio(audio):
             response_format="verbose_json",
         )
         
+        logging.info(f"Transcription successful: {transcription.text[:50]}...")
         return transcription.text
     except Exception as e:
         logging.error(f"Error in transcription: {str(e)}")
@@ -131,8 +134,9 @@ def generate_tutor_output(subject: str, difficulty: str, student_input: str) ->
            - Finally, provide the answer starting with "Answer:".
         3. Real-World Application: A challenging real-world application of this concept, demonstrating its practical use.
         4. Quiz: Create a short quiz (3 multiple-choice questions) to test the student's understanding.
-        Format your entire response as a JSON object with keys: "lesson", "example", "real_world_problem", "quiz".
-        Ensure that the content for each key is a single string, with line breaks where appropriate.
+        Format your entire response as a valid JSON object with ONLY these keys: "lesson", "example", "real_world_problem", "quiz".
+        Each value should be a string. DO NOT include any text outside of the JSON structure.
+        Your response should parse correctly when passed to json.loads().
         """
     else:
         prompt = f"""
@@ -145,11 +149,13 @@ def generate_tutor_output(subject: str, difficulty: str, student_input: str) ->
            - Finally, provide the answer starting with "Answer:".
         3. Real-World Application: Describe a real-world problem that can be solved using the concepts from the lesson.
         4. Quiz: Create a short quiz (3 multiple-choice questions) to test the student's understanding.
-        Format your entire response as a JSON object with keys: "lesson", "example", "real_world_problem", "quiz".
-        Ensure that the content for each key is a single string, with line breaks where appropriate.
+        Format your entire response as a valid JSON object with ONLY these keys: "lesson", "example", "real_world_problem", "quiz".
+        Each value should be a string. DO NOT include any text outside of the JSON structure.
+        Your response should parse correctly when passed to json.loads().
         """
 
     try:
+        logging.info(f"Sending request to Groq API for subject: {subject}, difficulty: {difficulty}")
         completion = client.chat.completions.create(
             messages=[
                 {
@@ -164,11 +170,59 @@ def generate_tutor_output(subject: str, difficulty: str, student_input: str) ->
             model="llama-3.3-70b-versatile",
             max_tokens=2000,
         )
-        # Parse the JSON string into a dictionary before returning
-        return json.loads(completion.choices[0].message.content)
+        
+        logging.info("Successfully received response from Groq API")
+        
+        try:
+            # Try to parse the JSON response
+            raw_content = completion.choices[0].message.content
+            logging.info(f"Raw API response preview: {raw_content[:100]}...")
+            result = json.loads(raw_content)
+            logging.info("Successfully parsed JSON response")
+            return result
+        except json.JSONDecodeError as json_err:
+            # If JSON parsing fails, log the error and return the raw content in a structured format
+            logging.error(f"JSON parsing error: {str(json_err)}")
+            raw_content = completion.choices[0].message.content
+            
+            # Try to extract content using basic string parsing if JSON fails
+            lesson_content = "The model didn't return properly formatted JSON. Here's the response:"
+            example_content = "Error processing example."
+            real_world_content = "Error processing real-world problem."
+            quiz_content = "Error processing quiz."
+            
+            # Try to extract sections using markers
+            if "Lesson:" in raw_content:
+                lesson_parts = raw_content.split("Lesson:")[1].split("Example:")[0] if "Example:" in raw_content else raw_content.split("Lesson:")[1]
+                lesson_content = "Lesson: " + lesson_parts.strip()
+            
+            if "Example:" in raw_content:
+                example_parts = raw_content.split("Example:")[1].split("Real-World Application:")[0] if "Real-World Application:" in raw_content else raw_content.split("Example:")[1]
+                example_content = "Example: " + example_parts.strip()
+                
+            if "Real-World Application:" in raw_content:
+                real_world_parts = raw_content.split("Real-World Application:")[1].split("Quiz:")[0] if "Quiz:" in raw_content else raw_content.split("Real-World Application:")[1]
+                real_world_content = "Real-World Application: " + real_world_parts.strip()
+                
+            if "Quiz:" in raw_content:
+                quiz_parts = raw_content.split("Quiz:")[1]
+                quiz_content = "Quiz: " + quiz_parts.strip()
+            
+            # Return a formatted response that won't cause downstream errors
+            return {
+                "lesson": lesson_content,
+                "example": example_content,
+                "real_world_problem": real_world_content,
+                "quiz": quiz_content
+            }
     except Exception as e:
         logging.error(f"Error generating tutor output: {str(e)}")
-        return {"error": f"Failed to generate tutor output: {str(e)}"}
+        return {
+            "lesson": f"Failed to generate lesson: {str(e)}",
+            "example": "Error: Could not generate example.",
+            "real_world_problem": "Error: Could not generate real-world problem.",
+            "quiz": "Error: Could not generate quiz."
+        }
 
 def process_output(output: Dict[str, Any]) -> Tuple[str, str, str, str]:
     try:
@@ -179,7 +233,7 @@ def process_output(output: Dict[str, Any]) -> Tuple[str, str, str, str]:
         return lesson, example, real_world, quiz
     except Exception as e:
         logging.error(f"Error processing output: {str(e)}")
-        return str(e), "", "", ""
+        return f"Error: {str(e)}", "Error processing example", "Error processing real-world problem", "Error processing quiz"
 
 def transcribe_and_display(audio):
     if not audio:
@@ -196,12 +250,14 @@ def create_interface() -> gr.Blocks:
                 subject = gr.Dropdown(
                     ["Art History", "Computer Science", "Literature", "Math", "Music", "Science", "Social Science"],
                     label="Subject",
-                    info="Choose the subject of your lesson"
+                    info="Choose the subject of your lesson",
+                    value="Math"  # Set default value
                 )
                 difficulty = gr.Radio(
                     ["Primary", "Secondary", "Higher Education"],
                     label="Difficulty Level",
-                    info="Select your proficiency level"
+                    info="Select your proficiency level",
+                    value="Secondary"  # Set default value
                 )
                 student_input = gr.Textbox(
                     placeholder="Type your topic or question here...",
@@ -244,33 +300,47 @@ def create_interface() -> gr.Blocks:
 
         def process_input(subject, difficulty, text_input, audio_input, transcribed_text_state):
             try:
-                if audio_input:
+                # Determine which input to use
+                if audio_input and transcribed_text_state:
                     student_input = transcribed_text_state
                     transcribed_output_value = transcribed_text_state
-                else:
+                    logging.info(f"Using transcribed audio input: {student_input[:50]}...")
+                elif text_input:
                     student_input = text_input
                     transcribed_output_value = ""
+                    logging.info(f"Using text input: {student_input[:50]}...")
+                else:
+                    logging.warning("No input provided")
+                    return "No input provided", "Please provide a question either by typing or speaking.", "", "", ""
                 
-                logging.info(f"Processing input: subject={subject}, difficulty={difficulty}, student_input={student_input}")
+                logging.info(f"Processing input: subject={subject}, difficulty={difficulty}")
                 
+                # Generate tutor output
                 tutor_output = generate_tutor_output(subject.lower(), difficulty, student_input)
+                
+                # Process the output
                 lesson, example, real_world, quiz = process_output(tutor_output)
+                logging.info("Successfully processed tutor output")
+                
                 return transcribed_output_value, lesson, example, real_world, quiz
             except Exception as e:
                 logging.error(f"Error in process_input: {str(e)}")
-                return str(e), "Error generating lesson", "Error generating example", "Error generating real-world problem", "Error generating quiz"
+                return str(e), f"Error generating lesson: {str(e)}", "Error generating example", "Error generating real-world problem", "Error generating quiz"
 
         def clear_outputs():
-            return "" * 5  # Empty strings for all outputs
+            return ["", "", "", "", ""]  # Five empty strings for all outputs
 
+        # Connect the audio input to the transcription function
         audio_input.upload(transcribe_and_display, audio_input, [transcription_output, transcribed_text_state])
         
+        # Connect the submit button
         submit_button.click(
             fn=process_input,
             inputs=[subject, difficulty, student_input, audio_input, transcribed_text_state],
             outputs=[transcription_output, lesson_output, example_output, real_world_output, quiz_output]
         )
 
+        # Connect the clear button
         clear_button.click(
             fn=clear_outputs,
             inputs=[],