syllables trying second

app.py

@@ -403,11 +403,12 @@ def detect_sections(y, sr):
 
 # New function: Create flexible syllable templates
 def create_flexible_syllable_templates(beats_info):
-    """Create syllable templates based purely on beat patterns without assuming song structure."""
+    """Create detailed syllable templates based on beat patterns, capturing stress patterns."""
     # Get the beat times and strengths
     beat_times = beats_info["beat_times"]
     beat_strengths = beats_info.get("beat_strengths", [1.0] * len(beat_times))
     phrases = beats_info.get("phrases", [])
+    tempo = beats_info.get("tempo", 120)
     
     # If no phrases were detected, create a simple division
     if not phrases:
@@ -418,190 +419,124 @@ def create_flexible_syllable_templates(beats_info):
             if end_idx - i >= 2:  # Ensure at least 2 beats per phrase
                 phrases.append(list(range(i, end_idx)))
     
-    # Create syllable templates for each phrase
+    # Create enhanced syllable templates for each phrase
     syllable_templates = []
     
     for phrase in phrases:
-        # Calculate appropriate syllable count for this phrase
-        beat_count = len(phrase)
+        # Extract beat strengths for this phrase
         phrase_strengths = [beat_strengths[i] for i in phrase if i < len(beat_strengths)]
-        avg_strength = sum(phrase_strengths) / len(phrase_strengths) if phrase_strengths else 1.0
+        if not phrase_strengths:
+            phrase_strengths = [1.0] * len(phrase)
         
-        # Base calculation: 1-2 syllables per beat depending on tempo
-        tempo = beats_info.get("tempo", 120)
-        if tempo > 120:  # Fast tempo
-            syllables_per_beat = 1.0
-        elif tempo > 90:  # Medium tempo
-            syllables_per_beat = 1.5
-        else:  # Slow tempo
-            syllables_per_beat = 2.0
-            
-        # Adjust for beat strength
-        syllables_per_beat *= (0.8 + (avg_strength * 0.4))
-        
-        # Calculate total syllables for the phrase
-        phrase_syllables = int(beat_count * syllables_per_beat)
-        if phrase_syllables < 2:
-            phrase_syllables = 2
-            
-        syllable_templates.append(str(phrase_syllables))
-    
-    return "-".join(syllable_templates)
-
-# New function: Analyze flexible structure
-def analyze_flexible_structure(audio_data):
-    """Analyze music structure without assuming traditional song sections."""
-    y = audio_data["waveform"]
-    sr = audio_data["sample_rate"]
-    
-    # Enhanced beat detection
-    beats_info = detect_beats(y, sr)
-    
-    # Identify segments with similar audio features (using MFCC)
-    mfcc = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=13)
-    
-    # Use agglomerative clustering to find segment boundaries
-    segment_boundaries = librosa.segment.agglomerative(mfcc, 3)
-    segment_times = librosa.frames_to_time(segment_boundaries, sr=sr)
-    
-    # Create segments
-    segments = []
-    for i in range(len(segment_times)-1):
-        start = segment_times[i]
-        end = segment_times[i+1]
-        
-        # Find beats within this segment
-        segment_beats = []
-        for j, time in enumerate(beats_info["beat_times"]):
-            if start <= time < end:
-                segment_beats.append(j)
-        
-        # Create syllable template for this segment
-        if segment_beats:
-            segment_beats_info = {
-                "beat_times": [beats_info["beat_times"][j] for j in segment_beats],
-                "tempo": beats_info.get("tempo", 120)
-            }
+        # Normalize strengths for easier pattern recognition
+        if phrase_strengths:
+            max_strength = max(phrase_strengths)
+            if max_strength > 0:
+                norm_strengths = [s/max_strength for s in phrase_strengths]
+            else:
+                norm_strengths = [1.0] * len(phrase_strengths)
+        else:
+            norm_strengths = []
             
