Update app.py

app.py

@@ -10,9 +10,9 @@ from typing import Dict, Any, Tuple
 from dotenv import load_dotenv
 import markdown2
 
-# Set up more detailed logging
+# Set up detailed logging
 logging.basicConfig(
-    level=logging.DEBUG,  # Changed to DEBUG for more verbose output
+    level=logging.DEBUG,
     format='%(asctime)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s',
     handlers=[
         logging.StreamHandler(sys.stdout),
@@ -27,7 +27,7 @@ logging.debug("Environment variables loaded")
 # Print environment check
 logging.debug(f"GROQ_API_KEY present: {bool(os.getenv('GROQ_API_KEY'))}")
 
-# Initialize Groq client with extensive error handling
+# Initialize Groq client with error handling
 try:
     api_key = os.getenv("GROQ_API_KEY")
     if not api_key:
@@ -57,20 +57,16 @@ def transcribe_audio(audio):
         
         logging.debug(f"Audio input received: {type(audio)} - {audio}")
         
-        # Check if audio is a path string or a file object
         audio_path = audio if isinstance(audio, str) else audio
-        
         logging.debug(f"Audio path: {audio_path}")
         logging.debug(f"File exists: {os.path.exists(audio_path) if audio_path else False}")
         
-        # Handle audio file properly based on gradio's audio component output
         if audio_path and os.path.exists(audio_path):
             with open(audio_path, "rb") as audio_file:
                 audio_data = audio_file.read()
                 
             logging.debug(f"Audio file opened, size: {len(audio_data)} bytes")
             
-            # Use the correct API endpoint and parameters for Groq's audio transcription
             try:
                 logging.debug("Sending audio to Groq API for transcription")
                 transcription = client.audio.transcriptions.create(
@@ -80,26 +76,22 @@ def transcribe_audio(audio):
                 
                 logging.debug(f"Transcription response received: {transcription}")
                 
-                # Check the structure of the response
                 if hasattr(transcription, 'text'):
                     result = transcription.text
                     logging.debug(f"Transcription text: {result}")
                     return result
                 else:
-                    # Handle different response structure
                     result = transcription.get('text', "Transcription succeeded but returned no text")
                     logging.debug(f"Transcription text (alt format): {result}")
                     return result
             except Exception as e:
                 logging.error(f"Audio transcription API error: {str(e)}")
-                logging.error(traceback.format_exc())
                 return f"Audio transcription failed: {str(e)}"
         else:
             logging.warning(f"Audio file not found at path: {audio_path}")
             return "Audio file not found. Please try recording again."
     except Exception as e:
         logging.error(f"Error in transcription: {str(e)}")
-        logging.error(traceback.format_exc())
         return f"Error in transcription: {str(e)}"
 
 def generate_tutor_output(subject: str, difficulty: str, student_input: str) -> Dict[str, str]:
@@ -124,13 +116,9 @@ def generate_tutor_output(subject: str, difficulty: str, student_input: str) ->
                 "dna replication": "the process of DNA replication and its importance in cell division",
                 "climate change": "the causes and effects of climate change, including global warming and its impact on ecosystems"
             },
-            # Add more subjects and topics as needed
         }
         
-        # Normalize subject to lowercase for matching
         subject_lower = subject.lower() if subject else "general"
-        
-        # Check if it's a specific topic and create an enhanced prompt
         enhanced_topic = None
         for subj, subject_topics in topics.items():
             for topic, description in subject_topics.items():
@@ -141,7 +129,6 @@ def generate_tutor_output(subject: str, difficulty: str, student_input: str) ->
             if enhanced_topic:
                 break
         
-        # Create the prompt based on whether it's a specific topic or not
         if enhanced_topic:
             logging.debug(f"Using enhanced topic: {enhanced_topic}")
             prompt = f"""
@@ -173,120 +160,84 @@ def generate_tutor_output(subject: str, difficulty: str, student_input: str) ->
             Ensure that the content for each key is a single string, with line breaks where appropriate.
             """
         
-        # Validate API models
-        try:
-            models = client.models.list()
-            model_ids = [m.id for m in models.data]
-            logging.debug(f"Available models: {model_ids}")
-            
-            # Check if our target model is available
-            target_model = "llama-3.3-70b-versatile"
-            if target_model not in model_ids:
-                logging.warning(f"Model {target_model} not found. Using fallback model.")
-                # Use a fallback model if the target model is not available
-                target_model = model_ids[0] if model_ids else "llama-3.3-70b-versatile"
-                logging.debug(f"Using fallback model: {target_model}")
-        except Exception as e:
-            logging.error(f"Error checking models: {e}")
-            target_model = "llama-3.3-70b-versatile"
-        
+        target_model = "llama-3.3-70b-versatile"
         logging.debug(f"Sending prompt to model: {target_model}")
         
-        # Make API call to Groq
-        try:
-            completion = client.chat.completions.create(
-                messages=[
-                    {
-                        "role": "system",
-                        "content": f"You are the world's best AI tutor, renowned for your ability to explain complex concepts in an engaging, clear, and memorable way. Your expertise in {subject_lower} is unparalleled, and you're adept at tailoring your teaching to {difficulty} level students. Your goal is to not just impart knowledge, but to inspire a love for learning and critical thinking.",
-                    },
-                    {
-                        "role": "user",
-                        "content": prompt,
-                    }
-                ],
-                model=target_model,
-                max_tokens=2000,
-            )
-            
-            # Handle the response parsing more robustly
-            response_content = completion.choices[0].message.content
-            logging.debug(f"Received response: {response_content[:100]}...")  # Log first 100 chars
-            
-            # Try to parse the JSON directly
-            try:
-                result = json.loads(response_content)
-                logging.debug("Successfully parsed JSON response")
-                return result
-            except json.JSONDecodeError as e:
-                logging.warning(f"Failed to parse JSON response: {e}")
-                
-                # Try to extract JSON-like structure
-                json_match = re.search(r'\{[\s\S]*\}', response_content)
-                if json_match:
-                    try:
-                        result = json.loads(json_match.group(0))
-                        logging.debug("Successfully extracted and parsed JSON from response")
-                        return result
-                    except json.JSONDecodeError as e2:
-                        logging.warning(f"Failed to parse extracted JSON: {e2}")
-                
-                # If JSON parsing fails, create a structured response
-                logging.debug("Creating structured response from plain text")
-                sections = {
-                    "lesson": "",
-                    "example": "",
-                    "real_world_problem": "",
-                    "quiz": ""
+        completion = client.chat.completions.create(
+            messages=[
+                {
+                    "role": "system",
+                    "content": f"You are the world's best AI tutor, renowned for your ability to explain complex concepts in an engaging, clear, and memorable way. Your expertise in {subject_lower} is unparalleled, and you're adept at tailoring your teaching to {difficulty} level students. Your goal is to not just impart knowledge, but to inspire a love for learning and critical thinking.",
+                },
+                {
+                    "role": "user",
+                    "content": prompt,
                 }
-                
-                # Try to extract sections based on headers
-                current_section = None
-                lines = response_content.split('\n')
-                for line in lines:
-                    line = line.strip()
-                    if "Lesson:" in line or line.startswith("1."):
-                        current_section = "lesson"
-                        sections[current_section] += line.replace("Lesson:", "").replace("1.", "").strip() + "\n"
-                    elif "Example:" in line or line.startswith("2."):
-                        current_section = "example"
-                        sections[current_section] += line.replace("Example:", "").replace("2.", "").strip() + "\n"
-                    elif "Real-World Application:" in line or "Real-World Problem:" in line or line.startswith("3."):
-                        current_section = "real_world_problem"
-                        sections[current_section] += line.replace("Real-World Application:", "").replace("Real-World Problem:", "").replace("3.", "").strip() + "\n"
-                    elif "Quiz:" in line or line.startswith("4."):
-                        current_section = "quiz"
-                        sections[current_section] += line.replace("Quiz:", "").replace("4.", "").strip() + "\n"
-                    elif current_section:
-                        sections[current_section] += line + "\n"
-                
-                return sections
-                
-        except Exception as e:
-            logging.error(f"Error calling Groq API: {str(e)}")
-            logging.error(traceback.format_exc())
-            return {"error": f"Failed to generate tutor output: {str(e)}"}
-            
+            ],
+            model=target_model,
+            max_tokens=2000,
+        )
+        
+        response_content = completion.choices[0].message.content
+        logging.debug(f"Received response: {response_content[:100]}...")
+        
+        try:
+            result = json.loads(response_content)
+            logging.debug("Successfully parsed JSON response")
+        except json.JSONDecodeError:
+            logging.warning("Failed to parse JSON, using fallback parsing")
+            sections = {
+                "lesson": "No lesson generated due to parsing error",
+                "example": "No example generated due to parsing error",
+                "real_world_problem": "No real-world application generated due to parsing error",
+                "quiz": "No quiz generated due to parsing error"
+            }
+            lines = response_content.split('\n')
+            current_section = None
+            for line in lines:
+                line = line.strip()
+                if "Lesson:" in line or line.startswith("1."):
+                    current_section = "lesson"
+                    sections[current_section] = line.replace("Lesson:", "").replace("1.", "").strip() + "\n"
+                elif "Example:" in line or line.startswith("2."):
+                    current_section = "example"
+                    sections[current_section] = line.replace("Example:", "").replace("2.", "").strip() + "\n"
+                elif "Real-World Application:" in line or line.startswith("3."):
+                    current_section = "real_world_problem"
+                    sections[current_section] = line.replace("Real-World Application:", "").replace("3.", "").strip() + "\n"
+                elif "Quiz:" in line or line.startswith("4."):
+                    current_section = "quiz"
+                    sections[current_section] = line.replace("Quiz:", "").replace("4.", "").strip() + "\n"
+                elif current_section:
+                    sections[current_section] += line + "\n"
+            result = sections
+        
+        # Ensure all keys are present
+        for key in ["lesson", "example", "real_world_problem", "quiz"]:
+            if key not in result:
+                result[key] = f"No {key.replace('_', ' ')} provided"
+        
+        return result
+    
     except Exception as e:
         logging.error(f"Error in generate_tutor_output: {str(e)}")
         logging.error(traceback.format_exc())
-        return {"error": f"Failed to generate tutor output: {str(e)}"}
+        return {
+            "lesson": f"Error: {str(e)}",
+            "example": "",
+            "real_world_problem": "",
+            "quiz": ""
+        }
 
 def process_output(output: Dict[str, Any]) -> Tuple[str, str, str, str]:
     """Process the output from generate_tutor_output into HTML format."""
     try:
         logging.debug(f"Processing output: {str(output)[:100]}...")
         
-        if "error" in output:
-            error_msg = output.get("error", "Unknown error occurred")
-            logging.error(f"Error message in output: {error_msg}")
-            return error_msg, "", "", ""
-        
-        # Use markdown2 to convert markdown to HTML, with fallbacks for missing content
-        lesson = markdown2.markdown(str(output.get("lesson", "No lesson available")))
-        example = markdown2.markdown(str(output.get("example", "No example available")))
-        real_world = markdown2.markdown(str(output.get("real_world_problem", "No real-world problem available")))
-        quiz = markdown2.markdown(str(output.get("quiz", "No quiz available")))
+        lesson = markdown2.markdown(output.get("lesson", "No lesson available"))
+        example = markdown2.markdown(output.get("example", "No example available"))
+        real_world = markdown2.markdown(output.get("real_world_problem", "No real-world application available"))
+        quiz = markdown2.markdown(output.get("quiz", "No quiz available"))
         
         logging.debug("Output processed successfully")
         return lesson, example, real_world, quiz
@@ -302,7 +253,6 @@ def create_interface() -> gr.Blocks:
     with gr.Blocks(theme=gr.themes.Soft()) as demo:
         gr.Markdown("# 🎓 Vers3Dynamics Tutor: Your Personal Learning Companion")
         
-        # Create a state variable to track submission
         state = gr.State({"is_submitting": False})
         
         with gr.Row():
@@ -311,32 +261,30 @@ def create_interface() -> gr.Blocks:
                     ["Art History", "Computer Science", "Literature", "Math", "Music", "Science", "Social Science"],
                     label="Subject",
                     info="Choose the subject of your lesson",
-                    value="Math"  # Set a default value
+                    value="Math"
                 )
                 difficulty = gr.Radio(
                     ["Primary", "Secondary", "Higher Education"],
                     label="Difficulty Level",
                     info="Select your proficiency level",
-                    value="Secondary"  # Set a default value
+                    value="Secondary"
                 )
                 student_input = gr.Textbox(
                     placeholder="Type your topic or question here...",
                     label="Type Your Question",
                     info="Enter the topic you want to explore"
                 )
-                # Updated audio input configuration
                 audio_input = gr.Audio(
-                    type="filepath", 
+                    type="filepath",
                     label="Speak Your Question",
                     sources=["microphone"],
-                    format="wav"  # Explicitly specify format
+                    format="wav"
                 )
                 
                 with gr.Row():
                     submit_button = gr.Button("📚 Teach Me", variant="primary")
                     clear_button = gr.Button("🧹 Clear", variant="secondary")
                     
-                # Add a status indicator
                 status_indicator = gr.Textbox(
                     label="Status",
                     value="Ready",
@@ -374,131 +322,87 @@ def create_interface() -> gr.Blocks:
         def process_input(subject, difficulty, text_input, audio_input, state):
             """Process input from text or audio."""
             try:
-                # Update state to indicate submission is in progress
-                state = {"is_submitting": True}
-                
-                # Update status
-                yield state, "Processing your request...", transcription_output.value, lesson_output.value, example_output.value, real_world_output.value, quiz_output.value
-                
-                # Add debug logging
                 logging.info(f"Received inputs - subject: {subject}, difficulty: {difficulty}")
-                logging.info(f"Text input: '{text_input}', Audio input type: {type(audio_input)}")
+                logging.info(f"Text input: '{text_input}', Audio input: {audio_input}")
                 
-                # Check for subject
-                if not subject:
-                    logging.warning("No subject provided, defaulting to Math")
-                    subject = "Math"
+                subject = subject or "Math"
+                difficulty = difficulty or "Secondary"
                 
-                # Check for difficulty
-                if not difficulty:
-                    logging.warning("No difficulty provided, defaulting to Secondary")
-                    difficulty = "Secondary"
-                
-                # Check if any input is provided
-                if (not text_input or text_input.strip() == "") and not audio_input:
-                    logging.warning("No input provided")
-                    yield (
+                if not text_input.strip() and not audio_input:
+                    return (
                         {"is_submitting": False},
                         "Ready",
-                        "No input provided. Please type a question or record audio.",
-                        "Please provide a question to begin.",
+                        "No input provided",
+                        "Please provide a question to begin",
                         "",
                         "",
                         ""
                     )
-                    return
-                
-                # Update status
-                yield state, "Processing input...", transcription_output.value, lesson_output.value, example_output.value, real_world_output.value, quiz_output.value
                 
-                # Prioritize text input if available
-                if text_input and text_input.strip():
+                if text_input.strip():
                     student_input = text_input.strip()
-                    transcribed_text = "Using text input instead of audio."
-                    logging.info(f"Using text input: {student_input}")
+                    transcribed_text = "Using text input"
                 elif audio_input:
-                    # Update status
-                    yield state, "Transcribing audio...", "Transcribing your audio...", lesson_output.value, example_output.value, real_world_output.value, quiz_output.value
-                    
                     transcribed_text = transcribe_audio(audio_input)
                     student_input = transcribed_text
-                    logging.info(f"Using transcribed audio: {student_input}")
-                    
-                    # Check if transcription was successful
-                    if not student_input or "error" in student_input.lower():
-                        yield (
+                    if "error" in transcribed_text.lower():
+                        return (
                             {"is_submitting": False},
                             "Ready",
                             transcribed_text,
-                            "Transcription error. Please try typing your question instead.",
+                            "Transcription error. Please try typing your question.",
                             "",
                             "",
                             ""
                         )
-                        return
                 else:
-                    # This should not happen given the check above, but just to be safe
-                    logging.warning("No valid input detected")
-                    yield (
+                    return (
                         {"is_submitting": False},
                         "Ready",
-                        "No valid input detected. Please try again.",
-                        "Please provide a question.",
+                        "No valid input",
+                        "Please provide a question",
                         "",
                         "",
                         ""
                     )
-                    return
-                
-                # Update status
-                yield state, "Generating educational content...", transcribed_text, "Generating lesson...", "Preparing examples...", "Finding applications...", "Creating quiz..."
                 
-                # Generate tutor output - use lowercase for subject
                 tutor_output = generate_tutor_output(subject, difficulty, student_input)
-                logging.info("Successfully generated tutor output")
-                
-                if "error" in tutor_output:
-                    error_msg = tutor_output.get("error", "Unknown error occurred")
-                    yield (
-                        {"is_submitting": False},
-                        "Ready",
-                        transcribed_text,
-                        f"Error: {error_msg}",
-                        "",
-                        "",
-                        ""
-                    )
-                    return
-                
-                # Update status
-                yield state, "Formatting results...", transcribed_text, lesson_output.value, example_output.value, real_world_output.value, quiz_output.value
-                
-                # Process the output
                 lesson, example, real_world, quiz = process_output(tutor_output)
-                logging.info("Successfully processed output into formatted HTML")
-                
-                # Update state to indicate submission is complete
-                yield {"is_submitting": False}, "Ready", transcribed_text, lesson, example, real_world, quiz
                 
+                return (
+                    {"is_submitting": False},
+                    "Ready",
+                    transcribed_text,
+                    lesson,
+                    example,
+                    real_world,
+                    quiz
+                )
+            
             except Exception as e:
                 logging.error(f"Error in process_input: {str(e)}")
                 logging.error(traceback.format_exc())
-                error_message = f"Error processing your request: {str(e)}"
-                yield {"is_submitting": False}, "Error", error_message, error_message, "", "", ""
+                return (
+                    {"is_submitting": False},
+                    "Error",
+                    f"Error: {str(e)}",
+                    f"Error processing request: {str(e)}",
+                    "",
+                    "",
+                    ""
+                )
 
         def clear_outputs():
             """Clear all inputs and outputs."""
             logging.debug("Clearing all outputs")
-            return {"is_submitting": False}, "Ready", "", "", "", "", ""
+            return {"is_submitting": False}, "Ready", "", "", "", "", "", ""
 
-        # Connect the submit button to process_input function
         submit_button.click(
             fn=process_input,
             inputs=[subject, difficulty, student_input, audio_input, state],
             outputs=[state, status_indicator, transcription_output, lesson_output, example_output, real_world_output, quiz_output]
         )
 
-        # Connect the clear button to clear_outputs function
         clear_button.click(
             fn=clear_outputs,
             inputs=[],
@@ -507,22 +411,18 @@ def create_interface() -> gr.Blocks:
 
     return demo
 
-# Add a health check function and detailed error handling for startup
 def check_health():
     """Perform a health check of required components."""
     problems = []
     
-    # Check environment variables
     if not os.getenv("GROQ_API_KEY"):
         problems.append("GROQ_API_KEY environment variable is not set")
     
-    # Check if markdown2 is installed
     try:
         import markdown2
     except ImportError:
         problems.append("markdown2 package is not installed")
     
-    # Check if Groq client can be initialized
     try:
         client = Groq(api_key=os.getenv("GROQ_API_KEY") or "dummy_key_for_test")
     except Exception as e:
@@ -533,7 +433,6 @@ def check_health():
 if __name__ == "__main__":
     logging.info("Starting Vers3Dynamics Tutor application")
     
-    # Perform health check
     health_issues = check_health()
     if health_issues:
         for issue in health_issues:
@@ -544,14 +443,13 @@ if __name__ == "__main__":
         demo = create_interface()
         logging.info("Gradio interface created successfully")
         
-        # Launch the app with error handling
         try:
             logging.info("Launching Gradio server")
-            demo.queue()  # Enable queuing for better handling of concurrent requests
+            demo.queue()
             demo.launch(
-                server_name="0.0.0.0", 
+                server_name="0.0.0.0",
                 server_port=7860,
-                debug=True  # Enable debug mode
+                debug=True
             )
         except Exception as e:
             logging.critical(f"Failed to launch Gradio server: {str(e)}")