Fix import issue

README.md

@@ -1,46 +1,35 @@
 ---
-title: Detect English Language Speaking
-emoji: 🔥
-colorFrom: red
-colorTo: yellow
+title: Video Accent Analyzer
+emoji: 🎧
+colorFrom: green
+colorTo: blue
 sdk: gradio
-sdk_version: 5.31.0
+sdk_version: 4.0.0
 app_file: app.py
 pinned: false
-license: mit
-short_description: 'a  tools to automate real hiring decisions. '
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
-# 🎧 Video Accent Analyzer
+# Video Accent Analyzer
 
-Analyze accents in videos from YouTube, Loom, or uploaded files. Supports multiple English accents.
+This application analyzes English accents in videos using machine learning. It supports:
+- YouTube videos
+- Loom recordings
+- Direct video links
+- Uploaded video files
 
 ## Features
-- YouTube video analysis
-- Loom video analysis
-- Direct MP4 link support
-- Local file upload
-- Multiple English accent detection
-
-## Requirements
-- Python 3.8+
-- FFmpeg
-- PyTorch
-- Transformers
+- Accent detection with confidence scores
+- English proficiency assessment
+- Interactive visualizations
+- Support for multiple video sources
 
 ## Usage
-1. Enter a video URL or upload a file
-2. Get instant accent analysis results
-
-"""
-Enhanced  Video Accent Analyzer
-Supports YouTube, Loom, direct MP4 links, and local video files with improved error handling and features.
+1. Enter a video URL or upload a video file
+2. Set the maximum duration to analyze
+3. Click "Analyze Video"
+4. View the detailed results and visualization
 
-Usage:
-    analyzer = VideoAccentAnalyzer()
-    results = analyzer.analyze_video_url("https://example.com/video.mp4", max_duration=30)
-    or
-    results = analyzer.analyze_local_video("/local/input/video.mp4", max_duration=30)
-    analyzer.display_results(results)
-"""
+## Tips
+- Keep videos under 2 minutes for best results
+- Ensure clear audio quality
+- Multiple speakers may affect accuracy

api.py

@@ -0,0 +1,101 @@
+from flask import Flask, request, jsonify, render_template
+from video_accent_analyzer import VideoAccentAnalyzer
+import plotly
+import json
+import os
+
+app = Flask(__name__)
+analyzer = VideoAccentAnalyzer()
+
+@app.route('/')
+def home():
+    return render_template('index.html')
+
+@app.route('/api/analyze', methods=['POST'])
+def analyze():
+    try:
+        data = request.json
+        url = data.get('url')
+        duration = int(data.get('duration', 30))
+
+        if not url:
+            return jsonify({'error': 'No URL provided'}), 400
+
+        # Initialize analyzer with display=False to avoid IPython dependency
+        result = analyzer.analyze_video_url(url, max_duration=duration)
+
+        if 'error' in result:
+            return jsonify({'error': result['error']}), 400
+
+        # Create Plotly figure
+        probabilities = result['all_probabilities']
+        accents = [analyzer.accent_display_names.get(acc, acc.title())
+                  for acc in probabilities.keys()]
+        probs = list(probabilities.values())
+
+        # Format detailed results
+        accent = result['predicted_accent']
+        confidence = result['accent_confidence']
+        english_conf = result['english_confidence']
+
+        details = {
+            'primary_classification': {
+                'accent': analyzer.accent_display_names.get(accent, accent.title()),
+                'confidence': f"{confidence:.1f}%",
+                'english_confidence': f"{english_conf:.1f}%"
+            },
+            'audio_analysis': {
+                'duration': f"{result['audio_duration']:.1f}s",
+                'quality_score': result.get('audio_quality_score', 'N/A'),
+                'chunks_analyzed': result.get('chunks_analyzed', 1)
+            },
+            'assessment': {
+                'english_level': 'Strong' if english_conf >= 70 else 'Moderate' if english_conf >= 50 else 'Low',
+                'confidence_level': 'High' if confidence >= 70 else 'Moderate' if confidence >= 50 else 'Low'
+            }
+        }
+
+        # Add visualization data
+        plot_data = {
+            'data': [{
+                'type': 'bar',
+                'x': accents,
+                'y': probs,
+                'text': [f'{p:.1f}%' for p in probs],
+                'textposition': 'auto',
+                'marker': {
+                    'color': ['#4CAF50' if p == max(probs) else '#2196F3'
+                             if p >= 20 else '#FFC107' if p >= 10 else '#9E9E9E'
+                             for p in probs]
+                }
+            }],
+            'layout': {
+                'title': 'Accent Probability Distribution',
+                'xaxis': {'title': 'Accent Type'},
+                'yaxis': {'title': 'Probability (%)', 'range': [0, 100]},
+                'template': 'plotly_white'
+            }
+        }
+
+        # Combine all results
+        response = {
+            'details': details,
+            'plot': plot_data,
+            'raw_results': result
+        }
+
+        return jsonify(response)
+
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/api/cleanup', methods=['POST'])
+def cleanup():
+    try:
+        analyzer.cleanup()
+        return jsonify({'message': 'Cleanup successful'})
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+if __name__ == '__main__':
+    app.run(debug=True)

