def getDeviceId(verbose=False):
cred_path = os.path.join(os.path.expanduser('~'), '.gmusicfs')
if not os.path.isfile(cred_path):
raise NoCredentialException(
'No username/password was specified. No config file could '
'be found either. Try creating %s and specifying your '
'username/password there. Make sure to chmod 600.' % cred_path)
if not oct(os.stat(cred_path)[os.path.stat.ST_MODE]).endswith('00'):
raise NoCredentialException(
'Config file is not protected. Please run: '
'chmod 600 %s' % cred_path)
config = configparser.ConfigParser()
config.read(cred_path)
username = config.get('credentials', 'username')
password = config.get('credentials', 'password')
if not username or not password:
raise NoCredentialException(
'No username/password could be read from config file'
': %s' % cred_path)
api = GoogleMusicWebAPI(debug_logging=verbose)
log.info('Logging in...')
api.login(username, password)
log.info('Login successful.')
for device in api.get_registered_devices():
if not device['name']:
device['name'] = 'NoName'
if device['id'][1] == 'x':
print('%s : %s' % (device['name'], device['id']))
def authenticate(self, USER_DATA_FILENAME):
self.G_username = raw_input("Google Play Account Email: ")
self.G_password = getpass.getpass("Google Play Account Pass: "******"PHONE":
self.GOOGLE_DEVICE_ID = device["id"]
if self.GOOGLE_DEVICE_ID[:2] == '0x':
self.GOOGLE_DEVICE_ID = self.GOOGLE_DEVICE_ID[2:]
break
self.S_username = raw_input("Soundcloud Account Username: "******"Soundcloud Account Password: "******"Soundcloud Client ID: ")
self.SOUNDCLOUD_CLIENT_SECRET_ID = raw_input("Soundcloud Secret Client ID: ")
File = open(USER_DATA_FILENAME, 'w+')
File.write(self.encode(self.enc_key, self.G_username) + '\n')
File.write(self.encode(self.enc_key, self.G_password) + '\n')
File.write(self.encode(self.enc_key, self.S_username) + '\n')
File.write(self.encode(self.enc_key, self.S_password) + '\n')
File.write(self.GOOGLE_DEVICE_ID + '\n')
File.write(self.SOUNDCLOUD_CLIENT_ID + '\n')
File.write(self.SOUNDCLOUD_CLIENT_SECRET_ID + '\n')
File.close()
def getDeviceId(verbose=False):
cred_path = os.path.join(os.path.expanduser('~'), '.gmusicfs')
if not os.path.isfile(cred_path):
raise NoCredentialException(
'No username/password was specified. No config file could '
'be found either. Try creating %s and specifying your '
'username/password there. Make sure to chmod 600.'
% cred_path)
if not oct(os.stat(cred_path)[os.path.stat.ST_MODE]).endswith('00'):
raise NoCredentialException(
'Config file is not protected. Please run: '
'chmod 600 %s' % cred_path)
config = ConfigParser.ConfigParser()
config.read(cred_path)
username = config.get('credentials','username')
password = config.get('credentials','password')
if not username or not password:
raise NoCredentialException(
'No username/password could be read from config file'
': %s' % cred_path)
api = GoogleMusicWebAPI(debug_logging=verbose)
log.info('Logging in...')
api.login(username, password)
log.info('Login successful.')
for device in api.get_registered_devices():
if not device['name']:
device['name']='NoName'
if device['id'][1]=='x':
print '%s : %s' % (device['name'], device['id'])
def initthread(mwc, mc):
library = mwc.library
mwc.status_msg("Initializing..")
wc = Webclient()
wc.login(config.user, config.password)
devices = wc.get_registered_devices()
mwc.status_msg("Retrieving usable device ID..")
for dev in devices:
if dev["type"] == "PHONE":
# strip 0x if present
config.devid = dev["id"][2:] if dev["id"].startswith("0x") else dev["id"]
print("Found a usable device id: " + config.devid)
break
else:
md = Gtk.MessageDialog(parent=mwc.ui, buttons=Gtk.ButtonsType.OK, message_type=Gtk.MessageType.ERROR, message_format="Could not find a usable device id. Please run the Google Play Music app at least once on your phone.")
GLib.idle_add(modal_dialog_func, md)
mc.login(config.user, config.password)
player = Player(mc, config.devid)
mwc.setplayer(player)
def getalbumart(structure):
if "albumArtRef" in structure:
a = structure["albumArtRef"]
for entry in a:
if "url" in entry:
return entry["url"]
return None
mwc.status_msg("Retrieving library..")
songs = mc.get_all_songs()
for song in songs:
track = Track(song["id"], song["title"], song["artist"], song["album"],
song["trackNumber"] if "trackNumber" in song else 0)
track.albumarturl = getalbumart(song)
library.add_track(track)
mwc.status_msg("Retrieving playlists..")
playlists = mc.get_all_user_playlist_contents()
for x in playlists:
tracks = []
for t in x["tracks"]:
if t["trackId"].startswith("T"): # all access track
trackEntry = t["track"]
track = Track(t["trackId"], trackEntry["title"], trackEntry["artist"], trackEntry["album"], trackEntry["trackNumber"])
track.albumarturl = getalbumart(trackEntry)
tracks.append(track)
else:
libtrack = library.find_track(t["trackId"])
if libtrack is not None:
tracks.append(libtrack)
library.add_list(Playlist(x["name"], tracks))
mwc.status_msg("Idle")
def get_deviceid(self, username, password):
logger.warning(u'No mobile device ID configured. '
u'Trying to detect one.')
webapi = Webclient(validate=False)
webapi.login(username, password)
devices = webapi.get_registered_devices()
deviceid = None
for device in devices:
if device['type'] == 'PHONE' and device['id'][0:2] == u'0x':
# Omit the '0x' prefix
deviceid = device['id'][2:]
break
webapi.logout()
if deviceid is None:
logger.error(u'No valid mobile device ID found. '
u'Playing songs will not work.')
else:
logger.info(u'Using mobile device ID %s', deviceid)
return deviceid
def initDevice(self):
device_id = self.settings.getSetting('device_id')
if not device_id:
self.main.log('Trying to fetch the device_id')
webclient = Webclient(debug_logging=False,validate=False)
self.checkCredentials()
username = self.settings.getSetting('username')
password = self.settings.getSetting('password')
webclient.login(username, password)
if webclient.is_authenticated():
devices = webclient.get_registered_devices()
for device in devices:
if device["type"] == "PHONE":
device_id = str(device["id"])
break
if device_id.lower().startswith('0x'): device_id = device_id[2:]
self.settings.setSetting('device_id',device_id)
self.main.log('device_id: '+device_id)
def get_deviceid(self, username, password):
logger.warning(u'No mobile device ID configured. '
u'Trying to detect one.')
webapi = Webclient(validate=False)
webapi.login(username, password)
devices = webapi.get_registered_devices()
deviceid = None
for device in devices:
if device['type'] == 'PHONE' and device['id'][0:2] == u'0x':
# Omit the '0x' prefix
deviceid = device['id'][2:]
break
webapi.logout()
if deviceid is None:
logger.error(u'No valid mobile device ID found. '
u'Playing songs will not work.')
else:
logger.info(u'Using mobile device ID %s', deviceid)
return deviceid
def initDevice(self):
device_id = self.settings.getSetting('device_id')
if not device_id:
self.main.log('Trying to fetch the device_id')
webclient = Webclient(debug_logging=False, validate=False)
self.checkCredentials()
username = self.settings.getSetting('username')
password = self.settings.getSetting('password')
webclient.login(username, password)
if webclient.is_authenticated():
devices = webclient.get_registered_devices()
for device in devices:
if device["type"] == "PHONE":
device_id = str(device["id"])
break
if device_id.lower().startswith('0x'):
device_id = device_id[2:]
self.settings.setSetting('device_id', device_id)
self.main.log('device_id: ' + device_id)
def main():
parser = argparse.ArgumentParser(description = 'List all devices registered for Google Play Music')
parser.add_argument('username', help = 'Your Google Play Music username')
parser.add_argument('password', help = 'Your very secret password')
args = parser.parse_args()
api = Webclient(validate = False)
if not api.login(args.username, args.password):
print "Could not login to Google Play Music. Incorrect username or password."
return
for device in api.get_registered_devices():
print '%s | %s | %s | %s' % (device['name'],
device.get('manufacturer'),
device['model'],
device['id'])
api.logout()
def main():
parser = argparse.ArgumentParser(
description='List all devices registered for Google Play Music')
parser.add_argument('username', help='Your Google Play Music username')
parser.add_argument('password', help='Your very secret password')
args = parser.parse_args()
api = Webclient(validate=False)
if not api.login(args.username, args.password):
print "Could not login to Google Play Music. Incorrect username or password."
return
for device in api.get_registered_devices():
print '%s | %s | %s | %s' % (device['name'],
device.get('manufacturer'),
device['model'], device['id'])
api.logout()
class MusicPlayer(object):
def __init__(self):
self.playlist = [] # Array of all tracks
self.playlist_id = 0 # Id of playlist
self.current_track_index = 0 # Index of current song
self.player = Player() # MPlayer instance
self.webclient = Webclient() # Client for WebInterface
self.mobileclient = Mobileclient() # Client for MobileInterface
self.timer = None # Timer to start next track
self.deviceid = 0 # DeviceId to use
self.playtype = PlayType.LINEAR # LINEAR or SHUFFLE
def login(self, username, password):
""" Login to Google Music.
Keyword arguments:
username -- the username
password -- the password
Returns:
True if successful else False
"""
# If either the web client or the mobile client failed to login return False
if not self.webclient.login(username, password) or not self.mobileclient.login(username, password):
return False
# Use first found devices as ID
devices = self.webclient.get_registered_devices();
# Convert HEX to INT
self.deviceid = int(devices[0]['id'], 16)
return True
def load_playlist(self, playlist_name):
# Load playlist
for playlist in self.mobileclient.get_all_user_playlist_contents():
if playlist['name'] == playlist_name:
for track_obj in playlist['tracks']:
track_obj['track']['id'] = track_obj['id']
self.playlist.append(track_obj['track'])
# Set playlist_id
self.playlist_id = playlist['id']
break;
# If playlist has not been found, create it
if self.playlist_id == 0:
self.playlist_id = self.mobileclient.create_playlist(playlist_name)
def add_track_to_playlist(self, track):
""" Append a track to the end of playlist
Keyword arguments:
track -- a dictionary containing the track informations
"""
track_id = self.mobileclient.add_songs_to_playlist(self.playlist_id, track['nid'])[0]
track['id'] = track_id
self.playlist.append(track)
# Notify all clients about the new track
factory.forwarder.dispatch(PLAYLIST_EVENT_TRACK_ADDED, json.dumps(track))
def remove_track_from_playlist(self, track_id):
""" Removes a track from the playlist
Keyword arguments:
track_id -- The id of the track to remove
"""
self.mobileclient.remove_entries_from_playlist(track_id)
index_to_remove = self._find_index_of_track_id(track_id)
del self.playlist[index_to_remove]
factory.forwarder.dispatch(PLAYLIST_EVENT_TRACK_REMOVED, track_id)
def play_track(self, track_id):
""" Play a track
Keyword arguments:
track_id -- Id of the track to play
"""
index_of_track = self._find_index_of_track_id(track_id)
track_to_play = self.playlist[index_of_track]
if track_to_play is not None:
# Request stream url from google music
stream_url = self.mobileclient.get_stream_url(track_to_play["storeId"], self.deviceid)
# Load stream url to mplayer
self.player.loadfile(stream_url)
# For some reason OSX needs to unpause mplayer
if sys.platform == "darwin":
self.player.pause()
# Set track
self.current_track_index = index_of_track
# Cancel previous timer
if self.timer is not None:
self.timer.cancel()
# How many minutes does the track last
track_duration = long(track_to_play["durationMillis"]) / 1000
# Set Timer to play next track when trackDuration is over
self.timer = Timer(track_duration, self.play_next_track)
self.timer.daemon = True
self.timer.start()
print "playing", track_to_play["artist"], " - ", track_to_play["title"], " : ", stream_url
# Fire event that a new track is playing
factory.forwarder.dispatch(TRACK_EVENT_PLAYBACK, json.dumps(track_to_play))
return True
else:
return False
def play_next_track(self):
""" Play the next track in the playlist.
Returns:
True or False
"""
if self.playtype == PlayType.LINEAR:
# Index of next track to play
next_track_index = self.current_track_index + 1
# Restart at index 0 if end of playlist is reached
if next_track_index >= len(self.playlist):
next_track_index = 0
elif self.playtype == PlayType.SHUFFLE:
# Index of next track to play at random
next_track_index = random.randrange(0, len(self.playlist), 1)
# Obtain the id of the next track to play
next_track_id = self.playlist[next_track_index]['id']
# Play track with that id
return self.play_track(next_track_id)
def play_previous_track(self):
""" Play the previous track in the playlist.
Returns:
True or False
"""
if self.playtype == PlayType.LINEAR:
# Index of previous track to play
previous_track_index = self.current_track_index - 1
# Contiune from the end of the playlist
if previous_track_index <= 0:
previous_track_index = len(self.playlist) - 1
elif self.playtype == PlayType.SHUFFLE:
# Index of the previous track is random
previous_track_index = random.randrange(0, len(self.playlist), 1)
# Obtain the id of the previous track to play
previous_track_id = self.playlist[previous_track_index]['id']
# Play track with that id
return self.play_track(previous_track_id)
def stop(self):
""" Stop playback.
"""
if self.timer is not None:
self.timer.cancel()
if self.player is not None:
self.player.stop()
def play(self):
""" Start playing current track
Returns:
True if track has been started. Else False
"""
current_track_id = self.playlist[self.current_track_index]
return self.play_track(current_track_id)
def _find_index_of_track_id(self, track_id):
index = 0
for track in self.playlist:
if track['id'] == track_id:
return index
index += 1
return None
def get_registered_devices(login, password):
websession = Webclient()
websession.login(login, password)
return websession.get_registered_devices()
web_client = Webclient()
mobile_client = Mobileclient()
p = vlc.MediaPlayer()
print "Logging in..."
logged_in = web_client.login(email, password)
logged_in = mobile_client.login(email, password)
# logged_in is True if login was successful
if logged_in == True:
print "Successfully logged in"
if device_id == '':
devices = web_client.get_registered_devices()
valid = [device['id'][2:] + " (" + device['model'] + ")" for device in devices if device['type'] == 'PHONE']
print valid
id_index = int(raw_input("Device ID: "))
device_id = valid[id_index].split(' ', 1)[0]
while True:
song_name = raw_input("Song title: ")
results = mobile_client.search_all_access(song_name, 1)
song = results['song_hits'][0]
song_id = song['track']['nid']
song_name = song['track']['title']
song_artist = song['track']['artist']
stream_url = mobile_client.get_stream_url(song_id, device_id)
class GMusic(object):
def __init__(self):
self.authenticated = False
self.all_access = False
self.library_loaded = False
self.all_songs = []
self.letters = {}
self.artists = {}
self.albums = {}
self.genres = {}
self.tracks_by_letter = {}
self.tracks_by_artist = {}
self.tracks_by_album = {}
self.tracks_by_genre = {}
self._device = None
self._webclient = Webclient(debug_logging=False)
self._mobileclient = Mobileclient(debug_logging=False)
self._playlists = []
self._playlist_contents = []
self._stations = []
def _get_device_id(self):
if self.authenticated:
devices = self._webclient.get_registered_devices()
for dev in devices:
if dev['type'] == 'PHONE':
self._device = dev['id'][2:]
break
elif dev['type'] == 'IOS':
self._device = dev['id']
break
def _set_all_access(self):
settings = self._webclient._make_call(webclient.GetSettings, '')
self.all_access = True if 'isSubscription' in settings[
'settings'] and settings['settings'][
'isSubscription'] == True else False
def _set_all_songs(self):
if len(self.all_songs) == 0:
try:
self.all_songs = self._mobileclient.get_all_songs()
except NotLoggedIn:
if self.authenticate():
self.all_songs = self._mobileclient.get_all_songs()
else:
return []
else:
return self.all_songs
def authenticate(self, email, password):
try:
mcauthenticated = self._mobileclient.login(email, password)
except AlreadyLoggedIn:
mcauthenticated = True
try:
wcauthenticated = self._webclient.login(email, password)
except AlreadyLoggedIn:
wcauthenticated = True
self.authenticated = mcauthenticated and wcauthenticated
self._set_all_access()
self._get_device_id()
return self.authenticated
def load_data(self):
self._set_all_songs()
for song in self.all_songs:
thumb = None
letter = song['title'][0]
artist = song['artist']
album = song['album']
genre = song['genre'] if 'genre' in song else '(None)'
if letter not in self.tracks_by_letter:
self.tracks_by_letter[letter] = []
self.letters[letter] = None
if artist not in self.tracks_by_artist:
self.tracks_by_artist[artist] = []
self.artists[artist] = None
if album not in self.tracks_by_album:
self.tracks_by_album[album] = []
self.albums[album] = None
if genre not in self.tracks_by_genre:
self.tracks_by_genre[genre] = []
self.genres[genre] = None
track = {'artist': artist, 'album': album}
if 'title' in song:
track['title'] = song['title']
if 'album' in song:
track['album'] = song['album']
if 'artist' in song:
track['artist'] = song['artist']
if 'durationMillis' in song:
track['durationMillis'] = song['durationMillis']
if 'id' in song:
track['id'] = song['id']
if 'trackNumber' in song:
track['trackType'] = song['trackNumber']
if 'storeId' in song:
track['storeId'] = song['storeId']
if 'albumArtRef' in song:
track['albumArtRef'] = song['albumArtRef']
thumb = song['albumArtRef'][0]['url']
self.letters[letter] = thumb
self.artists[artist] = thumb
self.albums[album] = thumb
self.genres[genre] = thumb
self.tracks_by_letter[letter].append({
'track': track,
'thumb': thumb,
'id': song['id']
})
self.tracks_by_artist[artist].append({
'track': track,
'thumb': thumb,
'id': song['id']
})
self.tracks_by_album[album].append({
'track': track,
'thumb': thumb,
'id': song['id']
})
self.tracks_by_genre[genre].append({
'track': track,
'thumb': thumb,
'id': song['id']
})
self.library_loaded = True
def get_tracks_for_type(self, type, name):
type = type.lower()
if type == 'artists':
return self.tracks_by_artist[name]
elif type == 'albums':
return self.tracks_by_album[name]
elif type == 'genres':
return self.tracks_by_genre[name]
elif type == 'songs by letter':
return self.tracks_by_letter[name]
else:
return {}
def get_song(self, id):
return [x for x in self.all_songs if x['id'] == id][0]
def get_all_playlists(self):
if len(self._playlists) == 0:
try:
self._playlists = self._mobileclient.get_all_playlists()
except NotLoggedIn:
if self.authenticate():
self._playlists = self._mobileclient.get_all_playlists()
else:
return []
return self._playlists
def get_all_user_playlist_contents(self, id):
tracks = []
if len(self._playlist_contents) == 0:
try:
self._playlist_contents = self._mobileclient.get_all_user_playlist_contents(
)
except NotLoggedIn:
if self.authenticate():
self._playlist_contents = self._mobileclient.get_all_user_playlist_contents(
)
else:
return []
for playlist in self._playlist_contents:
if id == playlist['id']:
tracks = playlist['tracks']
break
return tracks
def get_shared_playlist_contents(self, token):
playlist = []
try:
playlist = self._mobileclient.get_shared_playlist_contents(token)
except NotLoggedIn:
if self.authenticate():
playlist = self._mobileclient.get_shared_playlist_contents(
token)
else:
return []
return playlist
def get_all_stations(self):
if len(self._stations) == 0:
try:
self._stations = self._mobileclient.get_all_stations()
except NotLoggedIn:
if self.authenticate():
self._stations = self._mobileclient.get_all_stations()
else:
return []
return self._stations
def get_station_tracks(self, id, num_tracks=200):
tracks = []
try:
tracks = self._mobileclient.get_station_tracks(id, num_tracks)
except NotLoggedIn:
if self.authenticate():
tracks = self._mobileclient.get_station_tracks(id, num_tracks)
else:
return []
return tracks
def get_genres(self):
genres = []
try:
genres = self._mobileclient.get_genres()
except NotLoggedIn:
if self.authenticate():
genres = self._mobileclient.get_genres()
else:
return []
return genres
def create_station(self, name, id):
station = None
try:
station = self._mobileclient.create_station(name=name, genre_id=id)
except NotLoggedIn:
if self.authenticate():
station = self._mobileclient.create_station(name=name,
genre_id=id)
else:
return []
return station
def search_all_access(self, query, max_results=50):
results = None
try:
results = self._mobileclient.search_all_access(query, max_results)
except NotLoggedIn:
if self.authenticate():
results = self._mobileclient.search_all_access(
query, max_results)
else:
return []
return results
def get_artist_info(self,
id,
include_albums=True,
max_top_tracks=5,
max_rel_artist=5):
results = None
try:
results = self._mobileclient.get_artist_info(
id,
include_albums=include_albums,
max_top_tracks=max_top_tracks,
max_rel_artist=max_rel_artist)
except NotLoggedIn:
if self.authenticate():
results = self._mobileclient.get_artist_info(
id,
include_albums=include_albums,
max_top_tracks=max_top_tracks,
max_rel_artist=max_rel_artist)
else:
return []
return results
def get_album_info(self, id, include_tracks=True):
results = None
try:
results = self._mobileclient.get_album_info(
id, include_tracks=include_tracks)
except NotLoggedIn:
if self.authenticate():
results = self._mobileclient.get_album_info(
id, include_tracks=include_tracks)
else:
return []
return results
def add_aa_track(self, id):
track = None
try:
track = self._mobileclient.add_aa_track(id)
except NotLoggedIn:
if self.authenticate():
track = self._mobileclient.add_aa_track(id)
else:
return None
return track
def add_songs_to_playlist(self, playlist_id, song_ids):
tracks = None
try:
tracks = self._mobileclient.add_songs_to_playlist(
playlist_id, song_ids)
except NotLoggedIn:
if self.authenticate():
tracks = self._mobileclient.add_songs_to_playlist(
playlist_id, song_ids)
else:
return None
return tracks
def get_stream_url(self, id):
try:
stream_url = self._mobileclient.get_stream_url(id, self._device)
except NotLoggedIn:
if self.authenticate():
stream_url = self._mobileclient.get_stream_url(
id, self._device)
else:
return ''
except CallFailure:
raise CallFailure('Could not play song with id: ' + id,
'get_stream_url')
return stream_url
class GMusic(object):
def __init__(self):
self.authenticated = False
self.all_access = False
self._device = None
self._webclient = Webclient(debug_logging=False)
self._mobileclient = Mobileclient(debug_logging=False)
self._playlists = []
self._playlist_contents = []
self._all_songs = []
self._all_artists = {}
self._all_albums = {}
self._all_genres = {}
self._stations = []
def _get_device_id(self):
if self.authenticated:
devices = self._webclient.get_registered_devices()
for dev in devices:
if dev['type'] == 'PHONE':
self._device = dev['id'][2:]
break
def _set_all_access(self):
settings = self._webclient._make_call(webclient.GetSettings, '')
self.all_access = True if 'isSubscription' in settings['settings'] and settings['settings']['isSubscription'] == True else False
def authenticate(self, email, password):
try:
mcauthenticated = self._mobileclient.login(email, password)
except AlreadyLoggedIn:
mcauthenticated = True
try:
wcauthenticated = self._webclient.login(email, password)
except AlreadyLoggedIn:
wcauthenticated = True
self.authenticated = mcauthenticated and wcauthenticated
self._get_device_id()
self._set_all_access()
return self.authenticated
def get_all_songs(self, id=None):
if len(self._all_songs) == 0:
try:
self._all_songs = self._mobileclient.get_all_songs()
except NotLoggedIn:
if self.authenticate():
self._all_songs = self._mobileclient.get_all_songs()
else:
return []
if id:
return [x for x in self._all_songs if x['id'] == id][0]
else:
return self._all_songs
def get_all_artists(self):
if not self._all_artists:
songs = self.get_all_songs()
for song in songs:
artist = song['artist']
thumb = None
if artist not in self._all_artists:
self._all_artists[artist] = []
track = {'title': song['title'],
'album': song['album'],
'artist': artist,
'durationMillis': song['durationMillis'],
'trackType': song['trackNumber'],
'id': song['id']}
if 'albumArtRef' in song:
track['albumArtRef'] = song['albumArtRef']
if 'artistArtRef' in song:
thumb = song['artistArtRef'][0]['url']
if 'storeId' in song:
track['storeId'] = song['storeId']
self._all_artists[artist].append({'track': track, 'thumb': thumb, 'id': song['id']})
return self._all_artists
def get_all_albums(self):
if not self._all_albums:
songs = self.get_all_songs()
for song in songs:
album = song['album']
thumb = None
if album not in self._all_albums:
self._all_albums[album] = []
track = {'title': song['title'],
'album': album,
'artist': song['artist'],
'durationMillis': song['durationMillis'],
'trackType': song['trackNumber'],
'id': song['id']}
if 'albumArtRef' in song:
track['albumArtRef'] = song['albumArtRef']
thumb = song['albumArtRef'][0]['url']
if 'storeId' in song:
track['storeId'] = song['storeId']
self._all_albums[album].append({'track': track, 'thumb': thumb, 'id': song['id']})
return self._all_albums
def get_all_genres(self):
if not self._all_genres:
songs = self.get_all_songs()
for song in songs:
genre = song['genre']
if genre not in self._all_genres:
self._all_genres[genre] = []
track = {'title': song['title'],
'album': song['album'],
'artist': song['artist'],
'durationMillis': song['durationMillis'],
'trackType': song['trackNumber'],
'id': song['id']}
if 'albumArtRef' in song:
track['albumArtRef'] = song['albumArtRef']
if 'storeId' in song:
track['storeId'] = song['storeId']
self._all_genres[genre].append({'track': track, 'id': song['id']})
return self._all_genres
def get_all_playlists(self):
if len(self._playlists) == 0:
try:
self._playlists = self._mobileclient.get_all_playlists()
except NotLoggedIn:
if self.authenticate():
self._playlists = self._mobileclient.get_all_playlists()
else:
return []
return self._playlists
def get_all_user_playlist_contents(self, id):
tracks = []
if len(self._playlist_contents) == 0:
try:
self._playlist_contents = self._mobileclient.get_all_user_playlist_contents()
except NotLoggedIn:
if self.authenticate():
self._playlist_contents = self._mobileclient.get_all_user_playlist_contents()
else:
return []
for playlist in self._playlist_contents:
if id == playlist['id']:
tracks = playlist['tracks']
break
return tracks
def get_shared_playlist_contents(self, token):
playlist = []
try:
playlist = self._mobileclient.get_shared_playlist_contents(token)
except NotLoggedIn:
if self.authenticate():
playlist = self._mobileclient.get_shared_playlist_contents(token)
else:
return []
return playlist
def get_all_stations(self):
if len(self._stations) == 0:
try:
self._stations = self._mobileclient.get_all_stations()
except NotLoggedIn:
if self.authenticate():
self._stations = self._mobileclient.get_all_stations()
else:
return []
return self._stations
def get_station_tracks(self, id, num_tracks=200):
tracks = []
try:
tracks = self._mobileclient.get_station_tracks(id, num_tracks)
except NotLoggedIn:
if self.authenticate():
tracks = self._mobileclient.get_station_tracks(id, num_tracks)
else:
return []
return tracks
def get_genres(self):
genres = []
try:
genres = self._mobileclient.get_genres()
except NotLoggedIn:
if self.authenticate():
genres = self._mobileclient.get_genres()
else:
return []
return genres
def create_station(self, name, id):
station = None
try:
station = self._mobileclient.create_station(name=name, genre_id=id)
except NotLoggedIn:
if self.authenticate():
station = self._mobileclient.create_station(name=name, genre_id=id)
else:
return []
return station
def search_all_access(self, query, max_results=50):
results = None
try:
results = self._mobileclient.search_all_access(query, max_results)
except NotLoggedIn:
if self.authenticate():
results = self._mobileclient.search_all_access(query, max_results)
else:
return []
return results
def get_artist_info(self, id, include_albums=True, max_top_tracks=5, max_rel_artist=5):
results = None
try:
results = self._mobileclient.get_artist_info(id, include_albums=include_albums, max_top_tracks=max_top_tracks, max_rel_artist=max_rel_artist)
except NotLoggedIn:
if self.authenticate():
results = self._mobileclient.get_artist_info(id, include_albums=include_albums, max_top_tracks=max_top_tracks, max_rel_artist=max_rel_artist)
else:
return []
return results
def get_album_info(self, id, include_tracks=True):
results = None
try:
results = self._mobileclient.get_album_info(id, include_tracks=include_tracks)
except NotLoggedIn:
if self.authenticate():
results = self._mobileclient.get_album_info(id, include_tracks=include_tracks)
else:
return []
return results
def get_stream_url(self, id):
try:
stream_url = self._mobileclient.get_stream_url(id, self._device)
except NotLoggedIn:
if self.authenticate():
stream_url = self._mobileclient.get_stream_url(id, self._device)
else:
return ''
except CallFailure:
raise CallFailure('Could not play song with id: ' + id, 'get_stream_url')
return stream_url
class GMusic(object):
def __init__(self):
self.authenticated = False
self.all_access = False
self.library_loaded = False
self.all_songs = []
self.letters = {}
self.artists = {}
self.albums = {}
self.genres = {}
self.tracks_by_letter = {}
self.tracks_by_artist = {}
self.tracks_by_album = {}
self.tracks_by_genre = {}
self._device = None
self._webclient = Webclient(debug_logging=False)
self._mobileclient = Mobileclient(debug_logging=False)
self._playlists = []
self._playlist_contents = []
self._stations = []
def _get_device_id(self):
if self.authenticated:
devices = self._webclient.get_registered_devices()
for dev in devices:
if dev['type'] == 'PHONE':
self._device = dev['id'][2:]
break
elif dev['type'] == 'IOS':
self._device = dev['id']
break
def _set_all_access(self):
settings = self._webclient._make_call(webclient.GetSettings, '')
self.all_access = True if 'isSubscription' in settings['settings'] and settings['settings']['isSubscription'] == True else False
def _set_all_songs(self):
if len(self.all_songs) == 0:
try:
self.all_songs = self._mobileclient.get_all_songs()
except NotLoggedIn:
if self.authenticate():
self.all_songs = self._mobileclient.get_all_songs()
else:
return []
else:
return self.all_songs
def authenticate(self, email, password):
try:
mcauthenticated = self._mobileclient.login(email, password)
except AlreadyLoggedIn:
mcauthenticated = True
try:
wcauthenticated = self._webclient.login(email, password)
except AlreadyLoggedIn:
wcauthenticated = True
self.authenticated = mcauthenticated and wcauthenticated
self._set_all_access()
self._get_device_id()
return self.authenticated
def load_data(self):
self._set_all_songs()
for song in self.all_songs:
thumb = None
letter = song['title'][0]
artist = song['artist']
album = song['album']
genre = song['genre'] if 'genre' in song else '(None)'
if letter not in self.tracks_by_letter:
self.tracks_by_letter[letter] = []
self.letters[letter] = None
if artist not in self.tracks_by_artist:
self.tracks_by_artist[artist] = []
self.artists[artist] = None
if album not in self.tracks_by_album:
self.tracks_by_album[album] = []
self.albums[album] = None
if genre not in self.tracks_by_genre:
self.tracks_by_genre[genre] = []
self.genres[genre] = None
track = {'artist': artist, 'album': album}
if 'title' in song:
track['title'] = song['title']
if 'album' in song:
track['album'] = song['album']
if 'artist' in song:
track['artist'] = song['artist']
if 'durationMillis' in song:
track['durationMillis'] = song['durationMillis']
if 'id' in song:
track['id'] = song['id']
if 'trackNumber' in song:
track['trackType'] = song['trackNumber']
if 'storeId' in song:
track['storeId'] = song['storeId']
if 'albumArtRef' in song:
track['albumArtRef'] = song['albumArtRef']
thumb = song['albumArtRef'][0]['url']
self.letters[letter] = thumb
self.artists[artist] = thumb
self.albums[album] = thumb
self.genres[genre] = thumb
self.tracks_by_letter[letter].append({'track': track, 'thumb': thumb, 'id': song['id']})
self.tracks_by_artist[artist].append({'track': track, 'thumb': thumb, 'id': song['id']})
self.tracks_by_album[album].append({'track': track, 'thumb': thumb, 'id': song['id']})
self.tracks_by_genre[genre].append({'track': track, 'thumb': thumb, 'id': song['id']})
self.library_loaded = True
def get_tracks_for_type(self, type, name):
type = type.lower()
if type == 'artists':
return self.tracks_by_artist[name]
elif type == 'albums':
return self.tracks_by_album[name]
elif type == 'genres':
return self.tracks_by_genre[name]
elif type == 'songs by letter':
return self.tracks_by_letter[name]
else:
return {}
def get_song(self, id):
return [x for x in self.all_songs if x['id'] == id][0]
def get_all_playlists(self):
if len(self._playlists) == 0:
try:
self._playlists = self._mobileclient.get_all_playlists()
except NotLoggedIn:
if self.authenticate():
self._playlists = self._mobileclient.get_all_playlists()
else:
return []
return self._playlists
def get_all_user_playlist_contents(self, id):
tracks = []
if len(self._playlist_contents) == 0:
try:
self._playlist_contents = self._mobileclient.get_all_user_playlist_contents()
except NotLoggedIn:
if self.authenticate():
self._playlist_contents = self._mobileclient.get_all_user_playlist_contents()
else:
return []
for playlist in self._playlist_contents:
if id == playlist['id']:
tracks = playlist['tracks']
break
return tracks
def get_shared_playlist_contents(self, token):
playlist = []
try:
playlist = self._mobileclient.get_shared_playlist_contents(token)
except NotLoggedIn:
if self.authenticate():
playlist = self._mobileclient.get_shared_playlist_contents(token)
else:
return []
return playlist
def get_all_stations(self):
if len(self._stations) == 0:
try:
self._stations = self._mobileclient.get_all_stations()
except NotLoggedIn:
if self.authenticate():
self._stations = self._mobileclient.get_all_stations()
else:
return []
return self._stations
def get_station_tracks(self, id, num_tracks=200):
tracks = []
try:
tracks = self._mobileclient.get_station_tracks(id, num_tracks)
except NotLoggedIn:
if self.authenticate():
tracks = self._mobileclient.get_station_tracks(id, num_tracks)
else:
return []
return tracks
def get_genres(self):
genres = []
try:
genres = self._mobileclient.get_genres()
except NotLoggedIn:
if self.authenticate():
genres = self._mobileclient.get_genres()
else:
return []
return genres
def create_station(self, name, id):
station = None
try:
station = self._mobileclient.create_station(name=name, genre_id=id)
except NotLoggedIn:
if self.authenticate():
station = self._mobileclient.create_station(name=name, genre_id=id)
else:
return []
return station
def search_all_access(self, query, max_results=50):
results = None
try:
results = self._mobileclient.search_all_access(query, max_results)
except NotLoggedIn:
if self.authenticate():
results = self._mobileclient.search_all_access(query, max_results)
else:
return []
return results
def get_artist_info(self, id, include_albums=True, max_top_tracks=5, max_rel_artist=5):
results = None
try:
results = self._mobileclient.get_artist_info(id, include_albums=include_albums, max_top_tracks=max_top_tracks, max_rel_artist=max_rel_artist)
except NotLoggedIn:
if self.authenticate():
results = self._mobileclient.get_artist_info(id, include_albums=include_albums, max_top_tracks=max_top_tracks, max_rel_artist=max_rel_artist)
else:
return []
return results
def get_album_info(self, id, include_tracks=True):
results = None
try:
results = self._mobileclient.get_album_info(id, include_tracks=include_tracks)
except NotLoggedIn:
if self.authenticate():
results = self._mobileclient.get_album_info(id, include_tracks=include_tracks)
else:
return []
return results
def add_aa_track(self, id):
track = None
try:
track = self._mobileclient.add_aa_track(id)
except NotLoggedIn:
if self.authenticate():
track = self._mobileclient.add_aa_track(id)
else:
return None
return track
def add_songs_to_playlist(self, playlist_id, song_ids):
tracks = None
try:
tracks = self._mobileclient.add_songs_to_playlist(playlist_id, song_ids)
except NotLoggedIn:
if self.authenticate():
tracks = self._mobileclient.add_songs_to_playlist(playlist_id, song_ids)
else:
return None
return tracks
def get_stream_url(self, id):
try:
stream_url = self._mobileclient.get_stream_url(id, self._device)
except NotLoggedIn:
if self.authenticate():
stream_url = self._mobileclient.get_stream_url(id, self._device)
else:
return ''
except CallFailure:
raise CallFailure('Could not play song with id: ' + id, 'get_stream_url')
return stream_url
def reset_library(self):
self.library_loaded = False
self.all_songs[:] = []
self._playlists[:] = []
self._playlist_contents[:] = []
self._stations[:] = []
self.letters.clear()
self.artists.clear()
self.albums.clear()
self.genres.clear()
self.tracks_by_letter.clear()
self.tracks_by_artist.clear()
self.tracks_by_album.clear()
self.tracks_by_genre.clear()
import sys
from gmusicapi import Webclient
if __name__ == "__main__":
if sys.argv[1] == "1":
wc = Webclient()
success = wc.login(sys.argv[2], sys.argv[3])
if success == True:
devices = wc.get_registered_devices()
valid = [
device['id'][2:] + " (" + device['model'] + ")"
for device in devices if device['type'] == 'PHONE'
]
deviceid = valid[0].split(' ', 1)[0]
print(deviceid)
if sys.argv[1] == "2":
print("Spotify is not yet supported.")