Create app.py

app.py

@@ -0,0 +1,265 @@
+import gradio as gr
+import os
+import tempfile
+import requests
+from moviepy.editor import VideoFileClip
+import random
+import json
+
+# --- Lightweight AccentAnalyzer class ---
+
+class AccentAnalyzer:
+    def __init__(self):
+        self.accent_profiles = {
+            "American": {
+                "features": ["rhotic", "flapped_t", "cot_caught_merger"],
+                "description": "American English accent with rhotic pronunciation and typical North American features."
+            },
+            "British": {
+                "features": ["non_rhotic", "t_glottalization", "trap_bath_split"],
+                "description": "British English accent with non-rhotic pronunciation and typical UK features."
+            },
+            "Australian": {
+                "features": ["non_rhotic", "flat_a", "high_rising_terminal"],
+                "description": "Australian English accent with distinctive vowel sounds and intonation patterns."
+            },
+            "Canadian": {
+                "features": ["rhotic", "canadian_raising", "eh_tag"],
+                "description": "Canadian English accent with features of both American and British English."
+            },
+            "Indian": {
+                "features": ["retroflex_consonants", "monophthongization", "syllable_timing"],
+                "description": "Indian English accent influenced by native Indian languages."
+            },
+            "Irish": {
+                "features": ["dental_fricatives", "alveolar_l", "soft_consonants"],
+                "description": "Irish English accent with distinctive rhythm and consonant patterns."
+            },
+            "Scottish": {
+                "features": ["rolled_r", "monophthongs", "glottal_stops"],
+                "description": "Scottish English accent with strong consonants and distinctive vowel patterns."
+            },
+            "South African": {
+                "features": ["non_rhotic", "kit_split", "kw_hw_distinction"],
+                "description": "South African English accent with influences from Afrikaans and other local languages."
+            }
+        }
+        self._load_or_create_accent_data()
+
+    def _load_or_create_accent_data(self):
+        # For demo: just create simulated data in-memory
+        self.accent_data = self._create_simulated_accent_data()
+
+    def _create_simulated_accent_data(self):
+        accent_data = {}
+        for accent, profile in self.accent_profiles.items():
+            accent_data[accent] = {
+                "primary_features": profile["features"],
+                "feature_probabilities": {}
+            }
+            for feature in profile["features"]:
+                accent_data[accent]["feature_probabilities"][feature] = random.uniform(0.7, 0.9)
+            all_features = set()
+            for a, p in self.accent_profiles.items():
+                all_features.update(p["features"])
+            for feature in all_features:
+                if feature not in profile["features"]:
+                    accent_data[accent]["feature_probabilities"][feature] = random.uniform(0.1, 0.4)
+        return accent_data
+
+    def _extract_features(self, audio_path):
+        # This is a simulated feature extraction for the demo.
+        # In a real application, this would use SpeechBrain or similar ML models
+        # to extract actual phonetic features from the audio.
+        all_features = set()
+        for accent, profile in self.accent_profiles.items():
+            all_features.update(profile["features"])
+        detected_features = {}
+        for feature in all_features:
+            # Simulate detection of features with varying probabilities
+            detected_features[feature] = random.uniform(0.1, 0.9)
+        return detected_features
+
+    def _calculate_accent_scores(self, detected_features):
+        accent_scores = {}
+        for accent, data in self.accent_data.items():
+            score = 0
+            total_weight = 0
+            for feature, probability in detected_features.items():
+                expected_prob = data["feature_probabilities"].get(feature, 0.1)
+                weight = 3.0 if feature in data["primary_features"] else 1.0 # Give more weight to primary features
+                feature_score = probability * expected_prob * weight
+                score += feature_score
+                total_weight += weight
+            if total_weight > 0:
+                accent_scores[accent] = (score / total_weight) * 100
+            else:
+                accent_scores[accent] = 0
+        return accent_scores
+
+    def _generate_explanation(self, accent_type, confidence):
+        if confidence >= 70:
+            confidence_level = "high confidence"
+            certainty = "is very clear"
+        elif confidence >= 50:
+            confidence_level = "moderate confidence"
+            certainty = "is present"
+        else:
+            confidence_level = "low confidence"
+            certainty = "may be present"
+        description = self.accent_profiles[accent_type]["description"]
+        second_accent = self._get_second_most_likely_accent(accent_type)
+        explanation = f"The speaker has a {confidence_level} {accent_type} English accent. The {accent_type} accent {certainty}, with features of both {accent_type} and {second_accent} English present."
+        return explanation
+
+    def _get_second_most_likely_accent(self, primary_accent):
+        # Simple rule-based selection for demo purposes
+        accent_similarities = {
+            "American": ["Canadian", "British"],
+            "British": ["Australian", "Irish"],
+            "Australian": ["British", "South African"],
+            "Canadian": ["American", "British"],
+            "Indian": ["British", "South African"],
+            "Irish": ["Scottish", "British"],
+            "Scottish": ["Irish", "British"],
+            "South African": ["Australian", "British"]
+        }
+        # Pick a random similar accent from the predefined list
+        return random.choice(accent_similarities[primary_accent])
+
+    def analyze_accent(self, audio_path):
+        """
+        Analyzes the accent from an audio file.
+        In this demo, it simulates feature extraction and accent scoring.
+        """
+        detected_features = self._extract_features(audio_path)
+        accent_scores = self._calculate_accent_scores(detected_features)
+        
+        # Find the accent with the highest score
+        accent_type = max(accent_scores, key=accent_scores.get)
+        confidence = accent_scores[accent_type]
+        
+        explanation = self._generate_explanation(accent_type, confidence)
+        
+        return {
+            "accent_type": accent_type,
+            "confidence": confidence,
+            "explanation": explanation,
+            "all_scores": accent_scores # Useful for debugging or more detailed display
+        }
+
+# --- Utility: Download video and extract audio ---
+
+def download_and_extract_audio(url):
+    """
+    Downloads a video from a URL and extracts its audio to a WAV file.
+    Handles both direct MP4 links and YouTube URLs (using pytubefix).
+    """
+    temp_dir = tempfile.mkdtemp()
+    video_path = os.path.join(temp_dir, "video.mp4")
+    audio_path = os.path.join(temp_dir, "audio.wav")
+
+    try:
+        # Download video
+        # Check for YouTube URL patterns (simplified for demo)
+        if "youtube.com/" in url or "youtu.be/" in url:
+            try:
+                from pytubefix import YouTube
+                yt = YouTube(url)
+                # Try to get a progressive stream (video + audio)
+                stream = yt.streams.filter(progressive=True, file_extension='mp4').order_by('resolution').desc().first()
+                if not stream:
+                    # Fallback to separate audio stream if progressive not found
+                    stream = yt.streams.filter(only_audio=True).first()
+                    if not stream:
+                        raise RuntimeError("No suitable video or audio stream found for YouTube URL.")
+                
+                # Download the stream
+                stream.download(output_path=temp_dir, filename="video.mp4")
+            except ImportError:
+                raise ImportError("pytubefix is not installed. Please install it with 'pip install pytubefix'.")
+            except Exception as e:
+                # Catch specific YouTube errors, e.g., age restriction, unavailable
+                raise RuntimeError(f"Error downloading YouTube video: {e}. Try running locally or use a direct MP4 link.")
+        else:
+            # Direct MP4 download
+            response = requests.get(url, stream=True)
+            response.raise_for_status() # Raise an exception for bad status codes (4xx or 5xx)
+            with open(video_path, "wb") as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    f.write(chunk)
+        
+        # Extract audio using moviepy
+        clip = VideoFileClip(video_path)
+        clip.audio.write_audiofile(audio_path, logger=None) # logger=None suppresses moviepy output
+        clip.close()
+        
+        return audio_path
+    finally:
+        # Clean up the video file immediately after audio extraction
+        if os.path.exists(video_path):
+            os.remove(video_path)
+        # The temp_dir itself will be handled by Gradio's internal tempfile management,
+        # or you can add os.rmdir(temp_dir) if you manage temp_dir manually.
+
+# --- Gradio interface ---
+
+def analyze_from_url(url):
+    """
+    Gradio interface function to analyze accent from a given video URL.
+    """
+    if not url:
+        return "Please enter a video URL.", "N/A", "No URL provided."
+
+    try:
+        audio_path = download_and_extract_audio(url)
+        analyzer = AccentAnalyzer()
+        results = analyzer.analyze_accent(audio_path)
+        
+        # Clean up the temporary audio file after analysis
+        if os.path.exists(audio_path):
+            os.remove(audio_path)
+
+        return (
+            results["accent_type"],
+            f"{results['confidence']:.1f}%",
+            results["explanation"]
+        )
+    except Exception as e:
+        # Catch and display any errors during the process
+        return (
+            "Error",
+            "0%",
+            f"Error processing video/audio: {e}. Please ensure the URL is valid and publicly accessible."
+        )
+
+# Create the Gradio interface
+iface = gr.Interface(
+    fn=analyze_from_url,
+    inputs=gr.Textbox(
+        label="Enter Public Video URL (YouTube or direct MP4)",
+        placeholder="e.g., https://www.youtube.com/watch?v=dQw4w9WgXcQ or https://samplelib.com/lib/preview/mp4/sample-5s.mp4"
+    ),
+    outputs=[
+        gr.Textbox(label="Detected Accent"),
+        gr.Textbox(label="Confidence Score"),
+        gr.Textbox(label="Explanation")
+    ],
+    title="English Accent Analyzer (Rule-Based Demo)",
+    description="""
+    Paste a public video URL (YouTube or direct MP4) to detect the English accent and confidence score.
+    
+    **Important Notes:**
+    * This is a **DEMO** using a simulated accent analysis model, not a real machine learning model.
+    * It uses `pytubefix` for YouTube links and `requests`/`moviepy` for direct MP4s.
+    * YouTube video extraction can sometimes be temperamental due to YouTube's changing policies or region restrictions. Direct MP4 links are generally more reliable.
+    * **Sample MP4 URL for testing:** `https://samplelib.com/lib/preview/mp4/sample-5s.mp4`
+    """
+)
+
+# Launch the Gradio interface
+# `share=False` for local deployment (no public link generated)
+# For Hugging Face Spaces, you typically don't need `iface.launch()` as the platform handles it.
+# However, if you're running it locally to test before deployment, keep this block.
+if __name__ == "__main__":
+    iface.launch(debug=True, share=False)