push

app.py

@@ -1677,6 +1677,11 @@ def generate_lyrics(genre, duration, emotion_results, song_structure=None):
     syllable_guidance = ""
     templates_for_verification = []
     
+    # Create a structure visualization to help with lyrics-music matching
+    structure_visualization = "=== MUSIC-LYRICS STRUCTURE MATCHING ===\n\n"
+    structure_visualization += f"Song Duration: {duration:.1f} seconds\n"
+    structure_visualization += f"Tempo: {tempo:.1f} BPM\n\n"
+    
     if song_structure:
         # Try to use flexible structure if available
         if "flexible_structure" in song_structure and song_structure["flexible_structure"]:
@@ -1685,15 +1690,22 @@ def generate_lyrics(genre, duration, emotion_results, song_structure=None):
                 # Get the segments
                 segments = flexible["segments"]
                 
+                # Add structure visualization
+                structure_visualization += f"Total segments: {len(segments)}\n"
+                structure_visualization += "Each segment represents one musical phrase for which you should write ONE line of lyrics.\n\n"
+                
                 # 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
+                    if i < 30:  # Extend limit to 30 lines to handle longer songs
                         # Get the beat information for this segment
                         segment_start = segment["start"]
                         segment_end = segment["end"]
                         
+                        # Add segment info to visualization
+                        structure_visualization += f"Segment {i+1}: {segment_start:.1f}s - {segment_end:.1f}s (duration: {segment_end-segment_start:.1f}s)\n"
+                        
                         # Find beats within this segment
                         segment_beats = []
                         beat_times = flexible["beats"]["beat_times"]
@@ -1727,24 +1739,129 @@ def generate_lyrics(genre, duration, emotion_results, song_structure=None):
                         )
                         enhanced_templates.append(enhanced_template)
                         templates_for_verification.append(enhanced_template)
+                        
+                        # Add template to visualization
+                        structure_visualization += f"  Template: {enhanced_template}\n"
+                
+                # Use these templates to determine verse/chorus structure based on similar patterns
+                # This is a simple version - could be enhanced with more sophisticated pattern detection
+                section_types = []
+                pattern_groups = {}
+                
+                for i, template in enumerate(enhanced_templates):
+                    # Create simplified version for pattern matching
+                    simple_pattern = template.replace("(", "").replace(")", "").replace(":", "")
+                    
+                    # Check if this pattern is similar to any we've seen
+                    found_match = False
+                    for group, patterns in pattern_groups.items():
+                        if any(simple_pattern == p.replace("(", "").replace(")", "").replace(":", "") for p in patterns):
+                            pattern_groups[group].append(template)
+                            section_types.append(group)
+                            found_match = True
+                            break
+                    
+                    if not found_match:
+                        # New pattern type
+                        group_name = f"Group_{len(pattern_groups) + 1}"
+                        pattern_groups[group_name] = [template]
+                        section_types.append(group_name)
+                
+                # Map pattern groups to verse/chorus/bridge based on common structures
+                section_mapping = {}
+                if len(pattern_groups) >= 1:
+                    # Assume the most common pattern is the verse
+                    most_common = max(pattern_groups.items(), key=lambda x: len(x[1]))[0]
+                    section_mapping[most_common] = "verse"
+                
+                if len(pattern_groups) >= 2:
+                    # Second most common might be chorus
+                    sorted_groups = sorted(pattern_groups.items(), key=lambda x: len(x[1]), reverse=True)
+                    if len(sorted_groups) > 1:
+                        section_mapping[sorted_groups[1][0]] = "chorus"
+                
+                if len(pattern_groups) >= 3:
+                    # Third pattern could be bridge
+                    sorted_groups = sorted(pattern_groups.items(), key=lambda x: len(x[1]), reverse=True)
+                    if len(sorted_groups) > 2:
+                        section_mapping[sorted_groups[2][0]] = "bridge"
+                
+                # Update section types using the mapping
+                mapped_section_types = []
+                for section_type in section_types:
+                    if section_type in section_mapping:
+                        mapped_section_types.append(section_mapping[section_type])
+                    else:
+                        mapped_section_types.append("verse")  # Default to verse
+                
+                # Add structure visualization with section types
+                structure_visualization += "\nPredicted Song Structure:\n"
+                for i, section_type in enumerate(mapped_section_types):
+                    if i < len(enhanced_templates):
+                        structure_visualization += f"Line {i+1}: [{section_type.upper()}] {enhanced_templates[i]}\n"
+                
+                # Calculate total line count
+                total_lines = len(enhanced_templates)
+                verse_lines = mapped_section_types.count("verse")
+                chorus_lines = mapped_section_types.count("chorus")
+                bridge_lines = mapped_section_types.count("bridge")
                 