-            if "beat_strengths" in beats_info:
-                segment_beats_info["beat_strengths"] = [
-                    beats_info["beat_strengths"][j] for j in segment_beats 
-                    if j < len(beats_info["beat_strengths"])
-                ]
-                
-            if "intervals" in beats_info:
-                segment_beats_info["intervals"] = beats_info["intervals"]
+        # Identify strong and weak beats (S = strong, w = weak)
+        stress_pattern = []
+        for strength in norm_strengths:
+            if strength > 0.7:
+                stress_pattern.append("S")  # Strong beat
+            elif strength > 0.4:
+                stress_pattern.append("m")  # Medium beat
+            else:
+                stress_pattern.append("w")  # Weak beat
                 
-            if "phrases" in beats_info:
-                # Filter phrases to include only beats in this segment
-                segment_phrases = []
-                for phrase in beats_info["phrases"]:
-                    segment_phrase = [beat_idx for beat_idx in phrase if beat_idx in segment_beats]
-                    if len(segment_phrase) >= 2:
-                        segment_phrases.append(segment_phrase)
-                        
-                segment_beats_info["phrases"] = segment_phrases
-            
-            syllable_template = create_flexible_syllable_templates(segment_beats_info)
+        # Calculate appropriate syllable count based on tempo and beat pattern
+        if tempo > 160:
+            # Very fast tempo - typically one syllable per beat
+            syllables_per_beat = [1] * len(phrase)
+        elif tempo > 120:
+            # Fast tempo
+            syllables_per_beat = [1 if s == "S" or s == "m" else 1 for s in stress_pattern]
+        elif tempo > 90:
+            # Medium tempo
+            syllables_per_beat = [2 if s == "S" else 1 if s == "m" else 1 for s in stress_pattern]
         else:
-            syllable_template = "4"  # Default fallback
+            # Slow tempo
+            syllables_per_beat = [2 if s == "S" else 2 if s == "m" else 1 for s in stress_pattern]
         
-        segments.append({
-            "start": start,
-            "end": end,
-            "duration": end - start,
-            "syllable_template": syllable_template
-        })
+        # Create a detailed template with stress information
+        detailed_template = []
+        for i, (stress, syllable_count) in enumerate(zip(stress_pattern, syllables_per_beat)):
+            if stress == "S":
+                # Mark strong beat with capital letter followed by syllable count
+                detailed_template.append(f"S{syllable_count}")
+            elif stress == "m":
+                # Mark medium beat with lowercase letter
+                detailed_template.append(f"m{syllable_count}")
+            else:
+                # Mark weak beat with lowercase letter
+                detailed_template.append(f"w{syllable_count}")
+        
+        # Join all beat templates for this phrase
+        phrase_template = "-".join(detailed_template)
+        syllable_templates.append(phrase_template)
     
-    return {
-        "beats": beats_info,
-        "segments": segments
-    }
+    # Join all phrase templates
+    return "|".join(syllable_templates)
 
-# Enhanced estimate_syllables_per_section function
-def estimate_syllables_per_section(beats_info, sections):
-    """Estimate the number of syllables needed for each section based on beats."""
-    syllables_per_section = []
+# Helper function to convert technical templates to human-readable instructions
+def format_syllable_templates_for_prompt(syllable_templates):
+    """Convert technical syllable templates into clear, human-readable instructions."""
+    if not syllable_templates:
+        return ""
     
-    for section in sections:
-        # Find beats that fall within this section
-        section_beats = [
-            beat for beat in beats_info["beat_times"] 
-            if section["start"] <= beat < section["end"]
-        ]
-        
-        # Calculate syllables based on section type and beat count
-        beat_count = len(section_beats)
-        
-        # Extract beat strengths for this section if available
-        section_beat_strengths = []
-        if "beat_strengths" in beats_info:
-            for i, beat_time in enumerate(beats_info["beat_times"]):
-                if section["start"] <= beat_time < section["end"] and i < len(beats_info["beat_strengths"]):
-                    section_beat_strengths.append(beats_info["beat_strengths"][i])
+    # Check if we're dealing with the enhanced format or the old format
+    if isinstance(syllable_templates, str) and "|" in syllable_templates:
+        # Enhanced format with stress patterns
+        phrases = syllable_templates.split("|")
         
