Update app.py

app.py

@@ -1,13 +1,168 @@
 import streamlit as st
+from pathlib import Path
 import torch
 from transformers import pipeline
 from PIL import Image, ImageDraw, ImageFont
 import tempfile
-from pathlib import Path
-from moviepy.editor import VideoClip, VideoFileClip, AudioFileClip, concatenate_audioclips
-from gtts import gTTS
+import os
+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
+
+class FastVideoGenerator:
+    def __init__(self):
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        
+        # Initialize text generation with efficient model
+        self.text_generator = pipeline(
+            'text-generation',
+            model='distilgpt2',
+            device=0 if self.device == "cuda" else -1
+        )
+        
+        # Create temp directory
+        self.temp_dir = Path(tempfile.mkdtemp())
+        
+        # Theme colors with opacity for better text visibility
+        self.themes = {
+            'Professional': {
+                'bg': (245, 245, 245),
+                'text': (33, 33, 33),
+                'accent': (0, 102, 204),
+                'overlay': (255, 255, 255, 180)
+            },
+            'Creative': {
+                'bg': (255, 240, 245),
+                'text': (51, 51, 51),
+                'accent': (255, 64, 129),
+                'overlay': (255, 255, 255, 180)
+            },
+            'Educational': {
+                'bg': (240, 249, 255),
+                'text': (25, 25, 25),
+                'accent': (0, 151, 167),
+                'overlay': (255, 255, 255, 180)
+            }
+        }
+
+        # 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"""
+        if not isinstance(text, str):
+            text = str(text)
+        
+        # Remove non-ASCII characters
+        text = text.encode('ascii', 'ignore').decode('ascii')
+        
+        # Replace common problematic characters
+        text = text.replace('–', '-')  # en dash
+        text = text.replace('—', '-')  # em dash
+        text = text.replace('"', '"')  # smart quotes
+        text = text.replace('"', '"')  # smart quotes
+        text = text.replace(''', "'")  # smart apostrophe
+        text = text.replace(''', "'")  # smart apostrophe
+        text = text.replace('…', '...') # ellipsis
+        
+        # Remove any remaining non-standard characters
+        text = re.sub(r'[^\x00-\x7F]+', '', text)
+        
+        return text.strip()
+
+    @staticmethod
+    @st.cache_data
+    def generate_script_cached(prompt, style, length, temperature=0.7):
+        """Cached script generation with proper text cleaning"""
+        try:
+            style_prompts = {
+                'Professional': "Write a clear, professional video script about:",
+                'Creative': "Write an engaging, creative video script about:",
+                'Educational': "Write an informative educational video script about:"
+            }
+            
+            # Clean prompt before processing
+            prompt = FastVideoGenerator.clean_text(prompt)
+            
+            generator = pipeline('text-generation', model='distilgpt2')
+            output = generator(
+                f"{style_prompts[style]} {prompt}. Make it {length} seconds long.",
+                max_length=min(length * 3, 1000),
+                num_return_sequences=1,
+                temperature=temperature
+            )
+            
+            script = output[0]['generated_text']
+            script = script.replace(style_prompts[style], '').strip()
+            return FastVideoGenerator.clean_text(script)
+            
+        except Exception as e:
+            st.error(f"Script generation failed: {str(e)}")
+            raise
+
+    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)
+        
+        # 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 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
+        bar_width = int(1000 * progress)
+        draw.rectangle([140, 650, 1140, 660], fill=(200,200,200))
+        draw.rectangle([140, 650, 140+bar_width, 660], fill=theme['accent'])
+        
+        return np.array(img)
+
+    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:
+                # Additional cleaning for gTTS
+                chunk = re.sub(r'[^\x00-\x7F]+', '', chunk)
+                tts = gTTS(text=chunk, lang='en', slow=False)
+                tts.save(str(chunk_path))
+                audio_paths.append(chunk_path)
+            except Exception as e:
+                st.error(f"Audio generation failed for chunk {i}: {str(e)}")
+                raise
+        
+        return audio_paths
 
 class VideoGenerator:
     def __init__(self):