Update app.py

app.py

@@ -2,21 +2,38 @@ import gradio as gr
 from groq import Groq
 import os
 import threading
-from moviepy.editor import TextClip, concatenate_videoclips, AudioFileClip, ColorClip
 import tempfile
+import logging
+from moviepy.editor import TextClip, concatenate_videoclips, AudioFileClip, ColorClip
+
+# Set up logging for debugging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-# Initialize Groq client with your API key
-client = Groq(api_key=os.environ["GROQ_API_KEY"])
+# Disable proxies to avoid 'proxies' argument error
+os.environ["HTTP_PROXY"] = ""
+os.environ["HTTPS_PROXY"] = ""
 
-# Load Text-to-Image Models
-model1 = gr.load("models/prithivMLmods/SD3.5-Turbo-Realism-2.0-LoRA")
-model2 = gr.load("models/Purz/face-projection")
+# Initialize Groq client with error handling
+try:
+    client = Groq(api_key=os.environ.get("GROQ_API_KEY", ""))
+    logger.info("Groq client initialized successfully with API key: %s", "set" if os.environ.get("GROQ_API_KEY") else "not set")
+except Exception as e:
+    logger.error("Failed to initialize Groq client: %s", str(e))
+    raise
+
+# Load Text-to-Image Models (placeholders; adjust based on actual availability)
+model1 = gr.load("models/prithivMLmods/SD3.5-Turbo-Realism-2.0-LoRA", fallback=None)
+model2 = gr.load("models/Purz/face-projection", fallback=None)
 
 # Stop event for threading (image generation)
 stop_event = threading.Event()
 
 # Function to generate tutor output (lesson, question, feedback)
 def generate_tutor_output(subject, difficulty, student_input):
+    if not subject or not difficulty or not student_input:
+        return '{"lesson": "Please provide all inputs.", "question": "", "feedback": ""}'
+    
     prompt = f"""
     You are an expert tutor in {subject} at the {difficulty} level. 
     The student has provided the following input: "{student_input}"
@@ -29,23 +46,28 @@ def generate_tutor_output(subject, difficulty, student_input):
     Format your response as a JSON object with keys: "lesson", "question", "feedback"
     """
     
-    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 and giving math examples. Your expertise in {subject} is unparalleled, and you're adept at tailoring your teaching to {difficulty} level students."
-        }, {
-            "role": "user",
-            "content": prompt,
-        }],
-        model="mixtral-8x7b-32768",
-        max_tokens=1000,
-    )
-    
-    return completion.choices[0].message.content
+    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 and giving math examples. Your expertise in {subject} is unparalleled, and you're adept at tailoring your teaching to {difficulty} level students."
+            }, {
+                "role": "user",
+                "content": prompt,
+            }],
+            model="mixtral-8x7b-32768",
+            max_tokens=1000,
+        )
+        return completion.choices[0].message.content
+    except Exception as e:
+        logger.error("Error in generate_tutor_output: %s", str(e))
+        return '{"lesson": "Error generating lesson.", "question": "", "feedback": ""}'
 
 # Function to generate images based on model selection
 def generate_images(text, selected_model):
     stop_event.clear()
+    if not text:
+        return ["No text provided."] * 3
 
     if selected_model == "Model 1 (Turbo Realism)":
         model = model1
@@ -54,19 +76,27 @@ def generate_images(text, selected_model):
     else:
         return ["Invalid model selection."] * 3
 
+    if model is None:
+        return ["Model not loaded."] * 3
+
     results = []
     for i in range(3):
         if stop_event.is_set():
             return ["Image generation stopped by user."] * 3
-
         modified_text = f"{text} variation {i+1}"
-        result = model(modified_text)
-        results.append(result)
-
+        try:
+            result = model(modified_text)
+            results.append(result)
+        except Exception as e:
+            logger.error("Error generating image %d: %s", i+1, str(e))
+            results.append(None)
     return results
 
-# New function to generate text-to-video with voice
+# Function to generate text-to-video with voice
 def generate_text_to_video(text):
+    if not text:
+        return "No text provided for video generation."
+
     try:
         # Generate narration using Groq (text-to-speech simulation)
         narration_prompt = f"Convert this text to a natural-sounding narration: {text}"
@@ -83,11 +113,9 @@ def generate_text_to_video(text):
         )
         narration_text = narration_response.choices[0].message.content
 
-        # Simulate TTS by saving text as audio (placeholder; in reality, use a TTS API)
+        # Simulate TTS with a silent audio clip (replace with real TTS API if available)
         with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as temp_audio:
-            # Here, you'd use a real TTS service (e.g., Google TTS, ElevenLabs)
-            # For now, we'll simulate with a silent audio clip
-            audio_duration = len(narration_text.split()) / 2  # Rough estimate: 2 words per second
+            audio_duration = len(narration_text.split()) / 2  # Rough estimate: 2 words/sec
             audio = ColorClip(size=(100, 100), color=(0, 0, 0), duration=audio_duration).set_audio(None)
             audio.write_audiofile(temp_audio.name, fps=44100, logger=None)
 
@@ -98,7 +126,7 @@ def generate_text_to_video(text):
         for i in range(0, len(words), chunk_size):
             chunk = " ".join(words[i:i + chunk_size])
             clip = TextClip(chunk, fontsize=50, color='white', size=(1280, 720), bg_color='black')
