Update app.py

app.py

@@ -9,103 +9,123 @@ from moviepy.editor import *
 import numpy as np
 from gtts import gTTS
 import textwrap
+from concurrent.futures import ThreadPoolExecutor
+import io
+import unicodedata
+import re
 
-# Move the script generation to a standalone cached function
-@st.cache_data
-def generate_script_cached(prompt, style, length, model_output):
-    """Cached version of script generation"""
-    style_prompts = {
-        'Professional': "Write a clear, professional script about:",
-        'Creative': "Write an engaging, creative script about:",
-        'Educational': "Write an informative educational script about:"
-    }
-    
-    # Clean up the generated text
-    script = model_output[0]['generated_text']
-    script = script.replace(style_prompts[style], '').strip()
-    return script
-
-class EnhancedVideoGenerator:
+class FastVideoGenerator:
     def __init__(self):
-        # Use device agnostic setup
         self.device = "cuda" if torch.cuda.is_available() else "cpu"
         
-        # Initialize text generation with a faster model
+        # Initialize text generation with efficient model
         self.text_generator = pipeline(
             'text-generation',
-            model='distilgpt2',  # Smaller, faster model
+            model='distilgpt2',
             device=0 if self.device == "cuda" else -1
         )
         
         # Create temp directory
         self.temp_dir = Path(tempfile.mkdtemp())
         
-        # Store theme colors
+        # Theme colors with opacity for better text visibility
         self.themes = {
             'Professional': {
                 'bg': (245, 245, 245),
                 'text': (33, 33, 33),
-                'accent': (0, 102, 204)
+                'accent': (0, 102, 204),
+                'overlay': (255, 255, 255, 180)
             },
             'Creative': {
                 'bg': (255, 240, 245),
                 'text': (51, 51, 51),
-                'accent': (255, 64, 129)
+                'accent': (255, 64, 129),
+                'overlay': (255, 255, 255, 180)
             },
             'Educational': {
                 'bg': (240, 249, 255),
                 'text': (25, 25, 25),
-                'accent': (0, 151, 167)
+                'accent': (0, 151, 167),
+                'overlay': (255, 255, 255, 180)
             }
         }
 
-    def generate_script(self, prompt, style, length):
-        """Generate engaging script based on style and length"""
+        # Pre-load font
+        try:
+            self.font = ImageFont.truetype("arial.ttf", 40)
+        except:
+            self.font = ImageFont.load_default()
+            
+        # Add text cleaner
+        self.text_cleaner = re.compile(r'[^\x00-\x7F]+')
+
+    @staticmethod
+    def clean_text(text):
+        """Clean text to handle encoding issues"""
+        # Normalize unicode characters
+        text = unicodedata.normalize('NFKD', text)
+        # Replace special characters with standard ASCII
+        text = text.encode('ascii', 'ignore').decode('ascii')
+        # Replace common special characters
+        replacements = {
+            '–': '-',  # en dash
+            '—': '-',  # em dash
+            ''': "'",  # curly quote
+            ''': "'",  # curly quote
+            '"': '"',  # curly quote
+            '"': '"',  # curly quote
+            '…': '...' # ellipsis
+        }
+        for old, new in replacements.items():
+            text = text.replace(old, new)
+        return text
+
+    @staticmethod
+    @st.cache_data
+    def generate_script_cached(prompt, style, length, temperature=0.7):
+        """Cached script generation with proper text cleaning"""
         style_prompts = {
-            'Professional': "Write a clear, professional script about:",
-            'Creative': "Write an engaging, creative script about:",
-            'Educational': "Write an informative educational script about:"
+            'Professional': "Write a clear, professional video script about:",
+            'Creative': "Write an engaging, creative video script about:",
+            'Educational': "Write an informative educational video script about:"
         }
         
-        max_length = int(length * 2.5)  # Approximate words needed for duration
+        prompt = FastVideoGenerator.clean_text(prompt)
         
-        # Generate the text
-        output = self.text_generator(
-            f"{style_prompts[style]} {prompt}. Keep it concise and engaging.",
-            max_length=max_length,
-            num_return_sequences=1,
-            temperature=0.7
-        )
+        with pipeline('text-generation', model='distilgpt2') as generator:
+            output = generator(
+                f"{style_prompts[style]} {prompt}. Make it {length} seconds long.",
+                max_length=min(length * 3, 1000),
+                num_return_sequences=1,
+                temperature=temperature
+            )
         
-        # Use the cached function to process the output
-        return generate_script_cached(prompt, style, length, output)
+        script = output[0]['generated_text']
+        script = script.replace(style_prompts[style], '').strip()
+        return FastVideoGenerator.clean_text(script)
 
-    def create_styled_frame(self, text, theme, frame_number, total_frames):
-        """Create a visually appealing frame with text and progress bar"""
-        # Create base image
-        img = Image.new('RGB', (1280, 720), color=theme['bg'])
+    def create_frame_fast(self, text, theme, frame_number, total_frames, size=(1280, 720)):
+        """Create frame with cleaned text"""
+        # Clean text before rendering
+        text = self.clean_text(text)
+        
+        # Create frame
+        frame = np.full((size[1], size[0], 3), theme['bg'], dtype=np.uint8)
+        img = Image.fromarray(frame)
         draw = ImageDraw.Draw(img)
         
         # Wrap text for better presentation
         wrapped_text = textwrap.fill(text, width=50)
         
-        # Add text
-        font_size = 40
-        try:
-            font = ImageFont.truetype("arial.ttf", font_size)
-        except:
-            font = ImageFont.load_default()
-            
-        # Calculate text position for center alignment
-        text_bbox = draw.textbbox((0, 0), wrapped_text, font=font)
-        text_width = text_bbox[2] - text_bbox[0]
-        text_height = text_bbox[3] - text_bbox[1]
-        text_x = (1280 - text_width) // 2
-        text_y = (720 - text_height) // 2
+        # Calculate text position
+        text_bbox = draw.textbbox((0, 0), wrapped_text, font=self.font)
+        text_x = (size[0] - (text_bbox[2] - text_bbox[0])) // 2
+        text_y = (size[1] - (text_bbox[3] - text_bbox[1])) // 2
         
-        # Draw text with subtle shadow for depth
-        draw.text((text_x+2, text_y+2), wrapped_text, fill=(0,0,0,128), font=font)
-        draw.text((text_x, text_y), wrapped_text, fill=theme['text'], font=font)
+        # Draw text with background for better readability
+        text_bg = Image.new('RGBA', size, (0, 0, 0, 0))
+        text_draw = ImageDraw.Draw(text_bg)
+        text_draw.text((text_x, text_y), wrapped_text, fill=theme['text'], font=self.font)
         
         # Add progress bar
         progress = frame_number / total_frames
@@ -115,132 +135,166 @@ class EnhancedVideoGenerator:
         
         return np.array(img)
 
-    def generate_voiceover(self, script, lang='en'):
-        """Generate voice narration using gTTS"""
-        audio_path = self.temp_dir / "voiceover.mp3"
-        tts = gTTS(text=script, lang=lang, slow=False)
-        tts.save(str(audio_path))
-        return audio_path
+    def generate_audio_chunks(self, script, chunk_size=1000):
+        """Generate audio with cleaned text"""
+        # Clean text before TTS
+        script = self.clean_text(script)
+        chunks = textwrap.wrap(script, chunk_size)
+        audio_paths = []
+        
+        for i, chunk in enumerate(chunks):
+            chunk_path = self.temp_dir / f"audio_chunk_{i}.mp3"
+            try:
+                tts = gTTS(text=chunk, lang='en', slow=False)
+                tts.save(str(chunk_path))
+                audio_paths.append(chunk_path)
+            except Exception as e:
+                # If TTS fails, try with further cleaning
+                cleaned_chunk = re.sub(r'[^a-zA-Z0-9\s.,!?-]', '', chunk)
+                tts = gTTS(text=cleaned_chunk, lang='en', slow=False)
+                tts.save(str(chunk_path))
+                audio_paths.append(chunk_path)
+            
+        return audio_paths
 
-    def create_video(self, script, theme, duration=30):
-        """Create video with animated text and voiceover"""
-        # Generate frames
+    def create_optimized_video(self, script, theme, duration=30):
+        """Create video with optimized processing"""
         fps = 24
         total_frames = duration * fps
         
+        # Create frames efficiently
         def make_frame(t):
             frame_number = int(t * fps)
