Update app_enhanced.py

app_enhanced.py

@@ -1,34 +1,28 @@
 import os
 import time
-import threading
-import uuid
 import shutil
 import json
-import traceback
 import logging
 import string
 import random
-from concurrent.futures import ThreadPoolExecutor
+import uuid
 
-import gradio as gr
+print("===== Application Startup at", time.strftime("%Y-%m-%d %H:%M:%S"), "=====")
 
 # ============================================================================
-# 0. LOGGING & CONFIG
+# CONFIG
 # ============================================================================
 
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-print("===== Application Startup at", time.strftime("%Y-%m-%d %H:%M:%S"), "=====")
-
-# Use /tmp for HF Spaces
 BASE_USER_DIR = "/tmp/userdata"
 SAVED_COMICS_DIR = "/tmp/saved_comics"
 os.makedirs(BASE_USER_DIR, exist_ok=True)
 os.makedirs(SAVED_COMICS_DIR, exist_ok=True)
 
 # ============================================================================
-# 1. ZEROGPU SETUP
+# ZEROGPU
 # ============================================================================
 
 ZERO_GPU = False
@@ -37,879 +31,335 @@ try:
     ZERO_GPU = True
     logger.info("✅ ZeroGPU detected")
 except ImportError:
-    logger.info("⚠️ ZeroGPU not available, using CPU mode")
+    logger.info("⚠️ No ZeroGPU")
     class spaces:
         @staticmethod
         def GPU(duration=60):
-            def decorator(func):
-                return func
-            return decorator
+            def dec(fn): return fn
+            return dec
 
 # ============================================================================
-# 2. CORE DEPENDENCIES
+# DEPENDENCIES
 # ============================================================================
 
 try:
     import cv2
     import numpy as np
     from PIL import Image, ImageEnhance
-    logger.info("✅ OpenCV and PIL loaded")
+    logger.info("✅ CV2, PIL loaded")
 except ImportError as e:
-    logger.error(f"❌ Missing dependency: {e}")
+    logger.error(f"Missing: {e}")
     cv2 = None
-    np = None
     Image = None
 
 try:
     import srt
-    logger.info("✅ SRT parser loaded")
 except ImportError:
     srt = None
-    logger.warning("⚠️ SRT not available")
+
+# Import Gradio AFTER other imports
+import gradio as gr
 
 # ============================================================================
-# 3. WHISPER TRANSCRIPTION (GPU ACCELERATED)
+# WHISPER
 # ============================================================================
 
 if ZERO_GPU:
     @spaces.GPU(duration=120)
-    def transcribe_audio_gpu(video_path):
-        """GPU-accelerated transcription"""
+    def transcribe_gpu(video_path):
         try:
             import whisper
-            logger.info("🎤 Loading Whisper model (GPU)...")
             model = whisper.load_model("tiny")
             result = model.transcribe(video_path)
-            logger.info("✅ Transcription complete")
             return result.get('segments', [])
         except Exception as e:
-            logger.error(f"GPU transcription failed: {e}")
+            logger.error(f"GPU transcribe error: {e}")
             return None
 else:
-    def transcribe_audio_gpu(video_path):
-        return transcribe_audio_cpu(video_path)
+    def transcribe_gpu(video_path):
+        return transcribe_cpu(video_path)
 
-
-def transcribe_audio_cpu(video_path):
-    """CPU fallback transcription"""
+def transcribe_cpu(video_path):
     try:
         import whisper
-        logger.info("🎤 Loading Whisper model (CPU)...")
         model = whisper.load_model("tiny", device="cpu")
         result = model.transcribe(video_path, fp16=False)
-        logger.info("✅ Transcription complete (CPU)")
         return result.get('segments', [])
     except Exception as e:
-        logger.error(f"CPU transcription failed: {e}")
+        logger.error(f"CPU transcribe error: {e}")
         return None
 
-
-def transcribe_with_fallback(video_path):
-    """Try GPU first, fallback to CPU"""
+def transcribe(path):
     try:
-        logger.info("Attempting GPU transcription...")
-        segments = transcribe_audio_gpu(video_path)
-        if segments is not None:
-            return segments
-    except Exception as e:
-        error_msg = str(e).lower()
-        if "quota" in error_msg or "429" in error_msg:
-            logger.warning("⚠️ GPU quota exceeded, using CPU...")
-        else:
-            logger.warning(f"⚠️ GPU failed: {e}, using CPU...")
-    
-    return transcribe_audio_cpu(video_path)
-
+        result = transcribe_gpu(path)
+        if result: return result
+    except: pass
+    return transcribe_cpu(path)
 
 # ============================================================================
-# 4. HELPER CLASSES
+# HELPERS
 # ============================================================================
 
 class FaceDetector:
-    """Face detection using Haar Cascades"""
     def __init__(self):
         self.cascade = None
-        if cv2 is not None:
+        if cv2:
             try:
