Update app.py

app.py

@@ -30,7 +30,6 @@ 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")
@@ -41,18 +40,17 @@ 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()
 
+        # 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",
         )
         
-        logging.info(f"Transcription successful: {transcription.text[:50]}...")
         return transcription.text
     except Exception as e:
         logging.error(f"Error in transcription: {str(e)}")
@@ -75,41 +73,7 @@ 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"
         },
-        "art history": {
-            "renaissance art": "The art and artists of the Renaissance period, including Leonardo da Vinci, Michel angelo, and Raffaello.",
-            "ancient egyptian art": "Art forms, techniques, and cultural significance of ancient Egyptian art.",
-            "impressionism": "The impressionist movement in art, key artists, and their works.",
-            "cubism": "The cubist movement, pioneered by Pablo Picasso and Georges Braque.",
-            "modern art": "Art from the late 19th century to the present, including abstract expressionism, pop art, etc."
-        },
-        "computer science": {
-            "algorithms": "Study of algorithms, their design, analysis, and implementation.",
-            "data structures": "Different data structures and their applications in computer science.",
-            "programming languages": "Overview of various programming languages, their features, and uses.",
-            "artificial intelligence": "Basics of AI, machine learning, neural networks, etc.",
-            "cybersecurity": "Principles of cybersecurity, threats, and protection mechanisms."
-        },
-        "literature": {
-            "shakespeare": "Works of William Shakespeare, his plays and sonnets.",
-            "classic novels": "Notable novels from the 18th, 19th, and early 20th centuries.",
-            "modern fiction": "Contemporary novels and their authors.",
-            "poetry": "Different forms of poetry and notable poets.",
-            "drama": "Theater and dramatic literature."
-        },
-        "music": {
-            "classical music": "Music from the medieval period to the present, focusing on classical compositions.",
-            "pop music": "Popular music genres and artists.",
-            "jazz": "History and styles of jazz music.",
-            "rock and roll": "Evolution of rock music and its influential bands.",
-            "music theory": "Fundamentals of music theory, notation, and composition."
-        },
-        "social science": {
-            "economics": "Principles of micro and macroeconomics, economic systems, and policies.",
-            "sociology": "Study of society, social behavior, and cultural norms.",
-            "psychology": "Human behavior, mental processes, and psychological disorders.",
-            "anthropology": "Study of human cultures, evolution, and societies.",
-            "geography": "Earth's physical and human features, maps, and spatial analysis."
-        }
+        # Add more subjects and topics as needed
     }
     
     # Check if it's a specific topic and create an enhanced prompt
@@ -134,9 +98,8 @@ 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 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().
+        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.
         """
     else:
         prompt = f"""
@@ -149,13 +112,11 @@ 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 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().
+        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.
         """
 
     try:
-        logging.info(f"Sending request to Groq API for subject: {subject}, difficulty: {difficulty}")
         completion = client.chat.completions.create(
             messages=[
                 {
@@ -170,59 +131,11 @@ def generate_tutor_output(subject: str, difficulty: str, student_input: str) ->
             model="llama-3.3-70b-versatile",
             max_tokens=2000,
         )
-        
-        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
-            }
+        # Parse the JSON string into a dictionary before returning
+        return json.loads(completion.choices[0].message.content)
     except Exception as e:
         logging.error(f"Error generating 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."
-        }
+        return {"error": f"Failed to generate tutor output: {str(e)}"}
 
 def process_output(output: Dict[str, Any]) -> Tuple[str, str, str, str]:
     try:
@@ -233,13 +146,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 f"Error: {str(e)}", "Error processing example", "Error processing real-world problem", "Error processing quiz"
-
-def transcribe_and_display(audio):
-    if not audio:
-        return "", ""
-    transcription = transcribe_audio(audio)
-    return transcription, transcription
+        return str(e), "", "", ""
 
 def create_interface() -> gr.Blocks:
     with gr.Blocks(theme=gr.themes.Soft()) as demo:
@@ -250,14 +157,12 @@ 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",
-                    value="Math"  # Set default value
+                    info="Choose the subject of your lesson"
                 )
                 difficulty = gr.Radio(
                     ["Primary", "Secondary", "Higher Education"],
                     label="Difficulty Level",
-                    info="Select your proficiency level",
-                    value="Secondary"  # Set default value
+                    info="Select your proficiency level"
                 )
                 student_input = gr.Textbox(
                     placeholder="Type your topic or question here...",
@@ -265,13 +170,12 @@ def create_interface() -> gr.Blocks:
                     info="Enter the topic you want to explore"
                 )
                 audio_input = gr.Audio(type="filepath", label="Speak Your Question")
-                transcribed_text_state = gr.State("")
-                transcription_output = gr.Textbox(label="Transcribed Audio (if provided)")
                 with gr.Row():
                     submit_button = gr.Button("📚 Teach Me", variant="primary")
                     clear_button = gr.Button("🧹 Clear", variant="secondary")
 
             with gr.Column(scale=3):
+                transcription_output = gr.Textbox(label="Transcribed Audio (if provided)")
                 lesson_output = gr.HTML(label="Lesson")
                 example_output = gr.HTML(label="Example")
                 real_world_output = gr.HTML(label="Real-World Application")
@@ -298,49 +202,33 @@ def create_interface() -> gr.Blocks:
         Note: Make sure your browser has permission to access your microphone. If you encounter any issues, try using a different browser or check your device's audio settings.
         """)
 
-        def process_input(subject, difficulty, text_input, audio_input, transcribed_text_state):
+        def process_input(subject, difficulty, text_input, audio_input):
             try:
-                # Determine which input to use
-                if audio_input and transcribed_text_state:
-                    student_input = transcribed_text_state
-                    transcribed_output_value = transcribed_text_state
-                    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]}...")
+                if audio_input:
+                    transcribed_text = transcribe_audio(audio_input)
+                    student_input = transcribed_text
                 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 = text_input
+                    transcribed_text = ""
                 
-                # Generate tutor output
-                tutor_output = generate_tutor_output(subject.lower(), difficulty, student_input)
+                logging.info(f"Processing input: subject={subject}, difficulty={difficulty}, student_input={student_input}")
                 
-                # Process the output
+                tutor_output = generate_tutor_output(subject, difficulty, student_input)
                 lesson, example, real_world, quiz = process_output(tutor_output)
-                logging.info("Successfully processed tutor output")
-                
-                return transcribed_output_value, lesson, example, real_world, quiz
+                return transcribed_text, lesson, example, real_world, quiz
             except Exception as e:
                 logging.error(f"Error in process_input: {str(e)}")
-                return str(e), f"Error generating lesson: {str(e)}", "Error generating example", "Error generating real-world problem", "Error generating quiz"
+                return str(e), "Error generating lesson", "Error generating example", "Error generating real-world problem", "Error generating quiz"
 
         def clear_outputs():
-            return ["", "", "", "", ""]  # Five empty strings for all outputs
+            return [""] * 5  # Clear all five output fields
 
-        # 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],
+            inputs=[subject, difficulty, student_input, audio_input],
             outputs=[transcription_output, lesson_output, example_output, real_world_output, quiz_output]
         )
 
-        # Connect the clear button
         clear_button.click(
             fn=clear_outputs,
             inputs=[],
@@ -348,7 +236,7 @@ def create_interface() -> gr.Blocks:
         )
 
     return demo
-
+   
 if __name__ == "__main__":
     demo = create_interface()
     demo.launch(server_name="0.0.0.0", server_port=7860)