lyrict.py

import os
import sys
import re
import subprocess
import shutil
import getpass
import argparse
import itertools
from time import sleep
from tqdm import tqdm
from datetime import datetime
from mutagen.mp3 import MP3
from mutagen.flac import FLAC
from mutagen.id3 import ID3, SYLT, USLT, Encoding
from mutagen.id3._frames import TXXX
from mutagen.id3._util import ID3NoHeaderError

################################# MP3TAG CONFIG ######################################

# Name of the mp3tag action used to import synced lyrics from external .lrc files
import_synced_name = "LRC#Import Synced Lyrics From Filename.lrc"
# Tag to which the synced lyrics are saved in mp3tag
import_synced_tag = "LYRICS"

# Name of the mp3tag action used to import unsynced lyrics from external .txt files
import_unsynced_name = "LRC#Import Unsynced Lyrics From Filename.txt"
# Tag to which the unsynced lyrics are saved in mp3tag
import_unsynced_tag = "UNSYNCEDLYRICS"

# Name of the mp3tag action used to copy existing embedded lyrics to new tags with _BU appended, default: LYRICS_BU and UNSYNCEDLYRICS_BU
tag_backup_name = "LRC#Backup Embedded Lyrics"

# Name of the mp3tag action used to remove the backed up tags created with lyrics_backup, default: LYRICS_BU and SYLT_BU
remove_backup_name = "LRC#Remove Lyrics Backup"

################################ DO NOT TOUCH ########################################
# Parse arguments and fill variables to be passed to the main function
def parse_arguments():
    def dir_path(path):
        if os.path.isdir(path):
            return path
        else:
            raise argparse.ArgumentTypeError(f"readable_dir:{path} is not a valid path")
        
    parser = argparse.ArgumentParser(description='Test .lrc and .txt lyrics for broken links, embed synced and unsynced lyrics into tags or extract them from tags to files.')
    parser.add_argument('-d', '--directory',
                        help='Test, Import, mp3tag: The directory to scan for .lrc and .txt files. Export: Directory to scan for music files.',
                        type=dir_path, default=".", const=".", nargs="?")
    parser.add_argument('--delete', action='store_true',
                        help=f'''Import: After successful import, deletes external .lrc and .txt files from disk.
Export: After successful export, deletes LYRICS, SYLT and USYLT tags from mp3 files and LYRICS and UNSYNCEDLYRICS tags from flac files.''')     
    parser.add_argument('-e', '--extensions',
                        help='''Test, Import, mp3tag: List of song extensions the script will look for, default: flac and mp3. 
Export: Song extensions that will be scanned for embedded lyrics, default flac and mp3''',
                        nargs='+', default=["flac", "mp3"])
    parser.add_argument('--export', action='store_true',
                        help=f'''Export embedded lyrics of flac and mp3 files. Synced lyrics (LYRICS, SYLT) to .lrc and unsynced lyrics (UNSYNCEDLYRICS/USLT) to .txt files. 
Requires mutagen, use "pip3 install mutagen" to install it''')
    parser.add_argument('-g', '--guess_count', type=int, default=999_999, const=999_999, nargs="?",
                        help='Guess the total file count of the directory to be displayed when used with -p, default: 999_999.')
    parser.add_argument('-l', '--log', action='count',
                        help='''Test, mp3tag: Log filepaths (lyric and music extension) to "lyrict_results.log". 
"-ll" logs each filetype separately (lrc_flac.log, txt_mp3.log...) instead.
Import, Export: log embedding/exporting results to "lyrict_import_results"/"lyrict_export_results"''')
    parser.add_argument('--log_path',
                        help='The directory to save logs to when used with -l or -ll, defaults to "."',
                        type=dir_path, default=".", const=".", nargs="?")
    parser.add_argument('-m', choices=['export', 'import', 'mp3tag', 'test'], required=True,
                        help="""Mode, use 'test' to only log linked/unlinked songs to console or to file(s) when used with -l or -ll.
Use 'mp3tag' to embed external lyrics (.txt/.lrc) in audio tags via mp3tag.
Use 'import' to embed external lyrics (.txt/.lrc) in audio tags via mutagen.
Use 'export' to export embedded tags to external files (.lrc/.txt) via mutagen.
""")
    parser.add_argument('-o', '--overwrite', action='store_true',
                        help='''mp3tag: Overwrite/recreate the mp3tag actions to reflect changes made in the config section.
Import: Purge and overwrite existing embedded lyrics tags (LYRICS/UNSYNCEDLYRICS/SYLT/USLT)
Export: Overwrite the content of existing .lrc/.txt files.''')
    parser.add_argument('-p', '--progress', action='store_true',
                        help='Show progress bars. Useful for huge directories. Requires tqdm, use "pip3 install tqdm" to install it.')       
    parser.add_argument('-s', '--single_folder', action='store_true',
                        help='Test, Import, mp3tag: Only scans a single folder for .lrc and .txt files, no subdirectories. Export: Only scans a single folder for music files.')
    parser.add_argument('--standardize', action='store_true',
                        help=f'Import/Export: Ensure "[00:00.000]TEXT" formatting for lines in synced lyrics instead of "[0:00.000]TEXT" or "[00:00.00] TEXT".')

    args: argparse.Namespace = parser.parse_args()

    setattr(args, "log_to_disk", False)
    setattr(args, "separate_logs", False)
    if args.log == 1:
        setattr(args, "log_to_disk", True)
    elif args.log == 2:
        setattr(args, "log_to_disk", True)
        setattr(args, "separate_logs", True)

    setattr(args, "export_mode", False)
    setattr(args, "import_mode", False)
    setattr(args, "test_mode", False)
    setattr(args, "mp3tag_mode", False)
    if args.m == 'export':
        setattr(args, "export_mode", True)
    elif args.m == 'import':
        setattr(args, "import_mode", True)
    elif args.m == 'test':
        setattr(args, "test_mode", True)
    elif args.m == 'mp3tag':
        setattr(args, "mp3tag_mode", True)

    return args

