Update app.py

app.py

@@ -14,22 +14,302 @@ from deep_translator import GoogleTranslator
 import wikipediaapi
 from groq import Groq
 
-# Import functions from your Python files
-from script_generator import script_gen_and_translate
-from urdu_tts_video import urdu_tts_and_video
 
-def main():
-    with gr.Blocks() as app:
-        gr.Markdown("# AI-Powered Urdu Science Content Generator")
+
+# ✅ Set API Key
+os.environ["GROQ_API_KEY"] = "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"    # Replace with your API key
+client = Groq(api_key=os.environ["GROQ_API_KEY"])
+
+
+def fetch_wikipedia_summary(topic):
+    wiki_wiki = wikipediaapi.Wikipedia(
+        user_agent="EducationalScriptApp/1.0",
+        language="en"
+    )
+    page = wiki_wiki.page(topic)
+    return page.summary if page.exists() else "No Wikipedia summary available."
+
+def generate_script(topic, duration):
+    try:
+        factual_content = fetch_wikipedia_summary(topic)
+        words_per_minute = 130
+        target_words = duration * words_per_minute
+
+        response = client.chat.completions.create(
+            messages=[{"role": "user", "content": f"Format the following factual content into a well-structured educational script in English with approximately {target_words} words: \n{factual_content}"}],
+            model="llama-3.3-70b-versatile"
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        return f"❌ Error in script generation: {str(e)}"
+
+
+# ✅ Function to Extract Keywords Using YAKE
+def extract_keywords(script):
+    try:
+        kw_extractor = yake.KeywordExtractor(
+            lan="en",  # Language
+            n=3,  # Max number of words in a keyword phrase (trigrams)
+            dedupLim=0.9,  # Reduce redundant phrases
+            # top=10  # Extract top 10 keywords
+        )
+
+        keywords = kw_extractor.extract_keywords(script)
+        return ", ".join([kw[0] for kw in keywords])  # ✅ Extract only the keyword text
+    except Exception as e:
+        return f"❌ Error extracting keywords: {str(e)}"
+
+
+def save_keywords_file(keywords, topic):
+    today = datetime.today().strftime('%Y_%b_%d')
+    filename = f"Keywords/{topic}_Keyword_{today}.txt"
+    os.makedirs(os.path.dirname(filename), exist_ok=True)
+    with open(filename, "w", encoding="utf-8") as f:
+        f.write(keywords)
+    return filename
+
+
+
+def translate_to_urdu(english_script):
+    try:
+        # ✅ Define a max chunk size (Google Translator has a limit)
+        max_chunk_size = 4500  # Stay below 5000 to be safe
+        chunks = [english_script[i:i + max_chunk_size] for i in range(0, len(english_script), max_chunk_size)]
+
+        translated_chunks = []
+        for chunk in chunks:
+            translated_chunk = GoogleTranslator(source='en', target='ur').translate(chunk)
+            translated_chunks.append(translated_chunk)
+
+        return " ".join(translated_chunks)  # ✅ Join all translated chunks
+    except Exception as e:
+        return f"❌ Error in translation: {str(e)}"
+
+
+
+def save_english_file(content, topic):
+    today = datetime.today().strftime('%Y_%b_%d')  # Format: 2025_Feb_21
+    filename = f"English_Scripts/{topic}_Eng_{today}.txt"
+    os.makedirs(os.path.dirname(filename), exist_ok=True)  # Ensure directory exists
+    with open(filename, "w", encoding="utf-8") as f:
+        f.write(content)
+    return filename
+
+
+def save_urdu_file(content, topic):
+    today = datetime.today().strftime('%Y_%b_%d')
+    filename = f"Urdu_Scripts/{topic}_Urdu_{today}.txt"
+    os.makedirs(os.path.dirname(filename), exist_ok=True)
+    with open(filename, "w", encoding="utf-8") as f:
+        f.write(content)
+    return filename
+
+
+def save_final_urdu_file(topic, content):
+    date_str = datetime.now().strftime("%Y_%b_%d")
+    filename = f"Urdu_Final/{topic}_Urdu_Final_{date_str}.txt"  # ✅ Corrected file path
+    os.makedirs(os.path.dirname(filename), exist_ok=True)  # ✅ Ensure the directory exists
+    with open(filename, "w", encoding="utf-8") as f:
+        f.write(content)
+    return filename
+
+
+def finalize_process():
+    return "✅ Script Generation Completed Successfully!"
+
+
+def clear_old_files():
+    # ✅ Define all directories where files are stored
+    directories = ["English_Scripts", "Urdu_Scripts", "Urdu_Final", "Keywords"]
+
+    for directory in directories:
+        if os.path.exists(directory):  # ✅ Check if directory exists
+            files = glob.glob(f"{directory}/*")  # ✅ Get all files in the directory
+            for file in files:
+                try:
+                    os.remove(file)  # ✅ Delete each file
+                except Exception as e:
+                    print(f"❌ Error deleting {file}: {e}")
+
+    return "", "", "", "", ""  # ✅ Clear all textboxes in UI
+
+
+
+#######################################################################################
+
+    
+
+# Ensure required folders exist
+os.makedirs("generated_images", exist_ok=True)
+os.makedirs("output", exist_ok=True)
+
+# Load Stable Diffusion for image generation
+model_id = "runwayml/stable-diffusion-v1-5"
+pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float32)
+pipe.safety_checker = None  # Disable safety checker
+
+# Global variable to store generated TTS audio path
+global_audio_path = None
+
+
+### 🗣️ TEXT-TO-SPEECH FUNCTION ###
+def text_to_speech(script_file):
+    if script_file is None:
+        return None, "⚠️ Please upload an Urdu script file!"
+    
+    with open(script_file.name, "r", encoding="utf-8") as f:
+        urdu_text = f.read().strip()
+
+    audio_path = "output/urdu_audio.mp3"
+    tts = gTTS(text=urdu_text, lang="ur")
+    tts.save(audio_path)
+
+    global global_audio_path
+    global_audio_path = audio_path
+
+    return audio_path, "✅ Audio generated successfully!"
+
+
+### 🏞️ IMAGE GENERATION FUNCTION ###
+def generate_images(script_file, num_images):
+    if script_file is None:
+        return None, "⚠️ Please upload a script file!"
+    
+    num_images = int(num_images)
+
+    with open(script_file.name, "r", encoding="utf-8") as f:
+        text_lines = f.read().split("\n\n")  # Splitting scenes by double newlines
+    
+    image_paths = []
+    for i, scene in enumerate(text_lines[:num_images]):
+        prompt = f"Scene {i+1}: {scene.strip()}"
+        image = pipe(prompt).images[0]
+        image_path = f"generated_images/image_{i+1}.png"
+        image.save(image_path)
+        image_paths.append(image_path)
+    
+    return image_paths, "✅ Images generated successfully!"
+
+
+### 🎥 VIDEO CREATION FUNCTION ###
+def images_to_video(image_paths, fps=1):
+    if not image_paths:
+        return None
+    
+    frame = cv2.imread(image_paths[0])
+    height, width, layers = frame.shape
+
+    video_path = "output/generated_video.mp4"
+    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+    video = cv2.VideoWriter(video_path, fourcc, fps, (width, height))
+
+    for image in image_paths:
+        frame = cv2.imread(image)
+        video.write(frame)
+    
+    video.release()
+    return video_path
+
+
+### 🔊 AUDIO-VIDEO MERGE FUNCTION ###
+def merge_audio_video(video_path):
+    if global_audio_path is None:
+        return None, "⚠️ No audio found! Please generate Urdu TTS first."
+    
+    final_video_path = "output/final_video.mp4"
+    
+    video = ffmpeg.input(video_path)
+    audio = ffmpeg.input(global_audio_path)
+    
+    ffmpeg.output(video, audio, final_video_path, vcodec="libx264", acodec="aac").run(overwrite_output=True)
+    
+    return final_video_path, "✅ Video with Urdu voice-over generated successfully!"
+
+
+### 🎬 FINAL VIDEO GENERATION PIPELINE ###
+def generate_final_video(script_file, num_images):
+    if script_file is None:
+        return None, "⚠️ Please upload a script file for image generation!"
+    
+    image_paths, img_msg = generate_images(script_file, num_images)
+    if not image_paths:
+        return None, img_msg
+
+    video_path = images_to_video(image_paths, fps=1)
+    final_video_path, vid_msg = merge_audio_video(video_path)
+    
+    return final_video_path, vid_msg
+
+
+
+### 🚀 GRADIO UI ###
+with gr.Blocks() as app:
+
+    gr.Markdown("## # 🎬 AI-Powered Educational Video Generator")
+
+    # TTS Section
+    with gr.Tab("Script Generator"):
+        topic_input = gr.Textbox(label="Enter Topic")
+        duration_input = gr.Slider(minimum=1, maximum=30, step=1, label="Duration (minutes)")
+
+
+        generate_button = gr.Button("Generate English Script")
+        eng_output = gr.Textbox(label="Generated English Script", interactive=False)
+        download_english_button = gr.Button("Download English Script")
+        download_english_button.click(save_english_file, inputs=[eng_output, topic_input], outputs=[gr.File()])
+
+
+        # ✅ Keyword Extraction Section
+        extract_keywords_btn = gr.Button("🔑 Extract Keywords")
+        keyword_output = gr.Textbox(label="🔍 Extracted Keywords", interactive=True)
+        download_keywords_btn = gr.Button("⬇️ Download Keywords")
+        download_keywords_btn.click(save_keywords_file, inputs=[keyword_output, topic_input], outputs=[gr.File()])
+
+        translate_button = gr.Button("Generate Urdu Script")
+        urdu_output = gr.Textbox(label="Translated Urdu Script", interactive=False, rtl=True)
+        download_urdu_button = gr.Button("Download Urdu Script")
+        download_urdu_button.click(save_urdu_file, inputs=[urdu_output, topic_input], outputs=[gr.File()])
+
+        
+        final_edited_urdu_output = gr.Textbox(label="Edited Urdu Script", interactive=True, rtl=True)
+        download_final_urdu_button = gr.Button("Download Final Urdu Script")
+        download_final_urdu_button.click(save_final_urdu_file, inputs=[topic_input, final_edited_urdu_output], outputs=[gr.File()])
+
+
+        # ✅ Button Actions
+        # generate_button.click(generate_script, inputs=[topic_input, duration_input], outputs=[eng_output])
+        generate_button.click(generate_script, inputs=[topic_input, duration_input],  outputs=[eng_output])
+        extract_keywords_btn.click(extract_keywords, inputs=[eng_output], outputs=[keyword_output])
+        translate_button.click(translate_to_urdu, inputs=[eng_output], outputs=[urdu_output])
+
+        status_output = gr.Textbox(label="Status", interactive=False)
+        finalize_button = gr.Button("Finalize Process")
+        finalize_button.click(finalize_process, outputs=[status_output])
+
+        generate_button.click(
+        lambda topic, duration: (*clear_old_files(), generate_script(topic, duration)),  
+        inputs=[topic_input, duration_input],  
+        outputs=[keyword_output, urdu_output, final_edited_urdu_output, status_output]    )
         
