ss

app.py

@@ -230,11 +230,30 @@ ONLY WRITE THE ACTUAL LYRICS. NO EXPLANATIONS OR META-TEXT.
             # Create phrase examples
             num_phrases = len(lyric_templates)
             
-            # Create a more direct prompt with examples
+            # Calculate the typical syllable range for this genre
+            if num_phrases > 0:
+                # Get max syllables per line from templates
+                max_syllables = max([t.get('max_expected', 8) for t in lyric_templates]) if lyric_templates[0].get('max_expected') else 8
+                min_syllables = min([t.get('min_expected', 3) for t in lyric_templates]) if lyric_templates[0].get('min_expected') else 3
+                avg_syllables = (min_syllables + max_syllables) // 2
+            else:
+                min_syllables = 3
+                max_syllables = 8
+                avg_syllables = 5
+            
+            # Create a more direct prompt with examples and specific syllable count guidance
             prompt = f"""Write song lyrics for a {genre} song in {key} {mode} with tempo {tempo} BPM. The emotion is {emotion} and theme is {theme}.
 
 I need EXACTLY {num_phrases} lines of lyrics - one line for each musical phrase. Not one more, not one less.
 
+CRITICAL INSTRUCTIONS:
+- Each line MUST contain between {min_syllables}-{max_syllables} syllables (aim for {avg_syllables})
+- Keep lines SHORT and SIMPLE - fewer syllables is better than too many
+- Break complete thoughts across multiple lines instead of cramming them into one line
+- Each line should flow naturally with the beat
+- Make each line end at a natural pause point
+- Use shorter words when possible
+
 FORMAT:
 - Just write {num_phrases} plain text lines
 - Each line should be simple song lyrics (no annotations, no numbers, no labeling)
@@ -244,13 +263,13 @@ FORMAT:
 - Don't include line numbers
 
 EXAMPLE OF WHAT I WANT (for a {num_phrases}-line song):
-Lost in the shadows of yesterday
-Dreams fade away like morning dew
-Time slips through fingers like desert sand
-Memories echo in empty rooms
+Lost in the light ({min_syllables} syllables)
+Waiting for the morning dew ({avg_syllables} syllables)
+Time slips away ({min_syllables+1} syllables)
+In the silence of my room ({avg_syllables} syllables)
 (... and so on for exactly {num_phrases} lines)
 
-JUST THE PLAIN LYRICS, EXACTLY {num_phrases} LINES.
+JUST THE PLAIN LYRICS, EXACTLY {num_phrases} LINES, KEEPING EACH LINE TO {min_syllables}-{max_syllables} SYLLABLES.
 """
 
         # Generate lyrics using the LLM model
@@ -427,6 +446,9 @@ JUST THE PLAIN LYRICS, EXACTLY {num_phrases} LINES.
             clean_lines[i] = re.sub(r'</think>', '', clean_lines[i])
             clean_lines[i] = re.sub(r'\[thinking\]', '', clean_lines[i])
             clean_lines[i] = re.sub(r'\[/thinking\]', '', clean_lines[i])
+            
+            # Remove syllable count annotations
+            clean_lines[i] = re.sub(r'\s*\(\d+\s*syllables?\)', '', clean_lines[i])
         
         # 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()]
@@ -440,17 +462,27 @@ JUST THE PLAIN LYRICS, EXACTLY {num_phrases} LINES.
                 # Keep the first num_required lines
                 clean_lines = clean_lines[:num_required]
             
-            # If we don't have enough lines, generate placeholders
+            # If we don't have enough lines, generate placeholders that fit the syllable count
             while len(clean_lines) < num_required:
-                placeholder = f"Echoes of {emotion} fill the {genre} night"
-                if len(clean_lines) > 0:
-                    # Try to make the placeholder somewhat related to previous lines
-                    last_words = [word for line in clean_lines[-1:] for word in line.split() if len(word) > 3]
-                    if last_words:
-                        import random
-                        word = random.choice(last_words)
-                        placeholder = f"{word.capitalize()} whispers through the {emotion} silence"
-                
+                i = len(clean_lines)
+                if i < len(lyric_templates):
+                    template = lyric_templates[i]
+                    target_syllables = min(max_syllables, (template.get('min_expected', 3) + template.get('max_expected', 8)) // 2)
+                    
+                    if genre.lower() == 'pop':
+                        if target_syllables <= 4:
+                            placeholder = "Lost in the night"  # 4 syllables
+                        else:
+                            placeholder = "Dancing in the moonlight"  # 6 syllables
+                    elif genre.lower() == 'rock':
+                        placeholder = "Rocking to the beat"  # 5 syllables
+                    elif genre.lower() == 'country':
+                        placeholder = "Down the old dirt road"  # 5 syllables
+                    else:
+                        placeholder = f"Echoes of {emotion}"  # ~4-5 syllables
+                else:
+                    placeholder = "Whispers in the wind"  # 5 syllables
+                    
                 clean_lines.append(placeholder)
         
         # Assemble final lyrics

beat_analysis.py

@@ -32,11 +32,11 @@ class BeatAnalyzer:
         # Genre-specific syllable-to-beat ratio guidelines
         self.genre_syllable_ratios = {
             # Supported genres with strong syllable-to-beat patterns
-            'pop': (0.9, 1.5, 2.2),        # Pop tends to have more syllables per beat
-            'rock': (0.8, 1.2, 1.8),       # Rock can vary widely but maintains beat alignment
-            'country': (0.8, 1.2, 1.6),    # Country tends to be moderate and clear in syllable matching
-            'disco': (1.0, 1.5, 2.0),      # Disco tends to have more syllables with clear beat patterns
-            'metal': (0.8, 1.5, 2.0),      # Metal often has more syllables on strong beats
+            'pop': (0.7, 1.2, 1.6),        # Pop - more conservative range
+            'rock': (0.7, 1.0, 1.5),       # Rock - slightly reduced upper range
+            'country': (0.7, 1.0, 1.3),    # Country - clear and simple syllable patterns
+            'disco': (0.8, 1.2, 1.5),      # Disco - tighter range for better alignment
+            'metal': (0.7, 1.2, 1.5),      # Metal - reduced upper limit
             
             # Other genres (analysis only, no lyrics generation)
             'hiphop': (1.8, 2.5, 3.5),     # Hip hop often has many syllables per beat
@@ -49,7 +49,7 @@ class BeatAnalyzer:
             'electronic': (0.7, 1.0, 1.5), # Electronic music varies widely
             'classical': (0.7, 1.0, 1.4),  # Classical can vary by subgenre
             'blues': (0.6, 0.8, 1.2),      # Blues often extends syllables
-            'default': (0.9, 1.5, 2.0)     # Default for unknown genres
+            'default': (0.7, 1.2, 1.6)     # Default for unknown genres - more conservative
         }
         
         # List of genres supported for lyrics generation
@@ -278,12 +278,24 @@ class BeatAnalyzer:
         # Estimate number of words based on beats (very rough estimate)
         est_words = max(1, int(num_beats * words_per_beat))
         
-        # Estimate syllables - more flexible now, allowing for reasonable ranges
-        # Typical song might have 1-3 syllables per beat
-        min_syllables = num_beats
-        max_syllables = num_beats * 3
+        # Estimate syllables - use more conservative ranges
+        # For 4/4 time signature, we want to encourage shorter phrases
+        if stress_pattern == "SWMW":  # 4/4 time
+            min_syllables = max(1, int(num_beats * 0.7))
+            max_syllables = min(8, int(num_beats * 1.6)) 
+        else:
+            min_syllables = max(1, int(num_beats * 0.7))
+            max_syllables = int(num_beats * 1.5)
+        
+        # Store these in the template for future reference
+        template['min_expected'] = min_syllables
+        template['max_expected'] = max_syllables
         
         guide = f"~{est_words} words, ~{min_syllables}-{max_syllables} syllables | Pattern: {visual_pattern}"
+        
+        # Add additional guidance to the template for natural phrasing
+        template['phrasing_guide'] = "Keep lines short. Split complete thoughts across multiple lines."
+        
         return guide
 
     def check_syllable_stress_match(self, text, template, genre="pop"):
@@ -303,14 +315,26 @@ 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
         min_expected = max(1, int(expected_count * min_ratio))
-        max_expected = int(expected_count * max_ratio)
+        max_expected = min(8, int(expected_count * max_ratio))
+        
+        # For 4/4 time signature, cap the max syllables per line 
+        if template['stress_pattern'] == "SWMW":  # 4/4 time
+            max_expected = min(max_expected, 8)  # Cap at 8 syllables max for 4/4
+            
+        # Record min and max expected in the template for future reference
+        template['min_expected'] = min_expected
+        template['max_expected'] = max_expected
         
         # Check if syllable count falls within genre-appropriate range
         within_range = min_expected <= syllable_count <= max_expected
         
         # Consider typical ratio - how close are we to the ideal for this genre?
         ideal_count = int(expected_count * typical_ratio)
+        # Ensure ideal count is also within our constrained range
+        ideal_count = max(min_expected, min(max_expected, ideal_count))
+        
         closeness_to_ideal = 1.0 - min(abs(syllable_count - ideal_count) / (max_expected - min_expected + 1), 1.0)
         
         # Get detailed syllable breakdown for stress analysis