########################################## SHARED ############################################
# Find all .lrc and .txt files in the directory specified with -d, recursively if not called with -s, --single
def find_lrc_files(directory, guess_count, single_folder, progress):
    lrc_files = []
    txt_files = []
    pattern = r'^\d{2,3}\s' # Pattern to filter .txt files, default filters for names starting with 2 or 3 digits and a space, like "01 Hello.flac"

    if not single_folder:
        with tqdm(total = guess_count, desc="searching", unit=" files", disable=not progress) as pbar:
            lrc_count = 0
            txt_count = 0
            for root, dirs, files in os.walk(directory):
                for file in files:
                    pbar.update(1)
                    if file.endswith(".lrc"):
                        lrc_files.append(os.path.join(os.path.abspath(root), file))
                        lrc_count += 1
                        pbar.set_postfix({"lrc, txt": f"{lrc_count}, {txt_count}"})
                    elif file.endswith(".txt") and re.match(pattern, file):
                        txt_files.append(os.path.join(os.path.abspath(root), file))
                        txt_count += 1
                        pbar.set_postfix({"lrc, txt": f"{lrc_count}, {txt_count}"})
    else:
        with tqdm(total = guess_count, desc="searching", unit=" files", disable=not progress) as pbar:
            lrc_count = 0
            txt_count = 0
            for file in os.listdir(directory):
                if file.endswith(".lrc"):
                    lrc_files.append(os.path.join(os.path.abspath(directory), file))
                    lrc_count += 1
                    pbar.set_postfix({"lrc, txt": f"{lrc_count}, {txt_count}"})                    
                elif file.endswith(".txt")and re.match(pattern, file):
                    txt_files.append(os.path.join(os.path.abspath(directory), file))
                    txt_count += 1
                    pbar.set_postfix({"lrc, txt": f"{lrc_count}, {txt_count}"})

    if len(lrc_files) == 0:
        lrc_files = None
    if len(txt_files) == 0:
        txt_files = None
    if not lrc_files and not txt_files:
        print("No external lyrics (.lrc/.txt) found, closing in 5 seconds.")
        sleep(5)
        sys.exit()
    else:
        return lrc_files, txt_files

# Find matching songs from -e, --extensions list for .lrc and .txt files
def find_matches(lyric_paths, file_ext, extensions, progress):
    match_categories = dict.fromkeys(extensions)
    for ext in extensions:
        match_categories[ext] = []
    match_categories["unlinked"] = []
    with tqdm(total = len(lyric_paths), desc= f"finding {file_ext} matches", unit=f" {file_ext} files", disable=not progress) as pbar:
        for song in lyric_paths:
            hits = False
            for ext in extensions:
                song_path = os.path.splitext(song)[0] + f'.{ext}'
                if os.path.isfile(song_path):
                    match_categories[ext].append(song_path)
                    hits = True
                    pbar.update(1)
            if not hits:
                match_categories["unlinked"].append(song)
    match_categories = {key: value for key, value in match_categories.items() if value != []}
    return match_categories

##################################### IMPORT MP3TAG #############################################
# Open only songs with matching lyrics in mp3tag via CLI
def add_to_mp3tag(match_categories, first_track=True):
    for ext in match_categories.keys():
        for track in match_categories[ext]:
            if first_track:
                try:
                    subprocess.Popen(["mp3tag", "/fn:" + track])
                except subprocess.CalledProcessError:
                    print(f"Error while opening {track} in mp3tag.")
                first_track = False
                sleep(1)
            else:
                try:
                    subprocess.run(["mp3tag", "/add", "/fn:" + track])
                except subprocess.CalledProcessError:
                    print(f"Error while adding {track} to mp3tag.")
    return

# Check if mp3tag is on PATH and instruct how to add it if it isn't (Windows only)
def mp3tag_on_path():
    if shutil.which("mp3tag") is None and sys.platform == "win32":
        choice = input("mp3tag is not on PATH, open environment variable settings in Windows to add it? (y/n): ")
        if choice == "y":
            print(f"""
    Step 1: Under 'User variables for {getpass.getuser()}' select 'Path' and either double click it or click on 'Edit...'
    Step 2: Check if a path to Mp3tag is among the entries, if not, click on 'New' and paste:
            C:\\Program Files\\Mp3tag
            If you have mp3tag installed in a different directory, add the path to that instead.
            Note: You can also add the folder that contains this script to PATH in the same way.
    Step 3: Once that is done, re-run this script.""")
            try:
                subprocess.run(["rundll32.exe", "sysdm.cpl,EditEnvironmentVariables"])
            except subprocess.CalledProcessError:
                print(f"Error opening environment variable settings.")
            sys.exit()
        else:
            print("Exiting.")
            sys.exit()
    elif shutil.which("mp3tag") is None:
        print("mp3tag is not on PATH, add it and try again. Closing in 5 seconds.")
        sleep(5)
        sys.exit()
    else:
        return