-                cascade_path = cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'
-                if os.path.exists(cascade_path):
-                    self.cascade = cv2.CascadeClassifier(cascade_path)
-                    logger.info("✅ Face detector loaded")
-            except Exception as e:
-                logger.warning(f"Face detector failed: {e}")
-
-    def detect_faces(self, image_path):
-        if not self.cascade or cv2 is None:
-            return []
-        try:
-            img = cv2.imread(image_path)
-            if img is None:
-                return []
-            gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
-            faces = self.cascade.detectMultiScale(gray, 1.1, 5, minSize=(30, 30))
-            return [list(f) for f in faces]
-        except:
-            return []
-
-    def get_lip_position(self, image_path, face_rect):
-        try:
-            x, y, w, h = face_rect
-            return x + w // 2, y + int(h * 0.85)
-        except:
-            return -1, -1
-
-
-class ColorEnhancer:
-    """Comic-style color enhancement"""
-    def enhance(self, image_path):
-        if Image is None:
-            return False
-        try:
-            img = Image.open(image_path)
-            img = ImageEnhance.Color(img).enhance(1.4)
-            img = ImageEnhance.Contrast(img).enhance(1.25)
-            img = ImageEnhance.Sharpness(img).enhance(1.2)
-            img.save(image_path)
-            return True
-        except:
-            return False
-
+                self.cascade = cv2.CascadeClassifier(
+                    cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'
+                )
+            except: pass
 
-class BubblePlacer:
-    """Smart speech bubble placement"""
-    def place(self, image_path, lip_pos=None):
+    def detect(self, path):
+        if not self.cascade: return []
         try:
-            if Image is None:
-                return 50, 20
-            img = Image.open(image_path)
-            w, h = img.size
-            
-            if lip_pos and lip_pos[0] > 0:
-                lip_x, lip_y = lip_pos
-                if lip_x < w / 2:
-                    return w - 140, max(10, lip_y - 60)
-                return 20, max(10, lip_y - 60)
-            return 50, 20
-        except:
-            return 50, 20
-
+            img = cv2.imread(path)
+            gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+            return list(self.cascade.detectMultiScale(gray, 1.1, 5))
+        except: return []
 
-# Initialize helpers
 face_detector = FaceDetector()
-color_enhancer = ColorEnhancer()
-bubble_placer = BubblePlacer()
 
+def enhance(path):
+    if not Image: return
+    try:
+        img = Image.open(path)
+        img = ImageEnhance.Color(img).enhance(1.4)
+        img = ImageEnhance.Contrast(img).enhance(1.2)
+        img.save(path)
+    except: pass
 
-def generate_save_code(length=8):
-    """Generate unique save code"""
+def gen_code():
     chars = string.ascii_uppercase + string.digits
     while True:
-        code = ''.join(random.choices(chars, k=length))
+        code = ''.join(random.choices(chars, k=8))
         if not os.path.exists(os.path.join(SAVED_COMICS_DIR, code)):
             return code
 
-
 # ============================================================================
-# 5. COMIC GENERATOR CLASS
+# GENERATOR
 # ============================================================================
 
-class ComicGenerator:
+class Generator:
     def __init__(self, sid):
         self.sid = sid
-        self.user_dir = os.path.join(BASE_USER_DIR, sid)
-        self.video_path = os.path.join(self.user_dir, 'uploaded.mp4')
-        self.frames_dir = os.path.join(self.user_dir, 'frames')
-        self.output_dir = os.path.join(self.user_dir, 'output')
-        self.status_file = os.path.join(self.output_dir, 'status.json')
-        self.metadata_path = os.path.join(self.frames_dir, 'frame_metadata.json')
-        self.video_fps = 25
-        
-        os.makedirs(self.frames_dir, exist_ok=True)
-        os.makedirs(self.output_dir, exist_ok=True)
-
-    def update_status(self, message, progress):
+        self.base = os.path.join(BASE_USER_DIR, sid)
+        self.video = os.path.join(self.base, 'video.mp4')
+        self.frames = os.path.join(self.base, 'frames')
+        self.output = os.path.join(self.base, 'output')
+        self.meta = os.path.join(self.frames, 'meta.json')
+        self.fps = 25
+        os.makedirs(self.frames, exist_ok=True)
+        os.makedirs(self.output, exist_ok=True)
+
+    def clean(self):
+        for d in [self.frames, self.output]:
+            for f in os.listdir(d) if os.path.exists(d) else []:
+                try: os.remove(os.path.join(d, f))
+                except: pass
+
+    def extract(self, moments, max_n=48):
+        if not cv2: return False
         try:
-            with open(self.status_file, 'w') as f:
-                json.dump({'message': message, 'progress': progress}, f)
-        except:
-            pass
-
-    def get_status(self):
-        try:
-            if os.path.exists(self.status_file):
-                with open(self.status_file, 'r') as f:
-                    return json.load(f)
-        except:
-            pass
-        return {'message': 'Waiting...', 'progress': 0}
-
-    def cleanup(self):
-        """Clean previous run"""
-        logger.info(f"🧹 Cleaning session {self.sid}")
-        for directory in [self.frames_dir, self.output_dir]:
-            if os.path.exists(directory):
-                for f in os.listdir(directory):
-                    if f != 'status.json':
-                        try:
-                            os.remove(os.path.join(directory, f))
-                        except:
-                            pass
-
-    def extract_keyframes(self, key_moments, max_frames=48):
-        """Extract frames at key moments"""
-        if cv2 is None:
-            return False
-            
-        try:
-            cap = cv2.VideoCapture(self.video_path)
-            if not cap.isOpened():
-                raise Exception("Cannot open video")
-            
-            fps = cap.get(cv2.CAP_PROP_FPS) or 25
-            self.video_fps = fps
-            total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-            duration = total_frames / fps
-            
-            key_moments.sort(key=lambda x: x['start'])
-            frame_metadata = {}
-            frame_count = 0
-            
-            for i, moment in enumerate(key_moments[:max_frames]):
-                self.update_status(f"Extracting frame {i+1}/{min(len(key_moments), max_frames)}...", 
-                                   25 + int(25 * i / min(len(key_moments), max_frames)))
-                
-                frame_time = (moment['start'] + moment['end']) / 2
-                if frame_time > duration:
-                    continue
-                
-                frame_number = int(frame_time * fps)
-                cap.set(cv2.CAP_PROP_POS_FRAMES, frame_number)
+            cap = cv2.VideoCapture(self.video)
+            self.fps = cap.get(cv2.CAP_PROP_FPS) or 25
+            dur = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) / self.fps
+            
+            meta, cnt = {}, 0
+            for m in moments[:max_n]:
+                t = (m['start'] + m['end']) / 2
+                if t > dur: continue
+                cap.set(cv2.CAP_PROP_POS_FRAMES, int(t * self.fps))
                 ret, frame = cap.read()
-                
                 if ret:
-                    fname = f"frame_{frame_count:04d}.png"
-                    fpath = os.path.join(self.frames_dir, fname)
-                    cv2.imwrite(fpath, frame)
-                    
-                    frame_metadata[fname] = {
-                        'time': frame_time,
-                        'dialogue': moment.get('text', ''),
-                        'start': moment['start'],
-                        'end': moment['end']
-                    }
-                    frame_count += 1
-            
+                    name = f"frame_{cnt:04d}.png"
+                    path = os.path.join(self.frames, name)
+                    cv2.imwrite(path, frame)
+                    enhance(path)
+                    meta[name] = {'time': t, 'text': m.get('text', '')}
+                    cnt += 1
             cap.release()
             
-            with open(self.metadata_path, 'w') as f:
-                json.dump(frame_metadata, f, indent=2)
-            
-            logger.info(f"✅ Extracted {frame_count} keyframes")
+            with open(self.meta, 'w') as f:
+                json.dump(meta, f)
             return True
-            
         except Exception as e:
-            logger.error(f"Keyframe extraction failed: {e}")
+            logger.error(f"Extract error: {e}")
             return False
 
-    def enhance_frames(self):
-        """Enhance all frames"""
-        frame_files = [f for f in os.listdir(self.frames_dir) if f.endswith('.png')]
-        for fname in frame_files:
-            color_enhancer.enhance(os.path.join(self.frames_dir, fname))
-        logger.info("✅ Frame enhancement complete")
-
-    def create_bubbles(self):
-        """Create speech bubbles for frames"""
-        frame_files = sorted([f for f in os.listdir(self.frames_dir) if f.endswith('.png')])
-        
-        metadata = {}
-        if os.path.exists(self.metadata_path):
-            with open(self.metadata_path, 'r') as f:
-                metadata = json.load(f)
-        
-        bubbles_list = []
-        for fname in frame_files:
-            fpath = os.path.join(self.frames_dir, fname)
-            meta = metadata.get(fname, {})
-            dialogue = meta.get('dialogue', '') if isinstance(meta, dict) else ''
-            
-            # Detect faces and place bubbles
-            faces = face_detector.detect_faces(fpath)
-            lip_pos = face_detector.get_lip_position(fpath, faces[0]) if faces else (-1, -1)
-            bx, by = bubble_placer.place(fpath, lip_pos)
-            
-            bubbles_list.append({
-                'dialog': dialogue,
-                'bubble_offset_x': bx,
-                'bubble_offset_y': by,
-                'lip_x': lip_pos[0],
-                'lip_y': lip_pos[1],
-                'emotion': 'normal'
-            })
-        
-        return bubbles_list
-
-    def generate_pages(self, bubbles_list):
-        """Generate comic pages"""
-        frame_files = sorted([f for f in os.listdir(self.frames_dir) if f.endswith('.png')])
+    def pages(self):
+        files = sorted([f for f in os.listdir(self.frames) if f.endswith('.png')])
+        meta = {}
+        if os.path.exists(self.meta):
+            with open(self.meta) as f:
+                meta = json.load(f)
         
-        pages = []
-        panels_per_page = 4
+        result = []
+        for i in range(0, len(files), 4):
+            chunk = files[i:i+4]
+            panels = [{'image': f} for f in chunk]
+            bubbles = [{'dialog': meta.get(f, {}).get('text', ''), 'x': 20, 'y': 15} for f in chunk]
+            result.append({'panels': panels, 'bubbles': bubbles})
         
