class Music:
def __init__(self):
self.index = 0
self.tracks = []
self.api = Mobileclient()
print("logged")
self.api.login('*****@*****.**', 'romgroGMAIL95',
Mobileclient.FROM_MAC_ADDRESS)
def load_random(self):
stations = self.api.get_all_stations()
station = random.choice(stations)
self.tracks = self.api.get_station_tracks(station["id"])
def play_random(self):
url = self.api.get_stream_url(self.tracks[self.index]['nid'],
device_id=None,
quality=u'hi')
self.player = vlc.MediaPlayer(url)
self.player.play()
def update(self):
# todo update
pass
def next_song(self):
self.index += 1
self.play_random()
pass
class Jukebox:
def __init__(self, credentials_file):
with open(credentials_file) as f:
credentials = yaml.load(f)
email = credentials['email']
password = credentials['password']
android_id = credentials['android_id']
self.api = Mobileclient()
self.__authenticated = self.api.login(email, password, android_id)
self.player = vlc.MediaPlayer()
def search(self, query):
self.__is_authenticated()
return self.api.search(query)
def get_track_url(self, track_id):
self.__is_authenticated()
return self.api.get_stream_url(track_id)
def set_track(self, filepath):
self.player.set_media(
vlc.get_default_instance().media_new('songs/' + filepath + '.mp3'))
def play(self):
self.__is_authenticated()
self.player.play()
def pause(self):
self.__is_authenticated()
self.player.pause()
def stop(self):
self.__is_authenticated()
self.player.stop()
def get_length(self):
self.__is_authenticated()
return self.player.get_length()
def get_current_time(self):
self.__is_authenticated()
return self.player.get_time()
def is_playing(self):
self.__is_authenticated()
return self.player.is_playing()
def __is_authenticated(self):
if not self.__authenticated:
raise NotAuthenticatedError
def create_station(self, store_id):
self.__is_authenticated()
station_id = self.api.create_station('station', track_id=store_id)
station_tracks = self.api.get_station_tracks(station_id)
return station_tracks
class AudioStream:
__username = configuration.get('google_username')
__password = configuration.get('google_password')
__track_prefetch = 15
__client = None
__playlist = []
def __init__(self, station_id = 'IFL'):
self.__client = Mobileclient()
self.__client.login(self.__username, self.__password, Mobileclient.FROM_MAC_ADDRESS)
self.__playlist = self.__fetchTrackIDs(station_id)
def __del__(self):
if self.__client:
self.__client.logout()
def __fetchTrackIDs(self, station_id):
if not self.__client or not self.__client.is_authenticated():
logger.error("Client is not authenticated!")
return []
tracklist = self.__client.get_station_tracks(station_id, num_tracks=self.__track_prefetch)
logger.info("Received tracks: %r" % json.dumps(tracklist))
# Filter out explicit tracks, where non-explicit is explicitType=2
tracklist = [track for track in tracklist if not 'explicitType' in track or track['explicitType'] == "2"]
logger.info("Non-explicit tracks: %r" % json.dumps(tracklist))
# Fetch both song IDs and Nautilus (old) IDs
songids = [track['id'] for track in tracklist if 'id' in track]
nautids = [track['nid'] for track in tracklist if 'nid' in track]
return songids + nautids
def pop(self):
while self.__playlist:
track_id = self.__playlist.pop()
try:
stream_url = self.__client.get_stream_url(track_id, quality='low')
return stream_url
except(exceptions.CallFailure):
logger.warning("Failed to fetch Stream URL for ID %s" % track_id)
raise IndexError("pop from empty list")
def reverse(self):
# Reverse just returns itself, since the playlist is already chaos
return self
def __len__(self):
return len(self.__playlist)
class GClient:
def __init__(self):
self._gclient = Mobileclient()
self._credentials = self._get_credentials()
def _get_credentials(self):
config = configparser.ConfigParser()
config.read(os.path.expanduser(CREDENTIALS_FILE))
credentials = {}
credentials['username'] = config.get('credentials', 'username')
credentials['password'] = config.get('credentials', 'password')
return credentials
def login(self):
logged_in = self._gclient.login(self._credentials['username'],
self._credentials['password'],
Mobileclient.FROM_MAC_ADDRESS)
if not logged_in:
print("Failed to log in.")
exit(1)
def get_device_id(self):
# Get all devices, pick the first, get its ID, strip the leading '0x'
self.device_id = self._gclient.get_registered_devices()[0]['id'][2:]
return self.device_id
def get_station(self):
stations = [
station for station in self._gclient.get_all_stations()
if station['inLibrary']
]
return stations[0]
def get_tracks(self):
station = self.get_station()
tracks = self._gclient.get_station_tracks(station['id'])
return tracks
def get_stream_url(self, track_id):
device_id = self.get_device_id()
return self._gclient.get_stream_url(track_id, device_id)
class GMAAC(hass.Hass):
def initialize(self):
self.gmc = Mobileclient()
self.boolean_connect = self.args["boolean_connect"]
self.boolean_sync = self.args["boolean_sync"]
self.boolean_power = self.args["boolean_power"]
self.select_player = self.args["select_player"]
self.select_playlist = self.args["select_playlist"]
self.select_station = self.args["select_station"]
self.boolean_load_pl = self.args["boolean_load_pl"]
self.select_source = self.args["select_source"]
self.boolean_next = self.args["boolean_next"]
self.boolean_prev = self.args["boolean_prev"]
self.turn_off(self.boolean_connect)
self._player_id = ''
self._playlist_id = ''
self._playlists = []
self._playlist_to_index = {}
self._station_id = ''
self._stations = []
self._station_to_index = {}
self._tracks = []
self._next_track_no = 0
self._track = []
self._source = self.get_state(self.select_source)
self.listen_state(self.connect, self.boolean_connect)
self.listen_state(self.power, self.boolean_power, new="on")
self.listen_state(self.sync, self.boolean_sync, new="on")
self.listen_state(self.set_source, self.select_source)
self.listen_state(self.get_tracks, self.boolean_load_pl, new="on")
self.listen_state(self.next_track, self.boolean_next, new="on")
self.listen_state(self.prev_track, self.boolean_prev, new="on")
self.turn_on(self.boolean_connect)
def reset_booleans(self):
'''
Do not include "boolean_connect" here!
- NOT HERE: self.turn_off(self.boolean_connect)
That should be turned off directly when needed
'''
self.turn_off(self.boolean_load_pl)
self.turn_off(self.boolean_sync)
self.turn_off(self.boolean_power)
self.turn_off(self.boolean_next)
self.turn_off(self.boolean_prev)
def login(self):
_login = self.args["login_type"]
if _login == 'oauth':
self.oauth_login()
elif _login == 'legacy':
self.legacy_login()
else:
self.turn_off(self.boolean_connect)
raise SystemExit("Invalid login_type: {}".format(_login))
def legacy_login(self):
''' This legacy login may stop working at any time '''
authtoken_path = self.args["authtoken_path"] + "gmusic_authtoken"
email = self.args["user"]
password = self.args["password"]
device_id = self.args["device_id"]
if os.path.isfile(authtoken_path):
with open(authtoken_path, 'rb') as handle:
authtoken = pickle.load(handle)
else:
authtoken = None
self._api_login = self.gmc.login(email, password, device_id, authtoken)
if not self._api_login:
self.turn_off(self.boolean_connect)
raise SystemExit("legacy login failed")
with open(authtoken_path, 'wb') as f:
pickle.dump(self.gmc.session._authtoken, f)
def oauth_login(self):
if self.args["oauth_credentials"]:
try:
self._api_login = self.gmc.oauth_login(
device_id=self.args["device_id"],
oauth_credentials=self.args["oauth_credentials"],
locale=self.args["locale"])
except:
self.turn_off(self.boolean_connect)
raise SystemExit("oauth login failed")
def connect(self, entity, attribute, old, new, kwargs):
_connect = self.get_state(self.boolean_connect)
self.reset_booleans()
if _connect == "on":
self.login()
if self._api_login == True:
self.sync(entity=None,
attribute=None,
old=None,
new=None,
kwargs=None)
else: ## This will not trigger when app level constaint is set on the input_boolean
self.gmusic_api_logout(entity=None,
attribute=None,
old=None,
new=None,
kwargs=None)
def power(self, entity, attribute, old, new, kwargs):
self._power = self.get_state(self.boolean_power)
if self._power == "on":
self.select_media_player()
self.log("Powered ON -- Connected: {}".format(self._player_id))
elif self._power == "off":
self.unselect_media_player()
self.log("Powered OFF -- Disconnected: {}".format(self._player_id))
def select_media_player(self):
self._player_id = "media_player." + self.get_state(self.select_player)
## Set callbacks for media player
self.power_off = self.listen_state(self.power,
self.boolean_power,
new="off",
duration="1")
self.advance_track = self.listen_state(self.get_track,
self._player_id,
new="idle",
duration="2")
self.show_meta = self.listen_state(self.show_info,
self._player_id,
new="playing")
self.clear_meta = self.listen_state(self.clear_info,
self._player_id,
new="off",
duration="1")
def unselect_media_player(self):
self.media_player_off(entity=None,
attribute=None,
old=None,
new=None,
kwargs=None)
try: ## Cancel callbacks for media player
self.cancel_listen_state(self.power_off)
self.cancel_listen_state(self.advance_track)
self.cancel_listen_state(self.show_meta)
self.cancel_listen_state(self.clear_meta)
except:
self.log("cancel callback exception!")
pass
def update_playlists(self, entity, attribute, old, new, kwargs):
self._playlist_to_index = {}
self._playlists = self.gmc.get_all_user_playlist_contents()
idx = -1
for playlist in self._playlists:
idx = idx + 1
name = playlist.get('name', ' ')
if len(name) < 1:
continue
self._playlist_to_index[name] = idx
# self.log("Playlist: {} - {}".format(idx, name))
data = list(self._playlist_to_index.keys())
self.call_service("input_select/set_options",
entity_id=self.select_playlist,
options=data)
self.turn_off(self.boolean_sync)
self.log("--------------------------------------------")
self.log(data)
for _pl in self._playlist_to_index:
_num = self._playlist_to_index.get(_pl) + 1
self.log("{}: {}".format(_num, _pl))
self.log("--------------------------------------------")
def update_stations(self, entity, attribute, old, new, kwargs):
self._station_to_index = {}
self._stations = self.gmc.get_all_stations()
idx = -1
for station in self._stations:
idx = idx + 1
name = station.get('name', ' ')
library = station.get('inLibrary')
if len(name) < 1:
continue
if library == True:
self._station_to_index[name] = idx
# self.log("station: {} - {}: Library = {}".format(idx, name, library))
data = list(self._station_to_index.keys())
data.insert(0, "I'm Feeling Lucky")
self.call_service("input_select/set_options",
entity_id=self.select_station,
options=data)
self.turn_off(self.boolean_sync)
self.log("--------------------------------------------")
self.log(data)
for _pl in self._station_to_index:
_num = self._station_to_index.get(_pl) + 1
self.log("{}: {}".format(_num, _pl))
self.log("--------------------------------------------")
def sync(self, entity, attribute, old, new, kwargs):
self.update_playlists(entity=None,
attribute=None,
old=None,
new=None,
kwargs=None)
self.update_stations(entity=None,
attribute=None,
old=None,
new=None,
kwargs=None)
def set_source(self, entity, attribute, old, new, kwargs):
self._source = self.get_state(self.select_source)
def get_tracks(self, entity, attribute, old, new, kwargs):
if self._source == 'Station':
self.load_station(entity=None,
attribute=None,
old=None,
new=None,
kwargs=None)
elif self._source == 'Playlist':
self.load_playlist(entity=None,
attribute=None,
old=None,
new=None,
kwargs=None)
else:
self.log("invalid source: {}".format(self._source))
self.reset_booleans()
def load_playlist(self, entity, attribute, old, new, kwargs):
self.turn_on(self.boolean_power)
self._playlist_id = self.get_state(self.select_playlist)
idx = self._playlist_to_index.get(self._playlist_id)
self._tracks = self._playlists[idx]['tracks']
random.shuffle(self._tracks)
self.log("--------------------------------------------")
self.log("Loading [{}] Tracks From: {}".format(len(self._tracks),
self._playlist_id))
# self.log(self._tracks)
self.log("--------------------------------------------")
self._next_track_no = -1
self.get_track(entity=None,
attribute=None,
old=None,
new=None,
kwargs=None)
self.turn_off(self.boolean_load_pl)
def load_station(self, entity, attribute, old, new, kwargs):
self.turn_on(self.boolean_power)
self._station_id = self.get_state(self.select_station)
if self._station_id == "I'm Feeling Lucky":
self._tracks = self.gmc.get_station_tracks('IFL', num_tracks=100)
else:
idx = self._station_to_index.get(self._station_id)
id = self._stations[idx]['id']
self._tracks = self.gmc.get_station_tracks(id, num_tracks=100)
self.log("--------------------------------------------")
self.log("Loading [{}] Tracks From: {}".format(len(self._tracks),
self._station_id))
# self.log(self._tracks)
self.log("--------------------------------------------")
self._next_track_no = -1
self.get_track(entity=None,
attribute=None,
old=None,
new=None,
kwargs=None)
self.turn_off(self.boolean_load_pl)
def get_track(self, entity, attribute, old, new, kwargs):
self._track = ''
self._next_track_no = self._next_track_no + 1
if self._next_track_no >= len(self._tracks):
self._next_track_no = 0 ## Restart curent playlist (Loop)
random.shuffle(self._tracks) ## (re)Shuffle on Loop
_track = self._tracks[self._next_track_no]
if _track is None:
self.reset_booleans()
if 'track' in _track:
_track = _track['track']
self._track = _track
if 'trackId' in _track:
_uid = _track['trackId']
elif 'storeId' in _track:
_uid = _track['storeId']
elif 'id' in _track:
_uid = _track['id']
else:
self.log("TRACK ID NOT FOUND!")
self.play_track(_uid)
def play_track(self, uid):
try:
_url = self.gmc.get_stream_url(uid)
self.call_service("media_player/play_media",
entity_id=self._player_id,
media_content_id=_url,
media_content_type=self.args["media_type"])
except:
self.log(" --- FAILED TO PLAY TRACK --- ")
self.log("uid: {}".format(uid))
self.log("_url: {}".format(_url))
# self.get_track(entity=None,attribute=None,old=None,new=None,kwargs=None)
def next_track(self, entity, attribute, old, new, kwargs):
if new == 'on':
self.get_track(entity=None,
attribute=None,
old=None,
new=None,
kwargs=None)
self.turn_off(self.boolean_next)
def prev_track(self, entity, attribute, old, new, kwargs):
if new == 'on':
self._next_track_no = self._next_track_no - 2
self.get_track(entity=None,
attribute=None,
old=None,
new=None,
kwargs=None)
self.turn_off(self.boolean_prev)
def show_info(self, entity, attribute, old, new, kwargs):
_attr = {}
_track = self._track
if 'artist' in _track:
_attr['media_artist'] = _track['artist']
if 'album' in _track:
_attr['media_album_name'] = _track['album']
if 'title' in _track:
_attr['media_title'] = _track['title']
if 'albumArtRef' in _track:
_album_art_ref = _track['albumArtRef'] ## returns a list
_attr['entity_picture'] = _album_art_ref[0]['url'] ## of dic
if 'artistArtRef' in _track:
_artist_art_ref = _track['artistArtRef']
self.artist_art = _artist_art_ref[0]['url']
if _attr:
self.set_state(self._player_id, attributes=_attr)
def clear_info(self, entity, attribute, old, new, kwargs):
if new != 'playing' or new != 'paused':
self.set_state(self._player_id,
attributes={
"media_title": '',
"media_artist": '',
"media_album_name": '',
"entity_picture": ''
})
def media_player_off(self, entity, attribute, old, new, kwargs):
self.call_service("media_player/turn_off", entity_id=self._player_id)
def gmusic_api_logout(self, entity, attribute, old, new, kwargs):
self.gmc.logout()
self.reset_booleans()
class GmusicComponent(MediaPlayerDevice):
def __init__(self, hass, config):
from gmusicapi import Mobileclient
# https://github.com/simon-weber/gmusicapi/issues/424
class GMusic(Mobileclient):
def login(self, username, password, device_id, authtoken=None):
if authtoken:
self.session._authtoken = authtoken
self.session.is_authenticated = True
try:
# Send a test request to ensure our authtoken is still valide and working
self.get_registered_devices()
return True
except:
# Faild with the test-request so we set "is_authenticated=False"
# and go through the login-process again to get a new "authtoken"
self.session.is_authenticated = False
if device_id:
if super(GMusic, self).login(username, password, device_id):
return True
# Prevent further execution in case we failed with the login-process
raise Exception("Legacy login failed! Please check logs for any gmusicapi related WARNING")
self.hass = hass
#self._api = GMusic()
self._api = Mobileclient()
_login_type = config.get(CONF_LOGIN_TYPE, DEFAULT_LOGIN_TYPE)
_device_id = config.get(CONF_DEVICE_ID)
if _login_type == 'legacy':
_authtoken = config.get(CONF_TOKEN_PATH, DEFAULT_TOKEN_PATH) + "gmusic_authtoken"
if os.path.isfile(_authtoken):
with open(_authtoken, 'rb') as handle:
authtoken = pickle.load(handle)
else:
authtoken = None
_username = config.get(CONF_USERNAME)
_password = config.get(CONF_PASSWORD, DEFAULT_PASSWORD)
logged_in = self._api.login(_username, _password, _device_id, authtoken)
if not logged_in:
_LOGGER.error("Failed legacy log in, check http://unofficial-google-music-api.readthedocs.io/en/latest/reference/mobileclient.html#gmusicapi.clients.Mobileclient.login")
return False
with open(_authtoken, 'wb') as f:
pickle.dump(self._api.session._authtoken, f)
elif _login_type == 'oauth':
_oauth_cred = config.get(CONF_OAUTH_CRED, DEFAULT_OAUTH_CRED)
if os.path.isfile(_oauth_cred):
try:
logged_in = self._api.oauth_login(_device_id, _oauth_cred)
if not logged_in:
raise Exception("Login failed! Please check logs for any gmusicapi related WARNING")
except:
raise Exception("Failed oauth login, check https://unofficial-google-music-api.readthedocs.io/en/latest/reference/mobileclient.html#gmusicapi.clients.Mobileclient.perform_oauth")
else:
raise Exception("Invalid - Not a file! oauth_cred: ", _oauth_cred)
else:
raise Exception("Invalid! login_type: ", _login_type)
self._name = "gmusic_player"
self._playlist = "input_select." + config.get(CONF_PLAYLISTS, DEFAULT_PLAYLISTS)
self._media_player = "input_select." + config.get(CONF_SPEAKERS, DEFAULT_SPEAKERS)
self._station = "input_select." + config.get(CONF_STATIONS, DEFAULT_STATIONS)
self._source = "input_select." + config.get(CONF_SOURCE, DEFAULT_SOURCE)
self._entity_ids = [] ## media_players - aka speakers
self._playlists = []
self._playlist_to_index = {}
self._stations = []
self._station_to_index = {}
self._tracks = []
self._track = []
self._attributes = {}
self._next_track_no = 0
hass.bus.listen_once(EVENT_HOMEASSISTANT_START, self._update_playlists)
hass.bus.listen_once(EVENT_HOMEASSISTANT_START, self._update_stations)
self._shuffle = config.get(CONF_SHUFFLE, DEFAULT_SHUFFLE)
self._shuffle_mode = config.get(CONF_SHUFFLE_MODE, DEFAULT_SHUFFLE_MODE)
self._unsub_tracker = None
self._playing = False
self._state = STATE_OFF
self._volume = 0.0
self._is_mute = False
self._track_name = None
self._track_artist = None
self._track_album_name = None
self._track_album_cover = None
self._track_artist_cover = None
self._attributes['_player_state'] = STATE_OFF
@property
def name(self):
""" Return the name of the player. """
return self._name
@property
def icon(self):
return 'mdi:music-circle'
@property
def supported_features(self):
""" Flag media player features that are supported. """
return SUPPORT_GMUSIC_PLAYER
@property
def should_poll(self):
""" No polling needed. """
return False
@property
def state(self):
""" Return the state of the device. """
return self._state
@property
def device_state_attributes(self):
""" Return the device state attributes. """
return self._attributes
@property
def is_volume_muted(self):
""" Return True if device is muted """
return self._is_mute
@property
def is_on(self):
""" Return True if device is on. """
return self._playing
@property
def media_content_type(self):
""" Content type of current playing media. """
return MEDIA_TYPE_MUSIC
@property
def media_title(self):
""" Title of current playing media. """
return self._track_name
@property
def media_artist(self):
""" Artist of current playing media """
return self._track_artist
@property
def media_album_name(self):
""" Album name of current playing media """
return self._track_album_name
@property
def media_image_url(self):
""" Image url of current playing media. """
return self._track_album_cover
@property
def media_image_remotely_accessible(self):
" True --> entity_picture: http://lh3.googleusercontent.com/Ndilu... "
" False --> entity_picture: /api/media_player_proxy/media_player.gmusic_player?token=4454... "
return True
@property
def shuffle(self):
"""Boolean if shuffling is enabled."""
return self._shuffle
@property
def volume_level(self):
"""Volume level of the media player (0..1)."""
return self._volume
def turn_on(self, *args, **kwargs):
""" Turn on the selected media_player from input_select """
self._playing = False
if not self._update_entity_ids():
return
_player = self.hass.states.get(self._entity_ids)
data = {ATTR_ENTITY_ID: _player.entity_id}
if _player.state == STATE_OFF:
self._unsub_tracker = track_state_change(self.hass, _player.entity_id, self._sync_player)
self._turn_on_media_player(data)
elif _player.state != STATE_OFF:
self._turn_off_media_player(data)
call_later(self.hass, 1, self.turn_on)
def _turn_on_media_player(self, data=None):
"""Fire the on action."""
if data is None:
data = {ATTR_ENTITY_ID: self._entity_ids}
self._state = STATE_IDLE
self.schedule_update_ha_state()
self.hass.services.call(DOMAIN_MP, 'turn_on', data)
def turn_off(self, entity_id=None, old_state=None, new_state=None, **kwargs):
""" Turn off the selected media_player """
self._playing = False
self._track_name = None
self._track_artist = None
self._track_album_name = None
self._track_album_cover = None
_player = self.hass.states.get(self._entity_ids)
data = {ATTR_ENTITY_ID: _player.entity_id}
self._turn_off_media_player(data)
def _turn_off_media_player(self, data=None):
"""Fire the off action."""
self._playing = False
self._state = STATE_OFF
self._attributes['_player_state'] = STATE_OFF
self.schedule_update_ha_state()
if data is None:
data = {ATTR_ENTITY_ID: self._entity_ids}
self.hass.services.call(DOMAIN_MP, 'turn_off', data)
def _update_entity_ids(self):
""" sets the current media_player from input_select """
media_player = self.hass.states.get(self._media_player)
if media_player is None:
_LOGGER.error("(%s) is not a valid input_select entity.", self._media_player)
return False
_entity_ids = "media_player." + media_player.state
if self.hass.states.get(_entity_ids) is None:
_LOGGER.error("(%s) is not a valid media player.", media_player.state)
return False
# Example: self._entity_ids = media_player.bedroom_stereo
self._entity_ids = _entity_ids
return True
def _sync_player(self, entity_id=None, old_state=None, new_state=None):
""" Perform actions based on the state of the selected media_player """
# self._unsub_tracker = track_state_change(self.hass, self._entity_ids, self._sync_player)
if not self._playing:
return
_player = self.hass.states.get(self._entity_ids)
""" full state of device _player, include attributes. """
#self._attributes['_player_full'] = _player
""" entity_id of _player. """
_player_id = _player.entity_id
self._attributes['_player_id'] = _player_id
""" _player "friendley_name" """
_player_friendly = _player.attributes['friendly_name']
self._attributes['_player_friendly'] = _player_friendly
""" _player state - Example [playing -or- idle]. """
_player_state = _player.state
self._attributes['_player_state'] = _player_state
""" Set new volume if it has been changed on the _player """
if 'volume_level' in _player.attributes:
self._volume = round(_player.attributes['volume_level'],2)
if _player.state == 'off':
self._state = STATE_OFF
self.turn_off()
self.schedule_update_ha_state()
def _update_playlists(self, now=None):
""" Sync playlists from Google Music library """
self._playlist_to_index = {}
self._playlists = self._api.get_all_user_playlist_contents()
idx = -1
for playlist in self._playlists:
idx = idx + 1
name = playlist.get('name','')
if len(name) < 1:
continue
self._playlist_to_index[name] = idx
playlists = list(self._playlist_to_index.keys())
self._attributes['playlists'] = playlists
data = {"options": list(playlists), "entity_id": self._playlist}
self.hass.services.call(input_select.DOMAIN, input_select.SERVICE_SET_OPTIONS, data)
def _update_stations(self, now=None):
""" Sync stations from Google Music library """
self._station_to_index = {}
self._stations = self._api.get_all_stations()
idx = -1
for station in self._stations:
idx = idx + 1
name = station.get('name','')
library = station.get('inLibrary')
if len(name) < 1:
continue
if library == True:
self._station_to_index[name] = idx
stations = list(self._station_to_index.keys())
stations.insert(0,"I'm Feeling Lucky")
self._attributes['stations'] = stations
data = {"options": list(stations), "entity_id": self._station}
self.hass.services.call(input_select.DOMAIN, input_select.SERVICE_SET_OPTIONS, data)
def _load_playlist(self, playlist=None):
""" Load selected playlist to the track_queue """
if not self._update_entity_ids():
return
""" if source == Playlist """
_playlist_id = self.hass.states.get(self._playlist)
if _playlist_id is None:
_LOGGER.error("(%s) is not a valid input_select entity.", self._playlist)
return
if playlist is None:
playlist = _playlist_id.state
idx = self._playlist_to_index.get(playlist)
if idx is None:
_LOGGER.error("playlist to index is none!")
self._turn_off_media_player()
return
self._tracks = None
self._tracks = self._playlists[idx]['tracks']
self._total_tracks = len(self._tracks)
#self.log("Loading [{}] Tracks From: {}".format(len(self._tracks), _playlist_id))
if self._shuffle and self._shuffle_mode != 2:
random.shuffle(self._tracks)
self._play()
def _load_station(self, station=None):
""" Load selected station to the track_queue """
self._total_tracks = 100
if not self._update_entity_ids():
return
""" if source == station """
self._tracks = None
_station_id = self.hass.states.get(self._station)
if _station_id is None:
_LOGGER.error("(%s) is not a valid input_select entity.", self._station)
return
if station is None:
station = _station_id.state
if station == "I'm Feeling Lucky":
self._tracks = self._api.get_station_tracks('IFL', num_tracks = self._total_tracks)
else:
idx = None
idx = self._station_to_index.get(station)
if idx is None:
self._turn_off_media_player()
return
_id = self._stations[idx]['id']
self._tracks = self._api.get_station_tracks(_id, num_tracks = self._total_tracks)
# self.log("Loading [{}] Tracks From: {}".format(len(self._tracks), _station_id))
self._play()
def _play(self):
self._playing = True
self._next_track_no = -1
self._get_track()
def _get_track(self, entity_id=None, old_state=None, new_state=None, retry=3):
""" Get a track and play it from the track_queue. """
_track = None
if self._shuffle and self._shuffle_mode != 1:
self._next_track_no = random.randrange(self._total_tracks) - 1
else:
self._next_track_no = self._next_track_no + 1
if self._next_track_no >= self._total_tracks:
self._next_track_no = 0 ## Restart curent playlist (Loop)
#random.shuffle(self._tracks) ## (re)Shuffle on Loop
try:
_track = self._tracks[self._next_track_no]
except IndexError:
_LOGGER.error("Out of range! Number of tracks in track_queue == (%s)", self._total_tracks)
self._turn_off_media_player()
return
if _track is None:
_LOGGER.error("_track is None!")
self._turn_off_media_player()
return
""" If source is a playlist, track is inside of track """
if 'track' in _track:
_track = _track['track']
""" Find the unique track id. """
uid = ''
if 'trackId' in _track:
uid = _track['trackId']
elif 'storeId' in _track:
uid = _track['storeId']
elif 'id' in _track:
uid = _track['id']
else:
_LOGGER.error("Failed to get ID for track: (%s)", _track)
if retry < 1:
self._turn_off_media_player()
return
return self._get_track(retry=retry-1)
""" If available, get track information. """
if 'title' in _track:
self._track_name = _track['title']
else:
self._track_name = None
if 'artist' in _track:
self._track_artist = _track['artist']
else:
self._track_artist = None
if 'album' in _track:
self._track_album_name = _track['album']
else:
self._track_album_name = None
if 'albumArtRef' in _track:
_album_art_ref = _track['albumArtRef'] ## returns a list
self._track_album_cover = _album_art_ref[0]['url'] ## of dic
else:
self._track_album_cover = None
if 'artistArtRef' in _track:
_artist_art_ref = _track['artistArtRef']
self._track_artist_cover = _artist_art_ref[0]['url']
else:
self._track_artist_cover = None
""" Get the stream URL and play on media_player """
try:
_url = self._api.get_stream_url(uid)
except Exception as err:
_LOGGER.error("Failed to get URL for track: (%s)", uid)
if retry < 1:
self._turn_off_media_player()
return
return self._get_track(retry=retry-1)
self._state = STATE_PLAYING
self.schedule_update_ha_state()
data = {
ATTR_MEDIA_CONTENT_ID: _url,
ATTR_MEDIA_CONTENT_TYPE: "audio/mp3",
ATTR_ENTITY_ID: self._entity_ids
}
self.hass.services.call(DOMAIN_MP, SERVICE_PLAY_MEDIA, data)
def play_media(self, media_type, media_id, **kwargs):
if not self._update_entity_ids():
return
_player = self.hass.states.get(self._entity_ids)
if media_type == "station":
_source = {"option":"Station", "entity_id": self._source}
_option = {"option": media_id, "entity_id": self._station}
self.hass.services.call(input_select.DOMAIN, input_select.SERVICE_SELECT_OPTION, _source)
self.hass.services.call(input_select.DOMAIN, input_select.SERVICE_SELECT_OPTION, _option)
elif media_type == "playlist":
_source = {"option":"Playlist", "entity_id": self._source}
_option = {"option": media_id, "entity_id": self._playlist}
self.hass.services.call(input_select.DOMAIN, input_select.SERVICE_SELECT_OPTION, _source)
self.hass.services.call(input_select.DOMAIN, input_select.SERVICE_SELECT_OPTION, _option)
else:
_LOGGER.error("Invalid: (%s) --> media_types are 'station' or 'playlist'.", media_type)
return
if self._playing == True:
self.media_stop()
self.media_play()
elif self._playing == False and self._state == STATE_OFF:
if _player.state == STATE_OFF:
self.turn_on()
else:
data = {ATTR_ENTITY_ID: _player.entity_id}
self._turn_off_media_player(data)
call_later(self.hass, 1, self.turn_on)
else:
_LOGGER.error("self._state is: (%s).", self._state)
def media_play(self, entity_id=None, old_state=None, new_state=None, **kwargs):
"""Send play command."""
if self._state == STATE_PAUSED:
self._state = STATE_PLAYING
self.schedule_update_ha_state()
data = {ATTR_ENTITY_ID: self._entity_ids}
self.hass.services.call(DOMAIN_MP, 'media_play', data)
else:
_source = self.hass.states.get(self._source)
source = _source.state
if source == 'Playlist':
self._load_playlist()
elif source == 'Station':
self._load_station()
else:
_LOGGER.error("Invalid source: (%s)", source)
self.turn_off()
return
def media_pause(self, **kwargs):
""" Send media pause command to media player """
self._state = STATE_PAUSED
self.schedule_update_ha_state()
data = {ATTR_ENTITY_ID: self._entity_ids}
self.hass.services.call(DOMAIN_MP, 'media_pause', data)
def media_play_pause(self, **kwargs):
"""Simulate play pause media player."""
if self._state == STATE_PLAYING:
self.media_pause()
else:
self.media_play()
def media_previous_track(self, **kwargs):
"""Send the previous track command."""
if self._playing:
self._next_track_no = max(self._next_track_no - 2, -1)
self._get_track()
def media_next_track(self, **kwargs):
"""Send next track command."""
if self._playing:
self._get_track()
def media_stop(self, **kwargs):
"""Send stop command."""
self._state = STATE_IDLE
self._playing = False
self._track_artist = None
self._track_album_name = None
self._track_name = None
self._track_album_cover = None
self.schedule_update_ha_state()
data = {ATTR_ENTITY_ID: self._entity_ids}
self.hass.services.call(DOMAIN_MP, 'media_stop', data)
def set_shuffle(self, shuffle):
self._shuffle = shuffle
if self._shuffle_mode == 1:
self._attributes['shuffle_mode'] = 'Shuffle'
elif self._shuffle_mode == 2:
self._attributes['shuffle_mode'] = 'Random'
elif self._shuffle_mode == 3:
self._attributes['shuffle_mode'] = 'Shuffle Random'
else:
self._attributes['shuffle_mode'] = self._shuffle_mode
return self.schedule_update_ha_state()
def set_volume_level(self, volume):
"""Set volume level."""
self._volume = round(volume,2)
data = {ATTR_ENTITY_ID: self._entity_ids, 'volume_level': self._volume}
self.hass.services.call(DOMAIN_MP, 'volume_set', data)
self.schedule_update_ha_state()
def volume_up(self, **kwargs):
"""Volume up the media player."""
newvolume = min(self._volume + 0.05, 1)
self.set_volume_level(newvolume)
def volume_down(self, **kwargs):
"""Volume down media player."""
newvolume = max(self._volume - 0.05, 0.01)
self.set_volume_level(newvolume)
def mute_volume(self, mute):
"""Send mute command."""
if self._is_mute == False:
self._is_mute = True
else:
self._is_mute = False
self.schedule_update_ha_state()
data = {ATTR_ENTITY_ID: self._entity_ids, "is_volume_muted": self._is_mute}
self.hass.services.call(DOMAIN_MP, 'volume_mute', data)
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 GMusicClient(ContentConsumer):
"""Element in charge of interfacing with GMusicApi Client"""
def __init__(self, data_cache):
self.client = Mobileclient()
self.data_cache = data_cache
def login(self):
"""Use data/unlocked/credentials.json to log in"""
mac = Mobileclient.FROM_MAC_ADDRESS
try:
credentials = json.load(open("data/unlocked/credentials.json", "r"))
result = self.client.login(credentials["username"], credentials["password"], mac)
if result == False:
print("\n\033[93mLogin failed.")
print("Please double check that data/unlocked/credentials.json has correct information.\033[m\n")
os._exit(1)
except:
print("\n\033[93mdata/unlocked/credentials.json is not valid.")
print("You may need to delete and regnerate the credentials file.\033[m\n")
exit(1)
def load_my_library(self):
"""Load user's songs, playlists, and stations"""
track_load = threading.Thread(target=self.load_tracks)
radio_load = threading.Thread(target=self.load_radios)
playlist_load = threading.Thread(target=self.load_playlists)
track_load.start()
radio_load.start()
playlist_load.start()
track_load.join()
radio_load.join()
playlist_load.join()
def load_playlists(self):
playlists = self.client.get_all_user_playlist_contents()
playlists.reverse()
self.data_cache.playlists = playlists
def load_tracks(self):
self.data_cache.tracks = [t for t in self.client.get_all_songs() if "nid" in t]
def scrape_song(self, track):
return track
def load_radios(self):
radios = self.client.get_all_stations()
radios.reverse()
self.data_cache.radios = radios
def get_radio_contents(self, radio_id):
tracks = self.client.get_station_tracks(radio_id)
return tracks
def get_radio_list(self, name):
return [r for r in self.data_cache.radios if name in r["name"]]
def filter(self, element, field, filter_by):
return [e for e in element if filter_by in e[field]]
def get_playlist_list(self, name):
return self.filter(self.data_cache.playlists, "name", name)
def search_all_access(self, query):
return self.client.search_all_access(query)
def create_radio(self, seed_type, id, name):
"""Create a radio"""
# This is a weird way to do this, but there's no other choice
ids = {"track": None, "album": None, "artist": None}
seed_id_name = self.get_type_name(seed_type)
ids[seed_id_name] = id
return self.client.create_station(
name=name, track_id=ids["track"], album_id=ids["album"], artist_id=ids["artist"]
)
def search_items_all_access(self, type, query):
"""Searches Albums, Artists, and Songs; uses metaprogramming"""
index_arguments = self.get_index_arguments(type)
items = self.search_all_access(query)["{0}_hits".format(type[:-1])]
return [self.format_item(item, type, index_arguments) for item in items]
def get_sub_items(self, type_from, search_type, from_id):
"""Here type_from refers to artist or album we're indexing against"""
args = self.get_index_arguments(search_type)
if type_from == "playlist":
return self.get_playlist_contents(from_id)
else:
# Get the appropriate search method and execute it
search_method_name = "get_{0}_info".format(type_from)
search_method = getattr(self.client, search_method_name)
try:
items = search_method(from_id, True)[args["type"] + "s"] # True here includes subelements
except:
# User passed in a bad id or something
return
# Now return appropriately
return [self.format_subitems(t, args) for t in items if args["id"] in t]
def get_playlist_contents(self, from_id):
"""Playlist exclusive stuff"""
shareToken = [t for t in self.data_cache.playlists if t["id"] == from_id][0]["shareToken"]
contents = self.client.get_shared_playlist_contents(shareToken)
return [self.format_playlist_contents(t) for t in contents if "track" in t]
def get_suggested(self):
"""Returns a list of tracks that the user might be interested in"""
items = sorted(self.client.get_promoted_songs(), key=lambda y: y["title"])
return [self.format_suggested(t) for t in items if "storeId" in t]
def get_information_about(self, from_type, from_id):
"""Gets specific information about an id (depending on the type)"""
if "artist" in from_type.lower():
return self.client.get_artist_info(from_id, include_albums=False)
if "album" in from_type.lower():
return self.client.get_album_info(from_id, include_tracks=False)
return self.client.get_track_info(from_id)
def get_stream_url(self, nid):
return self.client.get_stream_url(nid)
def lookup(self, nid):
return self.client.get_track_info(nid)
def add_track_to_library(self, nid):
self.client.add_aa_track(nid)
def add_to_playlist(self, playlist_id, nid):
self.client.add_songs_to_playlist(playlist_id, nid)
playlist_load = threading.Thread(target=self.load_playlists)
playlist_load.daemon = True
playlist_load.start()
def format_suggested(self, t):
return (t["title"], t["storeId"], "Play", t["album"])
def format_playlist_contents(self, t):
return (t["track"]["title"], t["trackId"], "Play", t["track"]["album"])
def format_subitems(self, t, args):
return (t[args["name"]], t[args["id"]], args["command"], t[args["alt"]])
class GooglePlayMusic(BaseModule):
def __init__(self, client, options):
super(GooglePlayMusic, self).__init__(client, options)
self.api = Mobileclient()
if self.api.login(self.options["username"], self.options["password"]):
print "Login Successful"
self.webClient = Webclient()
self.webClient.login(self.options["username"], self.options["password"])
#self.findRegisteredDevice()
self.deviceId = self.options["deviceId"]
self.speaker = self.options["speaker"]
self.playing_track_list = False
self.current_track_list = []
self.current_track_index = 0
"""
def findRegisteredDevice(self):
webClient = Webclient()
webClient.login(self.options["username"], self.options["password"])
registered_devices = webClient.get_registered_devices()
for device in registered_devices:
if device["type"] == "PHONE":
self.deviceId = device["id"][2:] #removes the 0x from the front
"""
def onEvent(self, message):
if message["from"] == self.speaker:
if message["event"] == "streamEnded":
if self.playing_track_list:
self.continue_track_list()
def onAction(self, message):
if message["action"] == "search_and_play":
query = message["data"]["query"]
self.search_and_play(query)
if message["action"] == "stopMusic" or message["action"] == "stop":
self.stop_music()
if message["action"] == "startRadio":
query = message["data"]["query"]
self.start_radio(query)
def search_and_play(self, query):
results = self.api.search_all_access(query)
if not len(results["song_hits"]) > 0:
return
song_data = results["song_hits"][0]["track"]
print song_data
self.play_track(song_data)
def play_track(self, song_data):
print "Playing %s, by %s" % (song_data["title"], song_data["artist"])
stream_url = self.api.get_stream_url(song_data["nid"], self.deviceId)
self.client.emitAction(self.speaker, "streamMP3", {"url": stream_url})
def stop_music(self):
self.playing_track_list = False
self.client.emitAction(self.speaker, "stopStreaming", {})
def start_radio(self, query):
results = self.api.search_all_access(query, max_results=10)
top_song = results["song_hits"][0] if len(results["song_hits"]) else None
top_album = results["album_hits"][0] if len(results["album_hits"]) else None
top_artist = results["artist_hits"][0] if len(results["artist_hits"]) else None
if not top_song:
top_song = {"score": 0}
if not top_album:
top_album = {"score": 0}
if not top_artist:
top_artist = {"score": 0}
station_id = None
if top_song["score"] > top_album["score"]and top_song["score"] > top_artist["score"]:
station_id = self.api.create_station(query, track_id=top_song["track"]["nid"])
elif top_album["score"] > top_song["score"] and top_album["score"] > top_artist["score"]:
station_id = self.api.create_station(query, album_id=top_album["album"]["albumId"])
else:
station_id = self.api.create_station(query, artist_id=top_artist["artist"]["artistId"])
tracks = self.api.get_station_tracks(station_id)
self.play_track_list(tracks)
def play_track_list(self, tracks):
self.playing_track_list = True
self.current_track_list = tracks
self.current_track_index = 0
self.play_track(self.current_track_list[0])
def continue_track_list(self):
self.current_track_index += 1
self.play_track(self.current_track_list[self.current_track_index])
class GoogleMusicApi:
def __init__(self):
self._api = Mobileclient()
def login(self, username, password, device_id):
try:
return self._api.login(username, password, device_id)
except AlreadyLoggedIn:
Logger.debug('API: Already logged in')
return True
def relogin(self, username, password, device_id):
try:
return self._api.login(username, password, device_id)
except AlreadyLoggedIn:
self._api.logout()
return self._api.login(username, password, device_id)
def logout(self):
return self._api.logout()
def get_registered_mobile_devices(self):
devices = self._api.get_registered_devices()
mobile_devices = []
for device in devices:
if device['type'] == "ANDROID": # TODO: Add iOS
mobile_devices.append({
'name': device['friendlyName'],
'id': device['id'][2:]
})
return mobile_devices
def get_stream_url(self, track_id, quality):
return self._api.get_stream_url(song_id=track_id, quality=quality)
def get_library(self):
return self._api.get_all_songs()
def get_album_info(self, album_id):
return self._api.get_album_info(album_id)
def search(self, query, max_results=25):
# TODO: make number of results configurable / add to settings
try:
return self._api.search_all_access(query, max_results)
# TODO: remove when gmusicapi 9.0.1 is stable
except AttributeError: # develop version of gmusicapi is installed
return self._api.search(query, max_results)
def get_station_tracks(self, title, seed, num_tracks=25, recently_played_ids=None):
# TODO: make number of results configurable / add to settings
# TODO: check for existing stations, so we don't always create new ones (maybe not necessary: stations created with same seed have the same id
seed_type = seed['type']
seed = seed['seed']
station_id = ''
Logger.debug('Station: Creating station (Title: {}, Seed: {}, Type:{}'.format(title, seed, seed_type))
if seed_type == 'track':
station_id = self.create_station(title, track_id=seed)
elif seed_type == 'artist':
station_id = self.create_station(title, artist_id=seed)
elif seed_type == 'album':
station_id = self.create_station(title, album_id=seed)
elif seed_type == 'genre':
station_id = self.create_station(title, genre_id=seed)
elif seed_type == 'curated':
Logger.debug("Station: CuratedStationId seed, don't know what to do :(")
else:
Logger.error("Station: Unknown seed, don't know what to do :(")
if station_id:
Logger.debug('Station: ID is ' + station_id)
station_tracks = self._api.get_station_tracks(station_id, num_tracks, recently_played_ids)
Logger.debug('Station: Station has {} tracks'.format(len(station_tracks)))
return station_tracks
else:
Logger.warning("Station: Could not retrieve station ID")
return []
def get_feeling_lucky_station_tracks(self, num_tracks=25, recently_played_ids=None):
# TODO: make number of results configurable / add to settings
return self._api.get_station_tracks('IFL', num_tracks, recently_played_ids)
def create_station(self, name, track_id=None, artist_id=None, album_id=None, genre_id=None, playlist_token=None):
return self._api.create_station(name, track_id=track_id, artist_id=artist_id, album_id=album_id,
genre_id=genre_id, playlist_token=playlist_token)
def increment_track_playcount(self, track_id):
self._api.increment_song_playcount(track_id)
class GooglePlayMusicSkill(MycroftSkill):
def __init__(self):
super(GooglePlayMusicSkill, self).__init__(name="GooglePlayMusicSkill")
self.api = Mobileclient()
self.logged_in = False
self.process = None
self.audioservice = None
def initialize(self):
self.register_intent_file('play.genre.intent', self.handle_intent)
self.register_intent_file('stop.intent', self.handle_stop)
if not self.settings['account_name'] or not self.settings['account_password']:
self.speak_dialog('google-play-no-settings')
if AudioService:
self.audioservice = AudioService(self.emitter)
def login_if_necessary(self):
if (not self.logged_in):
if self.api.is_authenticated():
self.logged_in = True
elif not self.settings['account_name'] or not self.settings['account_password']:
self.speak_dialog('google-play-no-settings')
else:
self.logged_in = self.api.login(self.settings['account_name'], self.settings['account_password'], Mobileclient.FROM_MAC_ADDRESS)
def play_track(self, track_id):
stream_url = self.api.get_stream_url(track_id)
self.stop()
self.speak_dialog('google-play')
time.sleep(5)
# Pause for the intro, then start the new stream
# if audio service module is available use it
if self.audioservice:
self.audioservice.play(stream_url)
else: # othervice use normal mp3 playback
self.process = play_mp3(stream_url)
def play_station(self, query):
results = self.api.search(query, 5)
station_hits = results.get('station_hits', [])
if not station_hits:
self.speak_dialog('google-play-no-match')
return
station = station_hits[0].get('station')
station_seed = station.get('stationSeeds')[0].get('curatedStationId')
if not station_seed:
self.speak_dialog('google-play-no-match')
return
created_station = self.api.create_station(query + " radio", curated_station_id=station_seed)
tracks = self.api.get_station_tracks(created_station)
track_id = tracks[0].get('id', tracks[0].get('nid', ''))
self.play_track(track_id)
def play_song_artist(self, song, artist):
artist_hits = self.api.search(artist).get('artist_hits')
song_hits = self.api.search(song).get('song_hits', [])
for song in song_hits:
artist_ids = song.get('artistId')
for artist_id in artist_ids:
for artist in artist_hits:
if artist.get('artistId') == artist_id:
track_id = song.get('id', song.get('nid', ''))
self.play_track(track_id)
else:
self.speak_dialog('google-play-no-match')
def handle_intent(self, message):
self.login_if_necessary()
# try:
if message.data.get('genre'):
self.play_station(message.data.get('genre'))
# elif message.data.get("Song") and message.data.get("Artist"):
# self.play_song_artist(message.data.get("Song"), message.data.get("Artist"))
# except Exception as e:
# LOGGER.error("Error: {0}".format(e))
def handle_stop(self, message):
self.stop()
def stop(self):
if self.process and self.process.poll() is None:
self.process.terminate()
self.process.wait()
self.speak_dialog('google-play-stop')
#
# It might make sense to implement a messaging service that will handle
# the communication in a much cleaner manner
import re
import os
import json
from gmusicapi import Mobileclient
username = os.environ.get( 'GMUSIC_USERNAME' )
password = os.environ.get( 'GMUSIC_PASSWORD' )
api = Mobileclient()
logged_in = api.login(username, password, Mobileclient.FROM_MAC_ADDRESS)
tracks = api.get_station_tracks('44b0d91f-1696-303b-ade0-3f67767a47da', 1)
track_urls = []
class Track(object):
id = ""
title = ""
artist = ""
url = ""
def __init__(self, id, title, artist, url):
self.id = id
self.title = title
self.artist = artist
self.url = url
class GMusicClient(ContentConsumer):
'''Element in charge of interfacing with GMusicApi Client'''
def __init__(self, data_cache):
self.client = Mobileclient()
self.data_cache = data_cache
def login(self):
'''Use data/unlocked/credentials.json to log in'''
mac = Mobileclient.FROM_MAC_ADDRESS
credentials = json.load(open('data/unlocked/credentials.json', 'r'))
self.client.login(credentials['username'], credentials['password'], mac)
def load_my_library(self):
'''Load user's songs, playlists, and stations'''
track_load = threading.Thread(target=self.load_tracks)
radio_load = threading.Thread(target=self.load_radios)
playlist_load = threading.Thread(target=self.load_playlists)
track_load.start()
radio_load.start()
playlist_load.start()
track_load.join()
radio_load.join()
playlist_load.join()
def load_playlists(self):
playlists = self.client.get_all_user_playlist_contents()
playlists.reverse()
self.data_cache.playlists = playlists
def load_tracks(self):
self.data_cache.tracks = [t for t in self.client.get_all_songs() if 'nid' in t]
def scrape_song(self, track):
return track
def load_radios(self):
radios = self.client.get_all_stations()
radios.reverse()
self.data_cache.radios = radios
def get_radio_contents(self, radio_id):
tracks = self.client.get_station_tracks(radio_id)
return tracks
def get_radio_list(self, name):
return [r for r in self.data_cache.radios if name in r['name']]
def filter(self, element, field, filter_by):
return [e for e in element if filter_by in e[field]]
def get_playlist_list(self, name):
return self.filter(self.data_cache.playlists, 'name', name)
def search_all_access(self, query):
return self.client.search_all_access(query)
def create_radio(self, seed_type, id, name):
'''Create a radio'''
# This is a weird way to do this, but there's no other choice
ids = {"track": None, "album": None, "artist": None}
seed_id_name = self.get_type_name(seed_type)
ids[seed_id_name] = id
return self.client.create_station(name=name, track_id=ids['track'], album_id=ids['album'], artist_id=ids['artist'])
def search_items_all_access(self, type, query):
'''Searches Albums, Artists, and Songs; uses metaprogramming'''
index_arguments = self.get_index_arguments(type)
items = self.search_all_access(query)['{0}_hits'.format(type[:-1])]
return [self.format_item(item, type, index_arguments) for item in items]
def get_sub_items(self, type_from, search_type, from_id):
'''Here type_from refers to artist or album we're indexing against'''
args = self.get_index_arguments(search_type)
if type_from == 'playlist':
return self.get_playlist_contents(from_id)
else:
# Get the appropriate search method and execute it
search_method_name = 'get_{0}_info'.format(type_from)
search_method = getattr(self.client, search_method_name)
try:
items = search_method(from_id, True)[args['type']+'s'] # True here includes subelements
except:
# User passed in a bad id or something
return
# Now return appropriately
return [self.format_subitems(t, args) for t in items if args['id'] in t]
def get_playlist_contents(self, from_id):
'''Playlist exclusive stuff'''
shareToken = [t for t in self.data_cache.playlists \
if t['id'] == from_id][0]['shareToken']
contents = self.client.get_shared_playlist_contents(shareToken)
return [self.format_playlist_contents(t) for t in contents if 'track' in t]
def get_suggested(self):
'''Returns a list of tracks that the user might be interested in'''
items = sorted(self.client.get_promoted_songs(), key=lambda y: y['title'])
return [self.format_suggested(t) for t in items if 'storeId' in t]
def get_information_about(self, from_type, from_id):
'''Gets specific information about an id (depending on the type)'''
if 'artist' in from_type.lower():
return self.client.get_artist_info(from_id, include_albums=False)
if 'album' in from_type.lower():
return self.client.get_album_info(from_id, include_tracks=False)
return self.client.get_track_info(from_id)
def get_stream_url(self, nid):
return self.client.get_stream_url(nid)
def lookup(self, nid):
return self.client.get_track_info(nid)
def add_track_to_library(self, nid):
self.client.add_aa_track(nid)
def add_to_playlist(self, playlist_id, nid):
self.client.add_songs_to_playlist(playlist_id, nid)
playlist_load = threading.Thread(target=self.load_playlists)
playlist_load.daemon = True
playlist_load.start()
def format_suggested(self, t):
return (t['title'], t['storeId'], 'Play', t['album'])
def format_playlist_contents(self, t):
return (t['track']['title'], t['trackId'], 'Play', t['track']['album'])
def format_subitems(self, t, args):
return (t[args['name']], t[args['id']], args['command'], t[args['alt']])
nowPlaying = False workingPlaylist = None # ============================================================== # 1.) Login / Initialize #--------# api = Mobileclient() api.login( gMusicLogin.getUser() , gMusicLogin.getPass() , Mobileclient.FROM_MAC_ADDRESS ) lManager = LocalGManager() # 2.) Grab Example Playlist #------------------------# workingPlaylist = api.get_station_tracks( playlists['EDM'][0] , 1000 ) # 3.) Store Results in workingLibraryOBJ #--------------------------------------# workingPlaylistOBJ = lManager.analyzePlaylist(workingPlaylist) # 4.) Check Library for local copy , download if necessary / start playing 1st song # -----------------------------------------------------------------------------------# A2 = 0 while A2 < len(workingPlaylistOBJ['songIDS']): if workingPlaylistOBJ['songIDS'][A2] in localLibrary['EDM']: print( workingPlaylistOBJ['trackName'][A2] + " already exists in library" ) else:
class MusicManager(object):
def __init__(self):
self.api = Mobileclient(validate=False, debug_logging=False)
if config.GOOGLE_STREAMKEY is not None:
self.api.login(config.GOOGLE_USERNAME, config.GOOGLE_PASSWORD, config.GOOGLE_STREAMKEY)
else:
self.api.login(config.GOOGLE_USERNAME, config.GOOGLE_PASSWORD, Mobileclient.FROM_MAC_ADDRESS)
self.queue = []
self.current_index = len(self.queue) - 1
self.vlc = VlcManager()
self.state_thread = Thread(target=self.check_state)
self.state_thread.daemon = True
self.state_thread.start()
def play_song(self, id):
song = self.queue_song(id)
self.current_index = len(self.queue) - 1
self.load_song()
return song
def queue_song(self, id):
self.queue.append(self.getSongInfo(id))
def play_radio_station(self, id):
results = self.api.get_station_tracks(id, num_tracks=40)
for song in results:
song['albumArtRef'] = song['albumArtRef'][0]['url']
if 'artistId' in song:
song['artistId'] = song['artistId'][0]
self.current_index = len(self.queue) - 1
self.queue.append(results)
self.load_song()
def play_album(self, args):
album = self.get_album_details(args)
songs = []
for index in range(len(album['tracks'])):
song = album['tracks'][index]
if index == 0:
songs.append(self.play_song(song['nid']))
else:
songs.append(self.queue_song(song['nid']))
return songs
def queue_album(self, args):
album = self.get_album_details(args)
songs = []
for song in album['tracks']:
songs.append(self.queue_song(song['nid']))
return songs
def next(self):
self.current_index += 1
self.load_song()
def prev(self):
self.current_index -= 1
self.load_song()
def pause(self):
self.vlc.vlc_pause()
def resume(self):
self.vlc.vlc_resume()
def volume(self, val):
self.vlc.vlc_volume(val)
def delete(self, id):
if id > self.current_index:
del self.queue[id]
elif id < self.current_index:
del self.queue[id]
self.current_index -= 1
else:
del self.queue[id]
self.load_song()
def go_to(self, id):
self.current_index = id
self.load_song()
def load_song(self):
if self.current_index < len(self.queue):
song = self.queue[self.current_index]
url = self.api.get_stream_url(song['nid'], config.GOOGLE_STREAMKEY)
self.vlc.vlc_play(url)
def check_state(self):
while True:
status = self.vlc.player.get_state()
if status == vlc.State.Ended:
if self.current_index != len(self.queue) - 1:
self.next()
time.sleep(1)
def get_status(self):
status = self.vlc.vlc_status()
# status['queue'] = self.queue[:]
# for i in range(len(status['queue'])):
# status['queue'][i]['vlcid'] = i
# if i == self.current_index:
# status['queue'][i]['current'] = True
# status['current'] = status['queue'][i]
if len(self.queue) > 0:
status['current'] = self.queue[self.current_index]
return status
def get_queue(self):
queue = self.queue[:]
for i in range(len(queue)):
queue[i]['vlcid'] = i
return queue
def search(self, query):
results = self.api.search_all_access(query, max_results=50)
results['artist_hits'] = [artist['artist'] for artist in results['artist_hits']]
results['album_hits'] = [album['album'] for album in results['album_hits']]
for album in results['album_hits']:
album['artistId'] = album['artistId'][0]
results['song_hits'] = [song['track'] for song in results['song_hits']]
for song in results['song_hits']:
song['albumArtRef'] = song['albumArtRef'][0]['url']
if 'artistId' in song:
song['artistId'] = song['artistId'][0]
return results
def get_album_details(self, id):
results = self.api.get_album_info(album_id=id, include_tracks=True)
results['artistId'] = results['artistId'][0]
for song in results['tracks']:
song['albumArtRef'] = song['albumArtRef'][0]['url']
if 'artistId' in song:
song['artistId'] = song['artistId'][0]
return results
def get_artist_details(self, id):
results = self.api.get_artist_info(artist_id=id)
for album in results['albums']:
album['artistId'] = album['artistId'][0]
for song in results['topTracks']:
song['albumArtRef'] = song['albumArtRef'][0]['url']
if 'artistId' in song:
song['artistId'] = song['artistId'][0]
return results
def create_radio_station(self, name, id):
if id[0] == 'A':
station_id = self.api.create_station(name, artist_id=id)
elif id[0] == 'B':
station_id = self.api.create_station(name, album_id=id)
else:
station_id = self.api.create_station(name, track_id=id)
return station_id
def get_radio_stations(self):
return self.api.get_all_stations()
def flush(self):
self.vlc.vlc_stop()
self.queue = []
def getSongInfo(self, id):
song = self.api.get_track_info(id)
song['albumArtRef'] = song['albumArtRef'][0]['url']
if 'artistId' in song:
song['artistId'] = song['artistId'][0]
return song
class Session(object):
def __init__(self):
self.api = None
self.user = None
self.lib_albums = {}
self.lib_artists = {}
self.lib_tracks = {}
self.lib_updatetime = 0
self.sitdata = []
self.sitbyid = {}
self.sitdataupdtime = 0
def dmpdata(self, who, data):
print("%s: %s" % (who, json.dumps(data, indent=4)), file=sys.stderr)
def login(self, username, password, deviceid=None):
self.api = Mobileclient(debug_logging=False)
if deviceid is None:
logged_in = self.api.login(username, password, Mobileclient.FROM_MAC_ADDRESS)
else:
logged_in = self.api.login(username, password, deviceid)
# print("Logged in: %s" % logged_in)
# data = self.api.get_registered_devices()
# print("registered: %s" % data)
# isauth = self.api.is_authenticated()
# print("Auth ok: %s" % isauth)
return logged_in
def _get_user_library(self):
now = time.time()
if now - self.lib_updatetime < 300:
return
data = self.api.get_all_songs()
# self.dmpdata("all_songs", data)
self.lib_updatetime = now
tracks = [_parse_track(t) for t in data]
self.lib_tracks = dict([(t.id, t) for t in tracks])
for track in tracks:
# We would like to use the album id here, but gmusic
# associates the tracks with any compilations after
# uploading (does not use the metadata apparently), so
# that we can't (we would end up with multiple
# albums). OTOH, the album name is correct (so seems to
# come from the metadata). What we should do is test the
# album ids for one album with a matching title, but we're
# not sure to succeed. So at this point, the album id we
# end up storing could be for a different albums, and we
# should have a special library-local get_album_tracks
self.lib_albums[track.album.name] = track.album
self.lib_artists[track.artist.id] = track.artist
def get_user_albums(self):
self._get_user_library()
return self.lib_albums.values()
def get_user_artists(self):
self._get_user_library()
return self.lib_artists.values()
def get_user_playlists(self):
pldata = self.api.get_all_playlists()
# self.dmpdata("playlists", pldata)
return [_parse_playlist(pl) for pl in pldata]
def get_user_playlist_tracks(self, playlist_id):
self._get_user_library()
data = self.api.get_all_user_playlist_contents()
# self.dmpdata("user_playlist_content", data)
trkl = [item["tracks"] for item in data if item["id"] == playlist_id]
if not trkl:
return []
try:
return [self.lib_tracks[track["trackId"]] for track in trkl[0]]
except:
return []
def create_station_for_genre(self, genre_id):
id = self.api.create_station("station" + genre_id, genre_id=genre_id)
return id
def get_user_stations(self):
data = self.api.get_all_stations()
# parse_playlist works fine for stations
stations = [_parse_playlist(d) for d in data]
return stations
def delete_user_station(self, id):
self.api.delete_stations(id)
# not working right now
def listen_now(self):
print("api.get_listen_now_items()", file=sys.stderr)
ret = {"albums": [], "stations": []}
try:
data = self.api.get_listen_now_items()
except Exception as err:
print("api.get_listen_now_items failed: %s" % err, file=sys.stderr)
data = None
# listen_now entries are not like normal albums or stations,
# and need special parsing. I could not make obvious sense of
# the station-like listen_now entries, so left them aside for
# now. Maybe should use create_station on the artist id?
if data:
ret["albums"] = [_parse_ln_album(a["album"]) for a in data if "album" in a]
# ret['stations'] = [_parse_ln_station(d['radio_station']) \
# for d in data if 'radio_station' in d]
else:
print("listen_now: no items returned !", file=sys.stderr)
print(
"get_listen_now_items: returning %d albums and %d stations" % (len(ret["albums"]), len(ret["stations"])),
file=sys.stderr,
)
return ret
def get_situation_content(self, id=None):
ret = {"situations": [], "stations": []}
now = time.time()
if id is None and now - self.sitdataupdtime > 300:
self.sitbyid = {}
self.sitdata = self.api.get_listen_now_situations()
self.sitdataupdtime = now
# Root is special, it's a list of situations
if id is None:
ret["situations"] = [self._parse_situation(s) for s in self.sitdata]
return ret
# not root
if id not in self.sitbyid:
print("get_situation_content: %s unknown" % id, file=sys.stderr)
return ret
situation = self.sitbyid[id]
# self.dmpdata("situation", situation)
if "situations" in situation:
ret["situations"] = [self._parse_situation(s) for s in situation["situations"]]
if "stations" in situation:
ret["stations"] = [_parse_situation_station(s) for s in situation["stations"]]
return ret
def _parse_situation(self, data):
self.sitbyid[data["id"]] = data
return Playlist(id=data["id"], name=data["title"])
def create_curated_and_get_tracks(self, id):
sid = self.api.create_station("station" + id, curated_station_id=id)
print("create_curated: sid %s" % sid, file=sys.stderr)
tracks = [_parse_track(t) for t in self.api.get_station_tracks(sid)]
# print("curated tracks: %s"%tracks, file=sys.stderr)
self.api.delete_stations(sid)
return tracks
def get_station_tracks(self, id):
return [_parse_track(t) for t in self.api.get_station_tracks(id)]
def get_media_url(self, song_id, quality=u"med"):
url = self.api.get_stream_url(song_id, quality=quality)
print("get_media_url got: %s" % url, file=sys.stderr)
return url
def get_album_tracks(self, album_id):
data = self.api.get_album_info(album_id, include_tracks=True)
album = _parse_album(data)
return [_parse_track(t, album) for t in data["tracks"]]
def get_promoted_tracks(self):
data = self.api.get_promoted_songs()
# self.dmpdata("promoted_tracks", data)
return [_parse_track(t) for t in data]
def get_genres(self, parent=None):
data = self.api.get_genres(parent_genre_id=parent)
return [_parse_genre(g) for g in data]
def get_artist_info(self, artist_id, doRelated=False):
ret = {"albums": [], "toptracks": [], "related": []}
# Happens,some library tracks have no artistId entry
if artist_id is None or artist_id == "None":
print("get_artist_albums: artist_id is None", file=sys.stderr)
return ret
else:
print("get_artist_albums: artist_id %s" % artist_id, file=sys.stderr)
maxrel = 20 if doRelated else 0
maxtop = 0 if doRelated else 10
incalbs = False if doRelated else True
data = self.api.get_artist_info(artist_id, include_albums=incalbs, max_top_tracks=maxtop, max_rel_artist=maxrel)
# self.dmpdata("artist_info", data)
if "albums" in data:
ret["albums"] = [_parse_album(alb) for alb in data["albums"]]
if "topTracks" in data:
ret["toptracks"] = [_parse_track(t) for t in data["topTracks"]]
if "related_artists" in data:
ret["related"] = [_parse_artist(a) for a in data["related_artists"]]
return ret
def get_artist_related(self, artist_id):
data = self.get_artist_info(artist_id, doRelated=True)
return data["related"]
def search(self, query):
data = self.api.search(query, max_results=50)
# self.dmpdata("Search", data)
tr = [_parse_track(i["track"]) for i in data["song_hits"]]
print("track ok", file=sys.stderr)
ar = [_parse_artist(i["artist"]) for i in data["artist_hits"]]
print("artist ok", file=sys.stderr)
al = [_parse_album(i["album"]) for i in data["album_hits"]]
print("album ok", file=sys.stderr)
# self.dmpdata("Search playlists", data['playlist_hits'])
try:
pl = [_parse_splaylist(i) for i in data["playlist_hits"]]
except:
pl = []
print("playlist ok", file=sys.stderr)
return SearchResult(artists=ar, albums=al, playlists=pl, tracks=tr)
class Session(object):
def __init__(self):
self.api = None
self.user = None
self.lib_albums = {}
self.lib_artists = {}
self.lib_tracks = {}
self.lib_playlists = {}
self.lib_updatetime = 0
self.sitdata = []
self.sitbyid = {}
self.sitdataupdtime = 0
def dmpdata(self, who, data):
uplog("%s: %s" % (who, json.dumps(data, indent=4)))
# Look for an Android device id in the registered devices.
def find_device_id(self, data):
for entry in data:
if "type" in entry and entry["type"] == u"ANDROID":
# Get rid of 0x
id = entry["id"][2:]
uplog("Using deviceid %s" % id)
return id
return None
def login(self, username, password, deviceid=None):
self.api = Mobileclient(debug_logging=False)
if deviceid is None:
logged_in = self.api.login(username, password,
Mobileclient.FROM_MAC_ADDRESS)
if logged_in:
# Try to re-login with a valid deviceid
data = self.api.get_registered_devices()
#self.dmpdata("registered devices", data)
deviceid = self.find_device_id(data)
if deviceid:
logged_in = self.login(username, password, deviceid)
else:
logged_in = self.api.login(username, password, deviceid)
isauth = self.api.is_authenticated()
#uplog("login: Logged in: %s. Auth ok: %s" % (logged_in, isauth))
return logged_in
def _get_user_library(self):
now = time.time()
if now - self.lib_updatetime < 300:
return
if self.lib_updatetime == 0:
data = self.api.get_all_songs()
#self.dmpdata("all_songs", data)
else:
data = self.api.get_all_songs(updated_after=datetime.datetime.fromtimestamp(self.lib_updatetime))
#self.dmpdata("all_songs_since_update", data)
self.lib_updatetime = now
tracks = [_parse_track(t) for t in data]
self.lib_tracks.update(dict([(t.id, t) for t in tracks]))
for track in tracks:
# We would like to use the album id here, but gmusic
# associates the tracks with any compilations after
# uploading (does not use the metadata apparently), so
# that we can't (we would end up with multiple
# albums). OTOH, the album name is correct (so seems to
# come from the metadata). What we should do is test the
# album ids for one album with a matching title, but we're
# not sure to succeed. So at this point, the album id we
# end up storing could be for a different albums, and we
# should have a special library-local get_album_tracks
self.lib_albums[track.album.name] = track.album
self.lib_artists[track.artist.id] = track.artist
def get_user_albums(self):
self._get_user_library()
return self.lib_albums.values()
def get_user_artists(self):
self._get_user_library()
return self.lib_artists.values()
def get_user_playlists(self):
pldata = self.api.get_all_playlists()
#self.dmpdata("playlists", pldata)
return [_parse_playlist(pl) for pl in pldata]
def get_user_playlist_tracks(self, playlist_id):
self._get_user_library()
# Unfortunately gmusic does not offer incremental updates for
# playlists. This means we must download all playlist data any
# time we want an update. Playlists include track information
# for gmusic songs, so if a user has a lot of playlists this
# can take some time.
# For now, we only load the playlists one time for performance purposes
if len(self.lib_playlists) == 0:
data = self.api.get_all_user_playlist_contents()
self.lib_playlists = dict([(pl['id'], pl) for pl in data])
tracks = []
if playlist_id in self.lib_playlists:
for entry in self.lib_playlists[playlist_id]['tracks']:
if entry['deleted']:
continue
if entry['source'] == u'1':
tracks.append(self.lib_tracks[entry['trackId']])
elif 'track' in entry:
tracks.append(_parse_track(entry['track']) )
return tracks
def create_station_for_genre(self, genre_id):
id = self.api.create_station("station"+genre_id, genre_id=genre_id)
return id
def get_user_stations(self):
data = self.api.get_all_stations()
# parse_playlist works fine for stations
stations = [_parse_playlist(d) for d in data]
return stations
def delete_user_station(self, id):
self.api.delete_stations(id)
# not working right now
def listen_now(self):
print("api.get_listen_now_items()", file=sys.stderr)
ret = {'albums' : [], 'stations' : []}
try:
data = self.api.get_listen_now_items()
except Exception as err:
print("api.get_listen_now_items failed: %s" % err, file=sys.stderr)
data = None
# listen_now entries are not like normal albums or stations,
# and need special parsing. I could not make obvious sense of
# the station-like listen_now entries, so left them aside for
# now. Maybe should use create_station on the artist id?
if data:
ret['albums'] = [_parse_ln_album(a['album']) \
for a in data if 'album' in a]
#ret['stations'] = [_parse_ln_station(d['radio_station']) \
# for d in data if 'radio_station' in d]
else:
print("listen_now: no items returned !", file=sys.stderr)
print("get_listen_now_items: returning %d albums and %d stations" %\
(len(ret['albums']), len(ret['stations'])), file=sys.stderr)
return ret
def get_situation_content(self, id = None):
ret = {'situations' : [], 'stations' : []}
now = time.time()
if id is None and now - self.sitdataupdtime > 300:
self.sitbyid = {}
self.sitdata = self.api.get_listen_now_situations()
self.sitdataupdtime = now
# Root is special, it's a list of situations
if id is None:
ret['situations'] = [self._parse_situation(s) \
for s in self.sitdata]
return ret
# not root
if id not in self.sitbyid:
print("get_situation_content: %s unknown" % id, file=sys.stderr)
return ret
situation = self.sitbyid[id]
#self.dmpdata("situation", situation)
if 'situations' in situation:
ret['situations'] = [self._parse_situation(s) \
for s in situation['situations']]
if 'stations' in situation:
ret['stations'] = [_parse_situation_station(s) \
for s in situation['stations']]
return ret
def _parse_situation(self, data):
self.sitbyid[data['id']] = data
return Playlist(id=data['id'], name=data['title'])
def create_curated_and_get_tracks(self, id):
sid = self.api.create_station("station"+id, curated_station_id=id)
print("create_curated: sid %s"%sid, file=sys.stderr)
tracks = [_parse_track(t) for t in self.api.get_station_tracks(sid)]
#print("curated tracks: %s"%tracks, file=sys.stderr)
self.api.delete_stations(sid)
return tracks
def get_station_tracks(self, id):
return [_parse_track(t) for t in self.api.get_station_tracks(id)]
def get_media_url(self, song_id, quality=u'med'):
url = self.api.get_stream_url(song_id, quality=quality)
print("get_media_url got: %s" % url, file=sys.stderr)
return url
def get_album_tracks(self, album_id):
data = self.api.get_album_info(album_id, include_tracks=True)
album = _parse_album(data)
return [_parse_track(t, album) for t in data['tracks']]
def get_promoted_tracks(self):
data = self.api.get_promoted_songs()
#self.dmpdata("promoted_tracks", data)
return [_parse_track(t) for t in data]
def get_genres(self, parent=None):
data = self.api.get_genres(parent_genre_id=parent)
return [_parse_genre(g) for g in data]
def get_artist_info(self, artist_id, doRelated=False):
ret = {"albums" : [], "toptracks" : [], "related" : []}
# Happens,some library tracks have no artistId entry
if artist_id is None or artist_id == 'None':
uplog("get_artist_albums: artist_id is None")
return ret
else:
uplog("get_artist_albums: artist_id %s" % artist_id)
maxrel = 20 if doRelated else 0
maxtop = 0 if doRelated else 10
incalbs = False if doRelated else True
data = self.api.get_artist_info(artist_id, include_albums=incalbs,
max_top_tracks=maxtop,
max_rel_artist=maxrel)
#self.dmpdata("artist_info", data)
if 'albums' in data:
ret["albums"] = [_parse_album(alb) for alb in data['albums']]
if 'topTracks' in data:
ret["toptracks"] = [_parse_track(t) for t in data['topTracks']]
if 'related_artists' in data:
ret["related"] = [_parse_artist(a) for a in data['related_artists']]
return ret
def get_artist_related(self, artist_id):
data = self.get_artist_info(artist_id, doRelated=True)
return data["related"]
def search(self, query):
data = self.api.search(query, max_results=50)
#self.dmpdata("Search", data)
tr = [_parse_track(i['track']) for i in data['song_hits']]
ar = [_parse_artist(i['artist']) for i in data['artist_hits']]
al = [_parse_album(i['album']) for i in data['album_hits']]
#self.dmpdata("Search playlists", data['playlist_hits'])
try:
pl = [_parse_splaylist(i) for i in data['playlist_hits']]
except:
pl = []
return SearchResult(artists=ar, albums=al, playlists=pl, tracks=tr)
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()
# then run the script.
# TODO: Sanitize input
import pprint
from gmusicapi import Mobileclient
formatted = {}
api = Mobileclient()
email = input('Enter login email (enclosed by quotes): ')
pw = input('Enter password (enclosed by quotes): ')
#tr_num = input('Enter how many tracks to retrieve: ')
login_success = api.login(email, pw, Mobileclient.FROM_MAC_ADDRESS) # Should eval to True if successful
if not login_success:
print "Login unsuccessful."
else:
stns = api.get_all_stations()
last_station = stns[-1]
id = last_station['id']
tracks = api.get_station_tracks(id) #TODO: # trax
for t in tracks:
pprint.pprint(t)
formatted[t['artist']] = t['title']
pprint.pprint(formatted)
class GMusicWrapper:
def __init__(self, username, password):
self._api = Mobileclient()
success = self._api.login(username, password, Mobileclient.FROM_MAC_ADDRESS)
if not success:
raise Exception("Unsuccessful login. Aborting!")
def _search(self, query_type, query):
results = self._api.search(query)
hits_key = "%s_hits" % query_type
if hits_key not in results:
return []
# Ugh, Google had to make this schema nonstandard...
if query_type == 'song':
query_type = 'track'
return map(lambda x: x[query_type], results[hits_key])
def get_artist(self, name):
search = self._search("artist", name)
if len(search) == 0:
return False
return self._api.get_artist_info(search[0]['artistId'], max_top_tracks=100)
def get_album(self, name, artist_name=None):
if artist_name:
name = "%s %s" % (name, artist_name)
search = self._search("album", name)
if len(search) == 0:
return False
return self._api.get_album_info(search[0]['albumId'])
def get_song(self, name, artist_name=None):
if artist_name:
name = "%s %s" % (artist_name, name)
search = self._search("song", name)
if len(search) == 0:
return False
return search[0]
def get_station(self, title, artist_id=None):
if artist_id != None:
return self._api.create_station(title, artist_id=artist_id)
def get_station_tracks(self, station_id):
return self._api.get_station_tracks(station_id)
def get_google_stream_url(self, song_id):
return self._api.get_stream_url(song_id)
def get_stream_url(self, song_id):
return "%s/stream/%s" % (environ['APP_URL'], song_id)
def get_all_user_playlist_contents(self):
return self._api.get_all_user_playlist_contents()
@classmethod
def generate_api(self):
return self(environ['GOOGLE_EMAIL'], environ['GOOGLE_PASSWORD'])
class GMusicWrapper(object):
def __init__(self, username, password, logger=None):
self._api = Mobileclient()
self.logger = logger
success = self._api.login(
username, password,
environ.get('ANDROID_ID', Mobileclient.FROM_MAC_ADDRESS))
if not success:
raise Exception("Unsuccessful login. Aborting!")
# Populate our library
self.library = {}
self.indexing_thread = threading.Thread(target=self.index_library)
self.indexing_thread.start()
def populate_library(
self
): #TODO: Use this as a function to refresh the library with Alexa via voice commands.
# Populate our library
self.library = {}
self.indexing_thread = threading.Thread(target=self.index_library)
self.indexing_thread.start()
def _search(self, query_type, query):
try:
results = self._api.search(query)
except CallFailure:
return []
hits_key = "%s_hits" % query_type
if hits_key not in results:
return []
# Ugh, Google had to make this schema nonstandard...
if query_type == 'song':
query_type = 'track'
return [x[query_type] for x in results[hits_key]]
def _search_library_for_first(self, query_type, query):
#try searching the library instead of the api
for trackid, trackdata in self.library.items():
if query_type in trackdata:
if query.lower() in trackdata[query_type].lower():
return trackdata
return None
def _search_library(self, query_type, query):
#try searching the library instead of the api
found = []
for trackid, trackdata in self.library.items():
if query_type in trackdata:
if query.lower() in trackdata[query_type].lower():
found.append(trackdata)
if not found:
return None
return found
def is_indexing(self):
return self.indexing_thread.is_alive()
def index_library(self):
"""
Downloads the a list of every track in a user's library and populates
self.library with storeIds -> track definitions
"""
self.logger.debug('Fetching library...')
tracks = self.get_all_songs()
for track in tracks:
song_id = track['id']
self.library[song_id] = track
self.logger.debug('Done! Discovered %d tracks.' % len(self.library))
def get_artist(self, name):
"""
Fetches information about an artist given its name
"""
search = self._search("artist", name)
if len(search) == 0:
search_lib = self._search_library("artist", name)
if search_lib is not None:
self.logger.debug(search_lib)
return search_lib
return False
return self._api.get_artist_info(search[0]['artistId'],
max_top_tracks=100)
def get_album(self, name, artist_name=None):
if artist_name:
name = "%s %s" % (name, artist_name)
search = self._search("album", name)
if len(search) == 0:
search_lib = self._search_library("album", name)
if search_lib is not None:
self.logger.debug(search_lib)
return search_lib
return False
return self._api.get_album_info(search[0]['albumId'])
def get_latest_album(self, artist_name=None):
search = self._search("artist", artist_name)
if len(search) == 0:
return False
artist_info = self._api.get_artist_info(search[0]['artistId'],
include_albums=True)
album_info = artist_info['albums']
sorted_list = sorted(album_info.__iter__(),
key=lambda s: s['year'],
reverse=True)
for index, val in enumerate(sorted_list):
album_info = self._api.get_album_info(
album_id=sorted_list[index]['albumId'], include_tracks=True)
if len(album_info['tracks']) >= 5:
return album_info
return False
def get_album_by_artist(self, artist_name, album_id=None):
search = self._search("artist", artist_name)
if len(search) == 0:
return False
artist_info = self._api.get_artist_info(search[0]['artistId'],
include_albums=True)
album_info = artist_info['albums']
random.shuffle(album_info)
for index, val in enumerate(album_info):
album = self._api.get_album_info(
album_id=album_info[index]['albumId'], include_tracks=True)
if album['albumId'] != album_id and len(album['tracks']) >= 5:
return album
return False
def get_song(self, song_name, artist_name=None, album_name=None):
if artist_name:
name = "%s %s" % (artist_name, song_name)
elif album_name:
name = "%s %s" % (album_name, song_name)
self.logger.debug("get_song() : name: %s" % (name))
search = self._search("song", name)
self.logger.debug("result length: %d" % len(search))
if len(search) == 0:
search_lib = self._search_library_for_first("title", name)
if search_lib is not None:
return search_lib
return False
if album_name:
for i in range(0, len(search) - 1):
if album_name in search[i]['album']:
return search[i]
return search[0]
def get_station(self, title, track_id=None, artist_id=None, album_id=None):
if artist_id is not None:
if album_id is not None:
if track_id is not None:
return self._api.create_station(title, track_id=track_id)
return self._api.create_station(title, album_id=album_id)
return self._api.create_station(title, artist_id=artist_id)
def get_station_tracks(self, station_id):
return self._api.get_station_tracks(station_id)
def get_google_stream_url(self, song_id):
return self._api.get_stream_url(song_id)
def get_stream_url(self, song_id):
return "%s/alexa/stream/%s" % (environ['APP_URL'], song_id)
def get_thumbnail(self, artist_art):
# return artist_art.replace("http://", "https://") //OLD
artistArtKey = 'artistArtRef'
albumArtKey = 'albumArtRef'
if artist_art is None:
return self.default_thumbnail()
elif artistArtKey in artist_art:
artist_art = artist_art[artistArtKey]
elif albumArtKey in artist_art:
artist_art = artist_art[albumArtKey]
else:
return self.default_thumbnail()
if type(artist_art) is list:
if type(artist_art[0]) is dict:
artUrl = artist_art[0]['url']
elif type(artist_art) is dict:
artUrl = artist_art['url']
else:
artUrl = artist_art
return self.urlReplaceWithSecureHttps(artUrl)
def urlReplaceWithSecureHttps(self, url):
return url.replace("http://", "https://")
def default_thumbnail(self):
return 'https://lh3.googleusercontent.com/gdBHEk-u3YRDtuCU3iDTQ52nZd1t4GPmldYaT26Jh6EhXgp1mlhQiuLFl4eXDAXzDig5'
def get_all_user_playlist_contents(self):
return self._api.get_all_user_playlist_contents()
def get_all_songs(self):
return self._api.get_all_songs()
def rate_song(self, song, rating):
return self._api.rate_songs(song, rating)
def extract_track_info(self, track):
# When coming from a playlist, track info is nested under the "track"
# key
if 'track' in track:
track = track['track']
if 'trackId' in track:
return (self.library[track['trackId']], track['trackId'])
if self.use_library_first():
#Using free version track id first
if 'id' in track:
return (track, track['id'])
if 'storeId' in track:
return track, track['storeId']
return (None, None)
def get_artist_album_list(self, artist_name):
search = self._search("artist", artist_name)
if len(search) == 0:
return "Unable to find the artist you requested."
artist_info = self._api.get_artist_info(search[0]['artistId'],
include_albums=True)
album_list_text = "Here's the album listing for %s: " % artist_name
counter = 0
for index, val in enumerate(artist_info['albums']):
if counter > 25: # alexa will time out after 10 seconds if the list takes too long to iterate through
break
album_info = self._api.get_album_info(
album_id=artist_info['albums'][index]['albumId'],
include_tracks=True)
if len(album_info['tracks']) > 5:
counter += 1
album_list_text += (
artist_info['albums'][index]['name']) + ", "
return album_list_text
def get_latest_artist_albums(self, artist_name):
search = self._search("artist", artist_name)
if len(search) == 0:
return False
artist_info = self._api.get_artist_info(search[0]['artistId'],
include_albums=True)
album_list = artist_info['albums']
sorted_list = sorted(album_list.__iter__(),
key=lambda s: s['year'],
reverse=True)
speech_text = 'The latest albums by %s are ' % artist_name
counter = 0
for index, val in enumerate(sorted_list):
if counter > 5:
break
else:
album_info = self._api.get_album_info(
album_id=sorted_list[index]['albumId'],
include_tracks=True)
if len(album_info['tracks']) >= 5:
counter += 1
album_name = sorted_list[index]['name']
album_year = sorted_list[index]['year']
speech_text += '%s, released in %d, ' % (album_name,
album_year)
return speech_text
def closest_match(self,
request_name,
all_matches,
artist_name='',
minimum_score=70):
# Give each match a score based on its similarity to the requested
# name
self.logger.debug("The artist name is " + str(artist_name))
request_name = request_name.lower() + artist_name.lower()
scored_matches = []
for i, match in enumerate(all_matches):
try:
name = match['name'].lower()
except (KeyError, TypeError):
i = match
name = all_matches[match]['title'].lower()
if artist_name != "":
name += all_matches[match]['artist'].lower()
scored_matches.append({
'index': i,
'name': name,
'score': fuzz.ratio(name, request_name)
})
sorted_matches = sorted(scored_matches,
key=lambda a: a['score'],
reverse=True)
top_scoring = sorted_matches[0]
self.logger.debug("The top scoring match was: " + str(top_scoring))
best_match = all_matches[top_scoring['index']]
# Make sure the score is at least the min score value
if top_scoring['score'] < minimum_score:
return None
return best_match
def get_genres(self, parent_genre_id=None):
return self._api.get_genres(parent_genre_id)
def increment_song_playcount(self, song_id, plays=1, playtime=None):
return self._api.increment_song_playcount(song_id, plays, playtime)
def get_song_data(self, song_id):
return self._api.get_track_info(song_id)
def use_library_first(self):
return environ['USE_LIBRARY_FIRST'].lower() == 'true'
@classmethod
def generate_api(cls, **kwargs):
return cls(environ['GOOGLE_EMAIL'], environ['GOOGLE_PASSWORD'],
**kwargs)
class Downloader:
def __init__( self , username1=None , password1=None , baseDirectory=None , pickleLIBFilePath=None ):
self.api = Mobileclient()
if username1 is not None:
if password1 is not None:
self.login( username1 , password1 )
if self.isLoggedIn() == True:
print("Logged In")
else:
raise Exception
# Setup Default Save Location
if baseDirectory is not None:
self.homeDIR = baseDirectory
self.libDIR = os.path.join( self.homeDIR , 'GMusicLocalLibraryPOOL' )
else:
self.homeDIR = os.path.expanduser("~")
self.libDIR = os.path.join( self.homeDIR , 'GMusicLocalLibraryPOOL' )
if not os.path.exists(self.libDIR):
os.makedirs(self.libDIR)
self.stations = {}
self.workingPlaylistOBJ = {}
self.needToDownloadSongs = None
self.Full = True
#self.playlists = None
self.localLibrary = None
#self.initializePlaylists()
if pickleLIBFilePath is not None:
self.initializeLocalLibrary(pickleLIBFilePath)
else:
self.initializeLocalLibrary()
def isLoggedIn(self):
x = self.api.is_authenticated()
return x
def login(self , userN , passW ):
self.api.login( userN , passW , Mobileclient.FROM_MAC_ADDRESS )
def initializePlaylists(self):
try:
self.playlists = pickle.load( open( libDIR + "libPlaylists.p" , "rb" ) )
except:
print("Recreating Playlists Save File")
self.playlists = {}
playlists['EDM'] = []
playlists['Relaxing'] = []
playlists['EDM'].append('4b40425b-2e11-388f-aeed-ea736b88662c')
pickle.dump( playlists , open( libDIR + "libPlaylists.p" , "wb" ) )
def initializeLocalLibrary(self , pickleLIBFilePath=None):
defaultPath2 = os.path.join( self.libDIR , "libDatabasePOOL.p" )
if pickleLIBFilePath is not None:
defaultPath2 = pickleLIBFilePath
print("DefaultPath .p file = " + defaultPath2)
try:
self.localLibrary = pickle.load( open( defaultPath2 , "rb" ) )
print("Loaded libDatabasePOOL.p")
except:
self.localLibrary = {}
pickle.dump( self.localLibrary , open( defaultPath2 , "wb" ) )
print("Recreated LibraryPOOL Save File")
print( "LocalLibary Size = " + str( len( self.localLibrary ) ) )
def getMyStations(self):
stations = self.api.get_all_stations()
for x in stations:
self.stations[x['id']] = x['name']
def printAvailableStations(self):
for x in self.stations:
print( str(x) + " = " + self.stations[x] )
def downloadStationToPOOL( self , stationID ):
rawPlaylist = self.api.get_station_tracks( stationID , 25 )
self.needToDownloadSongs = {}
for x in rawPlaylist:
if x['nid'] in self.localLibrary:
print("Already in LibraryPOOL")
else:
self.Full = False
print( str(x['nid']) + " == Not in library ... need to download" )
self.needToDownloadSongs[x['nid']] = { 'stationID': stationID , 'trackName': x['title'] , 'artistName': x['artist'] , 'albumID': x['albumId'] , 'artURL': x['albumArtRef'][0]['url'] }
p1 = threading.Thread( target=self.getMP3FromSongIDS , args=( stationID , ) )
p1.start()
p1.join()
if self.Full == False:
self.Full = True
print( "LocalLibary Size = " + str( len( self.localLibrary ) ) )
self.downloadStationToPOOL( stationID )
def getMP3FromSongIDS( self , stationID ):
a1 = 1
for x in self.needToDownloadSongs:
self.saveMP3ToLibraryPOOL( x , self.needToDownloadSongs[x]['trackName'] , self.needToDownloadSongs[x]['artistName'] , stationID )
self.localLibrary[x] = self.needToDownloadSongs[x]
pickle.dump( self.localLibrary , open( os.path.join( self.libDIR , "libDatabasePOOL.p" ) , "wb" ) )
print("added [" + str(a1) + " of " + str(len(self.needToDownloadSongs)) + "] songs to localLibrary")
a1 = a1 + 1
def saveMP3ToLibraryPOOL( self , songID , name , artist , stationID ):
albumName = self.stations[stationID]
wURL = self.api.get_stream_url( songID , self.api.android_id , 'hi' )
fN = os.path.join( self.libDIR , songID + ".mp3" )
response1 = requests.get( wURL , stream=True )
with open( fN , 'wb' ) as f:
for data in tqdm( response1.iter_content(chunk_size=524288) ):
f.write(data)
m3 = MP3( fN , ID3=EasyID3 )
m3.add_tags( ID3=EasyID3 )
m3["title"] = name
m3['artist'] = artist
m3['album'] = albumName
m3['organization'] = stationID
m3.save()
def extractSinglePlaylistFromPOOL( self , stationID , destinationDIR , onlyCopyNotExtract=False ):
if not os.path.exists(destinationDIR):
os.makedirs(destinationDIR)
if onlyCopyNotExtract == True:
for key , value in self.localLibrary.items():
try:
if value['stationID'] == stationID:
#print( "found --> " + self.localLibrary[key]['trackName'] + " in ... " + str(stationID) )
fN = str(key) + ".mp3"
shutil.copy( os.path.join( self.libDIR , fN ) , os.path.join( destinationDIR , fN ) )
except:
pass
else:
for key , value in self.localLibrary.items():
try:
if value['stationID'] == stationID:
#print( "found --> " + self.localLibrary[key]['trackName'] + " in ... " + str(stationID) )
fN = str(key) + ".mp3"
shutil.move( os.path.join( self.libDIR , fN ) , os.path.join( destinationDIR , fN ) )
except:
pass
class tizgmusicproxy(object):
"""A class for logging into a Google Play Music account and retrieving song
URLs.
"""
all_songs_album_title = "All Songs"
thumbs_up_playlist_name = "Thumbs Up"
def __init__(self, email, password, device_id):
self.__gmusic = Mobileclient()
self.__email = email
self.__device_id = device_id
self.logged_in = False
self.queue = list()
self.queue_index = -1
self.play_queue_order = list()
self.play_modes = TizEnumeration(["NORMAL", "SHUFFLE"])
self.current_play_mode = self.play_modes.NORMAL
self.now_playing_song = None
userdir = os.path.expanduser('~')
tizconfig = os.path.join(userdir, ".config/tizonia/." + email + ".auth_token")
auth_token = ""
if os.path.isfile(tizconfig):
with open(tizconfig, "r") as f:
auth_token = pickle.load(f)
if auth_token:
# 'Keep track of the auth token' workaround. See:
# https://github.com/diraimondo/gmusicproxy/issues/34#issuecomment-147359198
print_msg("[Google Play Music] [Authenticating] : " \
"'with cached auth token'")
self.__gmusic.android_id = device_id
self.__gmusic.session._authtoken = auth_token
self.__gmusic.session.is_authenticated = True
try:
self.__gmusic.get_registered_devices()
except CallFailure:
# The token has expired. Reset the client object
print_wrn("[Google Play Music] [Authenticating] : " \
"'auth token expired'")
self.__gmusic = Mobileclient()
auth_token = ""
if not auth_token:
attempts = 0
print_nfo("[Google Play Music] [Authenticating] : " \
"'with user credentials'")
while not self.logged_in and attempts < 3:
self.logged_in = self.__gmusic.login(email, password, device_id)
attempts += 1
with open(tizconfig, "a+") as f:
f.truncate()
pickle.dump(self.__gmusic.session._authtoken, f)
self.library = CaseInsensitiveDict()
self.song_map = CaseInsensitiveDict()
self.playlists = CaseInsensitiveDict()
self.stations = CaseInsensitiveDict()
def logout(self):
""" Reset the session to an unauthenticated, default state.
"""
self.__gmusic.logout()
def set_play_mode(self, mode):
""" Set the playback mode.
:param mode: curren tvalid values are "NORMAL" and "SHUFFLE"
"""
self.current_play_mode = getattr(self.play_modes, mode)
self.__update_play_queue_order()
def current_song_title_and_artist(self):
""" Retrieve the current track's title and artist name.
"""
logging.info("current_song_title_and_artist")
song = self.now_playing_song
if song:
title = to_ascii(self.now_playing_song.get('title'))
artist = to_ascii(self.now_playing_song.get('artist'))
logging.info("Now playing %s by %s", title, artist)
return artist, title
else:
return '', ''
def current_song_album_and_duration(self):
""" Retrieve the current track's album and duration.
"""
logging.info("current_song_album_and_duration")
song = self.now_playing_song
if song:
album = to_ascii(self.now_playing_song.get('album'))
duration = to_ascii \
(self.now_playing_song.get('durationMillis'))
logging.info("album %s duration %s", album, duration)
return album, int(duration)
else:
return '', 0
def current_track_and_album_total(self):
"""Return the current track number and the total number of tracks in the
album, if known.
"""
logging.info("current_track_and_album_total")
song = self.now_playing_song
track = 0
total = 0
if song:
try:
track = self.now_playing_song['trackNumber']
total = self.now_playing_song['totalTrackCount']
logging.info("track number %s total tracks %s", track, total)
except KeyError:
logging.info("trackNumber or totalTrackCount : not found")
else:
logging.info("current_song_track_number_"
"and_total_tracks : not found")
return track, total
def current_song_year(self):
""" Return the current track's year of publication.
"""
logging.info("current_song_year")
song = self.now_playing_song
year = 0
if song:
try:
year = song['year']
logging.info("track year %s", year)
except KeyError:
logging.info("year : not found")
else:
logging.info("current_song_year : not found")
return year
def clear_queue(self):
""" Clears the playback queue.
"""
self.queue = list()
self.queue_index = -1
def enqueue_artist(self, arg):
""" Search the user's library for tracks from the given artist and adds
them to the playback queue.
:param arg: an artist
"""
try:
self.__update_local_library()
artist = None
if arg not in self.library.keys():
for name, art in self.library.iteritems():
if arg.lower() in name.lower():
artist = art
print_wrn("[Google Play Music] '{0}' not found. " \
"Playing '{1}' instead." \
.format(arg.encode('utf-8'), \
name.encode('utf-8')))
break
if not artist:
# Play some random artist from the library
random.seed()
artist = random.choice(self.library.keys())
artist = self.library[artist]
print_wrn("[Google Play Music] '{0}' not found. "\
"Feeling lucky?." \
.format(arg.encode('utf-8')))
else:
artist = self.library[arg]
tracks_added = 0
for album in artist:
tracks_added += self.__enqueue_tracks(artist[album])
print_wrn("[Google Play Music] Playing '{0}'." \
.format(to_ascii(artist)))
self.__update_play_queue_order()
except KeyError:
raise KeyError("Artist not found : {0}".format(arg))
def enqueue_album(self, arg):
""" Search the user's library for albums with a given name and adds
them to the playback queue.
"""
try:
self.__update_local_library()
album = None
artist = None
tentative_album = None
tentative_artist = None
for library_artist in self.library:
for artist_album in self.library[library_artist]:
print_nfo("[Google Play Music] [Album] '{0}'." \
.format(to_ascii(artist_album)))
if not album:
if arg.lower() == artist_album.lower():
album = artist_album
artist = library_artist
break
if not tentative_album:
if arg.lower() in artist_album.lower():
tentative_album = artist_album
tentative_artist = library_artist
if album:
break
if not album and tentative_album:
album = tentative_album
artist = tentative_artist
print_wrn("[Google Play Music] '{0}' not found. " \
"Playing '{1}' instead." \
.format(arg.encode('utf-8'), \
album.encode('utf-8')))
if not album:
# Play some random album from the library
random.seed()
artist = random.choice(self.library.keys())
album = random.choice(self.library[artist].keys())
print_wrn("[Google Play Music] '{0}' not found. "\
"Feeling lucky?." \
.format(arg.encode('utf-8')))
if not album:
raise KeyError("Album not found : {0}".format(arg))
self.__enqueue_tracks(self.library[artist][album])
print_wrn("[Google Play Music] Playing '{0}'." \
.format(to_ascii(album)))
self.__update_play_queue_order()
except KeyError:
raise KeyError("Album not found : {0}".format(arg))
def enqueue_playlist(self, arg):
"""Search the user's library for playlists with a given name
and adds the tracks of the first match to the playback queue.
Requires Unlimited subscription.
"""
try:
self.__update_local_library()
self.__update_playlists()
self.__update_playlists_unlimited()
playlist = None
playlist_name = None
for name, plist in self.playlists.items():
print_nfo("[Google Play Music] [Playlist] '{0}'." \
.format(to_ascii(name)))
if arg not in self.playlists.keys():
for name, plist in self.playlists.iteritems():
if arg.lower() in name.lower():
playlist = plist
playlist_name = name
print_wrn("[Google Play Music] '{0}' not found. " \
"Playing '{1}' instead." \
.format(arg.encode('utf-8'), \
to_ascii(name)))
break
if not playlist:
# Play some random playlist from the library
random.seed()
playlist_name = random.choice(self.playlists.keys())
playlist = self.playlists[playlist_name]
print_wrn("[Google Play Music] '{0}' not found. "\
"Feeling lucky?." \
.format(arg.encode('utf-8')))
else:
playlist_name = arg
playlist = self.playlists[arg]
self.__enqueue_tracks(playlist)
print_wrn("[Google Play Music] Playing '{0}'." \
.format(to_ascii(playlist_name)))
self.__update_play_queue_order()
except KeyError:
raise KeyError("Playlist not found : {0}".format(arg))
def enqueue_station_unlimited(self, arg):
"""Search the user's library for a station with a given name
and add its tracks to the playback queue.
Requires Unlimited subscription.
"""
try:
# First try to find a suitable station in the user's library
self.__enqueue_user_station_unlimited(arg)
if not len(self.queue):
# If no suitable station is found in the user's library, then
# search google play unlimited for a potential match.
self.__enqueue_station_unlimited(arg)
if not len(self.queue):
raise KeyError
except KeyError:
raise KeyError("Station not found : {0}".format(arg))
def enqueue_genre_unlimited(self, arg):
"""Search Unlimited for a genre with a given name and add its
tracks to the playback queue.
Requires Unlimited subscription.
"""
print_msg("[Google Play Music] [Retrieving genres] : '{0}'. " \
.format(self.__email))
try:
all_genres = list()
root_genres = self.__gmusic.get_genres()
second_tier_genres = list()
for root_genre in root_genres:
second_tier_genres += self.__gmusic.get_genres(root_genre['id'])
all_genres += root_genres
all_genres += second_tier_genres
for genre in all_genres:
print_nfo("[Google Play Music] [Genre] '{0}'." \
.format(to_ascii(genre['name'])))
genre = dict()
if arg not in all_genres:
genre = next((g for g in all_genres \
if arg.lower() in to_ascii(g['name']).lower()), \
None)
tracks_added = 0
while not tracks_added:
if not genre and len(all_genres):
# Play some random genre from the search results
random.seed()
genre = random.choice(all_genres)
print_wrn("[Google Play Music] '{0}' not found. "\
"Feeling lucky?." \
.format(arg.encode('utf-8')))
genre_name = genre['name']
genre_id = genre['id']
station_id = self.__gmusic.create_station(genre_name, \
None, None, None, genre_id)
num_tracks = 200
tracks = self.__gmusic.get_station_tracks(station_id, num_tracks)
tracks_added = self.__enqueue_tracks(tracks)
logging.info("Added %d tracks from %s to queue", tracks_added, genre_name)
if not tracks_added:
# This will produce another iteration in the loop
genre = None
print_wrn("[Google Play Music] Playing '{0}'." \
.format(to_ascii(genre['name'])))
self.__update_play_queue_order()
except KeyError:
raise KeyError("Genre not found : {0}".format(arg))
except CallFailure:
raise RuntimeError("Operation requires an Unlimited subscription.")
def enqueue_situation_unlimited(self, arg):
"""Search Unlimited for a situation with a given name and add its
tracks to the playback queue.
Requires Unlimited subscription.
"""
print_msg("[Google Play Music] [Retrieving situations] : '{0}'. " \
.format(self.__email))
try:
self.__enqueue_situation_unlimited(arg)
if not len(self.queue):
raise KeyError
logging.info("Added %d tracks from %s to queue", \
len(self.queue), arg)
except KeyError:
raise KeyError("Situation not found : {0}".format(arg))
except CallFailure:
raise RuntimeError("Operation requires an Unlimited subscription.")
def enqueue_artist_unlimited(self, arg):
"""Search Unlimited for an artist and adds the artist's 200 top tracks to the
playback queue.
Requires Unlimited subscription.
"""
try:
artist = self.__gmusic_search(arg, 'artist')
include_albums = False
max_top_tracks = 200
max_rel_artist = 0
artist_tracks = dict()
if artist:
artist_tracks = self.__gmusic.get_artist_info \
(artist['artist']['artistId'],
include_albums, max_top_tracks,
max_rel_artist)['topTracks']
if not artist_tracks:
raise KeyError
tracks_added = self.__enqueue_tracks(artist_tracks)
logging.info("Added %d tracks from %s to queue", \
tracks_added, arg)
self.__update_play_queue_order()
except KeyError:
raise KeyError("Artist not found : {0}".format(arg))
except CallFailure:
raise RuntimeError("Operation requires an Unlimited subscription.")
def enqueue_album_unlimited(self, arg):
"""Search Unlimited for an album and add its tracks to the
playback queue.
Requires Unlimited subscription.
"""
try:
album = self.__gmusic_search(arg, 'album')
album_tracks = dict()
if album:
album_tracks = self.__gmusic.get_album_info \
(album['album']['albumId'])['tracks']
if not album_tracks:
raise KeyError
print_wrn("[Google Play Music] Playing '{0}'." \
.format((album['album']['name']).encode('utf-8')))
tracks_added = self.__enqueue_tracks(album_tracks)
logging.info("Added %d tracks from %s to queue", \
tracks_added, arg)
self.__update_play_queue_order()
except KeyError:
raise KeyError("Album not found : {0}".format(arg))
except CallFailure:
raise RuntimeError("Operation requires an Unlimited subscription.")
def enqueue_tracks_unlimited(self, arg):
""" Search Unlimited for a track name and adds all the matching tracks
to the playback queue.
Requires Unlimited subscription.
"""
print_msg("[Google Play Music] [Retrieving library] : '{0}'. " \
.format(self.__email))
try:
max_results = 200
track_hits = self.__gmusic.search(arg, max_results)['song_hits']
if not len(track_hits):
# Do another search with an empty string
track_hits = self.__gmusic.search("", max_results)['song_hits']
print_wrn("[Google Play Music] '{0}' not found. "\
"Feeling lucky?." \
.format(arg.encode('utf-8')))
tracks = list()
for hit in track_hits:
tracks.append(hit['track'])
tracks_added = self.__enqueue_tracks(tracks)
logging.info("Added %d tracks from %s to queue", \
tracks_added, arg)
self.__update_play_queue_order()
except KeyError:
raise KeyError("Playlist not found : {0}".format(arg))
except CallFailure:
raise RuntimeError("Operation requires an Unlimited subscription.")
def enqueue_promoted_tracks_unlimited(self):
""" Retrieve the url of the next track in the playback queue.
"""
try:
tracks = self.__gmusic.get_promoted_songs()
count = 0
for track in tracks:
store_track = self.__gmusic.get_track_info(track['storeId'])
if u'id' not in store_track.keys():
store_track[u'id'] = store_track['nid']
self.queue.append(store_track)
count += 1
if count == 0:
print_wrn("[Google Play Music] Operation requires " \
"an Unlimited subscription.")
logging.info("Added %d Unlimited promoted tracks to queue", \
count)
self.__update_play_queue_order()
except CallFailure:
raise RuntimeError("Operation requires an Unlimited subscription.")
def next_url(self):
""" Retrieve the url of the next track in the playback queue.
"""
if len(self.queue):
self.queue_index += 1
if (self.queue_index < len(self.queue)) \
and (self.queue_index >= 0):
next_song = self.queue[self.play_queue_order[self.queue_index]]
return self.__retrieve_track_url(next_song)
else:
self.queue_index = -1
return self.next_url()
else:
return ''
def prev_url(self):
""" Retrieve the url of the previous track in the playback queue.
"""
if len(self.queue):
self.queue_index -= 1
if (self.queue_index < len(self.queue)) \
and (self.queue_index >= 0):
prev_song = self.queue[self.play_queue_order[self.queue_index]]
return self.__retrieve_track_url(prev_song)
else:
self.queue_index = len(self.queue)
return self.prev_url()
else:
return ''
def __update_play_queue_order(self):
""" Update the queue playback order.
A sequential order is applied if the current play mode is "NORMAL" or a
random order if current play mode is "SHUFFLE"
"""
total_tracks = len(self.queue)
if total_tracks:
if not len(self.play_queue_order):
# Create a sequential play order, if empty
self.play_queue_order = range(total_tracks)
if self.current_play_mode == self.play_modes.SHUFFLE:
random.shuffle(self.play_queue_order)
print_nfo("[Google Play Music] [Tracks in queue] '{0}'." \
.format(total_tracks))
def __retrieve_track_url(self, song):
""" Retrieve a song url
"""
song_url = self.__gmusic.get_stream_url(song['id'], self.__device_id)
try:
self.now_playing_song = song
return song_url
except AttributeError:
logging.info("Could not retrieve the song url!")
raise
def __update_local_library(self):
""" Retrieve the songs and albums from the user's library
"""
print_msg("[Google Play Music] [Retrieving library] : '{0}'. " \
.format(self.__email))
songs = self.__gmusic.get_all_songs()
self.playlists[self.thumbs_up_playlist_name] = list()
# Retrieve the user's song library
for song in songs:
if "rating" in song and song['rating'] == "5":
self.playlists[self.thumbs_up_playlist_name].append(song)
song_id = song['id']
song_artist = song['artist']
song_album = song['album']
self.song_map[song_id] = song
if song_artist == "":
song_artist = "Unknown Artist"
if song_album == "":
song_album = "Unknown Album"
if song_artist not in self.library:
self.library[song_artist] = CaseInsensitiveDict()
self.library[song_artist][self.all_songs_album_title] = list()
if song_album not in self.library[song_artist]:
self.library[song_artist][song_album] = list()
self.library[song_artist][song_album].append(song)
self.library[song_artist][self.all_songs_album_title].append(song)
# Sort albums by track number
for artist in self.library.keys():
logging.info("Artist : %s", to_ascii(artist))
for album in self.library[artist].keys():
logging.info(" Album : %s", to_ascii(album))
if album == self.all_songs_album_title:
sorted_album = sorted(self.library[artist][album],
key=lambda k: k['title'])
else:
sorted_album = sorted(self.library[artist][album],
key=lambda k: k.get('trackNumber',
0))
self.library[artist][album] = sorted_album
def __update_stations_unlimited(self):
""" Retrieve stations (Unlimited)
"""
self.stations.clear()
stations = self.__gmusic.get_all_stations()
self.stations[u"I'm Feeling Lucky"] = 'IFL'
for station in stations:
station_name = station['name']
logging.info("station name : %s", to_ascii(station_name))
self.stations[station_name] = station['id']
def __enqueue_user_station_unlimited(self, arg):
""" Enqueue a user station (Unlimited)
"""
print_msg("[Google Play Music] [Station search "\
"in user's library] : '{0}'. " \
.format(self.__email))
self.__update_stations_unlimited()
station_name = arg
station_id = None
for name, st_id in self.stations.iteritems():
print_nfo("[Google Play Music] [Station] '{0}'." \
.format(to_ascii(name)))
if arg not in self.stations.keys():
for name, st_id in self.stations.iteritems():
if arg.lower() in name.lower():
station_id = st_id
station_name = name
break
else:
station_id = self.stations[arg]
num_tracks = 200
tracks = list()
if station_id:
try:
tracks = self.__gmusic.get_station_tracks(station_id, \
num_tracks)
except KeyError:
raise RuntimeError("Operation requires an "
"Unlimited subscription.")
tracks_added = self.__enqueue_tracks(tracks)
if tracks_added:
if arg != station_name:
print_wrn("[Google Play Music] '{0}' not found. " \
"Playing '{1}' instead." \
.format(arg.encode('utf-8'), name.encode('utf-8')))
logging.info("Added %d tracks from %s to queue", tracks_added, arg)
self.__update_play_queue_order()
else:
print_wrn("[Google Play Music] '{0}' has no tracks. " \
.format(station_name))
if not len(self.queue):
print_wrn("[Google Play Music] '{0}' " \
"not found in the user's library. " \
.format(arg.encode('utf-8')))
def __enqueue_station_unlimited(self, arg, max_results=200, quiet=False):
"""Search for a station and enqueue all of its tracks (Unlimited)
"""
if not quiet:
print_msg("[Google Play Music] [Station search in "\
"Google Play Music] : '{0}'. " \
.format(arg.encode('utf-8')))
try:
station_name = arg
station_id = None
station = self.__gmusic_search(arg, 'station', max_results, quiet)
if station:
station = station['station']
station_name = station['name']
seed = station['seed']
seed_type = seed['seedType']
track_id = seed['trackId'] if seed_type == u'2' else None
artist_id = seed['artistId'] if seed_type == u'3' else None
album_id = seed['albumId'] if seed_type == u'4' else None
genre_id = seed['genreId'] if seed_type == u'5' else None
playlist_token = seed['playlistShareToken'] if seed_type == u'8' else None
curated_station_id = seed['curatedStationId'] if seed_type == u'9' else None
num_tracks = max_results
tracks = list()
try:
station_id \
= self.__gmusic.create_station(station_name, \
track_id, \
artist_id, \
album_id, \
genre_id, \
playlist_token, \
curated_station_id)
tracks \
= self.__gmusic.get_station_tracks(station_id, \
num_tracks)
except KeyError:
raise RuntimeError("Operation requires an "
"Unlimited subscription.")
tracks_added = self.__enqueue_tracks(tracks)
if tracks_added:
if not quiet:
print_wrn("[Google Play Music] [Station] : '{0}'." \
.format(station_name.encode('utf-8')))
logging.info("Added %d tracks from %s to queue", \
tracks_added, arg.encode('utf-8'))
self.__update_play_queue_order()
except KeyError:
raise KeyError("Station not found : {0}".format(arg))
def __enqueue_situation_unlimited(self, arg):
"""Search for a situation and enqueue all of its tracks (Unlimited)
"""
print_msg("[Google Play Music] [Situation search in "\
"Google Play Music] : '{0}'. " \
.format(arg.encode('utf-8')))
try:
situation_hits = self.__gmusic.search(arg)['situation_hits']
if not len(situation_hits):
# Do another search with an empty string
situation_hits = self.__gmusic.search("")['situation_hits']
print_wrn("[Google Play Music] '{0}' not found. "\
"Feeling lucky?." \
.format(arg.encode('utf-8')))
situation = next((hit for hit in situation_hits \
if 'best_result' in hit.keys()), None)
num_tracks = 200
if not situation and len(situation_hits):
max_results = num_tracks / len(situation_hits)
for hit in situation_hits:
situation = hit['situation']
print_nfo("[Google Play Music] [Situation] '{0} : {1}'." \
.format((hit['situation']['title']).encode('utf-8'),
(hit['situation']['description']).encode('utf-8')))
self.__enqueue_station_unlimited(situation['title'], max_results, True)
if not situation:
raise KeyError
except KeyError:
raise KeyError("Situation not found : {0}".format(arg))
def __enqueue_tracks(self, tracks):
""" Add tracks to the playback queue
"""
count = 0
for track in tracks:
if u'id' not in track.keys():
track[u'id'] = track['nid']
self.queue.append(track)
count += 1
return count
def __update_playlists(self):
""" Retrieve the user's playlists
"""
plists = self.__gmusic.get_all_user_playlist_contents()
for plist in plists:
plist_name = plist['name']
logging.info("playlist name : %s", to_ascii(plist_name))
tracks = plist['tracks']
tracks.sort(key=itemgetter('creationTimestamp'))
self.playlists[plist_name] = list()
for track in tracks:
try:
song = self.song_map[track['trackId']]
self.playlists[plist_name].append(song)
except IndexError:
pass
def __update_playlists_unlimited(self):
""" Retrieve shared playlists (Unlimited)
"""
plists_subscribed_to = [p for p in self.__gmusic.get_all_playlists() \
if p.get('type') == 'SHARED']
for plist in plists_subscribed_to:
share_tok = plist['shareToken']
playlist_items \
= self.__gmusic.get_shared_playlist_contents(share_tok)
plist_name = plist['name']
logging.info("shared playlist name : %s", to_ascii(plist_name))
self.playlists[plist_name] = list()
for item in playlist_items:
try:
song = item['track']
song['id'] = item['trackId']
self.playlists[plist_name].append(song)
except IndexError:
pass
def __gmusic_search(self, query, query_type, max_results=200, quiet=False):
""" Search Google Play (Unlimited)
"""
search_results = self.__gmusic.search(query, max_results)[query_type + '_hits']
result = next((hit for hit in search_results \
if 'best_result' in hit.keys()), None)
if not result and len(search_results):
secondary_hit = None
for hit in search_results:
if not quiet:
print_nfo("[Google Play Music] [{0}] '{1}'." \
.format(query_type.capitalize(),
(hit[query_type]['name']).encode('utf-8')))
if query.lower() == \
to_ascii(hit[query_type]['name']).lower():
result = hit
break
if query.lower() in \
to_ascii(hit[query_type]['name']).lower():
secondary_hit = hit
if not result and secondary_hit:
result = secondary_hit
if not result and not len(search_results):
# Do another search with an empty string
search_results = self.__gmusic.search("")[query_type + '_hits']
if not result and len(search_results):
# Play some random result from the search results
random.seed()
result = random.choice(search_results)
if not quiet:
print_wrn("[Google Play Music] '{0}' not found. "\
"Feeling lucky?." \
.format(query.encode('utf-8')))
return result
class GMusicWrapper(object):
def __init__(self, username, password, logger=None):
self._api = Mobileclient()
self.logger = logger
success = self._api.login(username, password, getenv('ANDROID_ID', Mobileclient.FROM_MAC_ADDRESS))
if not success:
raise Exception("Unsuccessful login. Aborting!")
try:
assert literal_eval(getenv("DEBUG_FORCE_LIBRARY", "False"))
self.use_store = False
except (AssertionError, ValueError): # AssertionError if it's False, ValueError if it's not set / not set to a proper boolean string
self.use_store = self._api.is_subscribed
# Populate our library
self.start_indexing()
def start_indexing(self):
self.library = {}
self.albums = set([])
self.artists = set([])
self.indexing_thread = threading.Thread(
target=self.index_library
)
self.indexing_thread.start()
def log(self, log_str):
if self.logger != None:
self.logger.debug(log_str)
def _search(self, query_type, query):
try:
results = self._api.search(query)
except CallFailure:
return []
hits_key = "%s_hits" % query_type
if hits_key not in results:
return []
# Ugh, Google had to make this schema nonstandard...
if query_type == 'song':
query_type = 'track'
return [x[query_type] for x in results[hits_key]]
def is_indexing(self):
return self.indexing_thread.is_alive()
def index_library(self):
"""
Downloads the a list of every track in a user's library and populates
self.library with storeIds -> track definitions
"""
self.log('Fetching library...')
tracks = self.get_all_songs()
for track in tracks:
song_id = track['id']
self.library[song_id] = track
self.albums.add(track['album'])
self.artists.add(track['artist'])
self.log('Fetching library complete.')
def get_artist(self, name):
"""
Fetches information about an artist given its name
"""
if self.use_store:
search = self._search("artist", name)
if len(search) == 0:
return False
return self._api.get_artist_info(search[0]['artistId'],
max_top_tracks=100)
else:
search = {}
search['topTracks'] = []
# Find the best artist we have, and then match songs to that artist
likely_artist, score = process.extractOne(name, self.artists)
if score < 70:
return False
for song_id, song in self.library.items():
if 'artist' in song and song['artist'].lower() == likely_artist.lower() and 'artistId' in song:
if not search['topTracks']: # First entry
# Copy artist details from the first song into the general artist response
try:
search['artistArtRef'] = song['artistArtRef'][0]['url']
except KeyError:
pass
search['name'] = song['artist']
search['artistId'] = song['artistId']
search['topTracks'].append(song)
random.shuffle(search['topTracks']) # This is all music, not top, but the user probably would prefer it shuffled.
if not search['topTracks']:
return False
return search
def get_album(self, name, artist_name=None):
if self.use_store:
if artist_name:
name = "%s %s" % (name, artist_name)
search = self._search("album", name)
if len(search) == 0:
return False
return self._api.get_album_info(search[0]['albumId'])
else:
search = {}
search['tracks'] = []
if artist_name:
artist_name, score = process.extractOne(artist_name, self.artists)
if score < 70:
return False
name, score = process.extractOne(name, self.albums)
if score < 70:
return False
for song_id, song in self.library.items():
if 'album' in song and song['album'].lower() == name.lower():
if not artist_name or ('artist' in song and song['artist'].lower() == artist_name.lower()):
if not search['tracks']: # First entry
search['albumArtist'] = song['albumArtist']
search['name'] = song['album']
try:
search['albumId'] = song['albumId']
except KeyError:
pass
search['tracks'].append(song)
if not search['tracks']:
return False
return search
def get_latest_album(self, artist_name=None):
search = self._search("artist", artist_name)
if len(search) == 0:
return False
artist_info = self._api.get_artist_info(search[0]['artistId'], include_albums=True)
album_info = artist_info['albums']
sorted_list = sorted(album_info.__iter__(), key=lambda s: s['year'], reverse=True)
for index, val in enumerate(sorted_list):
album_info = self._api.get_album_info(album_id=sorted_list[index]['albumId'], include_tracks=True)
if len(album_info['tracks']) >= 5:
return album_info
return False
def get_album_by_artist(self, artist_name, album_id=None):
search = self._search("artist", artist_name)
if len(search) == 0:
return False
artist_info = self._api.get_artist_info(search[0]['artistId'], include_albums=True)
album_info = artist_info['albums']
random.shuffle(album_info)
for index, val in enumerate(album_info):
album = self._api.get_album_info(album_id=album_info[index]['albumId'], include_tracks=True)
if album['albumId'] != album_id and len(album['tracks']) >= 5:
return album
return False
def get_song(self, name, artist_name=None, album_name=None):
if self.use_store:
if artist_name:
name = "%s %s" % (artist_name, name)
elif album_name:
name = "%s %s" % (album_name, name)
search = self._search("song", name)
if len(search) == 0:
return False
if album_name:
for i in range(0, len(search) - 1):
if album_name in search[i]['album']:
return search[i]
return search[0]
else:
search = {}
if not name:
return False
if artist_name:
artist_name, score = process.extractOne(artist_name, self.artists)
if score < 70:
return False
if album_name:
album_name, score = process.extractOne(album_name, self.albums)
if score < 70:
return False
possible_songs = {song_id: song['title'] for song_id, song in self.library.items() if (not artist_name or ('artist' in song and song['artist'].lower() == artist_name.lower())) and (not album_name or ('album' in song and song['album'].lower() == album_name.lower()))}
song, score, song_id = process.extractOne(name.lower(), possible_songs)
if score < 70:
return False
else:
return self.library[song_id]
def get_promoted_songs(self):
return self._api.get_promoted_songs()
def get_station(self, title, track_id=None, artist_id=None, album_id=None):
if artist_id is not None:
if album_id is not None:
if track_id is not None:
return self._api.create_station(title, track_id=track_id)
return self._api.create_station(title, album_id=album_id)
return self._api.create_station(title, artist_id=artist_id)
def get_station_tracks(self, station_id):
return self._api.get_station_tracks(station_id)
def get_google_stream_url(self, song_id):
return self._api.get_stream_url(song_id)
def get_stream_url(self, song_id):
return "%s/alexa/stream/%s" % (getenv('APP_URL'), song_id)
def get_thumbnail(self, artist_art):
return artist_art.replace("http://", "https://")
def get_all_user_playlist_contents(self):
return self._api.get_all_user_playlist_contents()
def get_all_songs(self):
return self._api.get_all_songs()
def rate_song(self, song, rating):
return self._api.rate_songs(song, rating)
def extract_track_info(self, track):
# When coming from a playlist, track info is nested under the "track"
# key
if 'track' in track:
track = track['track']
if self.use_store and 'storeId' in track:
return track, track['storeId']
elif 'id' in track:
return self.library[track['id']], track['id']
elif 'trackId' in track:
return self.library[track['trackId']], track['trackId']
else:
return None, None
def get_artist_album_list(self, artist_name):
search = self._search("artist", artist_name)
if len(search) == 0:
return "Unable to find the artist you requested."
artist_info = self._api.get_artist_info(search[0]['artistId'], include_albums=True)
album_list_text = "Here's the album listing for %s: " % artist_name
counter = 0
for index, val in enumerate(artist_info['albums']):
if counter > 25: # alexa will time out after 10 seconds if the list takes too long to iterate through
break
album_info = self._api.get_album_info(album_id=artist_info['albums'][index]['albumId'], include_tracks=True)
if len(album_info['tracks']) > 5:
counter += 1
album_list_text += (artist_info['albums'][index]['name']) + ", "
return album_list_text
def get_latest_artist_albums(self, artist_name):
search = self._search("artist", artist_name)
if len(search) == 0:
return False
artist_info = self._api.get_artist_info(search[0]['artistId'], include_albums=True)
album_list = artist_info['albums']
sorted_list = sorted(album_list.__iter__(), key=lambda s: s['year'], reverse=True)
speech_text = 'The latest albums by %s are ' % artist_name
counter = 0
for index, val in enumerate(sorted_list):
if counter > 5:
break
else:
album_info = self._api.get_album_info(album_id=sorted_list[index]['albumId'], include_tracks=True)
if len(album_info['tracks']) >= 5:
counter += 1
album_name = sorted_list[index]['name']
album_year = sorted_list[index]['year']
speech_text += '%s, released in %d, ' % (album_name, album_year)
return speech_text
def closest_match(self, request_name, all_matches, artist_name='', minimum_score=70):
# Give each match a score based on its similarity to the requested
# name
self.log('Finding closest match...')
best_match = None
request_name = request_name.lower() + artist_name.lower()
scored_matches = []
for i, match in enumerate(all_matches):
try:
name = match['name'].lower()
except (KeyError, TypeError):
i = match
name = all_matches[match]['title'].lower()
if artist_name != "":
name += all_matches[match]['artist'].lower()
scored_matches.append({
'index': i,
'name': name,
'score': fuzz.ratio(name, request_name)
})
sorted_matches = sorted(scored_matches, key=lambda a: a['score'], reverse=True)
try:
top_scoring = sorted_matches[0]
# Make sure we have a decent match (the score is n where 0 <= n <= 100)
if top_scoring['score'] >= minimum_score:
best_match = all_matches[top_scoring['index']]
except IndexError:
pass
self.log('Found %s...' % best_match)
return best_match
def get_genres(self, parent_genre_id=None):
return self._api.get_genres(parent_genre_id)
def increment_song_playcount(self, song_id, plays=1, playtime=None):
return self._api.increment_song_playcount(song_id, plays, playtime)
def get_song_data(self, song_id):
return self._api.get_track_info(song_id)
@classmethod
def generate_api(cls, **kwargs):
return cls(getenv('GOOGLE_EMAIL'), getenv('GOOGLE_PASSWORD'),
**kwargs)
class GoogleMusicManager(object):
def __init__(self):
"""Default construct""" #Main management Script
#This will scrape that data from a users account, peramiters can be set for downloading certains songs or entire playlists
#metadata is preserved as well as playlist or albumn structure
self.api = []
self.activeSongList = []
self.activePlayList = []
def Login(self, userName, userPassWord):
"""Login method to access you google play account"""
self.api = Mobileclient()
self.api.logout()
#reload(MusicLibraryManager)
if (self.api.login(userName, userPassWord,
Mobileclient.FROM_MAC_ADDRESS)):
print("You have been logged in")
else:
print("Seems the login is incorect")
def getAllRadioStations(self):
"""This will get all of the radiostations that I have saved"""
print("Collecting Radio Station Contents")
#Generate base directory
#check to see if a playlist directory exists
baseDir = os.getcwd() + '/RadioStations'
#if not os.path.exists(baseDir):
# raise ValueError(baseDir + " does not exist")
self.activeRadioStations = self.api.get_all_stations()
for Station in self.activeRadioStations:
print("Found a RadioStation called : " + Station['name'])
#get radioContent
RadioStationSongs = self.api.get_station_tracks(
Station['id'], 1000, {})
print("It contains " + str(len(RadioStationSongs)) + " Songs")
print("downloading songs")
stationName = Station['name']
#create a dir for the radiostation
activeDir = baseDir + "/" + stationName + "/"
#check to see if the radio station folder exists
if not os.path.exists(activeDir):
#radiostation doesn't exist so we create it
os.makedirs(activeDir)
for Song in RadioStationSongs:
print(str(Song))
if not os.path.exists(activeDir + Song['title'] + ".mp3"):
#it doesn't exists in the playlist yet, so we need to add it
songTitle = Song['title']
streamUrl = self.api.get_stream_url(Song['storeId'])
urllib.urlretrieve(streamUrl,
activeDir + songTitle + '.mp3')
song = eyed3.load(activeDir + songTitle + '.mp3')
song.initTag()
song.tag.save()
song = eyed3.load(activeDir + songTitle + '.mp3')
if "title" in Song:
song.tag.title = Song['title']
if "artist" in Song:
song.tag.artist = Song['artist']
if "album" in Song:
song.tag.album = Song['album']
#song.tag.year = currentSong['year']
if "genre" in song.tag:
song.tag.genre = Song['genre']
if "trackNumber" in Song:
song.tag.trackNumber = Song['trackNumber']
#song.tag.album = song['album']
#print song.tag.version
song.tag.save()
#print song.tag
#for song in self.activeSongList:
def getAllPlaylists(self):
"""Gets all of the users playlists that they have created"""
print("Getting all PLaylist contents")
self.activePlayList = self.api.get_all_user_playlist_contents()
baseDir = os.getcwd() + '/Playlists'
for Playlist in self.activePlayList:
playlistName = Playlist['name']
print(playlistName)
playlistSongs = Playlist['tracks']
activeDir = baseDir + '/' + playlistName + '/'
if not os.path.exists(activeDir):
os.makedirs(activeDir)
for Song in playlistSongs:
#print Song
if 'track' in Song:
activeSong = Song['track']
print('getting song : ' + activeSong['title'])
if not os.path.exists(activeDir + activeSong['title'] +
'mp3'):
#it doesn't exists in the playlist yet, so we need to add it
songTitle = activeSong['title']
streamUrl = self.api.get_stream_url(
activeSong['storeId'])
urllib.request.urlretrieve(
streamUrl, activeDir + songTitle + '.mp3')
song = eyed3.load(activeDir + songTitle + '.mp3')
song.initTag()
song.tag.save()
song = eyed3.load(activeDir + songTitle + '.mp3')
if "title" in activeSong:
song.tag.title = activeSong['title']
if "artist" in activeSong:
song.tag.artist = activeSong['artist']
if "album" in activeSong:
song.tag.album = activeSong['album']
#song.tag.year = currentSong['year']
if "genre" in activeSong:
song.tag.genre = activeSong['genre']
if "trackNumber" in activeSong:
song.tag.trackNumber = activeSong['trackNumber']
#song.tag.album = song['album']
#print song.tag.version
song.tag.save()
def getAllSongs(self):
"""Get all songs that the user has listen too that are associated with the account"""
print("Getting all Songs")
self.activeSongList = self.api.get_all_songs(False)
#print str(self.activeSongList.count)
baseDir = os.getcwd() + '/Music'
print("Grabbed " + str(len(self.activeSongList)) + " Songs")
#smallList = self.activeSongList[:3]
for currentSong in self.activeSongList:
#currentSong = self.activeSongList[0]
#create a location sting for where the song will be saved.
#check artist path
artistPath = currentSong['artist'].strip().replace('/', '')
albumPath = currentSong['album'].strip().replace('/', '')
songTitle = currentSong['title'].replace('/', '')
print(artistPath + " " + albumPath)
songPath = '/' + artistPath + '/' + albumPath + "/"
if os.path.exists(baseDir + songPath):
print("Folder Structure exists")
else:
print("Folder Structure does not exist")
if not os.path.exists(artistPath):
os.makedirs(baseDir + songPath)
print("created artitst and alartistPathbumn folder")
else:
os.makedirs(baseDir + songPath)
print(os.path.isfile(baseDir + songPath + songTitle + '.mp3'))
print(baseDir + songPath + songTitle + '.mp3')
if not os.path.isfile(baseDir + songPath + songTitle + '.mp3'):
#get stream url
streamUrl = self.api.get_stream_url(currentSong['id'])
urllib.request.urlretrieve(
streamUrl, baseDir + songPath + songTitle + '.mp3')
song = eyed3.load(baseDir + songPath + songTitle + '.mp3')
song.initTag()
song.tag.save()
song = eyed3.load(baseDir + songPath + songTitle + '.mp3')
song.tag.title = currentSong['title']
song.tag.artist = currentSong['artist']
song.tag.album = currentSong['album']
#song.tag.year = currentSong['year']
if 'genre' in currentSong:
song.tag.genre = currentSong['genre']
song.tag.trackNumber = currentSong['trackNumber']
#song.tag.album = song['album']
#print song.tag.version
song.tag.save()
#print song.tag
#for song in self.activeSongList:
else:
song = eyed3.load(baseDir + songPath + songTitle + '.mp3')
song.initTag()
song.tag.save()
song = eyed3.load(baseDir + songPath + songTitle + '.mp3')
song.tag.title = currentSong['title']
song.tag.artist = currentSong['artist']
song.tag.album = currentSong['album']
if 'genre' in currentSong:
song.tag.genre = currentSong['genre']
#song.tag.year = currentSong['year']
song.tag.trackNumber = currentSong['trackNumber']
#song.tag.album = song['album']
#print song.tag.version
song.tag.save()
def Logout(self):
self.api.logout()
def updateSongs(self):
"""Update locally stored music with any newly listened to or added"""
def getPlaylist(self, playlistName):
"""Gets a specific playlist by Name"""
print("Getting " + playlistName)
class tizgmusicproxy(object):
"""A class for logging into a Google Play Music account and retrieving song
URLs.
"""
all_songs_album_title = "All Songs"
thumbs_up_playlist_name = "Thumbs Up"
# pylint: disable=too-many-instance-attributes,too-many-public-methods
def __init__(self, email, password, device_id):
self.__gmusic = Mobileclient()
self.__email = email
self.__device_id = device_id
self.logged_in = False
self.queue = list()
self.queue_index = -1
self.play_queue_order = list()
self.play_modes = TizEnumeration(["NORMAL", "SHUFFLE"])
self.current_play_mode = self.play_modes.NORMAL
self.now_playing_song = None
userdir = os.path.expanduser('~')
tizconfig = os.path.join(userdir,
".config/tizonia/." + email + ".auth_token")
auth_token = ""
if os.path.isfile(tizconfig):
with open(tizconfig, "r") as f:
auth_token = pickle.load(f)
if auth_token:
# 'Keep track of the auth token' workaround. See:
# https://github.com/diraimondo/gmusicproxy/issues/34#issuecomment-147359198
print_msg("[Google Play Music] [Authenticating] : " \
"'with cached auth token'")
self.__gmusic.android_id = device_id
self.__gmusic.session._authtoken = auth_token
self.__gmusic.session.is_authenticated = True
try:
self.__gmusic.get_registered_devices()
except CallFailure:
# The token has expired. Reset the client object
print_wrn("[Google Play Music] [Authenticating] : " \
"'auth token expired'")
self.__gmusic = Mobileclient()
auth_token = ""
if not auth_token:
attempts = 0
print_nfo("[Google Play Music] [Authenticating] : " \
"'with user credentials'")
while not self.logged_in and attempts < 3:
self.logged_in = self.__gmusic.login(email, password,
device_id)
attempts += 1
with open(tizconfig, "a+") as f:
f.truncate()
pickle.dump(self.__gmusic.session._authtoken, f)
self.library = CaseInsensitiveDict()
self.song_map = CaseInsensitiveDict()
self.playlists = CaseInsensitiveDict()
self.stations = CaseInsensitiveDict()
def logout(self):
""" Reset the session to an unauthenticated, default state.
"""
self.__gmusic.logout()
def set_play_mode(self, mode):
""" Set the playback mode.
:param mode: curren tvalid values are "NORMAL" and "SHUFFLE"
"""
self.current_play_mode = getattr(self.play_modes, mode)
self.__update_play_queue_order()
def current_song_title_and_artist(self):
""" Retrieve the current track's title and artist name.
"""
logging.info("current_song_title_and_artist")
song = self.now_playing_song
if song:
title = to_ascii(self.now_playing_song.get('title'))
artist = to_ascii(self.now_playing_song.get('artist'))
logging.info("Now playing %s by %s", title, artist)
return artist, title
else:
return '', ''
def current_song_album_and_duration(self):
""" Retrieve the current track's album and duration.
"""
logging.info("current_song_album_and_duration")
song = self.now_playing_song
if song:
album = to_ascii(self.now_playing_song.get('album'))
duration = to_ascii \
(self.now_playing_song.get('durationMillis'))
logging.info("album %s duration %s", album, duration)
return album, int(duration)
else:
return '', 0
def current_track_and_album_total(self):
"""Return the current track number and the total number of tracks in the
album, if known.
"""
logging.info("current_track_and_album_total")
song = self.now_playing_song
track = 0
total = 0
if song:
try:
track = self.now_playing_song['trackNumber']
total = self.now_playing_song['totalTrackCount']
logging.info("track number %s total tracks %s", track, total)
except KeyError:
logging.info("trackNumber or totalTrackCount : not found")
else:
logging.info("current_song_track_number_"
"and_total_tracks : not found")
return track, total
def current_song_year(self):
""" Return the current track's year of publication.
"""
logging.info("current_song_year")
song = self.now_playing_song
year = 0
if song:
try:
year = song['year']
logging.info("track year %s", year)
except KeyError:
logging.info("year : not found")
else:
logging.info("current_song_year : not found")
return year
def clear_queue(self):
""" Clears the playback queue.
"""
self.queue = list()
self.queue_index = -1
def enqueue_tracks(self, arg):
""" Search the user's library for tracks and add
them to the playback queue.
:param arg: a track search term
"""
try:
songs = self.__gmusic.get_all_songs()
track_hits = list()
for song in songs:
song_title = song['title']
if arg.lower() in song_title.lower():
track_hits.append(song)
print_nfo("[Google Play Music] [Track] '{0}'." \
.format(to_ascii(song_title)))
if not len(track_hits):
print_wrn("[Google Play Music] '{0}' not found. "\
"Feeling lucky?." \
.format(arg.encode('utf-8')))
random.seed()
track_hits = random.sample(songs, MAX_TRACKS)
for hit in track_hits:
song_title = hit['title']
print_nfo("[Google Play Music] [Track] '{0}'." \
.format(to_ascii(song_title)))
if not len(track_hits):
raise KeyError
tracks_added = self.__enqueue_tracks(track_hits)
logging.info("Added %d tracks from %s to queue", \
tracks_added, arg)
self.__update_play_queue_order()
except KeyError:
raise KeyError("Track not found : {0}".format(arg))
def enqueue_artist(self, arg):
""" Search the user's library for tracks from the given artist and add
them to the playback queue.
:param arg: an artist
"""
try:
self.__update_local_library()
artist = None
artist_dict = None
if arg not in self.library.keys():
for name, art in self.library.iteritems():
if arg.lower() in name.lower():
artist = name
artist_dict = art
if arg.lower() != name.lower():
print_wrn("[Google Play Music] '{0}' not found. " \
"Playing '{1}' instead." \
.format(arg.encode('utf-8'), \
name.encode('utf-8')))
break
if not artist:
# Play some random artist from the library
random.seed()
artist = random.choice(self.library.keys())
artist_dict = self.library[artist]
print_wrn("[Google Play Music] '{0}' not found. "\
"Feeling lucky?." \
.format(arg.encode('utf-8')))
else:
artist = arg
artist_dict = self.library[arg]
tracks_added = 0
for album in artist_dict:
tracks_added += self.__enqueue_tracks(artist_dict[album])
print_wrn("[Google Play Music] Playing '{0}'." \
.format(to_ascii(artist)))
self.__update_play_queue_order()
except KeyError:
raise KeyError("Artist not found : {0}".format(arg))
def enqueue_album(self, arg):
""" Search the user's library for albums with a given name and add
them to the playback queue.
"""
try:
self.__update_local_library()
album = None
artist = None
tentative_album = None
tentative_artist = None
for library_artist in self.library:
for artist_album in self.library[library_artist]:
print_nfo("[Google Play Music] [Album] '{0}'." \
.format(to_ascii(artist_album)))
if not album:
if arg.lower() == artist_album.lower():
album = artist_album
artist = library_artist
break
if not tentative_album:
if arg.lower() in artist_album.lower():
tentative_album = artist_album
tentative_artist = library_artist
if album:
break
if not album and tentative_album:
album = tentative_album
artist = tentative_artist
print_wrn("[Google Play Music] '{0}' not found. " \
"Playing '{1}' instead." \
.format(arg.encode('utf-8'), \
album.encode('utf-8')))
if not album:
# Play some random album from the library
random.seed()
artist = random.choice(self.library.keys())
album = random.choice(self.library[artist].keys())
print_wrn("[Google Play Music] '{0}' not found. "\
"Feeling lucky?." \
.format(arg.encode('utf-8')))
if not album:
raise KeyError("Album not found : {0}".format(arg))
self.__enqueue_tracks(self.library[artist][album])
print_wrn("[Google Play Music] Playing '{0}'." \
.format(to_ascii(album)))
self.__update_play_queue_order()
except KeyError:
raise KeyError("Album not found : {0}".format(arg))
def enqueue_playlist(self, arg):
"""Search the user's library for playlists with a given name
and add the tracks of the first match to the playback queue.
Requires Unlimited subscription.
"""
try:
self.__update_local_library()
self.__update_playlists()
self.__update_playlists_unlimited()
playlist = None
playlist_name = None
for name, plist in self.playlists.items():
print_nfo("[Google Play Music] [Playlist] '{0}'." \
.format(to_ascii(name)))
if arg not in self.playlists.keys():
for name, plist in self.playlists.iteritems():
if arg.lower() in name.lower():
playlist = plist
playlist_name = name
if arg.lower() != name.lower():
print_wrn("[Google Play Music] '{0}' not found. " \
"Playing '{1}' instead." \
.format(arg.encode('utf-8'), \
to_ascii(name)))
break
else:
playlist_name = arg
playlist = self.playlists[arg]
random.seed()
x = 0
while (not playlist or not len(playlist)) and x < 3:
x += 1
# Play some random playlist from the library
playlist_name = random.choice(self.playlists.keys())
playlist = self.playlists[playlist_name]
print_wrn("[Google Play Music] '{0}' not found or found empty. "\
"Feeling lucky?." \
.format(arg.encode('utf-8')))
if not len(playlist):
raise KeyError
self.__enqueue_tracks(playlist)
print_wrn("[Google Play Music] Playing '{0}'." \
.format(to_ascii(playlist_name)))
self.__update_play_queue_order()
except KeyError:
raise KeyError(
"Playlist not found or found empty : {0}".format(arg))
def enqueue_podcast(self, arg):
"""Search Google Play Music for a podcast series and add its tracks to the
playback queue ().
Requires Unlimited subscription.
"""
print_msg("[Google Play Music] [Retrieving podcasts] : '{0}'. " \
.format(self.__email))
try:
self.__enqueue_podcast(arg)
if not len(self.queue):
raise KeyError
logging.info("Added %d episodes from '%s' to queue", \
len(self.queue), arg)
self.__update_play_queue_order()
except KeyError:
raise KeyError("Podcast not found : {0}".format(arg))
except CallFailure:
raise RuntimeError("Operation requires an Unlimited subscription.")
def enqueue_station_unlimited(self, arg):
"""Search the user's library for a station with a given name
and add its tracks to the playback queue.
Requires Unlimited subscription.
"""
try:
# First try to find a suitable station in the user's library
self.__enqueue_user_station_unlimited(arg)
if not len(self.queue):
# If no suitable station is found in the user's library, then
# search google play unlimited for a potential match.
self.__enqueue_station_unlimited(arg)
if not len(self.queue):
raise KeyError
except KeyError:
raise KeyError("Station not found : {0}".format(arg))
def enqueue_genre_unlimited(self, arg):
"""Search Unlimited for a genre with a given name and add its
tracks to the playback queue.
Requires Unlimited subscription.
"""
print_msg("[Google Play Music] [Retrieving genres] : '{0}'. " \
.format(self.__email))
try:
all_genres = list()
root_genres = self.__gmusic.get_genres()
second_tier_genres = list()
for root_genre in root_genres:
second_tier_genres += self.__gmusic.get_genres(
root_genre['id'])
all_genres += root_genres
all_genres += second_tier_genres
for genre in all_genres:
print_nfo("[Google Play Music] [Genre] '{0}'." \
.format(to_ascii(genre['name'])))
genre = dict()
if arg not in all_genres:
genre = next((g for g in all_genres \
if arg.lower() in to_ascii(g['name']).lower()), \
None)
tracks_added = 0
while not tracks_added:
if not genre and len(all_genres):
# Play some random genre from the search results
random.seed()
genre = random.choice(all_genres)
print_wrn("[Google Play Music] '{0}' not found. "\
"Feeling lucky?." \
.format(arg.encode('utf-8')))
genre_name = genre['name']
genre_id = genre['id']
station_id = self.__gmusic.create_station(genre_name, \
None, None, None, genre_id)
num_tracks = MAX_TRACKS
tracks = self.__gmusic.get_station_tracks(
station_id, num_tracks)
tracks_added = self.__enqueue_tracks(tracks)
logging.info("Added %d tracks from %s to queue", tracks_added,
genre_name)
if not tracks_added:
# This will produce another iteration in the loop
genre = None
print_wrn("[Google Play Music] Playing '{0}'." \
.format(to_ascii(genre['name'])))
self.__update_play_queue_order()
except KeyError:
raise KeyError("Genre not found : {0}".format(arg))
except CallFailure:
raise RuntimeError("Operation requires an Unlimited subscription.")
def enqueue_situation_unlimited(self, arg):
"""Search Unlimited for a situation with a given name and add its
tracks to the playback queue.
Requires Unlimited subscription.
"""
print_msg("[Google Play Music] [Retrieving situations] : '{0}'. " \
.format(self.__email))
try:
self.__enqueue_situation_unlimited(arg)
if not len(self.queue):
raise KeyError
logging.info("Added %d tracks from %s to queue", \
len(self.queue), arg)
except KeyError:
raise KeyError("Situation not found : {0}".format(arg))
except CallFailure:
raise RuntimeError("Operation requires an Unlimited subscription.")
def enqueue_artist_unlimited(self, arg):
"""Search Unlimited for an artist and add the artist's 200 top tracks to the
playback queue.
Requires Unlimited subscription.
"""
try:
artist = self.__gmusic_search(arg, 'artist')
include_albums = False
max_top_tracks = MAX_TRACKS
max_rel_artist = 0
artist_tracks = dict()
if artist:
artist_tracks = self.__gmusic.get_artist_info \
(artist['artist']['artistId'],
include_albums, max_top_tracks,
max_rel_artist)['topTracks']
if not artist_tracks:
raise KeyError
for track in artist_tracks:
song_title = track['title']
print_nfo("[Google Play Music] [Track] '{0}'." \
.format(to_ascii(song_title)))
tracks_added = self.__enqueue_tracks(artist_tracks)
logging.info("Added %d tracks from %s to queue", \
tracks_added, arg)
self.__update_play_queue_order()
except KeyError:
raise KeyError("Artist not found : {0}".format(arg))
except CallFailure:
raise RuntimeError("Operation requires an Unlimited subscription.")
def enqueue_album_unlimited(self, arg):
"""Search Unlimited for an album and add its tracks to the
playback queue.
Requires Unlimited subscription.
"""
try:
album = self.__gmusic_search(arg, 'album')
album_tracks = dict()
if album:
album_tracks = self.__gmusic.get_album_info \
(album['album']['albumId'])['tracks']
if not album_tracks:
raise KeyError
print_wrn("[Google Play Music] Playing '{0}'." \
.format((album['album']['name']).encode('utf-8')))
tracks_added = self.__enqueue_tracks(album_tracks)
logging.info("Added %d tracks from %s to queue", \
tracks_added, arg)
self.__update_play_queue_order()
except KeyError:
raise KeyError("Album not found : {0}".format(arg))
except CallFailure:
raise RuntimeError("Operation requires an Unlimited subscription.")
def enqueue_tracks_unlimited(self, arg):
""" Search Unlimited for a track name and add all the matching tracks
to the playback queue.
Requires Unlimited subscription.
"""
print_msg("[Google Play Music] [Retrieving library] : '{0}'. " \
.format(self.__email))
try:
max_results = MAX_TRACKS
track_hits = self.__gmusic.search(arg, max_results)['song_hits']
if not len(track_hits):
# Do another search with an empty string
track_hits = self.__gmusic.search("", max_results)['song_hits']
print_wrn("[Google Play Music] '{0}' not found. "\
"Feeling lucky?." \
.format(arg.encode('utf-8')))
tracks = list()
for hit in track_hits:
tracks.append(hit['track'])
tracks_added = self.__enqueue_tracks(tracks)
logging.info("Added %d tracks from %s to queue", \
tracks_added, arg)
self.__update_play_queue_order()
except KeyError:
raise KeyError("Playlist not found : {0}".format(arg))
except CallFailure:
raise RuntimeError("Operation requires an Unlimited subscription.")
def enqueue_playlist_unlimited(self, arg):
"""Search Unlimited for a playlist name and add all its tracks to the
playback queue.
Requires Unlimited subscription.
"""
print_msg("[Google Play Music] [Retrieving playlists] : '{0}'. " \
.format(self.__email))
try:
playlist_tracks = list()
playlist_hits = self.__gmusic_search(arg, 'playlist')
if playlist_hits:
playlist = playlist_hits['playlist']
playlist_contents = self.__gmusic.get_shared_playlist_contents(
playlist['shareToken'])
else:
raise KeyError
print_nfo("[Google Play Music] [Playlist] '{}'." \
.format(playlist['name']).encode('utf-8'))
for item in playlist_contents:
print_nfo("[Google Play Music] [Playlist Track] '{} by {} (Album: {}, {})'." \
.format((item['track']['title']).encode('utf-8'),
(item['track']['artist']).encode('utf-8'),
(item['track']['album']).encode('utf-8'),
(item['track']['year'])))
track = item['track']
playlist_tracks.append(track)
if not playlist_tracks:
raise KeyError
tracks_added = self.__enqueue_tracks(playlist_tracks)
logging.info("Added %d tracks from %s to queue", \
tracks_added, arg)
self.__update_play_queue_order()
except KeyError:
raise KeyError("Playlist not found : {0}".format(arg))
except CallFailure:
raise RuntimeError("Operation requires an Unlimited subscription.")
def enqueue_promoted_tracks_unlimited(self):
""" Retrieve the url of the next track in the playback queue.
"""
try:
tracks = self.__gmusic.get_promoted_songs()
count = 0
for track in tracks:
store_track = self.__gmusic.get_track_info(track['storeId'])
if u'id' not in store_track.keys():
store_track[u'id'] = store_track['storeId']
self.queue.append(store_track)
count += 1
if count == 0:
print_wrn("[Google Play Music] Operation requires " \
"an Unlimited subscription.")
logging.info("Added %d Unlimited promoted tracks to queue", \
count)
self.__update_play_queue_order()
except CallFailure:
raise RuntimeError("Operation requires an Unlimited subscription.")
def next_url(self):
""" Retrieve the url of the next track in the playback queue.
"""
if len(self.queue):
self.queue_index += 1
if (self.queue_index < len(self.queue)) \
and (self.queue_index >= 0):
next_song = self.queue[self.play_queue_order[self.queue_index]]
return self.__retrieve_track_url(next_song)
else:
self.queue_index = -1
return self.next_url()
else:
return ''
def prev_url(self):
""" Retrieve the url of the previous track in the playback queue.
"""
if len(self.queue):
self.queue_index -= 1
if (self.queue_index < len(self.queue)) \
and (self.queue_index >= 0):
prev_song = self.queue[self.play_queue_order[self.queue_index]]
return self.__retrieve_track_url(prev_song)
else:
self.queue_index = len(self.queue)
return self.prev_url()
else:
return ''
def __update_play_queue_order(self):
""" Update the queue playback order.
A sequential order is applied if the current play mode is "NORMAL" or a
random order if current play mode is "SHUFFLE"
"""
total_tracks = len(self.queue)
if total_tracks:
if not len(self.play_queue_order):
# Create a sequential play order, if empty
self.play_queue_order = range(total_tracks)
if self.current_play_mode == self.play_modes.SHUFFLE:
random.shuffle(self.play_queue_order)
print_nfo("[Google Play Music] [Tracks in queue] '{0}'." \
.format(total_tracks))
def __retrieve_track_url(self, song):
""" Retrieve a song url
"""
if song.get('episodeId'):
song_url = self.__gmusic.get_podcast_episode_stream_url(
song['episodeId'], self.__device_id)
else:
song_url = self.__gmusic.get_stream_url(song['id'],
self.__device_id)
try:
self.now_playing_song = song
return song_url
except AttributeError:
logging.info("Could not retrieve the song url!")
raise
def __update_local_library(self):
""" Retrieve the songs and albums from the user's library
"""
print_msg("[Google Play Music] [Retrieving library] : '{0}'. " \
.format(self.__email))
songs = self.__gmusic.get_all_songs()
self.playlists[self.thumbs_up_playlist_name] = list()
# Retrieve the user's song library
for song in songs:
if "rating" in song and song['rating'] == "5":
self.playlists[self.thumbs_up_playlist_name].append(song)
song_id = song['id']
song_artist = song['artist']
song_album = song['album']
self.song_map[song_id] = song
if song_artist == "":
song_artist = "Unknown Artist"
if song_album == "":
song_album = "Unknown Album"
if song_artist not in self.library:
self.library[song_artist] = CaseInsensitiveDict()
self.library[song_artist][self.all_songs_album_title] = list()
if song_album not in self.library[song_artist]:
self.library[song_artist][song_album] = list()
self.library[song_artist][song_album].append(song)
self.library[song_artist][self.all_songs_album_title].append(song)
# Sort albums by track number
for artist in self.library.keys():
logging.info("Artist : %s", to_ascii(artist))
for album in self.library[artist].keys():
logging.info(" Album : %s", to_ascii(album))
if album == self.all_songs_album_title:
sorted_album = sorted(self.library[artist][album],
key=lambda k: k['title'])
else:
sorted_album = sorted(
self.library[artist][album],
key=lambda k: k.get('trackNumber', 0))
self.library[artist][album] = sorted_album
def __update_stations_unlimited(self):
""" Retrieve stations (Unlimited)
"""
self.stations.clear()
stations = self.__gmusic.get_all_stations()
self.stations[u"I'm Feeling Lucky"] = 'IFL'
for station in stations:
station_name = station['name']
logging.info("station name : %s", to_ascii(station_name))
self.stations[station_name] = station['id']
def __enqueue_user_station_unlimited(self, arg):
""" Enqueue a user station (Unlimited)
"""
print_msg("[Google Play Music] [Station search "\
"in user's library] : '{0}'. " \
.format(self.__email))
self.__update_stations_unlimited()
station_name = arg
station_id = None
for name, st_id in self.stations.iteritems():
print_nfo("[Google Play Music] [Station] '{0}'." \
.format(to_ascii(name)))
if arg not in self.stations.keys():
for name, st_id in self.stations.iteritems():
if arg.lower() in name.lower():
station_id = st_id
station_name = name
break
else:
station_id = self.stations[arg]
num_tracks = MAX_TRACKS
tracks = list()
if station_id:
try:
tracks = self.__gmusic.get_station_tracks(station_id, \
num_tracks)
except KeyError:
raise RuntimeError("Operation requires an "
"Unlimited subscription.")
tracks_added = self.__enqueue_tracks(tracks)
if tracks_added:
if arg.lower() != station_name.lower():
print_wrn("[Google Play Music] '{0}' not found. " \
"Playing '{1}' instead." \
.format(arg.encode('utf-8'), name.encode('utf-8')))
logging.info("Added %d tracks from %s to queue", tracks_added,
arg)
self.__update_play_queue_order()
else:
print_wrn("[Google Play Music] '{0}' has no tracks. " \
.format(station_name))
if not len(self.queue):
print_wrn("[Google Play Music] '{0}' " \
"not found in the user's library. " \
.format(arg.encode('utf-8')))
def __enqueue_station_unlimited(self,
arg,
max_results=MAX_TRACKS,
quiet=False):
"""Search for a station and enqueue all of its tracks (Unlimited)
"""
if not quiet:
print_msg("[Google Play Music] [Station search in "\
"Google Play Music] : '{0}'. " \
.format(arg.encode('utf-8')))
try:
station_name = arg
station_id = None
station = self.__gmusic_search(arg, 'station', max_results, quiet)
if station:
station = station['station']
station_name = station['name']
seed = station['seed']
seed_type = seed['seedType']
track_id = seed['trackId'] if seed_type == u'2' else None
artist_id = seed['artistId'] if seed_type == u'3' else None
album_id = seed['albumId'] if seed_type == u'4' else None
genre_id = seed['genreId'] if seed_type == u'5' else None
playlist_token = seed[
'playlistShareToken'] if seed_type == u'8' else None
curated_station_id = seed[
'curatedStationId'] if seed_type == u'9' else None
num_tracks = max_results
tracks = list()
try:
station_id \
= self.__gmusic.create_station(station_name, \
track_id, \
artist_id, \
album_id, \
genre_id, \
playlist_token, \
curated_station_id)
tracks \
= self.__gmusic.get_station_tracks(station_id, \
num_tracks)
except KeyError:
raise RuntimeError("Operation requires an "
"Unlimited subscription.")
tracks_added = self.__enqueue_tracks(tracks)
if tracks_added:
if not quiet:
print_wrn("[Google Play Music] [Station] : '{0}'." \
.format(station_name.encode('utf-8')))
logging.info("Added %d tracks from %s to queue", \
tracks_added, arg.encode('utf-8'))
self.__update_play_queue_order()
except KeyError:
raise KeyError("Station not found : {0}".format(arg))
def __enqueue_situation_unlimited(self, arg):
"""Search for a situation and enqueue all of its tracks (Unlimited)
"""
print_msg("[Google Play Music] [Situation search in "\
"Google Play Music] : '{0}'. " \
.format(arg.encode('utf-8')))
try:
situation_hits = self.__gmusic.search(arg)['situation_hits']
# If the search didn't return results, just do another search with
# an empty string
if not len(situation_hits):
situation_hits = self.__gmusic.search("")['situation_hits']
print_wrn("[Google Play Music] '{0}' not found. "\
"Feeling lucky?." \
.format(arg.encode('utf-8')))
# Try to find a "best result", if one exists
situation = next((hit for hit in situation_hits \
if 'best_result' in hit.keys() \
and hit['best_result'] == True), None)
num_tracks = MAX_TRACKS
# If there is no best result, then get a selection of tracks from
# each situation. At least we'll play some music.
if not situation and len(situation_hits):
max_results = num_tracks / len(situation_hits)
for hit in situation_hits:
situation = hit['situation']
print_nfo("[Google Play Music] [Situation] '{0} : {1}'." \
.format((hit['situation']['title']).encode('utf-8'),
(hit['situation']['description']).encode('utf-8')))
self.__enqueue_station_unlimited(situation['title'],
max_results, True)
elif situation:
# There is at list one sitution, enqueue its tracks.
situation = situation['situation']
max_results = num_tracks
self.__enqueue_station_unlimited(situation['title'],
max_results, True)
if not situation:
raise KeyError
except KeyError:
raise KeyError("Situation not found : {0}".format(arg))
def __enqueue_podcast(self, arg):
"""Search for a podcast series and enqueue all of its tracks.
"""
print_msg("[Google Play Music] [Podcast search in "\
"Google Play Music] : '{0}'. " \
.format(arg.encode('utf-8')))
try:
podcast_hits = self.__gmusic_search(arg,
'podcast',
10,
quiet=False)
if not podcast_hits:
print_wrn(
"[Google Play Music] [Podcast] 'Search returned zero results'."
)
print_wrn(
"[Google Play Music] [Podcast] 'Are you in a supported region "
"(currently only US and Canada) ?'")
# Use the first podcast retrieved. At least we'll play something.
podcast = dict()
if podcast_hits and len(podcast_hits):
podcast = podcast_hits['series']
episodes_added = 0
if podcast:
# There is a podcast, enqueue its episodes.
print_nfo("[Google Play Music] [Podcast] 'Playing '{0}' by {1}'." \
.format((podcast['title']).encode('utf-8'),
(podcast['author']).encode('utf-8')))
print_nfo("[Google Play Music] [Podcast] '{0}'." \
.format((podcast['description'][0:150]).encode('utf-8')))
series = self.__gmusic.get_podcast_series_info(
podcast['seriesId'])
episodes = series['episodes']
for episode in episodes:
print_nfo("[Google Play Music] [Podcast Episode] '{0} : {1}'." \
.format((episode['title']).encode('utf-8'),
(episode['description'][0:80]).encode('utf-8')))
episodes_added = self.__enqueue_tracks(episodes)
if not podcast or not episodes_added:
raise KeyError
except KeyError:
raise KeyError(
"Podcast not found or no episodes found: {0}".format(arg))
def __enqueue_tracks(self, tracks):
""" Add tracks to the playback queue
"""
count = 0
for track in tracks:
if u'id' not in track.keys() and track.get('storeId'):
track[u'id'] = track['storeId']
self.queue.append(track)
count += 1
return count
def __update_playlists(self):
""" Retrieve the user's playlists
"""
plists = self.__gmusic.get_all_user_playlist_contents()
for plist in plists:
plist_name = plist.get('name')
tracks = plist.get('tracks')
if plist_name and tracks:
logging.info("playlist name : %s", to_ascii(plist_name))
tracks.sort(key=itemgetter('creationTimestamp'))
self.playlists[plist_name] = list()
for track in tracks:
song_id = track.get('trackId')
if song_id:
song = self.song_map.get(song_id)
if song:
self.playlists[plist_name].append(song)
def __update_playlists_unlimited(self):
""" Retrieve shared playlists (Unlimited)
"""
plists_subscribed_to = [p for p in self.__gmusic.get_all_playlists() \
if p.get('type') == 'SHARED']
for plist in plists_subscribed_to:
share_tok = plist['shareToken']
playlist_items \
= self.__gmusic.get_shared_playlist_contents(share_tok)
plist_name = plist['name']
logging.info("shared playlist name : %s", to_ascii(plist_name))
self.playlists[plist_name] = list()
for item in playlist_items:
try:
song = item['track']
song['id'] = item['trackId']
self.playlists[plist_name].append(song)
except IndexError:
pass
def __gmusic_search(self,
query,
query_type,
max_results=MAX_TRACKS,
quiet=False):
""" Search Google Play (Unlimited)
"""
search_results = self.__gmusic.search(query, max_results)[query_type +
'_hits']
# This is a workaround. Some podcast results come without these two
# keys in the dictionary
if query_type == "podcast" and len(search_results) \
and not search_results[0].get('navigational_result'):
for res in search_results:
res[u'best_result'] = False
res[u'navigational_result'] = False
res[query_type] = res['series']
result = ''
if query_type != "playlist":
result = next((hit for hit in search_results \
if 'best_result' in hit.keys() \
and hit['best_result'] == True), None)
if not result and len(search_results):
secondary_hit = None
for hit in search_results:
name = ''
if hit[query_type].get('name'):
name = hit[query_type].get('name')
elif hit[query_type].get('title'):
name = hit[query_type].get('title')
if not quiet:
print_nfo("[Google Play Music] [{0}] '{1}'." \
.format(query_type.capitalize(),
(name).encode('utf-8')))
if query.lower() == \
to_ascii(name).lower():
result = hit
break
if query.lower() in \
to_ascii(name).lower():
secondary_hit = hit
if not result and secondary_hit:
result = secondary_hit
if not result and not len(search_results):
# Do another search with an empty string
search_results = self.__gmusic.search("")[query_type + '_hits']
if not result and len(search_results):
# Play some random result from the search results
random.seed()
result = random.choice(search_results)
if not quiet:
print_wrn("[Google Play Music] '{0}' not found. "\
"Feeling lucky?." \
.format(query.encode('utf-8')))
return result
class GMusicWrapper(object):
def __init__(self, username, password, logger=None):
self._api = Mobileclient()
self.logger = logger
success = self._api.login(
username, password,
getenv('ANDROID_ID', Mobileclient.FROM_MAC_ADDRESS))
if not success:
raise Exception("Unsuccessful login. Aborting!")
# Populate our library
self.library = {}
self.indexing_thread = threading.Thread(target=self.index_library)
self.indexing_thread.start()
def log(self, log_str):
self.logger.debug(log_str)
def _search(self, query_type, query):
try:
results = self._api.search(query)
except CallFailure:
return []
hits_key = "%s_hits" % query_type
if hits_key not in results:
return []
# Ugh, Google had to make this schema nonstandard...
if query_type == 'song':
query_type = 'track'
return [x[query_type] for x in results[hits_key]]
def is_indexing(self):
return self.indexing_thread.is_alive()
def index_library(self):
"""
Downloads the a list of every track in a user's library and populates
self.library with storeIds -> track definitions
"""
self.log('Fetching library...')
tracks = self.get_all_songs()
for track in tracks:
song_id = track['id']
self.library[song_id] = track
self.log('Fetching library...')
def get_artist(self, name):
"""
Fetches information about an artist given its name
"""
search = self._search("artist", name)
if len(search) == 0:
return False
return self._api.get_artist_info(search[0]['artistId'],
max_top_tracks=100)
def get_album(self, name, artist_name=None):
if artist_name:
name = "%s %s" % (name, artist_name)
search = self._search("album", name)
if len(search) == 0:
return False
return self._api.get_album_info(search[0]['albumId'])
def get_latest_album(self, artist_name=None):
search = self._search("artist", artist_name)
if len(search) == 0:
return False
artist_info = self._api.get_artist_info(search[0]['artistId'],
include_albums=True)
album_info = artist_info['albums']
sorted_list = sorted(album_info.__iter__(),
key=lambda s: s['year'],
reverse=True)
for index, val in enumerate(sorted_list):
album_info = self._api.get_album_info(
album_id=sorted_list[index]['albumId'], include_tracks=True)
if len(album_info['tracks']) >= 5:
return album_info
return False
def get_album_by_artist(self, artist_name, album_id=None):
search = self._search("artist", artist_name)
if len(search) == 0:
return False
artist_info = self._api.get_artist_info(search[0]['artistId'],
include_albums=True)
album_info = artist_info['albums']
random.shuffle(album_info)
for index, val in enumerate(album_info):
album = self._api.get_album_info(
album_id=album_info[index]['albumId'], include_tracks=True)
if album['albumId'] != album_id and len(album['tracks']) >= 5:
return album
return False
def get_song(self, name, artist_name=None, album_name=None):
if artist_name:
name = "%s %s" % (artist_name, name)
elif album_name:
name = "%s %s" % (album_name, name)
search = self._search("song", name)
if len(search) == 0:
return False
if album_name:
for i in range(0, len(search) - 1):
if album_name in search[i]['album']:
return search[i]
return search[0]
def get_promoted_songs(self):
return self._api.get_promoted_songs()
def get_station(self, title, track_id=None, artist_id=None, album_id=None):
if artist_id is not None:
if album_id is not None:
if track_id is not None:
return self._api.create_station(title, track_id=track_id)
return self._api.create_station(title, album_id=album_id)
return self._api.create_station(title, artist_id=artist_id)
def get_station_tracks(self, station_id):
return self._api.get_station_tracks(station_id)
def get_google_stream_url(self, song_id):
return self._api.get_stream_url(song_id)
def get_stream_url(self, song_id):
return "%s/alexa/stream/%s" % (getenv('APP_URL'), song_id)
def get_thumbnail(self, artist_art):
return artist_art.replace("http://", "https://")
def get_all_user_playlist_contents(self):
return self._api.get_all_user_playlist_contents()
def get_all_songs(self):
return self._api.get_all_songs()
def rate_song(self, song, rating):
return self._api.rate_songs(song, rating)
def extract_track_info(self, track):
# When coming from a playlist, track info is nested under the "track"
# key
if 'track' in track:
track = track['track']
if 'storeId' in track:
return track, track['storeId']
elif 'trackId' in track:
return self.library[track['trackId']], track['trackId']
else:
return None, None
def get_artist_album_list(self, artist_name):
search = self._search("artist", artist_name)
if len(search) == 0:
return "Unable to find the artist you requested."
artist_info = self._api.get_artist_info(search[0]['artistId'],
include_albums=True)
album_list_text = "Here's the album listing for %s: " % artist_name
counter = 0
for index, val in enumerate(artist_info['albums']):
if counter > 25: # alexa will time out after 10 seconds if the list takes too long to iterate through
break
album_info = self._api.get_album_info(
album_id=artist_info['albums'][index]['albumId'],
include_tracks=True)
if len(album_info['tracks']) > 5:
counter += 1
album_list_text += (
artist_info['albums'][index]['name']) + ", "
return album_list_text
def get_latest_artist_albums(self, artist_name):
search = self._search("artist", artist_name)
if len(search) == 0:
return False
artist_info = self._api.get_artist_info(search[0]['artistId'],
include_albums=True)
album_list = artist_info['albums']
sorted_list = sorted(album_list.__iter__(),
key=lambda s: s['year'],
reverse=True)
speech_text = 'The latest albums by %s are ' % artist_name
counter = 0
for index, val in enumerate(sorted_list):
if counter > 5:
break
else:
album_info = self._api.get_album_info(
album_id=sorted_list[index]['albumId'],
include_tracks=True)
if len(album_info['tracks']) >= 5:
counter += 1
album_name = sorted_list[index]['name']
album_year = sorted_list[index]['year']
speech_text += '%s, released in %d, ' % (album_name,
album_year)
return speech_text
def closest_match(self,
request_name,
all_matches,
artist_name='',
minimum_score=70):
# Give each match a score based on its similarity to the requested
# name
self.log('Fetching library...')
request_name = request_name.lower() + artist_name.lower()
scored_matches = []
for i, match in enumerate(all_matches):
try:
name = match['name'].lower()
except (KeyError, TypeError):
i = match
name = all_matches[match]['title'].lower()
if artist_name != "":
name += all_matches[match]['artist'].lower()
scored_matches.append({
'index': i,
'name': name,
'score': fuzz.ratio(name, request_name)
})
sorted_matches = sorted(scored_matches,
key=lambda a: a['score'],
reverse=True)
top_scoring = sorted_matches[0]
self.log('Fetching library...')
best_match = all_matches[top_scoring['index']]
# Make sure we have a decent match (the score is n where 0 <= n <= 100)
if top_scoring['score'] < minimum_score:
return None
return best_match
def get_genres(self, parent_genre_id=None):
return self._api.get_genres(parent_genre_id)
def increment_song_playcount(self, song_id, plays=1, playtime=None):
return self._api.increment_song_playcount(song_id, plays, playtime)
def get_song_data(self, song_id):
return self._api.get_track_info(song_id)
@classmethod
def generate_api(cls, **kwargs):
return cls(getenv('GOOGLE_EMAIL'), getenv('GOOGLE_PASSWORD'), **kwargs)
class GMusicWrapper:
def __init__(self, username, password, logger=None):
self._api = Mobileclient()
self.logger = logger
success = self._api.login(
username, password,
environ.get('ANDROID_ID', Mobileclient.FROM_MAC_ADDRESS))
if not success:
raise Exception("Unsuccessful login. Aborting!")
# Populate our library
self.library = {}
self.indexing_thread = threading.Thread(target=self.index_library)
self.indexing_thread.start()
def _search(self, query_type, query):
try:
results = self._api.search(query)
except CallFailure:
return []
hits_key = "%s_hits" % query_type
if hits_key not in results:
return []
# Ugh, Google had to make this schema nonstandard...
if query_type == 'song':
query_type = 'track'
return map(lambda x: x[query_type], results[hits_key])
def is_indexing(self):
return self.indexing_thread.is_alive()
def index_library(self):
"""
Downloads the a list of every track in a user's library and populates
self.library with storeIds -> track definitions
"""
self.logger.debug('Fetching library...')
tracks = self.get_all_songs()
for track in tracks:
song_id = track['id']
self.library[song_id] = track
self.logger.debug('Done! Discovered %d tracks.' % len(self.library))
def get_artist(self, name):
"""
Fetches information about an artist given its name
"""
search = self._search("artist", name)
if len(search) == 0:
return False
return self._api.get_artist_info(search[0]['artistId'],
max_top_tracks=100)
def get_album(self, name, artist_name=None):
if artist_name:
name = "%s %s" % (name, artist_name)
search = self._search("album", name)
if len(search) == 0:
return False
return self._api.get_album_info(search[0]['albumId'])
def get_song(self, name, artist_name=None):
if artist_name:
name = "%s %s" % (artist_name, name)
search = self._search("song", name)
if len(search) == 0:
return False
return search[0]
def get_station(self, title, artist_id=None):
if artist_id != None:
return self._api.create_station(title, artist_id=artist_id)
def get_station_tracks(self, station_id):
return self._api.get_station_tracks(station_id)
def get_google_stream_url(self, song_id):
return self._api.get_stream_url(song_id)
def get_stream_url(self, song_id):
return "%s/stream/%s" % (environ['APP_URL'], song_id)
def get_all_user_playlist_contents(self):
return self._api.get_all_user_playlist_contents()
def get_all_songs(self):
return self._api.get_all_songs()
def rate_song(self, song, rating):
return self._api.rate_songs(song, rating)
def extract_track_info(self, track):
# When coming from a playlist, track info is nested under the "track"
# key
if 'track' in track:
track = track['track']
if 'storeId' in track:
return (track, track['storeId'])
elif 'trackId' in track:
return (self.library[track['trackId']], track['trackId'])
else:
return (None, None)
def increment_song_playcount(self, song_id, plays=1, playtime=None):
return self._api.increment_song_playcount(song_id, plays, playtime)
def get_song_data(self, song_id):
return self._api.get_track_info(song_id)
@classmethod
def generate_api(cls, **kwargs):
return cls(environ['GOOGLE_EMAIL'], environ['GOOGLE_PASSWORD'],
**kwargs)