# Create mp3tag actions to backup existing embedded lyrics, import external lyrics and delete the lyrics backups
def mp3tag_create_actions(action_folder, overwrite_actions, extensions):
    class Mp3tagAction:
        action_list = []
        def __init__(self, name, content):
            self.name = name
            self.path = os.path.join(action_folder + name + ".mta")
            self.content = content
            Mp3tagAction.action_list.append(self)
        def create(self):
            choice = ""
            if os.path.isfile(self.path) and not overwrite_actions:
                return
            if not overwrite_actions:
                choice = input(f"Create a mp3tag action called '{self.name}' in:\n{action_folder}? (y/n): ")
            if choice == "y" or overwrite_actions:
                try:
                    with open(self.path, "w", encoding="utf-8") as action:
                        action.write(self.content)
                except PermissionError:
                    print(f"{self.path}.mta cannot be created, ensure that you have write permissions and try again.")
                    sys.exit(1)
                print(f"{self.path} saved.")
            else:
                return
                
    backup_tags = f"{import_synced_tag}_BU;{import_unsynced_tag}_BU"
    backup_tag_synced = f"{import_synced_tag}_BU"
    backup_tag_unsynced = f"{import_unsynced_tag}_BU"

    backup_action = Mp3tagAction(tag_backup_name, f"[#0]\nT=5\n1={import_synced_tag}\nF={backup_tag_synced}\n\n[#1]\nT=5\n1={import_unsynced_tag}\nF={backup_tag_unsynced}\n")
    delete_backup_action = Mp3tagAction(remove_backup_name, f"[#0]\nT=9\nF={backup_tags}\n")
    import_synced_action = Mp3tagAction(import_synced_name, f"[#0]\nT=14\nF={import_synced_tag}\n1=%_filename%.lrc\n")
    import_unsynced_action = Mp3tagAction(import_unsynced_name, f"[#0]\nT=14\nF={import_unsynced_tag}\n1=%_filename%.txt\n")
    
    [action.create() for action in Mp3tagAction.action_list]

# Open songs with both types of matching lyrics (synced/unsynced) in mp3tag
def mp3tag_flow_both(match_categories_lrc, match_categories_txt, action_folder, overwrite_actions, extensions):
    errors = False
    if "unlinked" in match_categories_lrc.keys():
        print(f"LRC files without linked songs found:")
        for file_path in match_categories_lrc["unlinked"]:
            print(file_path)
        del match_categories_lrc["unlinked"]
        errors = True
    if "unlinked" in match_categories_txt.keys():
        print(f"TXT files without linked songs found:")
        for file_path in match_categories_txt["unlinked"]:
            print(file_path)
        del match_categories_txt["unlinked"]
        errors = True
    
    if errors and len(match_categories_lrc) > 0 or errors and len(match_categories_txt) > 0:
        choice = input(f"Open songs with external lyrics in mp3tag anyhow? (y/n): ")
        if choice == "y":
            mp3tag_on_path()
            if not os.path.isdir(action_folder):
                print(f"{action_folder} not found, skipping action creation.")
            else:
                mp3tag_create_actions(action_folder, overwrite_actions, extensions)
            first_execution = True
            if len(match_categories_lrc) > 0:
                add_to_mp3tag(match_categories_lrc, first_execution)
                first_execution = False
            if len(match_categories_txt) > 0:
                add_to_mp3tag(match_categories_txt, first_execution)
        else:
            print("Exiting.")
            sys.exit()
    else:
        if len(match_categories_lrc) > 0 or len(match_categories_txt) > 0:
            choice = input(f"Open songs with external lyrics in mp3tag? (y/n): ")
            if choice == "y":
                mp3tag_on_path()
                if not os.path.isdir(action_folder):
                    print(f"{action_folder} not found, skipping action creation.")
                else:
                    mp3tag_create_actions(action_folder, overwrite_actions, extensions)
                first_execution = True
                if len(match_categories_lrc) > 0:
                    add_to_mp3tag(match_categories_lrc, first_execution)
                    first_execution = False
                if len(match_categories_txt) > 0:
                    add_to_mp3tag(match_categories_txt, first_execution)
            else:
                print("Exiting.")
                sys.exit()

# Open songs with only one type of matching lyrics (synced/unsynced) in mp3tag
def mp3tag_flow_single(match_categories, action_folder, overwrite_actions, extensions, file_ext):
    if "unlinked" in match_categories.keys():
        print(f"{file_ext.upper()} files without linked songs found:")
        for file_path in match_categories["unlinked"]:
            print(file_path)
        del match_categories["unlinked"]
        if len(match_categories) > 0:
            choice = input(f"Open songs with external {file_ext} lyrics in mp3tag anyhow? (y/n): ")
            if choice == "y":
                mp3tag_on_path()
                if not os.path.isdir(action_folder):
                    print(f"{action_folder} not found, skipping action creation.")
                else:
                    mp3tag_create_actions(action_folder, overwrite_actions, extensions)
                add_to_mp3tag(match_categories)
            else:
                print("Exiting.")
                sys.exit()
        else:
            sys.exit()
    else:
        if len(match_categories) > 0:
            choice = input(f"Open songs with external {file_ext} lyrics in mp3tag? (y/n): ")
            if choice == "y":
                mp3tag_on_path()
                if not os.path.isdir(action_folder):
                    print(f"{action_folder} not found, skipping action creation.")
                else:
                    mp3tag_create_actions(action_folder, overwrite_actions, extensions)
                add_to_mp3tag(match_categories)
            else:
                print("Exiting.")
                sys.exit()
        else:
            sys.exit()

# Log found lrc paths to disk, grouped by extension and if there is a matching song
def write_log(match_categories, lyrics_ext, separate_logs, log_path):
    if not os.access(log_path, os.W_OK | os.X_OK):
        print("Cannot write log file(s) to current directory. Ensure that you have write permission. Skipping log creation.")
        return
    categories = match_categories.keys()
    if not separate_logs:
        with open(os.path.join(log_path, f"lyrict_{lyrics_ext}_results.log"), "w", encoding="utf8") as log:
            for category in categories:
                log.write(f"{category} results:\n")
                for result_path in match_categories[category]:
                    log.write(result_path+"\n")
                log.write("\n")
    else:
        for category in categories:
            with open(os.path.join(log_path, f"{lyrics_ext}_{category}.log"), "w", encoding="utf8") as log:
                for result_path in match_categories[category]:
                    log.write(result_path+"\n")

#################################### IMPORT MUTAGEN ########################################
def read_lyrics(file_path):
    with open(file_path, 'r', encoding='utf-8') as file:
        return file.read()

def parse_lrc_to_sylt(lyrics):
    sylt_lyrics = []
    timestamp_pattern = re.compile(r'^\[(\d{1,2}):(\d{2})\.(\d{2,3})\] *(.*)$')
    lines = lyrics.split('\n')
    for line in lines:
        match = timestamp_pattern.match(line)
        if match:
            minutes, seconds, milliseconds, text = match.groups()
            timestamp = (int(minutes) * 60000) + (int(seconds) * 1000) + int(milliseconds.ljust(3, '0'))  # Convert to milliseconds
            sylt_lyrics.append((text, timestamp))
    return sorted(sylt_lyrics, key=lambda x: x[1])

def embed_lyrics_flac(flac_file, lyrics=None, unsynced_lyrics=None, standardize=False, overwrite=False, results=None):
    audio = FLAC(flac_file)
    changed = False
    if not 'LYRICS' in audio or overwrite: # Embed if lyrics are not already embedded or when overwrite is True
        if lyrics:
            if standardize:
                lyrics = standardize_timestamps(lyrics)
            audio['LYRICS'] = lyrics
            changed = True
    if not 'UNSYNCEDLYRICS' in audio or overwrite: # Embed if lyrics are not already embedded or when overwrite is True
        if unsynced_lyrics:
            audio['UNSYNCEDLYRICS'] = unsynced_lyrics
            changed = True
    if changed:
        audio.save()
        results["saved"].append(flac_file)
    else:
        results["skipped"].append(flac_file)

def embed_lyrics_mp3(mp3_file, lyrics=None, unsynced_lyrics=None, overwrite=False, results=None):
    try:
        audio = MP3(mp3_file, ID3=ID3)
    except ID3NoHeaderError:
        audio = MP3(mp3_file)
        audio.add_tags()
    changed = False

    # SYLT frame
    if not any(isinstance(frame, SYLT) for frame in audio.tags.values()) or overwrite: # Embed if lyrics are not already embedded or when overwrite is True
        if lyrics:
            if overwrite:
                audio.tags.delall('SYLT') # delete existing SYLT frames to avoid duplicates
            sylt_lyrics = parse_lrc_to_sylt(lyrics)
            audio.tags.setall("SYLT", [SYLT(encoding=Encoding.UTF8, lang='eng', format=2, type=1, text=sylt_lyrics)])
#            print(audio.tags.get('SYLT::eng')) # Uncomment for debugging nasty SYLT syntax
            changed = True

    # USLT frame
    if not any(isinstance(frame, USLT) for frame in audio.tags.values()) or overwrite: # Embed if lyrics are not already embedded or when overwrite is True    
        if unsynced_lyrics:
            if overwrite:
                audio.tags.delall('USLT') # delete existing USLT frames to avoid duplicates
            uslt_frame = USLT(encoding=Encoding.UTF8, lang='eng', desc='', text=unsynced_lyrics)
            audio.tags.add(uslt_frame)
            changed = True
    if changed:
        audio.save(v2_version=3) # save as id3 2.3 for compatibility
        results["saved"].append(mp3_file)
    else:
        results["skipped"].append(mp3_file)

def embed_lyrics(file_path, lrc_path=None, txt_path=None, standardize=False, overwrite=False, results=None):
    lyrics = read_lyrics(lrc_path) if lrc_path else None
    unsynced_lyrics = read_lyrics(txt_path) if txt_path else None
    
    if file_path.lower().endswith('.flac'):
        embed_lyrics_flac(file_path, lyrics, unsynced_lyrics, standardize, overwrite, results)
    elif file_path.lower().endswith('.mp3'):
        embed_lyrics_mp3(file_path, lyrics, unsynced_lyrics, overwrite, results)
    else:
        raise ValueError("Unsupported file format. Only FLAC and MP3 are supported.")

def import_lyrics(match_categories_lrc={}, match_categories_txt={}, delete_files=False, standardize=False, progress=False, overwrite=False):
    all_extensions = set(match_categories_lrc.keys()).union(set(match_categories_txt.keys()))
    files_to_delete = []  # List to store files that need to be deleted
    combined_results = {"saved": [], "skipped": [], "deleted": [], "failed": []}

    for ext in all_extensions:
        if ext == "mp3" or ext == "flac":
            results = {"saved":[], "skipped": [], "failed": []}
            lrc_paths = set(match_categories_lrc.get(ext, []))
            txt_paths = set(match_categories_txt.get(ext, []))
            with tqdm(total=len(lrc_paths | txt_paths), desc=f"embedding {ext}", unit=" files", disable=not progress) as pbar:
                for path in lrc_paths | txt_paths:
                    base_path = os.path.splitext(path)[0]
                    lrc_path = base_path + '.lrc'
                    txt_path = base_path + '.txt'
                    try:
                        if path in lrc_paths and path in txt_paths:
                            embed_lyrics(path, lrc_path=lrc_path, txt_path=txt_path, standardize=standardize, overwrite=overwrite, results=results)
                        elif path in lrc_paths:
                            embed_lyrics(path, lrc_path=lrc_path, standardize=standardize, overwrite=overwrite, results=results)
                        elif path in txt_paths:
                            embed_lyrics(path, txt_path=txt_path, standardize=standardize, overwrite=overwrite, results=results)
                        # Add files to delete list if delete_files is True
                        if delete_files:
                            if lrc_path:
                                files_to_delete.append(lrc_path)
                            if txt_path:
                                files_to_delete.append(txt_path)
                    except Exception as e:
                        results["failed"].append({"path": path, "error": str(e)})
                    pbar.set_postfix({"saved:skipped:failed": f"{len(results["saved"])}:{len(results["skipped"])}:{len(results["failed"])}"})
                    pbar.update(1)
                combined_results["saved"].extend(results["saved"])
                combined_results["skipped"].extend(results["skipped"])
                combined_results["failed"].extend(results["failed"])
        else:
            continue     
    # Delete files after processing all music files
    if delete_files:
        for file_path in set(files_to_delete):
            os.remove(file_path)
            combined_results["deleted"].append(file_path)
    return combined_results

def write_import_log(results, separate_logs, log_path):
    if not os.access(log_path, os.W_OK | os.X_OK):
        print("Cannot write log file(s) to current directory. Ensure that you have write permission. Skipping log creation.")
        return
    categories = results.keys()
    if not separate_logs:
        with open(os.path.join(log_path, f"lyrict_import_results.log"), "w", encoding="utf8") as log:
            for category in categories:
                if len(results[category]) > 0:
                    log.write(f"{category} files:\n")
                    for result_path in results[category]:
                        log.write(f"{result_path}\n")
                    log.write("\n")
    else:
        for category in categories:
            if len(results[category]) > 0:
                with open(os.path.join(log_path, f"lyrict_import_{category}.log"), "w", encoding="utf8") as log:
                    for result_path in results[category]:
                        log.write(f"{result_path}\n")    



#################################### EXPORT MUTAGEN ########################################
# Find all music files specified in -e, --extensions, default FLAC, MP3
def find_music_files(directory, extensions, guess_count, single_folder, progress):
    exts = tuple(["." + extension for extension in extensions])
    music_files = []

    if not single_folder:
        with tqdm(total = guess_count, desc="searching music", unit=" files", disable=not progress) as pbar:
            songs = 0
            for root, dirs, files in os.walk(directory):
                for file in files:
                    pbar.update(1)
                    if file.endswith(exts):
                        music_files.append(os.path.join(os.path.abspath(root), file))
                        songs += 1
                        pbar.set_postfix({"songs": songs})
    else:
        with tqdm(total = guess_count, desc="searching", unit=" files", disable=not progress) as pbar:
            songs = 0
            for file in os.listdir(directory):
                pbar.update(1)
                if file.endswith(exts):
                    music_files.append(os.path.join(os.path.abspath(directory), file))
                    songs += 1
                    pbar.set_postfix({"songs": songs})

    if len(music_files) > 0:
        return music_files
    else:
        print("No music files found. Closing in 5 seconds.")
        sleep(5)
        sys.exit()

# Extract lyrics from MP3 and FLAC files
def extract_lyrics(file_paths, progress, standardize):
    synced_lyrics = []
    unsynced_lyrics = []
    with tqdm(total=len(file_paths), desc="extracting lyrics", unit=" lyrics", disable=not progress) as pbar:
        synced_count = 0
        unsynced_count = 0
        for file_path in file_paths:
            if file_path.lower().endswith(".mp3"):
                synced, unsynced = process_mp3(file_path, synced_lyrics, unsynced_lyrics, standardize)
            elif file_path.lower().endswith(".flac"):
                synced, unsynced = process_flac(file_path, synced_lyrics, unsynced_lyrics, standardize)
            else:
                continue
            
            if synced:
                synced_count += 1
            if unsynced:
                unsynced_count += 1
            
            pbar.set_postfix({"synced:unsynced": f"{synced_count}:{unsynced_count}"})
            pbar.update(1)
    return synced_lyrics, unsynced_lyrics

