ss

app.py

@@ -249,12 +249,11 @@ I need EXACTLY {num_phrases} lines of lyrics - one line for each musical phrase.
 CRITICAL INSTRUCTIONS:
 - Each line MUST be VERY SHORT with only {min_syllables}-{max_syllables} syllables (aim for {avg_syllables} or fewer)
 - PRIORITIZE BREVITY - use fewer syllables rather than more
-- Keep each line SIMPLE and DIRECT - avoid complex phrases
-- Break complete thoughts across MULTIPLE LINES rather than fitting them into one line
-- Think of each line as part of a flowing conversation, not a complete sentence
-- Each phrase should fit into one measure of music
+- CONNECT YOUR LINES - spread complete thoughts across 2-3 consecutive lines
+- Create SENTENCE FLOW across lines instead of making each line independent
+- Let sentence clauses and phrases flow naturally across multiple lines
+- Each individual line should still fit into one measure of music
 - Use simple, short words whenever possible
-- End each line at a natural speaking pause point
 
 FORMAT:
 - Just write {num_phrases} plain text lines
@@ -263,15 +262,24 @@ FORMAT:
 - Don't use any tags or markers
 - Don't include section labels like [Verse] or [Chorus]
 
-EXAMPLE OF WHAT I WANT:
-Empty chair ({min_syllables} syllables)
-Waiting by the door ({avg_syllables} syllables)
-Memories fade ({min_syllables+1} syllables) 
-Into silence ({avg_syllables-1} syllables)
-Your ghost remains ({avg_syllables} syllables)
-(... and so on)
+EXAMPLE OF CONNECTED THOUGHTS ACROSS LINES:
 