-            clip = clip.set_duration(audio_duration / (len(words) / chunk_size))  # Evenly split duration
+            clip = clip.set_duration(audio_duration / (len(words) / chunk_size))
             clips.append(clip)
 
         # Concatenate clips into a single video
@@ -115,32 +143,31 @@ def generate_text_to_video(text):
 
         # Clean up temporary audio file
         os.unlink(temp_audio.name)
-
         return video_path
     except Exception as e:
+        logger.error("Error generating video: %s", str(e))
         return f"Error generating video: {str(e)}"
 
-# Set up the Gradio interface
-with gr.Blocks() as demo:
-    gr.Markdown("# 🎓 Your AI Tutor with Visuals & Images")
+# Gradio interface setup
+with gr.Blocks(title="AI Tutor with Visuals") as demo:
+    gr.Markdown("# 🎓 Your AI Tutor with Visuals & Videos")
 
-    # Section for generating Text-based output (lesson, question, feedback)
+    # Text-based output section
     with gr.Row():
         with gr.Column(scale=2):
             subject = gr.Dropdown(
                 ["Math", "Science", "History", "Literature", "Code", "AI"], 
                 label="Subject", 
-                info="Choose the subject of your lesson"
+                value="Math"
             )
             difficulty = gr.Radio(
                 ["Beginner", "Intermediate", "Advanced"], 
                 label="Difficulty Level", 
-                info="Select your proficiency level"
+                value="Beginner"
             )
             student_input = gr.Textbox(
                 placeholder="Type your query here...", 
-                label="Your Input", 
-                info="Enter the topic you want to learn"
+                label="Your Input"
             )
             submit_button_text = gr.Button("Generate Lesson & Question", variant="primary")
         
@@ -148,8 +175,8 @@ with gr.Blocks() as demo:
             lesson_output = gr.Markdown(label="Lesson")
             question_output = gr.Markdown(label="Comprehension Question")
             feedback_output = gr.Markdown(label="Feedback")
-    
-    # Section for generating Visual output
+
+    # Visual output section
     with gr.Row():
         with gr.Column(scale=2):
             model_selector = gr.Radio(
@@ -158,58 +185,49 @@ with gr.Blocks() as demo:
                 value="Model 1 (Turbo Realism)"
             )
             submit_button_visual = gr.Button("Generate Visuals", variant="primary")
-            submit_button_video = gr.Button("Generate Video with Voice", variant="primary")  # New button
+            submit_button_video = gr.Button("Generate Video with Voice", variant="primary")
         
         with gr.Column(scale=3):
             output1 = gr.Image(label="Generated Image 1")
             output2 = gr.Image(label="Generated Image 2")
             output3 = gr.Image(label="Generated Image 3")
-            video_output = gr.Video(label="Generated Video with Voice")  # New video output
-    
+            video_output = gr.Video(label="Generated Video with Voice")
+
     gr.Markdown("""
     ### How to Use
-    1. **Text Section**: Select a subject and difficulty, type your query, and click 'Generate Lesson & Question' to get your personalized lesson, comprehension question, and feedback.
-    2. **Visual Section**: Select the model for image generation, then click 'Generate Visuals' to receive 3 variations of an image based on your topic. Click 'Generate Video with Voice' to create a video with narration.
-    3. Review the AI-generated content to enhance your learning experience!
+    1. **Text Section**: Select a subject and difficulty, type your query, and click 'Generate Lesson & Question'.
+    2. **Visual Section**: Choose an image model and click 'Generate Visuals' for 3 images, or 'Generate Video with Voice' for a narrated video.
+    3. Enjoy your personalized learning experience!
     """)
-    
+
+    # Processing functions
     def process_output_text(subject, difficulty, student_input):
+        tutor_output = generate_tutor_output(subject, difficulty, student_input)
         try:
-            tutor_output = generate_tutor_output(subject, difficulty, student_input)
-            parsed = eval(tutor_output)
+            parsed = eval(tutor_output)  # Safely parse JSON (consider json.loads in production)
             return parsed["lesson"], parsed["question"], parsed["feedback"]
-        except:
+        except Exception as e:
+            logger.error("Error parsing tutor output: %s", str(e))
             return "Error parsing output", "No question available", "No feedback available"
-    
+
     def process_output_visual(text, selected_model):
-        try:
-            images = generate_images(text, selected_model)
-            return images[0], images[1], images[2]
-        except:
-            return None, None, None
-    
+        images = generate_images(text, selected_model)
+        return images[0], images[1], images[2]
+
     def process_output_video(text):
-        try:
-            video_path = generate_text_to_video(text)
-            return video_path
-        except:
-            return None
+        return generate_text_to_video(text)
 
-    # Generate Text-based Output
+    # Button click handlers
     submit_button_text.click(
         fn=process_output_text,
         inputs=[subject, difficulty, student_input],
         outputs=[lesson_output, question_output, feedback_output]
     )
-    
-    # Generate Visual Output
     submit_button_visual.click(
         fn=process_output_visual,
         inputs=[student_input, model_selector],
         outputs=[output1, output2, output3]
     )
-    
-    # Generate Video Output
     submit_button_video.click(
         fn=process_output_video,
         inputs=[student_input],
@@ -217,4 +235,5 @@ with gr.Blocks() as demo:
     )
 
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    # Launch Gradio app
+    demo.launch(server_name="0.0.0.0", server_port=7860, debug=True)