Update app.py

app.py

@@ -5,12 +5,21 @@ import tempfile
 import shutil
 from pathlib import Path
 from typing import List, Dict, Optional
+import threading
+import signal
 
 import spacy
 import gradio as gr
 from transformers import pipeline
 import torch
 
+# Global timeout handler
+class TimeoutError(Exception):
+    pass
+
+def timeout_handler(signum, frame):
+    raise TimeoutError("Operation timed out")
+
 # ——— spaCy setup for HF Spaces ———
 def setup_spacy():
     """Setup spaCy model with proper error handling for HF Spaces"""
@@ -18,94 +27,116 @@ def setup_spacy():
         nlp = spacy.load("en_core_web_sm")
         return nlp
     except OSError:
-        print("Downloading spaCy model...")
-        try:
-            from spacy.cli import download as spacy_download
-            spacy_download("en_core_web_sm")
-            nlp = spacy.load("en_core_web_sm")
-            return nlp
-        except Exception as e:
-            print(f"Failed to download spaCy model: {e}")
-            return None
+        print("spaCy model not found, using fallback...")
+        return None
 
 nlp = setup_spacy()
 
 
-def retry_on_rate_limit(func, max_retries=2, initial_delay=3, backoff=1.5):
-    def wrapper(*args, **kwargs):
-        delay = initial_delay
-        for attempt in range(max_retries):
-            try:
-                return func(*args, **kwargs)
-            except Exception as e:
-                if "rate limit" in str(e).lower() or "429" in str(e):
-                    if attempt < max_retries - 1:
-                        print(f"Rate limit detected, retrying in {delay}s...")
-                        time.sleep(delay)
-                        delay *= backoff
-                    else:
-                        print("Maximum retries reached for rate limit.")
-                        raise
-                else:
-                    # For non-rate-limit errors, raise immediately
-                    raise
-    return wrapper
+def run_with_timeout(func, timeout_seconds, *args, **kwargs):
+    """Run a function with a timeout"""
+    result = [None]
+    exception = [None]
+    
+    def target():
+        try:
+            result[0] = func(*args, **kwargs)
+        except Exception as e:
+            exception[0] = e
+    
+    thread = threading.Thread(target=target)
+    thread.daemon = True
+    thread.start()
+    thread.join(timeout_seconds)
+    
+    if thread.is_alive():
+        # Force cleanup if thread is still running
+        raise TimeoutError(f"Function timed out after {timeout_seconds} seconds")
+    
+    if exception[0]:
+        raise exception[0]
+    
+    return result[0]
 
 
 def check_ffmpeg():
-    """Check if ffmpeg is available in HF Spaces"""
+    """Check if ffmpeg is available"""
     try:
-        subprocess.run(["ffmpeg", "-version"], capture_output=True, check=True)
-        return True
-    except (subprocess.CalledProcessError, FileNotFoundError):
+        result = subprocess.run(["ffmpeg", "-version"], capture_output=True, timeout=10)
+        return result.returncode == 0
+    except:
         return False
 
 
-def chunk_video(input_path: str, chunk_length: int = 180, output_dir: str = None) -> List[Path]:
-    """Chunk video with temporary directory handling for HF Spaces"""
-    if output_dir is None:
-        output_dir = tempfile.mkdtemp(prefix="chunks_")
-    
-    Path(output_dir).mkdir(exist_ok=True)
-    output_pattern = os.path.join(output_dir, "chunk_%03d.mp4")
-    
+def get_video_info(video_path: str) -> Dict:
+    """Get video information using ffprobe"""
     try:
         cmd = [
-            "ffmpeg", "-y", "-i", input_path,
-            "-f", "segment", "-segment_time", str(chunk_length),
-            "-reset_timestamps", "1", "-c", "copy",
-            output_pattern
+            "ffprobe", "-v", "quiet", "-print_format", "json", "-show_format", 
+            "-show_streams", video_path
         ]
-        result = subprocess.run(cmd, capture_output=True, text=True, timeout=300)
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
         
-        if result.returncode != 0:
-            print(f"FFmpeg error: {result.stderr}")
-            return []
+        if result.returncode == 0:
+            import json
+            info = json.loads(result.stdout)
             
