# 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()