-                # Format templates with improved formatting
+                # Add summary
+                structure_visualization += f"\nTotal Lines Required: {total_lines}\n"
+                structure_visualization += f"Verse Lines: {verse_lines}\n"
+                structure_visualization += f"Chorus Lines: {chorus_lines}\n"
+                structure_visualization += f"Bridge Lines: {bridge_lines}\n"
+                
+                # Format templates with improved formatting 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,
-                    arrow="→",
-                    line_wrap=8
-                )
+                syllable_guidance += "Each line of lyrics MUST match exactly with one musical phrase/segment.\n"
+                syllable_guidance += "Follow these rhythm patterns for each line (STRONG beats need stressed syllables):\n\n"
+                
+                # Add section headers to formatted templates
+                formatted_templates = []
+                for i, template in enumerate(enhanced_templates):
+                    if i < len(mapped_section_types):
+                        section_type = mapped_section_types[i].upper()
+                        if i > 0 and mapped_section_types[i] != mapped_section_types[i-1]:
+                            # New section
+                            formatted_templates.append(f"\n[{section_type}]")
+                        elif i == 0:
+                            # First section
+                            formatted_templates.append(f"[{section_type}]")
+                    formatted_templates.append(format_syllable_templates_for_prompt([template], arrow="→", line_wrap=8))
+                
+                syllable_guidance += "\n".join(formatted_templates)
+                
+                # Store info for later use in traditional sections approach
+                use_sections = True
+                
+                # Use the detected section structure for traditional approach
+                if verse_lines > 0:
+                    verse_lines = min(verse_lines, total_lines // 2)  # Ensure reasonable limits
+                else:
+                    verse_lines = total_lines // 2
+                    
+                if chorus_lines > 0:
+                    chorus_lines = min(chorus_lines, total_lines // 3)
+                else:
+                    chorus_lines = total_lines // 3
+                    
+                if bridge_lines > 0:
+                    bridge_lines = min(bridge_lines, total_lines // 6)
+                else:
+                    bridge_lines = 0
                 
-                # Note: The enhanced formatter now automatically includes explanations
-        
         # Fallback to traditional sections if needed
         elif "syllables" in song_structure and song_structure["syllables"]:
             syllable_guidance = "RHYTHM PATTERN INSTRUCTIONS:\n"
-            syllable_guidance += "Follow these syllable patterns for each section:\n\n"
+            syllable_guidance += "Follow these syllable patterns for each section. Each line should match ONE phrase:\n\n"
+            
+            # Count sections for visualization
+            section_counts = {"verse": 0, "chorus": 0, "bridge": 0, "intro": 0, "outro": 0}
             
             for section in song_structure["syllables"]:
+                section_counts[section["type"]] = section_counts.get(section["type"], 0) + 1
+                
                 if "syllable_template" in section:
                     # Process to create enhanced template
                     section_beats_info = {
@@ -1779,6 +1896,20 @@ def generate_lyrics(genre, duration, emotion_results, song_structure=None):
                     templates_for_verification.append(section)
                 elif "syllable_count" in section:
                     syllable_guidance += f"[{section['type'].capitalize()}]: ~{section['syllable_count']} syllables total\n"
+            
+            # Create structure visualization
+            structure_visualization += "Using traditional section-based structure:\n"
+            for section_type, count in section_counts.items():
+                if count > 0:
+                    structure_visualization += f"{section_type.capitalize()}: {count} sections\n"
+            
+            # Set traditional section counts
+            verse_lines = max(2, section_counts.get("verse", 0) * 4)
+            chorus_lines = max(2, section_counts.get("chorus", 0) * 4)
+            bridge_lines = max(0, section_counts.get("bridge", 0) * 2)
+            
+            # Use sections approach
+            use_sections = True
     
     # If we couldn't get specific templates, use general guidance
     if not syllable_guidance:
@@ -1789,6 +1920,21 @@ def generate_lyrics(genre, duration, emotion_results, song_structure=None):
         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"
+        
+        # Create basic structure visualization
+        structure_visualization += "Using estimated structure (no detailed analysis available):\n"
+        
+        # Calculate rough section counts based on duration
+        estimated_lines = max(8, int(duration / 10))
+        structure_visualization += f"Estimated total lines: {estimated_lines}\n"
+        
+        # Set traditional section counts based on duration
+        verse_lines = estimated_lines // 2
+        chorus_lines = estimated_lines // 3
+        bridge_lines = estimated_lines // 6 if estimated_lines > 12 else 0
+        
+        # Use sections approach
+        use_sections = True
     
     # Add examples of syllable-beat alignment with enhanced format
     syllable_guidance += "\nEXAMPLES OF PERFECT RHYTHM ALIGNMENT:\n"
@@ -1833,8 +1979,10 @@ def generate_lyrics(genre, duration, emotion_results, song_structure=None):
     # Add genre guidance to the main guidance
     syllable_guidance += genre_guidance
     
-    # Determine if we should use traditional sections or not
-    use_sections = True
+    # Store the syllable guidance for later use
+    syllable_guidance_text = syllable_guidance
+    
+    # Determine if we should use traditional sections or not based on structure
     if song_structure and "flexible_structure" in song_structure and song_structure["flexible_structure"]:
         # If we have more than 4 segments, it's likely not a traditional song structure
         if "segments" in song_structure["flexible_structure"]:
@@ -1842,73 +1990,6 @@ def generate_lyrics(genre, duration, emotion_results, song_structure=None):
             if len(segments) > 4:
                 use_sections = False
     
-    # 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"]
-                
-                # 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
-        else:
-            # Fallback to simple calculation
-            total_lines = max(4, int(duration / 10))
-            
-            # Default section distribution
-            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
@@ -1939,14 +2020,12 @@ Think step by step about how to match words to the rhythm pattern:
 3. Count syllables carefully to ensure they match the pattern precisely
 4. Test your line against the pattern by mapping each syllable
 
+IMPORTANT: Each line of lyrics must match exactly to ONE musical phrase/segment.
+
 The lyrics should:
 - Perfectly capture the essence and style of {genre} music
 - Express the {primary_emotion} emotion and {primary_theme} theme
-- Be approximately {total_lines} lines long
-- Follow this structure:
-  * Verse: {verse_lines} lines
-  * Chorus: {chorus_lines} lines
-  * {f'Bridge: {bridge_lines} lines' if bridge_lines > 0 else ''}
+- Follow the structure patterns provided above
 - Be completely original
 - Match the song duration of {duration:.1f} seconds
 
@@ -1988,6 +2067,8 @@ Think step by step about how to match words to the rhythm pattern:
 3. Count syllables carefully to ensure they match the pattern precisely
 4. Test your line against the pattern by mapping each syllable
 
+CRITICAL: Each line of lyrics must match exactly to ONE musical phrase/segment.
+
 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
@@ -2000,8 +2081,8 @@ The lyrics should:
 - Maintain a consistent theme throughout
 - 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 precisely.
+Include any section labels like [Verse] or [Chorus] as indicated in the rhythm patterns above.
+Each line of lyrics must follow the corresponding segment's rhythm pattern EXACTLY.
 
 IMPORTANT: Your generated lyrics must be followed by a section titled "[RHYTHM_ANALYSIS_SECTION]" 
 where you analyze how well the lyrics align with the musical rhythm. This section MUST appear
@@ -2144,29 +2225,6 @@ Improved lyrics with fixed rhythm:
             # No significant issues detected
             lyrics = verified_lyrics
     
-    # Add section labels if they're not present and we're using the traditional approach
-    if use_sections and "Verse" not in lyrics and "Chorus" not in lyrics:
-        lines = lyrics.split('\n')
-        formatted_lyrics = []
-        
-        line_count = 0
-        for i, line in enumerate(lines):
-            if not line.strip():
-                formatted_lyrics.append(line)
-                continue
-                
-            if line_count == 0:
-                formatted_lyrics.append("[Verse]")
-            elif line_count == verse_lines:
-                formatted_lyrics.append("\n[Chorus]")
-            elif line_count == verse_lines + chorus_lines and bridge_lines > 0:
-                formatted_lyrics.append("\n[Bridge]")
-                
-            formatted_lyrics.append(line)
-            line_count += 1
-            
-        lyrics = '\n'.join(formatted_lyrics)
-    
     # Check if we have the [RHYTHM_ANALYSIS_SECTION] tag
     if "[RHYTHM_ANALYSIS_SECTION]" in lyrics:
         # Split at our custom marker
@@ -2185,9 +2243,6 @@ Improved lyrics with fixed rhythm:
         # No analysis found, add a minimal one
         lyrics = lyrics + "\n\n[Note: Rhythm Analysis]\nNo rhythm issues detected. All syllables align well with the beat pattern."
     
-    # Store the syllable guidance for later use
-    syllable_guidance_text = syllable_guidance
-    
     # Before returning, add syllable analysis and prompt template
     if isinstance(lyrics, str):
         # Extract clean lyrics and analysis
@@ -2206,15 +2261,22 @@ Improved lyrics with fixed rhythm:
         if templates_for_verification:
             syllable_analysis += "Template Analysis:\n"
             for i, template in enumerate(templates_for_verification):
-                syllable_analysis += f"Line {i+1}:\n"
-                if isinstance(template, dict):
-                    if "syllable_template" in template:
-                        syllable_analysis += f"  Template: {template['syllable_template']}\n"
-                    if "syllable_count" in template:
-                        syllable_analysis += f"  Expected syllables: {template['syllable_count']}\n"
-                elif isinstance(template, str):
-                    syllable_analysis += f"  Template: {template}\n"
-                syllable_analysis += "\n"
+                if i < min(len(templates_for_verification), 30):  # Limit to 30 to avoid overwhelming output
+                    syllable_analysis += f"Line {i+1}:\n"
+                    if isinstance(template, dict):
+                        if "syllable_template" in template:
+                            syllable_analysis += f"  Template: {template['syllable_template']}\n"
+                        if "syllable_count" in template:
+                            syllable_analysis += f"  Expected syllables: {template['syllable_count']}\n"
+                    elif isinstance(template, str):
+                        syllable_analysis += f"  Template: {template}\n"
+                    syllable_analysis += "\n"
+            
+            if len(templates_for_verification) > 30:
+                syllable_analysis += f"... and {len(templates_for_verification) - 30} more lines\n\n"
+                
+        # Add structure visualization to syllable analysis
+        syllable_analysis += "\n" + structure_visualization
         
         # Create prompt template
         prompt_template = "=== PROMPT TEMPLATE ===\n\n"
@@ -2284,7 +2346,139 @@ def process_audio(audio_file):
         
         # Calculate detailed song structure for better lyrics alignment
         try:
-            song_structure = calculate_detailed_song_structure(audio_data)
+            # Enhanced song structure calculation for precise lyrics matching
+            y, sr = load_audio(audio_file, SAMPLE_RATE)
+            
+            # Analyze beats and phrases for music-aligned lyrics
+            beats_info = detect_beats(y, sr)
+            sections_info = detect_sections(y, sr)
+            
+            # Create structured segments for precise line-by-line matching
+            segments = []
+            
+            # Try to break audio into meaningful segments based on sections
+            # Each segment will correspond to one line of lyrics
+            if sections_info and len(sections_info) > 1:
+                min_segment_duration = 1.5  # Minimum 1.5 seconds per segment
+                
+                for section in sections_info:
+                    section_start = section["start"]
+                    section_end = section["end"]
+                    section_duration = section["duration"]
+                    
+                    # For very short sections, add as a single segment
+                    if section_duration < min_segment_duration * 1.5:
+                        segments.append({
+                            "start": section_start,
+                            "end": section_end
+                        })
+                    else:
+                        # Calculate ideal number of segments for this section
+                        # based on its duration - aiming for 2-4 second segments
+                        ideal_segment_duration = 3.0  # Target 3 seconds per segment
+                        segment_count = max(1, int(section_duration / ideal_segment_duration))
+                        
+                        # Create evenly-spaced segments within this section
+                        segment_duration = section_duration / segment_count
+                        for i in range(segment_count):
+                            segment_start = section_start + i * segment_duration
+                            segment_end = segment_start + segment_duration
+                            segments.append({
+                                "start": segment_start,
+                                "end": segment_end
+                            })
+            # If no good sections found, create segments based on beats
+            elif beats_info and len(beats_info["beat_times"]) > 4:
+                beats = beats_info["beat_times"]
+                time_signature = beats_info.get("time_signature", 4)
+                
+                # Target one segment per musical measure (typically 4 beats)
+                measure_size = time_signature
+                for i in range(0, len(beats), measure_size):
+                    if i + 1 < len(beats):  # Need at least 2 beats for a meaningful segment
+                        measure_start = beats[i]
+                        # If we have enough beats for the full measure
+                        if i + measure_size < len(beats):
+                            measure_end = beats[i + measure_size]
+                        else:
+                            # Use available beats and extrapolate for the last measure
+                            if i > 0:
+                                beat_interval = beats[i] - beats[i-1]
+                                measure_end = beats[-1] + (beat_interval * (measure_size - (len(beats) - i)))
+                            else:
+                                measure_end = audio_data["duration"]
+                        
+                        segments.append({
+                            "start": measure_start,
+                            "end": measure_end
+                        })
+            # Last resort: simple time-based segments
+            else:
+                # Create segments of approximately 3 seconds each
+                segment_duration = 3.0
+                total_segments = max(4, int(audio_data["duration"] / segment_duration))
+                segment_duration = audio_data["duration"] / total_segments
+                
+                for i in range(total_segments):
+                    segment_start = i * segment_duration
+                    segment_end = segment_start + segment_duration
+                    segments.append({
+                        "start": segment_start,
+                        "end": segment_end
+                    })
+            
+            # Create a flexible structure with the segments
+            flexible_structure = {
+                "beats": beats_info,
+                "segments": segments
+            }
+            
+            # Add to song structure
+            song_structure = {
+                "beats": beats_info,
+                "sections": sections_info,
+                "flexible_structure": flexible_structure
+            }
+            
+            # Add syllable counts to each section
+            song_structure["syllables"] = []
+            for section in sections_info:
+                # Create syllable templates for sections
+                section_beats_info = {
+                    "beat_times": [beat for beat in beats_info["beat_times"] 
+                                  if section["start"] <= beat < section["end"]],
+                    "tempo": beats_info.get("tempo", 120)
+                }
+                if "beat_strengths" in beats_info:
+                    section_beats_info["beat_strengths"] = [
+                        strength for i, strength in enumerate(beats_info["beat_strengths"])
+                        if i < len(beats_info["beat_times"]) and
+                        section["start"] <= beats_info["beat_times"][i] < section["end"]
+                    ]
+                
+                # Get a syllable count based on section duration and tempo
+                syllable_count = int(section["duration"] * (beats_info.get("tempo", 120) / 60) * 1.5)
+                
+                section_info = {
+                    "type": section["type"],
+                    "start": section["start"],
+                    "end": section["end"],
+                    "duration": section["duration"],
+                    "syllable_count": syllable_count,
+                    "beat_count": len(section_beats_info["beat_times"])
+                }
+                
+                # Try to create a more detailed syllable template
+                if len(section_beats_info["beat_times"]) >= 2:
+                    section_info["syllable_template"] = create_flexible_syllable_templates(
+                        section_beats_info,
+                        genre=top_genres[0][0]
+                    )
+                
+                song_structure["syllables"].append(section_info)
+            
+            print(f"Successfully analyzed song structure with {len(segments)} segments")
+            
         except Exception as e:
             print(f"Error analyzing song structure: {str(e)}")
             # Continue with a simpler approach if this fails