app.py

@@ -155,17 +155,19 @@ with gr.Blocks(css=css) as interface:
 
 # Add requirements.txt
 requirements = """
-    gradio>=4.0.0
-    plotly>=5.0.0
-    yt-dlp
-    librosa
-    soundfile
-    transformers
-    torch
-    ffmpeg-python
-    matplotlib
-    seaborn
-    """
+gradio>=4.0.0
+plotly>=5.0.0
+yt-dlp
+librosa
+soundfile
+transformers
+torch
+ffmpeg-python
+matplotlib
+seaborn
+pandas
+ipython
+"""
 
 with open("requirements.txt", "w") as f:
     f.write(requirements)

templates/index.html

@@ -0,0 +1,155 @@
+<!-- templates/index.html -->
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Video Accent Analyzer</title>
+    <script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
+    <style>
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            max-width: 1000px;
+            margin: 0 auto;
+            padding: 20px;
+            background-color: #f5f5f5;
+        }
+        .container {
+            background: white;
+            padding: 20px;
+            border-radius: 10px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+        .input-group {
+            margin-bottom: 20px;
+        }
+        input, button {
+            padding: 10px;
+            margin: 5px 0;
+            border-radius: 5px;
+            border: 1px solid #ddd;
+        }
+        input[type="text"] {
+            width: 100%;
+            box-sizing: border-box;
+        }
+        button {
+            background: linear-gradient(45deg, #4CAF50, #2196F3);
+            color: white;
+            border: none;
+            cursor: pointer;
+            transition: transform 0.2s;
+        }
+        button:hover {
+            transform: scale(1.02);
+        }
+        #results {
+            margin-top: 20px;
+            padding: 20px;
+            border-radius: 5px;
+            background-color: #f8f9fa;
+        }
+        .error {
+            color: red;
+            padding: 10px;
+            background-color: #fee;
+            border-radius: 5px;
+        }
+        #plot {
+            margin-top: 20px;
+        }
+        .metric {
+            display: inline-block;
+            padding: 10px;
+            margin: 5px;
+            background: #fff;
+            border-radius: 5px;
+            box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>🎧 Video Accent Analyzer</h1>
+
+        <div class="input-group">
+            <input type="text" id="videoUrl" placeholder="Enter YouTube, Loom, or direct video URL">
+            <input type="number" id="duration" value="30" min="10" max="120" step="10">
+            <button onclick="analyzeVideo()">Analyze Video</button>
+        </div>
+
+        <div id="loading" style="display: none;">
+            Analyzing video... Please wait...
+        </div>
+
+        <div id="results" style="display: none;"></div>
+        <div id="plot"></div>
+    </div>
+
+    <script>
+        async function analyzeVideo() {
+            const url = document.getElementById('videoUrl').value;
+            const duration = document.getElementById('duration').value;
+            const loading = document.getElementById('loading');
+            const results = document.getElementById('results');
+            const plot = document.getElementById('plot');
+
+            if (!url) {
+                alert('Please enter a video URL');
+                return;
+            }
+
+            loading.style.display = 'block';
+            results.style.display = 'none';
+            plot.innerHTML = '';
+
+            try {
+                const response = await fetch('/api/analyze', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({ url, duration }),
+                });
+
+                const data = await response.json();
+
+                if (data.error) {
+                    results.innerHTML = `<div class="error">Error: ${data.error}</div>`;
+                    results.style.display = 'block';
+                    return;
+                }
+
+                // Display results
+                results.innerHTML = `
+                    <h2>Analysis Results</h2>
+                    <div class="metric">
+                        <strong>Predicted Accent:</strong><br>
+                        ${data.predicted_accent}
+                    </div>
+                    <div class="metric">
+                        <strong>Confidence:</strong><br>
+                        ${data.accent_confidence.toFixed(1)}%
+                    </div>
+                    <div class="metric">
+                        <strong>English Confidence:</strong><br>
+                        ${data.english_confidence.toFixed(1)}%
+                    </div>
+                    <div class="metric">
+                        <strong>Audio Duration:</strong><br>
+                        ${data.audio_duration.toFixed(1)}s
+                    </div>
+                `;
+
+                // Create plot
+                Plotly.newPlot('plot', data.plot.data, data.plot.layout);
+                results.style.display = 'block';
+
+            } catch (error) {
+                results.innerHTML = `<div class="error">Error: ${error.message}</div>`;
+                results.style.display = 'block';
+            } finally {
+                loading.style.display = 'none';
+            }
+        }
+    </script>
+</body>
+</html>

video_accent_analyzer.py

@@ -22,6 +22,7 @@ import seaborn as sns
 # Suppress warnings for cleaner output
 warnings.filterwarnings('ignore')
 
+
 def install_if_missing(packages):
     """Install packages if they're not already available in Kaggle"""
     for package in packages:
@@ -34,6 +35,7 @@ def install_if_missing(packages):
             print(f"Installing {package}...")
             subprocess.check_call([sys.executable, "-m", "pip", "install", package, "--quiet"])
 
+
 # Required packages for Kaggle
 required_packages = [
     "yt-dlp",
@@ -55,6 +57,7 @@ import librosa
 import soundfile as sf
 import yt_dlp
 
+
 class VideoAccentAnalyzer:
     def __init__(self, model_name="dima806/multiple_accent_classification"):
         """Initialize the accent analyzer for Kaggle environment"""
@@ -103,20 +106,19 @@ class VideoAccentAnalyzer:
 
         return True, url
 
-
     def trim_video(self, input_path, output_path, duration):
-       try:
-        cmd = ['ffmpeg', '-i', input_path, '-t', str(duration), '-c', 'copy', output_path, '-y']
-        result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
-        if result.returncode == 0:
-            print(f"✂️ Trimmed video to {duration} seconds")
-            return output_path
-        else:
-            print(f"❌ Trimming failed: {result.stderr}")
-            return input_path  # fallback to original
-       except Exception as e:
-        print(f"❌ Trimming exception: {e}")
-        return input_path
+        try:
+            cmd = ['ffmpeg', '-i', input_path, '-t', str(duration), '-c', 'copy', output_path, '-y']
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
+            if result.returncode == 0:
+                print(f"✂️ Trimmed video to {duration} seconds")
+                return output_path
+            else:
+                print(f"❌ Trimming failed: {result.stderr}")
+                return input_path  # fallback to original
+        except Exception as e:
+            print(f"❌ Trimming exception: {e}")
+            return input_path
 
     def download_video(self, url, max_duration=None):
         """Download video using yt-dlp with improved error handling"""
@@ -145,7 +147,7 @@ class VideoAccentAnalyzer:
 
         if max_duration:
             # More generous time limit for download
-         ydl_opts['match_filter'] = lambda info: None if info.get('duration', 0) <= 200000 else "Video too long"
+            ydl_opts['match_filter'] = lambda info: None if info.get('duration', 0) <= 200000 else "Video too long"
 
         try:
             with yt_dlp.YoutubeDL(ydl_opts) as ydl:
@@ -166,9 +168,10 @@ class VideoAccentAnalyzer:
                 # Find downloaded file (try multiple patterns)
                 video_path = None
                 for file in os.listdir(self.temp_dir):
-                    if file.startswith("video.") and os.path.getsize(os.path.join(self.temp_dir, file)) > 1000:  # At least 1KB
+                    if file.startswith("video.") and os.path.getsize(
+                            os.path.join(self.temp_dir, file)) > 1000:  # At least 1KB
                         potential_path = os.path.join(self.temp_dir, file)
-                        print(f"📁 Found downloaded file: {file} ({os.path.getsize(potential_path)/1024:.1f}KB)")
+                        print(f"📁 Found downloaded file: {file} ({os.path.getsize(potential_path) / 1024:.1f}KB)")
 
                         # Try basic validation - if ffprobe fails, still try to extract audio
                         if self._is_valid_video(potential_path):
@@ -254,7 +257,7 @@ class VideoAccentAnalyzer:
                         f.write(chunk)
                         file_size += len(chunk)
 
-            print(f"📁 Downloaded {file_size / (1024*1024):.1f} MB")
+            print(f"📁 Downloaded {file_size / (1024 * 1024):.1f} MB")
 
             if self._is_valid_video(video_path):
                 print("✅ Direct download successful")
@@ -288,7 +291,7 @@ class VideoAccentAnalyzer:
             extraction_time = time.time() - start_time
 
             if result.returncode == 0 and os.path.exists(audio_path) and os.path.getsize(audio_path) > 1000:
-                file_size = os.path.getsize(audio_path) / (1024*1024)
+                file_size = os.path.getsize(audio_path) / (1024 * 1024)
                 print(f"✅ Audio extracted successfully ({extraction_time:.1f}s, {file_size:.1f}MB)")
                 return audio_path
             else:
@@ -298,7 +301,7 @@ class VideoAccentAnalyzer:
                 # Try alternative extraction method
                 print("🔄 Trying alternative audio extraction...")
                 cmd_alt = ['ffmpeg', '-i', video_path, '-vn', '-acodec', 'libmp3lame',
-                          '-ar', '16000', '-ac', '1', '-y', '-v', 'warning']
+                           '-ar', '16000', '-ac', '1', '-y', '-v', 'warning']
                 if max_duration:
                     cmd_alt.extend(['-t', str(max_duration)])
 