-        return sorted(Path(output_dir).glob("chunk_*.mp4"))
-    except subprocess.TimeoutExpired:
-        print("Video chunking timed out")
-        return []
+            # Extract video stream info
+            video_streams = [s for s in info.get('streams', []) if s.get('codec_type') == 'video']
+            audio_streams = [s for s in info.get('streams', []) if s.get('codec_type') == 'audio']
+            
+            duration = float(info.get('format', {}).get('duration', 0))
+            
+            return {
+                'duration': duration,
+                'has_video': len(video_streams) > 0,
+                'has_audio': len(audio_streams) > 0,
+                'video_codec': video_streams[0].get('codec_name') if video_streams else None,
+                'audio_codec': audio_streams[0].get('codec_name') if audio_streams else None
+            }
     except Exception as e:
-        print(f"Error chunking video: {str(e)}")
-        return []
+        print(f"Error getting video info: {e}")
+    
+    return {'duration': 0, 'has_video': False, 'has_audio': False}
 
 
-def extract_audio(video_path: str, audio_path: str) -> bool:
-    """Extract audio with better error handling for HF Spaces"""
+def extract_audio_simple(video_path: str, audio_path: str, start_time: float = 0, duration: float = 180) -> bool:
+    """Extract audio with simpler approach and better error handling"""
     try:
         cmd = [
-            "ffmpeg", "-y", "-i", video_path,
-            "-vn", "-c:a", "pcm_s16le", "-ar", "16000", "-ac", "1",
-            "-t", "180",  # Limit to 3 minutes per chunk
+            "ffmpeg", "-y", 
+            "-ss", str(start_time),  # Start time
+            "-i", video_path,
+            "-t", str(duration),     # Duration
+            "-vn",                   # No video
+            "-acodec", "pcm_s16le",  # Audio codec
+            "-ar", "16000",          # Sample rate
+            "-ac", "1",              # Mono
+            "-f", "wav",             # Output format
             audio_path
         ]
-        result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
         
-        if result.returncode != 0:
-            print(f"Audio extraction error: {result.stderr}")
+        print(f"Extracting audio: {' '.join(cmd)}")
+        
+        result = subprocess.run(
+            cmd, 
+            capture_output=True, 
+            text=True, 
+            timeout=60  # 1 minute timeout
+        )
+        
+        if result.returncode == 0:
+            # Check if file was created and has content
+            if os.path.exists(audio_path) and os.path.getsize(audio_path) > 1000:
+                print(f"Audio extracted successfully: {os.path.getsize(audio_path)} bytes")
+                return True
+            else:
+                print("Audio file created but seems empty")
+                return False
+        else:
+            print(f"FFmpeg error: {result.stderr}")
             return False
-        return True
+            
     except subprocess.TimeoutExpired:
         print("Audio extraction timed out")
         return False
@@ -114,119 +145,83 @@ def extract_audio(video_path: str, audio_path: str) -> bool:
         return False
 
 
-def extract_key_phrases(text: str, top_n: int = 5) -> List[str]:
-    """Extract key phrases with fallback if spaCy is not available"""
-    if nlp is None:
-        # Fallback: simple word extraction
-        words = text.split()
-        key_words = [w for w in words if len(w) > 4 and w.isalpha()]
-        return list(dict.fromkeys(key_words))[:top_n]
-    
-    try:
-        doc = nlp(text)
-        phrases = [chunk.text.strip() for chunk in doc.noun_chunks if len(chunk.text.strip()) > 2]
-        seen = set()
-        unique_phrases = [p for p in phrases if not (p.lower() in seen or seen.add(p.lower()))]
-        return unique_phrases[:top_n]
-    except Exception as e:
-        print(f"Error extracting key phrases: {str(e)}")
-        return []
-
-
-def extract_frame(video_path: str, timestamp: str, output_path: str) -> bool:
-    """Extract frame with timeout for HF Spaces"""
+def transcribe_audio_simple(audio_path: str) -> List[Dict]:
+    """Simple transcription without complex pipeline parameters"""
     try:
-        cmd = ["ffmpeg", "-y", "-i", video_path, "-ss", timestamp, "-frames:v", "1", "-q:v", "2", output_path]
-        result = subprocess.run(cmd, capture_output=True, text=True, timeout=15)
+        print(f"Starting transcription of {audio_path}")
         
