Update app.py

app.py

@@ -1,171 +1,151 @@
 import os
-import logging
-import uuid
-from typing import List, Tuple
+import json
 import urllib.request
 from PIL import Image
 from gtts import gTTS
+import cv2
 import moviepy.editor as mp
-import gradio as gr
+import logging
 from hercai import Hercai
+import uuid
+import time
+import gradio as gr
+from typing import Tuple, List
+
+# Enhanced logging configuration
+log_dir = os.getenv('LOG_DIRECTORY', './')
+LOGGER_FILE_PATH = os.path.join(str(log_dir), 'utils.log')
 
-# 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.FileHandler(LOGGER_FILE_PATH),
         logging.StreamHandler()
     ]
 )
-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"""
+LOGGER = logging.getLogger(__name__)
+
+class Text2Video:
+    def __init__(self) -> None:
+        """Initialize the Text2Video class."""
+        self.herc = Hercai()
+        LOGGER.info("Initialized Text2Video with Hercai API")
+
+    def get_image(self, img_prompt: str) -> str:
+        """Generate an image based on the provided text prompt."""
         try:
+            # Enhanced prompt engineering similar to DALL-E 3
             enhanced_prompt = (
-                f"{prompt}, comic book style, vibrant colors, "
-                "clear speech bubbles, dramatic lighting, "
-                "detailed backgrounds, professional illustration"
+                f"Create a high-quality comic panel: {img_prompt}. "
+                "Style: Professional comic book illustration, "
+                "vivid colors, clear composition, dramatic lighting. "
+                "Include text as comic-style captions. "
+                "Resolution: High detail, 1792x1024 aspect ratio. "
+                "Quality: Professional grade comic art."
             )
-            
-            result = self.api.draw_image(
-                model="simurg",
+
+            result = self.herc.draw_image(
+                model="simurg",  # Using Hercai's best model
                 prompt=enhanced_prompt,
-                negative_prompt="blurry, low quality, dark"
+                negative_prompt="blurry, low quality, poorly drawn, distorted"
             )
-            logger.info(f"Generated image for prompt: {prompt[:30]}...")
+
+            LOGGER.info(f"Successfully generated image for prompt: {img_prompt[:50]}...")
             return result["url"]
-            
+
         except Exception as e:
-            logger.error(f"Image generation failed: {e}")
+            LOGGER.error(f"Error generating image: {e}")
             raise
 
-    def process_image(self, url: str, save_path: str) -> str:
-        """Download and process image to correct size"""
+    def download_img_from_url(self, image_url: str, image_path: str) -> str:
+        """Download and process image from URL."""
         try:
-            urllib.request.urlretrieve(url, save_path)
+            urllib.request.urlretrieve(image_url, image_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
+            # Image processing for consistent quality
+            img = Image.open(image_path)
+            target_size = (1792, 1024)  # Matching DALL-E 3 size
+            img = img.resize(target_size, Image.Resampling.LANCZOS)
+            img.save(image_path, quality=95)
             
-        except Exception as e:
-            logger.error(f"Image processing failed: {e}")
-            raise
+            LOGGER.info(f"Successfully downloaded and processed image: {image_path}")
+            return image_path
 
-    def create_audio(self, text: str, save_path: str) -> str:
-        """Generate audio narration from text"""
-        try:
-            tts = gTTS(text=text, lang='en')
-            tts.save(save_path)
-            logger.info(f"Created audio: {save_path}")
-            return save_path
         except Exception as e:
-            logger.error(f"Audio generation failed: {e}")
+            LOGGER.error(f"Error downloading image: {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"""
+    def create_video_from_images_and_audio(self, image_files: list, audio_files: list, output_path: str) -> None:
+        """Create video with enhanced quality settings."""
         try:
-            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)
+            if len(image_files) != len(audio_files):
+                raise ValueError("Number of images doesn't match number of audio files")
+
+            video_clips = []
+            for image_file, audio_file in zip(image_files, audio_files):
+                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)
+                video_clips.append(video_clip)
+
+            final_clip = mp.concatenate_videoclips(video_clips)
+            
+            # Enhanced video quality settings
             final_clip.write_videofile(
                 output_path,
-                fps=24,
                 codec='libx264',
-                audio_codec='aac'
+                fps=24,
+                audio_codec='aac',
+                audio_bitrate='192k',
+                preset='medium',
+                threads=4
             )
-            logger.info(f"Created video: {output_path}")
-            return output_path
             
+            LOGGER.info("Video created successfully")
+
         except Exception as e:
-            logger.error(f"Video creation failed: {e}")
+            LOGGER.error(f"Error creating video: {e}")
             raise
 
-    def generate(self, text: str) -> str:
-        """Main video generation pipeline"""
-        try:
-            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)
+    # [Previous methods remain the same]
+
+    def gradio_interface(self):
+        """Create enhanced Gradio interface."""
+        with gr.Blocks(theme='abidlabs/dracula_revamped') as demo:
+            gr.HTML("""
+                <center>
+                    <h1 style="color:#fff">AI Comic Video Generator</h1>
+                    <p style="color:#ddd">Create engaging comic-style videos from your stories</p>
+                </center>
+            """)
+
+            with gr.Row():
+                input_text = gr.Textbox(
+                    label="Story Script",
+                    placeholder="Enter your story (separate scenes with ,,)",
+                    lines=5
+                )
+
+            with gr.Row():
+                generate_btn = gr.Button("🎬 Generate Comic Video", variant="primary")
+
+            with gr.Row():
+                output = gr.Video(label="Generated Comic Video")
+
+            example_txt = """Once upon a time in a magical forest,, 
+            A brave knight discovered a mysterious crystal,, 
+            The crystal began to glow with incredible power"""
             
-        except Exception as e:
-            logger.error(f"Generation pipeline failed: {e}")
-            raise
+            gr.Examples([[example_txt]], [input_text])
 
-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
+            generate_btn.click(
+                self.generate_video,
+                inputs=[input_text],
+                outputs=[output]
             )
-        
-        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
-        )
-        
-    return demo
-
-if __name__ == "__main__":
-    interface = create_interface()
-    interface.launch(debug=True)
+
+        demo.launch(debug=True)