Update app.py

app.py

@@ -2,174 +2,156 @@ import gradio as gr
 import requests
 import os
 import time
-from datetime import datetime
+import json
 
-# Load Suno API key
+# Suno API key
 SUNO_KEY = os.environ.get("SunoKey", "")
 if not SUNO_KEY:
-    print("⚠️ Warning: SunoKey environment variable not set!")
+    print("⚠️ SunoKey not set!")
 
-# Simple task storage
-tasks = {}
-
-def generate_lyrics_simple(prompt):
-    """Simple lyrics generation using correct endpoints"""
+def generate_lyrics(prompt):
+    """Final working lyrics generator"""
     if not SUNO_KEY:
-        return "❌ Error: SunoKey not configured"
+        yield "❌ Error: SunoKey not configured in environment variables"
+        return
     
     if not prompt.strip():
-        return "❌ Please enter a prompt"
-    
-    # Generate simple task ID for our tracking
-    task_id = str(int(time.time()))[-6:]
-    
-    # Submit to Suno API
-    submit_url = "https://api.sunoapi.org/api/v1/lyrics"
-    headers = {
-        "Authorization": f"Bearer {SUNO_KEY}",
-        "Content-Type": "application/json"
-    }
-    
-    # Use a dummy callback URL (required by API)
-    payload = {
-        "prompt": prompt,
-        "callBackUrl": "http://dummy.callback/not-used"
-    }
+        yield "❌ Error: Please enter a prompt"
+        return
     
+    # Submit task
     try:
-        # Step 1: Submit the task
-        print(f"📤 Submitting: {prompt[:50]}...")
-        response = requests.post(submit_url, json=payload, headers=headers, timeout=30)
+        resp = requests.post(
+            "https://api.sunoapi.org/api/v1/lyrics",
+            json={
+                "prompt": prompt,
+                "callBackUrl": "http://dummy.com/callback"  # Required but not used
+            },
+            headers={
+                "Authorization": f"Bearer {SUNO_KEY}",
+                "Content-Type": "application/json"
+            },
+            timeout=30
+        )
         
-        if response.status_code != 200:
-            return f"❌ Submission failed: HTTP {response.status_code}"
-        
-        data = response.json()
+        if resp.status_code != 200:
+            yield f"❌ Submission failed: HTTP {resp.status_code}"
+            return
         
+        data = resp.json()
         if data.get("code") != 200:
-            return f"❌ API error: {data.get('msg', 'Unknown error')}"
-        
-        # Get Suno's task ID
-        suno_task_id = data["data"]["taskId"]
-        print(f"✅ Submitted! Suno Task ID: {suno_task_id}")
+            yield f"❌ API error: {data.get('msg', 'Unknown')}"
+            return
         
-        # Store task
-        tasks[task_id] = {
-            "suno_id": suno_task_id,
-            "prompt": prompt,
-            "status": "submitted",
-            "start_time": datetime.now(),
-            "checks": 0
-        }
+        task_id = data["data"]["taskId"]
+        yield f"✅ **Submitted!**\nTask ID: `{task_id}`\n\n⏳ Waiting for lyrics...\n"
         
-        # Step 2: Wait a bit then check using /record-info endpoint
-        time.sleep(2)  # Give it a moment
-        
-        # Step 3: Poll using the CORRECT endpoint
-        return poll_for_results(task_id, suno_task_id)
-    
-    except Exception as e:
-        return f"❌ Error: {str(e)}"
-
-def poll_for_results(task_id, suno_task_id, max_attempts=12):
-    """Poll for results using /record-info endpoint"""
-    headers = {"Authorization": f"Bearer {SUNO_KEY}"}
-    
-    # Use the CORRECT endpoint: /record-info
-    poll_url = f"https://api.sunoapi.org/api/v1/lyrics/record-info"
-    
-    for attempt in range(max_attempts):
-        try:
-            # Try different parameter names
-            params_list = [
-                {"taskId": suno_task_id},
-                {"id": suno_task_id},
-                {"record_id": suno_task_id},
-            ]
+        # Poll for results
+        for attempt in range(30):  # 30 attempts * 5 seconds = 150 seconds max
+            time.sleep(5)
             
-            response_data = None
-            for params in params_list:
-                try:
-                    response = requests.get(poll_url, headers=headers, params=params, timeout=30)
-                    if response.status_code == 200:
-                        response_data = response.json()
-                        if response_data.get("code") == 200:
-                            break
-                except:
-                    continue
-            
-            if response_data and response_data.get("code") == 200:
-                task_info = response_data["data"]
-                
-                # Update status (might be in different field names)
-                status = task_info.get("status") or task_info.get("state") or "unknown"
-                tasks[task_id]["status"] = status
-                tasks[task_id]["checks"] = attempt + 1
+            try:
+                check = requests.get(
+                    "https://api.sunoapi.org/api/v1/lyrics/record-info",
+                    headers={"Authorization": f"Bearer {SUNO_KEY}"},
+                    params={"taskId": task_id},
+                    timeout=30
+                )
                 
