ss

app.py

@@ -282,41 +282,42 @@ ONLY WRITE THE ACTUAL LYRICS. NO EXPLANATIONS OR META-TEXT.
 PRIMARY THEME: {theme}
 EMOTION: {emotion}
 
-I need EXACTLY {num_phrases} lines of lyrics with these requirements:
-
-KEY INSTRUCTIONS:
-1. CONNECTED THOUGHTS: Spread complete sentences across multiple lines (2-3 lines)
-2. SHORT LINES: Keep each line between {min_syllables}-{max_syllables} syllables
-3. NATURAL FLOW: Use conjunctions, prepositions and fragments that flow together
-4. AVOID CLICHÉS: Don't use phrases like "moonlight shimmers" or "time slips away"
-5. ORIGINALITY: Create fresh, original imagery related to {theme} and {emotion}
-6. DISTINCTIVE VOICE: Use specific, concrete details rather than generic phrases
+I need EXACTLY {num_phrases} lines of lyrics with these STRICT requirements:
+
+CRITICAL INSTRUCTIONS:
+1. EXTREMELY SHORT LINES: Each line MUST be between {min_syllables}-{max_syllables} syllables MAXIMUM
+2. ENFORCE BREVITY: NO exceptions to the syllable limit - not a single line should exceed {max_syllables} syllables
+3. FRAGMENT STYLE: Use sentence fragments and short phrases instead of complete sentences
+4. CONNECTED THOUGHTS: Use prepositions and conjunctions at the start of lines to connect ideas
+5. SIMPLE WORDS: Choose one or two-syllable words whenever possible
+6. CONCRETE IMAGERY: Use specific, tangible details rather than abstract concepts
+7. NO CLICHÉS: Avoid common phrases like "time slips away" or "memories fade"
+8. ONE THOUGHT PER LINE: Express just one simple idea in each line
 
 FORMAT:
-- Write exactly {num_phrases} plain text lines of lyrics (just the lyrics, no annotations)
-- Don't include explanations, section markers, or line numbers
-
-===== EXAMPLES OF CONNECTED THOUGHTS =====
+- Write exactly {num_phrases} short text lines
+- No annotations, explanations, or line numbers
+- Do not count syllables in the output
 
-Example 1 - Connection with conjunction:
-{ex1_line1}
-{ex1_line2}
-{ex1_line3}
-{ex1_line4}
+IMPORTANT: If you can't express an idea in {max_syllables} or fewer syllables, break it across two lines or choose a simpler way to express it.
 
-↑ Notice how these lines connect grammatically to form complete thoughts.
+===== EXAMPLES OF CORRECT LENGTH =====
 
-Example 2 - Connection with prepositions:
-{ex2_fragments[0]}
-{ex2_fragments[1]}
-{ex2_fragments[2]}
-{ex2_fragments[3]}
+Example 1 (short fragments connected by flow):
+Cold tea cup (3 syllables)
+on windowsill (3 syllables)
+cat watches rain (3 syllables)
+through foggy glass (3 syllables)
 
-↑ These lines use prepositions to create flow across multiple lines.
+Example 2 (prepositional connections):
+Keys dropped here (3 syllables)
+by the front door (3 syllables)
+where shoes pile up (3 syllables)
+since you moved in (3 syllables)
 
-IMPORTANT: DO NOT copy my examples or use their wording. Create ENTIRELY NEW, ORIGINAL lyrics about {theme} with {emotion} feeling that have your own distinctive voice and perspective.
+DO NOT copy my examples. Create ENTIRELY NEW lyrics about {theme} with {emotion} feeling.
 
