beat_analysis.py

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