-        # Create a segment-specific beat info structure for template creation
-        segment_beats_info = {
-            "beat_times": section_beats,
-            "tempo": beats_info.get("tempo", 120)
-        }
-        
-        if section_beat_strengths:
-            segment_beats_info["beat_strengths"] = section_beat_strengths
+        instructions = []
+        for i, phrase in enumerate(phrases):
+            beats = phrase.split("-")
+            beat_instructions = []
             
-        if "intervals" in beats_info:
-            segment_beats_info["intervals"] = beats_info["intervals"]
+            for beat in beats:
+                if beat.startswith("S"):
+                    # Strong beat
+                    count = beat[1:]
+                    beat_instructions.append(f"STRONG({count})")
+                elif beat.startswith("m"):
+                    # Medium beat
+                    count = beat[1:]
+                    beat_instructions.append(f"medium({count})")
+                elif beat.startswith("w"):
+                    # Weak beat
+                    count = beat[1:]
+                    beat_instructions.append(f"weak({count})")
+                else:
+                    # Fallback for old format
+                    beat_instructions.append(beat)
             
-        # Create a detailed syllable template for this section
-        syllable_template = create_flexible_syllable_templates(segment_beats_info)
+            line_desc = " → ".join(beat_instructions)
+            instructions.append(f"Line {i+1}: {line_desc}")
         
-        # Calculate estimated syllable count
-        expected_counts = [int(count) for count in syllable_template.split("-")]
-        total_syllables = sum(expected_counts)
+        return "\n".join(instructions)
+    else:
+        # Handle the original format or segment dictionaries
+        formatted_lines = []
         
-        syllables_per_section.append({
-            "type": section["type"],
-            "start": section["start"],
-            "end": section["end"],
-            "duration": section["duration"],
-            "beat_count": beat_count,
-            "syllable_count": total_syllables,
-            "syllable_template": syllable_template
-        })
-    
-    return syllables_per_section
-
-def calculate_detailed_song_structure(audio_data):
-    """Calculate detailed song structure for better lyrics generation."""
-    y = audio_data["waveform"]
-    sr = audio_data["sample_rate"]
-    
-    # Enhanced beat detection
-    beats_info = detect_beats(y, sr)
-    
-    # Detect sections
-    sections = detect_sections(y, sr)
-    
-    # Create enhanced syllable info per section
-    syllables_info = estimate_syllables_per_section(beats_info, sections)
-    
-    # Get flexible structure analysis as an alternative approach
-    try:
-        flexible_structure = analyze_flexible_structure(audio_data)
-    except Exception as e:
-        print(f"Warning: Flexible structure analysis failed: {str(e)}")
-        flexible_structure = None
-    
-    return {
-        "beats": beats_info,
-        "sections": sections,
-        "syllables": syllables_info,
-        "flexible_structure": flexible_structure
-    }
+        if isinstance(syllable_templates, list):
+            for i, template in enumerate(syllable_templates):
+                if isinstance(template, dict) and "syllable_template" in template:
+                    formatted_lines.append(f"Line {i+1}: {template['syllable_template']} syllables")
+                elif isinstance(template, str):
+                    formatted_lines.append(f"Line {i+1}: {template} syllables")
+            
+            return "\n".join(formatted_lines)
+        
+        return str(syllable_templates)
 
-# New function: Verify syllable counts
+# Enhanced verification function to check syllable counts and stress patterns
 def verify_flexible_syllable_counts(lyrics, templates):
-    """Verify that the generated lyrics match the required syllable counts."""
+    """Verify that the generated lyrics match the required syllable counts and stress patterns."""
     # Split lyrics into lines
     lines = [line.strip() for line in lyrics.split("\n") if line.strip()]
     
@@ -616,31 +551,101 @@ def verify_flexible_syllable_counts(lyrics, templates):
         
         # Handle different template formats
         if isinstance(template, dict) and "syllable_template" in template:
