.

app.py

@@ -61,10 +61,10 @@ def create_lyrics_prompt(classification_results, song_structure):
     main_style = classification_results[0]['label']
     secondary_elements = [result['label'] for result in classification_results[1:3]]
     
-    # Create a more specific prompt with example lyrics
-    prompt = f"""Create song lyrics in {main_style} style with {', '.join(secondary_elements)} elements.
+    # Create a more specific prompt with example structure and style guidance
+    prompt = f"""Create {song_structure['verses']} verses and {song_structure['choruses']} choruses in {main_style} style with {', '.join(secondary_elements)} elements.
 
-Here's an example of the lyric style:
+Structure example:
 
 [Verse 1]
 Gentle bells ring in the night
@@ -72,56 +72,63 @@ Stars are shining pure and bright
 Music fills the evening air
 Magic moments we can share
 
-Write new original lyrics following this style:
+[Chorus]
+Let the rhythm take control
+Music flowing through your soul
+Dancing in the silver light
+Making magic through the night
+
+Write new original lyrics following this style and structure:
 
 [Verse 1]"""
+
     return prompt
 
 def format_lyrics(generated_text, song_structure):
     """Format the generated lyrics according to desired structure"""
     lines = []
-    current_section = None
     verse_count = 0
     chorus_count = 0
-    section_lines = []
+    current_section = []
     
-    # Process the generated text line by line
-    for line in generated_text.split('\n'):
+    # Split text into lines and process
+    text_lines = generated_text.split('\n')
+    for line in text_lines:
         line = line.strip()
         
-        # Skip empty lines and code blocks
+        # Skip empty lines and metadata
         if not line or line.startswith('```') or line.startswith('###'):
             continue
             
         # Handle section markers
         if '[verse' in line.lower() or '[chorus' in line.lower():
-            # Save previous section if exists
-            if section_lines:
-                while len(section_lines) < 4:  # Ensure 4 lines per section
-                    section_lines.append("...")
-                lines.extend(section_lines[:4])  # Only take first 4 lines if more
-                section_lines = []
+            # Save previous section if it exists
+            if current_section:
+                # Pad section to 4 lines if needed
+                while len(current_section) < 4:
+                    current_section.append("...")
+                lines.extend(current_section[:4])
+                current_section = []
             
-            # Add appropriate section marker
+            # Add new section marker
             if '[verse' in line.lower() and verse_count < song_structure['verses']:
                 verse_count += 1
                 lines.append(f"\n[Verse {verse_count}]")
-                current_section = 'verse'
             elif '[chorus' in line.lower() and chorus_count < song_structure['choruses']:
                 chorus_count += 1
                 lines.append(f"\n[Chorus {chorus_count}]")
-                current_section = 'chorus'
         else:
-            # Add line to current section
-            section_lines.append(line)
+            # Add line to current section if it looks like lyrics
+            if len(line.split()) <= 12 and not line[0] in '.,!?':
+                current_section.append(line)
     
-    # Handle the last section
-    if section_lines:
-        while len(section_lines) < 4:
-            section_lines.append("...")
-        lines.extend(section_lines[:4])
+    # Handle last section
+    if current_section:
+        while len(current_section) < 4:
+            current_section.append("...")
+        lines.extend(current_section[:4])
     
-    # If we don't have enough sections, add them
+    # Add any missing sections
     while verse_count < song_structure['verses'] or chorus_count < song_structure['choruses']:
         if verse_count < song_structure['verses']:
             verse_count += 1
@@ -134,8 +141,34 @@ def format_lyrics(generated_text, song_structure):
     
     return "\n".join(lines)
 
+def create_default_lyrics(song_structure):
+    """Create default lyrics when generation fails"""
+    lyrics = []
+    
+    # Add verses
+    for i in range(song_structure['verses']):
+        lyrics.append(f"\n[Verse {i+1}]")
+        lyrics.extend([
+            "Through the gentle evening light",
+            "Melodies take wings in flight",
+            "Every note a story tells",
+            "Like the sound of silver bells"
+        ])
+    
+    # Add choruses
+    for i in range(song_structure['choruses']):
+        lyrics.append(f"\n[Chorus {i+1}]")
+        lyrics.extend([
+            "Let the music fill the air",
+            "Feel the rhythm everywhere",
+            "Time stands still as we all sing",
+            "Joy and wonder it will bring"
+        ])
+    
+    return "\n".join(lyrics)
+
 def generate_lyrics_with_retry(prompt, song_structure, max_retries=5, initial_wait=2):
-    """Generate lyrics using GPT2 with retry logic"""
+    """Generate lyrics using GPT2 with improved retry logic and error handling"""
     wait_time = initial_wait
     
     for attempt in range(max_retries):
@@ -143,70 +176,47 @@ def generate_lyrics_with_retry(prompt, song_structure, max_retries=5, initial_wa
             print(f"\nAttempt {attempt + 1}: Generating lyrics...")
             
             response = requests.post(
-                "https://api-inference.huggingface.co/models/distilgpt2",
+                LYRICS_API_URL,
                 headers=headers,
                 json={
                     "inputs": prompt,
                     "parameters": {
-                        "max_new_tokens": 200,
-                        "temperature": 0.7,  # Lower temperature for more coherent output
-                        "top_p": 0.85,
+                        "max_new_tokens": song_structure['tokens'],
+                        "temperature": 0.8,
+                        "top_p": 0.9,
                         "do_sample": True,
-                        "return_full_text": False,
+                        "return_full_text": True,
                         "num_return_sequences": 1,
-                        "repetition_penalty": 1.2
+                        "repetition_penalty": 1.1
                     }
                 }
             )
             
             if response.status_code == 200:
-                try:
-                    result = response.json()
-                    if isinstance(result, list) and len(result) > 0:
-                        generated_text = result[0].get("generated_text", "")
-                        if not generated_text:
-                            continue
-                        
-                        # Clean up and format the text
-                        lines = []
-                        current_lines = []
-                        
-                        for line in generated_text.split('\n'):
-                            line = line.strip()
-                            # Skip empty lines, section markers, and non-lyric content
-                            if not line or line.startswith(('```', '###', '[', 'Start', 'Write')):
-                                continue
-                            # Only include lines that look like lyrics (not too long, no punctuation at start)
-                            if len(line.split()) <= 12 and not line[0] in '.,!?':
-                                current_lines.append(line)
-                        
-                        if len(current_lines) >= 4:
-                            # Format into song structure
-                            lines.append("[Verse 1]")
-                            lines.extend(current_lines[:4])
-                            
-                            if song_structure['choruses'] > 0:
-                                chorus_lines = [
-                                    "Hear the music in the air",
-                                    "Feel the rhythm everywhere",
-                                    "Let the melody take flight",
-                                    "As we sing into the night"
-                                ]
-                                lines.append("\n[Chorus]")
-                                lines.extend(chorus_lines)
-                            
-                            if song_structure['verses'] > 1 and len(current_lines) >= 8:
-                                lines.append("\n[Verse 2]")
-                                lines.extend(current_lines[4:8])
-                            
-                            return "\n".join(lines)
-                        else:
-                            print(f"Not enough valid lines generated (got {len(current_lines)}), retrying...")
-                            
-                except Exception as e:
-                    print(f"Error processing response: {str(e)}")
-                    if attempt < max_retries - 1:
-                        continue
+                result = response.json()
+                
+                # Handle different response formats
+                if isinstance(result, list):
+                    generated_text = result[0].get('generated_text', '')
+                elif isinstance(result, dict):
+                    generated_text = result.get('generated_text', '')
+                else:
+                    generated_text = str(result)
+                
+                if not generated_text:
+                    print("Empty response received, retrying...")
+                    time.sleep(wait_time)
+                    continue
+                
+                # Process the generated text into verses and chorus
+                formatted_lyrics = format_lyrics(generated_text, song_structure)
+                
+                # Verify we have enough content
+                if formatted_lyrics.count('[Verse') >= song_structure['verses'] and \
+                   formatted_lyrics.count('[Chorus') >= song_structure['choruses']:
+                    return formatted_lyrics
+                else:
+                    print("Not enough sections generated, retrying...")
                     
             elif response.status_code == 503:
                 print(f"Model loading, waiting {wait_time} seconds...")
@@ -216,18 +226,21 @@ def generate_lyrics_with_retry(prompt, song_structure, max_retries=5, initial_wa
             else:
                 print(f"Error response: {response.text}")
                 if attempt < max_retries - 1:
+                    time.sleep(wait_time)
                     continue
-                return f"Error generating lyrics: {response.text}"
-                
+        
         except Exception as e:
             print(f"Exception during generation: {str(e)}")
             if attempt < max_retries - 1:
                 time.sleep(wait_time)
                 wait_time *= 1.5
                 continue
-            return f"Error after {max_retries} attempts: {str(e)}"
+            
+        time.sleep(wait_time)
+        wait_time = min(wait_time * 1.5, 10)  # Cap maximum wait time at 10 seconds
     
-    return "Failed to generate lyrics after multiple attempts. Please try again."
+    # If we failed to generate after all retries, return a default structure
+    return create_default_lyrics(song_structure)
 
 def format_results(classification_results, lyrics, prompt):
     """Format the results for display"""