Update generate.py

generate.py

@@ -1,76 +1,52 @@
 import sys
 import os
 import re
-import textwrap
-import numpy as np
 import requests
-from PIL import Image, ImageDraw, ImageFont
-from moviepy.editor import ImageClip, concatenate_videoclips, AudioFileClip
+from moviepy.editor import VideoFileClip, concatenate_videoclips, AudioFileClip, ColorClip
 from io import BytesIO
 import upload
+import random
 
-WIDTH, HEIGHT = 1080, 1920
 FPS = 30
-DURATION_PER_LINE = 4
 PEXELS_API_KEY = "f7RBHJ4s4DTTFLmpUVhpYPnBFdk1MveAn0hJL2FQMhUb6aIeztxwhgA4"
+VIDEO_PATH = '/app/video.mp4'
 
-def get_pexels_image(query):
-    """Fetch image from Pexels based on query"""
+def get_pexels_video(query):
+    """Fetch vertical video from Pexels"""
     try:
         headers = {"Authorization": PEXELS_API_KEY}
-        params = {"query": query, "per_page": 1, "orientation": "portrait"}
-        response = requests.get("https://api.pexels.com/v1/search", headers=headers, params=params, timeout=15)
-        if response.status_code == 200:
-            data = response.json()
-            if data["photos"]:
-                img_url = data["photos"][0]["src"]["large"]
-                img_response = requests.get(img_url, timeout=15)
-                img = Image.open(BytesIO(img_response.content)).convert('RGB')
-                img = img.resize((WIDTH, HEIGHT))
-                print(f"Pexels image fetched for: {query[:50]}")
-                return img
-        print(f"Pexels no result for: {query[:50]}")
+        for q in [query, "india viral", "trending india", "nature cinematic"]:
+            params = {"query": q, "per_page": 5, "orientation": "portrait"}
+            response = requests.get("https://api.pexels.com/videos/search", headers=headers, params=params, timeout=15)
+            if response.status_code == 200:
+                data = response.json()
+                if data.get("videos"):
+                    video = random.choice(data["videos"])
+                    files = sorted(video["video_files"], key=lambda x: x.get("width", 9999))
+                    for f in files:
+                        if f.get("height", 0) >= 720:
+                            url = f["link"]
+                            print(f"Downloading Pexels video for: {q[:40]}")
+                            r = requests.get(url, timeout=60, headers={
+                                "User-Agent": "Mozilla/5.0",
+                                "Referer": "https://www.pexels.com/"
+                            })
+                            path = f'/app/bg_{random.randint(1000,9999)}.mp4'
+                            with open(path, 'wb') as file:
+                                file.write(r.content)
+                            return path
+        print("No Pexels video found")
         return None
     except Exception as e:
-        print(f"Pexels error: {e}")
+        print(f"Pexels video error: {e}")
         return None
 
-def make_text_frame(text, bg_image=None):
-    if bg_image:
-        img = bg_image.copy()
-    else:
-        img = Image.new('RGB', (WIDTH, HEIGHT), color=(15, 15, 25))
-
-    overlay = Image.new('RGBA', (WIDTH, HEIGHT), (0, 0, 0, 160))
-    img = img.convert('RGBA')
-    img = Image.alpha_composite(img, overlay)
-    img = img.convert('RGB')
-
-    draw = ImageDraw.Draw(img)
-    try:
-        font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 65)
-    except:
-        font = ImageFont.load_default()
-
-    draw.rectangle([60, 180, WIDTH-60, 195], fill=(255, 80, 80))
-    draw.rectangle([60, HEIGHT-195, WIDTH-60, HEIGHT-180], fill=(255, 80, 80))
-
-    lines = textwrap.wrap(text, width=22)
-    y = HEIGHT // 2 - (len(lines) * 85) // 2
-    for line in lines:
-        bbox = draw.textbbox((0, 0), line, font=font)
-        w = bbox[2] - bbox[0]
-        x = (WIDTH - w) // 2
-        draw.text((x+4, y+4), line, font=font, fill=(0, 0, 0))
-        draw.text((x, y), line, font=font, fill=(255, 255, 255))
-        y += 90
-
-    return np.array(img)
-
 def generate_tts(text, output_path):
     try:
         from gtts import gTTS