-            expected_counts = [int(count) for count in template["syllable_template"].split("-")]
+            template_str = template["syllable_template"]
         elif isinstance(template, str):
-            expected_counts = [int(count) for count in template.split("-")]
+            template_str = template
         else:
             continue
         
+        # Parse the enhanced template format if present
+        if "|" in template_str:
+            # This is a phrase, take just the first part for now
+            template_str = template_str.split("|")[0]
+        
+        # Count expected syllables
+        total_expected = 0
+        
+        # Handle the enhanced format with stress patterns
+        if "-" in template_str and any(x in template_str for x in ["S", "m", "w"]):
+            beats = template_str.split("-")
+            expected_counts = []
+            
+            for beat in beats:
+                if beat.startswith(("S", "m", "w")):
+                    try:
+                        count = int(beat[1:])
+                        expected_counts.append(count)
+                        total_expected += count
+                    except ValueError:
+                        expected_counts.append(1)
+                        total_expected += 1
+                else:
+                    try:
+                        count = int(beat)
+                        expected_counts.append(count)
+                        total_expected += count
+                    except ValueError:
+                        expected_counts.append(1)
+                        total_expected += 1
+        else:
+            # Old format - simple numbers separated by hyphens
+            try:
+                expected_counts = [int(count) for count in template_str.split("-")]
+                total_expected = sum(expected_counts)
+            except ValueError:
+                # Fallback if we can't parse the template
+                expected_counts = []
+                total_expected = 0
+        
         # Count actual syllables
         actual_count = count_syllables(line)
         
         # Calculate difference
-        total_expected = sum(expected_counts)
-        if abs(actual_count - total_expected) > 2:  # Allow small differences
+        if total_expected > 0 and abs(actual_count - total_expected) > 2:  # Allow small differences
             verification_notes.append(f"Line {i+1}: Expected {total_expected} syllables, got {actual_count}")
+            
+            # Additionally check if stressed syllables align with strong beats
+            words = re.findall(r'\b[a-zA-Z]+\b', line.lower())
+            if words and expected_counts and "S" in template_str:
+                # Try to find strong beats in the template
+                strong_beat_positions = []
+                current_pos = 0
+                
+                for j, beat in enumerate(template_str.split("-")):
+                    if beat.startswith("S"):
+                        beat_count = int(beat[1:]) if len(beat) > 1 else 1
+                        strong_beat_positions.append(current_pos)
+                        current_pos += beat_count
+                    else:
+                        beat_count = int(beat[1:]) if len(beat) > 1 else 1
+                        current_pos += beat_count
+                
+                # Try to get pronunciations for words to check stress alignment
+                word_stresses = []
+                for word in words:
+                    pronunciations = pronouncing.phones_for_word(word)
+                    if pronunciations:
+                        stress_pattern = pronouncing.stresses(pronunciations[0])
+                        word_stresses.append(stress_pattern)
+                
+                # Add note about stress alignment if we have enough information
+                if word_stresses and strong_beat_positions and len(word_stresses) >= len(strong_beat_positions):
+                    verification_notes.append(f"  → Check stress alignment on words with strong beats")
     
     # If we found issues, add them as notes at the end of the lyrics
     if verification_notes:
         lyrics += "\n\n[Note: Potential rhythm mismatches in these lines:]\n"
         lyrics += "\n".join(verification_notes)
-        lyrics += "\n[You may want to adjust these lines to match the music's rhythm better]"
+        lyrics += "\n\n[To fix mismatches:]\n"
+        lyrics += "1. Make sure stressed syllables fall on STRONG beats\n"
+        lyrics += "2. Adjust syllable counts to match the template\n"
+        lyrics += "3. Try using words with naturally aligned stress patterns"
     
     return lyrics
 
 # Modified generate_lyrics function
 def generate_lyrics(genre, duration, emotion_results, song_structure=None):
