.

app.py

@@ -3,78 +3,141 @@ import gradio as gr
 import os
 import torch
 import json
+from transformers import AutoTokenizer, AutoModelForCausalLM
 
 # Check if CUDA is available and set the device accordingly
 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
 
-API_URL = "https://api-inference.huggingface.co/models/MIT/ast-finetuned-audioset-10-10-0.4593"
+# API URLs and headers
+AUDIO_API_URL = "https://api-inference.huggingface.co/models/MIT/ast-finetuned-audioset-10-10-0.4593"
+JANUS_API_URL = "https://api-inference.huggingface.co/models/deepseek-ai/Janus-1.3B"
 headers = {"Authorization": f"Bearer {os.environ.get('HF_TOKEN')}"}
 
 def format_error(message):
     """Helper function to format error messages as JSON"""
-    return [{"error": message}]
+    return {"error": message}
 
-def classify_audio(audio_file):
+def create_lyrics_prompt(classification_results):
+    """Create a prompt for lyrics generation based on classification results"""
+    # Get the top genre and its characteristics
+    top_result = classification_results[0]
+    genre = top_result['label']
+    confidence = float(top_result['score'].strip('%')) / 100
+
+    # Create a detailed prompt
+    prompt = f"""Write song lyrics in the style of {genre} music. The song should capture the essence of this genre.
+    Additional musical elements detected: {', '.join(r['label'] for r in classification_results[1:3])}
+    
+    Please write creative and original lyrics that:
+    1. Match the {genre} style
+    2. Have a clear structure (verse, chorus)
+    3. Reflect the mood and themes common in this genre
+    
+    Generate the lyrics:
     """
-    Classify the uploaded audio file using Hugging Face AST model
+    return prompt
+
+def generate_lyrics(prompt):
+    """Generate lyrics using the Janus model"""
+    try:
+        response = requests.post(
+            JANUS_API_URL,
+            headers=headers,
+            json={
+                "inputs": prompt,
+                "parameters": {
+                    "max_new_tokens": 200,
+                    "temperature": 0.7,
+                    "top_p": 0.9,
+                    "return_full_text": False
+                }
+            }
+        )
+        
+        if response.status_code == 200:
+            return response.json()[0]["generated_text"]
+        elif response.status_code == 503:
+            return "Model is loading. Please try again in a few seconds."
+        else:
+            return f"Error generating lyrics: {response.text}"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def format_results(classification_results, lyrics, prompt):
+    """Format the results for display"""
+    # Format classification results
+    classification_text = "Classification Results:\n"
+    for i, result in enumerate(classification_results):
+        classification_text += f"{i+1}. {result['label']}: {result['score']}\n"
+    
+    # Format final output
+    output = f"""
+{classification_text}
+\n---Generated Lyrics---\n
+{lyrics}
+"""
+    return output
+
+def classify_and_generate(audio_file):
+    """
+    Classify the audio and generate matching lyrics
     """
     if audio_file is None:
-        return format_error("Please upload an audio file.")
+        return "Please upload an audio file."
     
     try:
-        # Debug: Print token status (masked)
         token = os.environ.get('HF_TOKEN')
         if not token:
-            return format_error("Error: HF_TOKEN environment variable is not set. Please set your Hugging Face API token.")
-        print(f"Token present: {'Yes' if token else 'No'}, Token length: {len(token) if token else 0}")
-        
-        # Debug: Print audio file info
-        print(f"Audio file path: {audio_file}")
-        print(f"Audio file size: {os.path.getsize(audio_file)} bytes")
+            return "Error: HF_TOKEN environment variable is not set. Please set your Hugging Face API token."
         
+        # First, classify the audio
         with open(audio_file, "rb") as f:
             data = f.read()
         
-        print("Sending request to Hugging Face API...")
-        response = requests.post(API_URL, headers=headers, data=data)
-        
-        # Print response for debugging
-        print(f"Response status code: {response.status_code}")
-        print(f"Response headers: {dict(response.headers)}")
-        print(f"Response content: {response.content.decode('utf-8', errors='ignore')}")
+        print("Sending request to Audio Classification API...")
+        response = requests.post(AUDIO_API_URL, headers=headers, data=data)
         
         if response.status_code == 200:
-            results = response.json()
-            # Format results for better readability
+            classification_results = response.json()
+            # Format classification results
             formatted_results = []
-            for result in results:
+            for result in classification_results:
                 formatted_results.append({
                     'label': result['label'],
                     'score': f"{result['score']*100:.2f}%"
                 })
-            return formatted_results
+            
+            # Generate lyrics based on classification
+            print("Generating lyrics based on classification...")
+            prompt = create_lyrics_prompt(formatted_results)
+            lyrics = generate_lyrics(prompt)
+            
+            # Format and return results
+            return format_results(formatted_results, lyrics, prompt)
+            
         elif response.status_code == 401:
-            return format_error("Error: Invalid or missing API token. Please check your Hugging Face API token.")
+            return "Error: Invalid or missing API token. Please check your Hugging Face API token."
         elif response.status_code == 503:
-            return format_error("Error: Model is loading. Please try again in a few seconds.")
+            return "Error: Model is loading. Please try again in a few seconds."
         else:
-            error_msg = f"Error: API returned status code {response.status_code}\n"
-            error_msg += f"Response headers: {dict(response.headers)}\n"
-            error_msg += f"Response: {response.text}"
-            return format_error(error_msg)
+            return f"Error: API returned status code {response.status_code}\nResponse: {response.text}"
             
     except Exception as e:
         import traceback
         error_details = traceback.format_exc()
-        return format_error(f"Error processing audio: {str(e)}\nDetails:\n{error_details}")
+        return f"Error processing request: {str(e)}\nDetails:\n{error_details}"
 
 # Create Gradio interface
 iface = gr.Interface(
-    fn=classify_audio,
+    fn=classify_and_generate,
     inputs=gr.Audio(type="filepath", label="Upload Audio File"),
-    outputs=gr.JSON(label="Classification Results"),
-    title="Audio Classification using AST Model",
-    description="Upload an audio file to get its classification results using the Audio Spectrogram Transformer model.",
+    outputs=gr.Textbox(
+        label="Results",
+        lines=15,
+        placeholder="Upload an audio file to see classification results and generated lyrics..."
+    ),
+    title="Music Genre Classifier + Lyric Generator",
+    description="Upload an audio file to classify its genre and generate matching lyrics using AI.",
     examples=[],
 )