-JUST THE PLAIN LYRICS, EXACTLY {num_phrases} LINES, KEEPING EACH LINE TO {min_syllables}-{max_syllables} SYLLABLES.
+Moonlight falls (3 syllables)
+through my window pane (5 syllables)
+as I wait for you (5 syllables)
+
+Notice how these 3 lines form ONE complete sentence.
+
+Another example:
+
+Whispers fade (3 syllables)
+in the morning light (5 syllables)
+leaving memories (5 syllables)
+of our last goodbye (5 syllables)
+
+These 4 lines form a connected thought, not independent statements.
+
+JUST THE PLAIN LYRICS, EXACTLY {num_phrases} LINES, KEEPING EACH LINE TO {min_syllables}-{max_syllables} SYLLABLES, WITH CONNECTED THOUGHTS ACROSS LINES.
 """
 
         # Generate lyrics using the LLM model
@@ -631,37 +639,137 @@ def analyze_lyrics_rhythm_match(lyrics, lyric_templates, genre="pop"):
         result += f"- Average stress pattern accuracy: {avg_stress_percentage:.1f}%\n"
         result += f"- Overall rhythmic accuracy: {((range_match_rate + avg_stress_percentage) / 2):.1f}%\n"
         
-        # Add guidance on ideal distribution for syllables
-        result += f"\n**Syllable Distribution Guidance:**\n"
+        # Analyze sentence flow across lines
+        sentence_flow_analysis = analyze_sentence_flow(lines)
+        result += f"\n**Sentence Flow Analysis:**\n"
+        result += f"- Connected thought groups: {sentence_flow_analysis['connected_groups']} detected\n"
+        result += f"- Average lines per thought: {sentence_flow_analysis['avg_lines_per_group']:.1f}\n"
+        result += f"- Flow quality: {sentence_flow_analysis['flow_quality']}\n"
+        
+        # Add guidance on ideal distribution for syllables and sentence flow
+        result += f"\n**Syllable & Flow Guidance:**\n"
         result += f"- Aim for {min([t.get('min_expected', 3) for t in lyric_templates])}-{max([t.get('max_expected', 7) for t in lyric_templates])} syllables per line\n"
-        result += f"- Break complete thoughts across multiple lines for a more natural flow\n"
-        result += f"- Allow sentences to span 2-3 measures for better musical phrasing\n"
+        result += f"- Break complete thoughts across 2-3 lines for natural flow\n"
+        result += f"- Connect your lyrics with sentence fragments that flow across lines\n"
+        result += f"- Use conjunctions, prepositions, and dependent clauses to connect lines\n"
         
         # Add genre-specific notes
         result += f"\n**Genre Notes ({genre}):**\n"
         
         # Add appropriate genre notes based on genre
         if genre.lower() == "pop":
-            result += "- Pop lyrics are typically concise with 3-7 syllables per musical phrase\n"
-            result += "- Strong beats often align with stressed syllables in important words\n"
+            result += "- Pop lyrics work well with thoughts spanning 2-3 musical phrases\n"
+            result += "- Create flow by connecting lines with transitions like 'as', 'when', 'through'\n"
         elif genre.lower() == "rock":
-            result += "- Rock lyrics favor brevity with 3-6 syllables per musical phrase\n"
-            result += "- Emphasis on strong beats for rhythmic impact\n"
+            result += "- Rock lyrics benefit from short phrases that build into complete thoughts\n"
+            result += "- Use line breaks strategically to emphasize key words\n"
         elif genre.lower() == "country":
-            result += "- Country lyrics tend toward clear storytelling with 3-6 syllables per phrase\n"
-            result += "- Natural speech rhythms are important for authentic delivery\n"
+            result += "- Country lyrics tell stories that flow naturally across multiple lines\n"
+            result += "- Connect narrative elements across phrases for authentic storytelling\n"
         elif genre.lower() == "disco":
-            result += "- Disco lyrics work well with 4-7 syllables per musical phrase\n"
-            result += "- Rhythmic patterns often emphasize dance-friendly phrasing\n"
+            result += "- Disco lyrics work well with phrases that create rhythmic momentum\n"
+            result += "- Use line transitions that maintain energy and flow\n"
         elif genre.lower() == "metal":
-            result += "- Metal lyrics balance intensity with 3-7 syllables per musical phrase\n"
-            result += "- Strong syllables on strong beats create powerful impact\n"
+            result += "- Metal lyrics can create intensity by breaking phrases at dramatic points\n"
+            result += "- Connect lines to build tension and release across measures\n"
         else:
-            result += "- This genre typically works well with concise, focused phrasing\n"
-            result += "- Consider breaking complete thoughts across multiple lines\n"
+            result += "- This genre works well with connected thoughts across multiple lines\n"
+            result += "- Aim for natural speech flow rather than complete thoughts per line\n"
     
     return result
 
+def analyze_sentence_flow(lines):
+    """Analyze how well the lyrics create sentence flow across multiple lines"""
+    if not lines or len(lines) < 2:
+        return {
+            "connected_groups": 0,
+            "avg_lines_per_group": 0,
+            "flow_quality": "Insufficient lines to analyze"
+        }
+    
+    # Simplified analysis looking for grammatical clues of sentence continuation
+    continuation_starters = [
+        'and', 'but', 'or', 'nor', 'for', 'yet', 'so',  # Coordinating conjunctions
+        'as', 'when', 'while', 'before', 'after', 'since', 'until', 'because', 'although', 'though',  # Subordinating conjunctions
+        'with', 'without', 'through', 'throughout', 'beyond', 'beneath', 'under', 'over', 'into', 'onto',  # Prepositions
+        'to', 'from', 'by', 'at', 'in', 'on', 'of',  # Common prepositions
+        'where', 'how', 'who', 'whom', 'whose', 'which', 'that',  # Relative pronouns
+        'if', 'then',  # Conditional connectors
+    ]
+    
+    # Check for lines that likely continue a thought from previous line
+    connected_lines = []
+    potential_groups = []
+    current_group = [0]  # Start with first line
+    
+    for i in range(1, len(lines)):
+        # Check if line starts with a continuation word
+        words = lines[i].lower().split()
+        
+        # Empty line or no words
+        if not words:
+            if len(current_group) > 1:  # Only consider groups of 2+ lines
+                potential_groups.append(current_group.copy())
+            current_group = [i]
+            continue
+            
+        # Check first word for continuation clues
+        first_word = words[0].strip(',.!?;:')
+        if first_word in continuation_starters:
+            connected_lines.append(i)
+            current_group.append(i)
+        # Check for absence of capitalization as continuation clue
+        elif not first_word[0].isupper() and first_word[0].isalpha():
+            connected_lines.append(i)
+            current_group.append(i)
+        # Check if current line is very short (likely part of a continued thought)
+        elif len(words) <= 3 and i < len(lines) - 1:
+            # Look ahead to see if next line could be a continuation
+            if i+1 < len(lines):
+                next_words = lines[i+1].lower().split()
+                if next_words and next_words[0] in continuation_starters:
+                    connected_lines.append(i)
+                    current_group.append(i)
+                else:
+                    # This might end a group
+                    if len(current_group) > 1:  # Only consider groups of 2+ lines
+                        potential_groups.append(current_group.copy())
+                    current_group = [i]
+        else:
+            # This likely starts a new thought
+            if len(current_group) > 1:  # Only consider groups of 2+ lines
+                potential_groups.append(current_group.copy())
+            current_group = [i]
+    
+    # Add the last group if it has multiple lines
+    if len(current_group) > 1:
+        potential_groups.append(current_group)
+    
+    # Calculate metrics
+    connected_groups = len(potential_groups)
+    
+    if connected_groups > 0:
+        avg_lines_per_group = sum(len(group) for group in potential_groups) / connected_groups
+        
+        # Determine flow quality
+        if connected_groups >= len(lines) / 3 and avg_lines_per_group >= 2.5:
+            flow_quality = "Excellent - multiple connected thoughts across lines"
+        elif connected_groups >= len(lines) / 4 and avg_lines_per_group >= 2:
+            flow_quality = "Good - some connected thoughts across lines"
+        elif connected_groups > 0:
+            flow_quality = "Fair - limited connection between lines"
+        else:
+            flow_quality = "Poor - mostly independent lines"
+    else:
+        avg_lines_per_group = 0
+        flow_quality = "Poor - no connected thoughts detected"
+    
+    return {
+        "connected_groups": connected_groups,
+        "avg_lines_per_group": avg_lines_per_group,
+        "flow_quality": flow_quality
+    }
+
 # Create Gradio interface
 def create_interface():
     with gr.Blocks(title="Music Analysis & Lyrics Generator") as demo: