tag.py

"""
    Created by reddit user /u/notsplat.
    This is share-ware; edit it if you like, tell your friends if you want to. Just leave this header part up here!
    If you want to donate to me, use this link:
    https://greenaddress.it/pay/GA4VAAh9K2xw1UAG8fat9asiCAUcht/
"""

import eyed3
import os

# Change this to your own music library's location.

rootdir = u"C:/Users/Username/Music"   # Change me!

valid_extensions = [".mp3"]

def fix_tags(directory):
    # Loop through files in library location.
    for subdir, dirs, files in os.walk(directory):
        # If we've already done this album, skip.
        if os.path.isfile(os.path.join(subdir, "_ignore")) and subdir != rootdir:
            continue
        elif subdir != rootdir:
            # Make sure it's an album folder.

            x = False

            for y in os.listdir(subdir):
                if y[len(y)-4:] in valid_extensions:
                    x = True
            if x:
                open(os.path.join(subdir, "_ignore"), 'a').close()

        # Sort our files so we can set the track number from it.
        sorted(files)

        # Just a counter.
        q = 0

        for file in files:
            # Try/except for catching errors.
            try:
                if file[len(file)-4:] not in valid_extensions:
                    continue

                q += 1

                # Load our file for this iteration.
                audiofile = eyed3.load(os.path.join(subdir, file))
                print "LOADED:\t" + file + "."

                # If the total discs is one or nil, leave our disc tag empty.
                if audiofile.tag.disc_num[1] <= 1:
                    audiofile.tag.disc_num = (None, None)

                    v = str(q)

                    if q < 10:
                        v = "0" + v

                    audiofile.tag.track_num = (v, audiofile.tag.track_num[1])

                # Otherwise, add trailing zeroes to disc number.
                else:
                    # Convert to str to read.
                    d = str(audiofile.tag.disc_num)

                    # Initialise variables for disc index and total, respectively.
                    i, t = "", ""

                    # Should it be a tuple, strip it of its parentheses and use the resulting string to read from.
                    if type(eval(d)) == tuple:
                        s = d.lstrip("(").rstrip(")")

                        # Read our index from the tuple.
                        i = s[0:s.find(",")]

                        # Remember, trailing zeroes are not necessary for indices of 10 or above.
                        if int(i) < 10:
                            # Neither is it necessary to have multiple trailing zeroes for our disc numbers.
                            if i[0] != "0":
                                i = "0" + i

                    # Set our disc number; bizarrely, the title automatically trails given a track index which is trailed. This still has to be saved later.
                    audiofile.tag.disc_num = (i, audiofile.tag.disc_num[1])

                # String-ify the track number property.
                v = str(audiofile.tag.track_num)

                # Initialise some variables for index and total amount of tracks.
                i, t = "", ""

                # If there is not already a trailing zero then ...
                if v[0] != "0":
                    # Should our track number be a tuple, strip its parentheses and make it readable as a string.
                    if type(eval(v)) == tuple:
                        s = v.lstrip("(").rstrip(")")

                        # Find our index from this string-ified tuple.
                        i = s[0:s.find(",")]

                        # Once again, we do not need to trail zeroes unless our track is between 0-9, or is already trailed.
                        if int(i) < 10:
                            if i[0] != "0":
                                i = "0" + i

                    # Set our track number. As above, no need to parse or rewrite the total.
                    audiofile.tag.track_num = (i, audiofile.tag.track_num[1])

                # Rename and re-tag untitled tracks.
                try:
                    # Firstly, lower() the title, and see if it is titled like a typical untitled track.
                    if audiofile.tag.title.lower() == "[untitled]" or audiofile.tag.title.lower() == "untitled":
                        # We save the title tag with unicode-encoded strings.
                        audiofile.tag.title = u"Untitled"
                except TypeError:
                    # If it is unreadable as a string, then that probably warrants that it be titled blank, too.
                    audiofile.tag.title = u"Untitled"

                # Save our tracks and their tags; the fruits of our labour.
                # We use os.path.normpath(path) to localise the file location's string to the directory structure of the host system. This is to avoid quite unlikely but pretty annoying errors that would occur from using "/" on a Windows System. Screw you, Microsoft.
                audiofile.tag.save(
                    os.path.normpath(os.path.join(subdir, file)),
                    eyed3.id3.ID3_V2_3
                )

                # We print our result!
                print u"SAVED: \t" + file + u"."

            except AttributeError as e:
                # We don't want to print attribute errors when the file isn't even an mp3. This happens when our function loops through some other files that may be in the directory -- for example, "folder.png" or similar.
                print "AttributeError:\t" + str(e)

            # Print our other exceptions.
            except IOError as e:
                print "IOError:\t" + str(e)

            except UnicodeEncodeError as e:
                print "UnicodeEncodeError:\t" + str(e)

def capitalise_title(title):
    # List the words we want in lower-case.
    words = ["a", "an", "at", "and", "by", "for", "in", "of", "on", "to", "the"]

    # Split the title into a list of words to check.
    new_title = title.lower().split(" ")

    for i, word in enumerate(new_title):
        # Always capitalise the first letter of the title.
        # We also capitalise if the word is not in the above list.
        if i == 0 or not word in words:
            new_title[i] = word[0].upper() + word[1:].lower()
        else:
            new_title[i] = word.lower()

    # Create a buffer and write to our new_title.
    _new_title = new_title
    new_title = ""

    for i, word in enumerate(_new_title):
        new_title += word

        # We don't want a space to be the last character of the title.
        if i < len(_new_title) - 1:
            new_title += " "

    return new_title

def fix_folders(directory):
    # Loop through each artist folder.
    for artist in os.listdir(directory):
        # Just to make the join()'s a little easier.
        current_folder = os.path.join(directory, artist)

        # Skip to next folder if this is not a directory.
        if not os.path.isdir(current_folder):
            continue

        # Loop through the album folders.
        for album in os.listdir(current_folder):
            # Skip if not a directory.
            if not os.path.isdir(os.path.join(current_folder, album)):
                continue

            # Skip to next album if "ignore" file exists.
            if os.path.isfile(os.path.join(os.path.join(current_folder, album), "ignore")):
                continue

            # Capitalise the title correctly.
            new_album = capitalise_title(album)

            # No need to rename if it's identical to the previous title.
            if new_album != album:
                os.rename(
                    os.path.join(current_folder, album),
                    os.path.join(current_folder, new_album)
                )

        # We do the album stuff first for each artist, then re-capitalise the artist's title.
        new_artist = capitalise_title(artist)

        if new_artist != artist:
            os.rename(
                os.path.join(directory, artist),
                os.path.join(directory, new_artist)
            )

def main():
    fix_tags(rootdir)
    fix_folders(rootdir)

# Call main().
if __name__ == '__main__':
    main()