Spaces:
Running
Running
| # 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 os | |
| import json | |
| import requests | |
| import ffmpeg | |
| import gradio as gr | |
| import tempfile | |
| import threading | |
| import time | |
| # Video formats that are supported | |
| video_formats = ['3gp', 'asf', 'avi', 'divx', 'flv', 'm2ts', 'm4v', 'mkv', 'mov', 'mp4', 'mpeg', 'mpg', 'mts', 'ts', 'vob', 'webm', 'wmv', 'xvid'] | |
| # Function to convert video to audio using ffmpeg | |
| def convert_video_to_audio(video_path): | |
| try: | |
| # Ensure the directory exists | |
| output_dir = "flowly_ai_audio_converter" | |
| os.makedirs(output_dir, exist_ok=True) | |
| # Correctly construct the output file path | |
| output_path = os.path.join(output_dir, os.path.splitext(os.path.basename(video_path))[0] + ".mp3") | |
| # Run ffmpeg conversion | |
| ffmpeg.input(video_path).output(output_path).run() | |
| return output_path | |
| except Exception as e: | |
| return f"Error converting video: {str(e)}" | |
| # Function to download file from URL | |
| def download_file(url): | |
| try: | |
| response = requests.get(url, stream=True) | |
| filename = os.path.join("temp_downloads", url.split("/")[-1]) # Save in temp_downloads folder | |
| os.makedirs("temp_downloads", exist_ok=True) | |
| # Save file content | |
| with open(filename, 'wb') as f: | |
| for chunk in response.iter_content(chunk_size=8192): | |
| f.write(chunk) | |
| return filename | |
| except Exception as e: | |
| return f"Error downloading file: {str(e)}" | |
| # Function to recognize audio from URL or uploaded file | |
| def recognize_audio(choice, url, file): | |
| api_url = os.getenv("API_URL") | |
| params = { | |
| "return": "apple_music,spotify", | |
| "api_token": os.getenv("API_TOKEN") | |
| } | |
| # Check if URL is provided | |
| if choice == "URL": | |
| if not url: | |
| return "Please enter a valid URL." | |
| # Check if the URL ends with a video file extension | |
| url_extension = url.split('.')[-1].lower() | |
| if url_extension in video_formats: | |
| # Download video and process as video | |
| video_path = download_file(url) | |
| if video_path.startswith("Error"): | |
| return video_path | |
| audio_file_path = convert_video_to_audio(video_path) | |
| if audio_file_path.startswith("Error"): | |
| return audio_file_path | |
| else: | |
| # Process URL as audio | |
| params['url'] = url | |
| response = requests.post(api_url, data=params) | |
| # Check if file is uploaded | |
| elif choice == "Upload File": | |
| if not file: | |
| return "Please upload a valid audio file." | |
| # Check if the uploaded file is a video (e.g., mp4) | |
| file_extension = file.split('.')[-1].lower() | |
| audio_file_path = file | |
| if file_extension in video_formats: | |
| # Convert video to audio file (mp3 format) | |
| audio_file_path = convert_video_to_audio(file) | |
| if audio_file_path.startswith("Error"): | |
| return audio_file_path | |
| # If it's already an audio file, use it as is | |
| with open(audio_file_path, "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: | |
| if response.status_code != 200: | |
| return f"Error: Received unexpected status code {response.status_code}" | |
| # Try to parse the response as JSON | |
| data = response.json() | |
| # Check if the response is valid | |
| if not data: | |
| return "Error: No data received from the API." | |
| # Check if there's an error in the response | |
| if data.get("status") == "error": | |
| error_message = data.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)}" | |
| # Function to cache the audio file and delete it after 15 minutes | |
| def cache_and_delete_file(audio_file_path): | |
| # Wait for 15 minutes before deleting the file | |
| time.sleep(900) # 900 seconds = 15 minutes | |
| try: | |
| os.remove(audio_file_path) | |
| print(f"File {audio_file_path} has been deleted after 15 minutes.") | |
| except Exception as e: | |
| print(f"Error deleting file {audio_file_path}: {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/Video URL", placeholder="https://example.com/audio.mp3 or video.mp4"), | |
| gr.File(label="Upload Audio or Video 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/video file or enter a URL to identify the song.", | |
| css="footer {visibility: hidden}" | |
| ) | |
| # Run Gradio App | |
| if __name__ == "__main__": | |
| # Launch the Gradio interface | |
| interface.launch() | |