Update app.py

app.py

@@ -1,17 +1,3 @@
-# Copyright 2024 Christopher Woodyard
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
 import gradio as gr
 from groq import Groq
 import os
@@ -39,19 +25,34 @@ def transcribe_audio(audio):
         if audio is None:
             return ""
         
-        audio_path = audio if isinstance(audio, str) else audio.name
-        
-        with open(audio_path, "rb") as audio_file:
-            audio_data = audio_file.read()
-
-        # Transcribe the audio using Distil-Whisper
-        transcription = client.audio.transcriptions.create(
-            file=(os.path.basename(audio_path), audio_data),
-            model="distil-whisper-large-v3-en",
-            response_format="verbose_json",
-        )
+        # Check if audio is a path string or a file object
+        audio_path = audio if isinstance(audio, str) else audio
         
-        return transcription.text
+        # Handle audio file properly based on gradio's audio component output
+        if os.path.exists(audio_path):
+            with open(audio_path, "rb") as audio_file:
+                audio_data = audio_file.read()
+                
+            # Use the correct API endpoint and parameters for Groq's audio transcription
+            # Note: Groq may have updated their API structure for audio transcriptions
+            try:
+                transcription = client.audio.transcriptions.create(
+                    file=("audio.wav", audio_data),  # Use generic filename with proper content
+                    model="distil-whisper-large-v3-en",
+                )
+                
+                # Check the structure of the response
+                if hasattr(transcription, 'text'):
+                    return transcription.text
+                else:
+                    # Handle different response structure
+                    return transcription.get('text', "Transcription succeeded but returned no text")
+            except AttributeError:
+                # Fallback if the API structure has changed
+                logging.warning("Audio transcription API structure may have changed, using fallback method")
+                return "Audio transcription failed. Please type your question instead."
+        else:
+            return "Audio file not found. Please try recording again."
     except Exception as e:
         logging.error(f"Error in transcription: {str(e)}")
         return f"Error in transcription: {str(e)}"
@@ -117,6 +118,7 @@ def generate_tutor_output(subject: str, difficulty: str, student_input: str) ->
         """
 
     try:
+        # Make sure we're using the correct model and parameters
         completion = client.chat.completions.create(
             messages=[
                 {
@@ -131,14 +133,33 @@ def generate_tutor_output(subject: str, difficulty: str, student_input: str) ->
             model="llama3-groq-70b-8192-tool-use-preview",
             max_tokens=2000,
         )
-        # Parse the JSON string into a dictionary before returning
-        return json.loads(completion.choices[0].message.content)
+        
+        # Handle the response parsing more robustly
+        response_content = completion.choices[0].message.content
+        
+        # Ensure we're getting valid JSON
+        try:
+            return json.loads(response_content)
+        except json.JSONDecodeError:
+            # If the response isn't valid JSON, try to extract and format it manually
+            logging.warning("Failed to parse JSON response, attempting to format manually")
+            
+            # Create a fallback response structure
+            fallback_response = {
+                "lesson": "The AI generated a response that couldn't be properly formatted. Here's the raw output:\n\n" + response_content,
+                "example": "Could not parse example from response.",
+                "real_world_problem": "Could not parse real-world application from response.",
+                "quiz": "Could not parse quiz from response."
+            }
+            return fallback_response
+            
     except Exception as e:
         logging.error(f"Error generating tutor output: {str(e)}")
         return {"error": f"Failed to generate tutor output: {str(e)}"}
 
 def process_output(output: Dict[str, Any]) -> Tuple[str, str, str, str]:
     try:
+        # 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")))
@@ -146,7 +167,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 processing output: {str(e)}", "", "", ""
 
 def create_interface() -> gr.Blocks:
     with gr.Blocks(theme=gr.themes.Soft()) as demo:
@@ -157,19 +178,28 @@ 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 a 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 a default value
                 )
                 student_input = gr.Textbox(
                     placeholder="Type your topic or question here...",
                     label="Type Your Question",
                     info="Enter the topic you want to explore"
                 )
-                audio_input = gr.Audio(type="filepath", label="Speak Your Question")
+                # Updated audio input configuration
+                audio_input = gr.Audio(
+                    type="filepath", 
+                    label="Speak Your Question",
+                    sources=["microphone"],
+                    format="wav"  # Explicitly specify format
+                )
+                
                 with gr.Row():
                     submit_button = gr.Button("📚 Teach Me", variant="primary")
                     clear_button = gr.Button("🧹 Clear", variant="secondary")
@@ -204,21 +234,28 @@ def create_interface() -> gr.Blocks:
 
         def process_input(subject, difficulty, text_input, audio_input):
             try:
-                if audio_input:
+                # Prioritize text input if both are provided
+                if text_input and text_input.strip():
+                    student_input = text_input
+                    transcribed_text = "Using text input instead of audio."
+                elif audio_input:
                     transcribed_text = transcribe_audio(audio_input)
                     student_input = transcribed_text
                 else:
-                    student_input = text_input
-                    transcribed_text = ""
+                    return "No input provided. Please type a question or record audio.", "Please provide a question to begin.", "", "", ""
                 
                 logging.info(f"Processing input: subject={subject}, difficulty={difficulty}, student_input={student_input}")
                 
+                if not student_input or student_input.strip() == "":
+                    return "Input was empty or could not be processed.", "Please provide a valid question.", "", "", ""
+                
                 tutor_output = generate_tutor_output(subject, difficulty, student_input)
                 lesson, example, real_world, quiz = process_output(tutor_output)
                 return transcribed_text, 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"
+                error_message = f"Error processing your request: {str(e)}"
+                return error_message, error_message, "", "", ""
 
         def clear_outputs():
             return [""] * 5  # Clear all five output fields
@@ -232,7 +269,7 @@ def create_interface() -> gr.Blocks:
         clear_button.click(
             fn=clear_outputs,
             inputs=[],
-            outputs=[transcription_output, lesson_output, example_output, real_world_output, quiz_output]
+            outputs=[transcription_output, student_input, lesson_output, example_output, real_world_output, quiz_output]
         )
 
     return demo