-Just write {num_phrases} lines of original lyrics, focusing on connecting your lines with thought flow.
+REMEMBER: NO LINE SHOULD EXCEED {max_syllables} SYLLABLES - this is the most important rule!
 """
 
         # Generate lyrics using the LLM model
@@ -500,7 +501,16 @@ Just write {num_phrases} lines of original lyrics, focusing on connecting your l
         # 9. Filter out any remaining empty lines after tag removal
         clean_lines = [line for line in clean_lines if line.strip() and not line.isspace()]
         
-        # 10. NEW: Check for template copying or clichéd phrases
+        # 10. NEW: Apply strict syllable enforcement - split or truncate lines that are too long
+        # This is a critical step to ensure no line exceeds our max syllable count
+        if lyric_templates:
+            max_allowed_syllables = min(7, max([t.get('max_expected', 6) for t in lyric_templates]))
+        else:
+            max_allowed_syllables = 6
+            
+        clean_lines = enforce_syllable_limits(clean_lines, max_allowed_syllables)
+        
+        # 11. NEW: Check for template copying or clichéd phrases
         cliched_patterns = [
             r'moonlight (shimmers?|falls?|dances?)',
             r'shadows? (dance|play|fall|stretch)',
@@ -530,7 +540,7 @@ Just write {num_phrases} lines of original lyrics, focusing on connecting your l
         else:
             cliche_percentage = 0
             
-        # 11. If we have lyric templates, ensure we have the correct number of lines
+        # 12. If we have lyric templates, ensure we have the correct number of lines
         if lyric_templates:
             num_required = len(lyric_templates)
             
@@ -544,7 +554,7 @@ Just write {num_phrases} lines of original lyrics, focusing on connecting your l
                 i = len(clean_lines)
                 if i < len(lyric_templates):
                     template = lyric_templates[i]
-                    target_syllables = min(max_syllables, (template.get('min_expected', 2) + template.get('max_expected', 7)) // 2)
+                    target_syllables = min(max_allowed_syllables - 1, (template.get('min_expected', 2) + template.get('max_expected', 6)) // 2)
                     
                     # Generate more creative, contextual placeholders with specificity
                     # Avoid clichés like "moonlight shimmers" or "time slips away"
@@ -559,46 +569,38 @@ Just write {num_phrases} lines of original lyrics, focusing on connecting your l
                         ],
                         # 3-4 syllables - specific contexts
                         3: [
-                            "Coffee's getting cold", 
-                            "Fan blades spinning", 
-                            "Pages turning slow", 
-                            "Neighbors argue loud", 
-                            "Radio plays soft"
+                            "Coffee gets cold", 
+                            "Fan blades spin", 
+                            "Pages turn slow", 
+                            "Neighbors talk", 
+                            "Radio hums soft"
                         ],
                         # 4-5 syllables - specific details
                         4: [
-                            "Fingers tap the table", 
+                            "Fingers tap table", 
                             "Taxi waits in rain", 
-                            "Laptop screen flickers", 
-                            "Wedding ring forgotten", 
-                            "Sunday church bells ring"
+                            "Laptop screen blinks", 
+                            "Ring left on sink", 
+                            "Church bells ring loud"
                         ],
                         # 5-6 syllables - context rich
                         5: [
-                            "Letters sent without stamps", 
-                            "Broken watch shows wrong time", 
-                            "Faded jeans with torn knees", 
-                            "Neighbor's dog keeps barking", 
-                            "Smoke detector beeping"
-                        ],
-                        # 6-7 syllables - specific scenarios
-                        6: [
-                            "Fingerprints on dusty frames", 
-                            "Afternoon bus running late", 
-                            "Yellowed photos in a box", 
-                            "Backyard swing rocks in the wind", 
-                            "Curtains move with summer breeze"
+                            "Letters with no stamps", 
+                            "Watch shows wrong time", 
+                            "Jeans with torn knees", 
+                            "Dog barks next door", 
+                            "Smoke alarm beeps"
                         ]
                     }
                     
                     # Make theme and emotion specific placeholders to add to the list
                     theme_specific = []
                     if theme.lower() in ["love", "relationship", "romance"]:
-                        theme_specific = ["Lipstick on a glass", "Texts left on read", "Perfume on your coat"]
+                        theme_specific = ["Lipstick on glass", "Text left on read", "Scent on your coat"]
                     elif theme.lower() in ["loss", "grief", "sadness"]:
-                        theme_specific = ["Empty chair remains", "Photos face-down now", "Clothes still in the closet"]
+                        theme_specific = ["Chair sits empty", "Photos face down", "Clothes in closet"]
                     elif theme.lower() in ["hope", "inspiration", "triumph"]:
-                        theme_specific = ["Seeds begin to sprout", "Finish line in sight", "Mountain peak awaits"]
+                        theme_specific = ["Seeds start to grow", "Finish line waits", "New day breaks through"]
                     
                     # Get the closest matching syllable group
                     closest_group = min(specific_placeholders.keys(), key=lambda k: abs(k - target_syllables))
@@ -615,9 +617,8 @@ Just write {num_phrases} lines of original lyrics, focusing on connecting your l
                         placeholder = available_placeholders[idx]
                     else:
                         # If we've used all placeholders, create something random and specific
-                        subjects = ["Car", "Dog", "Child", "Clock", "Phone", "Tree", "Book", "Door", "Light"]
-                        verbs = ["waits", "moves", "stops", "falls", "breaks", "turns", "opens", "runs", "sleeps"]
-                        modifiers = ["slowly", "loudly", "brightly", "quickly", "gently", "badly", "forever", "never", "always"]
+                        subjects = ["Car", "Dog", "Kid", "Clock", "Phone", "Tree", "Book", "Door", "Light"]
+                        verbs = ["waits", "moves", "stops", "falls", "breaks", "turns", "sleeps"]
                         
                         # Ensure randomness with seed that changes with each call
                         import random
@@ -626,13 +627,9 @@ Just write {num_phrases} lines of original lyrics, focusing on connecting your l
                         subj = random.choice(subjects)
                         verb = random.choice(verbs)
                         
-                        if target_syllables <= 3:
-                            placeholder = f"{subj} {verb}"
-                        else:
-                            mod = random.choice(modifiers)
-                            placeholder = f"{subj} {verb} {mod}"
+                        placeholder = f"{subj} {verb}"
                 else:
-                    placeholder = "Final page turns now"
+                    placeholder = "Page turns slow"
                     
                 clean_lines.append(placeholder)
         
@@ -645,8 +642,8 @@ Just write {num_phrases} lines of original lyrics, focusing on connecting your l
 Try regenerating for more original content.
 
 {final_lyrics}"""
