Update app.py

app.py

@@ -1,330 +1,171 @@
 import os
-import json
+import logging
+import uuid
+from typing import List, Tuple
 import urllib.request
 from PIL import Image
 from gtts import gTTS
-import cv2
 import moviepy.editor as mp
-import logging
-import uuid
-import time
 import gradio as gr
- from hercai import Hercai
-import requests
-from random import randint
-# Configure logging
-log_dir = os.getenv('LOG_DIRECTORY', './')
-LOGGER_FILE_PATH = os.path.join(str(log_dir), 'utils.log')
+from hercai import Hercai
 
+# Configure logging
 logging.basicConfig(
-    filename=LOGGER_FILE_PATH,
-    filemode='a',
-    format='[%(asctime)s] [%(levelname)s] [%(filename)s] [%(lineno)s:%(funcName)s()] %(message)s',
-    datefmt='%Y-%b-%d %H:%M:%S'
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('comic_generator.log'),
+        logging.StreamHandler()
+    ]
 )
-LOGGER = logging.getLogger(__name__)
-
-log_level_env = os.getenv('LOG_LEVEL', 'INFO')
-log_level_dict = {
-    'DEBUG': logging.DEBUG,
-    'INFO': logging.INFO,
-    'WARNING': logging.WARNING,
-    'ERROR': logging.ERROR,
-    'CRITICAL': logging.CRITICAL
-}
-if log_level_env in log_level_dict:
-    log_level = log_level_dict[log_level_env]
-else:
-    log_level = log_level_dict['INFO']
-LOGGER.setLevel(log_level)
-
-
-class Text2Video:
-    """A class to generate videos from text prompts."""
-
-    def __init__(self) -> None:
-        """
-        Initialize the Text2Video class.
-        Args:
-            file_path (str): Path to the configuration file.
-        """
-        # Replace Azure OpenAI with Hercai
-        self.hercai = Hercai("")  # Replace "" with your Hercai API key if you have one
-        self.prodia_model = "stable-diffusion-xl"
-        self.pollinations_model = None
-
-    def get_image(self, img_prompt: str) -> str:
-        """
-        Generate an image based on the provided text prompt using Hercai's draw_image method.
-        Args:
-            img_prompt (str): Text prompt for generating the image.
-        Returns:
-            str: URL of the generated image.
-        """
+logger = logging.getLogger(__name__)
+
+class ComicVideoGenerator:
+    def __init__(self):
+        """Initialize comic video generator with Hercai API"""
+        self.api = Hercai()
+        self.image_size = (1024, 1024)
+        
+    def generate_comic_image(self, prompt: str) -> str:
+        """Generate comic-style image from text prompt"""
         try:
-            # Generate image using Hercai's draw_image method
-            image_result = self.hercai.draw_image(model="v3", prompt=img_prompt, negative_prompt="")
-            image_url = image_result["url"]
-            return image_url
-
+            enhanced_prompt = (
+                f"{prompt}, comic book style, vibrant colors, "
+                "clear speech bubbles, dramatic lighting, "
+                "detailed backgrounds, professional illustration"
+            )
+            
+            result = self.api.draw_image(
+                model="simurg",
+                prompt=enhanced_prompt,
+                negative_prompt="blurry, low quality, dark"
+            )
+            logger.info(f"Generated image for prompt: {prompt[:30]}...")
+            return result["url"]
+            
         except Exception as e:
-            # Log any errors encountered during image generation
-            LOGGER.error(f"Error generating image: {e}")
-            return ""
+            logger.error(f"Image generation failed: {e}")
+            raise
 
