accentDetector.py

import streamlit as st
import requests
import tempfile
import os
from pathlib import Path
import subprocess
import speech_recognition as sr
from pydub import AudioSegment
import re
import numpy as np
from typing import Dict, Tuple, Optional
import json

class AccentDetector:
    """
    Accent detection system that analyzes English speech patterns
    to classify regional accents and provide confidence scores.
    """
    
    def __init__(self):
        self.accent_patterns = {
            'American': {
                'keywords': ['gonna', 'wanna', 'gotta', 'kinda', 'sorta'],
                'phonetic_markers': ['r-colored vowels', 'rhotic'],
                'vocabulary': ['elevator', 'apartment', 'garbage', 'vacation', 'cookie']
            },
            'British': {
                'keywords': ['brilliant', 'lovely', 'quite', 'rather', 'chap'],
                'phonetic_markers': ['non-rhotic', 'received pronunciation'],
                'vocabulary': ['lift', 'flat', 'rubbish', 'holiday', 'biscuit']
            },
            'Australian': {
                'keywords': ['mate', 'bloody', 'fair dinkum', 'crikey', 'reckon'],
                'phonetic_markers': ['broad vowels', 'rising intonation'],
                'vocabulary': ['arvo', 'brekkie', 'servo', 'bottle-o', 'mozzie']
            },
            'Canadian': {
                'keywords': ['eh', 'about', 'house', 'out', 'sorry'],
                'phonetic_markers': ['canadian raising', 'eh particle'],
                'vocabulary': ['toque', 'hydro', 'washroom', 'parkade', 'chesterfield']
            },
            'South African': {
                'keywords': ['ag', 'man', 'hey', 'lekker', 'braai'],
                'phonetic_markers': ['kit-split', 'dental fricatives'],
                'vocabulary': ['robot', 'bakkie', 'boerewors', 'biltong', 'sosatie']
            }
        }
    
    def download_video(self, url: str) -> str:
        """Download video from URL to temporary file"""
        try:
            response = requests.get(url, stream=True, timeout=30)
            response.raise_for_status()
            
            # Create temporary file
            with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as temp_file:
                for chunk in response.iter_content(chunk_size=8192):
                    temp_file.write(chunk)
                return temp_file.name
        except Exception as e:
            raise Exception(f"Failed to download video: {str(e)}")
    
    def extract_audio(self, video_path: str) -> str:
        """Extract audio from video file using ffmpeg"""
        try:
            audio_path = video_path.replace('.mp4', '.wav')
            
            # Use ffmpeg to extract audio
            cmd = [
                'ffmpeg', '-i', video_path, '-vn', '-acodec', 'pcm_s16le',
                '-ar', '16000', '-ac', '1', '-y', audio_path
            ]
            
            result = subprocess.run(cmd, capture_output=True, text=True)
            if result.returncode != 0:
                # Fallback to pydub if ffmpeg fails
                audio = AudioSegment.from_file(video_path)
                audio = audio.set_frame_rate(16000).set_channels(1)
                audio.export(audio_path, format="wav")
            
            return audio_path
        except Exception as e:
            raise Exception(f"Failed to extract audio: {str(e)}")
    
    def transcribe_audio(self, audio_path: str) -> str:
        """Transcribe audio to text using speech recognition"""
        try:
            r = sr.Recognizer()
            
            with sr.AudioFile(audio_path) as source:
                # Adjust for ambient noise
                r.adjust_for_ambient_noise(source, duration=0.5)
                audio_data = r.record(source)
            
            # Use Google Speech Recognition (free tier)
            text = r.recognize_google(audio_data, language='en-US')
            return text.lower()
        except sr.UnknownValueError:
            raise Exception("Could not understand the audio")
        except sr.RequestError as e:
            raise Exception(f"Speech recognition error: {str(e)}")
    
    def analyze_accent_patterns(self, text: str) -> Dict[str, float]:
        """Analyze text for accent-specific patterns"""
        scores = {}
        words = text.split()
        word_count = len(words)
        
        if word_count == 0:
            return {accent: 0.0 for accent in self.accent_patterns.keys()}
        
        for accent, patterns in self.accent_patterns.items():
            score = 0.0
            matches = 0
            
            # Check for accent-specific keywords
            for keyword in patterns['keywords']:
                if keyword in text:
                    score += 15.0
                    matches += 1
            
            # Check for accent-specific vocabulary
            for vocab_word in patterns['vocabulary']:
                if vocab_word in text:
                    score += 10.0
                    matches += 1
            
            # Normalize score based on text length and matches
            if matches > 0:
                score = min(score * (matches / word_count) * 100, 95.0)
            else:
                # Base score for general English patterns
                score = self._calculate_base_score(text, accent)
            
            scores[accent] = round(score, 1)
        
        return scores
    
    def _calculate_base_score(self, text: str, accent: str) -> float:
        """Calculate base confidence score for accent detection"""
        # Simple heuristics based on common patterns
        base_scores = {
            'American': 25.0,  # Default higher for American English
            'British': 15.0,
            'Australian': 10.0,
            'Canadian': 12.0,
            'South African': 8.0
        }
        
        # Adjust based on text characteristics
        score = base_scores.get(accent, 10.0)
        
        # Look for spelling patterns
        if accent == 'British' and ('colour' in text or 'favour' in text or 'centre' in text):
            score += 20.0
        elif accent == 'American' and ('color' in text or 'favor' in text or 'center' in text):
            score += 20.0
        
        return min(score, 40.0)  # Cap base scores
    
    def classify_accent(self, scores: Dict[str, float]) -> Tuple[str, float, str]:
        """Classify the most likely accent and provide explanation"""
        if not scores or all(score == 0 for score in scores.values()):
            return "Unknown", 0.0, "Insufficient accent markers detected"
        
        # Find the highest scoring accent
        top_accent = max(scores.items(), key=lambda x: x[1])
        accent_name, confidence = top_accent
        
        # Generate explanation
        explanation = self._generate_explanation(accent_name, confidence, scores)
        
        return accent_name, confidence, explanation
    
    def _generate_explanation(self, accent: str, confidence: float, all_scores: Dict[str, float]) -> str:
        """Generate explanation for the accent classification"""
        if confidence < 20:
            return f"Low confidence detection. The speech patterns are not strongly indicative of any specific English accent."
        elif confidence < 50:
            return f"Moderate confidence in {accent} accent based on limited linguistic markers."
        elif confidence < 75:
            return f"Good confidence in {accent} accent. Several characteristic patterns detected."
        else:
            return f"High confidence in {accent} accent with strong linguistic indicators."
    
    def process_video(self, url: str) -> Dict:
        """Main processing pipeline"""
        temp_files = []
        try:
            # Step 1: Download video
            st.write("📥 Downloading video...")
            video_path = self.download_video(url)
            temp_files.append(video_path)
            
            # Step 2: Extract audio
            st.write("🎵 Extracting audio...")
            audio_path = self.extract_audio(video_path)
            temp_files.append(audio_path)
            
            # Step 3: Transcribe audio
            st.write("🎤 Transcribing speech...")
            transcript = self.transcribe_audio(audio_path)
            
            # Step 4: Analyze accent
            st.write("🔍 Analyzing accent patterns...")
            accent_scores = self.analyze_accent_patterns(transcript)
            accent, confidence, explanation = self.classify_accent(accent_scores)
            
            return {
                'success': True,
                'transcript': transcript,
                'accent': accent,
                'confidence': confidence,
                'explanation': explanation,
                'all_scores': accent_scores
            }
            
        except Exception as e:
            return {
                'success': False,
                'error': str(e)
            }
        finally:
            # Cleanup temporary files
            for temp_file in temp_files:
                try:
                    if os.path.exists(temp_file):
                        os.remove(temp_file)
                except:
                    pass

