class MobileClientWrapper(_Base):
def __init__(self, log=False, quiet=False):
self.api = Mobileclient(debug_logging=log)
self.api.logger.addHandler(logging.NullHandler())
self.print_ = safe_print if not quiet else lambda *args, **kwargs: None
def login(self, *args):
"""Authenticate the gmusicapi Mobileclient instance."""
if len(args) == 2:
username, password = args[0], args[1]
elif len(args) == 1:
username, password = args[0], None
else:
username, password = None, None
if not self.api.login(username, password):
if not username:
username = raw_input("Enter your Google username or email address: ")
if not password:
password = getpass.getpass(b"Enter your Google Music password: "******"Sorry, login failed.")
return False
self.print_("Successfully logged in.\n")
return True
def logout(self):
"""Log out the gmusicapi Mobileclient instance."""
self.api.logout()
def get_google_songs(self, filters=None, filter_all=False):
"""Load song list from Google Music library."""
self.print_("Loading Google Music songs...")
google_songs = []
filter_songs = []
songs = self.api.get_all_songs()
google_songs, filter_songs = match_filters_google(songs, filters, filter_all)
self.print_("Filtered {0} Google Music songs".format(len(filter_songs)))
self.print_("Loaded {0} Google Music songs\n".format(len(google_songs)))
return google_songs
def prompt_for_mc_auth():
"""Return a valid (user, pass, android_id) tuple by continually
prompting the user."""
print("These tests will never delete or modify your music."
"\n\n"
"If the tests fail, you *might* end up with a test"
" song/playlist in your library, though."
"\n")
mclient = Mobileclient()
valid_mc_auth = False
while not valid_mc_auth:
print()
email = input("Email: ")
passwd = getpass()
try:
android_id = os.environ['GM_AA_D_ID']
except KeyError:
android_id = input("Device ID ('mac' for FROM_MAC_ADDRESS): ")
if android_id == "mac":
android_id = Mobileclient.FROM_MAC_ADDRESS
if not android_id:
print('a device id must be provided')
sys.exit(1)
valid_mc_auth = mclient.login(email, passwd, android_id)
return email, passwd, android_id
def prompt_for_mc_auth():
"""Return a valid (user, pass, android_id) tuple by continually
prompting the user."""
print("These tests will never delete or modify your music."
"\n\n"
"If the tests fail, you *might* end up with a test"
" song/playlist in your library, though."
"\n")
mclient = Mobileclient()
valid_mc_auth = False
while not valid_mc_auth:
print()
email = input("Email: ")
passwd = getpass()
try:
android_id = os.environ['GM_AA_D_ID']
except KeyError:
android_id = input("Device ID ('mac' for FROM_MAC_ADDRESS): ")
if android_id == "mac":
android_id = Mobileclient.FROM_MAC_ADDRESS
if not android_id:
print('a device id must be provided')
sys.exit(1)
valid_mc_auth = mclient.login(email, passwd, android_id)
return email, passwd, android_id
def create_api_client(self):
client = Mobileclient()
success = client.login(config.EMAIL, config.PASSWORD,
Mobileclient.FROM_MAC_ADDRESS)
if not success:
raise Exception("Failed to login API client")
print("Logged in API client")
return client
def exportlib(user, password):
"""Logs into Google Music and exports the user's
library to a file called 'export.json'.
"""
keys = ['comment', 'rating', 'composer', 'year', 'album',
'albumArtist', 'title', 'totalDiscCount', 'trackNumber',
'discNumber', 'totalTrackCount', 'estimatedSize',
'beatsPerMinute', 'genre', 'playCount', 'artist',
'durationMillis']
client = Mobileclient()
client.login(user, password)
with open('export.json', 'w+') as out:
for songs in client.get_all_songs(incremental=True):
for song in songs:
pruned = select_keys(song, keys)
print(json.dumps(pruned), file=out)
class GMusic(object):
def __init__(self, user, password):
self.client = Mobileclient()
self.client.login(user, password, Mobileclient.FROM_MAC_ADDRESS)
def genTracks(self):
for chunk in self.client.get_all_songs(incremental=True):
for track in chunk:
yield track
def findTrack(self, rdio_track, keys=('artist', 'album', 'name',)):
if not keys:
return
results = self.client.search_all_access(' '.join(rdio_track[k] for k in keys))['song_hits']
if not results:
return self.findTrack(rdio_track, keys[1:])
# FIXME: is the best match always first?
best_match = results[0]
return best_match['track']
def addTrack(self, google_track):
self.client.add_aa_track(google_track['nid'])
class _GP(object):
"""
Interface to :class:`gmusicapi.Mobileclient`. Implements
asynchronous API calls, caching and some other perks.
Singleton.
"""
# TODO: Switch to urwid signals for more explicitness?
caches_invalidated = EventHook()
def __init__(self):
# self.is_debug = os.getenv('CLAY_DEBUG')
self.mobile_client = Mobileclient()
self.mobile_client._make_call = self._make_call_proxy(
self.mobile_client._make_call)
# if self.is_debug:
# self.debug_file = open('/tmp/clay-api-log.json', 'w')
# self._last_call_index = 0
self.cached_tracks = None
self.cached_liked_songs = LikedSongs()
self.cached_playlists = None
self.cached_stations = None
self.invalidate_caches()
self.auth_state_changed = EventHook()
def _make_call_proxy(self, func):
"""
Return a function that wraps *fn* and logs args & return values.
"""
def _make_call(protocol, *args, **kwargs):
"""
Wrapper function.
"""
logger.debug('GP::{}(*{}, **{})'.format(protocol.__name__, args,
kwargs))
result = func(protocol, *args, **kwargs)
# self._last_call_index += 1
# call_index = self._last_call_index
# self.debug_file.write(json.dumps([
# call_index,
# protocol.__name__, args, kwargs,
# result
# ]) + '\n')
# self.debug_file.flush()
return result
return _make_call
def invalidate_caches(self):
"""
Clear cached tracks & playlists & stations.
"""
self.cached_tracks = None
self.cached_playlists = None
self.cached_stations = None
self.caches_invalidated.fire()
@synchronized
def login(self, email, password, device_id, **_):
"""
Log in into Google Play Music.
"""
self.mobile_client.logout()
self.invalidate_caches()
# prev_auth_state = self.is_authenticated
result = self.mobile_client.login(email, password, device_id)
# if prev_auth_state != self.is_authenticated:
self.auth_state_changed.fire(self.is_authenticated)
return result
login_async = asynchronous(login)
@synchronized
def use_authtoken(self, authtoken, device_id):
"""
Try to use cached token to log into Google Play Music.
"""
# pylint: disable=protected-access
self.mobile_client.session._authtoken = authtoken
self.mobile_client.session.is_authenticated = True
self.mobile_client.android_id = device_id
del self.mobile_client.is_subscribed
if self.mobile_client.is_subscribed:
self.auth_state_changed.fire(True)
return True
del self.mobile_client.is_subscribed
self.mobile_client.android_id = None
self.mobile_client.session.is_authenticated = False
self.auth_state_changed.fire(False)
return False
use_authtoken_async = asynchronous(use_authtoken)
def get_authtoken(self):
"""
Return currently active auth token.
"""
# pylint: disable=protected-access
return self.mobile_client.session._authtoken
@synchronized
def get_all_tracks(self):
"""
Cache and return all tracks from "My library".
Each track will have "id" and "storeId" keys.
"""
if self.cached_tracks:
return self.cached_tracks
data = self.mobile_client.get_all_songs()
self.cached_tracks = Track.from_data(data, Track.SOURCE_LIBRARY, True)
return self.cached_tracks
get_all_tracks_async = asynchronous(get_all_tracks)
def get_stream_url(self, stream_id):
"""
Returns playable stream URL of track by id.
"""
return self.mobile_client.get_stream_url(stream_id)
get_stream_url_async = asynchronous(get_stream_url)
def increment_song_playcount(self, track_id):
"""
Increments the playcount of the song given by track_id
by one.
"""
return gp.mobile_client.increment_song_playcount(track_id)
increment_song_playcount_async = asynchronous(increment_song_playcount)
@synchronized
def get_all_user_station_contents(self, **_):
"""
Return list of :class:`.Station` instances.
"""
if self.cached_stations:
return self.cached_stations
self.get_all_tracks()
self.cached_stations = Station.from_data(
self.mobile_client.get_all_stations(), True)
return self.cached_stations
get_all_user_station_contents_async = ( # pylint: disable=invalid-name
asynchronous(get_all_user_station_contents))
@synchronized
def get_all_user_playlist_contents(self, **_):
"""
Return list of :class:`.Playlist` instances.
"""
if self.cached_playlists:
return [self.cached_liked_songs] + self.cached_playlists
self.get_all_tracks()
self.cached_playlists = Playlist.from_data(
self.mobile_client.get_all_user_playlist_contents(), True)
return [self.cached_liked_songs] + self.cached_playlists
get_all_user_playlist_contents_async = ( # pylint: disable=invalid-name
asynchronous(get_all_user_playlist_contents))
def get_cached_tracks_map(self):
"""
Return a dictionary of tracks where keys are strings with track IDs
and values are :class:`.Track` instances.
"""
return {track.id: track for track in self.cached_tracks}
def get_track_by_id(self, any_id):
"""
Return track by id or store_id.
"""
for track in self.cached_tracks:
if any_id in (track.library_id, track.store_id,
track.playlist_item_id):
return track
return None
def search(self, query):
"""
Find tracks and return an instance of :class:`.SearchResults`.
"""
results = self.mobile_client.search(query)
return SearchResults.from_data(results)
search_async = asynchronous(search)
def add_to_my_library(self, track):
"""
Add a track to my library.
"""
result = self.mobile_client.add_store_tracks(track.id)
if result:
self.invalidate_caches()
return result
def remove_from_my_library(self, track):
"""
Remove a track from my library.
"""
result = self.mobile_client.delete_songs(track.id)
if result:
self.invalidate_caches()
return result
@property
def is_authenticated(self):
"""
Return True if user is authenticated on Google Play Music, false otherwise.
"""
return self.mobile_client.is_authenticated()
@property
def is_subscribed(self):
"""
Return True if user is subscribed on Google Play Music, false otherwise.
"""
return self.mobile_client.is_subscribed
from gmusicapi.clients import Mobileclient
api = Mobileclient()
logged_in = api.login('<<email_address>>', '<<password>>',
Mobileclient.FROM_MAC_ADDRESS)
print(logged_in)
playlists = api.get_all_playlists()
myplaylists = list(
filter(lambda p: p['name'].find('My Library') == 0, playlists))
for playlist in myplaylists:
api.delete_playlist(playlist['id'])
print(playlist['name'])
class _GP(object):
"""
Interface to :class:`gmusicapi.Mobileclient`. Implements
asynchronous API calls, caching and some other perks.
Singleton.
"""
# TODO: Switch to urwid signals for more explicitness?
caches_invalidated = EventHook()
parsed_songs = EventHook()
def __init__(self):
# self.is_debug = os.getenv('CLAY_DEBUG')
self.mobile_client = Mobileclient()
self.mobile_client._make_call = self._make_call_proxy(
self.mobile_client._make_call)
# if self.is_debug:
# self.debug_file = open('/tmp/clay-api-log.json', 'w')
# self._last_call_index = 0
self.cached_tracks = None
self.cached_playlists = None
self.cached_stations = None
self.cached_artists = {}
self.cached_albums = {}
self.liked_songs = LikedSongs()
self.invalidate_caches()
self.auth_state_changed = EventHook()
def _make_call_proxy(self, func):
"""
Return a function that wraps *fn* and logs args & return values.
"""
def _make_call(protocol, *args, **kwargs):
"""
Wrapper function.
"""
logger.debug('GP::{}(*{}, **{})'.format(protocol.__name__, args,
kwargs))
result = func(protocol, *args, **kwargs)
# self._last_call_index += 1
# call_index = self._last_call_index
# self.debug_file.write(json.dumps([
# call_index,
# protocol.__name__, args, kwargs,
# result
# ]) + '\n')
# self.debug_file.flush()
return result
return _make_call
def invalidate_caches(self):
"""
Clear cached tracks & playlists & stations.
"""
self.cached_tracks = None
self.cached_playlists = None
self.cached_stations = None
self.cached_artist = None
self.caches_invalidated.fire()
@synchronized
def login(self, email, password, device_id, **_):
"""
Log in into Google Play Music.
"""
self.mobile_client.logout()
self.invalidate_caches()
result = self.mobile_client.login(email, password, device_id)
# prev_auth_state = self.is_authenticated
# if prev_auth_state != self.is_authenticated:
self.auth_state_changed.fire(self.is_authenticated)
return result
login_async = asynchronous(login)
@synchronized
def get_artist_info(self, artist_id):
"""
Get the artist info
"""
return self.mobile_client.get_artist_info(artist_id,
max_rel_artist=0,
max_top_tracks=15)
@synchronized
def get_album_tracks(self, album_id):
"""
Get album tracks
"""
return self.mobile_client.get_album_info(album_id,
include_tracks=True)['tracks']
@synchronized
def add_album_song(self, id_, album_name, track):
"""
Adds an album to an artist and adds the specified track to it
Args:
id_ (`str`): the album ID (currently the same as the album title)
album_name (`str`): the name of the album
track (`clay.gp.Track`): the track in the album
"""
if album_name == '':
id_ = track.artist
album_name = "Unknown Album"
if id_ not in self.cached_albums:
self.cached_albums[id_] = Album(track.album_artist, {
'albumId': id_,
'name': album_name
})
self.cached_albums[id_].add_track(track)
return self.cached_albums[id_]
@synchronized
def add_artist(self, artist_id, name):
"""
Creates or lookup an artist object and return it.
Args:
artist_id (`str`): The Artist id given by Google Play Music
Returns:
The artist class
"""
name = ("Unknown Artist" if name == '' else name)
lname = name.lower()
if lname not in self.cached_artists:
self.cached_artists[lname] = Artist(artist_id, name)
return self.cached_artists[lname]
@synchronized
def use_authtoken(self, authtoken, device_id):
"""
Try to use cached token to log into Google Play Music.
"""
self.mobile_client.session._authtoken = authtoken
self.mobile_client.session.is_authenticated = True
self.mobile_client.android_id = device_id
del self.mobile_client.is_subscribed
if self.mobile_client.is_subscribed:
self.auth_state_changed.fire(True)
return True
del self.mobile_client.is_subscribed
self.mobile_client.android_id = None
self.mobile_client.session.is_authenticated = False
self.auth_state_changed.fire(False)
return False
use_authtoken_async = asynchronous(use_authtoken)
def get_authtoken(self):
"""
Return currently active auth token.
"""
return self.mobile_client.session._authtoken
@synchronized
def get_all_tracks(self):
"""
Cache and return all tracks from "My library".
Each track will have "id" and "storeId" keys.
"""
if self.cached_tracks:
return self.cached_tracks
data = self.mobile_client.get_all_songs()
self.cached_tracks = Track.from_data(data, Source.library, True)
self.parsed_songs.fire()
return self.cached_tracks
get_all_tracks_async = asynchronous(get_all_tracks)
def get_stream_url(self, stream_id):
"""
Returns playable stream URL of track by id.
"""
return self.mobile_client.get_stream_url(stream_id)
get_stream_url_async = asynchronous(get_stream_url)
def increment_song_playcount(self, track_id):
"""
increments the playcount of a song with a given `track_id` by one
Args:
track_id (`int`): The track id of the song to increment the playcount
Returns:
Nothing
"""
gp.mobile_client.increment_song_playcount(track_id)
increment_song_playcount_async = asynchronous(increment_song_playcount)
@synchronized
def get_all_user_station_contents(self, **_):
"""
Return list of :class:`.Station` instances.
"""
if self.cached_stations:
return self.cached_stations
self.get_all_tracks()
self.cached_stations = Station.from_data(
self.mobile_client.get_all_stations(), True)
self.cached_stations.insert(0, IFLStation())
return self.cached_stations
get_all_user_station_contents_async = (
asynchronous(get_all_user_station_contents))
@synchronized
def get_all_user_playlist_contents(self, **_):
"""
Return list of :class:`.Playlist` instances.
"""
if self.cached_playlists:
return self.cached_playlists
self.get_all_tracks()
self.cached_playlists = Playlist.from_data(
self.mobile_client.get_all_user_playlist_contents(), True)
self.refresh_liked_songs()
self.cached_playlists.insert(0, self.liked_songs)
return self.cached_playlists
get_all_user_playlist_contents_async = (
asynchronous(get_all_user_playlist_contents))
def refresh_liked_songs(self, **_):
"""
Refresh the liked songs playlist
"""
self.liked_songs.refresh_tracks(self.mobile_client.get_top_songs())
refresh_liked_songs_async = asynchronous(refresh_liked_songs)
def get_cached_tracks_map(self):
"""
Return a dictionary of tracks where keys are strings with track IDs
and values are :class:`.Track` instances.
"""
return {track.id: track for track in self.cached_tracks}
def get_track_by_id(self, any_id):
"""
Return track by id or store_id.
"""
for track in self.cached_tracks:
if any_id in (track.id_, track.nid, track.store_id):
return track
return None
def search(self, query):
"""
Find tracks and return an instance of :class:`.SearchResults`.
"""
results = self.mobile_client.search(query)
return SearchResults.from_data(results)
search_async = asynchronous(search)
def add_to_my_library(self, track):
"""
Add a track to my library.
"""
result = self.mobile_client.add_store_tracks(track.id)
if result:
self.invalidate_caches()
return result
def remove_from_my_library(self, track):
"""
Remove a track from my library.
"""
result = self.mobile_client.delete_songs(track.id)
if result:
self.invalidate_caches()
return result
@property
def is_authenticated(self):
"""
Return True if user is authenticated on Google Play Music, false otherwise.
"""
return self.mobile_client.is_authenticated()
@property
def is_subscribed(self):
"""
Return True if user is subscribed on Google Play Music, false otherwise.
"""
return self.mobile_client.is_subscribed
class GoogleClient(object):
def __init__(self):
self.api = Mobileclient()
def _get_playlist_id(self):
"""
Gets user input for the playlist URL and attempts to parse it
to get the Playlist ID
"""
playlist_shared_url = input(
"Enter the shared URL for the Google playlist: ")
try:
playlist_id = parse.unquote(
playlist_shared_url.split('playlist/')[1])
except:
playlist_id = None
return playlist_id
def _search_for_track(self, album, artist, track_name):
"""
Searches Google for a track matching the provided album, artist, and name
Returns the track ID if found, else None
"""
query = track_name + ',' + artist + ',' + album
result = self.api.search(query)
song_hits = result['song_hits']
# TODO this search has gotta get better...
for h in song_hits:
if h['track']['title'] == track_name:
if h['track']['album'] == album or h['track'][
'artist'] == artist:
return h['track']['storeId']
# TODO Return the best match if no full match is made
return None
def _delete_playlist(self, playlist_id):
"""
Unfollow a playlist so that it does not appear in your account
Mostly useful for testing, but maybe this should be used if
an exception occurs in the track add process?
Return playlist ID
"""
return (self.api.delete_playlist(playlist_id) == playlist_id)
def authenticate(self):
email = input("Enter your Google email address: ")
password = getpass.getpass(
"Enter the password for your Google account: ")
# TODO store email locally
return self.api.login(email, password, Mobileclient.FROM_MAC_ADDRESS)
def get_playlist_tracks(self, playlist_id=None):
# TODO Get playlist namea s well!!!
if not playlist_id:
playlist_id = self._get_playlist_id()
tracks = self.api.get_shared_playlist_contents(playlist_id)
tracks = [{
"track": t['track']['title'],
"album": t['track']['album'],
"artist": t['track']['artist']
} for t in tracks]
return {"name": None, "tracks": tracks}
def search_for_tracklist(self, tracklist):
"""
Searches Google for a provided list of tracks
Track list should be the format provided by indexing 'tracks' in the
dict returned from get_playlist_tracks()
"""
found, not_found = [], []
for t in tracklist:
result = self._search_for_track(album=t['album'],
artist=t['artist'],
track_name=t['track'])
if result:
found.append(result)
else:
not_found.append(t)
return {"found": found, "not_found": not_found}
def create_playlist(self, playlist_name):
"""
Create a new playlist with the provided name
"prompt" param is mostly just here for testing
Return the generated playlist ID
"""
return self.api.create_playlist(name=playlist_name)
def add_tracks_to_playlist(self, playlist_id, track_list):
"""
Add all track in provided track_list to desired playlist
track_list should be a list of Google track IDs,
provided by the 'found' index of search_for_tracks()
"""
return self.api.add_songs_to_playlist(playlist_id=playlist_id,
song_ids=track_list)
def downAlbum(search):
sr = mc.search(search)
if len(sr['album_hits']) == 0:
print('no albums found for ' + search)
return
album = mc.get_album_info(sr['album_hits'][0]['album']['albumId'])
query_yes_no('Download album ' + album['name'] + ' by ' + album['artist'] +
'?')
for track in album['tracks']:
downResource(track)
parser = argparse.ArgumentParser(description='GPM Download Tool')
parser.add_argument('search', type=str, help='search term')
parser.add_argument('-a',
'--album',
dest='album',
action='store_true',
help='treat the search term as an album')
args = parser.parse_args()
mc = Mobileclient()
# username, password, deviceid
mc.login('aa', 'aa', 'aa')
print('Logged in')
if args.album:
downAlbum(args.search)
else:
downSong(args.search)
class MobileClientWrapper(_Base):
"""Wraps gmusicapi's Mobileclient client interface to provide extra functionality and conveniences."""
def __init__(self, log=False):
"""
:param log: Enable gmusicapi's debug_logging option.
"""
self.api = Mobileclient(debug_logging=log)
self.api.logger.addHandler(logging.NullHandler())
def login(self, username=None, password=None, android_id=None):
"""Authenticate the gmusicapi Mobileclient instance.
Returns ``True`` on successful login or ``False`` on unsuccessful login.
:param username: (Optional) Your Google Music username. Will be prompted if not given.
:param password: (Optional) Your Google Music password. Will be prompted if not given.
:param android_id: (Optional) The 16 hex digits from an Android device ID.
Default: Use gmusicapi.Mobileclient.FROM_MAC_ADDRESS to create ID from computer's MAC address.
"""
if not username:
username = raw_input("Enter your Google username or email address: ")
if not password:
password = getpass.getpass(b"Enter your Google Music password: "******"Sorry, login failed.")
return False
logger.info("Successfully logged in.\n")
return True
def logout(self):
"""Log out the gmusicapi Mobileclient instance.
Returns ``True`` on success.
"""
return self.api.logout()
def get_google_songs(self, include_filters=None, exclude_filters=None, all_include_filters=False, all_exclude_filters=False):
"""Create song list from user's Google Music library using gmusicapi's Mobileclient.get_all_songs().
Returns a list of Google Music song dicts matching criteria and
a list of Google Music song dicts filtered out using filter criteria.
:param include_filters: A list of ``(field, pattern)`` tuples.
Fields are any valid Google Music metadata field available to the Musicmanager client.
Patterns are Python regex patterns.
Google Music songs are filtered out if the given metadata field values don't match any of the given patterns.
:param exclude_filters: A list of ``(field, pattern)`` tuples.
Fields are any valid Google Music metadata field available to the Musicmanager client.
Patterns are Python regex patterns.
Google Music songs are filtered out if the given metadata field values match any of the given patterns.
:param all_include_filters: If ``True``, all include_filters criteria must match to include a song.
:param all_exclude_filters: If ``True``, all exclude_filters criteria must match to exclude a song.
"""
logger.info("Loading Google Music songs...")
google_songs = self.api.get_all_songs()
if include_filters or exclude_filters:
matched_songs, filtered_songs = filter_google_songs(
google_songs, include_filters, exclude_filters, all_include_filters, all_exclude_filters
)
else:
matched_songs = google_songs
filtered_songs = []
logger.info("Filtered {0} Google Music songs".format(len(filtered_songs)))
logger.info("Loaded {0} Google Music songs".format(len(matched_songs)))
return matched_songs, filtered_songs
class MobileClientWrapper(_Base):
def __init__(self, log=False, quiet=False):
self.api = Mobileclient(debug_logging=log)
self.api.logger.addHandler(logging.NullHandler())
self.print_ = safe_print if not quiet else lambda *args, **kwargs: None
def login(self, *args):
"""Authenticate the gmusicapi Mobileclient instance."""
if len(args) == 2:
username, password = args[0], args[1]
elif len(args) == 1:
username, password = args[0], None
else:
username, password = None, None
if not self.api.login(username, password):
if not username:
username = raw_input(
"Enter your Google username or email address: ")
if not password:
password = getpass.getpass(
b"Enter your Google Music password: "******"Sorry, login failed.")
return False
self.print_("Successfully logged in.\n")
return True
def logout(self):
"""Log out the gmusicapi Mobileclient instance."""
self.api.logout()
def get_google_songs(self, filters=None, filter_all=False):
"""Load song list from Google Music library."""
self.print_("Loading Google Music songs...")
google_songs = []
filter_songs = []
songs = self.api.get_all_songs()
google_songs, filter_songs = match_filters_google(
songs, filters, filter_all)
self.print_("Filtered {0} Google Music songs".format(
len(filter_songs)))
self.print_("Loaded {0} Google Music songs\n".format(
len(google_songs)))
return google_songs
import subprocess
from django.shortcuts import render
from gmusicapi.clients import Webclient, Mobileclient
import mutagen
from mutagen.easyid3 import EasyID3
import TTR.settings
from django.http import HttpResponse
import yaml
from game.models import DownloadedTrack
import json
from django.core.serializers.json import DjangoJSONEncoder
api = Mobileclient()
webCli = Webclient()
api.login(TTR.settings.UN, TTR.settings.P)
webCli.login(TTR.settings.UN, TTR.settings.P)
# TODO: Will want to separate these files.
# ==============================================================================
# Page Renderings
# 1) Search Page Rendering
# =============================================================================
# def index(request):
#
def search(request):
root_path = TTR.settings.MEDIA_ROOT