Update app.py

app.py

@@ -1,51 +1,124 @@
-# app.py
 import os
-import gradio as gr
+import subprocess
+import glob
+import numpy as np
+from PIL import Image
+
+# Function to install missing dependencies
+def install_dependencies():
+    packages = [
+        "groq", 
+        "transformers", 
+        "diffusers", 
+        "gradio"
+    ]
+    for package in packages:
+        try:
+            __import__(package)
+        except ImportError:
+            subprocess.check_call(["pip", "install", package])
+
+# Install dependencies
+install_dependencies()
+
+# Import dependencies
+from groq import Groq
 from transformers import pipeline
 from diffusers import StableDiffusionPipeline
+import gradio as gr
 
-# Install necessary dependencies
-os.system("pip install transformers diffusers gradio")
+# Validate GROQ_API_KEY environment variable
+def validate_groq_api_key():
+    if not os.environ.get("GROQ_API_KEY"):
+        # Set default API key if not present
+        os.environ["GROQ_API_KEY"] = "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"
 
-# Text Understanding with Hugging Face Transformers
-def analyze_text(input_text):
-    summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
-    summary = summarizer(input_text, max_length=50, min_length=10, do_sample=False)[0]['summary_text']
+# Initialize Groq Client
+validate_groq_api_key()
+client = Groq(
+    api_key=os.environ.get("GROQ_API_KEY"),
+)
+
+# Example Groq Usage
+def fetch_groq_completion(prompt):
+    chat_completion = client.chat.completions.create(
+        messages=[
+            {
+                "role": "user",
+                "content": prompt,
+            }
+        ],
+        model="llama3-8b-8192",
+        stream=False,
+    )
+    return chat_completion.choices[0].message.content
 
+# Text Understanding with Hugging Face Transformers
+def extract_key_entities(text):
     ner_pipeline = pipeline("ner", model="dbmdz/bert-large-cased-finetuned-conll03-english")
-    entities = ner_pipeline(input_text)
-    key_entities = [entity["word"] for entity in entities]
+    entities = ner_pipeline(text)
+    return [entity["word"] for entity in entities]
 
-    return summary, key_entities
+def summarize_text(text):
+    summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
+    summary = summarizer(text, max_length=50, min_length=10, do_sample=False)
+    return summary[0]['summary_text']
 
-# Generate Images Using Stable Diffusion
-def generate_images(prompts):
+# Frame Generation using Stable Diffusion
+def generate_frames(prompts, output_dir="frames"):
+    os.makedirs(output_dir, exist_ok=True)
     model_id = "CompVis/stable-diffusion-v1-4"
     sd_pipeline = StableDiffusionPipeline.from_pretrained(model_id)
-    images = []
-    for prompt in prompts:
+    
+    frames = []
+    for i, prompt in enumerate(prompts):
         image = sd_pipeline(prompt).images[0]
-        images.append(image)
-    return images
-
-# Gradio App Interface
-def generate_video_from_text(input_text):
-    # Analyze text
-    summary, key_entities = analyze_text(input_text)
+        frame_path = os.path.join(output_dir, f"frame_{i:04d}.png")
+        image.save(frame_path)
+        frames.append(frame_path)
     
-    # Generate prompts and images
+    return frames
+
+# Video Stitching with FFmpeg
+def create_video_from_frames(frames_dir, output_video="output.mp4", fps=24):
+    frame_pattern = os.path.join(frames_dir, "frame_%04d.png")
+    command = [
+        "ffmpeg", "-y", "-framerate", str(fps), "-i", frame_pattern,
+        "-c:v", "libx264", "-pix_fmt", "yuv420p", output_video
+    ]
+    subprocess.run(command, check=True)
+    return output_video
+
+# Gradio Interface for Final Output
+def generate_video_interface(prompt):
+    # Step 1: Fetch understanding from Groq
+    groq_response = fetch_groq_completion(prompt)
+
+    # Step 2: Extract entities and summarize
+    key_entities = extract_key_entities(groq_response)
+    summary = summarize_text(groq_response)
+
+    # Step 3: Generate frames
     prompts = [f"{entity}, cinematic, ultra-realistic" for entity in key_entities]
-    images = generate_images(prompts)
+    frame_dir = "frames"
+    generate_frames(prompts, output_dir=frame_dir)
 
-    return summary, images
+    # Step 4: Create video
+    video_path = create_video_from_frames(frame_dir)
+    
+    return video_path
 
-interface = gr.Interface(
-    fn=generate_video_from_text,
-    inputs="text",
-    outputs=["text", gr.outputs.Image(type="pil", label="Generated Images")],
-    title="Hugging Face Text Analysis & Image Generator",
-    description="Analyze text to extract key entities and generate corresponding images using open-source AI models."
-)
+# Launch Gradio App
+def gradio_ui():
+    interface = gr.Interface(
+        fn=generate_video_interface,
+        inputs="text",
+        outputs="video",
+        title="Text-to-Video Generator",
+        description="Generate videos from text descriptions using open-source AI tools."
+    )
+    interface.launch()
 
 if __name__ == "__main__":
-    interface.launch()
+    gradio_ui()
+