# Function to extract and format SYLT to LRC style
def extract_sylt_to_lrc(sylt_frame):
    lrc_lines = []
    for text, timestamp in sylt_frame.text:
        minutes = timestamp // 60000
        seconds = (timestamp % 60000) / 1000
        lrc_timestamp = f"[{minutes:02}:{seconds:06.3f}]" # change "06.3f" to "06.2f" if you want "[00:00.00] text"
        lrc_line = f"{lrc_timestamp}{text}" # change "{lrc_timestamp}{text}" to "{lrc_timestamp} {text}" if you want "[00:00.00] text"
        lrc_lines.append(lrc_line)
    lrc_lines.sort()
    lrc_content = "\n".join(lrc_lines)
    return lrc_content

# Extract lyrics from MP3 files
def process_mp3(file_path, synced_lyrics, unsynced_lyrics, standardize):
    audio = MP3(file_path, ID3=ID3)
    synced = False
    unsynced = False
    for tag in audio.tags.values():
        if isinstance(tag, SYLT):
            lrc_content = extract_sylt_to_lrc(tag)
            synced_lyrics.append((file_path, lrc_content))
            synced = True
        elif isinstance(tag, USLT):
            unsynced_lyrics.append((file_path, tag.text))
            unsynced = True
        elif isinstance(tag, TXXX) and tag.desc == "LYRICS":
            lyrics = tag.text[0]
            if standardize:
                lyrics = standardize_timestamps(lyrics)
            synced_lyrics.append((file_path, lyrics))
            synced = True
    return synced, unsynced

# Extract lyrics from FLAC files
def process_flac(file_path, synced_lyrics, unsynced_lyrics, standardize):
    audio = FLAC(file_path)
    synced = False
    unsynced = False
    if "LYRICS" in audio:
        lyrics = audio["LYRICS"][0]
        if standardize:
            lyrics = standardize_timestamps(lyrics)
        synced_lyrics.append((file_path, lyrics))
        synced = True
    if "UNSYNCEDLYRICS" in audio:
        unsynced_lyrics.append((file_path, audio["UNSYNCEDLYRICS"][0]))
        unsynced = True
    return synced, unsynced

# Conform timestamp style to [00:00.000]TEXT
def standardize_timestamps(lyrics):
    match_to_skip = r"^\[(\d{2}:\d{2}\.\d{3})\](?! )(.*)$" # if you want the final version to be [00:00.00] text, change "\d{3})\](?! )" to "\d{2})\] "
    match_to_alter = r"^\[(\d{1,2}:\d{2}\.\d{2,3})\] *(.*)$"
    lines = lyrics.split('\n')
    standardized_lyrics = []

    for line in itertools.islice(lines, 5):
        skip = re.match(match_to_skip, line)
        if skip:
            return lyrics
    for line in lines:
        match = re.match(match_to_alter, line)
        if match:
            time_stamp = match.group(1)
            text = match.group(2)
            time_obj = datetime.strptime(time_stamp, "%M:%S.%f")
            formatted_time = time_obj.strftime("%M:%S.%f")[:-3] # if you want to change the formatting to [00:00.00] text, change "[:-3]" to "[:-4]
            standardized_lyrics.append(f"[{formatted_time}]{text}") # and also change "[{formatted_time}]{text}" to "[{formatted_time}] {text}"
        else:
            standardized_lyrics.append(line)
    return '\n'.join(standardized_lyrics)

# Export embedded lyrics to .lrc and .txt files
def write_lrc_files(lyrics, extension, overwrite, progress, write_success):
    with tqdm(total = len(lyrics), desc=f"saving {extension}", unit=f" {extension} files", disable=not progress) as pbar:
        saved = 0
        skipped = 0
        failed = 0
        for filename, lyrics in lyrics:
            pbar.update(1)
            basename = os.path.splitext(filename)[0]
            lyrics_filename = basename + extension
            lyrics = '\n'.join(line.strip() for line in lyrics.split('\r\n'))
            if not os.path.exists(lyrics_filename) or overwrite:
                try:
                    with open(lyrics_filename, 'w', encoding="utf-8") as f:
                        f.write(lyrics)
                    write_success["saved"].append((filename, extension))
                    saved += 1
                    pbar.set_postfix({"saved:skipped": f"{saved}:{skipped}"})                        
                except PermissionError:
                    write_success["failed"].append((filename, extension))
                    failed += 1
                    print(f"Failed to write {lyrics_filename} due to missing write permissions.")
            else:
                write_success["skipped"].append((filename, extension))
                skipped += 1
                pbar.set_postfix({"saved:skipped": f"{saved}:{skipped}"})
    return saved, skipped, failed