@@ -310,11 +313,11 @@ class VideoAccentAnalyzer:
                 if result_alt.returncode == 0 and os.path.exists(audio_path_alt):
                     # Convert mp3 to wav
                     cmd_convert = ['ffmpeg', '-i', audio_path_alt, '-ar', '16000', '-ac', '1',
-                                  audio_path, '-y', '-v', 'quiet']
+                                   audio_path, '-y', '-v', 'quiet']
                     result_convert = subprocess.run(cmd_convert, capture_output=True, text=True, timeout=60)
 
                     if result_convert.returncode == 0 and os.path.exists(audio_path):
-                        file_size = os.path.getsize(audio_path) / (1024*1024)
+                        file_size = os.path.getsize(audio_path) / (1024 * 1024)
                         print(f"✅ Alternative extraction successful ({file_size:.1f}MB)")
                         return audio_path
 
@@ -463,7 +466,7 @@ class VideoAccentAnalyzer:
             return {"error": f"File not found: {file_path}"}
 
         # Check file size
-        file_size = os.path.getsize(file_path) / (1024*1024)  # MB
+        file_size = os.path.getsize(file_path) / (1024 * 1024)  # MB
         print(f"📁 File size: {file_size:.1f} MB")
 
         video_filename = os.path.basename(file_path)
@@ -488,166 +491,121 @@ class VideoAccentAnalyzer:
 
         return results
 
