Update app.py

app.py

@@ -2,28 +2,45 @@ import os
 import json
 import urllib.request
 from PIL import Image
-from gtts import gTTS
 import cv2
 import moviepy.editor as mp
 import logging
+import requests
 import uuid
 import time
 import gradio as gr
-import g4f
-from g4f import Provider
+from moviepy.editor import *
+from moviepy.video.tools.subtitles import SubtitlesClip
+from hercai import Hercai  # Import the hercai library
+from gtts import gTTS  # Import gTTS for text-to-speech
+from hercai import Hercai  # Import the hercai module
 
-# Configure logging
+# Configure logging for both file and console
 log_dir = os.getenv('LOG_DIRECTORY', './')
 LOGGER_FILE_PATH = os.path.join(str(log_dir), 'utils.log')
 
-logging.basicConfig(
-    filename=LOGGER_FILE_PATH,
-    filemode='a',
-    format='[%(asctime)s] [%(levelname)s] [%(filename)s] [%(lineno)s:%(funcName)s()] %(message)s',
+# Create a formatter
+formatter = logging.Formatter(
+    '[%(asctime)s] [%(levelname)s] [%(filename)s] [%(lineno)s:%(funcName)s()] %(message)s',
     datefmt='%Y-%b-%d %H:%M:%S'
 )
+
+# Create and configure the logger
 LOGGER = logging.getLogger(__name__)
 
+# Create file handler
+file_handler = logging.FileHandler(LOGGER_FILE_PATH, mode='a')
+file_handler.setFormatter(formatter)
+
+# Create console handler
+console_handler = logging.StreamHandler()
+console_handler.setFormatter(formatter)
+
+# Add both handlers to logger
+LOGGER.addHandler(file_handler)
+LOGGER.addHandler(console_handler)
+
+# Set log level
 log_level_env = os.getenv('LOG_LEVEL', 'INFO')
 log_level_dict = {
     'DEBUG': logging.DEBUG,
@@ -38,81 +55,74 @@ else:
     log_level = log_level_dict['INFO']
 LOGGER.setLevel(log_level)
 
+# Set the path to the ImageMagick binary
+# os.environ["IMAGE_MAGICK_BINARY"] = "/usr/local/bin/convert"  # Update this path as needed (No longer needed)
+
 
 class Text2Video:
     """A class to generate videos from text prompts."""
 
     def __init__(self) -> None:
         """Initialize the Text2Video class."""
-        pass
+        self.hercai_api_key = "YOUR_HERCAI_API_KEY"  # Replace with your Hercai API key
+        self.hercai = Hercai(self.hercai_api_key)  # Initialize Hercai
+        self.hercai_base_url = "https://hercai.onrender.com/v3/text2image"
+        LOGGER.info("🚀 Text2Video class initialized.")
+
+    def generate_text(self, prompt: str) -> str:
+        """Generate text using GPT-3.5-turbo."""
+        LOGGER.info(f"📝 Generating text for prompt: {prompt}")
+        # ... (This part is not needed for Hercai) ...
+        return ""
 
     def get_image(self, img_prompt: str) -> str:
-        """
-        Generate an image based on the provided text prompt using G4F.
-        Args:
-            img_prompt (str): Text prompt for generating the image.
-        Returns:
-            str: URL of the generated image.
-        """
+        """Generate an image based on the provided text prompt."""
+        LOGGER.info(f"🖼️ Generating image for prompt: {img_prompt}")
         try:
-            # Using G4F to generate image
-            response = g4f.Image.create(
-                prompt=f"text: ``` {img_prompt}```. add this backticked text in the image as comics.",
-                model="dalle",  # or any other available model
-                provider=Provider.DeepAI
+            image_result = self.hercai.draw_image(
+                model="simurg",  # Choose a Hercai model
+                prompt=img_prompt,
+                negative_prompt="Dark and gloomy"
             )
-            
-            # The response format might vary depending on the provider
-            # Assuming it returns a direct image URL
-            return response
-
-        except Exception as e:
-            LOGGER.error(f"Error generating image: {e}")
+            image_url = image_result['url']
+            LOGGER.info(f"✅ Generated image URL: {image_url}")
+            return image_url
+        except requests.exceptions.RequestException as e:
+            LOGGER.error(f"❌ Error generating image: {str(e)}")
             return ""
 
     def download_img_from_url(self, image_url: str, image_path: str) -> str:
-        """
-        Download an image from a URL.
-        Args:
-            image_url (str): URL of the image to download.
-            image_path (str): Path to save the downloaded image.
-        Returns:
-            str: Path of the downloaded image.
-        """
+        """Download an image from a URL."""
+        LOGGER.info(f"⬇️ Downloading image from URL: {image_url} to path: {image_path}")
         try:
             urllib.request.urlretrieve(image_url, image_path)
+            # Resize after downloading
+            img = Image.open(image_path)
+            img = img.resize((640, 480))  # Adjust resolution for reduced size
+            img.save(image_path)
+            LOGGER.info(f"✅ Image downloaded to: {image_path}")
             return image_path
-
         except Exception as e:
-            LOGGER.error(f"Error downloading image from URL: {e}")
+            LOGGER.error(f"❌ Error downloading image from URL: {e}")
             return ""
 
-    def text_to_audio(self, img_prompt: str, audio_path: str) -> str:
-        """
-        Convert text to speech and save it as an audio file.
-        Args:
-            img_prompt (str): Text to convert to speech.
-            audio_path (str): Path to save the audio file.
-        Returns:
-            str: Path of the saved audio file.
-        """
+    def text_to_audio(self, text: str, audio_path: str) -> str:
+        """Convert text to speech using gTTS."""
+        LOGGER.info(f"🔊 Converting text to audio for text: {text}")
         try:
-            language = 'en'
-            myobj = gTTS(text=img_prompt, lang=language, slow=False)
-            myobj.save(audio_path)
+            tts = gTTS(text=text, lang='en')  # You can change the language ('en' for English)
+            tts.save(audio_path, bitrate="128k")  # Reduce `bitrate` for smaller file size
+            LOGGER.info(f"✅ Audio saved to: {audio_path}")
             return audio_path
         except Exception as e:
-            LOGGER.error(f"Error converting text to audio: {e}")
+            LOGGER.error(f"❌ Error generating speech: {str(e)}")
             return ""
 
+    #  The transcription part has been removed as it's no longer needed
+
     def get_images_and_audio(self, list_prompts: list) -> tuple:
-        """
-        Generate images and corresponding audio files from a list of prompts.
-        Args:
-            list_prompts (list): List of text prompts.
-        Returns:
-            tuple: A tuple containing lists of image paths and audio paths.
-        """
+        """Generate images and corresponding audio files from a list of prompts."""
+        LOGGER.info(f"🖼️🔊 Generating images and audio for prompts: {list_prompts}")
         img_list = []
         audio_paths = []
         for img_prompt in list_prompts:
@@ -120,70 +130,108 @@ class Text2Video:
                 unique_id = uuid.uuid4().hex
                 image_path = f"{img_prompt[:9]}_{unique_id}.png"
                 img_url = self.get_image(img_prompt)
-                image = self.download_img_from_url(img_url, image_path)
-                img_list.append(image)
+
+                if img_url:  # Only process if img_url exists & is not None
+                    image = self.download_img_from_url(img_url, image_path)
+                    img_list.append(image)
 
                 audio_path = f"{img_prompt[:9]}_{unique_id}.mp3"
                 audio = self.text_to_audio(img_prompt, audio_path)
-                audio_paths.append(audio)
+
+                if audio:  # Only process if audio exists 
+                    audio_paths.append(audio)
+                LOGGER.info(f"✅ Processed prompt: {img_prompt}, Image: {image}, Audio: {audio}")
 
             except Exception as e:
-                LOGGER.error(f"Error processing prompt: {img_prompt}, {e}")
+                LOGGER.error(f"❌ Error processing prompt: {img_prompt}, {e}")
 
         return img_list, audio_paths
+        
 
     def create_video_from_images_and_audio(self, image_files: list, audio_files: list, output_path: str) -> None:
-        """
-        Create a video from images and corresponding audio files.
-        Args:
-            image_files (list): List of image files.
-            audio_files (list): List of audio files.
-            output_path (str): Path to save the output video file.
-        """
+        """Create a video from images and corresponding audio files with pop-up bubbles."""
+        LOGGER.info(f"🎥 Creating video from images: {image_files}, audio files: {audio_files}")
         try:
             if len(image_files) != len(audio_files):
-                LOGGER.error("Error: Number of images doesn't match the number of audio files.")
+                LOGGER.error("❌ Error: Number of images and audio files don't match.")
                 return
 
             video_clips = []
 
             for image_file, audio_file in zip(image_files, audio_files):
-                frame = cv2.imread(image_file)
+                # Create the base video from the image and audio
+                if not os.path.exists(audio_file) or not os.path.exists(image_file):
+                    LOGGER.error(f"❌ Audio or image file missing for {image_file} or {audio_file}")
+                    continue
+
                 audio_clip = mp.AudioFileClip(audio_file)
                 video_clip = mp.ImageClip(image_file).set_duration(audio_clip.duration)
                 video_clip = video_clip.set_audio(audio_clip)
+
+                # Apply image cropping and bubble creation
+                try:
+                    img = Image.open(image_file)
+                    width, height = img.size
+                    cropped_image = img.crop((0, 0, int(width * 0.80), height))  # Cropping image to make space for bubble
+
+                    bubble_clip = mp.ImageClip(image_file).resize((150, 150))
+                    bubble_clip = bubble_clip.set_position((int(width * 0.90), 0))
+
+                    # Now combine the original video with the bubble
+                    video_clip = CompositeVideoClip([video_clip, bubble_clip])                
+                except Exception as ex:
+                    LOGGER.error(f"❌ Error adding comic bubble: {str(ex)}")
+
                 video_clips.append(video_clip)
+                LOGGER.info(f"✅ Created video clip for image: {image_file}, audio: {audio_file}")
 
-            final_clip = mp.concatenate_videoclips(video_clips)
-            final_clip.write_videofile(output_path, codec='libx264', fps=24)
-            print("Video created successfully.")
+            # Combine the generated clips into a single video
+            if video_clips:  # Only process if clip exists
+                final_clip = mp.concatenate_videoclips(video_clips)
+                final_clip.write_videofile(output_path, codec='libx264', fps=24) # Optimized codec and fps settings 
+                LOGGER.info(f"✅ Video created successfully at: {output_path}")
 
         except Exception as e:
-            LOGGER.error(f"Error creating video: {e}")
+            LOGGER.error(f"❌ Error creating video: {str(e)}")
 
-    def generate_video(self, text: list) -> None:
+    def generate_video(self, text: str) -> str:
         """
         Generate a video from a list of text prompts.
         Args:
-            list_prompts (list): List of text prompts.
+            text (str): Text prompts separated by double commas.
+        Returns:
+            str: Path to the generated video file.
         """
+        LOGGER.info(f"🎬 Generating video for text: {text}")
         try:
             list_prompts = [sentence.strip() for sentence in text.split(",,") if sentence.strip()]
-            output_path = "output_video1.mp4"
+            LOGGER.info(f"📝 List of prompts: {list_prompts}")
+
+            # Set the output path for the generated video
+            output_path = f"output_video_{uuid.uuid4().hex[:8]}.mp4"
+            LOGGER.info(f"📁 Output path for video: {output_path}")
+
+            # Generate images and audio
             img_list, audio_paths = self.get_images_and_audio(list_prompts)
+
+            # Create video from images and audio
             self.create_video_from_images_and_audio(img_list, audio_paths, output_path)
+
             return output_path
         except Exception as e:
-            LOGGER.error(f"Error generating video: {e}")
+            LOGGER.error(f"❌ Error generating video: {str(e)}")
+            return ""
 
     def gradio_interface(self):
+        """Create and launch the Gradio interface."""
+        LOGGER.info("🌐 Launching Gradio interface.")
         with gr.Blocks(css="style.css", theme='abidlabs/dracula_revamped') as demo:
             example_txt = """once upon a time there was a village. It was a nice place to live, except for one thing. people did not like to share.,, One day a visitor came to town. 
             'Hello. Does anybody have food to share?' He asked. 'No', said everyone.,,
             That's okay', said the visitor. 'I will make stone soup for everyone'.Then he took a stone and dropped it into a giant pot,,"""
 
             gr.HTML("""
-                  <center><h1 style="color:#fff">Comics Video Generator</h1></center>""")
+                <center><h1 style="color:#fff">Comics Video Generator</h1></center>""")
 
             with gr.Row(elem_id="col-container"):
                 input_text = gr.Textbox(label="Comics Text", placeholder="Enter the comics by double comma separated")
@@ -192,15 +240,18 @@ class Text2Video:
                 button = gr.Button("Generate Video")
 
             with gr.Row(elem_id="col-container"):
-                output = gr.PlayableVideo()
+                output = gr.Video()
 
             with gr.Row(elem_id="col-container"):
                 example = gr.Examples([example_txt], input_text)
 
             button.click(self.generate_video, [input_text], output)
-            demo.launch(debug=True)
+
+        demo.launch(debug=True)
+        LOGGER.info("✅ Gradio interface launched.")
 
 
 if __name__ == "__main__":
+    LOGGER.info("🚀 Starting Text2Video application.")
     text2video = Text2Video()
     text2video.gradio_interface()