[user, root_dir, playlists] = parse_cmdline_args()

# Show some pretty ASCII art

print " ____ _ __ __ _ ____ _ _ _ _ ____ "

print " / ___| ___ ___ __ _| | ___ | \/ |_ _ ___(_) ___ | _ \| | __ _ _ _| (_)___| |_ / ___| _ _ _ __ ___ "

print "| | _ / _ \ / _ \ / _` | |/ _ \ | |\/| | | | / __| |/ __| | |_) | |/ _` | | | | | / __| __| \___ \| | | | '_ \ / __|"

print "| |_| | (_) | (_) | (_| | | __/ | | | | |_| \__ \ | (__ | __/| | (_| | |_| | | \__ \ |_ ___) | |_| | | | | (__ "

print " \____|\___/ \___/ \__, |_|\___| |_| |_|\__,_|___/_|\___| |_| |_|\__,_|\__, |_|_|___/\__| |____/ \__, |_| |_|\___|"

print " |___/ |___/ |___/ "

print "\nThis script will sync a local XSPF or M3U format playlist, to a playlist on Google Music. Use the Google Music uploader to\nfirst upload the songs in the playlist.\n"

# Log in to Google Music

api = login_to_google_music(user)

# Get all songs in the library

print "Retrieving all songs in library. This may take a minute..."

remote_library = api.get_all_songs()

for playlist in playlists:

print "Syncing playlist: " + playlist

process_playlist(api, playlist, remote_library, root_dir)

# Be a good citizen and log out

api.logout()

print "Bye!"

argvParser = argparse.ArgumentParser()

argvParser.add_argument('-u', '--user', dest='user', nargs='?', help="The Google username/email to log in with.")

argvParser.add_argument('-r', '--root-dir', dest='root_dir', nargs='?', default='./', help="The root directory of a music directory. Useful for M3U playlists.")

argvParser.add_argument('playlists', nargs='+', help="The filenames of playlists.")

args = argvParser.parse_args()

# If the root directory doesn't have a directory separator at the end, add it

if not args.root_dir.endswith('/'):

args.root_dir += '/'

api = Mobileclient()

attempts = 0

while attempts < 3:

if user == None:

user = raw_input("Google username or email: ")

# Try to read the password from a file

# If file doesn't exist, ask for password

# This is useful for 2-step authentication only

# Don't store your regular password in plain text!

try:

pw_file = open("pass.txt")

password = pw_file.readline()

print "Reading password from pass.txt."

except IOError:

password = getpass()

print "\nLogging in..."

if api.login(user, password):

return api

else:

print "Login failed."

# Set the username to none so it is prompted to be re-entered on the next loop iteration

user = None

attempts += 1

print str(attempts) + " failed login attempts. Giving up."

# Get the filename. This will be used as the playlist name.

local_playlist_name, local_playlist_type = path.splitext(path.basename(local_playlist_path))

# Check that the file extension and parse the playlist

if local_playlist_type == ".xspf":

(name, local_tracks) = parse_xml(local_playlist_path)

# If the xml contained a playlist name, use that instead of the filename

if name:

local_playlist_name = name

elif local_playlist_type == ".m3u":

local_tracks = parse_m3u(local_playlist_path, root_dir)

else:

print "Error: Playlist " + local_playlist_name + " must be XSPF or M3U format."

return

# Check that the playlist has tracks in it

if len(local_tracks) == 0:

print "Error: Playlist " + local_playlist_name + " is empty."

return

# Sync the playlist

if not sync_playlist(api, remote_library, local_tracks , local_playlist_name):

print "Syncing playlist " + local_playlist_name + " failed."

# Parse the playlist XML file

xml_root = parse(local_playlist_path).getroot()

# Get the playlist title

playlist_name = None

title_element = xml_root.find("{http://xspf.org/ns/0/}title")

if not title_element is None:

playlist_name = title_element.text.strip()

# Get the list of tracks in the playlists

tracks_elements = xml_root.find("{http://xspf.org/ns/0/}trackList")

if tracks_elements is None:

print "Error: Malformed or empty playlist."

exit(1)

# Convert the XML elements to a dict

tracks = []

for track in tracks_elements:

ntrack = {}

for field in track:

if field.tag == "{http://xspf.org/ns/0/}title":

ntrack['title'] = field.text.strip()

elif field.tag == "{http://xspf.org/ns/0/}creator":

ntrack['artist'] = field.text.strip()

elif field.tag == "{http://xspf.org/ns/0/}album":

ntrack['album'] = field.text.strip()

elif field.tag == "{http://xspf.org/ns/0/}location":

ntrack['path'] = field.text.strip()

tracks.append(ntrack)

playlist = open(local_playlist_path, 'r')

# Convert the tracks in the playlist into a dict

tracks = []

for line in playlist:

# Remove the newline from the end of the string

line = line.rstrip()

format = get_song_format(line)

try:

if format == "mp3":

song = EasyID3(root_dir + line)

elif format == "mp4" or format == "m4a":

song = EasyMP4(root_dir + line)

elif format == "flac":

song = FLAC(root_dir + line)

else:

print "\"" + line + "\" is not a supported format. Supported formats are MP3, MP4, M4A, or FLAC."

continue

except ID3NoHeaderError:

print "\"" + filename + "\" does not contain an ID3 tag."

# IO errors are most likely file not found errors or the wrong format file

except IOError as ioe:

print "\"" + line + "\": " + ioe.strerror

# Only take the first

track = {}

track['title'] = song['title'][0]

track['artist'] = song['artist'][0]

track['album'] = song['album'][0]

track['path'] = root_dir + line

tracks.append(track)

# Strip whitespaces and use lowercase

string = string.strip()

string = string.lower()

# Remove (feat. [some artist])

patterns = ['^(.*?)\(feat\..*?\).*?$', '^(.*?)feat\..*?$']

for pattern in patterns:

reg = re.search(pattern, string)

if reg:

string = reg.group(1)

seqMatchArtist = difflib.SequenceMatcher(None, "foobar", clean_string(l_track['artist']))

seqMatchTitle = difflib.SequenceMatcher(None, "foobar", clean_string(l_track['title']))

bestMatch = 0

for remoteTrack in trackList:

seqMatchArtist.set_seq1(clean_string(remoteTrack['artist']))

seqMatchTitle.set_seq1(clean_string(remoteTrack['title']))

scoreArtist = seqMatchArtist.quick_ratio()

scoreTitle = seqMatchTitle.quick_ratio()

totalScore = (scoreArtist + scoreTitle) / 2

if totalScore == 1:

return remoteTrack

elif totalScore > bestMatch:

bestMatch = totalScore

bestMatchTrack = remoteTrack

if bestMatch >= 0.85:

return bestMatchTrack

else:

# Get all available playlists from Google Music

remote_playlists = api.get_all_playlists(False, False)

# Try to find the playlist if it already exists

remote_playlist_id = None

for item in remote_playlists:

if item['name'] == local_playlist_name:

# TODO: Handle multiple playlists with the same name

remote_playlist_id = item['id']

print "Found playlist with ID: " + remote_playlist_id

break

# If the playlist wasn't found, create it

if remote_playlist_id is None:

print "Playlist not found on Google Music. Creating it."

remote_playlist_id = api.create_playlist(local_playlist_name)

else:

print "A playlist already exists with that name. Updating existing playlists is not currently supported."

return False

# TODO: Reintegrate checking existing playlists

# Get the songs on the playlist

#remote_tracks = api.get_playlist_songs(remote_playlist_id)

# Check if each track in the local playlist is on the Google Music playlist

tracks_to_add_names = []

tracks_to_add_ids = []

for local_track in local_tracks:

added = False

# Check if the track is already present in the playlist

#if find_track(local_track, remote_tracks) != False:

# added = True

# Add the track to the playlist

if not added:

# Find the song ID

local_track_id = None

matchedTrack = find_track(local_track, remote_library)

if matchedTrack:

local_track_id = matchedTrack['id']

tracks_to_add_names.append(matchedTrack['artist'] + " - " + matchedTrack['title'])

tracks_to_add_ids.append(matchedTrack['id'])

# Check if the song wasn't found in the library

if local_track_id == None:

print "Error: Track \"" + local_track["artist"] + " - " + local_track['title'] + "\" in local playlist, but not found in Google Music library. Skipping this track."

continue

# Check that there are tracks to add

if len(tracks_to_add_ids) == 0:

print "\nPlaylist is already up-to-date."

return True

# Print the songs about to be added

print "Tracks to be added:"

for track in tracks_to_add_names:

print "\t" + track

print "\nThe above tracks will be added to the playlist \"" + local_playlist_name + "\""

if raw_input("Is this okay? (y,n) ") == "y":

# Finally, add the new track to the playlist

for track_id in tracks_to_add_ids:

api.add_songs_to_playlist(remote_playlist_id, track_id)

print "\nTracks added to playlist."

else:

print "Sorry!"

return False