class gmObject:
def __init__(self):
self.mc = Mobileclient()
self.wc = Webclient()
self.mm = Musicmanager()
def login(self, username, password):
error.e = 0
if not self.mc.login(username, password):
gmtPrintV("gmObject.login: Wrong username or password (or no internet connection)")
error.e = error.LOGIN_FAILED
return
if not self.wc.login(username, password):
gmtPrintV("gmObject.login: Wrong username or password (or no internet connection)")
error.e = error.LOGIN_FAILED
return
if not self.mm.login(config.cred_path):
gmtPrintV("gmObject.login: Wrong credentials (or no internet connection)")
error.e = error.LOGIN_FAILED
return
def logout(self):
error.e = 0
try:
self.mc.logout()
self.wc.logout()
self.mm.logout()
except:
gmtPrintV("gmObject.logout: Logout failed")
error.e = error.LOGOUT_FAILED
def index(request):
args = {}
if request.user.is_authenticated:
credential = request.user.profile.google_oauth
if not credential:
return HttpResponse('No credentials found. Remake an account.')
manager = Musicmanager()
# TODO: Maybe change mac address for each user?
login_success = manager.login(
credential,
uploader_name="GMusicManagerOnline - {}".format(
request.user.username))
args.update({'login_success': login_success})
if login_success:
quota = manager.get_quota()
default_fields_form = DefaultFieldsForm(
request.POST or None, instance=request.user.profile)
if default_fields_form.is_valid():
default_fields_form.save()
return redirect('index')
args.update({
'currently_uploaded': quota[0],
'upload_limit': quota[1],
'default_fields_form': default_fields_form
})
manager.logout()
return render(request, 'core/index.html', args)
def youtube_upload(request):
# TODO: Async status updates?
if not request.user.is_authenticated:
return HttpResponse('log in first')
credential = request.user.profile.google_oauth
if not credential:
return HttpResponse('no creds')
manager = Musicmanager()
# TODO: Maybe change mac address for each user?
login_success = manager.login(
credential,
uploader_name="GMusicManagerOnline - {}".format(request.user.username))
form = YoutubeUploadForm()
args = {'can_login': login_success, 'form': form, 'success': False}
if request.method == "POST":
form = YoutubeUploadForm(request.POST)
if form.is_valid():
music = form.save()
for i in [
'title', 'album', 'composer', 'genre', 'language',
'artist', 'album_artist'
]:
if getattr(music, i) == "":
setattr(music, i,
getattr(request.user.profile, "default_" + i))
music.save()
youtube_url = request.POST.get('youtube_url')
metadata_opts = {
i: getattr(music, i)
for i in [
'title', 'album', 'composer', 'genre', 'language',
'artist', 'album_artist'
] if getattr(music, i) != ""
}
ydl_opts = {
'format':
'bestaudio/best',
'outtmpl':
settings.MEDIA_ROOT + "/{}{}.%(ext)s".format(
request.user.username, int(time.time())),
'postprocessors': [{
'key': 'FFmpegExtractAudio',
'preferredcodec': 'mp3',
'preferredquality': '320',
}],
}
upload_args = (youtube_url, ydl_opts, music, metadata_opts,
credential, "GMusicManagerOnline - {}".format(
request.user.username))
upload_thread = threading.Thread(target=_process_youtube_upload,
args=upload_args)
upload_thread.start()
args.update({'success': True})
args.update({'form': form})
manager.logout()
return render(request, 'core/youtube.html', args)
class GoogleMusicClient(object):
def __init__(self):
self.client = Musicmanager()
if not self.login(self.client):
raise ClientLoginException
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, traceback):
if not self.client.logout():
print("WARNING: Could not logout of Musicmanager")
def login(self, client):
print("Connecting to Google Music....", end='')
json_credentials = ""
with open('/run/secrets/google_oauth_credentials', 'r') as raw_cred:
cred_dict = ast.literal_eval(raw_cred.read())
json_credentials = json.dumps(cred_dict, ensure_ascii=False)
oauth_credentials = OAuth2Credentials.from_json(json_credentials)
results = client.login(oauth_credentials)
print("Success" if results else "Failure")
return results
def upload(request):
# TODO: Async status updates?
if not request.user.is_authenticated:
return HttpResponse('log in first')
credential = request.user.profile.google_oauth
if not credential:
return HttpResponse('no creds')
manager = Musicmanager()
# TODO: Maybe change mac address for each user?
login_success = manager.login(
credential,
uploader_name="GMusicManagerOnline - {}".format(request.user.username))
form = MusicUploadForm()
args = {'can_login': login_success, 'form': form, 'success': False}
if request.method == "POST":
form = MusicUploadForm(request.POST, request.FILES)
if form.is_valid():
music = form.save()
music_file = request.FILES.get('music_file')
ext = music_file.name[music_file.name.rfind('.'):]
fs = FileSystemStorage()
filename = fs.save("{0}{1}".format(request.user.username, ext),
music_file)
music_filepath = fs.path(filename)
post_filepath = music_filepath + ".mp3"
options = {
i: getattr(music, i)
for i in [
'title', 'album', 'composer', 'genre', 'language',
'artist', 'album_artist'
] if getattr(music, i) != ""
}
logger.info("Transcoding metadata: " + str(options))
options.update({'quality': '320k'})
_transcode(music_filepath, options, post_filepath)
if os.path.isfile(music_filepath):
os.remove(music_filepath)
success, _, _ = manager.upload( # Already transcoding.
post_filepath,
enable_matching=True,
enable_transcoding=False)
if os.path.isfile(post_filepath):
os.remove(post_filepath)
args.update({'success': True})
args.update({'form': form})
manager.logout()
return render(request, 'core/upload.html', args)
def main():
path = sys.argv[1]
if not os.path.exists(path):
print("Invalid file path. %s" % path)
return
api = Musicmanager()
api.login()
if not api.is_authenticated():
print("Login Error\n")
return
print("start upload...\n")
upload_info = api.upload(path)
print(upload_info)
print("upload is completed.\n")
api.logout()
def songs_uploader(self):
ip = urllib2.urlopen('http://ip.42.pl/raw').read() #Obtain your public IP address
mac_binary = str(get_mac()) #Obtain binary MAC address
temp = mac_binary.replace(':', '').replace('-', '').replace('.', '').upper()
mac_h3x = temp[:2] + ":" + ":".join([temp[i] + temp[i+1] for i in range(2,12,2)]) #Convert MAC from 48bit int to hexadecimal string
user = pwd.getpwuid(os.getuid())[0] #Get your system's username
api = Musicmanager()
hostname = '<' + ip + '>' + '' + '(gmusicapi-{2.0.0})'
Musicmanager.perform_oauth(storage_filepath='/home/' + user + '/.config/gmusicapi/oauth.cred', open_browser=False)
api.login(oauth_credentials='/home/' + user + '/.config/gmusicapi/oauth.cred', uploader_id=mac_h3x, uploader_name=hostname)
gmusicapi.clients.Musicmanager(debug_logging=True, validate=True)
#newWorkingDirectory = '../home'
#os.path.join(os.path.abspath(sys.path[0]), newWorkingDirectory) #Change the working directory
filepath = '/home/blackram/Scrivania/BRES_/UMM/ciao.mp3'
uploading = api.upload(filepath, transcode_quality=3, enable_matching=False)
print 'Uploading...'
f = open('uploading.txt','w') #log
f.write(str(uploading))
f.close()
final = re.search("GetUploadSession error 200: this song is already uploaded", open('uploading.txt','r').read())
if final is None:
print '\033[32mTrack uploaded!\033[0m'
else:
print '\033[31mTrack already exists in your library!\033[0m'
choice = raw_input("Exit from uploader? [Y/N] ")
if choice == 'y' or choice == 'Y':
print 'Return to main menu.'
Musicmanager.logout(revoke_oauth=False)
UMM.read_information()
elif choice == 'n' or choice == 'N':
print 'Okay.'
UMM.songs_uploader()
"Since this is your first time using the app you will need to allow your google account to authenticate..."
)
print(
"If you would like to change the app settings please modify the config file."
)
mm.perform_oauth()
config = open("yt2gpmCONFIG.txt", "w")
firstRun = False
config.write(
f"firstRun:{firstRun}\nYoutube-DL Args:{ytDlString}\nremoveDownloadedFile (saves storage space):{removeFile}"
)
config.close()
print("Attempting to login to GPM.")
mm.login()
print(f"Successfuly logged into GPM, Uploading file: {latestFile}...")
c = mm.upload(latestFile)
mm.logout()
print("File upload complete! Finishing up.")
# remove mp3 file from directory (default)
# if you want to keep the file change config (removeFile to true)
if "True" in removeFile:
os.remove(latestFile)
print("Removed downloaded file. Goodbye.")
else:
print("Goodbye.")
time.sleep(1)
def play_song_by_artist(song, artist):
if Mobileclient.is_authenticated(gpm):
mm = Musicmanager()
mm.login('/home/pi/oauth.cred')
if Musicmanager.is_authenticated(mm):
song_dict = mm.get_purchased_songs()
song_pattern = re.compile(
r'(?:.)*\s?(' + re.escape(song) + r')\s?(?:.)*', re.IGNORECASE)
artist_pattern = re.compile(
r'(?:.)*\s?(' + re.escape(artist) + r')\s?(?:.)*',
re.IGNORECASE)
btn = OnButtonPress()
btn.start()
for song in song_dict:
m = re.match(artist_pattern, song['artist'])
print(m)
if (re.match(song_pattern, song['title']) is not None and
re.match(artist_pattern, song['artist']) is not None):
print('Song found!')
song_id = song['id']
(filename, audio) = mm.download_song(song_id)
# get rid of non-ascii characters in file name
filename = filename.encode('ascii', errors='ignore')
# check if song is already downloaded
# path will look something like:
# /home/pi/Music/02 - Raindrop Prelude.mp3
# forces filename to be a string
filename = filename.decode('ascii')
path = song_location + filename
try:
if os.path.isfile(path):
print('Song is already downloaded...')
print(path)
print('Playing song.')
vlc_instance = vlc.Instance()
p = vlc_instance.media_player_new()
media = vlc_instance.media_new(path)
p.set_media(media)
events = p.event_manager()
events.event_attach(
vlc.EventType.MediaPlayerEndReached,
SongFinished)
p.play()
p.audio_set_volume(58)
while finish == 0:
duration = p.get_time() / 1000
(m, s) = divmod(duration, 60)
print('Current song is: ', path)
print('Length:', '%02d:%02d' % (m, s))
time.sleep(5)
p.stop()
break
else:
with open(path, 'wb') as f:
f.write(audio)
print('Song has been added to: ' + path)
print('Playing song.')
vlc_instance = vlc.Instance()
p = vlc_instance.media_player_new()
media = vlc_instance.media_new(path)
p.set_media(media)
events = p.event_manager()
events.event_attach(
vlc.EventType.MediaPlayerEndReached,
SongFinished)
p.play()
p.audio_set_volume(58)
while finish == 0:
duration = p.get_time() / 1000
m, s = divmod(duration, 60)
print('Current song is: ', path)
print('Length:', '%02d:%02d' % (m, s))
time.sleep(5)
p.stop()
break
except (OSError, IOError):
print('An error has occurred.')
break
else:
print('Song not found yet.')
else:
print('Looks like you need to authenticate.')
mm.perform_oauth('/home/pi/oauth.cred')
print('Logging out.')
Mobileclient.logout(gpm)
mm.logout()
else:
print('Mobile client is not authenticated.')
Mobileclient.logout(gpm)
class MusicSync(object):
def __init__(self, email=None, password=None):
self.mm = Musicmanager()
self.wc = Webclient()
self.mc = Mobileclient()
if not email:
email = raw_input("Email: ")
if not password:
password = getpass()
self.email = email
self.password = password
self.logged_in = self.auth()
print "Fetching playlists from Google..."
self.playlists = self.mc.get_all_user_playlist_contents()
#self.playlists = self.mc.get_all_playlists()
#self.playlists = self.wc.get_all_playlist_ids(auto=False)
self.all_songs = self.mc.get_all_songs()
#print "Got %d playlists." % len(self.playlists['user'])
print "Got %d playlists containing %d songs." % (len(
self.playlists), len(self.all_songs))
print ""
def auth(self):
self.logged_in = self.mc.login(self.email, self.password)
#self.logged_in = self.wc.login(self.email, self.password)
if not self.logged_in:
print "Login failed..."
exit()
print ""
print "Logged in as %s" % self.email
print ""
if not os.path.isfile(OAUTH_FILEPATH):
print "First time login. Please follow the instructions below:"
self.mm.perform_oauth()
self.logged_in = self.mm.login()
if not self.logged_in:
print "OAuth failed... try deleting your %s file and trying again." % OAUTH_FILEPATH
exit()
print "Authenticated"
print ""
def sync_playlist(self, filename, remove_missing):
#def sync_playlist(self, filename, remove_missing=False):
filename = self.get_platform_path(filename)
os.chdir(os.path.dirname(filename))
title = os.path.splitext(os.path.basename(filename))[0]
print "Syncing playlist: %s" % filename
#if title not in self.playlists['user']:
#print " didn't exist... creating..."
#self.playlists['user'][title] = [self.wc.create_playlist(title)]
print ""
plid = ""
for pl in self.playlists:
if pl['name'] == title:
plid = pl['id']
goog_songs = pl['tracks']
if plid == "":
print " didn't exist... creating..."
plid = self.mc.create_playlist(self, title)
#plid = self.playlists['user'][title][0]
#goog_songs = self.wc.get_playlist_songs(plid)
print "%d songs already in Google Music playlist" % len(goog_songs)
pc_songs = self.get_files_from_playlist(filename)
print "%d songs in local playlist" % len(pc_songs)
print ""
# Sanity check max 1000 songs per playlist
if len(pc_songs) > MAX_SONGS_IN_PLAYLIST:
print " Google music doesn't allow more than %d songs in a playlist..." % MAX_SONGS_IN_PLAYLIST
print " Will only attempt to sync the first %d songs." % MAX_SONGS_IN_PLAYLIST
del pc_songs[MAX_SONGS_IN_PLAYLIST:]
existing_files = 0
added_files = 0
failed_files = 0
removed_files = 0
fatal_count = 0
for fn in pc_songs:
if self.file_already_in_list(fn, goog_songs, self.all_songs):
existing_files += 1
continue
print ""
print "Adding: %s" % os.path.basename(fn).encode('cp1252')
#print "Adding: %s" % os.path.basename(fn)
#online = False
online = self.find_song(fn, goog_songs, self.all_songs)
#online = self.find_song(fn)
song_id = None
if online:
song_id = online['id']
print " already uploaded [%s]" % song_id
else:
attempts = 0
result = []
while not result and attempts < MAX_UPLOAD_ATTEMPTS_PER_FILE:
print " uploading... (may take a while)"
attempts += 1
try:
result = self.mm.upload(fn)
except (BadStatusLine, CannotSendRequest):
# Bail out if we're getting too many disconnects
if fatal_count >= MAX_CONNECTION_ERRORS_BEFORE_QUIT:
print ""
print "Too many disconnections - quitting. Please try running the script again."
print ""
exit()
print "Connection Error -- Reattempting login"
fatal_count += 1
self.wc.logout()
self.mc.logout()
self.mm.logout()
result = []
time.sleep(STANDARD_SLEEP)
except:
result = []
time.sleep(STANDARD_SLEEP)
try:
if result[0]:
song_id = result[0].itervalues().next()
else:
song_id = result[1].itervalues().next()
print " upload complete [%s]" % song_id
except:
print " upload failed - skipping"
tag = self.get_id3_tag(fn)
print " failed song:\t%s\t%s\t%s" % (
tag['title'].encode('cp1252'),
tag['artist'].encode('cp1252'),
tag['album'].encode('cp1252'))
if not song_id:
failed_files += 1
continue
added = self.mc.add_songs_to_playlist(plid, song_id)
time.sleep(.3) # Don't spam the server too fast...
print " done adding to playlist"
added_files += 1
if remove_missing:
for g in goog_songs:
for s in self.all_songs:
if g['trackId'] == s['id']:
print ""
print "Removing: %s" % s['title'].encode('cp1252')
self.mc.remove_entries_from_playlist(g['id'])
#self.wc.remove_songs_from_playlist(plid, s.id)
time.sleep(.3) # Don't spam the server too fast...
removed_files += 1
print ""
print "---"
print "%d songs unmodified" % existing_files
print "%d songs added" % added_files
print "%d songs failed" % failed_files
print "%d songs removed" % removed_files
def get_files_from_playlist(self, filename):
files = []
f = codecs.open(filename, encoding='cp1252')
#f = codecs.open(filename, encoding='utf-8')
for line in f:
line = line.rstrip().replace(u'\ufeff', u'')
if line == "" or line[0] == "#":
continue
path = os.path.abspath(self.get_platform_path(line))
if not os.path.exists(path):
print "File not found: %s" % line
continue
files.append(path)
f.close()
return files
def file_already_in_list(self, filename, goog_songs, all_songs):
tag = self.get_id3_tag(filename)
print "Searching for\t%s\t%s\t%s" % (tag['title'].encode('cp1252'),
tag['artist'].encode('cp1252'),
tag['album'].encode('cp1252'))
i = 0
while i < len(goog_songs):
for s in all_songs:
if goog_songs[i]['trackId'] == s['id']:
if self.tag_compare(s, tag):
print "Found match\t%s\t%s\t%s" % (
s['title'].encode('cp1252'),
s['artist'].encode('cp1252'),
s['album'].encode('cp1252'))
goog_songs.pop(i)
return True
i += 1
return False
def get_id3_tag(self, filename):
data = mutagen.File(filename, easy=True)
r = {}
if 'title' not in data:
title = os.path.splitext(os.path.basename(filename))[0]
print 'Found song with no ID3 title, setting using filename:'
print ' %s' % title
print ' (please note - the id3 format used (v2.4) is invisible to windows)'
data['title'] = [title]
data.save()
r['title'] = data['title'][0]
r['track'] = int(data['tracknumber'][0].split('/')
[0]) if 'tracknumber' in data else 0
# If there is no track, try and get a track number off the front of the file... since thats
# what google seems to do...
# Not sure how google expects it to be formatted, for now this is a best guess
if r['track'] == 0:
m = re.match("(\d+) ", os.path.basename(filename))
if m:
r['track'] = int(m.group(0))
r['artist'] = data['artist'][0] if 'artist' in data else ''
r['album'] = data['album'][0] if 'album' in data else ''
return r
def find_song(self, filename, goog_songs, all_songs):
tag = self.get_id3_tag(filename)
print "Searching for\t%s\t%s\t%s" % (tag['title'].encode('cp1252'),
tag['artist'].encode('cp1252'),
tag['album'].encode('cp1252'))
#results = self.wc.search(tag['title'])
# NOTE - diagnostic print here to check results if you're creating duplicates
#print results['song_hits']
#for r in goog_songs:
#for r in results['song_hits']:
for s in all_songs:
#if r['trackId'] == s['id']:
if self.tag_compare(s, tag):
# TODO: add rough time check to make sure its "close"
print "Found match\t%s\t%s\t%s" % (
s['title'].encode('cp1252'), s['artist'].encode('cp1252'),
s['album'].encode('cp1252'))
return s
return None
def tag_compare(self, g_song, tag):
# If a google result has no track, google doesn't return a field for it
if 'title' not in g_song:
g_song['title'] = ""
if 'artist' not in g_song:
g_song['artist'] = ""
if 'album' not in g_song:
g_song['album'] = ""
if 'track' not in g_song:
g_song['track'] = 0
if (g_song['title'].lower() == tag['title'].lower() and g_song['artist'].lower() == tag['artist'].lower()) or\
(g_song['album'].lower() == tag['album'].lower() and g_song['title'].lower() == tag['title'].lower()) or\
(g_song['artist'].lower() == tag['artist'].lower() and g_song['album'].lower() == tag['album'].lower() and g_song['track'] == tag['track']):
print "Partial match\t%s\t%s\t%s" % (
g_song['title'].encode('cp1252'),
g_song['artist'].encode('cp1252'),
g_song['album'].encode('cp1252'))
return g_song['title'].lower() == tag['title'].lower() and\
g_song['artist'].lower() == tag['artist'].lower() and\
g_song['album'].lower() == tag['album'].lower() #and\
#g_song['track'] == tag['track']
def delete_song(self, sid):
self.mc.delete_songs(sid)
print "Deleted song by id [%s]" % sid
def get_platform_path(self, full_path):
# Try to avoid messing with the path if possible
if os.sep == '/' and '\\' not in full_path:
return full_path
if os.sep == '\\' and '\\' in full_path:
return full_path
if '\\' not in full_path:
return full_path
return os.path.normpath(full_path.replace('\\', '/'))
return "%02x:%02x:%02x:%02x:%02x:%02x" % (
random.randint(0, 255),
random.randint(0, 255),
random.randint(0, 255),
random.randint(0, 255),
random.randint(0, 255),
random.randint(0, 255)
)
'''
# A unique id as a MAC address, eg '00:11:22:33:AA:BB'.
# Per the docs, this should only be provided in cases where the default (host MAC address incremented by 1) will not work.
# It's recommended to use the same MAC address for continued uploads from the same machine.
mac_address = '38:F9:D3:57:68:FC'
mm = Musicmanager()
# mm.perform_oauth() # For the first run/implementation only. Not needed afterwards.
mm.login(uploader_id=mac_address)
track = sys.argv[1]
print(track)
def upload_music(track):
mm.upload(track, enable_matching=True, enable_transcoding=True)
if __name__ == '__main__':
upload_music(track)
mm.logout(revoke_oauth=False)
from gmusicapi import Musicmanager
import os.path
storage_filepath = '/home/alex/.local/share/gmusicapi/oauth.cred'
mm = Musicmanager()
if os.path.isfile(storage_filepath):
mm.login()
else:
Musicmanager.perform_oauth(storage_filepath, open_browser=True)
songs = mm.get_uploaded_songs(incremental=False)
print(songs)
song_id = []
for x in songs:
song_id.append(x.get('id'))
print(song_id)
for an_id in song_id:
filename, audio = mm.download_song(an_id)
with open(filename, 'wb') as f:
f.write(audio)
input("Enter: ")
mm.logout(revoke_oauth=False)
class MusicSync(object):
def __init__(self, email=None, password=None):
self.mm = Musicmanager()
self.wc = Webclient()
self.mc = Mobileclient()
if not email:
email = raw_input("Email: ")
if not password:
password = getpass()
self.email = email
self.password = password
self.logged_in = self.auth()
print "Fetching playlists from Google..."
self.playlists = self.mc.get_all_user_playlist_contents()
#self.playlists = self.mc.get_all_playlists()
#self.playlists = self.wc.get_all_playlist_ids(auto=False)
self.all_songs = self.mc.get_all_songs()
#print "Got %d playlists." % len(self.playlists['user'])
print "Got %d playlists containing %d songs." % (len(self.playlists), len(self.all_songs))
print ""
def auth(self):
self.logged_in = self.mc.login(self.email, self.password)
#self.logged_in = self.wc.login(self.email, self.password)
if not self.logged_in:
print "Login failed..."
exit()
print ""
print "Logged in as %s" % self.email
print ""
if not os.path.isfile(OAUTH_FILEPATH):
print "First time login. Please follow the instructions below:"
self.mm.perform_oauth()
self.logged_in = self.mm.login()
if not self.logged_in:
print "OAuth failed... try deleting your %s file and trying again." % OAUTH_FILEPATH
exit()
print "Authenticated"
print ""
def sync_playlist(self, filename, remove_missing):
#def sync_playlist(self, filename, remove_missing=False):
filename = self.get_platform_path(filename)
os.chdir(os.path.dirname(filename))
title = os.path.splitext(os.path.basename(filename))[0]
print "Syncing playlist: %s" % filename
#if title not in self.playlists['user']:
#print " didn't exist... creating..."
#self.playlists['user'][title] = [self.wc.create_playlist(title)]
print ""
plid = ""
for pl in self.playlists:
if pl['name'] == title:
plid = pl['id']
goog_songs = pl['tracks']
if plid == "":
print " didn't exist... creating..."
plid = self.mc.create_playlist(self, title)
#plid = self.playlists['user'][title][0]
#goog_songs = self.wc.get_playlist_songs(plid)
print "%d songs already in Google Music playlist" % len(goog_songs)
pc_songs = self.get_files_from_playlist(filename)
print "%d songs in local playlist" % len(pc_songs)
print ""
# Sanity check max 1000 songs per playlist
if len(pc_songs) > MAX_SONGS_IN_PLAYLIST:
print " Google music doesn't allow more than %d songs in a playlist..." % MAX_SONGS_IN_PLAYLIST
print " Will only attempt to sync the first %d songs." % MAX_SONGS_IN_PLAYLIST
del pc_songs[MAX_SONGS_IN_PLAYLIST:]
existing_files = 0
added_files = 0
failed_files = 0
removed_files = 0
fatal_count = 0
for fn in pc_songs:
if self.file_already_in_list(fn, goog_songs, self.all_songs):
existing_files += 1
continue
print ""
print "Adding: %s" % os.path.basename(fn).encode('cp1252')
#print "Adding: %s" % os.path.basename(fn)
#online = False
online = self.find_song(fn, goog_songs, self.all_songs)
#online = self.find_song(fn)
song_id = None
if online:
song_id = online['id']
print " already uploaded [%s]" % song_id
else:
attempts = 0
result = []
while not result and attempts < MAX_UPLOAD_ATTEMPTS_PER_FILE:
print " uploading... (may take a while)"
attempts += 1
try:
result = self.mm.upload(fn)
except (BadStatusLine, CannotSendRequest):
# Bail out if we're getting too many disconnects
if fatal_count >= MAX_CONNECTION_ERRORS_BEFORE_QUIT:
print ""
print "Too many disconnections - quitting. Please try running the script again."
print ""
exit()
print "Connection Error -- Reattempting login"
fatal_count += 1
self.wc.logout()
self.mc.logout()
self.mm.logout()
result = []
time.sleep(STANDARD_SLEEP)
except:
result = []
time.sleep(STANDARD_SLEEP)
try:
if result[0]:
song_id = result[0].itervalues().next()
else:
song_id = result[1].itervalues().next()
print " upload complete [%s]" % song_id
except:
print " upload failed - skipping"
tag = self.get_id3_tag(fn)
print " failed song:\t%s\t%s\t%s" % (tag['title'].encode('cp1252'), tag['artist'].encode('cp1252'), tag['album'].encode('cp1252'))
if not song_id:
failed_files += 1
continue
added = self.mc.add_songs_to_playlist(plid, song_id)
time.sleep(.3) # Don't spam the server too fast...
print " done adding to playlist"
added_files += 1
if remove_missing:
for g in goog_songs:
for s in self.all_songs:
if g['trackId'] == s['id']:
print ""
print "Removing: %s" % s['title'].encode('cp1252')
self.mc.remove_entries_from_playlist(g['id'])
#self.wc.remove_songs_from_playlist(plid, s.id)
time.sleep(.3) # Don't spam the server too fast...
removed_files += 1
print ""
print "---"
print "%d songs unmodified" % existing_files
print "%d songs added" % added_files
print "%d songs failed" % failed_files
print "%d songs removed" % removed_files
def get_files_from_playlist(self, filename):
files = []
f = codecs.open(filename, encoding='cp1252')
#f = codecs.open(filename, encoding='utf-8')
for line in f:
line = line.rstrip().replace(u'\ufeff',u'')
if line == "" or line[0] == "#":
continue
path = os.path.abspath(self.get_platform_path(line))
if not os.path.exists(path):
print "File not found: %s" % line
continue
files.append(path)
f.close()
return files
def file_already_in_list(self, filename, goog_songs, all_songs):
tag = self.get_id3_tag(filename)
print "Searching for\t%s\t%s\t%s" % (tag['title'].encode('cp1252'), tag['artist'].encode('cp1252'), tag['album'].encode('cp1252'))
i = 0
while i < len(goog_songs):
for s in all_songs:
if goog_songs[i]['trackId'] == s['id']:
if self.tag_compare(s, tag):
print "Found match\t%s\t%s\t%s" % (s['title'].encode('cp1252'), s['artist'].encode('cp1252'), s['album'].encode('cp1252'))
goog_songs.pop(i)
return True
i += 1
return False
def get_id3_tag(self, filename):
data = mutagen.File(filename, easy=True)
r = {}
if 'title' not in data:
title = os.path.splitext(os.path.basename(filename))[0]
print 'Found song with no ID3 title, setting using filename:'
print ' %s' % title
print ' (please note - the id3 format used (v2.4) is invisible to windows)'
data['title'] = [title]
data.save()
r['title'] = data['title'][0]
r['track'] = int(data['tracknumber'][0].split('/')[0]) if 'tracknumber' in data else 0
# If there is no track, try and get a track number off the front of the file... since thats
# what google seems to do...
# Not sure how google expects it to be formatted, for now this is a best guess
if r['track'] == 0:
m = re.match("(\d+) ", os.path.basename(filename))
if m:
r['track'] = int(m.group(0))
r['artist'] = data['artist'][0] if 'artist' in data else ''
r['album'] = data['album'][0] if 'album' in data else ''
return r
def find_song(self, filename, goog_songs, all_songs):
tag = self.get_id3_tag(filename)
print "Searching for\t%s\t%s\t%s" % (tag['title'].encode('cp1252'), tag['artist'].encode('cp1252'), tag['album'].encode('cp1252'))
#results = self.wc.search(tag['title'])
# NOTE - diagnostic print here to check results if you're creating duplicates
#print results['song_hits']
#for r in goog_songs:
#for r in results['song_hits']:
for s in all_songs:
#if r['trackId'] == s['id']:
if self.tag_compare(s, tag):
# TODO: add rough time check to make sure its "close"
print "Found match\t%s\t%s\t%s" % (s['title'].encode('cp1252'), s['artist'].encode('cp1252'), s['album'].encode('cp1252'))
return s
return None
def tag_compare(self, g_song, tag):
# If a google result has no track, google doesn't return a field for it
if 'title' not in g_song:
g_song['title'] = ""
if 'artist' not in g_song:
g_song['artist'] = ""
if 'album' not in g_song:
g_song['album'] = ""
if 'track' not in g_song:
g_song['track'] = 0
if (g_song['title'].lower() == tag['title'].lower() and g_song['artist'].lower() == tag['artist'].lower()) or\
(g_song['album'].lower() == tag['album'].lower() and g_song['title'].lower() == tag['title'].lower()) or\
(g_song['artist'].lower() == tag['artist'].lower() and g_song['album'].lower() == tag['album'].lower() and g_song['track'] == tag['track']):
print "Partial match\t%s\t%s\t%s" % (g_song['title'].encode('cp1252'), g_song['artist'].encode('cp1252'), g_song['album'].encode('cp1252'))
return g_song['title'].lower() == tag['title'].lower() and\
g_song['artist'].lower() == tag['artist'].lower() and\
g_song['album'].lower() == tag['album'].lower() #and\
#g_song['track'] == tag['track']
def delete_song(self, sid):
self.mc.delete_songs(sid)
print "Deleted song by id [%s]" % sid
def get_platform_path(self, full_path):
# Try to avoid messing with the path if possible
if os.sep == '/' and '\\' not in full_path:
return full_path
if os.sep == '\\' and '\\' in full_path:
return full_path
if '\\' not in full_path:
return full_path
return os.path.normpath(full_path.replace('\\', '/'))
# remove uploaded file
if upload_ok :
os.remove(PUSH_DIR + musique)
# init
id_list={}
try : id_list = marshal.load(open(DICT_FILE, "rb"))
except : pass
mm = Musicmanager()
if not mm.login() :
mm.perform_oauth()
mm.login()
for arg in sys.argv :
if arg == 'pull' :
print 'pulling...'
pull()
elif arg == 'push' :
print 'pushing...'
push()
# finish
mm.logout()
marshal.dump(id_list, open(DICT_FILE, 'wb'))
class User:
def __init__(self, email, app_data_dir):
self.email = email
self.app_data_dir = app_data_dir
self.db_lock = threading.Lock()
def init(self, oauth_credentials):
# Initialize the database
logger.info("%s: Initializing database" % self.email)
self._data_init()
# Create the Musicmanager
logger.info("%s: Logging in to Google music" % self.email)
self.mm = Musicmanager()
if not self.mm.login(oauth_credentials):
logger.info("%s: Error logging in to Google music" % self.email)
return False
# Check if we already have any watch paths configured
config = self._read_config()
watched_paths = config["watched_paths"] if "watched_paths" in config else []
logger.info("%s: Found previously watched paths %s" % (self.email, watched_paths))
# Create the FileWatcher
logger.info("%s: Creating the FileWatcher" % (self.email))
self.fw = FileWatcher(self.email, self._finished_writing_callback, watched_paths)
return True
def logout(self):
self.mm.logout()
self.fw.stop_watching()
def _read_config(self):
return util.read_config(os.path.join(self.app_data_dir, self.email, CFG_FILE_NAME))
def _write_config(self, config):
util.write_config(config, os.path.join(self.app_data_dir, self.email, CFG_FILE_NAME))
def get_watched_paths(self):
logger.debug("reading config from %s" % os.path.join(self.app_data_dir, self.email))
config = self._read_config()
logger.debug("read config: %s" % config)
return config["watched_paths"] if "watched_paths" in config else []
def add_watch_path(self, path):
# Add to file watcher
self.fw.watch(path)
# Add to the config
config = self._read_config()
if "watched_paths" not in config:
config["watched_paths"] = [path]
else:
if path not in config["watched_paths"]:
config["watched_paths"].append(path)
self._write_config(config)
def remove_watch_path(self, path):
# Remove from the file watcher
self.fw.remove_watch(path)
# Remove from the config
config = self._read_config()
if "watched_paths" in config:
if path in config["watched_paths"]:
config["watched_paths"].remove(path)
else:
logger.info("%s trying to remove watch path %s that we weren't watching" % (self.email, path))
self._write_config(config)
def set_default_action(self, default_action):
config = self._read_config()
config["default_action"] = default_action
self._write_config(config)
def get_default_action(self):
config = self._read_config()
return config.get("default_action", "scan_only")
def scan_existing_files(self):
watched_paths = self.get_watched_paths()
logger.debug("%s Scanning existing files in these directories: %s" % (self.email, watched_paths))
for watched_path in watched_paths:
logger.debug("Scanning existing files in %s" % watched_path)
for root, subFolders, files in os.walk(watched_path):
logger.debug("root: %s, subfolders: %s, files: %s" % (root, subFolders, files))
for file in files:
filename, fileExtension = os.path.splitext(file)
logger.debug("looking at file %s, filename = %s, file extension = %s" % (file, filename, fileExtension))
if fileExtension == ".mp3":
logger.debug("Found file %s" % file);
self._update_path(os.path.join(root, file), FileStatus.Scanned)
logger.debug("scanning finished");
def upload_scanned(self):
songs = self.get_all_songs()
for song_path in songs.keys():
if songs[song_path]["status"] == FileStatus.Scanned:
logger.debug("Uploading song %s" % song_path)
self.upload(song_path)
return
def _data_init(self):
with self.db_lock:
con = sql.connect(os.path.join(self.app_data_dir, self.email, DB_NAME))
with con:
cur = con.cursor()
cur.execute('''CREATE TABLE IF NOT EXISTS songs(path TEXT PRIMARY KEY, id TEXT, status TEXT)''')
def _update_path(self, path, status, id=None, override=False):
logger.info("Updating path %s with id %s and status %s" % (path, id, status))
info = ((path,
"" if not id else id,
status)
)
with self.db_lock:
con = sql.connect(os.path.join(self.app_data_dir, self.email, DB_NAME))
with con:
cur = con.cursor()
if not override:
# Check if the song is already in the data store and, if so, what its status is
cur.execute('''SELECT status FROM songs WHERE path=(?)''', (path,))
res = cur.fetchone()
if res:
res = res[0]
if res == FileStatus.Uploaded:
# If it's already been uploaded, don't override that status with something else
return
cur.execute('''REPLACE INTO songs VALUES(?, ?, ?)''', info)
def _finished_writing_callback(self, new_file_path):
logger.debug("New file %s" % new_file_path)
filename, file_extension = os.path.splitext(new_file_path)
if file_extension != ".mp3":
logger.debug("Skipping non-mp3 file")
return
self._update_path(new_file_path, FileStatus.Scanned)
if self.get_default_action() == "auto_upload":
logger.info("Uploading new file: %s" % new_file_path)
self.upload(new_file_path)
@staticmethod
def _find_gmusic_song(scanned_song_tags, gmusic_songs):
try:
artist = scanned_song_tags.artist.lower()
album = scanned_song_tags.album.lower()
title = scanned_song_tags.title.lower()
#logger.debug("Found scanned song %s - %s - %s" % (artist, album, title))
except:
logger.debug("Error grabbing song meta data")
return
# Search for an uploaded song that matches
for gmusic_song in gmusic_songs:
up_artist = gmusic_song['artist'].lower()
up_album = gmusic_song['album'].lower()
up_title = gmusic_song['title'].lower()
#logger.debug("Looking at song %s - %s - %s" % (up_artist, up_album, up_title))
if artist == up_artist and album == up_album and title == up_title:
#logger.debug("Found match!")
return gmusic_song
return None
def sync_library(self):
logger.debug("Syncing")
uploaded_songs = self.mm.get_all_songs()
scanned_songs = self.get_all_songs()
logger.debug("found %d scanned songs" % len(scanned_songs))
# Go through all songs marked 'scanned' and search for a matching that's already been uploaded.
# If we find one, grab the id and mark the song as uploaded
for song_path in scanned_songs.keys():
# Since we only have the path, scan its tags to get the meta data
audioFile = eyed3.load(song_path)
if audioFile and audioFile.tag:
local_song = scanned_songs[song_path]
gmusic_song = User._find_gmusic_song(audioFile.tag, uploaded_songs)
# Now make sure our static is in sync, possibilities:
# 1) We show it as uploaded but google doesn't -> mark it as 'scanned', remove our id
# 2) Google shows it as uploaded but we don't -> mark it as 'uploaded', add the id
# 3) We both show it as uploaded and the ids match -> do nothing
# 4) Neither of us think it was uploaded -> do nothing
# 5) Google has it but we don't at all -> TODO!! (option for download?) we'll need to detect this another way (currently searching only by scanned songs)
if gmusic_song:
# Google shows this song
if local_song['status'] == FileStatus.Scanned:
# Google shows it as uploaded but we don't. Mark it as uploaded and update the id
#logger.debug("'%s - %s - %s' was already uploaded, updating its id to %s" % (gmusic_song['artist'], gmusic_song['album'], gmusic_song['title'], gmusic_song['id']))
self._update_path(song_path, FileStatus.Uploaded, gmusic_song['id'], override=True)
elif local_song['status'] == FileStatus.Uploaded:
# We both show it as uploaded, make sure ids match
if local_song['id'] != gmusic_song['id']:
#logger.debug("Ids differ! Updating to use google's id")
self._update_path(song_path, FileStatus.Uploaded, gmusic_song['id'], override=True)
else:
pass
#logger.debug("Ids match! No update needed")
else:
# No matching song on google found
if local_song['status'] == FileStatus.Uploaded:
#logger.debug("We show the song as uploaded but google doesn't, changing status to scanned and clearing id")
self._update_path(song_path, FileStatus.Scanned, override=True)
else:
pass
#logger.debug("Neither side thinks it's uploaded, no update needed")
else:
logger.debug("Error loading metadata for song %s" % song_path)
def upload(self, file_path):
uploaded, matched, not_uploaded = self.mm.upload(file_path, enable_matching=False) # async me!
if uploaded:
logger.info("Uploaded song %s with ID %s" % (file_path, uploaded[file_path]))
self._update_path(file_path, FileStatus.Uploaded, uploaded[file_path])
if matched:
logger.info("Matched song %s with ID %s" % (file_path, matched[file_path]))
self._update_path(file_path, FileStatus.Uploaded, uploaded[file_path])
if not_uploaded:
reason_string = not_uploaded[file_path]
if "ALREADY_EXISTS" in reason_string:
song_id = reason_string[reason_string.find("(") + 1 : reason_string.find(")")]
logger.info("Song already exists with ID %s, updating database" % song_id)
# The song ID is located within parentheses in the reason string
self._update_path(file_path, FileStatus.Uploaded, song_id)
else:
logger.info("Unable to upload song %s because %s" % (file_path, reason_string))
self._update_path(file_path, FileStatus.Error, reason_string)
def get_all_songs(self):
songs = {}
with self.db_lock:
con = sql.connect(os.path.join(self.app_data_dir, self.email, DB_NAME))
with con:
cur = con.cursor()
for row in cur.execute('''SELECT * FROM songs'''):
song_path = row[0]
song_id = row[1]
song_status = row[2]
songs[song_path] = {'id': song_id,
'status': song_status}
return songs
class GoolgeMusicUploader(object):
"Google music upload class"
def __init__(self, config):
self.credential_file = ''
if len(config.googleplay_credential_file) > 0:
self.credential_file = config.googleplay_credential_file
else:
self.credential_file = clients.OAUTH_FILEPATH
self.mac_address = config.mac_address_for_gplay
self.manager = Musicmanager(False)
self.logger = logging.getLogger(__name__)
def login(self):
"Logs in"
if not self.manager.login(self.credential_file, self.mac_address):
raise AuthError(
'Could not authenticate music manager using {}'.format(
self.credential_file))
def logout(self):
"Logs out"
if self.manager.is_authenticated:
success = self.manager.logout()
if success:
self.logger.info('Logged out of Google Play Music')
else:
self.logger.warning('Failed to log out of Google Play Music')
def upload(self, track_dir):
"Does the upload."
if not self.manager.is_authenticated:
raise AuthError(
"Music Manager not authenticated. Call 'login' first.")
if not isdir(track_dir):
raise DirectoryNotFoundError(track_dir)
files = absolute_files(track_dir)
info = TrackInfo()
info.load(get_track_info_file(files))
track_file = get_track_file(files)
result = UploadResult(track_dir, track_file, info.full_title)
if track_file == DEFAULT_FILE_NAME:
result.set_failure('MP3 Track file not found')
return result
locked = lock_file_exists(track_dir)
if locked:
result.set_failure('Lock file exists')
return result
metadata = AudioMetadata(track_file)
metadata.apply_album_art(get_album_art_file(files))
metadata.apply_track_info(info)
success, message = self.__upload_file__(track_file)
if success:
result.set_success(message)
else:
result.set_failure(message)
return result
def __upload_file__(self, track_file):
self.logger.info('Uploading %s', track_file)
upload_result = self.manager.upload(track_file)
if upload_result[0] != {}:
return True, upload_result[0]
elif upload_result[1] != {}:
return True, upload_result[2]
elif upload_result[2] != {}:
reason = list(upload_result[2].items())[0]
return False, 'Couldn\'t upload {} because {}'.format(
reason[0], reason[1])
