StoryTelling Engine

Author: TacosyHorchata

MindGUI.py

@@ -4,7 +4,7 @@
 import os
 import logging
 from dotenv import load_dotenv
-from src.json_2_video.json_2_video import PyJson2Video  # Import the process_video function
+from src.json_2_video_engine.json_2_video import PyJson2Video  # Import the process_video function
 import asyncio
 import uuid
 

prompt_templates/storytelling_script.yaml

@@ -0,0 +1,23 @@
+system_prompt: |
+  You are a script generator for YouTube Shorts. The user will provide instructions, and you will generate a script that adheres to their instructions.
+
+  **Guidelines:**
+
+  - Ensure the script consists solely of the text to be narrated—no titles, character names, actions, or additional formatting. Always verify that the script is exclusively the narration text.
+  - Create a concise and engaging narrative that aligns with the user’s instructions, as long as they comply with the following guidelines.
+  - Aim for a length of 120-140 words unless user specified otherwise.
+  - Start with a captivating hook within the first 5 seconds to engage viewers.
+  - End the script naturally at the conclusion of the story, avoiding calls to action or prompts to continue watching.
+  - Use a friendly, conversational tone, as if sharing a personal story with a close friend.
+  - Jump straight into the narrative—omit any titles, subtitles, or formal wrap-ups.
+  - Maintain a single voice throughout the narration.
+
+  **Output Instructions:**
+  - Return the result as a JSON object structured as follows:
+    {
+      "text_script": "script text here"
+    }
+
+user_prompt: |
+  - Generate a new script.
+  - Script instructions: 

src/json_2_video/__init__.py src/__init__.py

@@ -18,13 +18,14 @@ def __init__(self):
         self.video_captioner = VideoCaptioner()
         self.default_font = "Dacherry.ttf"
 
-    async def process(self, audio_file: str, captions_color="white", shadow_color="cyan", font_size=60, font=None):
+    async def process(self, audio_file: str, captions_color="white", shadow_color="cyan", font_size=60, font=None, width=540):
         subtitles_file = await self.subtitle_generator.generate_subtitles(audio_file)
         caption_clips = self.video_captioner.generate_captions_to_video(
             subtitles_file,
             font=font,
             captions_color=captions_color,
             shadow_color=shadow_color,
-            font_size=font_size
+            font_size=font_size,
+            width=width
         )
         return subtitles_file, caption_clips

src/captions/caption_handler.py

@@ -18,30 +18,32 @@ def get_font_path(self, font_name):
             logging.warning(f"Font file {font_name} not found. Using default system font.")
             return None
 
-    def create_shadow_text(self, txt, fontsize, font, color, shadow_color, shadow_offset, blur_color):
+    def create_shadow_text(self, txt, fontsize, font, color, shadow_color, shadow_offset, blur_color, width):
         """ # Create the blurred shadow
         blur_size = int(fontsize * 1.08)  # 10% larger than the main text
         blur_clip = TextClip(txt, fontsize=blur_size, font=font, color=blur_color, size=(1000, None), method='caption')
         blur_clip = blur_clip.set_opacity(0.15)  # Set the opacity to 15%
          """
+        
         # Create the offset shadow
-        shadow_clip = TextClip(txt, fontsize=fontsize, font=font, color=shadow_color, size=(1000, None), method='caption')
-        shadow_clip = shadow_clip.set_position((shadow_offset, shadow_offset))
+        #shadow_clip = TextClip(txt, fontsize=fontsize, font=font, color=shadow_color, size=(width, None), method='caption')
+        #shadow_clip = shadow_clip.set_position((shadow_offset, shadow_offset))
 
         # Create the main text
-        text_clip = TextClip(txt, fontsize=fontsize, font=font, color=color, size=(1000, None), method='caption')
+        text_clip = TextClip(txt, fontsize=fontsize*1.1, font=font, color=color, size=(width*0.8, None), method='caption', stroke_color=shadow_color, stroke_width=fontsize/15)
 
         # Composite all layers
         #return CompositeVideoClip([blur_clip, shadow_clip, text_clip])