-        for i in range(0, len(frame_files), panels_per_page):
-            page_frames = frame_files[i:i + panels_per_page]
-            page_bubbles = bubbles_list[i:i + panels_per_page]
-            
-            pages.append({
-                'panels': [{'image': f} for f in page_frames],
-                'bubbles': page_bubbles
-            })
-        
-        return pages
+        with open(os.path.join(self.output, 'pages.json'), 'w') as f:
+            json.dump(result, f)
+        return result
 
-    def save_results(self, pages):
-        """Save results to JSON"""
+    def run(self, progress=None):
         try:
-            output_path = os.path.join(self.output_dir, 'pages.json')
-            with open(output_path, 'w') as f:
-                json.dump(pages, f, indent=2)
-            logger.info("✅ Results saved")
-            return True
-        except Exception as e:
-            logger.error(f"Save failed: {e}")
-            return False
-
-    def generate(self):
-        """Main generation pipeline"""
-        start_time = time.time()
-        
-        try:
-            if cv2 is None:
-                raise Exception("OpenCV not available")
-            
-            self.update_status("Initializing...", 5)
-            self.cleanup()
-            
-            # Analyze video
-            self.update_status("Analyzing video...", 10)
-            cap = cv2.VideoCapture(self.video_path)
-            if not cap.isOpened():
-                raise Exception("Cannot open video")
+            if not cv2: raise Exception("No OpenCV")
+            self.clean()
             
-            self.video_fps = cap.get(cv2.CAP_PROP_FPS) or 25
-            total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-            duration = total_frames / self.video_fps
+            if progress: progress(0.1, desc="Analyzing...")
+            cap = cv2.VideoCapture(self.video)
+            self.fps = cap.get(cv2.CAP_PROP_FPS) or 25
+            dur = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) / self.fps
             cap.release()
-            logger.info(f"📹 Video: {duration:.1f}s @ {self.video_fps:.1f}fps")
             
-            # Transcribe
-            self.update_status("Transcribing audio...", 15)
-            segments = transcribe_with_fallback(self.video_path)
+            if progress: progress(0.2, desc="Transcribing...")
+            segs = transcribe(self.video)
             
-            # Create key moments
-            if segments:
-                key_moments = [{'text': s.get('text', ''), 'start': s.get('start', 0), 'end': s.get('end', 0)} 
-                               for s in segments]
-                logger.info(f"📝 Found {len(key_moments)} dialogue segments")
+            if segs:
+                moments = [{'text': s.get('text', ''), 'start': s.get('start', 0), 'end': s.get('end', 0)} for s in segs]
             else:
-                # Fallback: regular intervals
-                key_moments = [{'text': '', 'start': i * 3, 'end': i * 3 + 3} 
-                               for i in range(min(16, int(duration / 3) + 1))]
-                logger.warning("⚠️ Using fallback keyframes")
-            
-            # Extract frames
-            self.update_status("Extracting keyframes...", 25)
-            if not self.extract_keyframes(key_moments):
-                raise Exception("Keyframe extraction failed")
-            
-            # Enhance
-            self.update_status("Enhancing images...", 55)
-            self.enhance_frames()
+                moments = [{'text': '', 'start': i*3, 'end': i*3+3} for i in range(min(16, int(dur/3)+1))]
             
-            # Create bubbles
-            self.update_status("Placing speech bubbles...", 70)
-            bubbles = self.create_bubbles()
+            if progress: progress(0.5, desc="Extracting frames...")
+            if not self.extract(moments):
+                raise Exception("Extraction failed")
             
-            # Generate pages
-            self.update_status("Generating pages...", 85)
-            pages = self.generate_pages(bubbles)
-            
-            # Save
-            self.update_status("Saving...", 95)
-            self.save_results(pages)
-            
-            elapsed = time.time() - start_time
-            logger.info(f"✅ Done in {elapsed:.1f}s")
-            self.update_status("Complete!", 100)
-            return True
+            if progress: progress(0.9, desc="Creating pages...")
+            pages = self.pages()
             
+            if progress: progress(1.0, desc="Done!")
+            return True, pages
         except Exception as e:
-            logger.error(f"Generation failed: {e}")
-            traceback.print_exc()
-            self.update_status(f"Error: {str(e)}", -1)
-            return False
-
-    def regenerate_frame(self, filename, direction):
-        """Regenerate frame forward/backward"""
-        if cv2 is None:
-            return {"success": False, "message": "OpenCV not available"}
-            
-        try:
-            if not os.path.exists(self.metadata_path):
-                return {"success": False, "message": "No metadata"}
-            
-            with open(self.metadata_path, 'r') as f:
-                meta = json.load(f)
-            
-            if filename not in meta:
-                return {"success": False, "message": "Frame not found"}
-            
-            data = meta[filename]
-            current_time = data['time'] if isinstance(data, dict) else data
-            
-            offset = (1.0 / self.video_fps) * (1 if direction == 'forward' else -1)
-            new_time = max(0, current_time + offset)
-            
-            cap = cv2.VideoCapture(self.video_path)
-            cap.set(cv2.CAP_PROP_POS_MSEC, new_time * 1000)
-            ret, frame = cap.read()
-            cap.release()
-            
-            if ret:
-                fpath = os.path.join(self.frames_dir, filename)
-                cv2.imwrite(fpath, frame)
-                color_enhancer.enhance(fpath)
-                
-                if isinstance(meta[filename], dict):
-                    meta[filename]['time'] = new_time
-                else:
-                    meta[filename] = new_time
-                
-                with open(self.metadata_path, 'w') as f:
-                    json.dump(meta, f, indent=2)
-                
-                return {"success": True, "message": f"Moved to {new_time:.3f}s", "new_time": new_time}
-            
-            return {"success": False, "message": "End of video"}
-            
-        except Exception as e:
-            return {"success": False, "message": str(e)}
-
-    def goto_timestamp(self, filename, timestamp):
-        """Jump to specific timestamp"""
-        if cv2 is None:
-            return {"success": False, "message": "OpenCV not available"}
-            
-        try:
-            cap = cv2.VideoCapture(self.video_path)
-            fps = cap.get(cv2.CAP_PROP_FPS) or 25
-            total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-            duration = total / fps
-            
-            if timestamp < 0 or timestamp > duration:
-                cap.release()
-                return {"success": False, "message": f"Time must be 0-{duration:.1f}s"}
-            
-            cap.set(cv2.CAP_PROP_POS_MSEC, timestamp * 1000)
-            ret, frame = cap.read()
-            cap.release()
-            
-            if ret:
-                fpath = os.path.join(self.frames_dir, filename)
-                cv2.imwrite(fpath, frame)
-                color_enhancer.enhance(fpath)
-                
-                if os.path.exists(self.metadata_path):
-                    with open(self.metadata_path, 'r') as f:
-                        meta = json.load(f)
-                    if filename in meta:
-                        if isinstance(meta[filename], dict):
-                            meta[filename]['time'] = timestamp
-                        else:
-                            meta[filename] = timestamp
-                        with open(self.metadata_path, 'w') as f:
-                            json.dump(meta, f, indent=2)
-                
-                return {"success": True, "message": f"Jumped to {timestamp:.3f}s"}
-            
-            return {"success": False, "message": "Invalid time"}
-        except Exception as e:
-            return {"success": False, "message": str(e)}
-
+            logger.error(f"Error: {e}")
+            return False, str(e)
 
 # ============================================================================
-# 6. GRADIO HANDLERS
+# HANDLERS
 # ============================================================================
 
-def new_session():
-    return str(uuid.uuid4())[:8]
-
-
-def handle_upload(video_file, session_id, progress=gr.Progress()):
-    """Handle video upload"""
-    if video_file is None:
-        return "❌ Please upload a video", session_id, "", gr.update(interactive=True)
+def upload(video, sid, progress=gr.Progress()):
+    if not video:
+        return "❌ Upload a video", "", "", sid
     
-    if not session_id:
-        session_id = new_session()
+    if not sid:
+        sid = str(uuid.uuid4())[:8]
     
-    try:
-        gen = ComicGenerator(session_id)
-        
-        # Copy video
-        if hasattr(video_file, 'name'):
-            shutil.copy(video_file.name, gen.video_path)
-        else:
-            shutil.copy(video_file, gen.video_path)
-        
-        progress(0.05, desc="Starting generation...")
-        
-        # Run generation (synchronous for progress tracking)
-        gen.update_status("Starting...", 5)
-        
-        if cv2 is None:
-            return "❌ OpenCV not available", session_id, "", gr.update(interactive=True)
-        
-        gen.cleanup()
-        
-        # Analyze video
-        progress(0.1, desc="Analyzing video...")
-        cap = cv2.VideoCapture(gen.video_path)
-        if not cap.isOpened():
-            return "❌ Cannot open video", session_id, "", gr.update(interactive=True)
-        
-        gen.video_fps = cap.get(cv2.CAP_PROP_FPS) or 25
-        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-        duration = total_frames / gen.video_fps
-        cap.release()
-        
-        # Transcribe
-        progress(0.15, desc="Transcribing audio (may take a while)...")
-        segments = transcribe_with_fallback(gen.video_path)
-        
-        if segments:
-            key_moments = [{'text': s.get('text', ''), 'start': s.get('start', 0), 'end': s.get('end', 0)} 
-                           for s in segments]
-        else:
-            key_moments = [{'text': '', 'start': i * 3, 'end': i * 3 + 3} 
-                           for i in range(min(16, int(duration / 3) + 1))]
-        
-        # Extract frames
-        progress(0.3, desc="Extracting keyframes...")
-        if not gen.extract_keyframes(key_moments):
-            return "❌ Frame extraction failed", session_id, "", gr.update(interactive=True)
-        
-        # Enhance
-        progress(0.6, desc="Enhancing images...")
-        gen.enhance_frames()
-        
-        # Bubbles
-        progress(0.75, desc="Placing speech bubbles...")
-        bubbles = gen.create_bubbles()
-        
-        # Pages
-        progress(0.9, desc="Generating pages...")
-        pages = gen.generate_pages(bubbles)
-        gen.save_results(pages)
-        
-        progress(1.0, desc="Complete!")
-        
-        # Generate HTML
-        html = generate_comic_html(pages, session_id)
-        
-        return f"✅ Comic generated! ({len(pages)} pages)", session_id, html, gr.update(interactive=True)
-        
-    except Exception as e:
-        logger.error(f"Error: {e}")
-        traceback.print_exc()
-        return f"❌ Error: {str(e)}", session_id, "", gr.update(interactive=True)
-
-
-def generate_comic_html(pages, session_id):
-    """Generate HTML preview"""
-    html = '''
-    <style>
-        .comic-wrapper { max-width: 900px; margin: 0 auto; font-family: 'Comic Sans MS', cursive; }
-        .comic-page { 
-            display: grid; grid-template-columns: 1fr 1fr; gap: 8px;
-            background: #fff; padding: 12px; margin: 15px 0;
-            border: 4px solid #222; border-radius: 8px;
-            box-shadow: 6px 6px 0 #333;
-        }
-        .panel {
-            position: relative; border: 3px solid #333;
-            background: #f0f0f0; min-height: 200px; overflow: hidden;
-        }
-        .panel img { width: 100%; height: 200px; object-fit: cover; }
-        .bubble {
-            position: absolute; top: 8px; left: 8px; right: 8px;
-            background: #fff; border: 2px solid #000; border-radius: 18px;
-            padding: 8px 12px; font-size: 13px; font-weight: bold;
-            box-shadow: 2px 2px 0 #333; max-width: 85%;
-        }
-        .bubble::after {
-            content: ''; position: absolute; bottom: -15px; left: 25px;
-            border: 10px solid transparent; border-top-color: #000;
-        }
-        .page-label { text-align: center; font-size: 20px; font-weight: bold; margin: 10px 0; }
-    </style>
-    <div class="comic-wrapper">
-    '''
+    gen = Generator(sid)
     