-        if result.returncode != 0:
-            return False
-        return True
-    except (subprocess.TimeoutExpired, Exception):
-        return False
-
-
-@retry_on_rate_limit
-def transcribe_audio(asr_pipeline, audio_path: str) -> List[Dict]:
-    """Transcribe audio with improved error handling"""
-    try:
-        # Use the pipeline with proper parameters
-        result = asr_pipeline(
-            audio_path,
-            return_timestamps=True,
-            chunk_length_s=30,
-            stride_length_s=5
-        )
+        # Use a simpler approach
+        import whisper
         
-        if isinstance(result, dict):
-            if "chunks" in result:
-                return result["chunks"]
-            else:
-                # Handle single result
-                text = result.get("text", "")
-                timestamps = result.get("timestamps", [(0.0, 30.0)])
-                if isinstance(timestamps, list) and len(timestamps) > 0:
-                    return [{"text": text, "timestamp": timestamps[0]}]
-                else:
-                    return [{"text": text, "timestamp": (0.0, 30.0)}]
-        elif isinstance(result, list):
-            # Handle list of results
+        # Load smaller model
+        model = whisper.load_model("tiny")
+        
+        # Transcribe with timeout
+        def do_transcribe():
+            result = model.transcribe(audio_path, language="en")
+            return result
+        
+        result = run_with_timeout(do_transcribe, 120)  # 2 minute timeout
+        
+        if result and "segments" in result:
             segments = []
-            for i, item in enumerate(result):
-                if isinstance(item, dict):
-                    segments.append({
-                        "text": item.get("text", ""),
-                        "timestamp": item.get("timestamp", (i*30, (i+1)*30))
-                    })
+            for seg in result["segments"]:
+                segments.append({
+                    "text": seg.get("text", "").strip(),
+                    "timestamp": (seg.get("start", 0), seg.get("end", 30))
+                })
             return segments
+        elif result and "text" in result:
+            return [{"text": result["text"], "timestamp": (0, 30)}]
         else:
-            return [{"text": str(result), "timestamp": (0.0, 30.0)}]
+            return [{"text": "Transcription failed", "timestamp": (0, 30)}]
             
     except Exception as e:
         print(f"Transcription error: {str(e)}")
-        return [{"text": "Transcription failed", "timestamp": (0.0, 30.0)}]
+        return [{"text": f"Transcription failed: {str(e)}", "timestamp": (0, 30)}]
 
 
-@retry_on_rate_limit
-def summarize_text(summarizer_pipeline, text: str) -> str:
-    """Summarize text with proper length handling"""
-    if not text.strip():
-        return "No content to summarize."
+def extract_key_phrases_simple(text: str, top_n: int = 5) -> List[str]:
+    """Simple key phrase extraction"""
+    if not text:
+        return []
     
-    # Clean and prepare text
-    text = text.strip()
+    # Simple approach: extract longer words
     words = text.split()
+    # Filter for meaningful words
+    key_words = [
+        w.strip('.,!?";') for w in words 
+        if len(w) > 4 and w.isalpha() and w.lower() not in {
+            'this', 'that', 'with', 'have', 'will', 'from', 'they', 'been', 
+            'were', 'said', 'each', 'which', 'their', 'time', 'would', 'there'
+        }
+    ]
+    
+    # Remove duplicates while preserving order
+    seen = set()
+    unique_words = [w for w in key_words if not (w.lower() in seen or seen.add(w.lower()))]
     
-    # Skip very short texts
-    if len(words) < 10:
-        return text  # Return original if too short
+    return unique_words[:top_n]
+
+
+def summarize_text_simple(text: str) -> str:
+    """Simple text summarization"""
+    if not text or len(text.split()) < 10:
+        return text
     
-    # Truncate if too long
-    if len(words) > 500:
-        text = " ".join(words[:500])
+    # Simple approach: take first and last sentences, or middle part
+    sentences = text.split('.')
+    sentences = [s.strip() for s in sentences if s.strip()]
     