-    """Generate lyrics based on the genre, emotion, and structure analysis."""
+    """Generate lyrics based on the genre, emotion, and structure analysis with enhanced rhythmic alignment."""
     # Extract emotion and theme data from analysis results
     primary_emotion = emotion_results["emotion_analysis"]["primary_emotion"]
     primary_theme = emotion_results["theme_analysis"]["primary_theme"]
@@ -663,39 +668,119 @@ def generate_lyrics(genre, duration, emotion_results, song_structure=None):
         if "flexible_structure" in song_structure and song_structure["flexible_structure"]:
             flexible = song_structure["flexible_structure"]
             if "segments" in flexible and flexible["segments"]:
-                syllable_guidance = "Follow these exact syllable patterns for each line:\n"
+                # Get the segments
+                segments = flexible["segments"]
                 
-                for i, segment in enumerate(flexible["segments"]):
+                # Process each segment to create enhanced rhythmic templates
+                enhanced_templates = []
+                
+                for i, segment in enumerate(segments):
                     if i < 15:  # Limit to 15 lines to keep prompt manageable
-                        syllable_guidance += f"Line {i+1}: {segment['syllable_template']} syllables\n"
-                        templates_for_verification.append(segment["syllable_template"])
+                        # Get the beat information for this segment
+                        segment_start = segment["start"]
+                        segment_end = segment["end"]
+                        
+                        # Find beats within this segment
+                        segment_beats = []
+                        beat_times = flexible["beats"]["beat_times"]
+                        beat_strengths = flexible["beats"].get("beat_strengths", [])
+                        
+                        for j, beat_time in enumerate(beat_times):
+                            if segment_start <= beat_time < segment_end:
+                                # Add this beat to the segment
+                                segment_beats.append(j)
+                        
+                        # Create segment-specific beat info
+                        segment_beats_info = {
+                            "beat_times": [beat_times[j] for j in segment_beats],
+                            "tempo": flexible["beats"].get("tempo", 120)
+                        }
+                        
+                        if beat_strengths:
+                            segment_beats_info["beat_strengths"] = [
+                                beat_strengths[j] for j in segment_beats 
+                                if j < len(beat_strengths)
+                            ]
+                        
+                        # Create a phrase structure for this segment
+                        segment_beats_info["phrases"] = [segment_beats]
+                        
+                        # Generate enhanced template
+                        enhanced_template = create_flexible_syllable_templates(segment_beats_info)
+                        enhanced_templates.append(enhanced_template)
+                        templates_for_verification.append(enhanced_template)
+                
+                # Format templates for the prompt
+                syllable_guidance = "CRITICAL RHYTHM INSTRUCTIONS:\n"
+                syllable_guidance += "Match each line exactly to this rhythm pattern (STRONG beats need stressed syllables):\n\n"
+                syllable_guidance += format_syllable_templates_for_prompt(enhanced_templates)
+                
+                # Add explanation of notation
+                syllable_guidance += "\n\nWhere:\n"
+                syllable_guidance += "- STRONG(n): Place a STRESSED syllable here, followed by (n-1) unstressed syllables\n"
+                syllable_guidance += "- medium(n): Place a medium-stressed or unstressed syllable here, followed by (n-1) unstressed syllables\n"
+                syllable_guidance += "- weak(n): Place unstressed syllables here\n"
+                syllable_guidance += "- →: Indicates flow from one beat to the next within a line\n"
         
         # Fallback to traditional sections if needed
         elif "syllables" in song_structure and song_structure["syllables"]:
-            syllable_guidance = "Follow these syllable patterns for each section:\n"
+            syllable_guidance = "RHYTHM PATTERN INSTRUCTIONS:\n"
+            syllable_guidance += "Follow these syllable patterns for each section:\n\n"
             
             for section in song_structure["syllables"]:
                 if "syllable_template" in section:
-                    syllable_guidance += f"[{section['type'].capitalize()}]: {section['syllable_template']} syllables per line\n"
+                    # Process to create enhanced template
+                    section_beats_info = {
+                        "beat_times": [beat for beat in song_structure["beats"]["beat_times"] 
+                                       if section["start"] <= beat < section["end"]],
+                        "tempo": song_structure["beats"].get("tempo", 120)
+                    }
+                    
+                    if "beat_strengths" in song_structure["beats"]:
+                        section_beats_info["beat_strengths"] = [
+                            strength for i, strength in enumerate(song_structure["beats"]["beat_strengths"])
+                            if i < len(song_structure["beats"]["beat_times"]) and
+                            section["start"] <= song_structure["beats"]["beat_times"][i] < section["end"]
+                        ]
+                    
+                    # Create a phrase structure for this section
+                    section_beats_info["phrases"] = [list(range(len(section_beats_info["beat_times"])))]
+                    
+                    # Generate enhanced template
+                    enhanced_template = create_flexible_syllable_templates(section_beats_info)
+                    
+                    syllable_guidance += f"[{section['type'].capitalize()}]:\n"
+                    syllable_guidance += format_syllable_templates_for_prompt(enhanced_template) + "\n\n"
+                    templates_for_verification.append(section)
                 elif "syllable_count" in section:
                     syllable_guidance += f"[{section['type'].capitalize()}]: ~{section['syllable_count']} syllables total\n"
-                
-                if "syllable_template" in section:
-                    templates_for_verification.append(section)
     
     # If we couldn't get specific templates, use general guidance
     if not syllable_guidance:
-        syllable_guidance = "Make sure each line has an appropriate syllable count for singing:\n"
-        syllable_guidance += "- For faster sections (tempo > 120 BPM): 4-6 syllables per line\n"
-        syllable_guidance += "- For medium tempo sections: 6-8 syllables per line\n"
-        syllable_guidance += "- For slower sections (tempo < 90 BPM): 8-10 syllables per line\n"
+        syllable_guidance = "RHYTHM ALIGNMENT INSTRUCTIONS:\n\n"
+        syllable_guidance += "1. Align stressed syllables with strong beats (usually beats 1 and 3 in 4/4 time)\n"
+        syllable_guidance += "2. Use unstressed syllables on weak beats (usually beats 2 and 4 in 4/4 time)\n"
+        syllable_guidance += "3. Use appropriate syllable counts based on tempo:\n"
+        syllable_guidance += "   - Fast tempo (>120 BPM): 4-6 syllables per line\n"
+        syllable_guidance += "   - Medium tempo (90-120 BPM): 6-8 syllables per line\n"
+        syllable_guidance += "   - Slow tempo (<90 BPM): 8-10 syllables per line\n"
+    
+    # Add examples of syllable-beat alignment with stress patterns
+    syllable_guidance += "\nEXAMPLES OF PERFECT RHYTHM ALIGNMENT:\n"
+    syllable_guidance += "Pattern: STRONG(1) → weak(1) → medium(1) → weak(1)\n"
+    syllable_guidance += "Lyric: 'HEAR the MU-sic PLAY'\n"
+    syllable_guidance += "        ↑     ↑    ↑    ↑\n"
+    syllable_guidance += "        S     w    m    w    <- BEAT TYPE\n\n"
     
-    # Add examples of syllable counting
-    syllable_guidance += "\nExamples of syllable counting:\n"
-    syllable_guidance += "- 'I can see the light' = 4 syllables\n"
-    syllable_guidance += "- 'When it fades a-way' = 4 syllables\n"
-    syllable_guidance += "- 'The sun is shin-ing bright to-day' = 8 syllables\n"
-    syllable_guidance += "- 'I'll be wait-ing for you' = 6 syllables\n"
+    syllable_guidance += "Pattern: STRONG(2) → weak(1) → STRONG(1) → weak(2)\n"
+    syllable_guidance += "Lyric: 'DANC-ing TO the RHYTHM of LOVE'\n"
+    syllable_guidance += "        ↑    ↑  ↑   ↑     ↑  ↑\n"
+    syllable_guidance += "        S    S  w   S     w  w    <- BEAT TYPE\n\n"
+    
+    syllable_guidance += "Pattern: STRONG(1) → medium(2) → STRONG(1) → weak(1)\n"
+    syllable_guidance += "Lyric: 'TIME keeps FLOW-ing ON and ON'\n"
+    syllable_guidance += "        ↑     ↑    ↑   ↑  ↑   ↑\n"
+    syllable_guidance += "        S     m    m   S  w   w    <- BEAT TYPE\n\n"
     
     # Determine if we should use traditional sections or not
     use_sections = True
