musixmatch_api.py:




mycode.py:

import acrcloud
import os
import eyed3
import requests
import json
from acrcloud.recognizer import ACRCloudRecognizer



# ACR Cloud setup
config = {
‘host’: ACR_HOST,
‘access_key’: ACR_ACCESS_KEY,
‘access_secret’: ACR_ACCESS_SECRET,
‘timeout’: 10 # seconds
}
dir(acrcloud)

# Initialize the ACRCloud recognizer
recognizer = ACRCloudRecognizer(config)

# Function to recognize the song from an audio file
def recognize_song(audio_file_path):
buffer = open(audio_file_path, ‘rb’).read()
result = recognizer.recognize_by_filebuffer(buffer, 0)
try:
result_dict = json.loads(result) # Parse the JSON string into a dictionary
return result_dict[‘metadata’][‘music’][0]
except (KeyError, IndexError, json.JSONDecodeError) as e:
print(f"Error while parsing result: {e}“)
return None

# Function to set ID3 tags
def set_id3_tags_mp3(audio_file_path, tags):
audio_file = eyed3.load(audio_file_path)
if not audio_file.tag:
audio_file.initTag()

audio_file.tag.artist = tags.get(‘artists’)[0].get(‘name’)
audio_file.tag.album = tags.get(‘album’).get(‘name’)
audio_file.tag.album_artist = tags.get(‘artists’)[0].get(‘name’)
audio_file.tag.title = tags.get(‘title’)

# Set the release year (if available)
release_date = tags.get(‘release_date’)
if release_date and len(release_date) >= 4: # Check if release_date contains at least the year
year_string = release_date[:4]
try:
year = int(year_string)
# Some versions of eyeD3 require a Date object if available
if hasattr(eyed3.id3.tag, ‘Date’):
audio_file.tag.recording_date = eyed3.id3.tag.Date(year)
else:
# Otherwise, set it as text_frame
audio_file.tag.setTextFrame(“TDRC”, year_string)
except ValueError:
print(f"Invalid date format in the tag: {release_date}”)

# Add more tags here
audio_file.tag.genre = tags.get(‘genres’)[0].get(‘name’) # Assuming there’s at least one genre
audio_file.tag.publisher = “Karthik” # Publisher tag set as ‘karthik’

# To save the copyright label:
audio_file.tag.copyright = tags.get(‘label’, ‘’)

# To save the album cover page, you would need to download the image from a source
# and then do something like this:
# with open(“path_to_cover_image.jpg”, “rb”) as album_art:
# audio_file.tag.images.set(3, album_art.read(), “image/jpeg”, u"Description")


audio_file.tag.save(version=eyed3.id3.ID3_V2_3)

audio_file.tag.save()

# Replace ‘path_to_your_audio_file.mp3’ with the actual file path of the unknown song
if name == “main”:
audio_file_path = ‘C:/Users/ILEG-i5-11/Downloads/Music/Unknown_file.mp3’
song_tags = recognize_song(audio_file_path)
if song_tags:
print(f’Song identified: {song_tags}‘)
set_id3_tags_mp3(audio_file_path, song_tags)

# Renaming the file after identifying the song and setting tags
artist_name = song_tags.get(‘artists’)[0].get(‘name’)
song_title = song_tags.get(‘title’)
if artist_name and song_title:
new_file_name = f"{artist_name} - {song_title}.mp3"
new_file_path = os.path.join(os.path.dirname(audio_file_path), new_file_name)
os.rename(audio_file_path, new_file_path)
print(f"File has been renamed to: {new_file_name}“)

else:
print(‘Could not identify the song.’)


import json
import requests
from acrcloud.recognizer import ACRCloudRecognizer
from musixmatch_api import Musixmatch, CaptchaError, UserTokenError
from mutagen.mp3 import MP3
from mutagen.id3 import ID3, APIC, error



# ACR Cloud configuration (update with your credentials)
config = {
‘host’: ACR_HOST,
‘access_key’: ACR_ACCESS_KEY,
‘access_secret’: ACR_ACCESS_SECRET,
‘timeout’: 10 # seconds
}

recognizer = ACRCloudRecognizer(config)

# Initialize Musixmatch API (exception handling to be added as per your implementation)
musixmatch = Musixmatch(Exception)

# Function to recognize a song using ACRCloud
def recognize_song(audio_file_path):
buffer = open(audio_file_path, ‘rb’).read()
result = recognizer.recognize_by_filebuffer(buffer, 0)
try:
result_dict = json.loads(result)
return result_dict[‘metadata’][‘music’][0]
except (KeyError, IndexError, json.JSONDecodeError) as e:
print(f"Error while parsing result: {e}”)
return None

def format_time(ts):
‘’‘Converts time in seconds to the format [mm:ss.xx]’’‘
minutes = int(ts // 60)
seconds = int(ts % 60)
hundredths = int((ts - int(ts)) * 100)
return f’[{minutes:02d}:{seconds:02d}.{hundredths:02d}]‘

def process_rich_sync_lyrics(rich_sync_lyrics_json):
‘’‘Converts Musixmatch rich sync data to LRC format’’‘
lrc_lines = []
try:
# Load the JSON string into a Python object
rich_sync_data = json.loads(rich_sync_lyrics_json)
except json.JSONDecodeError as e:
print(f"Error decoding JSON: {e}")
return None

# Iterate through each line and create formatted LRC lines
for line in rich_sync_data:
ts = format_time(line[‘ts’]) # Start time of the line
lrc_line = f’{ts}{line[“x”]}’ # Use “x” for the entire line of lyrics
lrc_lines.append(lrc_line)

# Join the formatted lines with line breaks
return ‘\n’.join(lrc_lines)


# Function to get lyrics from Musixmatch given artist name and song title
def get_lyrics_from_musicxmatch(artist_name, song_title):
try:
user_token = musixmatch.get_user_token()

track_data = musixmatch.get_search_by_track(song_title, artist_name, “”)
if track_data:
track_id = track_data[‘track_id’]
rich_sync_data = musixmatch.get_rich_sync_by_id(track_id)

# Print the JSON response for debugging
print(json.dumps(track_data, indent=2))
print(json.dumps(rich_sync_data, indent=2))

if rich_sync_data and ‘richsync_body’ in rich_sync_data:
rich_sync_lyrics_json = rich_sync_data[‘richsync_body’]
lrc_lyrics = process_rich_sync_lyrics(rich_sync_lyrics_json)
return lrc_lyrics
else:
print(“No synced lyrics found.”)
return None
else:
print(“Track not found in Musixmatch.”)
return None
except (CaptchaError, UserTokenError) as e:
print(f"Error while working with Musixmatch: {e}“)
return None

if name == “main”:
audio_file_path = ‘C:/Users/ILEG-i5-11/Downloads/Music/Unknown_file.mp3’ # Replace with actual path
lrc_file_path = ‘C:/Users/ILEG-i5-11/Downloads/Music/Unknown_file.lrc’ # Output LRC file path

# Recognize the song using ACRCloud
song_tags = recognize_song(audio_file_path)
if song_tags:
artist_name = song_tags[‘artists’][0][‘name’]
song_title = song_tags[‘title’]
print(f"Identified Song: {artist_name} - {song_title}”)

# Fetch track data using the recognized song’s title and artist name
track_data = musixmatch.get_search_by_track(song_title, artist_name)
if track_data:
track_id = track_data[‘track_id’]

# Fetch the synced lyrics using the recognized song’s track ID
rich_sync_data = musixmatch.get_rich_sync_by_id(track_id)
if rich_sync_data and ‘richsync_body’ in rich_sync_data:
rich_sync_lyrics_json = rich_sync_data[‘richsync_body’]
lrc_lyrics = process_rich_sync_lyrics(rich_sync_lyrics_json)
if lrc_lyrics:
# Write the LRC lyrics to a file
with open(lrc_file_path, ‘w’, encoding=‘utf-8’) as lrc_file:
lrc_file.write(lrc_lyrics)
print(f"Saved LRC file to: {lrc_file_path}")
else:
print(“No synced lyrics found.”)
else:
print(“Track not found in Musixmatch.”)
else:
print(“Could not identify the song.”)


use these both codes: and combine into one

parameters to include to tagging a audio file are:
Title, contributing artists, artists, album, year of released, track index number in album, genre, copyright label, composer’s name, published by Karthik.
get these by musixmatch