def download_by_id(self, key, upload=False):
if self.logstack.has_key(key) and self.logstack[key]["state"] != "fail":
return
url = "http://www.youtube.com/watch?v=%s" % (key)
if upload:
print "upload google music!!!"
self.current_key = key
self.logstack[key] = {"path": "", "process": "", "state": "downloading"}
result = None
try:
self.download([url])
except:
self.logstack[key]["state"] = "fail"
return
if upload:
self.logstack[key]["state"] = "uploading"
print self.logstack[key]["path"]
path = self.logstack[key]["path"].encode("utf-8")
api = Api()
api.login(gpass.id, gpass.passwd)
ids = api.get_all_playlist_ids(auto=False, instant=False)
playlist_id = ids["user"]["youtube"]
try:
result = api.upload([path])
except:
print "upload error"
self.logstack[key]["state"] = "fail"
return
if len(result):
api.add_songs_to_playlist(playlist_id, result.values()[0])
self.logstack[key]["state"] = "complete"
class GoogleMusicApi():
def __init__(self):
self.xbmc = sys.modules["__main__"].xbmc
self.xbmcgui = sys.modules["__main__"].xbmcgui
self.xbmcplugin = sys.modules["__main__"].xbmcplugin
self.settings = sys.modules["__main__"].settings
self.language = sys.modules["__main__"].language
self.dbg = sys.modules["__main__"].dbg
self.common = sys.modules["__main__"].common
self.storage = sys.modules["__main__"].storage
self.gmusicapi = Api()
self.login = GoogleMusicLogin.GoogleMusicLogin(self.gmusicapi)
def getPlaylistSongs(self, playlist_id, forceRenew=False):
if not self.storage.isPlaylistFetched(playlist_id) or forceRenew:
self.updatePlaylistSongs(playlist_id)
songs = self.storage.getPlaylistSongs(playlist_id)
return songs
def getPlaylistsByType(self, playlist_type, forceRenew=False):
if forceRenew:
self.updatePlaylists(playlist_type)
playlists = self.storage.getPlaylistsByType(playlist_type)
if len(playlists) == 0 and not forceRenew:
self.updatePlaylists(playlist_type)
playlists = self.storage.getPlaylistsByType(playlist_type)
return playlists
def getSong(self, song_id):
return self.storage.getSong(song_id)
def updatePlaylistSongs(self, playlist_id):
api_songs = []
self.login.login()
if playlist_id == 'all_songs':
api_songs = self.gmusicapi.get_all_songs()
else:
api_songs = self.gmusicapi.get_playlist_songs(playlist_id)
self.storage.storeApiSongs(api_songs, playlist_id)
def updatePlaylists(self, playlist_type):
self.login.login()
playlists = self.gmusicapi.get_all_playlist_ids(playlist_type=="auto", playlist_type=="instant", playlist_type=="user", always_id_lists=True)
self.storage.storePlaylists(playlists[playlist_type], playlist_type)
def getSongStreamUrl(self, song_id):
self.login.login()
stream_url = self.gmusicapi.get_stream_url(song_id)
#self.storage.updateSongStreamUrl(song_id, stream_url)
return stream_url
def download_by_id(self, key, upload=False):
if self.logstack.has_key(
key) and self.logstack[key]['state'] != 'fail':
return
url = 'http://www.youtube.com/watch?v=%s' % (key)
if upload:
print 'upload google music!!!'
self.current_key = key
self.logstack[key] = {
'path': '',
'process': '',
'state': 'downloading'
}
result = None
try:
self.download([url])
except:
self.logstack[key]['state'] = 'fail'
return
if upload:
self.logstack[key]['state'] = 'uploading'
print self.logstack[key]['path']
path = self.logstack[key]['path'].encode('utf-8')
api = Api()
api.login(gpass.id, gpass.passwd)
ids = api.get_all_playlist_ids(auto=False, instant=False)
playlist_id = ids['user']['youtube']
try:
result = api.upload([path])
except:
print 'upload error'
self.logstack[key]['state'] = 'fail'
return
if len(result):
api.add_songs_to_playlist(playlist_id, result.values()[0])
self.logstack[key]['state'] = 'complete'
class GoogleMusicApi():
def __init__(self):
self.storage = sys.modules["__main__"].storage
self.gmusicapi = Api(debug_logging=False)
self.login = GoogleMusicLogin.GoogleMusicLogin(self.gmusicapi)
def getPlaylistSongs(self, playlist_id, forceRenew=False):
if playlist_id == 'thumbsup':
return self.storage.getThumbsup()
if playlist_id == 'lastadded':
return self.storage.getLastadded()
if playlist_id == 'mostplayed':
return self.storage.getMostplayed()
if playlist_id == 'freepurchased':
return self.storage.getFreepurchased()
if not self.storage.isPlaylistFetched(playlist_id) or forceRenew:
self.updatePlaylistSongs(playlist_id)
songs = self.storage.getPlaylistSongs(playlist_id)
return songs
def getPlaylistsByType(self, playlist_type, forceRenew=False):
if playlist_type == 'auto':
return [['thumbsup', 'Highly Rated'], ['lastadded', 'Last Added'],
['freepurchased', 'Free and Purchased'],
['mostplayed', 'Most Played']]
if forceRenew:
self.updatePlaylists(playlist_type)
playlists = self.storage.getPlaylistsByType(playlist_type)
if len(playlists) == 0 and not forceRenew:
self.updatePlaylists(playlist_type)
playlists = self.storage.getPlaylistsByType(playlist_type)
return playlists
def getSong(self, song_id):
return self.storage.getSong(song_id)
def updatePlaylistSongs(self, playlist_id):
api_songs = []
self.login.login()
if playlist_id == 'all_songs':
api_songs = self.gmusicapi.get_all_songs()
else:
api_songs = self.gmusicapi.get_playlist_songs(playlist_id)
if api_songs:
self.storage.storeApiSongs(api_songs, playlist_id)
def updatePlaylists(self, playlist_type):
self.login.login()
playlists = self.gmusicapi.get_all_playlist_ids(playlist_type)
self.storage.storePlaylists(playlists[playlist_type], playlist_type)
def getSongStreamUrl(self, song_id):
self.login.login()
stream_url = self.gmusicapi.get_stream_url(song_id)
#self.storage.updateSongStreamUrl(song_id, stream_url)
return stream_url
def getFilterSongs(self, filter_type, filter_criteria):
songs = self.storage.getFilterSongs(filter_type, filter_criteria)
return songs
def getCriteria(self, criteria):
return self.storage.getCriteria(criteria)
def getSearch(self, query):
return self.storage.getSearch(query)
def clearCache(self):
self.storage.clearCache()
self.login.clearCookie()
def clearCookie(self):
self.login.clearCookie()
class GoogleMusicApi():
def __init__(self):
self.storage = sys.modules["__main__"].storage
self.gmusicapi = Api(debug_logging=False)
self.login = GoogleMusicLogin.GoogleMusicLogin(self.gmusicapi)
def getPlaylistSongs(self, playlist_id, forceRenew=False):
if playlist_id == 'thumbsup':
return self.storage.getThumbsup()
if playlist_id == 'lastadded':
return self.storage.getLastadded()
if playlist_id == 'mostplayed':
return self.storage.getMostplayed()
if playlist_id == 'freepurchased':
return self.storage.getFreepurchased()
if not self.storage.isPlaylistFetched(playlist_id) or forceRenew:
self.updatePlaylistSongs(playlist_id)
songs = self.storage.getPlaylistSongs(playlist_id)
return songs
def getPlaylistsByType(self, playlist_type, forceRenew=False):
if playlist_type == 'auto':
return [['thumbsup','Highly Rated'],['lastadded','Last Added'],['freepurchased','Free and Purchased'],['mostplayed','Most Played']]
if forceRenew:
self.updatePlaylists(playlist_type)
playlists = self.storage.getPlaylistsByType(playlist_type)
if len(playlists) == 0 and not forceRenew:
self.updatePlaylists(playlist_type)
playlists = self.storage.getPlaylistsByType(playlist_type)
return playlists
def getSong(self, song_id):
return self.storage.getSong(song_id)
def updatePlaylistSongs(self, playlist_id):
api_songs = []
self.login.login()
if playlist_id == 'all_songs':
api_songs = self.gmusicapi.get_all_songs()
else:
api_songs = self.gmusicapi.get_playlist_songs(playlist_id)
if api_songs:
self.storage.storeApiSongs(api_songs, playlist_id)
def updatePlaylists(self, playlist_type):
self.login.login()
playlists = self.gmusicapi.get_all_playlist_ids(playlist_type)
self.storage.storePlaylists(playlists[playlist_type], playlist_type)
def getSongStreamUrl(self, song_id):
self.login.login()
stream_url = self.gmusicapi.get_stream_url(song_id)
#self.storage.updateSongStreamUrl(song_id, stream_url)
return stream_url
def getFilterSongs(self, filter_type, filter_criteria):
songs = self.storage.getFilterSongs(filter_type, filter_criteria)
return songs
def getCriteria(self, criteria):
return self.storage.getCriteria(criteria)
def getSearch(self, query):
return self.storage.getSearch(query)
def clearCache(self):
self.storage.clearCache()
self.login.clearCookie()
def clearCookie(self):
self.login.clearCookie()
class MusicSync(object):
def __init__(self, email=None, password=None):
self.api = Api()
if not email:
email = raw_input("Email: ")
if not password:
password = getpass()
self.email = email
self.password = password
self.logged_in = self.auth()
print "Fetching playlists from Google..."
self.playlists = self.api.get_all_playlist_ids(auto=False)
print "Got %d playlists." % len(self.playlists['user'])
print ""
def auth(self):
self.logged_in = self.api.login(self.email, self.password)
if not self.logged_in:
print "Login failed..."
exit()
print ""
print "Logged in as %s" % self.email
print ""
def sync_playlist(self, filename, remove_missing=False):
filename = self.get_platform_path(filename)
os.chdir(os.path.dirname(filename))
title = os.path.splitext(os.path.basename(filename))[0]
print "Synching playlist: %s" % filename
if title not in self.playlists['user']:
print " didn't exist... creating..."
self.playlists['user'][title] = [self.api.create_playlist(title)]
print ""
plid = self.playlists['user'][title][0]
goog_songs = self.api.get_playlist_songs(plid)
print "%d songs already in Google Music playlist" % len(goog_songs)
local_songs = self.get_songs_from_playlist(filename)
print "%d songs in local playlist" % len(local_songs)
# Sanity check max 1000 songs per playlist
if len(local_songs) > MAX_SONGS_IN_PLAYLIST:
print " Google music doesn't allow more than %d songs in a playlist..." % MAX_SONGS_IN_PLAYLIST
print " Will only attempt to sync the first %d songs." % MAX_SONGS_IN_PLAYLIST
del local_songs[MAX_SONGS_IN_PLAYLIST:]
existing_files = 0
added_files = 0
failed_files = 0
removed_files = 0
fatal_count = 0
for fn, song in local_songs:
if self.file_already_in_list(song, goog_songs):
existing_files += 1
continue
print ""
print "Adding: %s" % os.path.basename(fn)
online = self.find_song(song)
song_id = None
if online:
song_id = online['id']
print " already uploaded [%s]" % song_id
else:
if not os.path.isfile(fn):
print " Attempted to upload non-existent file", song
continue
attempts = 0
result = []
while not result and attempts < MAX_UPLOAD_ATTEMPTS_PER_FILE:
print " uploading... (may take a while)"
attempts += 1
try:
result = self.api.upload(fn)
except (BadStatusLine, CannotSendRequest):
# Bail out if we're getting too many disconnects
if fatal_count >= MAX_CONNECTION_ERRORS_BEFORE_QUIT:
print ""
print "Too many disconnections - quitting. Please try running the script again."
print ""
exit()
print "Connection Error -- Reattempting login"
fatal_count += 1
self.api.logout()
result = []
time.sleep(STANDARD_SLEEP)
except:
result = []
time.sleep(STANDARD_SLEEP)
try:
if result[0]:
song_id = result[0].itervalues().next()
else:
song_id = result[1].itervalues().next()
print " upload complete [%s]" % song_id
except:
print " upload failed - skipping"
if not song_id:
failed_files += 1
continue
added = self.api.add_songs_to_playlist(plid, song_id)
time.sleep(.3) # Don't spam the server too fast...
print " done adding to playlist"
added_files += 1
if remove_missing:
for s in goog_songs:
print ""
print "Removing: %s" % s['title']
self.api.remove_songs_from_playlist(plid, s.id)
time.sleep(.3) # Don't spam the server too fast...
removed_files += 1
print ""
print "---"
print "%d songs unmodified" % existing_files
print "%d songs added" % added_files
print "%d songs failed" % failed_files
print "%d songs removed" % removed_files
def get_songs_from_playlist(self, filename):
ext = os.path.splitext(filename)[1].lower()
if ext == '.m3u':
return list(self._get_songs_from_m3u_playlist(filename))
elif ext == '.xml':
return list(self._get_songs_from_itunes_playlist(filename))
def _get_songs_from_m3u_playlist(self, filename):
with codecs.open(filename, encoding='utf-8') as f:
for line in f:
line = line.rstrip().replace(u'\ufeff',u'')
if line == "" or line[0] == "#":
continue
path = os.path.abspath(self.get_platform_path(line))
if not os.path.exists(path):
print "File not found: %s" % line
continue
yield (path, self.get_id3_tag(path))
def _get_songs_from_itunes_playlist(self, filename):
plist = plistlib.readPlist(filename)
for track_id, track in plist['Tracks'].iteritems():
p = urlparse.urlparse(track['Location'])
path = os.path.abspath(os.path.join(p.netloc, p.path))
yield (path, {
'name': track['Name'],
#'artist': track['Artist'],
'album': track['Album'],
'track': track['Track Number'] if 'Track Number' in track else 0,
'disc': track['Disc Number'] if 'Disc Number' in track else 1
})
def file_already_in_list(self, song, goog_songs):
i = 0
while i < len(goog_songs):
if self.tag_compare(goog_songs[i], song):
goog_songs.pop(i)
return True
i += 1
return False
def get_id3_tag(self, filename):
data = mutagen.File(filename, easy=True)
r = {}
if 'title' not in data:
title = os.path.splitext(os.path.basename(filename))[0]
print 'Found song with no ID3 title, setting using filename:'
print ' %s' % title
print ' (please note - the id3 format used (v2.4) is invisible to windows)'
data['title'] = [title]
data.save()
r['name'] = data['title'][0]
r['track'] = int(data['tracknumber'][0].split('/')[0]) if 'tracknumber' in data else 0
# If there is no track, try and get a track number off the front of the file... since thats
# what google seems to do...
# Not sure how google expects it to be formatted, for now this is a best guess
if r['track'] == 0:
m = re.match("(\d+) ", os.path.basename(filename))
if m:
r['track'] = int(m.group(0))
r['artist'] = data['artist'][0] if 'artist' in data else ''
r['album'] = data['album'][0] if 'album' in data else ''
return r
def find_song(self, song):
results = self.api.search(song['name'])
# NOTE - dianostic print here to check results if you're creating duplicates
#print results['song_hits']
#print "%s ][ %s ][ %s ][ %s" % (tag['title'], tag['artist'], tag['album'], tag['track'])
return find_in_list(results['song_hits'], song)
def tag_compare(self, g_song, tag):
# If a google result has no track, google doesn't return a field for it
if 'track' not in g_song:
g_song['track'] = 0
#g_song['artist'].lower() == tag['artist'].lower() and\
return g_song['name'].lower() == tag['name'].lower() and\
g_song['album'].lower() == tag['album'].lower() and\
g_song['track'] == tag['track']
def delete_song(self, sid):
self.api.delete_songs(sid)
print "Deleted song by id [%s]" % sid
def get_platform_path(self, full_path):
# Try to avoid messing with the path if possible
if os.sep == '/' and '\\' not in full_path:
return full_path
if os.sep == '\\' and '\\' in full_path:
return full_path
if '\\' not in full_path:
return full_path
return os.path.normpath(full_path.replace('\\', '/'))
class GoogleMusicApi():
def __init__(self):
self.xbmc = sys.modules["__main__"].xbmc
self.xbmcgui = sys.modules["__main__"].xbmcgui
self.xbmcplugin = sys.modules["__main__"].xbmcplugin
self.settings = sys.modules["__main__"].settings
self.language = sys.modules["__main__"].language
self.dbg = sys.modules["__main__"].dbg
self.common = sys.modules["__main__"].common
self.storage = sys.modules["__main__"].storage
self.gmusicapi = Api()
self.login = GoogleMusicLogin.GoogleMusicLogin(self.gmusicapi)
def getPlaylistSongs(self, playlist_id, forceRenew=False):
if not self.storage.isPlaylistFetched(playlist_id) or forceRenew:
self.updatePlaylistSongs(playlist_id)
songs = self.storage.getPlaylistSongs(playlist_id)
return songs
def getPlaylistsByType(self, playlist_type, forceRenew=False):
if forceRenew:
self.updatePlaylists(playlist_type)
playlists = self.storage.getPlaylistsByType(playlist_type)
if len(playlists) == 0 and not forceRenew:
self.updatePlaylists(playlist_type)
playlists = self.storage.getPlaylistsByType(playlist_type)
return playlists
def getSong(self, song_id):
return self.storage.getSong(song_id)
def updatePlaylistSongs(self, playlist_id):
api_songs = []
self.login.login()
if playlist_id == 'all_songs':
api_songs = self.gmusicapi.get_all_songs()
else:
api_songs = self.gmusicapi.get_playlist_songs(playlist_id)
self.storage.storeApiSongs(api_songs, playlist_id)
def updatePlaylists(self, playlist_type):
self.login.login()
playlists = self.gmusicapi.get_all_playlist_ids(
playlist_type == "auto",
playlist_type == "instant",
playlist_type == "user",
always_id_lists=True)
self.storage.storePlaylists(playlists[playlist_type], playlist_type)
def getSongStreamUrl(self, song_id):
self.login.login()
stream_url = self.gmusicapi.get_stream_url(song_id)
#self.storage.updateSongStreamUrl(song_id, stream_url)
return stream_url
class GMusicRater:
def __init__(self, files):
self.__api = Api()
self.__by_rating = {}
self.__needs_rating_update = []
# fill list of songs
lib = []
cachefile = "gmusic.pickle"
if os.path.isfile(cachefile):
print "Loading cached library..."
infile = open(cachefile, "rb")
lib = cPickle.load(infile)
else:
self.__log_in()
print "Getting music..."
lib = self.__api.get_all_songs()
print "Writing..."
outfile = open(cachefile, "wb+")
cPickle.dump(lib, outfile)
# order list of songs by rating
notfound = []
total_found = 0
for s in lib:
r = files.find_rating(s)
# error finding file:
if r < 0:
notfound.append(s)
continue
# print "Got rating for %s: %s" % (s["title"], s["rating"])
# file rating is different from cloud rating:
if not r == s["rating"]:
s["rating"] = r
self.__needs_rating_update.append(s)
if not self.__by_rating.has_key(r):
self.__by_rating[r] = []
self.__by_rating[r].append(s)
total_found += 1
print "Found %d cloud songs, %d of which need rating updates." % (total_found, len(self.__needs_rating_update))
print "Not found on disk: %d" % len(notfound)
for s in notfound:
print " %s - %s" % (s["artist"], s["title"])
def __log_in(self):
if self.__api.is_authenticated():
return
print "Logging in..."
email = raw_input("Email: ")
password = getpass.getpass()
if not self.__api.login(email, password):
print "couldnt log in"
sys.exit(1)
def reset_playlists(self):
self.__log_in()
playlists = self.__api.get_all_playlist_ids(auto=False, user=True)["user"]
print "Got %d playlists:" % len(playlists)
for k, v in playlists.iteritems():
print " Deleting %s (%s)" % (k, v)
for playlistid in v:
self.__api.delete_playlist(playlistid)
def get_ids(slist):
ret = []
for s in slist:
ret.append(s["id"])
return ret
awesome_songids = get_ids(self.__by_rating.get(5, []))
good_songids = awesome_songids + get_ids(self.__by_rating.get(4, []))
unrated_songids = get_ids(self.__by_rating.get(0, []))
awesome_pid = self.__api.create_playlist("Awesome")
print "Awesome %s -> %d songs" % (awesome_pid, len(awesome_songids))
self.__api.add_songs_to_playlist(awesome_pid, awesome_songids)
good_pid = self.__api.create_playlist("Good")
print "Good %s -> %d songs" % (good_pid, len(good_songids))
self.__api.add_songs_to_playlist(good_pid, good_songids)
unrated_pid = self.__api.create_playlist("Unrated")
print "Unrated %s -> %d songs" % (unrated_pid, len(unrated_songids))
self.__api.add_songs_to_playlist(unrated_pid, unrated_songids)
def update_ratings(self):
total = len(self.__needs_rating_update)
if total == 0:
return
self.__log_in()
print "Updating %d songs..." % total
# divide updates into chunks.
start = 0
chunksz = 100 # could probably be larger, wasn't tested for max possible
while start < total:
end = start + chunksz
if end >= total:
end = total
print "%d - %d" % (start, end)
self.__api.change_song_metadata(self.__needs_rating_update[start:end])
start = end
def logout(self):
if self.__api.is_authenticated():
print "Logging out..."
self.__api.logout()