-        
-        # 12. Final sanity check - if we have nothing or garbage, return an error
+            
+        # 13. Final sanity check - if we have nothing or garbage, return an error
         if not final_lyrics or len(final_lyrics) < 10:
             return "The model generated only thinking content but no actual lyrics. Please try again."
         
@@ -868,6 +865,52 @@ def analyze_sentence_flow(lines):
         "flow_quality": flow_quality
     }
 
+def enforce_syllable_limits(lines, max_syllables=6):
+    """
+    Enforce syllable limits by splitting or truncating lines that are too long.
+    Returns a modified list of lines where no line exceeds max_syllables.
+    """
+    if not lines:
+        return []
+    
+    result_lines = []
+    
+    for line in lines:
+        words = line.split()
+        if not words:
+            continue
+            
+        # Count syllables in the line
+        syllable_count = sum(count_syllables_for_word(word) for word in words)
+        
+        # If within limits, keep the line as is
+        if syllable_count <= max_syllables:
+            result_lines.append(line)
+            continue
+            
+        # Line is too long - we need to split or truncate it
+        current_line = []
+        current_syllables = 0
+        
+        for word in words:
+            word_syllables = count_syllables_for_word(word)
+            
+            # If adding this word would exceed the limit, start a new line
+            if current_syllables + word_syllables > max_syllables and current_line:
+                result_lines.append(" ".join(current_line))
+                current_line = [word]
+                current_syllables = word_syllables
+            else:
+                # Add the word to the current line
+                current_line.append(word)
+                current_syllables += word_syllables
+        
+        # Don't forget the last line if there are words left
+        if current_line:
+            result_lines.append(" ".join(current_line))
+    
+    return result_lines
+
 # Create Gradio interface
 def create_interface():
     with gr.Blocks(title="Music Analysis & Lyrics Generator") as demo:

beat_analysis.py

@@ -276,16 +276,16 @@ class BeatAnalyzer:
                 visual_pattern += "weak "
         
         # Estimate number of words based on beats (very rough estimate)
-        est_words = max(1, int(num_beats * 0.4))  # Reduced from 0.5 to encourage fewer words
+        est_words = max(1, int(num_beats * 0.3))  # Reduced further to encourage extreme brevity
         
-        # Estimate syllables - use even more conservative ranges
-        # For 4/4 time signature, we want to encourage shorter phrases
+        # 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.5))  # Reduced from 0.7
-            max_syllables = min(7, int(num_beats * 1.3))  # Reduced from 1.6 to max 7
+            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.5))  # Reduced from 0.7
-            max_syllables = min(7, int(num_beats * 1.2))  # Reduced from 1.5 to max 7
+            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
@@ -294,7 +294,7 @@ class BeatAnalyzer:
         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'] = "Keep lines SHORT. Break complete thoughts across MULTIPLE LINES."
+        template['phrasing_guide'] = "ULTRA SHORT LINES. One thought per line. Use FRAGMENTS not sentences."
         
         return guide
 
@@ -315,13 +315,13 @@ class BeatAnalyzer:
             min_ratio, typical_ratio, max_ratio = self.genre_syllable_ratios['default']
         
         # Calculate flexible min and max syllable expectations based on genre
-        # Use more conservative ranges to avoid too many syllables
+        # Use extremely conservative ranges to enforce ultra-short lines
         min_expected = max(1, int(expected_count * min_ratio))
-        max_expected = min(7, int(expected_count * max_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 
+        # 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, 7)  # Cap at 7 syllables max for 4/4
+            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