-    for idx, page in enumerate(pages):
-        html += f'<div class="page-label">📖 Page {idx + 1}</div>'
-        html += '<div class="comic-page">'
-        
-        panels = page.get('panels', [])
-        bubbles = page.get('bubbles', [])
-        
-        for i, panel in enumerate(panels):
-            img_name = panel.get('image', '')
-            bubble = bubbles[i] if i < len(bubbles) else {}
-            dialog = str(bubble.get('dialog', ''))[:100]
-            
-            img_url = f"/file=/tmp/userdata/{session_id}/frames/{img_name}"
-            
+    src = video.name if hasattr(video, 'name') else video
+    shutil.copy(src, gen.video)
+    
+    ok, result = gen.run(progress)
+    
+    if ok:
+        html = make_html(result, sid)
+        return f"✅ {len(result)} pages created", html, sid, sid
+    return f"❌ {result}", "", "", sid
+
+def make_html(pages, sid):
+    html = '<div style="max-width:800px;margin:auto;font-family:Comic Sans MS,cursive">'
+    for i, p in enumerate(pages):
+        html += f'<h3 style="text-align:center">Page {i+1}</h3>'
+        html += '<div style="display:grid;grid-template-columns:1fr 1fr;gap:8px;background:#fff;padding:10px;border:3px solid #333;margin-bottom:20px">'
+        for j, panel in enumerate(p['panels']):
+            img = panel['image']
+            txt = p['bubbles'][j]['dialog'][:80] if j < len(p['bubbles']) else ''
             html += f'''
-            <div class="panel" data-filename="{img_name}">
-                <img src="{img_url}" alt="Panel {i+1}" onerror="this.src='data:image/svg+xml,<svg xmlns=%22http://www.w3.org/2000/svg%22 width=%22300%22 height=%22200%22><rect fill=%22%23ddd%22 width=%22300%22 height=%22200%22/><text x=%2250%25%22 y=%2250%25%22 text-anchor=%22middle%22 dy=%22.3em%22 fill=%22%23999%22>Panel {i+1}</text></svg>'">
-                {f'<div class="bubble">{dialog}</div>' if dialog else ''}
-            </div>
-            '''
-        
+            <div style="position:relative;border:2px solid #333;min-height:180px;background:#eee">
+                <img src="/file=/tmp/userdata/{sid}/frames/{img}" style="width:100%;height:180px;object-fit:cover" onerror="this.style.display='none'">
+                {f'<div style="position:absolute;top:5px;left:5px;right:5px;background:#fff;border:2px solid #000;border-radius:12px;padding:6px;font-size:11px">{txt}</div>' if txt else ''}
+            </div>'''
         html += '</div>'
-    
     html += '</div>'
     return html
 
-
-def save_comic_handler(session_id):
-    """Save comic and return code"""
-    if not session_id:
-        return "❌ No session", ""
-    
+def save(sid):
+    if not sid: return "No comic", ""
     try:
-        gen = ComicGenerator(session_id)
-        pages_path = os.path.join(gen.output_dir, 'pages.json')
-        
-        if not os.path.exists(pages_path):
-            return "❌ No comic to save", ""
+        gen = Generator(sid)
+        pf = os.path.join(gen.output, 'pages.json')
+        if not os.path.exists(pf): return "Nothing to save", ""
         
-        with open(pages_path, 'r') as f:
+        with open(pf) as f:
             pages = json.load(f)
         
-        save_code = generate_save_code()
-        save_dir = os.path.join(SAVED_COMICS_DIR, save_code)
-        os.makedirs(save_dir, exist_ok=True)
+        code = gen_code()
+        sdir = os.path.join(SAVED_COMICS_DIR, code)
+        os.makedirs(sdir, exist_ok=True)
         
-        # Copy frames
-        if os.path.exists(gen.frames_dir):
-            saved_frames = os.path.join(save_dir, 'frames')
-            if os.path.exists(saved_frames):
-                shutil.rmtree(saved_frames)
-            shutil.copytree(gen.frames_dir, saved_frames)
+        if os.path.exists(gen.frames):
+            shutil.copytree(gen.frames, os.path.join(sdir, 'frames'), dirs_exist_ok=True)
         
-        # Save state
-        save_data = {
-            'code': save_code,
-            'sid': session_id,
-            'pages': pages,
-            'savedAt': time.strftime('%Y-%m-%d %H:%M:%S')
-        }
-        
-        with open(os.path.join(save_dir, 'state.json'), 'w') as f:
-            json.dump(save_data, f, indent=2)
-        
-        logger.info(f"💾 Saved: {save_code}")
-        return f"✅ Saved! Your code:", save_code
+        with open(os.path.join(sdir, 'state.json'), 'w') as f:
+            json.dump({'sid': sid, 'pages': pages}, f)
         
+        return "✅ Saved!", code
     except Exception as e:
-        logger.error(f"Save error: {e}")
-        return f"❌ Error: {e}", ""
-
+        return f"Error: {e}", ""
 
-def load_comic_handler(code):
-    """Load comic from code"""
-    if not code:
-        return "❌ Enter a code", "", ""
-    
+def load(code):
     code = code.strip().upper()
-    save_dir = os.path.join(SAVED_COMICS_DIR, code)
-    state_file = os.path.join(save_dir, 'state.json')
-    
-    if not os.path.exists(state_file):
-        return "❌ Code not found", "", ""
+    sf = os.path.join(SAVED_COMICS_DIR, code, 'state.json')
+    if not os.path.exists(sf): return "Not found", "", ""
     
     try:
-        with open(state_file, 'r') as f:
+        with open(sf) as f:
             data = json.load(f)
         
-        sid = data.get('sid', '')
-        pages = data.get('pages', [])
+        sid = data['sid']
+        frames_src = os.path.join(SAVED_COMICS_DIR, code, 'frames')
+        frames_dst = os.path.join(BASE_USER_DIR, sid, 'frames')
+        os.makedirs(frames_dst, exist_ok=True)
         
-        # Restore frames
-        saved_frames = os.path.join(save_dir, 'frames')
-        if sid and os.path.exists(saved_frames):
-            user_frames = os.path.join(BASE_USER_DIR, sid, 'frames')
-            os.makedirs(user_frames, exist_ok=True)
-            for f in os.listdir(saved_frames):
-                src = os.path.join(saved_frames, f)
-                dst = os.path.join(user_frames, f)
-                if not os.path.exists(dst):
-                    shutil.copy2(src, dst)
-        
-        html = generate_comic_html(pages, sid)
-        return f"✅ Loaded comic (saved {data.get('savedAt', 'unknown')})", sid, html
+        if os.path.exists(frames_src):
+            for fn in os.listdir(frames_src):
+                shutil.copy2(os.path.join(frames_src, fn), os.path.join(frames_dst, fn))
         
+        return "✅ Loaded!", make_html(data['pages'], sid), sid
     except Exception as e:
-        return f"❌ Error: {e}", "", ""
-
-
-def adjust_frame(session_id, filename, direction):
-    """Adjust frame timing"""
-    if not session_id or not filename:
-        return "Select a panel first"
-    
-    gen = ComicGenerator(session_id)
-    result = gen.regenerate_frame(filename, direction)
-    return result.get('message', 'Error')
-
-
-def jump_to_time(session_id, filename, time_str):
-    """Jump to timestamp"""
-    if not session_id or not filename:
-        return "Select a panel first"
-    
-    try:
-        if ':' in time_str:
-            parts = time_str.split(':')
-            ts = int(parts[0]) * 60 + float(parts[1])
-        else:
-            ts = float(time_str)
-    except:
-        return "Invalid time format"
-    
-    gen = ComicGenerator(session_id)
-    result = gen.goto_timestamp(filename, ts)
-    return result.get('message', 'Error')
-
+        return f"Error: {e}", "", ""
 
 # ============================================================================
-# 7. GRADIO UI
+# UI
 # ============================================================================
 
-CSS = """
-.main-title { text-align: center; margin-bottom: 20px; }
-.upload-box { border: 2px dashed #ccc; padding: 20px; border-radius: 10px; }
-.comic-output { min-height: 400px; background: #fafafa; border-radius: 8px; padding: 10px; }
-"""
-
-with gr.Blocks(title="🎬 Comic Generator", theme=gr.themes.Soft(), css=CSS) as demo:
-    
-    # State
-    session_state = gr.State("")
-    selected_panel = gr.State("")
-    
-    gr.Markdown("""
-    # 🎬 Video to Comic Generator
-    Transform any video into a comic book with AI-powered transcription!
-    """, elem_classes="main-title")
+with gr.Blocks(title="🎬 Comic Generator", theme=gr.themes.Soft()) as demo:
+    state = gr.State("")
     
-    with gr.Tabs():
-        # TAB 1: Generate
-        with gr.TabItem("🎥 Generate Comic"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    video_input = gr.Video(label="📤 Upload Video")
-                    generate_btn = gr.Button("🚀 Generate Comic", variant="primary", size="lg")
-                    status_text = gr.Textbox(label="Status", interactive=False)
-                    
-                    with gr.Accordion("💾 Save & Load", open=False):
-                        save_btn = gr.Button("💾 Save Comic", variant="secondary")
-                        save_status = gr.Textbox(label="Save Status", interactive=False)
-                        save_code_out = gr.Textbox(label="Your Save Code", interactive=False)
-                        
-                        gr.Markdown("---")
-                        load_code_in = gr.Textbox(label="Enter Code to Load", placeholder="XXXXXXXX")
-                        load_btn = gr.Button("📂 Load Saved Comic")
-                
-                with gr.Column(scale=2):
-                    comic_html = gr.HTML(label="Comic Preview", elem_classes="comic-output")
-        
-        # TAB 2: Edit
-        with gr.TabItem("✏️ Edit Panels"):
-            gr.Markdown("### Panel Adjustment")
-            with gr.Row():
-                panel_input = gr.Textbox(label="Panel Filename", placeholder="frame_0001.png")
-                with gr.Column():
-                    prev_btn = gr.Button("⬅️ Previous Frame")
-                    next_btn = gr.Button("➡️ Next Frame")
-            
-            with gr.Row():
-                time_input = gr.Textbox(label="Jump to Time", placeholder="mm:ss or seconds")
-                goto_btn = gr.Button("⏱️ Go")
-            
-            edit_status = gr.Textbox(label="Result", interactive=False)
-    
-    gr.Markdown("""
-    ---
-    ### 💡 Tips
-    - Keep videos **under 3 minutes** for best results
-    - Clear audio = better transcription
-    - **Login to HuggingFace** for more GPU quota
-    - Save your comic with a **unique code** to continue later!
-    """)
-    
-    # Events
-    generate_btn.click(
-        fn=handle_upload,
-        inputs=[video_input, session_state],
-        outputs=[status_text, session_state, comic_html, generate_btn]
-    )
+    gr.Markdown("# 🎬 Video to Comic Generator\nUpload a video to create a comic!")
     
-    save_btn.click(
-        fn=save_comic_handler,
-        inputs=[session_state],
-        outputs=[save_status, save_code_out]
-    )
+    with gr.Row():
+        with gr.Column(scale=1):
+            vid = gr.Video(label="📤 Upload Video")
+            btn = gr.Button("🚀 Generate", variant="primary", size="lg")
+            status = gr.Textbox(label="Status", interactive=False)
+            
+            gr.Markdown("---")
+            save_btn = gr.Button("💾 Save")
+            code_out = gr.Textbox(label="Save Code", interactive=False)
+            code_in = gr.Textbox(label="Load Code", placeholder="XXXXXXXX")
+            load_btn = gr.Button("📂 Load")
+        
+        with gr.Column(scale=2):
+            html = gr.HTML()
     
-    load_btn.click(
-        fn=load_comic_handler,
-        inputs=[load_code_in],
-        outputs=[status_text, session_state, comic_html]
-    )
+    gr.Markdown("💡 Short videos work best. Login to HF for more GPU time.")
     
-    prev_btn.click(
-        fn=lambda sid, fname: adjust_frame(sid, fname, 'backward'),
-        inputs=[session_state, panel_input],
-        outputs=[edit_status]
-    )
-    
-    next_btn.click(
-        fn=lambda sid, fname: adjust_frame(sid, fname, 'forward'),
-        inputs=[session_state, panel_input],
-        outputs=[edit_status]
-    )
-    
-    goto_btn.click(
-        fn=jump_to_time,
-        inputs=[session_state, panel_input, time_input],
-        outputs=[edit_status]
-    )
-
+    btn.click(upload, [vid, state], [status, html, code_out, state])
+    save_btn.click(save, [state], [status, code_out])
+    load_btn.click(load, [code_in], [status, html, state])
 
 # ============================================================================
-# 8. LAUNCH
+# LAUNCH
 # ============================================================================
 
 if __name__ == "__main__":
-    logger.info("🚀 Starting Comic Generator")
-    logger.info(f"📁 Data: {BASE_USER_DIR}")
-    logger.info(f"💾 Saves: {SAVED_COMICS_DIR}")
-    
     demo.queue(max_size=5).launch(
         server_name="0.0.0.0",
         server_port=7860,
-        show_error=True,
         allowed_paths=["/tmp"]
     )