ss

beat_analysis.py

@@ -0,0 +1,854 @@
+import librosa
+import numpy as np
+import pronouncing
+import re
+from functools import lru_cache
+import string
+from nltk.corpus import cmudict
+import nltk
+from scipy import signal
+
+try:
+    nltk.data.find('corpora/cmudict')
+except LookupError:
+    nltk.download('cmudict')
+
+class BeatAnalyzer:
+    def __init__(self):
+        # Mapping for standard stress patterns by time signature
+        # Simplified to only include 4/4, 3/4, and 6/8
+        self.stress_patterns = {
+            # Format: Strong (1.0), Medium (0.5), Weak (0.0)
+            "4/4": [1.0, 0.0, 0.5, 0.0],  # Strong, weak, medium, weak
+            "3/4": [1.0, 0.0, 0.0],       # Strong, weak, weak
+            "6/8": [1.0, 0.0, 0.0, 0.5, 0.0, 0.0]   # Strong, weak, weak, medium, weak, weak
+        }
+        
+        self.cmudict = None
+        try:
+            self.cmudict = cmudict.dict()
+        except:
+            pass  # Fall back to rule-based counting if cmudict is not available
+            
+        # Genre-specific syllable-to-beat ratio guidelines
+        self.genre_syllable_ratios = {
+            # Supported genres with strong syllable-to-beat patterns
+            'pop': (0.5, 1.0, 1.5),        # Pop - significantly reduced range
+            'rock': (0.5, 0.9, 1.3),       # Rock - reduced for brevity
+            'country': (0.6, 0.9, 1.2),    # Country - simpler syllable patterns
+            'disco': (0.7, 1.0, 1.3),      # Disco - tightened range
+            'metal': (0.6, 1.0, 1.3),      # Metal - reduced upper limit
+            
+            # Other genres (analysis only, no lyrics generation)
+            'hiphop': (1.8, 2.5, 3.5),     # Hip hop often has many syllables per beat
+            'rap': (2.0, 3.0, 4.0),        # Rap often has very high syllable counts
+            'folk': (0.8, 1.0, 1.3),       # Folk often has close to 1:1 ratio
+            'jazz': (0.7, 1.0, 1.5),       # Jazz can be very flexible
+            'reggae': (0.7, 1.0, 1.3),     # Reggae often emphasizes specific beats
+            'soul': (0.8, 1.2, 1.6),       # Soul music tends to be expressive
+            'r&b': (1.0, 1.5, 2.0),        # R&B can have melisma
+            'electronic': (0.7, 1.0, 1.5), # Electronic music varies widely
+            'classical': (0.7, 1.0, 1.4),  # Classical can vary by subgenre
+            'blues': (0.6, 0.8, 1.2),      # Blues often extends syllables
+            'default': (0.6, 1.0, 1.3)     # Default for unknown genres - more conservative
+        }
+        
+        # List of genres supported for lyrics generation
+        # These genres have the most predictable and consistent syllable-to-beat relationships,
+        # making them ideal for our beat-matching algorithm
+        self.supported_genres = ['pop', 'rock', 'country', 'disco', 'metal']
+        
+        # Common time signatures and their beat patterns with weights for prior probability
+        # Simplified to only include 4/4, 3/4, and 6/8
+        self.common_time_signatures = {
+            "4/4": {"beats_per_bar": 4, "beat_pattern": [1.0, 0.2, 0.5, 0.2], "weight": 0.55},
+            "3/4": {"beats_per_bar": 3, "beat_pattern": [1.0, 0.2, 0.3], "weight": 0.30},
+            "6/8": {"beats_per_bar": 6, "beat_pattern": [1.0, 0.2, 0.3, 0.8, 0.2, 0.3], "weight": 0.15}
+        }
+        
+        # Add common accent patterns for different time signatures
+        self.accent_patterns = {
+            "4/4": [[1, 0, 0, 0], [1, 0, 2, 0], [1, 0, 2, 0, 3, 0, 2, 0]],
+            "3/4": [[1, 0, 0], [1, 0, 2]],
+            "6/8": [[1, 0, 0, 2, 0, 0], [1, 0, 0, 2, 0, 3]]
+        }
+        
+        # Expected rhythm density (relative note density per beat) for different time signatures
+        self.rhythm_density = {
+            "4/4": [1.0, 0.7, 0.8, 0.6],
+            "3/4": [1.0, 0.6, 0.7],
+            "6/8": [1.0, 0.5, 0.4, 0.8, 0.5, 0.4]
+        }
+        
+    @lru_cache(maxsize=128)
+    def count_syllables(self, word):
+        """Count syllables in a word using CMU dictionary if available, otherwise use rule-based method."""
+        word = word.lower().strip()
+        word = re.sub(r'[^a-z]', '', word)  # Remove non-alphabetic characters
+        
+        if not word:
+            return 0
+            
+        # Try using CMUDict first if available
+        if self.cmudict and word in self.cmudict:
+            return max([len(list(y for y in x if y[-1].isdigit())) for x in self.cmudict[word]])
+            
+        # Rule-based syllable counting as fallback
+        # Modified version from NLTK's implementation
+        vowels = "aeiouy"
+        double_vowels = ['aa', 'ae', 'ai', 'ao', 'au', 'ay', 'ea', 'ee', 'ei', 'eo', 'eu', 'ey', 'ia', 'ie', 'ii', 'io', 'iu', 'oa', 'oe', 'oi', 'oo', 'ou', 'oy', 'ua', 'ue', 'ui', 'uo', 'uy']
+        prev_was_vowel = False
+        count = 0
+        final_e = False
+        
+        if word.endswith('e') and not word.endswith('le'):
+            final_e = True
+            
+        for i, char in enumerate(word):
+            if char in vowels:
+                # Check if current char and previous char form a dipthong
+                if prev_was_vowel and i > 0 and (word[i-1:i+1] in double_vowels):
+                    prev_was_vowel = True
+                    continue
+                
+                if not prev_was_vowel:
+                    count += 1
+                prev_was_vowel = True
+            else:
+                prev_was_vowel = False
+                
+        # Handle edge cases
+        if word.endswith('le') and len(word) > 2 and word[-3] not in vowels:
+            count += 1
+        elif final_e:
+            count = max(count-1, 1)  # Remove last 'e', but ensure at least 1 syllable
+        elif word.endswith('y') and not prev_was_vowel:
+            count += 1
+            
+        # Ensure at least one syllable
+        return max(count, 1)
+
+    def detect_time_signature(self, audio_path, sr=22050):
+        """
+        Advanced multi-method approach to time signature detection
+        
+        Args:
+            audio_path: Path to audio file
+            sr: Sample rate
+        
+        Returns:
+            dict with detected time signature and confidence
+        """
+        # Load audio
+        y, sr = librosa.load(audio_path, sr=sr)
+        
+        # 1. Compute onset envelope and beat positions
+        onset_env = librosa.onset.onset_strength(y=y, sr=sr, hop_length=512)
+        
+        # Get tempo and beat frames
+        tempo, beat_frames = librosa.beat.beat_track(onset_envelope=onset_env, sr=sr)
+        beat_times = librosa.frames_to_time(beat_frames, sr=sr)
+        
+        # Return default if not enough beats detected
+        if len(beat_times) < 8:
+            return {"time_signature": "4/4", "confidence": 0.5}
+        
+        # 2. Extract beat strengths and normalize
+        beat_strengths = self._get_beat_strengths(y, sr, beat_times, onset_env)
+        
+        # 3. Compute various time signature features using different methods
+        results = {}
+        
+        # Method 1: Beat pattern autocorrelation
+        autocorr_result = self._detect_by_autocorrelation(onset_env, sr)
+        results["autocorrelation"] = autocorr_result
+        
+        # Method 2: Beat strength pattern matching
+        pattern_result = self._detect_by_pattern_matching(beat_strengths)
+        results["pattern_matching"] = pattern_result
+        
+        # Method 3: Spectral rhythmic analysis
+        spectral_result = self._detect_by_spectral_analysis(onset_env, sr)
+        results["spectral"] = spectral_result
+        
+        # Method 4: Note density analysis
+        density_result = self._detect_by_note_density(y, sr, beat_times)
+        results["note_density"] = density_result
+        
+        # Method 5: Tempo-based estimation
+        tempo_result = self._estimate_from_tempo(tempo)
+        results["tempo_based"] = tempo_result
+        
+        # 4. Combine results with weighted voting
+        final_result = self._combine_detection_results(results, tempo)
+        
+        return final_result
+    
+    def _get_beat_strengths(self, y, sr, beat_times, onset_env):
+        """Extract normalized strengths at beat positions"""
+        # Convert beat times to frames
+        beat_frames = librosa.time_to_frames(beat_times, sr=sr, hop_length=512)
+        beat_frames = [min(f, len(onset_env)-1) for f in beat_frames]
+        
+        # Get beat strengths from onset envelope
+        beat_strengths = np.array([onset_env[f] for f in beat_frames])
+        
+        # Also look at energy and spectral flux at beat positions
+        hop_length = 512
+        frame_length = 2048
+        
+        # Get energy at each beat
+        energy = librosa.feature.rms(y=y, frame_length=frame_length, hop_length=hop_length)[0]
+        beat_energy = np.array([energy[min(f, len(energy)-1)] for f in beat_frames])
+        
+        # Combine onset strength with energy (weighted average)
+        beat_strengths = 0.7 * beat_strengths + 0.3 * beat_energy
+        
+        # Normalize
+        if np.max(beat_strengths) > 0:
+            beat_strengths = beat_strengths / np.max(beat_strengths)
+            
+        return beat_strengths
+    
+    def _detect_by_autocorrelation(self, onset_env, sr):
+        """Detect meter using autocorrelation of onset strength"""
+        # Calculate autocorrelation of onset envelope
+        hop_length = 512
+        ac = librosa.autocorrelate(onset_env, max_size=4 * sr // hop_length)
+        ac = librosa.util.normalize(ac)
+        
+        # Find significant peaks in autocorrelation
+        peaks = signal.find_peaks(ac, height=0.2, distance=sr//(8*hop_length))[0]
+        
+        if len(peaks) < 2:
+            return {"time_signature": "4/4", "confidence": 0.4}
+            
+        # Analyze peak intervals in terms of beats
+        peak_intervals = np.diff(peaks)
+        
+        # Convert peaks to time
+        peak_times = peaks * hop_length / sr
+        
+        # Analyze for common time signature patterns
+        time_sig_votes = {}
+        
+        # Check if peaks match expected bar lengths
+        for ts, info in self.common_time_signatures.items():
+            beats_per_bar = info["beats_per_bar"]
+            
+            # Check how well peaks match this meter
+            score = 0
+            for interval in peak_intervals:
+                # Check if this interval corresponds to this time signature
+                # Allow some tolerance around the expected value
+                expected = beats_per_bar * (hop_length / sr)  # in seconds
+                tolerance = 0.25 * expected
+                
+                if abs(interval * hop_length / sr - expected) < tolerance:
+                    score += 1
+            
+            if len(peak_intervals) > 0:
+                time_sig_votes[ts] = score / len(peak_intervals)
+        
+        # Return most likely time signature
+        if time_sig_votes:
+            best_ts = max(time_sig_votes.items(), key=lambda x: x[1])
+            return {"time_signature": best_ts[0], "confidence": best_ts[1]}
+        
+        return {"time_signature": "4/4", "confidence": 0.4}
+    
+    def _detect_by_pattern_matching(self, beat_strengths):
+        """Match beat strength patterns against known time signature patterns"""
+        if len(beat_strengths) < 6:
+            return {"time_signature": "4/4", "confidence": 0.4}
+            
+        results = {}
+        
+        # Try each possible time signature
+        for ts, info in self.common_time_signatures.items():
+            beats_per_bar = info["beats_per_bar"]
+            expected_pattern = info["beat_pattern"]
+            
+            # Calculate correlation scores for overlapping segments
+            scores = []
+            
+            # We need at least one complete pattern
+            if len(beat_strengths) >= beats_per_bar:
+                # Try different offsets to find best alignment
+                for offset in range(min(beats_per_bar, len(beat_strengths) - beats_per_bar + 1)):
+                    # Calculate scores for each complete pattern
+                    pattern_scores = []
+                    
+                    for i in range(offset, len(beat_strengths) - beats_per_bar + 1, beats_per_bar):
+                        segment = beat_strengths[i:i+beats_per_bar]
+                        
+                        # If expected pattern is longer than segment, truncate it
+                        pattern = expected_pattern[:len(segment)]
+                        
+                        # Normalize segment and pattern
+                        if np.std(segment) > 0 and np.std(pattern) > 0:
+                            # Calculate correlation
+                            corr = np.corrcoef(segment, pattern)[0, 1]
+                            if not np.isnan(corr):
+                                pattern_scores.append(corr)
+                    
+                    if pattern_scores:
+                        scores.append(np.mean(pattern_scores))
+            
+            # Use the best score among different offsets
+            if scores:
+                confidence = max(scores)
+                results[ts] = confidence
+        
+        # Find best match
+        if results:
+            best_ts = max(results.items(), key=lambda x: x[1])
+            return {"time_signature": best_ts[0], "confidence": best_ts[1]}
+        
+        # Default
+        return {"time_signature": "4/4", "confidence": 0.5}
+    
+    def _detect_by_spectral_analysis(self, onset_env, sr):
+        """Analyze rhythm in frequency domain"""
+        # Get rhythm periodicity through Fourier Transform
+        # Focus on periods corresponding to typical bar lengths (1-8 seconds)
+        hop_length = 512
+        
+        # Calculate rhythm periodicity
+        fft_size = 2**13  # Large enough to give good frequency resolution
+        S = np.abs(np.fft.rfft(onset_env, n=fft_size))
+        
+        # Convert frequency to tempo in BPM
+        freqs = np.fft.rfftfreq(fft_size, d=hop_length/sr)
+        tempos = 60 * freqs
+        
+        # Focus on reasonable tempo range (40-240 BPM)
+        tempo_mask = (tempos >= 40) & (tempos <= 240)
+        S_tempo = S[tempo_mask]
+        tempos = tempos[tempo_mask]
+        
+        # Find peaks in spectrum
+        peaks = signal.find_peaks(S_tempo, height=np.max(S_tempo)*0.1, distance=5)[0]
+
+        if len(peaks) == 0:
+            return {"time_signature": "4/4", "confidence": 0.4}
+            
+        # Get peak tempos and strengths
+        peak_tempos = tempos[peaks]
+        peak_strengths = S_tempo[peaks]
+        
+        # Sort by strength
+        peak_indices = np.argsort(peak_strengths)[::-1]
+        peak_tempos = peak_tempos[peak_indices]
+        peak_strengths = peak_strengths[peak_indices]
+        
+        # Analyze relationships between peaks
+        # For example, 3/4 typically has peaks at multiples of 3 beats
+        # 4/4 has peaks at multiples of 4 beats
+        
+        time_sig_scores = {}
+        
+        # Check relationships between top peaks
+        if len(peak_tempos) >= 2:
+            tempo_ratios = []
+            for i in range(len(peak_tempos)):
+                for j in range(i+1, len(peak_tempos)):
+                    if peak_tempos[j] > 0:
+                        ratio = peak_tempos[i] / peak_tempos[j]
+                        tempo_ratios.append(ratio)
+            
+            # Check for patterns indicative of different time signatures
+            for ts in self.common_time_signatures:
+                score = 0
+                
+                if ts == "4/4" or ts == "6/8":
+                    # Look for ratios close to 4 or 6
+                    for ratio in tempo_ratios:
+                        if abs(ratio - 4) < 0.2 or abs(ratio - 6) < 0.3:
+                            score += 1
+                
+                # Normalize score
+                if tempo_ratios:
+                    time_sig_scores[ts] = min(1.0, score / len(tempo_ratios) + 0.4)
+        
+        # If we have meaningful scores, return best match
+        if time_sig_scores:
+            best_ts = max(time_sig_scores.items(), key=lambda x: x[1])
+            return {"time_signature": best_ts[0], "confidence": best_ts[1]}
+        
+        # Default fallback
+        return {"time_signature": "4/4", "confidence": 0.4}
+    
+    def _detect_by_note_density(self, y, sr, beat_times):
+        """Analyze note density patterns between beats"""
+        if len(beat_times) < 6:
+            return {"time_signature": "4/4", "confidence": 0.4}
+            
+        # Extract note onsets (not just beats)
+        onset_times = librosa.onset.onset_detect(y=y, sr=sr, units='time')
+        
+        if len(onset_times) < len(beat_times):
+            return {"time_signature": "4/4", "confidence": 0.4}
+            
+        # Count onsets between consecutive beats
+        note_counts = []
+        for i in range(len(beat_times) - 1):
+            start = beat_times[i]
+            end = beat_times[i+1]
+            
+            # Count onsets in this beat
+            count = sum(1 for t in onset_times if start <= t < end)
+            note_counts.append(count)
+        
+        # Look for repeating patterns in the note counts
+        time_sig_scores = {}
+        
+        for ts, info in self.common_time_signatures.items():
+            beats_per_bar = info["beats_per_bar"]
+            
+            # Skip if we don't have enough data
+            if len(note_counts) < beats_per_bar:
+                continue
+                
+            # Calculate pattern similarity for this time signature
+            scores = []
+            
+            for offset in range(min(beats_per_bar, len(note_counts) - beats_per_bar + 1)):
+                similarities = []
+                
+                for i in range(offset, len(note_counts) - beats_per_bar + 1, beats_per_bar):
+                    # Get current bar pattern
+                    pattern = note_counts[i:i+beats_per_bar]
+                    
+                    # Compare with expected density pattern
+                    expected = self.rhythm_density.get(ts, [1.0] * beats_per_bar)
+                    expected = expected[:len(pattern)]  # Truncate if needed
+                    
+                    # Normalize both patterns
+                    if sum(pattern) > 0 and sum(expected) > 0:
+                        pattern_norm = [p/max(1, sum(pattern)) for p in pattern]
+                        expected_norm = [e/sum(expected) for e in expected]
+                        
+                        # Calculate similarity (1 - distance)
+                        distance = sum(abs(p - e) for p, e in zip(pattern_norm, expected_norm)) / len(pattern)
+                        similarity = 1 - min(1.0, distance)
+                        similarities.append(similarity)
+                
+                if similarities:
+                    scores.append(np.mean(similarities))
+            
+            # Use the best score
+            if scores:
+                time_sig_scores[ts] = max(scores)
+        
+        # Return best match
+        if time_sig_scores:
+            best_ts = max(time_sig_scores.items(), key=lambda x: x[1])
+            return {"time_signature": best_ts[0], "confidence": best_ts[1]}
+        
+        # Default
+        return {"time_signature": "4/4", "confidence": 0.4}
+    
+    def _estimate_from_tempo(self, tempo):
+        """Use tempo to help estimate likely time signature"""
+        # Statistical tendencies: slower tempos often in compound meters (6/8)
+        # Fast tempos favor 4/4
+        
+        scores = {}
+        
+        if tempo < 70:
+            # Slow tempos favor compound meters
+            scores = {
+                "4/4": 0.5,
+                "3/4": 0.4,
+                "6/8": 0.7
+            }
+        elif 70 <= tempo <= 120:
+            # Medium tempos favor 4/4, 3/4
+            scores = {
+                "4/4": 0.7,
+                "3/4": 0.6,
+                "6/8": 0.3
+            }
+        else:
+            # Fast tempos favor 4/4
+            scores = {
+                "4/4": 0.8,
+                "3/4": 0.4,
+                "6/8": 0.2
+            }
+        
+        # Find best match
+        best_ts = max(scores.items(), key=lambda x: x[1])
+        return {"time_signature": best_ts[0], "confidence": best_ts[1]}
+    
+    def _combine_detection_results(self, results, tempo):
+        """Combine results from different detection methods"""
+        # Define weights for different methods
+        method_weights = {
+            "autocorrelation": 0.25,
+            "pattern_matching": 0.30,
+            "spectral": 0.20,
+            "note_density": 0.20,
+            "tempo_based": 0.05
+        }
+        
+        # Prior probability (based on frequency in music)
+        prior_weights = {ts: info["weight"] for ts, info in self.common_time_signatures.items()}
+        
+        # Combine votes
+        total_votes = {ts: prior_weights.get(ts, 0.1) for ts in self.common_time_signatures}
+        
+        for method, result in results.items():
+            ts = result["time_signature"]
+            confidence = result["confidence"]
+            weight = method_weights.get(method, 0.1)
+            
+            # Add weighted vote
+            if ts in total_votes:
+                total_votes[ts] += confidence * weight
+            else:
+                total_votes[ts] = confidence * weight
+        
+        # Special case: disambiguate between 3/4 and 6/8
+        if "3/4" in total_votes and "6/8" in total_votes:
+            # If the two are close, use tempo to break tie
+            if abs(total_votes["3/4"] - total_votes["6/8"]) < 0.1:
+                if tempo < 100:  # Slower tempo favors 6/8
+                    total_votes["6/8"] += 0.1
+                else:  # Faster tempo favors 3/4
+                    total_votes["3/4"] += 0.1
+        
+        # Get highest scoring time signature
+        best_ts = max(total_votes.items(), key=lambda x: x[1])
+        
+        # Calculate confidence score (normalize to 0-1)
+        confidence = best_ts[1] / (sum(total_votes.values()) + 0.001)
+        confidence = min(0.95, max(0.4, confidence))  # Bound confidence
+        
+        return {
+            "time_signature": best_ts[0],
+            "confidence": confidence,
+            "all_candidates": {ts: float(score) for ts, score in total_votes.items()}
+        }
+    
+    def analyze_beat_pattern(self, audio_path, sr=22050, time_signature="4/4", auto_detect=False):
+        """Analyze beat patterns and stresses in music using the provided time signature."""
+        # Auto-detect time signature if requested
+        if auto_detect:
+            time_sig_result = self.detect_time_signature(audio_path, sr)
+            time_signature = time_sig_result["time_signature"]
+        
+        # Load audio
+        y, sr = librosa.load(audio_path, sr=sr)
+        
+        # Get tempo and beat frames
+        tempo, beat_frames = librosa.beat.beat_track(y=y, sr=sr)
+        beat_times = librosa.frames_to_time(beat_frames, sr=sr)
+        
+        # Get beat strengths using onset envelope
+        onset_env = librosa.onset.onset_strength(y=y, sr=sr)
+        beat_strengths = onset_env[beat_frames]
+        
+        # Normalize beat strengths
+        if len(beat_strengths) > 0 and np.max(beat_strengths) > np.min(beat_strengths):
+            beat_strengths = (beat_strengths - np.min(beat_strengths)) / (np.max(beat_strengths) - np.min(beat_strengths))
+        
+        # Parse time signature
+        if '/' in time_signature:
+            num, denom = map(int, time_signature.split('/'))
+        else:
+            num, denom = 4, 4  # Default to 4/4
+        
+        # Group beats into bars (each bar is one phrase based on time signature)
+        bars = []
+        current_bar = []
+        
+        for i, (time, strength) in enumerate(zip(beat_times, beat_strengths)):
+            # Determine metrical position and stress
+            metrical_position = i % num
+            
+            # Define stress pattern according to time signature
+            if time_signature == "4/4":
+                if metrical_position == 0:  # First beat (strongest)
+                    stress = "S"  # Strong
+                elif metrical_position == 2:  # Third beat (medium)
+                    stress = "M"  # Medium
+                else:  # Second and fourth beats (weak)
+                    stress = "W"  # Weak
+            elif time_signature == "3/4":
+                if metrical_position == 0:  # First beat (strongest)
+                    stress = "S"  # Strong
+                else:  # Other beats (weak)
+                    stress = "W"  # Weak
+            elif time_signature == "6/8":
+                if metrical_position == 0:  # First beat (strongest)
+                    stress = "S"  # Strong
+                elif metrical_position == 3:  # Fourth beat (medium)
+                    stress = "M"  # Medium
+                else:  # Other beats (weak)
+                    stress = "W"  # Weak
+            else:
+                # Default pattern for other time signatures
+                if metrical_position == 0:
+                    stress = "S"
+                else:
+                    stress = "W"
+            
+            # Add beat to current bar
+            current_bar.append({
+                'time': time,
+                'strength': strength,
+                'stress': stress,
+                'metrical_position': metrical_position
+            })
+            
+            # When we complete a bar, add it to our bars list
+            if metrical_position == num - 1 or i == len(beat_times) - 1:
+                if current_bar:
+                    bars.append(current_bar)
+                    current_bar = []
+                    
+        # If there's any remaining beats, add them as a partial bar
+        if current_bar:
+            bars.append(current_bar)
+        
+        # Organize beats into phrases (one phrase = one bar)
+        phrases = []
+        
+        for i, bar in enumerate(bars):
+            phrase_beats = bar
+            
+            if not phrase_beats:
+                continue
+                
+            # Calculate the phrase information
+            phrase = {
+                'id': i,
+                'num_beats': len(phrase_beats),
+                'beats': phrase_beats,
+                'stress_pattern': ''.join(beat['stress'] for beat in phrase_beats),
+                'start_time': phrase_beats[0]['time'],
+                'end_time': phrase_beats[-1]['time'] + (phrase_beats[-1]['time'] - phrase_beats[-2]['time'] if len(phrase_beats) > 1 else 0.5),
+            }
+            
+            phrases.append(phrase)
+        
+        return {
+            'tempo': tempo,
+            'time_signature': time_signature,
+            'num_beats': len(beat_times),
+            'beat_times': beat_times.tolist(),
+            'beat_strengths': beat_strengths.tolist(),
+            'phrases': phrases
+        }
+    
+    def create_lyric_template(self, beat_analysis):
+        """Create templates for lyrics based on beat phrases."""
+        templates = []
+        
+        if not beat_analysis or 'phrases' not in beat_analysis:
+            return templates
+            
+        phrases = beat_analysis['phrases']
+        
+        for i, phrase in enumerate(phrases):
+            duration = phrase['end_time'] - phrase['start_time']
+            
+            template = {
+                'id': phrase['id'],
+                'start_time': phrase['start_time'],
+                'end_time': phrase['end_time'],
+                'duration': duration,
+                'num_beats': phrase['num_beats'],
+                'stress_pattern': phrase['stress_pattern'],
+                'syllable_guide': self.generate_phrase_guide(phrase)
+            }
+            
+            templates.append(template)
+            
+        return templates
+    
+    def generate_phrase_guide(self, template, words_per_beat=0.5):
+        """Generate a guide for each phrase to help the LLM."""
+        num_beats = template['num_beats']
+        stress_pattern = template['stress_pattern']
+        
+        # Create a visual representation of the stress pattern
+        # S = Strong stress, M = Medium stress, W = Weak stress
+        visual_pattern = ""
+        for i, stress in enumerate(stress_pattern):
+            if stress == "S":
+                visual_pattern += "STRONG "
+            elif stress == "M":
+                visual_pattern += "medium "
+            else:
+                visual_pattern += "weak "
+        
+        # Estimate number of words based on beats (very rough estimate)
+        est_words = max(1, int(num_beats * 0.3))  # Reduced further to encourage extreme brevity
+        
+        # Estimate syllables - use ultra conservative ranges
+        # For 4/4 time signature, we want to enforce extremely short phrases
+        if stress_pattern == "SWMW":  # 4/4 time
+            min_syllables = max(1, int(num_beats * 0.4))  # Reduced from 0.5
+            max_syllables = min(6, int(num_beats * 1.2))  # Reduced from 1.3 to max 6
+        else:
+            min_syllables = max(1, int(num_beats * 0.4))  # Reduced from 0.5
+            max_syllables = min(6, int(num_beats * 1.1))  # Reduced from 1.2 to max 6
+        
+        # Store these in the template for future reference
+        template['min_expected'] = min_syllables
+        template['max_expected'] = max_syllables
+        
+        guide = f"~{est_words} words, ~{min_syllables}-{max_syllables} syllables | Pattern: {visual_pattern}"
+        
+        # Add additional guidance to the template for natural phrasing
+        template['phrasing_guide'] = "ULTRA SHORT LINES. One thought per line. Use FRAGMENTS not sentences."
+        
+        return guide
+
+    def check_syllable_stress_match(self, text, template, genre="pop"):
+        """Check if lyrics match the syllable and stress pattern with genre-specific flexibility."""
+        # Split text into words and count syllables
+        words = text.split()
+        syllable_count = sum(self.count_syllables(word) for word in words)
+        
+        # Get expected syllable count based on number of beats
+        expected_count = template['num_beats']
+        
+        # Get syllable-to-beat ratios based on genre
+        genre_lower = genre.lower()
+        if genre_lower in self.genre_syllable_ratios:
+            min_ratio, typical_ratio, max_ratio = self.genre_syllable_ratios[genre_lower]
+        else:
+            min_ratio, typical_ratio, max_ratio = self.genre_syllable_ratios['default']
+        
+        # Calculate flexible min and max syllable expectations based on genre
+        # Use extremely conservative ranges to enforce ultra-short lines
+        min_expected = max(1, int(expected_count * min_ratio))
+        max_expected = min(6, int(expected_count * max_ratio))  # Hard cap at 6 syllables
+        
+        # For 4/4 time signature, cap the max syllables per line even lower
+        if template['stress_pattern'] == "SWMW":  # 4/4 time
+            max_expected = min(max_expected, 6)  # Cap at 6 syllables max for 4/4
+            
+        # Record min and max expected in the template for future reference
+        template['min_expected'] = min_expected
+        template['max_expected'] = max_expected
+        
+        # Check if syllable count falls within genre-appropriate range
+        within_range = min_expected <= syllable_count <= max_expected
+        
+        # Consider typical ratio - how close are we to the ideal for this genre?
+        ideal_count = int(expected_count * typical_ratio)
+        # Ensure ideal count is also within our constrained range
+        ideal_count = max(min_expected, min(max_expected, ideal_count))
+        
+        # More lenient approach to determining "ideal"
+        # Count as ideal if within 1 syllable of the target instead of exact match
+        close_to_ideal = abs(syllable_count - ideal_count) <= 1
+        
+        closeness_to_ideal = 1.0 - min(abs(syllable_count - ideal_count) / (max_expected - min_expected + 1), 1.0)
+        
+        # Get detailed syllable breakdown for stress analysis
+        word_syllables = []
+        for word in words:
+            count = self.count_syllables(word)
+            word_syllables.append(count)
+        
+        # Analyze stress pattern match using a more flexible approach
+        stress_pattern = template['stress_pattern']
+        
+        # Simple stress matching algorithm (can be improved in future versions)
+        # We need to map syllables to beats in a more flexible way
+        syllable_to_beat_mapping = self._map_syllables_to_beats(word_syllables, stress_pattern)
+        
+        # Calculate stress match score based on alignment of stressed syllables with strong beats
+        stress_match_percentage = self._calculate_stress_match(words, word_syllables, syllable_to_beat_mapping, stress_pattern)
+        
+        # Consider a stress match if the percentage is high enough
+        stress_matches = stress_match_percentage >= 0.6  # Reduced from 0.7 to be more lenient
+        
+        return {
+            'syllable_count': syllable_count,
+            'expected_count': expected_count,
+            'min_expected': min_expected,
+            'max_expected': max_expected,
+            'within_range': within_range,
+            'matches_beat_count': syllable_count == expected_count,  # Exact match (strict)
+            'close_match': within_range,  # Flexible match (based on genre)
+            'stress_matches': stress_matches,
+            'stress_match_percentage': stress_match_percentage,
+            'closeness_to_ideal': closeness_to_ideal,
+            'word_syllables': word_syllables,
+            'ideal_syllable_count': ideal_count,
+            'close_to_ideal': close_to_ideal  # New field
+        }
+    
+    def _map_syllables_to_beats(self, word_syllables, stress_pattern):
+        """Map syllables to beats in a flexible way."""
+        total_syllables = sum(word_syllables)
+        total_beats = len(stress_pattern)
+        
+        # Simple mapping for now - this could be improved with more sophisticated algorithms
+        if total_syllables <= total_beats:
+            # Fewer syllables than beats - some beats have no syllables (prolongation)
+            mapping = []
+            syllable_index = 0
+            for beat_index in range(total_beats):
+                if syllable_index < total_syllables:
+                    mapping.append((syllable_index, beat_index))
+                    syllable_index += 1
+            return mapping
+        else:
+            # More syllables than beats - some beats have multiple syllables (melisma/syncopation)
+            mapping = []
+            syllables_per_beat = total_syllables / total_beats
+            for beat_index in range(total_beats):
+                start_syllable = int(beat_index * syllables_per_beat)
+                end_syllable = int((beat_index + 1) * syllables_per_beat)
+                for syllable_index in range(start_syllable, end_syllable):
+                    if syllable_index < total_syllables:
+                        mapping.append((syllable_index, beat_index))
+            return mapping
+    
+    def _calculate_stress_match(self, words, word_syllables, syllable_to_beat_mapping, stress_pattern):
+        """Calculate how well syllable stresses match beat stresses."""
+        # This is a simplified version - real stress analysis would be more complex
+        # For now, we'll assume the first syllable of each word is stressed
+        
+        # First, create a flat list of all syllables with their stress (1 = stressed, 0 = unstressed)
+        syllable_stresses = []
+        for word, syllable_count in zip(words, word_syllables):
+            # Simple assumption: first syllable is stressed, rest are unstressed
+            for i in range(syllable_count):
+                if i == 0:  # First syllable of word
+                    syllable_stresses.append(1)  # Stressed
+                else:
+                    syllable_stresses.append(0)  # Unstressed
+        
+        # Count matches between syllable stress and beat stress
+        matches = 0
+        total_mapped = 0
+        
+        for syllable_index, beat_index in syllable_to_beat_mapping:
+            if syllable_index < len(syllable_stresses):
+                syllable_stress = syllable_stresses[syllable_index]
+                beat_stress = 1 if stress_pattern[beat_index] == 'S' else (0.5 if stress_pattern[beat_index] == 'M' else 0)
+                
+                # Consider it a match if:
+                # - Stressed syllable on Strong beat
+                # - Unstressed syllable on Weak beat
+                # - Some partial credit for other combinations
+                if (syllable_stress == 1 and beat_stress > 0.5) or (syllable_stress == 0 and beat_stress < 0.5):
+                    matches += 1
+                elif syllable_stress == 1 and beat_stress == 0.5:  # Stressed syllable on Medium beat
+                    matches += 0.7
+                
+                total_mapped += 1
+        
+        if total_mapped == 0:
+            return 0
+            
+        return matches / total_mapped

emotionanalysis.py

@@ -1,5 +1,7 @@
 import librosa
 import numpy as np
+from scipy import signal
+from collections import Counter
 try:
     import matplotlib.pyplot as plt
 except ImportError:
@@ -7,8 +9,13 @@ except ImportError:
 from scipy.stats import mode
 import warnings
 warnings.filterwarnings('ignore')  # Suppress librosa warnings
+from beat_analysis import BeatAnalyzer  # Import BeatAnalyzer for rhythm analysis
+
 class MusicAnalyzer:
     def __init__(self):
+        # Create an instance of BeatAnalyzer for rhythm detection
+        self.beat_analyzer = BeatAnalyzer()
+        
         # Emotion feature mappings - these define characteristics of different emotions
         self.emotion_profiles = {
             'happy': {'tempo': (100, 180), 'energy': (0.6, 1.0), 'major_mode': True, 'brightness': (0.6, 1.0)},
@@ -56,8 +63,20 @@ class MusicAnalyzer:
         ac = librosa.autocorrelate(onset_env, max_size=sr // 2)
         ac = librosa.util.normalize(ac, norm=np.inf)
 
-        # Time signature estimation - a challenging task with many limitations
-        estimated_signature = self._estimate_time_signature(y, sr, beat_times, onset_env)
+        # Use BeatAnalyzer for advanced time signature detection
+        # We need to save the audio temporarily to use the BeatAnalyzer method
+        import tempfile
+        import soundfile as sf
+        
+        # Create a temporary file
+        with tempfile.NamedTemporaryFile(suffix='.wav', delete=True) as temp_file:
+            sf.write(temp_file.name, y, sr)
+            # Use BeatAnalyzer's advanced time signature detection
+            time_sig_result = self.beat_analyzer.detect_time_signature(temp_file.name)
+        
+        # Extract results from the time signature detection
+        estimated_signature = time_sig_result["time_signature"]
+        time_sig_confidence = time_sig_result["confidence"]
 
         # Compute onset strength to get a measure of rhythm intensity
         rhythm_intensity = np.mean(onset_env) / np.max(onset_env) if np.max(onset_env) > 0 else 0
@@ -65,49 +84,22 @@ class MusicAnalyzer:
         # Rhythm complexity based on variation in onset strength
         rhythm_complexity = np.std(onset_env) / np.mean(onset_env) if np.mean(onset_env) > 0 else 0
 
+        # Convert numpy arrays to regular Python types for JSON serialization
+        beat_times_list = [float(t) for t in beat_times.tolist()]
+        beat_intervals_list = [float(i) for i in beat_intervals.tolist()]
+
         return {
             "tempo": float(tempo),
-            "beat_times": beat_times.tolist(),
-            "beat_intervals": beat_intervals.tolist(),
+            "beat_times": beat_times_list,
+            "beat_intervals": beat_intervals_list,
             "beat_regularity": float(beat_regularity),
             "rhythm_intensity": float(rhythm_intensity),
             "rhythm_complexity": float(rhythm_complexity),
-            "estimated_time_signature": estimated_signature
+            "estimated_time_signature": estimated_signature,
+            "time_signature_confidence": float(time_sig_confidence),
+            "time_signature_candidates": time_sig_result.get("all_candidates", {})
         }
 
-    def _estimate_time_signature(self, y, sr, beat_times, onset_env):
-        """Estimate the time signature based on beat patterns"""
-        # This is a simplified approach - accurate time signature detection is complex
-        if len(beat_times) < 4:
-            return "Unknown"
-
-        # Analyze beat emphasis patterns to detect meter
-        beat_intervals = np.diff(beat_times)
-
-        # Look for periodicity in the onset envelope
-        ac = librosa.autocorrelate(onset_env, max_size=sr)
-
-        # Find peaks in autocorrelation after the first one (which is at lag 0)
-        peaks = librosa.util.peak_pick(ac, pre_max=20, post_max=20, pre_avg=20, post_avg=20, delta=0.1, wait=1)
-        peaks = peaks[peaks > 0]  # Remove the first peak which is at lag 0
-
-        if len(peaks) == 0:
-            return "4/4"  # Default to most common
-
-        # Convert first significant peak to beats
-        first_peak_time = peaks[0] / sr
-        beats_per_bar = round(first_peak_time / np.median(beat_intervals))
-
-        # Map to common time signatures
-        if beats_per_bar == 4 or beats_per_bar == 8:
-            return "4/4"
-        elif beats_per_bar == 3 or beats_per_bar == 6:
-            return "3/4"
-        elif beats_per_bar == 2:
-            return "2/4"
-        else:
-            return f"{beats_per_bar}/4"  # Default assumption
-
     def analyze_tonality(self, y, sr):
         """Analyze tonal features: key, mode, harmonic features"""
         # Compute chromagram
@@ -355,6 +347,26 @@ class MusicAnalyzer:
         emotion_data = self.analyze_emotion(rhythm_data, tonal_data, energy_data)
         theme_data = self.analyze_theme(rhythm_data, tonal_data, emotion_data)
 
+        # Convert any remaining numpy values to native Python types
+        def convert_numpy_to_python(obj):
+            if isinstance(obj, dict):
+                return {k: convert_numpy_to_python(v) for k, v in obj.items()}
+            elif isinstance(obj, list):
+                return [convert_numpy_to_python(item) for item in obj]
+            elif isinstance(obj, np.ndarray):
+                return obj.tolist()
+            elif isinstance(obj, np.number):
+                return float(obj)
+            else:
+                return obj
+
+        # Ensure all numpy values are converted
+        rhythm_data = convert_numpy_to_python(rhythm_data)
+        tonal_data = convert_numpy_to_python(tonal_data)
+        energy_data = convert_numpy_to_python(energy_data)
+        emotion_data = convert_numpy_to_python(emotion_data)
+        theme_data = convert_numpy_to_python(theme_data)
+
         # Combine all results
         return {
             "file": file_path,
@@ -364,7 +376,7 @@ class MusicAnalyzer:
             "emotion_analysis": emotion_data,
             "theme_analysis": theme_data,
             "summary": {
-                "tempo": rhythm_data["tempo"],
+                "tempo": float(rhythm_data["tempo"]),
                 "time_signature": rhythm_data["estimated_time_signature"],
                 "key": tonal_data["key"],
                 "mode": tonal_data["mode"],

requirements.txt

@@ -13,3 +13,4 @@ scipy>=1.12.0
 soundfile>=0.12.1
 matplotlib>=3.7.0 
 pronouncing>=0.2.0
+nltk>=3.8.1