# Remove embedded lyrics tags from files
def purge_tags(write_success, progress):
    saved_list = [filepath for filepath, _ in write_success["saved"]]
    skipped_list = [filepath for filepath, _ in write_success["skipped"]]
    failed_list = [filepath for filepath, _ in write_success["failed"]]
    combined_list = saved_list + skipped_list
    seen = set()
    # Filter out "failed" file paths and remove duplicates
    delete_me = [filepath for filepath in combined_list if filepath not in failed_list and (filepath not in seen and seen.add(filepath) is None)]
    if len(delete_me) > 0:
        with tqdm(total=len(delete_me), desc="purging embedded lyrics", unit=" files", disable=not progress) as pbar:
            purged = 0
            failed = 0
            for file_path in delete_me:
                try:
                    if file_path.lower().endswith(".mp3"):
                        audio = MP3(file_path, ID3=ID3)
                        # Remove TXXX:LYRICS, SYLT, and USLT tags
                        tags_to_remove = []
                        for tag in audio.tags.values():
                            if isinstance(tag, TXXX) and tag.desc == "LYRICS":
                                tags_to_remove.append(tag)
                            elif isinstance(tag, (SYLT, USLT)):
                                tags_to_remove.append(tag)
                        for tag in tags_to_remove:
                            audio.tags.delall(tag.HashKey)
                        # Save with ID3v2.3
                        audio.save(v2_version=3)
                        
                    elif file_path.lower().endswith(".flac"):
                        audio = FLAC(file_path)
                        # Remove TXXX:LYRICS and TXXX:UNSYNCEDLYRICS tags
                        tags_to_remove = ["LYRICS", "UNSYNCEDLYRICS"]
                        for tag in tags_to_remove:
                            if tag in audio:
                                del audio[tag]
                        # Save the file
                        audio.save()
                    purged += 1
                    pbar.set_postfix({"purged:failed": f"{purged}:{failed}"})
                    pbar.update(1)                    
                    
                except Exception as e:
                    print(f"Error processing {file_path}: {e}")
                    failed += 1
                    pbar.set_postfix({"purged:failed": f"{purged}:{failed}"})
                    pbar.update(1)                         
                    continue
        return purged, failed

# Log the results of the export to disk
def export_log(write_success, separate_logs, log_path):
    if not os.access(log_path, os.W_OK | os.X_OK):
        print("Cannot write log file(s) to current directory. Ensure that you have write permission. Skipping log creation.")
        return
    categories = write_success.keys()
    if not separate_logs:
        with open(os.path.join(log_path, f"lyrict_export_results.log"), "w", encoding="utf8") as log:
            for category in categories:
                if len(write_success[category]) > 0:
                    log.write(f"{category} lyrics:\n")
                    for result_path, extension in write_success[category]:
                        log.write(f"{result_path} to {extension}\n")
                    log.write("\n")
    else:
        for category in categories:
            if len(write_success[category]) > 0:
                with open(os.path.join(log_path, f"lyrict_export_{category}.log"), "w", encoding="utf8") as log:
                    for result_path, extension in write_success[category]:
                        log.write(f"{result_path} to {extension}\n")