-                # Check if completed
-                if status == "completed":
-                    # Try to get lyrics from different possible field names
-                    lyrics = (
-                        task_info.get("lyrics") or 
-                        task_info.get("data") or 
-                        task_info.get("result") or 
-                        []
-                    )
+                if check.status_code == 200:
+                    check_data = check.json()
+                    status = check_data["data"].get("status", "PENDING")
+                    
+                    if status == "SUCCESS":
+                        # Success! Extract lyrics
+                        response_data = check_data["data"].get("response", {})
+                        
+                        if isinstance(response_data, str):
+                            # Sometimes response is a JSON string
+                            try:
+                                response_data = json.loads(response_data.replace('null', 'None'))
+                            except:
+                                response_data = {"data": []}
+                        
+                        lyrics_list = response_data.get("data", [])
+                        
+                        if lyrics_list:
+                            output = "🎵 **Lyrics Generated Successfully!**\n\n"
+                            
+                            for i, lyric in enumerate(lyrics_list, 1):
+                                title = lyric.get('title', f'Variant {i}')
+                                text = lyric.get('text', 'No lyrics')
+                                
+                                output += f"## Variant {i}: {title}\n"
+                                output += "```\n"
+                                output += text
+                                output += "\n```\n"
+                                output += "---\n\n"
+                            
+                            output += f"⏱️ Generated in about {(attempt + 1) * 5} seconds"
+                            yield output
+                        else:
+                            yield "✅ Completed but no lyrics found in response"
+                        return
+                    
+                    elif status == "FAILED":
+                        error = check_data["data"].get("errorMessage", "Unknown error")
+                        yield f"❌ Task failed: {error}"
+                        return
                     
-                    if lyrics:
-                        elapsed = int((datetime.now() - tasks[task_id]["start_time"]).total_seconds())
-                        return format_success(lyrics, task_id, elapsed)
-                    else:
-                        return "✅ Completed but no lyrics data found"
-                
-                elif status == "failed":
-                    error = task_info.get("error", "Unknown error")
-                    return f"❌ Task failed: {error}"
-                
-                elif status == "processing":
-                    # Still processing
-                    elapsed = int((datetime.now() - tasks[task_id]["start_time"]).total_seconds())
-                    if attempt < max_attempts - 1:
-                        time.sleep(5)  # Wait 5 seconds before next check
-                        continue
-                    else:
-                        return f"⏳ Still processing after {elapsed} seconds. Try checking again later."
-                
-                else:  # submitted or unknown
-                    elapsed = int((datetime.now() - tasks[task_id]["start_time"]).total_seconds())
-                    if attempt < max_attempts - 1:
-                        time.sleep(5)
-                        continue
                     else:
-                        return f"📥 Still submitted after {elapsed} seconds. Suno API might be slow."
-            
-            else:
-                # If we can't get status, show what we got
-                if response_data:
-                    return f"⚠️ Status check error: {response_data.get('msg', 'Unknown')}"
+                        # PENDING or PROCESSING
+                        yield (f"⏳ Status: {status}\n"
+                               f"Attempt: {attempt + 1}/30\n"
+                               f"Task ID: `{task_id}`\n\n"
+                               f"Still processing... (Usually takes 30-90 seconds)")
                 else:
-                    return "⚠️ Could not check status - no response from API"
+                    yield f"⚠️ Check error: HTTP {check.status_code}"
+            
+            except Exception as e:
+                yield f"⚠️ Error checking status: {str(e)}"
         
-        except Exception as e:
-            if attempt < max_attempts - 1:
-                time.sleep(5)
-                continue
-            else:
-                return f"⚠️ Error checking status: {str(e)}"
+        yield "⏰ Timeout after 150 seconds. Try checking again later."
     
-    return "⏰ Timeout after multiple attempts"
+    except Exception as e:
+        yield f"❌ Error: {str(e)}"
 
-def format_success(lyrics_data, task_id, elapsed_time):
-    """Format successful lyrics"""
-    # Handle different data structures
-    if isinstance(lyrics_data, dict):
-        # If it's a dict, try to extract lyrics
-        lyrics_text = lyrics_data.get('text') or lyrics_data.get('lyrics') or str(lyrics_data)
-        title = lyrics_data.get('title', 'Generated Lyrics')
+# Create the app
+with gr.Blocks(title="Suno Lyrics Generator", theme="soft") as app:
+    gr.Markdown("# 🎵 Suno Lyrics Generator")
+    gr.Markdown("Generate song lyrics using Suno AI")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            prompt = gr.Textbox(
+                label="Lyrics Prompt",
+                placeholder="Example: A happy song about sunshine and rainbows",
+                lines=3
+            )
+            btn = gr.Button("🎵 Generate Lyrics", variant="primary", scale=1)
+            
+            gr.Markdown("""
+            **How it works:**
+            1. Enter your lyrics idea
+            2. Click Generate
+            3. Wait 30-90 seconds
+            4. Get 2 lyric variants
+            
+            **Status messages:**
+            - ✅ Submitted = Task accepted
+            - ⏳ PENDING/PROCESSING = Generating
+            - 🎵 Success = Lyrics ready!
+            """)
         
-        output = f"""# 🎵 {title} (Task: {task_id})
-
-**Generated in:** {elapsed_time} seconds
+        with gr.Column(scale=2):
+            output = gr.Markdown(
+                label="Results",
+                value="Your generated lyrics will appear here..."
+            )
+    
+    btn.click(generate_lyrics, prompt, output)
 
-```text
-{lyrics_text}
+if __name__ == "__main__":
+    print("🚀 Starting Suno Lyrics Generator")
+    print(f"🔑 SunoKey: {'✅ Set' if SUNO_KEY else '❌ Not set'}")
+    app.launch(server_name="0.0.0.0", server_port=7860, share=False)