app.py

# import gradio as gr
# import os
# from acrcloud.recognizer import ACRCloudRecognizer
# import tempfile
# import shutil
# import json

# # Retrieve ACRCloud credentials from environment variables
# acr_access_key = os.environ.get('ACR_ACCESS_KEY')
# acr_access_secret = os.environ.get('ACR_ACCESS_SECRET')
# acr_host = 'identify-ap-southeast-1.acrcloud.com' # os.environ.get('ACR_HOST', 'eu-west-1.api.acrcloud.com')

# # ACRCloud recognizer configuration
# config = {
#     'host': acr_host,
#     'access_key': acr_access_key,
#     'access_secret': acr_access_secret,
#     'timeout': 10  # seconds
# }

# # Initialize ACRCloud recognizer
# acr = ACRCloudRecognizer(config)

# def identify_audio(file):
#     # Gradio provides a file object, and file.name contains the path
#     file_path = file.name  # Gradio file object already provides a file path

#     # Get the duration of the audio file in milliseconds
#     duration_ms = int(acr.get_duration_ms_by_file(file_path))

#     results = []

#     # Full recognition result
#     full_result = acr.recognize_by_file(file_path, 0)
#     full_result_dict = json.loads(full_result)
    
#     music = full_result_dict['metadata']['music'][0]

#     # Spotify link
#     spotify_track_id = music['external_metadata']['spotify']['track']['id']
#     spotify_link = f"https://open.spotify.com/track/{spotify_track_id}"

#     # Deezer link
#     deezer_track_id = music['external_metadata']['deezer']['track']['id']
#     deezer_link = f"https://www.deezer.com/track/{deezer_track_id}"

#     # Final markdown result
#     result_md = f"""
#     ### **Full Result**:
#     - **Track**: {music['title']}
#     - **Artist**: {music['artists'][0]['name']}
#     - **Album**: {music['album']['name']}
#     - **Release Date**: {music['release_date']}
#     - **Score**: {music['score']}%
#     - **Download Link**:
#     - [Listen on Spotify]({spotify_link})
#     - [Listen on Deezer]({deezer_link})
#     """

#     return gr.Markdown(result_md)

# # Create Gradio interface
# iface = gr.Interface(
#     fn=identify_audio,
#     inputs=gr.File(label="Upload Audio or Video File"),
#     outputs=gr.Markdown(label="Audio Metadata"),
#     title="Audio Search by File (Support Audio or Video File)",
#     description="Upload an audio or video file to identify it using ACRCloud."
# )

# # Launch the Gradio interface
# iface.launch()

import requests
import gradio as gr
import os
import json

# Function to recognize audio from URL or uploaded file
def recognize_audio(choice, url, file):
    api_url = os.getenv("API_URL", "https://api.audd.io/").strip('"')
    params = {
        "return": "apple_music,spotify",
        "api_token": os.getenv("API_TOKEN", "your_api_token_here").strip('"')
    }

    if choice == "URL":
        if not url:
            return "Please enter a valid URL."
        params['url'] = url
        response = requests.post(api_url, data=params)

    elif choice == "Upload File":
        if not file:
            return "Please upload a valid audio file."
        with open(file, "rb") as f:
            response = requests.post(api_url, data=params, files={'file': f})

    else:
        return "Please select a method (URL or Upload File)."

    # Parse the response into a structured format
    try:
        data = response.json()

        # Check if the response contains an error
        if result.get("status") == "error":
            error_message = result.get("error", {}).get("error_message", "Unknown error.")
            return f"""
### Song recognition failed
{error_message}
        """
        
        result = data.get('result', {})
        artist = result.get('artist', 'Unknown Artist')
        title = result.get('title', 'Unknown Title')
        album = result.get('album', 'Unknown Album')
        release_date = result.get('release_date', 'Unknown Date')
        song_link = result.get('song_link', '')
        apple_music_link = result.get('apple_music', {}).get('url', '')
        spotify_link = result.get('spotify', {}).get('external_urls', {}).get('spotify', '')

        markdown_output = f"""
### Song Recognition Result
- **Title**: {title}
- **Artist**: {artist}
- **Album**: {album}
- **Release Date**: {release_date}

[Listen on Apple Music]({apple_music_link})
[Listen on Spotify]({spotify_link})

#### Song Link:
[Click here to listen]({song_link})
        """
        return markdown_output

    except Exception as e:
        return f"Error parsing response: {str(e)}"

# Gradio Interface
interface = gr.Interface(
    fn=recognize_audio,
    inputs=[
        gr.Radio(["URL", "Upload File"], label="Select Input Method"),
        gr.Textbox(label="Enter Audio URL", placeholder="https://example.com/audio.mp3"),
        gr.File(label="Upload Audio File", type="filepath")  # Menggunakan filepath agar sesuai dengan Gradio
    ],
    outputs=gr.Markdown(label="Recognition Result"),
    title="Audio Recognition",
    description="Choose a method: Upload an audio file or enter a URL to identify the song."
)

# Run Gradio App
if __name__ == "__main__":
    interface.launch()