@@ -706,55 +791,35 @@ def generate_lyrics(genre, duration, emotion_results, song_structure=None):
             if len(segments) > 4:
                 use_sections = False
     
-    # Create enhanced prompt for the LLM
-    if use_sections:
-        # Traditional approach with sections
-        # Calculate appropriate lyrics length and section distribution
-        try:
-            if song_structure and "beats" in song_structure:
-                beats_info = song_structure["beats"]
-                tempo = beats_info.get("tempo", 120)
-                time_signature = beats_info.get("time_signature", 4)
-                lines_structure = calculate_lyrics_length(duration, tempo, time_signature)
+    # Calculate appropriate lyrics length and section distribution
+    try:
+        if song_structure and "beats" in song_structure:
+            beats_info = song_structure["beats"]
+            tempo = beats_info.get("tempo", 120)
+            time_signature = beats_info.get("time_signature", 4)
+            lines_structure = calculate_lyrics_length(duration, tempo, time_signature)
+            
+            # Handle both possible return types
+            if isinstance(lines_structure, dict):
+                total_lines = lines_structure["lines_count"]
                 
-                # Handle both possible return types
-                if isinstance(lines_structure, dict):
-                    total_lines = lines_structure["lines_count"]
-                    
-                    # Extract section line counts if available
-                    verse_lines = 0
-                    chorus_lines = 0
-                    bridge_lines = 0
-                    
-                    for section in lines_structure["sections"]:
-                        if section["type"] == "verse":
-                            verse_lines = section["lines"]
-                        elif section["type"] == "chorus":
-                            chorus_lines = section["lines"]
-                        elif section["type"] == "bridge":
-                            bridge_lines = section["lines"]
-                else:
-                    # The function returned just an integer (old behavior)
-                    total_lines = lines_structure
-                    
-                    # Default section distribution based on total lines
-                    if total_lines <= 6:
-                        verse_lines = 2
-                        chorus_lines = 2
-                        bridge_lines = 0
-                    elif total_lines <= 10:
-                        verse_lines = 3
-                        chorus_lines = 2
-                        bridge_lines = 0
-                    else:
-                        verse_lines = 3
-                        chorus_lines = 2
-                        bridge_lines = 2
+                # Extract section line counts if available
+                verse_lines = 0
+                chorus_lines = 0
+                bridge_lines = 0
+                
+                for section in lines_structure["sections"]:
+                    if section["type"] == "verse":
+                        verse_lines = section["lines"]
+                    elif section["type"] == "chorus":
+                        chorus_lines = section["lines"]
+                    elif section["type"] == "bridge":
+                        bridge_lines = section["lines"]
             else:
-                # Fallback to simple calculation
-                total_lines = max(4, int(duration / 10))
+                # The function returned just an integer (old behavior)
+                total_lines = lines_structure
                 
-                # Default section distribution
+                # Default section distribution based on total lines
                 if total_lines <= 6:
                     verse_lines = 2
                     chorus_lines = 2
@@ -767,15 +832,35 @@ def generate_lyrics(genre, duration, emotion_results, song_structure=None):
                     verse_lines = 3
                     chorus_lines = 2
                     bridge_lines = 2
-        except Exception as e:
-            print(f"Error calculating lyrics length: {str(e)}")
+        else:
+            # Fallback to simple calculation
             total_lines = max(4, int(duration / 10))
             
             # Default section distribution