def main():
    st.set_page_config(
        page_title="English Accent Detector",
        page_icon="🎤",
        layout="wide"
    )
    
    st.title("🎤 English Accent Detection Tool")
    st.markdown("### Analyze English accents from video content")
    
    st.markdown("""
    **How it works:**
    1. Paste a public video URL (MP4, Loom, etc.)
    2. The tool extracts audio and transcribes speech
    3. AI analyzes linguistic patterns to detect English accent
    4. Get classification, confidence score, and explanation
    """)
    
    # Input section
    st.subheader("📹 Video Input")
    video_url = st.text_input(
        "Enter video URL:",
        placeholder="https://example.com/video.mp4 or Loom link",
        help="Must be a direct video link or public Loom video"
    )
    
    # Process button
    if st.button("🚀 Analyze Accent", type="primary"):
        if not video_url:
            st.error("Please enter a video URL")
            return
        
        # Validate URL
        if not (video_url.startswith('http://') or video_url.startswith('https://')):
            st.error("Please enter a valid URL starting with http:// or https://")
            return
        
        # Initialize detector
        detector = AccentDetector()
        
        # Process video
        with st.spinner("Processing video... This may take a few minutes."):
            result = detector.process_video(video_url)
        
        # Display results
        if result['success']:
            st.success("✅ Analysis Complete!")
            
            # Main results
            col1, col2 = st.columns(2)
            
            with col1:
                st.metric(
                    label="🗣️ Detected Accent",
                    value=result['accent']
                )
            
            with col2:
                st.metric(
                    label="🎯 Confidence Score",
                    value=f"{result['confidence']}%"
                )
            
            # Explanation
            st.subheader("📝 Analysis Explanation")
            st.write(result['explanation'])
            
            # Transcript
            st.subheader("📄 Transcript")
            st.text_area("Transcribed Text:", result['transcript'], height=100)
            
            # Detailed scores
            st.subheader("📊 Detailed Accent Scores")
            scores_df = []
            for accent, score in result['all_scores'].items():
                scores_df.append({"Accent": accent, "Confidence": f"{score}%"})
            
            st.table(scores_df)
            
        else:
            st.error(f"❌ Error: {result['error']}")
    
    # Footer
    st.markdown("---")
    st.markdown("""
    **Technical Notes:**
    - Supports common video formats (MP4, MOV, AVI)
    - Works with public Loom videos and direct video links
    - Analyzes vocabulary, pronunciation patterns, and linguistic markers
    - Optimized for English language detection
    """)

if __name__ == "__main__":
    main()