-    try:
-        # Calculate appropriate lengths
-        input_length = len(words)
-        max_new_tokens = min(100, max(20, input_length // 3))
-        min_length = min(15, max(5, input_length // 8))
-        
-        result = summarizer_pipeline(
-            text,
-            max_new_tokens=max_new_tokens,
-            min_length=min_length,
-            do_sample=False,
-            early_stopping=True
-        )
-        
-        if isinstance(result, list) and len(result) > 0:
-            summary = result[0]["summary_text"].strip()
-            return summary if summary else text
+    if len(sentences) <= 2:
         return text
-        
-    except Exception as e:
-        print(f"Summarization error: {str(e)}")
-        return text  # Return original text if summarization fails
+    elif len(sentences) <= 5:
+        return '. '.join(sentences[:2]) + '.'
+    else:
+        # Take first, middle, and last sentences
+        middle_idx = len(sentences) // 2
+        summary_sentences = [sentences[0], sentences[middle_idx], sentences[-1]]
+        return '. '.join(summary_sentences) + '.'
 
 
 def format_timestamp(seconds: float) -> str:
@@ -236,168 +231,201 @@ def format_timestamp(seconds: float) -> str:
     return f"{minutes:02d}:{remaining_seconds:02d}"
 
 
+def process_video_segment(video_path: str, start_time: float, duration: float, segment_id: int, temp_dir: str) -> Dict:
+    """Process a single video segment"""
+    try:
+        print(f"Processing segment {segment_id}: {start_time}s - {start_time + duration}s")
+        
+        # Create audio file path
+        audio_path = os.path.join(temp_dir, f"segment_{segment_id:03d}.wav")
+        
+        # Extract audio for this segment
+        if not extract_audio_simple(video_path, audio_path, start_time, duration):
+            return {
+                "segment": segment_id,
+                "start_time": format_timestamp(start_time),
+                "end_time": format_timestamp(start_time + duration),
+                "text": "Audio extraction failed",
+                "summary": "Failed to process this segment",
+                "key_phrases": []
+            }
+        
+        # Transcribe audio
+        segments = transcribe_audio_simple(audio_path)
+        
+        # Combine all text from segments
+        full_text = " ".join([seg["text"] for seg in segments if seg["text"]])
+        
+        # Clean up audio file
+        try:
+            os.remove(audio_path)
+        except:
+            pass
+        
+        if not full_text.strip():
+            return {
+                "segment": segment_id,
+                "start_time": format_timestamp(start_time),
+                "end_time": format_timestamp(start_time + duration),
+                "text": "No speech detected",
+                "summary": "No content in this segment",
+                "key_phrases": []
+            }
+        
+        # Generate summary and key phrases
+        summary = summarize_text_simple(full_text)
+        key_phrases = extract_key_phrases_simple(full_text)
+        
+        return {
+            "segment": segment_id,
+            "start_time": format_timestamp(start_time),
+            "end_time": format_timestamp(start_time + duration),
+            "text": full_text,
+            "summary": summary,
+            "key_phrases": key_phrases
+        }
+        
+    except Exception as e:
+        print(f"Error processing segment {segment_id}: {str(e)}")
+        return {
+            "segment": segment_id,
+            "start_time": format_timestamp(start_time),
+            "end_time": format_timestamp(start_time + duration),
+            "text": f"Processing failed: {str(e)}",
+            "summary": "Error occurred during processing",
+            "key_phrases": []
+        }
+
+
 def run_pipeline(video_file: str, progress=gr.Progress()) -> List[Dict]:
-    """Main pipeline function optimized for HF Spaces"""
+    """Main pipeline function with better error handling and debugging"""
     if not video_file:
         return [{"error": "No video file provided"}]
     
+    print(f"Processing video: {video_file}")
+    
     # Check if ffmpeg is available
     if not check_ffmpeg():
         return [{"error": "FFmpeg is not available in this environment"}]
     
-    progress(0.1, desc="Initializing models...")
+    progress(0.1, desc="Analyzing video...")
     
-    # Initialize models with proper configuration
-    try:
-        # Configure Whisper with proper settings
-        asr = pipeline(
-            "automatic-speech-recognition",
-            model="openai/whisper-tiny",  # Use tiny model for better compatibility
-            device=0 if torch.cuda.is_available() else -1,
-            model_kwargs={
-                "attn_implementation": "eager"  # Fix attention implementation warning
-            }
-        )
-        progress(0.2, desc="ASR model loaded...")
-        
-        # Configure BART with proper settings
-        summarizer = pipeline(
-            "summarization",
-            model="facebook/bart-large-cnn",
-            device=0 if torch.cuda.is_available() else -1
-        )
-        progress(0.3, desc="Summarization model loaded...")
-        
-    except Exception as e:
-        return [{"error": f"Failed to load models: {str(e)}"}]
-
-    # Create temporary directories
+    # Get video information
+    video_info = get_video_info(video_file)
+    print(f"Video info: {video_info}")
+    
+    if not video_info['has_audio']:
+        return [{"error": "Video has no audio track"}]
+    
+    duration = video_info['duration']
+    if duration == 0:
+        return [{"error": "Could not determine video duration"}]
+    
+    # Limit processing time for HF Spaces
+    max_duration = min(duration, 600)  # Max 10 minutes
+    segment_length = 120  # 2 minutes per segment
+    
+    progress(0.2, desc=f"Video duration: {duration:.1f}s, processing {max_duration:.1f}s...")
+    
+    # Create temporary directory
     temp_dir = tempfile.mkdtemp(prefix="lecture_capture_")
-    chunks_dir = os.path.join(temp_dir, "chunks")
-    frames_dir = os.path.join(temp_dir, "frames")
     
     try:
-        Path(chunks_dir).mkdir(exist_ok=True)
-        Path(frames_dir).mkdir(exist_ok=True)
-        
-        progress(0.4, desc="Processing video chunks...")
-        
-        # Process video with shorter chunks
-        chunks = chunk_video(video_file, chunk_length=180, output_dir=chunks_dir)
-        if not chunks:
-            return [{"error": "No video chunks were created. Video may be corrupted or unsupported format."}]
-        
-        # Limit number of chunks for HF Spaces
-        chunks = chunks[:5]  # Process max 5 chunks (15 minutes)
-        
-        progress(0.5, desc=f"Processing {len(chunks)} chunks...")
+        # Calculate segments
+        segments_to_process = []
+        current_time = 0
+        segment_id = 1
         
-        # Process each chunk
-        all_segments = []
-        for i, chunk in enumerate(chunks):
-            progress(0.5 + (0.3 * i / len(chunks)), desc=f"Processing chunk {i+1}/{len(chunks)}...")
+        while current_time < max_duration:
+            remaining_time = max_duration - current_time
+            actual_duration = min(segment_length, remaining_time)
             
-            wav_path = str(chunk).replace(".mp4", ".wav")
-            
-            # Extract audio
-            if not extract_audio(str(chunk), wav_path):
-                print(f"Failed to extract audio from chunk {i}")
-                continue
-            
-            # Transcribe with better error handling
-            try:
-                chunk_segments = transcribe_audio(asr, wav_path)
-                
-                # Calculate absolute timestamps
-                chunk_start_time = i * 180  # 180 seconds per chunk
-                
-                for seg in chunk_segments:
-                    timestamp = seg.get("timestamp", (0.0, 30.0))
-                    if isinstance(timestamp, tuple) and len(timestamp) == 2:
-                        start_time = chunk_start_time + timestamp[0]
-                        end_time = chunk_start_time + timestamp[1]
-                    else:
-                        start_time = chunk_start_time
-                        end_time = chunk_start_time + 30
-                    
-                    text = seg.get("text", "").strip()
-                    if text:  # Only add non-empty segments
-                        all_segments.append({
-                            "text": text,
-                            "start": format_timestamp(start_time),
-                            "end": format_timestamp(end_time),
-                            "start_seconds": start_time,
-                            "end_seconds": end_time
-                        })
-                        
-            except Exception as e:
-                print(f"Error processing chunk {i}: {str(e)}")
-                continue
+            segments_to_process.append({
+                'start_time': current_time,
+                'duration': actual_duration,
+                'segment_id': segment_id
+            })
             
-            # Clean up audio file immediately
-            try:
-                os.remove(wav_path)
-            except:
-                pass
-        
-        if not all_segments:
-            return [{"error": "No segments were successfully processed"}]
-        
-        progress(0.8, desc="Generating summaries and extracting key phrases...")
+            current_time += actual_duration
+            segment_id += 1
         
-        # Sort segments by start time
-        all_segments.sort(key=lambda x: x["start_seconds"])
+        print(f"Will process {len(segments_to_process)} segments")
         
-        # Generate timeline (limit to 15 segments for HF Spaces)
+        # Process each segment
         timeline = []
-        for i, segment in enumerate(all_segments[:15]):
-            segment_text = segment["text"]
+        for i, seg_info in enumerate(segments_to_process):
+            progress(
+                0.3 + (0.6 * i / len(segments_to_process)), 
+                desc=f"Processing segment {i+1}/{len(segments_to_process)}..."
+            )
             
-            # Generate summary
             try:
-                summary = summarize_text(summarizer, segment_text) if len(segment_text.split()) > 5 else segment_text
+                result = run_with_timeout(
+                    process_video_segment,
+                    300,  # 5 minute timeout per segment
+                    video_file,
+                    seg_info['start_time'],
+                    seg_info['duration'],
+                    seg_info['segment_id'],
+                    temp_dir
+                )
+                timeline.append(result)
+                
+            except TimeoutError:
+                print(f"Segment {i+1} timed out")
+                timeline.append({
+                    "segment": seg_info['segment_id'],
+                    "start_time": format_timestamp(seg_info['start_time']),
+                    "end_time": format_timestamp(seg_info['start_time'] + seg_info['duration']),
+                    "text": "Processing timed out",
+                    "summary": "Segment processing exceeded time limit",
+                    "key_phrases": []
+                })
             except Exception as e:
-                summary = segment_text
-            
-            # Extract key phrases
-            key_phrases = extract_key_phrases(segment_text) if segment_text else []
-            
-            timeline.append({
-                "segment": i + 1,
-                "start_time": segment["start"],
-                "end_time": segment["end"],
-                "text": segment_text,
-                "summary": summary,
-                "key_phrases": key_phrases
-            })
+                print(f"Error processing segment {i+1}: {str(e)}")
+                timeline.append({
+                    "segment": seg_info['segment_id'],
+                    "start_time": format_timestamp(seg_info['start_time']),
+                    "end_time": format_timestamp(seg_info['start_time'] + seg_info['duration']),
+                    "text": f"Error: {str(e)}",
+                    "summary": "Processing failed",
+                    "key_phrases": []
+                })
         
         progress(1.0, desc="Processing complete!")
+        
+        if not timeline:
+            return [{"error": "No segments were successfully processed"}]
+        
         return timeline
-    
+        
     except Exception as e:
         import traceback
-        return [{"error": f"Pipeline failed: {str(e)}", "details": traceback.format_exc()}]
+        print(f"Pipeline error: {str(e)}")
+        print(traceback.format_exc())
+        return [{"error": f"Pipeline failed: {str(e)}"}]
     
     finally:
         # Clean up temporary files
         try:
             shutil.rmtree(temp_dir)
+            print("Cleaned up temporary files")
         except Exception as e:
             print(f"Failed to clean up temp directory: {str(e)}")
 
 
-# ——— Gradio UI optimized for HF Spaces ———
+# ——— Gradio UI ———
 def create_interface():
     with gr.Blocks(title="Lecture Capture AI Pipeline", theme=gr.themes.Soft()) as demo:
         gr.Markdown("""
-        # 🎓 Lecture Capture AI Pipeline
+        # 🎓 Lecture Capture AI Pipeline (Debug Version)
         
         Upload a lecture video to automatically generate:
         - 📝 Transcription with timestamps
         - 📋 Summaries for each segment  
         - 🔑 Key phrases extraction
         
-        **Note**: Optimized for Hugging Face Spaces. Processing limited to 15 minutes of video.
+        **Debug Features**: Enhanced error reporting and timeout handling
         """)
         
         with gr.Row():
@@ -415,10 +443,10 @@ def create_interface():
                 
                 gr.Markdown("""
                 ### 💡 Tips:
-                - Videos up to 15 minutes work best
-                - Clear audio improves transcription quality
+                - Videos up to 10 minutes work best
+                - Clear audio improves results
                 - Processing takes 2-5 minutes
-                - Supported formats: MP4, AVI, MOV
+                - Check browser console for debug info
                 """)
             
             with gr.Column(scale=2):
@@ -435,11 +463,11 @@ def create_interface():
         )
         
         gr.Markdown("""
-        ### 🔧 Technical Details:
-        - Uses Whisper (tiny) for speech recognition
-        - BART for text summarization  
-        - spaCy for key phrase extraction
-        - Optimized for Hugging Face Spaces environment
+        ### 🔧 Debug Info:
+        - Uses direct Whisper model loading
+        - Enhanced timeout handling
+        - Detailed error reporting
+        - Segment-by-segment processing
         """)
     
     return demo
@@ -447,4 +475,4 @@ def create_interface():
 
 if __name__ == "__main__":
     demo = create_interface()
-    demo.launch()
+    demo.launch(debug=True)