-    def display_results(self, results):
-        """Enhanced results display with visualizations"""
-        if 'error' in results:
-            display(HTML(f"<div style='color: red; font-size: 16px; padding: 10px; border: 1px solid red; border-radius: 5px;'>❌ {results['error']}</div>"))
-            return
-
-        accent = results['predicted_accent']
-        confidence = results['accent_confidence']
-        english_conf = results['english_confidence']
-        duration = results['audio_duration']
-        processed_duration = results.get('processed_duration', duration)
-        quality_score = results.get('audio_quality_score', 50)
-
-        accent_display = self.accent_display_names.get(accent, accent.title())
-
-        # Enhanced HTML display
-        html = f"""
-        <div style='border: 2px solid #4CAF50; border-radius: 10px; padding: 20px; margin: 10px 0; background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);'>
-            <h2 style='color: #2E7D32; margin-top: 0; text-align: center;'>🎯 Accent Analysis Results</h2>
-            
-            <div style='display: flex; flex-wrap: wrap; gap: 20px; margin-bottom: 20px;'>
-                <div style='flex: 1; min-width: 200px; background: white; padding: 15px; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1);'>
-                    <h3 style='color: #1976D2; margin-top: 0;'>🎭 Primary Classification</h3>
-                    <p style='font-size: 20px; margin: 5px 0; font-weight: bold;'>{accent_display}</p>
-                    <p style='margin: 5px 0;'>Confidence: <strong style='color: {"#4CAF50" if confidence >= 70 else "#FF9800" if confidence >= 50 else "#F44336"};'>{confidence:.1f}%</strong></p>
-                </div>
-                
-                <div style='flex: 1; min-width: 200px; background: white; padding: 15px; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1);'>
-                    <h3 style='color: #1976D2; margin-top: 0;'>🌍 English Proficiency</h3>
-                    <p style='font-size: 18px; margin: 5px 0;'><strong style='color: {"#4CAF50" if english_conf >= 70 else "#FF9800" if english_conf >= 50 else "#F44336"};'>{english_conf:.1f}%</strong></p>
-                    <p style='margin: 5px 0;'>Audio Quality: <strong>{quality_score:.0f}/100</strong></p>
-                </div>
-                
-                <div style='flex: 1; min-width: 200px; background: white; padding: 15px; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1);'>
-                    <h3 style='color: #1976D2; margin-top: 0;'>⏱️ Processing Info</h3>
-                    <p style='margin: 5px 0;'>Duration: <strong>{duration:.1f}s</strong></p>
-                    <p style='margin: 5px 0;'>Processed: <strong>{processed_duration:.1f}s</strong></p>
-                    <p style='margin: 5px 0;'>Chunks: <strong>{results.get("chunks_analyzed", 1)}</strong></p>
-                </div>
-            </div>
-            
-            <div style='background: white; padding: 15px; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1);'>
-                <h3 style='color: #1976D2; margin-top: 0;'>📊 Assessment</h3>
-                <div style='display: flex; flex-wrap: wrap; gap: 10px;'>
-                    <span style='background: {"#4CAF50" if english_conf >= 70 else "#FF9800" if english_conf >= 50 else "#F44336"}; color: white; padding: 5px 10px; border-radius: 15px; font-size: 14px;'>
-                        {'✅ Strong English Speaker' if english_conf >= 70 else '⚠️ Moderate English Confidence' if english_conf >= 50 else '❓ Low English Confidence'}
-                    </span>
-                    <span style='background: {"#4CAF50" if confidence >= 70 else "#FF9800" if confidence >= 50 else "#F44336"}; color: white; padding: 5px 10px; border-radius: 15px; font-size: 14px;'>
-                        {'🎯 High Confidence' if confidence >= 70 else '🤔 Moderate Confidence' if confidence >= 50 else '❓ Low Confidence'}
-                    </span>
-                    <span style='background: {"#4CAF50" if quality_score >= 70 else "#FF9800" if quality_score >= 40 else "#F44336"}; color: white; padding: 5px 10px; border-radius: 15px; font-size: 14px;'>
-                        {'🎤 Good Audio Quality' if quality_score >= 70 else '📢 Fair Audio Quality' if quality_score >= 40 else '🔇 Poor Audio Quality'}
-                    </span>
-                </div>
-            </div>
-        </div>
-        """
-        display(HTML(html))
-
-        # Create probability breakdown visualization
-        self._plot_probabilities(results['all_probabilities'])
-
-        # Display detailed breakdown table
-        prob_df = pd.DataFrame([
-            {
-                'Accent': self.accent_display_names.get(accent, accent.title()),
-                'Probability': f"{prob:.1f}%",
-                'Confidence': '🟢 High' if prob >= 70 else '🟡 Medium' if prob >= 30 else '🔴 Low'
-            }
-            for accent, prob in sorted(results['all_probabilities'].items(), key=lambda x: x[1], reverse=True)
-        ])
 