-        return CompositeVideoClip([shadow_clip, text_clip])
+        return CompositeVideoClip([text_clip])
 
     """ Call this function to generate the captions to video """
     def generate_captions_to_video(self, 
                                    subtitles_path,
                                    font=None, 
                                    captions_color='#BA4A00', 
                                    shadow_color='white',
-                                   font_size=60
+                                   font_size=60,
+                                   width=540
                                    ):
         font = self.get_font_path(font) if font else self.default_font
         try:
@@ -79,6 +81,7 @@ def generate_captions_to_video(self,
                     shadow_color=shadow_color, 
                     shadow_offset=shadow_offset,
                     blur_color='black',
+                    width=width
                 )
 
                 start_seconds = start_time.ordinal / 1000 if hasattr(start_time, 'ordinal') else start_time

src/captions/video_captioner.py

@@ -5,6 +5,7 @@
 import re
 from openai import OpenAI 
 import math
+import time
 
 from dotenv import load_dotenv  # To load environment variables
 
@@ -19,6 +20,50 @@ def __init__(self, pexels_api_key, openai_api_key):
         self.openai = OpenAI(api_key=self.openai_api_key)
         self.base_dir = os.path.dirname(os.path.abspath(__file__))
 
+    def generate_image_pollinations(self, query, width=1024, height=1024, model=None, seed=None, nologo=False, private=True, enhance=False, timeout=15):
+        """Generate an image using Pollinations AI API
+        
+        Args:
+            query (str): Text description of the image to generate
+            width (int, optional): Width of generated image. Defaults to 1024
+            height (int, optional): Height of generated image. Defaults to 1024
+            model (str, optional): Model to use for generation
+            seed (int, optional): Seed for reproducible results
+            nologo (bool, optional): Turn off logo rendering. Defaults to False
+            private (bool, optional): Prevent image from appearing in public feed. Defaults to True
+            enhance (bool, optional): Enable prompt enhancing via LLM. Defaults to False
+            timeout (int, optional): Maximum time to wait for image generation in seconds. Defaults to 15
+        
+        Returns:
+            list: List containing the generated image URL if successful, empty list otherwise
+        """
+        # Build query parameters
+        params = {
+            'width': width,
+            'height': height,
+            'nologo': str(nologo).lower(),
+            'private': str(private).lower(),
+            'enhance': str(enhance).lower()
+        }
+        if model:
+            params['model'] = model
+        if seed is not None:
+            params['seed'] = seed
+
+        # URL encode the prompt
+        encoded_query = requests.utils.quote(query)
+        generate_url = f"https://image.pollinations.ai/prompt/{encoded_query}"
+
+        try:
+            full_url = requests.Request('GET', generate_url, params=params).prepare().url
+            response = requests.get(full_url, timeout=timeout)
+            if response.status_code == 200:
+                return [full_url]
+            return []
+        except Exception as e:
+            logging.error(f"Error generating image URL: {e}")
+            return []
+
     def search_pexels_images(self, query):
         """Search for images using Pexels API and return the URLs."""
         search_url = "https://api.pexels.com/v1/search"
@@ -197,9 +242,14 @@ def get_images_from_subtitles(self, subtitles_file_path, video_context, video_du
             logging.info(f"Searching image for keywords: {refined_keyword}")
 
             try:
-                image_urls = self.search_pexels_images(refined_keyword)
+                ## Search for images using first Pollinations API
+                image_urls = self.generate_image_pollinations(refined_keyword)
                 if not image_urls:
-                    image_urls = self.search_pixabay_images(refined_keyword)
+                    ## Search for images using Pexels API
+                    image_urls = self.search_pexels_images(refined_keyword)
+                    if not image_urls:
+                        ## Search for images using Pixabay API
+                        image_urls = self.search_pixabay_images(refined_keyword)
                     logging.info(f"No images found on Pexels, searching on Pixabay: {image_urls}")
                 if not image_urls:
                     logging.info(f"No images found on Pixabay")