-        with gr.Tabs():
-            with gr.Tab("Script Generation & Translation"):
-                script_gen_and_translate()
-            
-            with gr.Tab("Urdu TTS & Video Generation"):
-                urdu_tts_and_video()
+
+    
+    # TTS Section
+    with gr.Tab("🗣️ Urdu Text-to-Speech"):
+        script_file_tts = gr.File(label="📂 Upload Urdu Script for Audio", type="filepath")
+        generate_audio_btn = gr.Button("🎙️ Generate Audio", variant="primary")
+        audio_output = gr.Audio(label="🔊 Urdu Speech Output", interactive=False)
+        audio_status = gr.Textbox(label="ℹ️ Status", interactive=False)
+    
+    generate_audio_btn.click(text_to_speech, inputs=[script_file_tts], outputs=[audio_output, audio_status])
+    
+    # Video Generation Section
+    with gr.Tab("🎥 AI Video Generator"):
+        script_file_video = gr.File(label="📂 Upload Urdu Script for Images", type="filepath")
+        num_images = gr.Number(label="📸 Number of Scenes", value=3, minimum=1, maximum=10, step=1)
+        generate_video_btn = gr.Button("🎬 Generate Video", variant="primary")
+        video_output = gr.Video(label="🎞️ Generated Video")
+        video_status = gr.Textbox(label="ℹ️ Status", interactive=False)
     
-    app.launch()
+    generate_video_btn.click(generate_final_video, inputs=[script_file_video, num_images], outputs=[video_output, video_status])
 
-if __name__ == "__main__":
-    main()
+app.launch()