-        print("\n📊 Detailed Probability Breakdown:")
-        display(prob_df)
+def display_results(self, results):
+    """Display results in text format"""
+    if 'error' in results:
+        print(f"❌ {results['error']}")
+        return
 
-    def _plot_probabilities(self, probabilities):
-        """Create a visualization of accent probabilities"""
-        try:
-            plt.figure(figsize=(10, 6))
+    accent = results['predicted_accent']
+    confidence = results['accent_confidence']
+    english_conf = results['english_confidence']
+    duration = results['audio_duration']
+    processed_duration = results.get('processed_duration', duration)
+    quality_score = results.get('audio_quality_score', 50)
 
-            accents = [self.accent_display_names.get(acc, acc.title()) for acc in probabilities.keys()]
-            probs = list(probabilities.values())
+    accent_display = self.accent_display_names.get(accent, accent.title())
 
-            # Create color map
-            colors = ['#4CAF50' if p == max(probs) else '#2196F3' if p >= 20 else '#FFC107' if p >= 10 else '#9E9E9E'
-                     for p in probs]
+    print(f"\n=== Accent Analysis Results ===")
+    print(f"Predicted Accent: {accent_display}")
+    print(f"Confidence: {confidence:.1f}%")
+    print(f"English Confidence: {english_conf:.1f}%")
+    print(f"Audio Duration: {duration:.1f}s")
+    print(f"Processed Duration: {processed_duration:.1f}s")
+    print(f"Audio Quality: {quality_score:.0f}/100")
+    print(f"Chunks Analyzed: {results.get('chunks_analyzed', 1)}")
 
-            bars = plt.bar(accents, probs, color=colors, alpha=0.8, edgecolor='black', linewidth=0.5)
 
-            plt.title('Accent Classification Probabilities', fontsize=16, fontweight='bold', pad=20)
-            plt.xlabel('Accent Type', fontsize=12)
-            plt.ylabel('Probability (%)', fontsize=12)
-            plt.xticks(rotation=45, ha='right')
-            plt.grid(axis='y', alpha=0.3)
+def _plot_probabilities(self, probabilities):
+    """Create a visualization of accent probabilities"""
+    try:
+        plt.figure(figsize=(10, 6))
 
-            # Add value labels on bars
-            for bar, prob in zip(bars, probs):
-                height = bar.get_height()
-                plt.text(bar.get_x() + bar.get_width()/2., height + 0.5,
-                        f'{prob:.1f}%', ha='center', va='bottom', fontweight='bold')
+        accents = [self.accent_display_names.get(acc, acc.title()) for acc in probabilities.keys()]
+        probs = list(probabilities.values())
 
-            plt.tight_layout()
-            plt.show()
+        # Create color map
+        colors = ['#4CAF50' if p == max(probs) else '#2196F3' if p >= 20 else '#FFC107' if p >= 10 else '#9E9E9E'
+                  for p in probs]
 
-        except Exception as e:
-            print(f"⚠️ Could not create visualization: {e}")
+        bars = plt.bar(accents, probs, color=colors, alpha=0.8, edgecolor='black', linewidth=0.5)
 
-    def batch_analyze(self, urls, max_duration=30):
-        """Analyze multiple videos with progress tracking"""
-        results = []
-        failed_count = 0
+        plt.title('Accent Classification Probabilities', fontsize=16, fontweight='bold', pad=20)
+        plt.xlabel('Accent Type', fontsize=12)
+        plt.ylabel('Probability (%)', fontsize=12)
+        plt.xticks(rotation=45, ha='right')
+        plt.grid(axis='y', alpha=0.3)
 
-        print(f"🚀 Starting batch analysis of {len(urls)} videos")
+        # Add value labels on bars
+        for bar, prob in zip(bars, probs):
+            height = bar.get_height()
+            plt.text(bar.get_x() + bar.get_width() / 2., height + 0.5,
+                     f'{prob:.1f}%', ha='center', va='bottom', fontweight='bold')
 
-        for i, url in enumerate(urls, 1):
-            print(f"\n{'='*60}")
-            print(f"Processing video {i}/{len(urls)}")
+        plt.tight_layout()
+        plt.show()
 
-            result = self.analyze_video_url(url, max_duration)
-            result['video_index'] = i
+    except Exception as e:
+        print(f"⚠️ Could not create visualization: {e}")
 