-        tts = gTTS(text=text, lang='en', slow=False)
+        hindi_chars = sum(1 for c in text if '\u0900' <= c <= '\u097F')
+        lang = 'hi' if hindi_chars > 5 else 'en'
+        tts = gTTS(text=text, lang=lang, slow=False)
         tts.save(output_path)
         return True
     except Exception as e:
@@ -78,8 +54,8 @@ def generate_tts(text, output_path):
         return False
 
 def generate_video(script, title, description):
-    print("Starting cinematic video generation...")
-    print(f"Script received: {script[:100]}")
+    print("Starting video generation...")
+    print(f"Script: {script[:100]}")
 
     sentences = re.split(r'[.!?\n]', script)
     sentences = [s.strip() for s in sentences if len(s.strip()) > 5]
@@ -88,34 +64,56 @@ def generate_video(script, title, description):
         words = script.split()
         sentences = [' '.join(words[i:i+8]) for i in range(0, len(words), 8)]
 
-    sentences = sentences[:10]
+    sentences = sentences[:8]
     print(f"Total clips: {len(sentences)}")
 
     clips = []
+    temp_files = []
 
     for i, sentence in enumerate(sentences):
         print(f"Creating clip {i+1}/{len(sentences)}")
 
-        # Get Pexels image
-        bg_image = get_pexels_image(sentence)
-
-        # Generate TTS
         audio_path = f'/app/audio_{i}.mp3'
         has_audio = generate_tts(sentence, audio_path)
 
-        # Create frame
-        frame = make_text_frame(sentence, bg_image)
-
-        # Create clip
         if has_audio and os.path.exists(audio_path):
             audio = AudioFileClip(audio_path)
-            duration = max(audio.duration + 0.5, DURATION_PER_LINE)
-            clip = ImageClip(frame, duration=duration)
-            clip = clip.set_audio(audio)
+            duration = max(audio.duration + 0.3, 3)
+            temp_files.append(audio_path)
         else:
-            clip = ImageClip(frame, duration=DURATION_PER_LINE)
+            audio = None
+            duration = 4
+
+        bg_path = get_pexels_video(sentence[:30])
+
+        if bg_path and os.path.exists(bg_path):
+            try:
+                bg_clip = VideoFileClip(bg_path)
+                bg_duration = bg_clip.duration
+                if bg_duration < duration:
+                    bg_clip = bg_clip.loop(duration=duration)
+                else:
+                    bg_clip = bg_clip.subclip(0, duration)
+
+                # Crop to 9:16
+                w, h = bg_clip.size
+                target_w = int(h * 9 / 16)
+                if target_w < w:
+                    x1 = (w - target_w) // 2
+                    bg_clip = bg_clip.crop(x1=x1, y1=0, x2=x1+target_w, y2=h)
+                bg_clip = bg_clip.resize((1080, 1920))
+                clip = bg_clip
+                temp_files.append(bg_path)
+            except Exception as e:
+                print(f"Video clip error: {e}")
+                clip = ColorClip(size=(1080, 1920), color=[15, 15, 25], duration=duration)
+        else:
+            clip = ColorClip(size=(1080, 1920), color=[15, 15, 25], duration=duration)
+
+        if audio:
+            clip = clip.set_audio(audio)
 
-        clip = clip.fadein(0.5).fadeout(0.5)
+        clip = clip.fadein(0.3).fadeout(0.3)
         clips.append(clip)
 
     if not clips:
@@ -125,10 +123,9 @@ def generate_video(script, title, description):
     print("Combining clips...")
     final = concatenate_videoclips(clips, method="compose")
 
-    output_path = '/app/video.mp4'
     print("Writing video...")
     final.write_videofile(
-        output_path,
+        VIDEO_PATH,
         fps=FPS,
         codec='libx264',
         audio_codec='aac',
@@ -136,13 +133,13 @@ def generate_video(script, title, description):
         logger=None
     )
 
-    for i in range(len(sentences)):
+    for f in temp_files:
         try:
-            os.remove(f'/app/audio_{i}.mp3')
+            os.remove(f)
         except:
             pass
 
-    print("Cinematic video generated successfully!")
+    print("Video generated successfully!")
     return True
 
 if __name__ == '__main__':