Skip to content
TheChatArchiveThe Chat Archive
gpt-4-1106-preview· openaiHugging Face Suzhen/CodeChat

musixmatchapi.py: mycode.py: import acrcloud import os import eyed3 import requests…

  1. User

    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

  2. Assistant

    To combine these codes into one and ensure we gather the specified information to tag the audio file, we need to merge functionality from both scripts. Please note the provided code isn't complete (e.g., the musixmatch_api.py script isn't given), and there might be undefined variables and classes which need to be defined in the actual implementation (like Musixmatch, CaptchaError, and UserTokenError).

    Here is how we can merge them, assuming you have a proper Musixmatch API client:

    import os
    import json
    import eyed3
    from acrcloud.recognizer import ACRCloudRecognizer
    from musixmatch_api import Musixmatch, CaptchaError, UserTokenError
    
    # ACR Cloud configuration (update with your credentials)
    ACR_HOST = '' # Your ACR Host
    ACR_ACCESS_KEY = '' # Your ACR Access Key
    ACR_ACCESS_SECRET = '' # Your ACR Access Secret
    
    config = {
        'host': ACR_HOST,
        'access_key': ACR_ACCESS_KEY,
        'access_secret': ACR_ACCESS_SECRET,
        'timeout': 10  # seconds
    }
    
    recognizer = ACRCloudRecognizer(config)
    
    # Initialize Musixmatch API with an appropriate instantiation
    # NOTE: Replace 'Exception' with the correct error handling as implemented in your musixmatch_api.py
    musixmatch = Musixmatch()  # You must create Musixmatch class instance as in your musixmatch_api.py
    
    # 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
    
    # Function to set ID3 tags including all needed fields
    def set_id3_tags(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')
    
        release_date = tags.get('release_date')
        if release_date and len(release_date) >= 4:
            audio_file.tag.recording_date = eyed3.core.Date(int(release_date[:4]))
    
        audio_file.tag.track_num = tags.get('track_number')
        if tags.get('genres'):
            audio_file.tag.genre = tags.get('genres')[0].get('name')
        
        audio_file.tag.publisher = "Karthik"  # Set publisher as 'karthik'
        audio_file.tag.composer = tags.get('composers')
        audio_file.tag.copyright = tags.get('copyright_label')
    
        audio_file.tag.save(version=eyed3.id3.ID3_V2_3)
    
    
    # Main function to process and tag a music file
    def tag_music_file(audio_file_path):
        song_tags = recognize_song(audio_file_path)
        if song_tags is None:
            print("Could not identify the song.")
            return
    
        print(f"Song identified: {song_tags}")
        # Use Musixmatch to get more data using the 'song_tags'
        artist_name = song_tags['artists'][0]['name']
        song_title = song_tags['title']
    
        try:
            track_data = musixmatch.get_track(artist_name, song_title)
            if track_data:
                song_tags.update(track_data)  # This assumes that the `get_track` will return a dictionary with the additional data
                set_id3_tags(audio_file_path, song_tags)
                print(f"ID3 tags set for {audio_file_path}")
            else:
                print(f"No additional data found for {artist_name} - {song_title} on Musixmatch.")
        except (CaptchaError, UserTokenError) as e:
            print(f"Error while working with Musixmatch: {e}")
    
    if __name__ == "__main__":
        audio_file_path = 'C:/Users/ILEG-i5-11/Downloads/Music/Unknown_file.mp3'
        tag_music_file(audio_file_path)
    

    In this script:

    • ACRCloudRecognizer is used to recognize the song.
    • The Musixmatch API client is meant to fill in the additional details needed for tagging. You need to have functions like get_track in your Musixmatch API client which should gather the details such as track number, copyright label, and composers.
    • The identified tags from both the ACR recognition and Musixmatch are then used to set the ID3 tags accordingly.
    • The script assumes that the track_data returned by Musixmatch will be a dictionary containing extra details required to update the song_tags. You will need to modify the get_track method in the Musixmatch class to fetch all the required data for complete ID3 tagging.

    Please make sure you replace placeholders and classes with the appropriate working functions and implementations from your musixmatch_api.py file.