Create video.py

video.py

@@ -0,0 +1,148 @@
+import os
+import asyncio
+import aiohttp
+import random
+from PIL import Image, ImageDraw, ImageFont
+from io import BytesIO
+from duckduckgo_search import DDGS
+import glob
+from moviepy.editor import *
+def video_generation(text, prompts):
+
+    # -------- TEXT SPLITTING --------
+    def split_text(text, word_count=30):
+        words = text.split()
+        lines = []
+        for i in range(0, len(words) // word_count):
+            line = " ".join(words[i * word_count:(i + 1) * word_count])
+            lines.append(line)
+        if len(words) % word_count != 0:
+            lines.append(" ".join(words[(len(words) // word_count) * word_count:]))
+        return lines
+
+    # -------- ASYNC IMAGE SEARCH --------
+    def get_headers():
+        user_agents = [
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
+            "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)",
+            "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:90.0)"
+        ]
+        return {"User-Agent": random.choice(user_agents)}
+
+    def is_valid_image(image):
+        width, height = image.size
+        aspect_ratio = round(width / height, 2)
+        return width >= 854 and height >= 480 and abs(aspect_ratio - (16 / 9)) <= 0.2
+
+    async def fetch_image(session, url, name):
+        try:
+            async with session.get(url, timeout=10) as response:
+                content = await response.read()
+                image = Image.open(BytesIO(content)).convert("RGB")
+                if not is_valid_image(image):
+                    return None
+                path = os.path.join("images", f"{name}.jpg")
+                image.save(path)
+                return path
+        except:
+            return None
+
+    async def search_and_download(session, prompt):
+        name = prompt.replace(" ", "_").lower()
+        try:
+            ddgs = DDGS()
+            results = ddgs.images(prompt, max_results=15)
+            for item in results:
+                url = item.get("image")
+                result = await fetch_image(session, url, name)
+                if result:
+                    return result
+            return None
+        except:
+            return None
+
+    async def run_image_search(prompts):
+        os.makedirs("images", exist_ok=True)
+        async with aiohttp.ClientSession(headers=get_headers()) as session:
+            tasks = [search_and_download(session, prompt) for prompt in prompts]
+            return await asyncio.gather(*tasks)
+
+    # -------- TEXT ON IMAGE --------
+    def get_text_size(text, font):
+        bbox = font.getbbox(text)
+        width = bbox[2] - bbox[0]
+        height = bbox[3] - bbox[1]
+        return width, height
+
+    def create_text_image(text, image_link):
+        image = Image.open(image_link).convert("RGB")
+        draw = ImageDraw.Draw(image)
+        image_size = image.size
+
+        font_path = "/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf"
+        max_font_size = 80
+        min_font_size = 10
+        best_font, best_lines = None, []
+
+        for font_size in range(max_font_size, min_font_size, -2):
+            font = ImageFont.truetype(font_path, font_size)
+            words = text.split()
+            lines, current_line = [], ""
+
+            for word in words:
+                test_line = f"{current_line} {word}" if current_line else word
+                w, _ = get_text_size(test_line, font)
+                if w <= image_size[0] * 0.95:
+                    current_line = test_line
+                else:
+                    lines.append(current_line)
+                    current_line = word
+            if current_line:
+                lines.append(current_line)
+
+            total_height = sum(get_text_size(line, font)[1] + 10 for line in lines)
+            if total_height <= image_size[1] * 0.95:
+                best_font, best_lines = font, lines
+                break
+
+        y = (image_size[1] - total_height) // 2
+        for line in best_lines:
+            w, h = get_text_size(line, best_font)
+            x = (image_size[0] - w) // 2
+
+            for dx in range(-2, 3):
+                for dy in range(-2, 3):
+                    if dx != 0 or dy != 0:
+                        draw.text((x + dx, y + dy), line, font=best_font, fill='black')
+            draw.text((x, y), line, font=best_font, fill='white')
+            y += h + 10
+
+        image.save(image_link)
+
+    # -------- VIDEO GENERATION --------
+    def create_video_from_images(folder="images", output="output_video.mp4", duration=3):
+        image_files = sorted(glob.glob(os.path.join(folder, "*.jpg")))
+        if not image_files:
+            raise ValueError("No images found!")
+        clips = [ImageClip(m).set_duration(duration) for m in image_files]
+        video = concatenate_videoclips(clips, method="compose")
+        video.write_videofile(output, fps=24, audio=False)
+        return output
+
+    # -------- RUN COMPLETE PIPELINE --------
+    lines = split_text(text)
+    if len(lines) != len(prompts):
+        print(len(lines),len(prompts))
+        raise ValueError("The number of text chunks must match the number of prompts!")
+
+    image_paths = asyncio.run(run_image_search(prompts))
+    image_paths = [p for p in image_paths if p is not None]
+
+    if len(image_paths) != len(lines):
+        raise ValueError("Mismatch in number of images downloaded and text chunks!")
+
+    for i in range(len(lines)):
+        create_text_image(lines[i], image_paths[i])
+
+    video_path = create_video_from_images()
+    return video_path