-            if 'error' in result:
-                failed_count += 1
-                print(f"❌ Failed: {result['error']}")
-            else:
-                print(f"✅ Success: {result['predicted_accent']} ({result['accent_confidence']:.1f}%)")
 
-            results.append(result)
-            self.display_results(result)
+def batch_analyze(self, urls, max_duration=30):
+    """Analyze multiple videos with progress tracking"""
+    results = []
+    failed_count = 0
 
-            # Small delay to prevent overwhelming servers
-            if i < len(urls):
-                time.sleep(1)
+    print(f"🚀 Starting batch analysis of {len(urls)} videos")
 
-        # Summary
-        success_count = len(urls) - failed_count
-        print(f"\n📈 Batch Analysis Summary:")
-        print(f"   ✅ Successful: {success_count}/{len(urls)}")
-        print(f"   ❌ Failed: {failed_count}/{len(urls)}")
+    for i, url in enumerate(urls, 1):
+        print(f"\n{'=' * 60}")
+        print(f"Processing video {i}/{len(urls)}")
 
-        return results
+        result = self.analyze_video_url(url, max_duration)
+        result['video_index'] = i
 
-    def export_results(self, results, filename="accent_analysis_results.json"):
-        """Export results to JSON file"""
-        try:
-            with open(filename, 'w') as f:
-                json.dump(results, f, indent=2, default=str)
-            print(f"💾 Results exported to {filename}")
-        except Exception as e:
-            print(f"❌ Export failed: {e}")
+        if 'error' in result:
+            failed_count += 1
+            print(f"❌ Failed: {result['error']}")
+        else:
+            print(f"✅ Success: {result['predicted_accent']} ({result['accent_confidence']:.1f}%)")
+
+        results.append(result)
+        self.display_results(result)
+
+        # Small delay to prevent overwhelming servers
+        if i < len(urls):
+            time.sleep(1)
+
+    # Summary
+    success_count = len(urls) - failed_count
+    print(f"\n📈 Batch Analysis Summary:")
+    print(f"   ✅ Successful: {success_count}/{len(urls)}")
+    print(f"   ❌ Failed: {failed_count}/{len(urls)}")
+
+    return results
+
+
+def export_results(self, results, filename="accent_analysis_results.json"):
+    """Export results to JSON file"""
+    try:
+        with open(filename, 'w') as f:
+            json.dump(results, f, indent=2, default=str)
+        print(f"💾 Results exported to {filename}")
+    except Exception as e:
+        print(f"❌ Export failed: {e}")
+
+
+def cleanup(self):
+    """Clean up temporary files"""
+    try:
+        import shutil
+        if os.path.exists(self.temp_dir):
+            shutil.rmtree(self.temp_dir, ignore_errors=True)
+            print("🧹 Cleaned up temporary files")
+    except Exception as e:
+        print(f"⚠️ Cleanup warning: {e}")
 
-    def cleanup(self):
-        """Clean up temporary files"""
-        try:
-            import shutil
-            if os.path.exists(self.temp_dir):
-                shutil.rmtree(self.temp_dir, ignore_errors=True)
-                print("🧹 Cleaned up temporary files")
-        except Exception as e:
-            print(f"⚠️ Cleanup warning: {e}")
 
 # Helper Functions
 def show_examples():
@@ -669,6 +627,7 @@ def show_examples():
     print("  • Multiple speakers may affect accuracy")
     print("  • Model works best with sustained speech")
 
+
 def quick_test_url():
     """Interactive test for video URLs"""
     print("🔍 Quick Test Mode for Video URLs")
@@ -699,10 +658,11 @@ def quick_test_url():
     finally:
         analyzer.cleanup()
 
+
 def demo_analysis():
     """Demo function with example usage"""
     print("🎬 Video Accent Analyzer Demo")
-    print("="*50)
+    print("=" * 50)
 
     # Initialize analyzer
     analyzer = VideoAccentAnalyzer()
@@ -722,5 +682,6 @@ def demo_analysis():
     print("3. analyzer.display_results(results)")
     print("4. analyzer.cleanup()  # Clean up temporary files")
 
+
 # Show examples on import
-show_examples()
+show_examples()