-    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.
-        """
+    def process_image(self, url: str, save_path: str) -> str:
+        """Download and process image to correct size"""
         try:
-            # Download the image from the provided URL and save it to the specified path
-            urllib.request.urlretrieve(image_url, image_path)
-            return image_path  # Return the path of the downloaded image if successful
-
+            urllib.request.urlretrieve(url, save_path)
+            
+            with Image.open(save_path) as img:
+                img.thumbnail(self.image_size)
+                new_img = Image.new('RGB', self.image_size, 'white')
+                offset = tuple(map(lambda x, y: (x - y) // 2, 
+                                 self.image_size, img.size))
+                new_img.paste(img, offset)
+                new_img.save(save_path, quality=95)
+                
+            logger.info(f"Processed and saved image: {save_path}")
+            return save_path
+            
         except Exception as e:
-            # Log any errors encountered during image download
-            LOGGER.error(f"Error downloading image from URL: {e}")
-            return ""  # Return an empty string if an error occurs
+            logger.error(f"Image processing failed: {e}")
+            raise
 
-    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 create_audio(self, text: str, save_path: str) -> str:
+        """Generate audio narration from text"""
         try:
-            language = 'en'
-
-            # Create a gTTS object to convert text to speech
-            myobj = gTTS(text=img_prompt, lang=language, slow=False)
-
-            # Save the audio file at the specified path
-            myobj.save(audio_path)
-
-            # Return the path of the saved audio file if successful
-            return audio_path
+            tts = gTTS(text=text, lang='en')
+            tts.save(save_path)
+            logger.info(f"Created audio: {save_path}")
+            return save_path
         except Exception as e:
-
-            # Log any errors encountered during text-to-audio conversion
-            LOGGER.error(f"Error converting text to audio: {e}")
-            return ""
-
-    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.
-        """
-        img_list = []  # Initialize an empty list to store image paths
-        audio_paths = []  # Initialize an empty list to store audio paths
-        for img_prompt in list_prompts:
-            try:
-                # Generate a unique identifier for this file
-                unique_id = uuid.uuid4().hex
-
-                # Construct the image path using the unique identifier
-                image_path = f"{img_prompt[:9]}_{unique_id}.png"
-
-                # Generate image URL based on the prompt
-                img_url = self.get_image(img_prompt)
-
-                # Download and save the image
-                image = self.download_img_from_url(img_url, image_path)
-
-                # Add the image path to the list
-                img_list.append(image)
-
-                # Construct the audio path using the unique identifier
-                audio_path = f"{img_prompt[:9]}_{unique_id}.mp3"
-
-                # Convert text to audio and save it
-                audio = self.text_to_audio(img_prompt, audio_path)
-
-                # Add the audio path to the list
-                audio_paths.append(audio)
-
-            except Exception as e:
-                LOGGER.error(f"Error processing prompt: {img_prompt}, {e}")
-
-        # Return lists of image paths and audio paths as a tuple
-        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.
-        """
+            logger.error(f"Audio generation failed: {e}")
+            raise
+
+    def process_scene(self, prompt: str, scene_id: str) -> Tuple[str, str]:
+        """Process single scene (image + audio)"""
+        image_path = f"scene_{scene_id}.png"
+        audio_path = f"audio_{scene_id}.mp3"
+        
+        image_url = self.generate_comic_image(prompt)
+        image_file = self.process_image(image_url, image_path)
+        audio_file = self.create_audio(prompt, audio_path)
+        
+        return image_file, audio_file
+
+    def create_video(self, images: List[str], audios: List[str], 
+                    output_path: str) -> str:
+        """Create final video from images and audio"""
         try:
-            # Check if the number of images matches the number of audio files
-            if len(image_files) != len(audio_files):
-                LOGGER.error("Error: Number of images doesn't match the number of audio files.")
-                return
-
-            # Initialize an empty list to store video clips
-            video_clips = []
-
-            for image_file, audio_file in zip(image_files, audio_files):
-
-                # Read the image frame
-                frame = cv2.imread(image_file)
-
-                # Load the audio clip
-                audio_clip = mp.AudioFileClip(audio_file)
-
-                # Create video clip with image
-                video_clip = mp.ImageClip(image_file).set_duration(audio_clip.duration)
-
-                # Set audio for the video clip
-                video_clip = video_clip.set_audio(audio_clip)
-
-                # Append the video clip to the list
-                video_clips.append(video_clip)
-
-            # Concatenate all video clips into a single clip
-            final_clip = mp.concatenate_videoclips(video_clips)
-
-            # Write the final video to the output path
-            final_clip.write_videofile(output_path, codec='libx264', fps=24)
-            print("Video created successfully.")
-
+            clips = []
+            for img, audio in zip(images, audios):
+                audio_clip = mp.AudioFileClip(audio)
+                video_clip = (mp.ImageClip(img)
+                            .set_duration(audio_clip.duration)
+                            .set_audio(audio_clip))
+                clips.append(video_clip)
+
+            final_clip = mp.concatenate_videoclips(clips)
+            final_clip.write_videofile(
+                output_path,
+                fps=24,
+                codec='libx264',
+                audio_codec='aac'
+            )
+            logger.info(f"Created video: {output_path}")
+            return output_path
+            
         except Exception as e:
-            # Log any errors encountered during video creation
-            LOGGER.error(f"Error creating video: {e}")
+            logger.error(f"Video creation failed: {e}")
+            raise
 
-    def generate_video(self, text: list) -> None:
-        """
-        Generate a video from a list of text prompts.
-        Args:
-            list_prompts (list): List of text prompts.
-        """
+    def generate(self, text: str) -> str:
+        """Main video generation pipeline"""
         try:
-            list_prompts = [sentence.strip() for sentence in text.split(",,") if sentence.strip()]
-
-            # Set the output path for the generated video
-            output_path = "output_video1.mp4"
-
-            # Generate images and corresponding audio files
-            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
+            scenes = [s.strip() for s in text.split(",,") if s.strip()]
+            output_path = f"comic_{uuid.uuid4().hex[:8]}.mp4"
+            
+            images, audios = [], []
+            for i, scene in enumerate(scenes):
+                img, audio = self.process_scene(scene, f"{i}")
+                images.append(img)
+                audios.append(audio)
+                
+            return self.create_video(images, audios, output_path)
+            
         except Exception as e:
-
-            # Log any errors encountered during video generation
-            LOGGER.error(f"Error generating video: {e}")
-
-    def gradio_interface(self):
-
-        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>""")
-
-            with gr.Row(elem_id="col-container"):
-                input_text = gr.Textbox(label="Comics Text", placeholder="Enter the comics by double comma separated")
-
-            with gr.Row(elem_id="col-container"):
-                button = gr.Button("Generate Video")
-
-            with gr.Row(elem_id="col-container"):
-                output = gr.PlayableVideo()
-
-            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)
-
-    # --- Prodia & Pollinations Methods ---
-    def prodia_generate(self, model, prompt, output_file="prodia_output.png"):
-        s = requests.Session()
-        headers = {"user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko)"}
-
-        resp = s.get(
-            "https://api.prodia.com/generate",
-            params={
-                "new": "true", "prompt": prompt, "model": model,
-                "negative_prompt": "verybadimagenegative_v1.3",
-                "steps": "20", "cfg": "7", "seed": randint(1, 10000),
-                "sample": "DPM++ 2M Karras", "aspect_ratio": "square"
-            },
-            headers=headers
+            logger.error(f"Generation pipeline failed: {e}")
+            raise
+
+def create_interface():
+    """Create Gradio interface"""
+    generator = ComicVideoGenerator()
+    
+    examples = [
+        "A magical forest at sunset.,, A brave knight finds a glowing crystal.,, The crystal transforms into a dragon.",
+        "A busy city street.,, A mysterious package appears.,, The package opens to reveal a portal."
+    ]
+    
+    with gr.Blocks(theme='default') as demo:
+        gr.Markdown("# Comic Video Generator")
+        
+        with gr.Row():
+            text_input = gr.Textbox(
+                label="Story Text",
+                placeholder="Enter story scenes separated by ',,'",
+                lines=3
+            )
+        
+        with gr.Row():
+            generate_btn = gr.Button("Generate Comic")
+            video_output = gr.Video(label="Generated Comic")
+            
+        gr.Examples(examples, text_input)
+        
+        generate_btn.click(
+            fn=generator.generate,
+            inputs=text_input,
+            outputs=video_output
         )
-
-        job_id = resp.json()['job']
-        while True:
-            time.sleep(5)
-            status = s.get(f"https://api.prodia.com/job/{job_id}", headers=headers).json()
-            if status["status"] == "succeeded":
-                img_data = s.get(f"https://images.prodia.xyz/{job_id}.png?download=1", headers=headers).content
-                with open(output_file, 'wb') as f:
-                    f.write(img_data)
-                return output_file
-        return None
-
-    def pollinations_generate(self, prompt, output_file="pollinations_output.png"):
-        response = requests.get(f"https://image.pollinations.ai/prompt/{prompt}{randint(1, 10000)}")
-        if response.status_code == 200:
-            with open(output_file, 'wb') as f:
-                f.write(response.content)
-            return output_file
-        return None
-
-    # --- Hercai Class ---
-    class Hercai:
-        def __init__(self, api_key=None):
-            self.api_key = api_key
-
-        def question(self, model="v3", content="", personality=None):
-            url = f"https://hercai.onrender.com/v3/hercai?question={content}&model={model}"
-            if personality:
-                url += f"&personality={personality}"
-            if self.api_key:
-                url += f"&key={self.api_key}"
-            response = requests.get(url)
-            return response.json()
-
-        def draw_image(self, model="v3", prompt="", negative_prompt=""):
-            url = f"https://hercai.onrender.com/v3/text2image?prompt={prompt}&model={model}&negative_prompt={negative_prompt}"
-            if self.api_key:
-                url += f"&key={self.api_key}"
-            response = requests.get(url)
-            return response.json()
-
-        def beta_question(self, model="v3", content="", personality=None):
-            url = f"https://hercai.onrender.com/beta/hercai?question={content}&model={model}"
-            if personality:
-                url += f"&personality={personality}"
-            if self.api_key:
-                url += f"&key={self.api_key}"
-            response = requests.get(url)
-            return response.json()
-
-        def beta_draw_image(self, model="v3", prompt="", negative_prompt=""):
-            url = f"https://hercai.onrender.com/beta/text2image?prompt={prompt}&model={model}&negative_prompt={negative_prompt}"
-            if self.api_key:
-                url += f"&key={self.api_key}"
-            response = requests.get(url)
-            return response.json()
+        
+    return demo
 
 if __name__ == "__main__":
-    text2video = Text2Video()
-    text2video.gradio_interface()
+    interface = create_interface()
+    interface.launch(debug=True)