-            return self.create_styled_frame(
-                script, 
-                self.themes[theme], 
+            return self.create_frame_fast(
+                script,
+                self.themes[theme],
                 frame_number,
                 total_frames
             )
         
-        # Create video clip
+        # Generate video with reduced memory usage
         clip = VideoClip(make_frame, duration=duration)
         
-        # Generate and add voiceover
-        audio_path = self.generate_voiceover(script)
-        audio = AudioFileClip(str(audio_path))
-        
-        # Combine video and audio
-        final_clip = clip.set_audio(audio)
-        
-        # Save video
-        output_path = self.temp_dir / "output_video.mp4"
-        final_clip.write_videofile(str(output_path), fps=fps, codec='libx264')
-        return output_path
+        # Generate audio in background while processing video
+        with ThreadPoolExecutor() as executor:
+            future_audio = executor.submit(self.generate_audio_chunks, script)
+            
+            # Process video
+            output_path = self.temp_dir / "output_video.mp4"
+            temp_video = self.temp_dir / "temp_video.mp4"
+            
+            # Write video without audio first
+            clip.write_videofile(
+                str(temp_video),
+                fps=fps,
+                codec='libx264',
+                audio=False,
+                preset='ultrafast'
+            )
+            
+            # Get audio paths and combine audio
+            audio_paths = future_audio.result()
+            audio_clips = [AudioFileClip(str(path)) for path in audio_paths]
+            final_audio = concatenate_audioclips(audio_clips)
+            
+            # Combine video and audio
+            video = VideoFileClip(str(temp_video))
+            final_clip = video.set_audio(final_audio)
+            final_clip.write_videofile(str(output_path), fps=fps, codec='libx264')
+            
+            # Cleanup
+            video.close()
+            final_clip.close()
+            for clip in audio_clips:
+                clip.close()
+            
+            return output_path
 
 def main():
     st.set_page_config(
-        page_title="✨ Smart Video Generator",
+        page_title="⚡ Fast Video Generator",
         layout="wide",
         initial_sidebar_state="expanded"
     )
 
-    # Custom CSS for better UI
+    # Custom CSS
     st.markdown("""
         <style>
         .stButton>button {
             width: 100%;
             height: 3em;
-            margin-top: 2em;
+            background-color: #FF4B4B;
+            color: white;
         }
-        .stProgress .st-bo {
-            height: 20px;
+        .stProgress > div > div > div > div {
+            background-color: #FF4B4B;
         }
         </style>
     """, unsafe_allow_html=True)
 
-    # Initialize session state
     if 'video_generator' not in st.session_state:
-        with st.spinner("🚀 Initializing... (just a moment)"):
-            st.session_state.video_generator = EnhancedVideoGenerator()
+        st.session_state.video_generator = FastVideoGenerator()
 
-    # Sidebar for settings
     with st.sidebar:
         st.title("🎮 Video Settings")
+        
         theme = st.selectbox(
-            "Choose Theme",
+            "Theme Style",
             ["Professional", "Creative", "Educational"],
-            help="Select the style for your video"
+            help="Choose the visual style of your video"
         )
         
         duration = st.slider(
-            "Video Duration (seconds)",
-            min_value=15,
-            max_value=90,
-            value=30,
-            step=15,
-            help="Choose the length of your video"
+            "Duration (seconds)",
+            min_value=30,
+            max_value=300,
+            value=60,
+            step=30,
+            help="Videos up to 5 minutes supported"
+        )
+        
+        quality = st.select_slider(
+            "Generation Speed",
+            options=["High Quality", "Balanced", "Fast"],
+            value="Balanced",
+            help="Faster generation may reduce video quality"
         )
 
-    # Main content
-    st.title("✨ Smart Video Generator")
-    st.markdown("""
-    Transform your ideas into engaging videos with AI-powered content generation.
-    Just enter your topic below! 🎥
-    """)
+    st.title("⚡ Fast Video Generator")
+    st.markdown("Create longer videos with optimized performance!")
 
-    # Input section with example
     text_input = st.text_area(
-        "What's your video about?",
+        "Video Topic",
         height=100,
-        placeholder="Example: Explain how rainbows form in the sky..."
+        placeholder="Enter your topic here..."
     )
 
-    # Generate button with loading animation
     if st.button("🎬 Generate Video", use_container_width=True):
         if text_input:
             try:
                 progress_bar = st.progress(0)
-                status_text = st.empty()
+                status = st.empty()
                 
-                # Generate script
-                status_text.text("✍️ Creating engaging script...")
-                script = st.session_state.video_generator.generate_script(
+                # Script generation
+                status.text("✍️ Creating script...")
+                script = FastVideoGenerator.generate_script_cached(
                     text_input, theme, duration
                 )
                 progress_bar.progress(30)
                 
-                # Create video
-                status_text.text("🎨 Crafting visual elements...")
-                progress_bar.progress(60)
-                
-                video_path = st.session_state.video_generator.create_video(
+                # Video creation
+                status.text("🎨 Generating video...")
+                video_path = st.session_state.video_generator.create_optimized_video(
                     script, theme, duration
                 )
                 progress_bar.progress(100)
-                status_text.text("✨ Done! Your video is ready!")
+                status.text("✨ Video ready!")
                 
-                # Display results in tabs
+                # Display results
                 tab1, tab2 = st.tabs(["📽️ Video", "📝 Script"])
                 
                 with tab1:
                     st.video(str(video_path))
-                    
-                    # Download button
                     with open(str(video_path), 'rb') as f:
                         st.download_button(
                             "⬇️ Download Video",
@@ -252,11 +306,12 @@ def main():
                 with tab2:
                     st.markdown("### Generated Script")
                     st.write(script)
-                    
+                
             except Exception as e:
-                st.error(f"💥 Oops! Something went wrong: {str(e)}")
+                st.error(f"💥 Error: {str(e)}")
+                st.error("Please try again with different settings")
         else:
-            st.warning("🎯 Please enter a topic to generate a video!")
+            st.warning("⚠️ Please enter a topic first!")
 
 if __name__ == "__main__":
     main()