Update app.py

app.py

@@ -1,39 +1,22 @@
-#!/usr/bin/env python3
-import streamlit as st
-from gradio_client import Client
+import gradio as gr
 from groq import Groq
-from PIL import Image
-import moviepy.editor as mp
-from natsort import natsorted
 import os
-from dotenv import load_dotenv
-import json
-
-# Load environment variables
-load_dotenv()
-
-# Constants
-HF_TOKEN = os.getenv("HF_TOKEN")
-GROQ_API_KEY = os.getenv("GROQ_API_KEY")
-# Switching to HF Inference API for stability
-IMAGE_GENERATION_API = "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-2-1"
-
-# Initialize Groq client
-try:
-    groq_client = Groq(api_key=GROQ_API_KEY)
-except Exception as e:
-    st.error(f"Failed to initialize Groq client: {e}")
-    groq_client = None
-
-# LLM Models
-LLM_MODELS = {
-    "Mixtral 8x7B (Groq)": "mixtral-8x7b-32768",
-    "Mistral 7B (HF)": "mistralai/Mixtral-7B-Instruct-v0.1",
-    "LLaMA 13B (HF)": "meta-llama/Llama-13b-hf"
-}
-
-# Utility Functions
-def generate_tutor_output(subject, difficulty, student_input, model):
+import threading
+from moviepy.editor import TextClip, concatenate_videoclips, AudioFileClip, ColorClip
+import tempfile
+
+# Initialize Groq client with your API key
+client = Groq(api_key=os.environ["GROQ_API_KEY"])
+
+# Load Text-to-Image Models
+model1 = gr.load("models/prithivMLmods/SD3.5-Turbo-Realism-2.0-LoRA")
+model2 = gr.load("models/Purz/face-projection")
+
+# 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):
     prompt = f"""
     You are an expert tutor in {subject} at the {difficulty} level. 
     The student has provided the following input: "{student_input}"
@@ -46,129 +29,192 @@ def generate_tutor_output(subject, difficulty, student_input, model):
     Format your response as a JSON object with keys: "lesson", "question", "feedback"
     """
     
-    if model.startswith("mixtral") and groq_client:
-        try:
-            completion = groq_client.chat.completions.create(
-                messages=[{
-                    "role": "system",
-                    "content": f"You are the world's best AI tutor for {subject}, renowned for clear, engaging explanations."
-                }, {
-                    "role": "user",
-                    "content": prompt
-                }],
-                model=model,
-                max_tokens=1000
-            )
-            return json.loads(completion.choices[0].message.content)
-        except Exception as e:
-            st.error(f"Groq error: {e}")
-            return {"lesson": "Sorry, unable to generate lesson due to API issue.", "question": "N/A", "feedback": "Please try again or check your input."}
+    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
+
+# Function to generate images based on model selection
+def generate_images(text, selected_model):
+    stop_event.clear()
+
+    if selected_model == "Model 1 (Turbo Realism)":
+        model = model1
+    elif selected_model == "Model 2 (Face Projection)":
+        model = model2
     else:
-        try:
-            client = Client("https://api-inference.huggingface.co/models/" + model, hf_token=HF_TOKEN)
-            response = client.predict(prompt, api_name="/generate")
-            return json.loads(response)
-        except:
-            st.warning(f"HF model {model} failed, falling back to Mixtral.")
-            if groq_client:
-                return generate_tutor_output(subject, difficulty, student_input, "mixtral-8x7b-32768")
-            return {"lesson": "Sorry, unable to generate lesson.", "question": "N/A", "feedback": "N/A"}
+        return ["Invalid model selection."] * 3
 
-def generate_image(prompt, path='temp_image.png'):
-    try:
-        client = Client(IMAGE_GENERATION_API, hf_token=HF_TOKEN)
-        result = client.predict(prompt, api_name="/predict")
-        if isinstance(result, str):  # Handle file path or binary data
-            image = Image.open(result)
-        else:
-            image = Image.open(result)
-        image.save(path)
-        return path
-    except Exception as e:
-        st.error(f"Error generating image: {e}")
-        return None
+    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)
+
+    return results
 
-def generate_video(images, audio_text, language, speaker, path='temp_video.mp4'):
+# New function to generate text-to-video with voice
+def generate_text_to_video(text):
     try:
-        if not images or all(img is None for img in images):
-            st.error("No valid images to create video.")
-            return None
-        audio_client = Client("habib926653/Multilingual-TTS")
-        audio_result = audio_client.predict(
-            text=audio_text,
-            language_code=language,
-            speaker=speaker,
-            api_name="/text_to_speech_edge"
+        # Generate narration using Groq (text-to-speech simulation)
+        narration_prompt = f"Convert this text to a natural-sounding narration: {text}"
+        narration_response = client.chat.completions.create(
+            messages=[{
+                "role": "system",
+                "content": "You are an AI voice generator that produces natural, human-like speech."
+            }, {
+                "role": "user",
+                "content": narration_prompt,
+            }],
+            model="mixtral-8x7b-32768",
+            max_tokens=500,
         )
-        audio_file = audio_result[1]
-        with open(audio_file, 'rb') as f:
-            audio_bytes = f.read()
-        audio_path = "temp_audio.mp3"
-        with open(audio_path, 'wb') as f:
-            f.write(audio_bytes)
+        narration_text = narration_response.choices[0].message.content
+
+        # Simulate TTS by saving text as audio (placeholder; in reality, use a TTS API)
+        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 = ColorClip(size=(100, 100), color=(0, 0, 0), duration=audio_duration).set_audio(None)
+            audio.write_audiofile(temp_audio.name, fps=44100, logger=None)
+
+        # Create video clips from text
+        clips = []
+        words = narration_text.split()
+        chunk_size = 10  # Display 10 words at a time
+        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
+            clips.append(clip)
+
+        # Concatenate clips into a single video
+        final_video = concatenate_videoclips(clips)
         
-        audio_clip = mp.AudioFileClip(audio_path)
-        duration_per_image = audio_clip.duration / len([img for img in images if img])
-        image_clips = [mp.ImageClip(img).set_duration(duration_per_image) for img in images if img]
-        if not image_clips:
-            st.error("No image clips generated.")
-            return None
-        video = mp.concatenate_videoclips(image_clips, method="compose").set_audio(audio_clip)
-        video.write_videofile(path, fps=24, codec='libx264')
-        return path
+        # Add audio to video
+        audio_clip = AudioFileClip(temp_audio.name)
+        final_video = final_video.set_audio(audio_clip)
+
+        # Save video to temporary file
+        with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as temp_video:
+            final_video.write_videofile(temp_video.name, fps=24, logger=None)
+            video_path = temp_video.name
+
+        # Clean up temporary audio file
+        os.unlink(temp_audio.name)
+
+        return video_path
     except Exception as e:
-        st.error(f"Error generating video: {e}")
-        return None
-
-# Streamlit App
-def main():
-    st.markdown("<h1 style='text-align: center;'>EduAI: Your Interactive Tutor</h1>", unsafe_allow_html=True)
-    st.markdown("<p style='text-align: center;'>Learn, Ask, Visualize! ❤️</p>", unsafe_allow_html=True)
-
-    subject = st.selectbox("Choose Subject:", ["Math", "Science", "History", "Literature", "Code", "AI"])
-    difficulty = st.selectbox("Difficulty Level:", ["Beginner", "Intermediate", "Advanced"])
-    model = st.selectbox("Choose LLM Model:", list(LLM_MODELS.keys()))
-    student_input = st.text_area("Your Question/Input (max 1500 chars):", max_chars=1500)
-
-    if 'tutor_response' not in st.session_state:
-        st.session_state.tutor_response = None
-
-    if st.button("Generate Answer & Question"):
-        if student_input:
-            with st.spinner("Generating your lesson..."):
-                response = generate_tutor_output(subject, difficulty, student_input, LLM_MODELS[model])
-                st.session_state.tutor_response = response
-        else:
-            st.warning("Please provide an input!")
-
-    if st.session_state.tutor_response:
-        st.markdown("### Lesson")
-        st.write(st.session_state.tutor_response["lesson"])
-        st.markdown("### Comprehension Question")
-        st.write(st.session_state.tutor_response["question"])
-        st.markdown("### Feedback")
-        st.write(st.session_state.tutor_response["feedback"])
-
-        col1, col2 = st.columns(2)
-        with col1:
-            if st.button("Generate Image"):
-                with st.spinner("Creating image..."):
-                    image_path = generate_image(st.session_state.tutor_response["lesson"])
-                    if image_path:
-                        st.image(image_path, caption="Visual of your lesson")
-        with col2:
-            if st.button("Generate Video"):
-                with st.spinner("Creating video..."):
-                    audio_client = Client("habib926653/Multilingual-TTS")
-                    speakers_response = audio_client.predict(language="English", api_name="/get_speakers")
-                    speaker = speakers_response["choices"][0][0]
-                    images = [generate_image(st.session_state.tutor_response["lesson"])]
-                    video_path = generate_video(images, st.session_state.tutor_response["lesson"], "English", speaker)
-                    if video_path:
-                        st.video(video_path)
-
-    st.markdown("---")
-    st.markdown("<p style='text-align: center;'>Built for learning, powered by AI!</p>", unsafe_allow_html=True)
+        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")
+
+    # Section for generating Text-based output (lesson, question, feedback)
+    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"
+            )
+            difficulty = gr.Radio(
+                ["Beginner", "Intermediate", "Advanced"], 
+                label="Difficulty Level", 
+                info="Select your proficiency level"
+            )
+            student_input = gr.Textbox(
+                placeholder="Type your query here...", 
+                label="Your Input", 
+                info="Enter the topic you want to learn"
+            )
+            submit_button_text = gr.Button("Generate Lesson & Question", variant="primary")
+        
+        with gr.Column(scale=3):
+            lesson_output = gr.Markdown(label="Lesson")
+            question_output = gr.Markdown(label="Comprehension Question")
+            feedback_output = gr.Markdown(label="Feedback")
+    
+    # Section for generating Visual output
+    with gr.Row():
+        with gr.Column(scale=2):
+            model_selector = gr.Radio(
+                ["Model 1 (Turbo Realism)", "Model 2 (Face Projection)"],
+                label="Select Image Generation Model",
+                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
+        
+        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
+    
+    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!
+    """)
+    
+    def process_output_text(subject, difficulty, student_input):
+        try:
+            tutor_output = generate_tutor_output(subject, difficulty, student_input)
+            parsed = eval(tutor_output)
+            return parsed["lesson"], parsed["question"], parsed["feedback"]
+        except:
+            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
+    
+    def process_output_video(text):
+        try:
+            video_path = generate_text_to_video(text)
+            return video_path
+        except:
+            return None
+
+    # Generate Text-based Output
+    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],
+        outputs=[video_output]
+    )
 
 if __name__ == "__main__":
-    main()
+    demo.launch(server_name="0.0.0.0", server_port=7860)