def main(args):
    directory = args.directory
    delete = args.delete
    extensions = args.extensions
    guess_count = args.guess_count
    log_to_disk = args.log_to_disk
    separate_logs = args.separate_logs
    log_path = args.log_path
    overwrite = args.overwrite
    progress = args.progress
    single_folder = args.single_folder
    import_mode = args.import_mode
    export_mode = args.export_mode
    test_run = args.test_mode
    mp3tag = args.mp3tag_mode
    standardize = args.standardize

    if test_run:
        lrc_paths, txt_paths = find_lrc_files(directory, guess_count, single_folder, progress)
        if lrc_paths and txt_paths:
            match_categories_lrc = find_matches(lrc_paths, "lrc", extensions, progress)
            match_categories_txt = find_matches(txt_paths, "txt", extensions, progress)
            if log_to_disk:
                write_log(match_categories_lrc, "lrc", separate_logs, log_path)
                write_log(match_categories_txt, "txt", separate_logs, log_path)
            errors = False
            if "unlinked" in match_categories_lrc.keys():
                print(f"LRC files without linked songs found:")
                for file_path in match_categories_lrc["unlinked"]:
                    print(file_path)
                errors = True
            if "unlinked" in match_categories_txt.keys():
                print(f"TXT files without linked songs found:")
                for file_path in match_categories_txt["unlinked"]:
                    print(file_path)
                errors = True
            if errors:
                print("Unlinked lyrics found. Closing in 5 seconds.")
                sleep(5)
                sys.exit()
            else:
                print(f"No unlinked lyrics files found, closing in 5 seconds.")
                sleep(5)
                sys.exit()
        elif lrc_paths and not txt_paths:
            match_categories = find_matches(lrc_paths, "lrc", extensions, progress)
            if log_to_disk:
                write_log(match_categories, "lrc", separate_logs, log_path)
            if "unlinked" in match_categories.keys():
                print("LRC files without linked songs found:")
                for file_path in match_categories["unlinked"]:
                    print(file_path)
                print("Closing in 5 seconds.")
                sleep(5)
                sys.exit()
            else:
                print(f"No unlinked LRC files found, closing in 5 seconds.")
                sleep(5)
                sys.exit()
        elif not lrc_paths and txt_paths:
            match_categories = find_matches(txt_paths, "txt", extensions, progress)
            if log_to_disk:
                write_log(match_categories, "txt", separate_logs, log_path)
            if "unlinked" in match_categories.keys():
                print("TXT files without linked songs found:")
                for file_path in match_categories["unlinked"]:
                    print(file_path)
                print("Closing in 5 seconds.")
                sleep(5)
                sys.exit()
            else:
                print(f"No unlinked LRC files found, closing in 5 seconds.")
                sleep(5)
                sys.exit()

    if mp3tag:
        action_folder = os.path.join(os.getenv('APPDATA')+"\\Mp3tag\\data\\actions\\")
        lrc_paths, txt_paths = find_lrc_files(directory, guess_count, single_folder, progress)
        if lrc_paths and txt_paths:
            match_categories_lrc = find_matches(lrc_paths, "lrc", extensions, progress)
            match_categories_txt = find_matches(txt_paths, "txt", extensions, progress)
            if log_to_disk:
                write_log(match_categories_lrc, "lrc", separate_logs, log_path)
                write_log(match_categories_txt, "txt", separate_logs, log_path)
            mp3tag_flow_both(match_categories_lrc, match_categories_txt, action_folder, overwrite, extensions)
        elif lrc_paths and not txt_paths:
            match_categories = find_matches(lrc_paths, "lrc", extensions, progress)
            if log_to_disk:
                write_log(match_categories, "lrc", separate_logs, log_path)
            mp3tag_flow_single(match_categories, action_folder, overwrite, extensions, "lrc")
        elif not lrc_paths and txt_paths:
            match_categories = find_matches(txt_paths, "txt", extensions, progress)
            if log_to_disk:
                write_log(match_categories, "txt", separate_logs, log_path)
            mp3tag_flow_single(match_categories, action_folder, overwrite, extensions, "txt")

    if import_mode:
        lrc_paths, txt_paths = find_lrc_files(directory, guess_count, single_folder, progress)
        if lrc_paths and txt_paths:
            match_categories_lrc = find_matches(lrc_paths, "lrc", extensions, progress)
            match_categories_txt = find_matches(txt_paths, "txt", extensions, progress)
            results = import_lyrics(match_categories_lrc=match_categories_lrc,
                                    match_categories_txt=match_categories_txt,
                                    delete_files=delete,
                                    standardize=standardize,
                                    progress=progress,
                                    overwrite=overwrite)
            if log_to_disk:
                write_import_log(results, separate_logs, log_path)
            saved = len(results["saved"])
            skipped = len(results["skipped"])
            failed = len(results["failed"])
            deleted = len(results["deleted"])
            print(f"{saved} embedded, {skipped} skipped, {failed} failed, {deleted} external lyrics deleted.")
        elif lrc_paths and not txt_paths:
            match_categories_lrc = find_matches(lrc_paths, "lrc", extensions, progress)
            results = import_lyrics(match_categories_lrc=match_categories_lrc,
                                    delete_files=delete,
                                    standardize=standardize,
                                    progress=progress,
                                    overwrite=overwrite)
            if log_to_disk:
                write_import_log(results, separate_logs, log_path)
            saved = len(results["saved"])
            skipped = len(results["skipped"])
            failed = len(results["failed"])
            deleted = len(results["deleted"])
            print(f"{saved} embedded, {skipped} skipped, {failed} failed, {deleted} external lyrics deleted.")
        elif not lrc_paths and txt_paths:
            match_categories_txt = find_matches(lrc_paths, "txt", extensions, progress)
            results = import_lyrics(match_categories_txt=match_categories_txt,
                                    delete_files=delete,
                                    standardize=standardize,
                                    progress=progress,
                                    overwrite=overwrite)
            if log_to_disk:
                write_import_log(results, separate_logs, log_path)
            saved = len(results["saved"])
            skipped = len(results["skipped"])
            failed = len(results["failed"])
            deleted = len(results["deleted"])
            print(f"{saved} embedded, {skipped} skipped, {failed} failed, {deleted} external lyrics deleted.")

    if export_mode:
        music_files = find_music_files(directory, extensions, guess_count, single_folder, progress)
        synced_lyrics, unsynced_lyrics = extract_lyrics(music_files, progress, standardize)
        write_success = {"saved":[], "skipped":[], "failed":[]}
        lrc_saved = 0
        lrc_skipped = 0
        lrc_failed = 0
        txt_saved = 0
        txt_skipped = 0
        txt_failed = 0
        purged = 0
        failed = 0
        if len(synced_lyrics) > 0:
            lrc_saved, lrc_skipped, lrc_failed = write_lrc_files(synced_lyrics, ".lrc", overwrite, progress, write_success)
        if len(unsynced_lyrics) > 0:
            txt_saved, txt_skipped, lrc_failed = write_lrc_files(unsynced_lyrics, ".txt", overwrite, progress, write_success)
        
        if log_to_disk:
            export_log(write_success, separate_logs, log_path)

        if delete:
            purged, failed = purge_tags(write_success, progress)
        
        print(f"\n{len(music_files)} music files processed, {len(synced_lyrics)} synced lyrics and {len(unsynced_lyrics)} unsynced lyrics found.")
        if lrc_saved > 0 or lrc_skipped > 0 or lrc_failed > 0:
            print(f"{lrc_saved} synced lyrics written to disk, {lrc_skipped} skipped, {lrc_failed} errors.")
        if txt_saved > 0 or txt_skipped > 0 or lrc_failed > 0:
            print(f"{txt_saved} unsynced lyrics written to disk, {txt_skipped} skipped., {txt_failed} errors.")
        if purged > 0 or failed > 0:
            print(f"Deleted embedded lyrics of {purged} files, encountered {failed} errors.")
        print("Closing in 5 seconds.")
        sleep(5)
        sys.exit()
        
if __name__ == "__main__":
    args = parse_arguments()
    try:
        main(args)
    except KeyboardInterrupt:
        print("Interrupted")
        try:
            sys.exit(130)
        except SystemExit:
            os._exit(130)