-            verse_lines = 3
-            chorus_lines = 2
-            bridge_lines = 0
+            if total_lines <= 6:
+                verse_lines = 2
+                chorus_lines = 2
+                bridge_lines = 0
+            elif total_lines <= 10:
+                verse_lines = 3
+                chorus_lines = 2
+                bridge_lines = 0
+            else:
+                verse_lines = 3
+                chorus_lines = 2
+                bridge_lines = 2
+    except Exception as e:
+        print(f"Error calculating lyrics length: {str(e)}")
+        total_lines = max(4, int(duration / 10))
         
+        # Default section distribution
+        verse_lines = 3
+        chorus_lines = 2
+        bridge_lines = 0
+    
+    # Create enhanced prompt with better rhythm alignment instructions
+    if use_sections:
+        # Traditional approach with sections
         prompt = f"""
 You are a talented songwriter who specializes in {genre} music.
 Write original {genre} song lyrics for a song that is {duration:.1f} seconds long.
@@ -786,14 +871,14 @@ Music analysis has detected the following qualities in the music:
 - Primary emotion: {primary_emotion}
 - Primary theme: {primary_theme}
 
-IMPORTANT: The lyrics must match the rhythm of the music exactly!
 {syllable_guidance}
 
-When writing the lyrics:
-1. Count syllables carefully for each line to match the specified pattern
-2. Ensure words fall naturally on the beat
-3. Place stressed syllables on strong beats
-4. Create a coherent theme throughout the lyrics
+CRITICAL PRINCIPLES FOR RHYTHMIC ALIGNMENT:
+1. STRESSED syllables MUST fall on STRONG beats (marked with STRONG in the pattern)
+2. Natural word stress patterns must match the beat strength (strong words on strong beats)
+3. Line breaks should occur at phrase endings for natural breathing
+4. Consonant clusters should be avoided on fast notes and strong beats
+5. Open vowels (a, e, o) work better for sustained notes and syllables
 
 The lyrics should:
 - Perfectly capture the essence and style of {genre} music
@@ -820,14 +905,19 @@ Music analysis has detected the following qualities:
 - Primary emotion: {primary_emotion}
 - Primary theme: {primary_theme}
 
-IMPORTANT: The lyrics must match the rhythm of the music exactly!
 {syllable_guidance}
 
-When writing the lyrics:
-1. Count syllables carefully for each line to match the specified pattern
-2. Ensure words fall naturally on the beat
-3. Place stressed syllables on strong beats
-4. Create coherent lyrics that would work for this music segment
+CRITICAL PRINCIPLES FOR RHYTHMIC ALIGNMENT:
+1. STRESSED syllables MUST fall on STRONG beats (marked with STRONG in the pattern)
+2. Natural word stress patterns must match the beat strength (strong words on strong beats)
+3. Line breaks should occur at phrase endings for natural breathing
+4. Consonant clusters should be avoided on fast notes and strong beats
+5. Open vowels (a, e, o) work better for sustained notes and syllables
+
+For perfect alignment examples:
+- "FEEL the RHY-thm in your SOUL" – stressed syllables on strong beats
+- "to-DAY we DANCE a-LONG" – natural speech stress matches musical stress
+- "WAIT-ing FOR the SUN to RISE" – syllable emphasis aligns with beat emphasis
 
 The lyrics should:
 - Perfectly capture the essence and style of {genre} music
@@ -837,7 +927,7 @@ The lyrics should:
 - Match the audio segment duration of {duration:.1f} seconds
 
 DON'T include any section labels like [Verse] or [Chorus] unless specifically instructed.
-Instead, write lyrics that flow naturally and match the music's rhythm.
+Instead, write lyrics that flow naturally and match the music's rhythm precisely.
 
 Your lyrics:
 """
@@ -898,7 +988,7 @@ def process_audio(audio_file):
             is_music, ast_results = detect_music(audio_data)
         except Exception as e:
             print(f"Error in music detection: {str(e)}")
-            return f"Error in music detection: {str(e)}", None, []
+            return f"Error in music detection: {str(e)}", None, ast_results
             
         if not is_music:
             return "The uploaded audio does not appear to be music. Please upload a music file.", None, ast_results