From b7abdf1973dcde8022df0d963ebea6e3972186da Mon Sep 17 00:00:00 2001 From: Jesse Mullan Date: Sat, 1 Nov 2014 16:23:38 -0700 Subject: [PATCH] Fix E201,E202,E211,E241,E303 whitespace issues --- headphones/albumswitcher.py | 54 +++---- headphones/cache.py | 16 +- headphones/config.py | 20 +-- headphones/getXldProfile.py | 4 +- headphones/helpers.py | 22 +-- headphones/importer.py | 262 +++++++++++++++---------------- headphones/librarysync.py | 58 +++---- headphones/lyrics.py | 2 +- headphones/mb.py | 104 ++++++------ headphones/music_encoder.py | 2 +- headphones/notifiers.py | 14 +- headphones/postprocessor.py | 112 ++++++------- headphones/sab.py | 2 +- headphones/searcher.py | 12 +- headphones/searcher_rutracker.py | 10 +- headphones/transmission.py | 8 +- headphones/webserve.py | 29 ++-- headphones/webstart.py | 2 +- 18 files changed, 366 insertions(+), 367 deletions(-) diff --git a/headphones/albumswitcher.py b/headphones/albumswitcher.py index 30063b24..1f52d0a6 100644 --- a/headphones/albumswitcher.py +++ b/headphones/albumswitcher.py @@ -31,17 +31,17 @@ def switch(AlbumID, ReleaseID): 'SELECT * from alltracks WHERE ReleaseID=?', [ReleaseID]).fetchall() myDB.action('DELETE from tracks WHERE AlbumID=?', [AlbumID]) - controlValueDict = {"AlbumID": AlbumID} + controlValueDict = {"AlbumID": AlbumID} - newValueDict = {"ArtistID": newalbumdata['ArtistID'], - "ArtistName": newalbumdata['ArtistName'], - "AlbumTitle": newalbumdata['AlbumTitle'], - "ReleaseID": newalbumdata['ReleaseID'], - "AlbumASIN": newalbumdata['AlbumASIN'], - "ReleaseDate": newalbumdata['ReleaseDate'], - "Type": newalbumdata['Type'], - "ReleaseCountry": newalbumdata['ReleaseCountry'], - "ReleaseFormat": newalbumdata['ReleaseFormat'] + newValueDict = {"ArtistID": newalbumdata['ArtistID'], + "ArtistName": newalbumdata['ArtistName'], + "AlbumTitle": newalbumdata['AlbumTitle'], + "ReleaseID": newalbumdata['ReleaseID'], + "AlbumASIN": newalbumdata['AlbumASIN'], + "ReleaseDate": newalbumdata['ReleaseDate'], + "Type": newalbumdata['Type'], + "ReleaseCountry": newalbumdata['ReleaseCountry'], + "ReleaseFormat": newalbumdata['ReleaseFormat'] } myDB.upsert("albums", newValueDict, controlValueDict) @@ -53,21 +53,21 @@ def switch(AlbumID, ReleaseID): for track in newtrackdata: - controlValueDict = {"TrackID": track['TrackID'], - "AlbumID": AlbumID} + controlValueDict = {"TrackID": track['TrackID'], + "AlbumID": AlbumID} - newValueDict = {"ArtistID": track['ArtistID'], - "ArtistName": track['ArtistName'], - "AlbumTitle": track['AlbumTitle'], - "AlbumASIN": track['AlbumASIN'], - "ReleaseID": track['ReleaseID'], - "TrackTitle": track['TrackTitle'], - "TrackDuration": track['TrackDuration'], - "TrackNumber": track['TrackNumber'], - "CleanName": track['CleanName'], - "Location": track['Location'], - "Format": track['Format'], - "BitRate": track['BitRate'] + newValueDict = {"ArtistID": track['ArtistID'], + "ArtistName": track['ArtistName'], + "AlbumTitle": track['AlbumTitle'], + "AlbumASIN": track['AlbumASIN'], + "ReleaseID": track['ReleaseID'], + "TrackTitle": track['TrackTitle'], + "TrackDuration": track['TrackDuration'], + "TrackNumber": track['TrackNumber'], + "CleanName": track['CleanName'], + "Location": track['Location'], + "Format": track['Format'], + "BitRate": track['BitRate'] } myDB.upsert("tracks", newValueDict, controlValueDict) @@ -88,9 +88,9 @@ def switch(AlbumID, ReleaseID): havetracks = len(myDB.select( 'SELECT TrackTitle from tracks WHERE ArtistID=? AND Location IS NOT NULL', [newalbumdata['ArtistID']])) - controlValueDict = {"ArtistID": newalbumdata['ArtistID']} + controlValueDict = {"ArtistID": newalbumdata['ArtistID']} - newValueDict = {"TotalTracks": totaltracks, - "HaveTracks": havetracks} + newValueDict = {"TotalTracks": totaltracks, + "HaveTracks": havetracks} myDB.upsert("artists", newValueDict, controlValueDict) diff --git a/headphones/cache.py b/headphones/cache.py index 49e9023e..13bdf775 100644 --- a/headphones/cache.py +++ b/headphones/cache.py @@ -191,11 +191,11 @@ class Cache(object): if not db_info or not db_info['LastUpdated'] or not self._is_current(date=db_info['LastUpdated']): self._update_cache() - info_dict = { 'Summary': self.info_summary, 'Content': self.info_content } + info_dict = {'Summary': self.info_summary, 'Content': self.info_content} return info_dict else: - info_dict = { 'Summary': db_info['Summary'], 'Content': db_info['Content'] } + info_dict = {'Summary': db_info['Summary'], 'Content': db_info['Content']} return info_dict def get_image_links(self, ArtistID=None, AlbumID=None): @@ -240,7 +240,7 @@ class Cache(object): if not thumb_url: logger.debug('No album thumbnail image found on last.fm') - return {'artwork': image_url, 'thumbnail': thumb_url } + return {'artwork': image_url, 'thumbnail': thumb_url} def remove_from_cache(self, ArtistID=None, AlbumID=None): """ @@ -343,13 +343,13 @@ class Cache(object): #Save the content & summary to the database no matter what if we've opened up the url if self.id_type == 'artist': - controlValueDict = {"ArtistID": self.id} + controlValueDict = {"ArtistID": self.id} else: - controlValueDict = {"ReleaseGroupID": self.id} + controlValueDict = {"ReleaseGroupID": self.id} - newValueDict = {"Summary": self.info_summary, - "Content": self.info_content, - "LastUpdated": helpers.today()} + newValueDict = {"Summary": self.info_summary, + "Content": self.info_content, + "LastUpdated": helpers.today()} myDB.upsert("descriptions", newValueDict, controlValueDict) diff --git a/headphones/config.py b/headphones/config.py index e20ea9c1..079e2e1d 100644 --- a/headphones/config.py +++ b/headphones/config.py @@ -381,16 +381,16 @@ class Config(object): if self.CONFIG_VERSION == '1': from headphones.helpers import replace_all file_values = { - 'Track': '$Track', - 'Title': '$Title', - 'Artist': '$Artist', - 'Album': '$Album', - 'Year': '$Year', - 'track': '$track', - 'title': '$title', - 'artist': '$artist', - 'album': '$album', - 'year': '$year' + 'Track': '$Track', + 'Title': '$Title', + 'Artist': '$Artist', + 'Album': '$Album', + 'Year': '$Year', + 'track': '$track', + 'title': '$title', + 'artist': '$artist', + 'album': '$album', + 'year': '$year' } folder_values = { 'Artist': '$Artist', diff --git a/headphones/getXldProfile.py b/headphones/getXldProfile.py index b17e2244..d52c5b2d 100755 --- a/headphones/getXldProfile.py +++ b/headphones/getXldProfile.py @@ -12,11 +12,11 @@ def getXldProfile(xldProfile): try: preferences = plistlib.Plist.fromFile(expandedPath) except (expat.ExpatError): - os.system("/usr/bin/plutil -convert xml1 %s" % expandedPath ) + os.system("/usr/bin/plutil -convert xml1 %s" % expandedPath) try: preferences = plistlib.Plist.fromFile(expandedPath) except (ImportError): - os.system("/usr/bin/plutil -convert binary1 %s" % expandedPath ) + os.system("/usr/bin/plutil -convert binary1 %s" % expandedPath) logger.info('The plist at "%s" has a date in it, and therefore is not useable.' % expandedPath) return(xldProfileNotFound, None, None) except (ImportError): diff --git a/headphones/helpers.py b/headphones/helpers.py index e1fc3045..4fa66a92 100644 --- a/headphones/helpers.py +++ b/headphones/helpers.py @@ -33,7 +33,7 @@ RE_CD = re.compile(r"^(CD|dics)\s*[0-9]+$", re.I) def multikeysort(items, columns): - comparers = [ ((itemgetter(col[1:].strip()), -1) if col.startswith('-') else (itemgetter(col.strip()), 1)) for col in columns] + comparers = [((itemgetter(col[1:].strip()), -1) if col.startswith('-') else (itemgetter(col.strip()), 1)) for col in columns] def comparer(left, right): for fn, mult in comparers: @@ -290,7 +290,7 @@ def expand_subfolders(f): return # Split into path components - media_folders = [ split_path(media_folder) for media_folder in media_folders ] + media_folders = [split_path(media_folder) for media_folder in media_folders] # Correct folder endings such as CD1 etc. for index, media_folder in enumerate(media_folders): @@ -298,7 +298,7 @@ def expand_subfolders(f): media_folders[index] = media_folders[index][:-1] # Verify the result by computing path depth relative to root. - path_depths = [ len(media_folder) for media_folder in media_folders ] + path_depths = [len(media_folder) for media_folder in media_folders] difference = max(path_depths) - min(path_depths) if difference > 0: @@ -308,15 +308,15 @@ def expand_subfolders(f): # directory may contain separate CD's and maybe some extra's. The # structure may look like X albums at same depth, and (one or more) # extra folders with a higher depth. - extra_media_folders = [ media_folder[:min(path_depths)] for media_folder in media_folders if len(media_folder) > min(path_depths) ] - extra_media_folders = list(set([ os.path.join(*media_folder) for media_folder in extra_media_folders ])) + extra_media_folders = [media_folder[:min(path_depths)] for media_folder in media_folders if len(media_folder) > min(path_depths)] + extra_media_folders = list(set([os.path.join(*media_folder) for media_folder in extra_media_folders])) logger.info("Please look at the following folder(s), since they cause the depth difference: %s", extra_media_folders) return # Convert back to paths and remove duplicates, which may be there after # correcting the paths - media_folders = list(set([ os.path.join(*media_folder) for media_folder in media_folders ])) + media_folders = list(set([os.path.join(*media_folder) for media_folder in media_folders])) # Don't return a result if the number of subfolders is one. In this case, # this algorithm will not improve processing and will likely interfere @@ -406,9 +406,9 @@ def extract_metadata(f): return (None, None, None) # Count distinct values - artists = list(set([ x[0] for x in results ])) - albums = list(set([ x[1] for x in results ])) - years = list(set([ x[2] for x in results ])) + artists = list(set([x[0] for x in results])) + albums = list(set([x[1] for x in results])) + years = list(set([x[2] for x in results])) # Remove things such as CD2 from album names if len(albums) > 1: @@ -436,8 +436,8 @@ def extract_metadata(f): # (Lots of) different artists. Could be a featuring album, so test for this. if len(artists) > 1 and len(albums) == 1: - split_artists = [ RE_FEATURING.split(artist) for artist in artists ] - featurings = [ len(split_artist) - 1 for split_artist in split_artists ] + split_artists = [RE_FEATURING.split(artist) for artist in artists] + featurings = [len(split_artist) - 1 for split_artist in split_artists] logger.info("Album seem to feature %d different artists", sum(featurings)) if sum(featurings) > 0: diff --git a/headphones/importer.py b/headphones/importer.py index a7482523..a7e3ae3d 100644 --- a/headphones/importer.py +++ b/headphones/importer.py @@ -133,19 +133,19 @@ def addArtisttoDB(artistid, extrasonly=False, forcefull=False): # We need the current minimal info in the database instantly # so we don't throw a 500 error when we redirect to the artistPage - controlValueDict = {"ArtistID": artistid} + controlValueDict = {"ArtistID": artistid} # Don't replace a known artist name with an "Artist ID" placeholder dbartist = myDB.action('SELECT * FROM artists WHERE ArtistID=?', [artistid]).fetchone() # Only modify the Include Extras stuff if it's a new artist. We need it early so we know what to fetch if not dbartist: - newValueDict = {"ArtistName": "Artist ID: %s" % (artistid), - "Status": "Loading", + newValueDict = {"ArtistName": "Artist ID: %s" % (artistid), + "Status": "Loading", "IncludeExtras": headphones.CONFIG.INCLUDE_EXTRAS, - "Extras": headphones.CONFIG.EXTRAS } + "Extras": headphones.CONFIG.EXTRAS} else: - newValueDict = {"Status": "Loading"} + newValueDict = {"Status": "Loading"} myDB.upsert("artists", newValueDict, controlValueDict) @@ -162,10 +162,10 @@ def addArtisttoDB(artistid, extrasonly=False, forcefull=False): if not artist: logger.warn("Error fetching artist info. ID: " + artistid) if dbartist is None: - newValueDict = {"ArtistName": "Fetch failed, try refreshing. (%s)" % (artistid), - "Status": "Active"} + newValueDict = {"ArtistName": "Fetch failed, try refreshing. (%s)" % (artistid), + "Status": "Active"} else: - newValueDict = {"Status": "Active"} + newValueDict = {"Status": "Active"} myDB.upsert("artists", newValueDict, controlValueDict) return @@ -175,11 +175,11 @@ def addArtisttoDB(artistid, extrasonly=False, forcefull=False): sortname = artist['artist_name'] logger.info(u"Now adding/updating: " + artist['artist_name']) - controlValueDict = {"ArtistID": artistid} - newValueDict = {"ArtistName": artist['artist_name'], - "ArtistSortName": sortname, - "DateAdded": helpers.today(), - "Status": "Loading"} + controlValueDict = {"ArtistID": artistid} + newValueDict = {"ArtistName": artist['artist_name'], + "ArtistSortName": sortname, + "DateAdded": helpers.today(), + "Status": "Loading"} myDB.upsert("artists", newValueDict, controlValueDict) @@ -292,26 +292,26 @@ def addArtisttoDB(artistid, extrasonly=False, forcefull=False): for items in find_hybrid_releases: if items['ReleaseID'] != rg['id']: #don't include hybrid information, since that's what we're replacing hybrid_release_id = items['ReleaseID'] - newValueDict = {"ArtistID": items['ArtistID'], - "ArtistName": items['ArtistName'], - "AlbumTitle": items['AlbumTitle'], - "AlbumID": items['AlbumID'], - "AlbumASIN": items['AlbumASIN'], - "ReleaseDate": items['ReleaseDate'], - "Type": items['Type'], - "ReleaseCountry": items['ReleaseCountry'], - "ReleaseFormat": items['ReleaseFormat'] + newValueDict = {"ArtistID": items['ArtistID'], + "ArtistName": items['ArtistName'], + "AlbumTitle": items['AlbumTitle'], + "AlbumID": items['AlbumID'], + "AlbumASIN": items['AlbumASIN'], + "ReleaseDate": items['ReleaseDate'], + "Type": items['Type'], + "ReleaseCountry": items['ReleaseCountry'], + "ReleaseFormat": items['ReleaseFormat'] } find_hybrid_tracks = myDB.action("SELECT * from alltracks WHERE ReleaseID=?", [hybrid_release_id]) totalTracks = 1 hybrid_track_array = [] for hybrid_tracks in find_hybrid_tracks: hybrid_track_array.append({ - 'number': hybrid_tracks['TrackNumber'], - 'title': hybrid_tracks['TrackTitle'], - 'id': hybrid_tracks['TrackID'], + 'number': hybrid_tracks['TrackNumber'], + 'title': hybrid_tracks['TrackTitle'], + 'id': hybrid_tracks['TrackID'], #'url': hybrid_tracks['TrackURL'], - 'duration': hybrid_tracks['TrackDuration'] + 'duration': hybrid_tracks['TrackDuration'] }) totalTracks += 1 newValueDict['ReleaseID'] = hybrid_release_id @@ -331,15 +331,15 @@ def addArtisttoDB(artistid, extrasonly=False, forcefull=False): # Use the ReleaseGroupID as the ReleaseID for the hybrid release to differentiate it # We can then use the condition WHERE ReleaseID == ReleaseGroupID to select it # The hybrid won't have a country or a format - controlValueDict = {"ReleaseID": rg['id']} + controlValueDict = {"ReleaseID": rg['id']} - newValueDict = {"ArtistID": artistid, - "ArtistName": artist['artist_name'], - "AlbumTitle": rg['title'], - "AlbumID": rg['id'], - "AlbumASIN": hybridrelease['AlbumASIN'], - "ReleaseDate": hybridrelease['ReleaseDate'], - "Type": rg['type'] + newValueDict = {"ArtistID": artistid, + "ArtistName": artist['artist_name'], + "AlbumTitle": rg['title'], + "AlbumID": rg['id'], + "AlbumASIN": hybridrelease['AlbumASIN'], + "ReleaseDate": hybridrelease['ReleaseDate'], + "Type": rg['type'] } myDB.upsert("allalbums", newValueDict, controlValueDict) @@ -348,18 +348,18 @@ def addArtisttoDB(artistid, extrasonly=False, forcefull=False): cleanname = helpers.cleanName(artist['artist_name'] + ' ' + rg['title'] + ' ' + track['title']) - controlValueDict = {"TrackID": track['id'], - "ReleaseID": rg['id']} + controlValueDict = {"TrackID": track['id'], + "ReleaseID": rg['id']} - newValueDict = {"ArtistID": artistid, - "ArtistName": artist['artist_name'], - "AlbumTitle": rg['title'], - "AlbumASIN": hybridrelease['AlbumASIN'], - "AlbumID": rg['id'], - "TrackTitle": track['title'], - "TrackDuration": track['duration'], - "TrackNumber": track['number'], - "CleanName": cleanname + newValueDict = {"ArtistID": artistid, + "ArtistName": artist['artist_name'], + "AlbumTitle": rg['title'], + "AlbumASIN": hybridrelease['AlbumASIN'], + "AlbumID": rg['id'], + "TrackTitle": track['title'], + "TrackDuration": track['duration'], + "TrackNumber": track['number'], + "CleanName": cleanname } match = myDB.action('SELECT Location, BitRate, Format from have WHERE CleanName=?', [cleanname]).fetchone() @@ -392,17 +392,17 @@ def addArtisttoDB(artistid, extrasonly=False, forcefull=False): album = myDB.action('SELECT * from allalbums WHERE ReleaseID=?', [releaseid]).fetchone() - controlValueDict = {"AlbumID": rg['id']} + controlValueDict = {"AlbumID": rg['id']} - newValueDict = {"ArtistID": album['ArtistID'], - "ArtistName": album['ArtistName'], - "AlbumTitle": album['AlbumTitle'], - "ReleaseID": album['ReleaseID'], - "AlbumASIN": album['AlbumASIN'], - "ReleaseDate": album['ReleaseDate'], - "Type": album['Type'], - "ReleaseCountry": album['ReleaseCountry'], - "ReleaseFormat": album['ReleaseFormat'] + newValueDict = {"ArtistID": album['ArtistID'], + "ArtistName": album['ArtistName'], + "AlbumTitle": album['AlbumTitle'], + "ReleaseID": album['ReleaseID'], + "AlbumASIN": album['AlbumASIN'], + "ReleaseDate": album['ReleaseDate'], + "Type": album['Type'], + "ReleaseCountry": album['ReleaseCountry'], + "ReleaseFormat": album['ReleaseFormat'] } if rg_exists: @@ -440,21 +440,21 @@ def addArtisttoDB(artistid, extrasonly=False, forcefull=False): continue for track in tracks: - controlValueDict = {"TrackID": track['TrackID'], - "AlbumID": rg['id']} + controlValueDict = {"TrackID": track['TrackID'], + "AlbumID": rg['id']} - newValueDict = {"ArtistID": track['ArtistID'], - "ArtistName": track['ArtistName'], - "AlbumTitle": track['AlbumTitle'], - "AlbumASIN": track['AlbumASIN'], - "ReleaseID": track['ReleaseID'], - "TrackTitle": track['TrackTitle'], - "TrackDuration": track['TrackDuration'], - "TrackNumber": track['TrackNumber'], - "CleanName": track['CleanName'], - "Location": track['Location'], - "Format": track['Format'], - "BitRate": track['BitRate'] + newValueDict = {"ArtistID": track['ArtistID'], + "ArtistName": track['ArtistName'], + "AlbumTitle": track['AlbumTitle'], + "AlbumASIN": track['AlbumASIN'], + "ReleaseID": track['ReleaseID'], + "TrackTitle": track['TrackTitle'], + "TrackDuration": track['TrackDuration'], + "TrackNumber": track['TrackNumber'], + "CleanName": track['CleanName'], + "Location": track['Location'], + "Format": track['Format'], + "BitRate": track['BitRate'] } myDB.upsert("tracks", newValueDict, controlValueDict) @@ -515,19 +515,19 @@ def finalize_update(artistid, artistname, errors=False): #havetracks = len(myDB.select('SELECT TrackTitle from tracks WHERE ArtistID=? AND Location IS NOT NULL', [artistid])) + len(myDB.select('SELECT TrackTitle from have WHERE ArtistName like ?', [artist['artist_name']])) havetracks = len(myDB.select('SELECT TrackTitle from tracks WHERE ArtistID=? AND Location IS NOT NULL', [artistid])) + len(myDB.select('SELECT TrackTitle from have WHERE ArtistName like ? AND Matched = "Failed"', [artistname])) - controlValueDict = {"ArtistID": artistid} + controlValueDict = {"ArtistID": artistid} if latestalbum: - newValueDict = {"Status": "Active", - "LatestAlbum": latestalbum['AlbumTitle'], - "ReleaseDate": latestalbum['ReleaseDate'], - "AlbumID": latestalbum['AlbumID'], - "TotalTracks": totaltracks, - "HaveTracks": havetracks} + newValueDict = {"Status": "Active", + "LatestAlbum": latestalbum['AlbumTitle'], + "ReleaseDate": latestalbum['ReleaseDate'], + "AlbumID": latestalbum['AlbumID'], + "TotalTracks": totaltracks, + "HaveTracks": havetracks} else: - newValueDict = {"Status": "Active", - "TotalTracks": totaltracks, - "HaveTracks": havetracks} + newValueDict = {"Status": "Active", + "TotalTracks": totaltracks, + "HaveTracks": havetracks} if not errors: newValueDict['LastUpdated'] = helpers.now() @@ -545,10 +545,10 @@ def addReleaseById(rid, rgid=None): dbalbum = myDB.select("SELECT * from albums WHERE AlbumID=?", [rgid]) if not dbalbum: status = 'Loading' - controlValueDict = {"AlbumID": rgid} - newValueDict = {"AlbumTitle": rgid, - "ArtistName": status, - "Status": status} + controlValueDict = {"AlbumID": rgid} + newValueDict = {"AlbumTitle": rgid, + "ArtistName": status, + "Status": status} myDB.upsert("albums", newValueDict, controlValueDict) time.sleep(1) @@ -592,11 +592,11 @@ def addReleaseById(rid, rgid=None): sortname = release_dict['artist_name'] logger.info(u"Now manually adding: " + release_dict['artist_name'] + " - with status Paused") - controlValueDict = {"ArtistID": release_dict['artist_id']} - newValueDict = {"ArtistName": release_dict['artist_name'], - "ArtistSortName": sortname, - "DateAdded": helpers.today(), - "Status": "Paused"} + controlValueDict = {"ArtistID": release_dict['artist_id']} + newValueDict = {"ArtistName": release_dict['artist_name'], + "ArtistSortName": sortname, + "DateAdded": helpers.today(), + "Status": "Paused"} if headphones.CONFIG.INCLUDE_EXTRAS: newValueDict['IncludeExtras'] = 1 @@ -613,20 +613,20 @@ def addReleaseById(rid, rgid=None): if not rg_exists and release_dict or status == 'Loading' and release_dict: #it should never be the case that we have an rg and not the artist #but if it is this will fail logger.info(u"Now adding-by-id album (" + release_dict['title'] + ") from id: " + rgid) - controlValueDict = {"AlbumID": rgid} + controlValueDict = {"AlbumID": rgid} if status != 'Loading': status = 'Wanted' - newValueDict = {"ArtistID": release_dict['artist_id'], - "ReleaseID": rgid, - "ArtistName": release_dict['artist_name'], - "AlbumTitle": release_dict['title'] if 'title' in release_dict else release_dict['rg_title'], - "AlbumASIN": release_dict['asin'], - "ReleaseDate": release_dict['date'], - "DateAdded": helpers.today(), - "Status": status, - "Type": release_dict['rg_type'], - "ReleaseID": rid + newValueDict = {"ArtistID": release_dict['artist_id'], + "ReleaseID": rgid, + "ArtistName": release_dict['artist_name'], + "AlbumTitle": release_dict['title'] if 'title' in release_dict else release_dict['rg_title'], + "AlbumASIN": release_dict['asin'], + "ReleaseDate": release_dict['date'], + "DateAdded": helpers.today(), + "Status": status, + "Type": release_dict['rg_type'], + "ReleaseID": rid } myDB.upsert("albums", newValueDict, controlValueDict) @@ -637,16 +637,16 @@ def addReleaseById(rid, rgid=None): for track in release_dict['tracks']: cleanname = helpers.cleanName(release_dict['artist_name'] + ' ' + release_dict['rg_title'] + ' ' + track['title']) - controlValueDict = {"TrackID": track['id'], - "AlbumID": rgid} - newValueDict = {"ArtistID": release_dict['artist_id'], - "ArtistName": release_dict['artist_name'], - "AlbumTitle": release_dict['rg_title'], - "AlbumASIN": release_dict['asin'], - "TrackTitle": track['title'], - "TrackDuration": track['duration'], - "TrackNumber": track['number'], - "CleanName": cleanname + controlValueDict = {"TrackID": track['id'], + "AlbumID": rgid} + newValueDict = {"ArtistID": release_dict['artist_id'], + "ArtistName": release_dict['artist_name'], + "AlbumTitle": release_dict['rg_title'], + "AlbumASIN": release_dict['asin'], + "TrackTitle": track['title'], + "TrackDuration": track['duration'], + "TrackNumber": track['number'], + "CleanName": cleanname } match = myDB.action('SELECT Location, BitRate, Format, Matched from have WHERE CleanName=?', [cleanname]).fetchone() @@ -671,11 +671,11 @@ def addReleaseById(rid, rgid=None): # Reset status if status == 'Loading': - controlValueDict = {"AlbumID": rgid} + controlValueDict = {"AlbumID": rgid} if headphones.CONFIG.AUTOWANT_MANUALLY_ADDED: - newValueDict = {"Status": "Wanted"} + newValueDict = {"Status": "Wanted"} else: - newValueDict = {"Status": "Skipped"} + newValueDict = {"Status": "Skipped"} myDB.upsert("albums", newValueDict, controlValueDict) # Start a search for the album @@ -703,7 +703,7 @@ def updateFormat(): except Exception, e: logger.info("Exception from MediaFile for: " + track['Location'] + " : " + str(e)) continue - controlValueDict = {"TrackID": track['TrackID']} + controlValueDict = {"TrackID": track['TrackID']} newValueDict = {"Format": f.format} myDB.upsert("tracks", newValueDict, controlValueDict) logger.info('Finished finding media format for %s files' % len(tracks)) @@ -716,7 +716,7 @@ def updateFormat(): except Exception, e: logger.info("Exception from MediaFile for: " + track['Location'] + " : " + str(e)) continue - controlValueDict = {"TrackID": track['TrackID']} + controlValueDict = {"TrackID": track['TrackID']} newValueDict = {"Format": f.format} myDB.upsert("have", newValueDict, controlValueDict) logger.info('Finished finding media format for %s files' % len(havetracks)) @@ -734,18 +734,18 @@ def getHybridRelease(fullreleaselist): sortable_release_list = [] formats = { - '2xVinyl': '2', - 'Vinyl': '2', - 'CD': '0', - 'Cassette': '3', - '2xCD': '1', - 'Digital Media': '0' + '2xVinyl': '2', + 'Vinyl': '2', + 'CD': '0', + 'Cassette': '3', + '2xCD': '1', + 'Digital Media': '0' } countries = { - 'US': '0', - 'GB': '1', - 'JP': '2', + 'US': '0', + 'GB': '1', + 'JP': '2', } for release in fullreleaselist: @@ -762,14 +762,14 @@ def getHybridRelease(fullreleaselist): # Create record release_dict = { - 'hasasin': bool(release['AlbumASIN']), - 'asin': release['AlbumASIN'], - 'trackscount': len(release['Tracks']), - 'releaseid': release['ReleaseID'], - 'releasedate': release['ReleaseDate'], - 'format': format, - 'country': country, - 'tracks': release['Tracks'] + 'hasasin': bool(release['AlbumASIN']), + 'asin': release['AlbumASIN'], + 'trackscount': len(release['Tracks']), + 'releaseid': release['ReleaseID'], + 'releasedate': release['ReleaseDate'], + 'format': format, + 'country': country, + 'tracks': release['Tracks'] } sortable_release_list.append(release_dict) diff --git a/headphones/librarysync.py b/headphones/librarysync.py index 43919413..a0f97431 100644 --- a/headphones/librarysync.py +++ b/headphones/librarysync.py @@ -136,7 +136,7 @@ def libraryScan(dir=None, append=False, ArtistID=None, ArtistName=None, cron=Fal controlValueDict = {'Location': unicode_song_path} - newValueDict = { 'TrackID': f.mb_trackid, + newValueDict = {'TrackID': f.mb_trackid, #'ReleaseID' : f.mb_albumid, 'ArtistName': f_artist, 'AlbumTitle': f.album, @@ -221,72 +221,72 @@ def libraryScan(dir=None, append=False, ArtistID=None, ArtistName=None, cron=Fal track = myDB.action('SELECT ArtistName, AlbumTitle, TrackTitle, AlbumID from tracks WHERE ArtistName LIKE ? AND AlbumTitle LIKE ? AND TrackTitle LIKE ?', [song['ArtistName'], song['AlbumTitle'], song['TrackTitle']]).fetchone() have_updated = False if track: - controlValueDict = { 'ArtistName': track['ArtistName'], + controlValueDict = {'ArtistName': track['ArtistName'], 'AlbumTitle': track['AlbumTitle'], - 'TrackTitle': track['TrackTitle'] } - newValueDict = { 'Location': song['Location'], + 'TrackTitle': track['TrackTitle']} + newValueDict = {'Location': song['Location'], 'BitRate': song['BitRate'], - 'Format': song['Format'] } + 'Format': song['Format']} myDB.upsert("tracks", newValueDict, controlValueDict) - controlValueDict2 = { 'Location': song['Location']} - newValueDict2 = { 'Matched': track['AlbumID']} + controlValueDict2 = {'Location': song['Location']} + newValueDict2 = {'Matched': track['AlbumID']} myDB.upsert("have", newValueDict2, controlValueDict2) have_updated = True else: track = myDB.action('SELECT CleanName, AlbumID from tracks WHERE CleanName LIKE ?', [song['CleanName']]).fetchone() if track: - controlValueDict = { 'CleanName': track['CleanName']} - newValueDict = { 'Location': song['Location'], + controlValueDict = {'CleanName': track['CleanName']} + newValueDict = {'Location': song['Location'], 'BitRate': song['BitRate'], - 'Format': song['Format'] } + 'Format': song['Format']} myDB.upsert("tracks", newValueDict, controlValueDict) - controlValueDict2 = { 'Location': song['Location']} - newValueDict2 = { 'Matched': track['AlbumID']} + controlValueDict2 = {'Location': song['Location']} + newValueDict2 = {'Matched': track['AlbumID']} myDB.upsert("have", newValueDict2, controlValueDict2) have_updated = True else: - controlValueDict2 = { 'Location': song['Location']} - newValueDict2 = { 'Matched': "Failed"} + controlValueDict2 = {'Location': song['Location']} + newValueDict2 = {'Matched': "Failed"} myDB.upsert("have", newValueDict2, controlValueDict2) have_updated = True alltrack = myDB.action('SELECT ArtistName, AlbumTitle, TrackTitle, AlbumID from alltracks WHERE ArtistName LIKE ? AND AlbumTitle LIKE ? AND TrackTitle LIKE ?', [song['ArtistName'], song['AlbumTitle'], song['TrackTitle']]).fetchone() if alltrack: - controlValueDict = { 'ArtistName': alltrack['ArtistName'], + controlValueDict = {'ArtistName': alltrack['ArtistName'], 'AlbumTitle': alltrack['AlbumTitle'], - 'TrackTitle': alltrack['TrackTitle'] } - newValueDict = { 'Location': song['Location'], + 'TrackTitle': alltrack['TrackTitle']} + newValueDict = {'Location': song['Location'], 'BitRate': song['BitRate'], - 'Format': song['Format'] } + 'Format': song['Format']} myDB.upsert("alltracks", newValueDict, controlValueDict) - controlValueDict2 = { 'Location': song['Location']} - newValueDict2 = { 'Matched': alltrack['AlbumID']} + controlValueDict2 = {'Location': song['Location']} + newValueDict2 = {'Matched': alltrack['AlbumID']} myDB.upsert("have", newValueDict2, controlValueDict2) else: alltrack = myDB.action('SELECT CleanName, AlbumID from alltracks WHERE CleanName LIKE ?', [song['CleanName']]).fetchone() if alltrack: - controlValueDict = { 'CleanName': alltrack['CleanName']} - newValueDict = { 'Location': song['Location'], + controlValueDict = {'CleanName': alltrack['CleanName']} + newValueDict = {'Location': song['Location'], 'BitRate': song['BitRate'], - 'Format': song['Format'] } + 'Format': song['Format']} myDB.upsert("alltracks", newValueDict, controlValueDict) - controlValueDict2 = { 'Location': song['Location']} - newValueDict2 = { 'Matched': alltrack['AlbumID']} + controlValueDict2 = {'Location': song['Location']} + newValueDict2 = {'Matched': alltrack['AlbumID']} myDB.upsert("have", newValueDict2, controlValueDict2) else: # alltracks may not exist if adding album manually, have should only be set to failed if not already updated in tracks if not have_updated: - controlValueDict2 = { 'Location': song['Location']} - newValueDict2 = { 'Matched': "Failed"} + controlValueDict2 = {'Location': song['Location']} + newValueDict2 = {'Matched': "Failed"} myDB.upsert("have", newValueDict2, controlValueDict2) else: - controlValueDict2 = { 'Location': song['Location']} - newValueDict2 = { 'Matched': "Failed"} + controlValueDict2 = {'Location': song['Location']} + newValueDict2 = {'Matched': "Failed"} myDB.upsert("have", newValueDict2, controlValueDict2) #######myDB.action('INSERT INTO have (ArtistName, AlbumTitle, TrackNumber, TrackTitle, TrackLength, BitRate, Genre, Date, TrackID, Location, CleanName, Format) VALUES( ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)', [song['ArtistName'], song['AlbumTitle'], song['TrackNumber'], song['TrackTitle'], song['TrackLength'], song['BitRate'], song['Genre'], song['Date'], song['TrackID'], song['Location'], CleanName, song['Format']]) diff --git a/headphones/lyrics.py b/headphones/lyrics.py index 2968725c..066b97c5 100644 --- a/headphones/lyrics.py +++ b/headphones/lyrics.py @@ -21,7 +21,7 @@ from headphones import logger, request def getLyrics(artist, song): - params = { "artist": artist.encode('utf-8'), + params = {"artist": artist.encode('utf-8'), "song": song.encode('utf-8'), "fmt": 'xml' } diff --git a/headphones/mb.py b/headphones/mb.py index d097dced..cca475bb 100644 --- a/headphones/mb.py +++ b/headphones/mb.py @@ -110,7 +110,7 @@ def findArtist(name, limit=1): # Just need the artist id if the limit is 1 # 'name': unicode(result['sort-name']), # 'uniquename': uniquename, - 'id': unicode(result['id']), + 'id': unicode(result['id']), # 'url': unicode("http://musicbrainz.org/artist/" + result['id']),#probably needs to be changed # 'score': int(result['ext:score']) }) @@ -118,11 +118,11 @@ def findArtist(name, limit=1): artistlist.append(artistdict) else: artistlist.append({ - 'name': unicode(result['sort-name']), - 'uniquename': uniquename, - 'id': unicode(result['id']), - 'url': unicode("http://musicbrainz.org/artist/" + result['id']),#probably needs to be changed - 'score': int(result['ext:score']) + 'name': unicode(result['sort-name']), + 'uniquename': uniquename, + 'id': unicode(result['id']), + 'url': unicode("http://musicbrainz.org/artist/" + result['id']),#probably needs to be changed + 'score': int(result['ext:score']) }) return artistlist @@ -189,19 +189,19 @@ def findRelease(name, limit=1, artist=None): rg_type = secondary_type releaselist.append({ - 'uniquename': unicode(result['artist-credit'][0]['artist']['name']), - 'title': unicode(title), - 'id': unicode(result['artist-credit'][0]['artist']['id']), - 'albumid': unicode(result['id']), - 'url': unicode("http://musicbrainz.org/artist/" + result['artist-credit'][0]['artist']['id']),#probably needs to be changed - 'albumurl': unicode("http://musicbrainz.org/release/" + result['id']),#probably needs to be changed - 'score': int(result['ext:score']), - 'date': unicode(result['date']) if 'date' in result else '', - 'country': unicode(result['country']) if 'country' in result else '', - 'formats': unicode(formats), - 'tracks': unicode(tracks), - 'rgid': unicode(result['release-group']['id']), - 'rgtype': unicode(rg_type) + 'uniquename': unicode(result['artist-credit'][0]['artist']['name']), + 'title': unicode(title), + 'id': unicode(result['artist-credit'][0]['artist']['id']), + 'albumid': unicode(result['id']), + 'url': unicode("http://musicbrainz.org/artist/" + result['artist-credit'][0]['artist']['id']),#probably needs to be changed + 'albumurl': unicode("http://musicbrainz.org/release/" + result['id']),#probably needs to be changed + 'score': int(result['ext:score']), + 'date': unicode(result['date']) if 'date' in result else '', + 'country': unicode(result['country']) if 'country' in result else '', + 'formats': unicode(formats), + 'tracks': unicode(tracks), + 'rgid': unicode(result['release-group']['id']), + 'rgtype': unicode(rg_type) }) return releaselist @@ -259,10 +259,10 @@ def getArtist(artistid, extrasonly=False): if "secondary-type-list" in rg.keys(): #only add releases without a secondary type continue releasegroups.append({ - 'title': unicode(rg['title']), - 'id': unicode(rg['id']), - 'url': u"http://musicbrainz.org/release-group/" + rg['id'], - 'type': unicode(rg['type']) + 'title': unicode(rg['title']), + 'id': unicode(rg['id']), + 'url': u"http://musicbrainz.org/release-group/" + rg['id'], + 'type': unicode(rg['type']) }) # See if we need to grab extras. Artist specific extras take precedence over global option @@ -315,10 +315,10 @@ def getArtist(artistid, extrasonly=False): rg_type = secondary_type releasegroups.append({ - 'title': unicode(rg['title']), - 'id': unicode(rg['id']), - 'url': u"http://musicbrainz.org/release-group/" + rg['id'], - 'type': unicode(rg_type) + 'title': unicode(rg['title']), + 'id': unicode(rg['id']), + 'url': u"http://musicbrainz.org/release-group/" + rg['id'], + 'type': unicode(rg_type) }) artist_dict['releasegroups'] = releasegroups @@ -517,15 +517,15 @@ def get_new_releases(rgid, includeExtras=False, forcefull=False): # tracks into the tracks table controlValueDict = {"ReleaseID": release['ReleaseID']} - newValueDict = {"ArtistID": release['ArtistID'], - "ArtistName": release['ArtistName'], - "AlbumTitle": release['AlbumTitle'], - "AlbumID": release['AlbumID'], - "AlbumASIN": release['AlbumASIN'], - "ReleaseDate": release['ReleaseDate'], - "Type": release['Type'], - "ReleaseCountry": release['ReleaseCountry'], - "ReleaseFormat": release['ReleaseFormat'] + newValueDict = {"ArtistID": release['ArtistID'], + "ArtistName": release['ArtistName'], + "AlbumTitle": release['AlbumTitle'], + "AlbumID": release['AlbumID'], + "AlbumASIN": release['AlbumASIN'], + "ReleaseDate": release['ReleaseDate'], + "Type": release['Type'], + "ReleaseCountry": release['ReleaseCountry'], + "ReleaseFormat": release['ReleaseFormat'] } myDB.upsert("allalbums", newValueDict, controlValueDict) @@ -534,18 +534,18 @@ def get_new_releases(rgid, includeExtras=False, forcefull=False): cleanname = helpers.cleanName(release['ArtistName'] + ' ' + release['AlbumTitle'] + ' ' + track['title']) - controlValueDict = {"TrackID": track['id'], - "ReleaseID": release['ReleaseID']} + controlValueDict = {"TrackID": track['id'], + "ReleaseID": release['ReleaseID']} - newValueDict = {"ArtistID": release['ArtistID'], - "ArtistName": release['ArtistName'], - "AlbumTitle": release['AlbumTitle'], - "AlbumID": release['AlbumID'], - "AlbumASIN": release['AlbumASIN'], - "TrackTitle": track['title'], - "TrackDuration": track['duration'], - "TrackNumber": track['number'], - "CleanName": cleanname + newValueDict = {"ArtistID": release['ArtistID'], + "ArtistName": release['ArtistName'], + "AlbumTitle": release['AlbumTitle'], + "AlbumID": release['AlbumID'], + "AlbumASIN": release['AlbumASIN'], + "TrackTitle": track['title'], + "TrackDuration": track['duration'], + "TrackNumber": track['number'], + "CleanName": cleanname } match = myDB.action('SELECT Location, BitRate, Format from have WHERE CleanName=?', [cleanname]).fetchone() @@ -586,11 +586,11 @@ def getTracksFromRelease(release): except: track_title = unicode(track['recording']['title']) tracks.append({ - 'number': totalTracks, - 'title': track_title, - 'id': unicode(track['recording']['id']), - 'url': u"http://musicbrainz.org/track/" + track['recording']['id'], - 'duration': int(track['length']) if 'length' in track else 0 + 'number': totalTracks, + 'title': track_title, + 'id': unicode(track['recording']['id']), + 'url': u"http://musicbrainz.org/track/" + track['recording']['id'], + 'duration': int(track['length']) if 'length' in track else 0 }) totalTracks += 1 return tracks diff --git a/headphones/music_encoder.py b/headphones/music_encoder.py index 5cbef54d..ee5dcb71 100644 --- a/headphones/music_encoder.py +++ b/headphones/music_encoder.py @@ -131,7 +131,7 @@ def encode(albumPath): else: encode = True elif (headphones.CONFIG.ENCODEROUTPUTFORMAT == 'mp3' or headphones.CONFIG.ENCODEROUTPUTFORMAT == 'm4a'): - if (music.decode(headphones.SYS_ENCODING, 'replace').lower().endswith('.'+headphones.CONFIG.ENCODEROUTPUTFORMAT) and (int(infoMusic.bitrate / 1000 ) <= headphones.CONFIG.BITRATE)): + if (music.decode(headphones.SYS_ENCODING, 'replace').lower().endswith('.'+headphones.CONFIG.ENCODEROUTPUTFORMAT) and (int(infoMusic.bitrate / 1000) <= headphones.CONFIG.BITRATE)): logger.info('%s has bitrate <= %skb, will not be re-encoded', music, headphones.CONFIG.BITRATE) else: encode = True diff --git a/headphones/notifiers.py b/headphones/notifiers.py index d88bfaf0..9cfec86c 100644 --- a/headphones/notifiers.py +++ b/headphones/notifiers.py @@ -149,7 +149,7 @@ class PROWL(object): 'application': 'Headphones', 'event': event, 'description': message.encode("utf-8"), - 'priority': headphones.CONFIG.PROWL_PRIORITY } + 'priority': headphones.CONFIG.PROWL_PRIORITY} http_handler.request("POST", "/publicapi/add", @@ -189,8 +189,8 @@ class MPC(object): pass - def notify( self ): - subprocess.call( ["mpc", "update"] ) + def notify(self): + subprocess.call(["mpc", "update"]) class XBMC(object): @@ -452,12 +452,12 @@ class PUSHBULLET(object): data = {'device_iden': headphones.CONFIG.PUSHBULLET_DEVICEID, 'type': "note", 'title': "Headphones", - 'body': message.encode("utf-8") } + 'body': message.encode("utf-8")} http_handler.request("POST", "/api/pushes", headers={'Content-type': "application/x-www-form-urlencoded", - 'Authorization': 'Basic %s' % base64.b64encode(headphones.CONFIG.PUSHBULLET_APIKEY + ":") }, + 'Authorization': 'Basic %s' % base64.b64encode(headphones.CONFIG.PUSHBULLET_APIKEY + ":")}, body=urlencode(data)) response = http_handler.getresponse() request_status = response.status @@ -504,7 +504,7 @@ class PUSHALOT(object): data = {'AuthorizationToken': pushalot_authorizationtoken, 'Title': event.encode('utf-8'), - 'Body': message.encode("utf-8") } + 'Body': message.encode("utf-8")} http_handler.request("POST", "/api/sendmessage", @@ -590,7 +590,7 @@ class PUSHOVER(object): 'user': headphones.CONFIG.PUSHOVER_KEYS, 'title': event, 'message': message.encode("utf-8"), - 'priority': headphones.CONFIG.PUSHOVER_PRIORITY } + 'priority': headphones.CONFIG.PUSHOVER_PRIORITY} http_handler.request("POST", "/1/messages.json", diff --git a/headphones/postprocessor.py b/headphones/postprocessor.py index 1ed0de51..f699b607 100755 --- a/headphones/postprocessor.py +++ b/headphones/postprocessor.py @@ -109,11 +109,11 @@ def verify(albumid, albumpath, Kind=None, forced=False): else: sortname = release_dict['artist_name'] - controlValueDict = {"ArtistID": release_dict['artist_id']} - newValueDict = {"ArtistName": release_dict['artist_name'], - "ArtistSortName": sortname, - "DateAdded": helpers.today(), - "Status": "Paused"} + controlValueDict = {"ArtistID": release_dict['artist_id']} + newValueDict = {"ArtistName": release_dict['artist_name'], + "ArtistSortName": sortname, + "DateAdded": helpers.today(), + "Status": "Paused"} logger.info("ArtistID: " + release_dict['artist_id'] + " , ArtistName: " + release_dict['artist_name']) @@ -124,17 +124,17 @@ def verify(albumid, albumpath, Kind=None, forced=False): myDB.upsert("artists", newValueDict, controlValueDict) logger.info(u"Now adding album: " + release_dict['title']) - controlValueDict = {"AlbumID": albumid} + controlValueDict = {"AlbumID": albumid} - newValueDict = {"ArtistID": release_dict['artist_id'], - "ReleaseID": albumid, - "ArtistName": release_dict['artist_name'], - "AlbumTitle": release_dict['title'], - "AlbumASIN": release_dict['asin'], - "ReleaseDate": release_dict['date'], - "DateAdded": helpers.today(), - "Type": release_dict['rg_type'], - "Status": "Snatched" + newValueDict = {"ArtistID": release_dict['artist_id'], + "ReleaseID": albumid, + "ArtistName": release_dict['artist_name'], + "AlbumTitle": release_dict['title'], + "AlbumASIN": release_dict['asin'], + "ReleaseDate": release_dict['date'], + "DateAdded": helpers.today(), + "Type": release_dict['rg_type'], + "Status": "Snatched" } myDB.upsert("albums", newValueDict, controlValueDict) @@ -143,22 +143,22 @@ def verify(albumid, albumpath, Kind=None, forced=False): myDB.action('DELETE from tracks WHERE AlbumID=?', [albumid]) for track in release_dict['tracks']: - controlValueDict = {"TrackID": track['id'], - "AlbumID": albumid} + controlValueDict = {"TrackID": track['id'], + "AlbumID": albumid} - newValueDict = {"ArtistID": release_dict['artist_id'], - "ArtistName": release_dict['artist_name'], - "AlbumTitle": release_dict['title'], - "AlbumASIN": release_dict['asin'], - "TrackTitle": track['title'], - "TrackDuration": track['duration'], - "TrackNumber": track['number'] + newValueDict = {"ArtistID": release_dict['artist_id'], + "ArtistName": release_dict['artist_name'], + "AlbumTitle": release_dict['title'], + "AlbumASIN": release_dict['asin'], + "TrackTitle": track['title'], + "TrackDuration": track['duration'], + "TrackNumber": track['number'] } myDB.upsert("tracks", newValueDict, controlValueDict) - controlValueDict = {"ArtistID": release_dict['artist_id']} - newValueDict = {"Status": "Paused"} + controlValueDict = {"ArtistID": release_dict['artist_id']} + newValueDict = {"Status": "Paused"} myDB.upsert("artists", newValueDict, controlValueDict) logger.info(u"Addition complete for: " + release_dict['title'] + " - " + release_dict['artist_name']) @@ -532,12 +532,12 @@ def addAlbumArt(artwork, albumpath, release): except TypeError: year = '' - values = { '$Artist': release['ArtistName'], - '$Album': release['AlbumTitle'], - '$Year': year, - '$artist': release['ArtistName'].lower(), - '$album': release['AlbumTitle'].lower(), - '$year': year + values = {'$Artist': release['ArtistName'], + '$Album': release['AlbumTitle'], + '$Year': year, + '$artist': release['ArtistName'].lower(), + '$album': release['AlbumTitle'].lower(), + '$year': year } album_art_name = helpers.replace_all(headphones.CONFIG.ALBUM_ART_FORMAT.strip(), values) + ".jpg" @@ -616,19 +616,19 @@ def moveFiles(albumpath, release, tracks): except: origfolder = u'' - values = { '$Artist': artist, + values = {'$Artist': artist, '$SortArtist': sortname, - '$Album': album, - '$Year': year, - '$Type': releasetype, + '$Album': album, + '$Year': year, + '$Type': releasetype, '$OriginalFolder': origfolder, - '$First': firstchar.upper(), - '$artist': artist.lower(), + '$First': firstchar.upper(), + '$artist': artist.lower(), '$sortartist': sortname.lower(), - '$album': album.lower(), - '$year': year, - '$type': releasetype.lower(), - '$first': firstchar.lower(), + '$album': album.lower(), + '$year': year, + '$type': releasetype.lower(), + '$first': firstchar.lower(), '$originalfolder': origfolder.lower() } @@ -966,20 +966,20 @@ def renameFiles(albumpath, downloaded_track_list, release): else: sortname = artistname - values = { '$Disc': discnumber, - '$Track': tracknumber, - '$Title': title, - '$Artist': artistname, - '$SortArtist': sortname, - '$Album': release['AlbumTitle'], - '$Year': year, - '$disc': discnumber, - '$track': tracknumber, - '$title': title.lower(), - '$artist': artistname.lower(), - '$sortartist': sortname.lower(), - '$album': release['AlbumTitle'].lower(), - '$year': year + values = {'$Disc': discnumber, + '$Track': tracknumber, + '$Title': title, + '$Artist': artistname, + '$SortArtist': sortname, + '$Album': release['AlbumTitle'], + '$Year': year, + '$disc': discnumber, + '$track': tracknumber, + '$title': title.lower(), + '$artist': artistname.lower(), + '$sortartist': sortname.lower(), + '$album': release['AlbumTitle'].lower(), + '$year': year } ext = os.path.splitext(downloaded_track)[1] diff --git a/headphones/sab.py b/headphones/sab.py index a1466545..632ea320 100644 --- a/headphones/sab.py +++ b/headphones/sab.py @@ -131,7 +131,7 @@ def sendNZB(nzb): def checkConfig(): - params = { 'mode': 'get_config', + params = {'mode': 'get_config', 'section': 'misc' } diff --git a/headphones/searcher.py b/headphones/searcher.py index 281dec33..425601aa 100644 --- a/headphones/searcher.py +++ b/headphones/searcher.py @@ -477,7 +477,7 @@ def searchNZB(album, new=False, losslessOnly=False, albumlength=None): # Request results logger.info('Parsing results from Headphones Indexer') - headers = { 'User-Agent': USER_AGENT } + headers = {'User-Agent': USER_AGENT} params = { "t": "search", "cat": categories, @@ -549,7 +549,7 @@ def searchNZB(album, new=False, losslessOnly=False, albumlength=None): # Request results logger.info('Parsing results from %s', newznab_host[0]) - headers = { 'User-Agent': USER_AGENT } + headers = {'User-Agent': USER_AGENT} params = { "t": "search", "apikey": newznab_host[1], @@ -598,7 +598,7 @@ def searchNZB(album, new=False, losslessOnly=False, albumlength=None): # Request results logger.info('Parsing results from nzbs.org') - headers = { 'User-Agent': USER_AGENT } + headers = {'User-Agent': USER_AGENT} params = { "t": "search", "apikey": headphones.CONFIG.NZBSORG_HASH, @@ -645,7 +645,7 @@ def searchNZB(album, new=False, losslessOnly=False, albumlength=None): # Request results logger.info('Parsing results from omgwtfnzbs') - headers = { 'User-Agent': USER_AGENT } + headers = {'User-Agent': USER_AGENT} params = { "user": headphones.CONFIG.OMGWTFNZBS_UID, "api": headphones.CONFIG.OMGWTFNZBS_APIKEY, @@ -1288,8 +1288,8 @@ def searchTorrent(album, new=False, losslessOnly=False, albumlength=None): # filter on format, size, and num seeders logger.info(u"Filtering torrents by format, maximum size, and minimum seeders...") - match_torrents = [ torrent for torrent in all_torrents if torrent.size <= maxsize ] - match_torrents = [ torrent for torrent in match_torrents if torrent.seeders >= minimumseeders ] + match_torrents = [torrent for torrent in all_torrents if torrent.size <= maxsize] + match_torrents = [torrent for torrent in match_torrents if torrent.seeders >= minimumseeders] logger.info(u"Remaining torrents: %s" % ", ".join(repr(torrent) for torrent in match_torrents)) diff --git a/headphones/searcher_rutracker.py b/headphones/searcher_rutracker.py index 4601efa6..ab7f10b1 100644 --- a/headphones/searcher_rutracker.py +++ b/headphones/searcher_rutracker.py @@ -197,7 +197,7 @@ class Rutracker(): if torrent: decoded = bdecode(torrent) metainfo = decoded['info'] - page.close () + page.close() except Exception, e: logger.error('Error getting torrent: %s' % e) return False @@ -216,9 +216,9 @@ class Rutracker(): cuecount += 1 title = returntitle.lower() - logger.debug ('torrent title: %s' % title) - logger.debug ('headphones trackcount: %s' % hptrackcount) - logger.debug ('rutracker trackcount: %s' % trackcount) + logger.debug('torrent title: %s' % title) + logger.debug('headphones trackcount: %s' % hptrackcount) + logger.debug('rutracker trackcount: %s' % trackcount) # If torrent track count less than headphones track count, and there's a cue, then attempt to get track count from log(s) # This is for the case where we have a single .flac/.wav which can be split by cue @@ -246,7 +246,7 @@ class Rutracker(): if totallogcount > 0: trackcount = totallogcount - logger.debug ('rutracker logtrackcount: %s' % totallogcount) + logger.debug('rutracker logtrackcount: %s' % totallogcount) # If torrent track count = hp track count then return torrent, # if greater, check for deluxe/special/foreign editions diff --git a/headphones/transmission.py b/headphones/transmission.py index da2b54ad..a3f947d9 100644 --- a/headphones/transmission.py +++ b/headphones/transmission.py @@ -64,7 +64,7 @@ def addTorrent(link): def getTorrentFolder(torrentid): method = 'torrent-get' - arguments = { 'ids': torrentid, 'fields': ['name', 'percentDone']} + arguments = {'ids': torrentid, 'fields': ['name', 'percentDone']} response = torrentAction(method, arguments) percentdone = response['arguments']['torrents'][0]['percentDone'] @@ -98,7 +98,7 @@ def setSeedRatio(torrentid, ratio): def removeTorrent(torrentid, remove_data=False): method = 'torrent-get' - arguments = { 'ids': torrentid, 'fields': ['isFinished', 'name']} + arguments = {'ids': torrentid, 'fields': ['isFinished', 'name']} response = torrentAction(method, arguments) if not response: @@ -181,8 +181,8 @@ def torrentAction(method, arguments): return # Prepare next request - headers = { 'x-transmission-session-id': sessionid } - data = { 'method': method, 'arguments': arguments } + headers = {'x-transmission-session-id': sessionid} + data = {'method': method, 'arguments': arguments} response = request.request_json(host, method="post", data=json.dumps(data), headers=headers, auth=auth) diff --git a/headphones/webserve.py b/headphones/webserve.py index 9aa9b326..6ce895ff 100644 --- a/headphones/webserve.py +++ b/headphones/webserve.py @@ -167,7 +167,7 @@ class WebInterface(object): myDB = db.DBConnection() controlValueDict = {'ArtistID': ArtistID} newValueDict = {'IncludeExtras': 1, - 'Extras': extras} + 'Extras': extras} myDB.upsert("artists", newValueDict, controlValueDict) threading.Thread(target=importer.addArtisttoDB, args=[ArtistID, True, False]).start() raise cherrypy.HTTPRedirect("artistPage?ArtistID=%s" % ArtistID) @@ -460,12 +460,12 @@ class WebInterface(object): # else: # original_clean = None if original_clean == albums['CleanName']: - have_dict = { 'ArtistName': albums['ArtistName'], 'AlbumTitle': albums['AlbumTitle'] } + have_dict = {'ArtistName': albums['ArtistName'], 'AlbumTitle': albums['AlbumTitle']} have_album_dictionary.append(have_dict) headphones_albums = myDB.select('SELECT ArtistName, AlbumTitle from albums ORDER BY ArtistName') for albums in headphones_albums: if albums['ArtistName'] and albums['AlbumTitle']: - headphones_dict = { 'ArtistName': albums['ArtistName'], 'AlbumTitle': albums['AlbumTitle'] } + headphones_dict = {'ArtistName': albums['ArtistName'], 'AlbumTitle': albums['AlbumTitle']} headphones_album_dictionary.append(headphones_dict) #unmatchedalbums = [f for f in have_album_dictionary if f not in [x for x in headphones_album_dictionary]] @@ -574,7 +574,7 @@ class WebInterface(object): album_status = "Ignored" elif albums['Matched'] == "Manual" or albums['CleanName'] != original_clean: album_status = "Matched" - manual_dict = { 'ArtistName': albums['ArtistName'], 'AlbumTitle': albums['AlbumTitle'], 'AlbumStatus': album_status } + manual_dict = {'ArtistName': albums['ArtistName'], 'AlbumTitle': albums['AlbumTitle'], 'AlbumStatus': album_status} if manual_dict not in manual_albums: manual_albums.append(manual_dict) manual_albums_sorted = sorted(manual_albums, key=itemgetter('ArtistName', 'AlbumTitle')) @@ -865,7 +865,7 @@ class WebInterface(object): artist = myDB.action('SELECT * FROM artists WHERE ArtistID=?', [ArtistID]).fetchone() artist_json = json.dumps({ 'ArtistName': artist['ArtistName'], - 'Status': artist['Status'] + 'Status': artist['Status'] }) return artist_json getArtistjson.exposed = True @@ -876,7 +876,7 @@ class WebInterface(object): album_json = json.dumps({ 'AlbumTitle': album['AlbumTitle'], 'ArtistName': album['ArtistName'], - 'Status': album['Status'] + 'Status': album['Status'] }) return album_json getAlbumjson.exposed = True @@ -900,7 +900,7 @@ class WebInterface(object): import hashlib, random - apikey = hashlib.sha224( str(random.getrandbits(256)) ).hexdigest()[0:32] + apikey = hashlib.sha224(str(random.getrandbits(256))).hexdigest()[0:32] logger.info("New API generated") return apikey @@ -929,7 +929,7 @@ class WebInterface(object): def config(self): interface_dir = os.path.join(headphones.PROG_DIR, 'data/interfaces/') - interface_list = [ name for name in os.listdir(interface_dir) if os.path.isdir(os.path.join(interface_dir, name)) ] + interface_list = [name for name in os.listdir(interface_dir) if os.path.isdir(os.path.join(interface_dir, name))] config = { "http_host": headphones.CONFIG.HTTP_HOST, @@ -1053,12 +1053,12 @@ class WebInterface(object): "log_dir": headphones.CONFIG.LOG_DIR, "cache_dir": headphones.CONFIG.CACHE_DIR, "interface_list": interface_list, - "music_encoder": checked(headphones.CONFIG.MUSIC_ENCODER), - "encoder": headphones.CONFIG.ENCODER, - "xldprofile": headphones.CONFIG.XLDPROFILE, - "bitrate": int(headphones.CONFIG.BITRATE), - "encoder_path": headphones.CONFIG.ENCODER_PATH, - "advancedencoder": headphones.CONFIG.ADVANCEDENCODER, + "music_encoder": checked(headphones.CONFIG.MUSIC_ENCODER), + "encoder": headphones.CONFIG.ENCODER, + "xldprofile": headphones.CONFIG.XLDPROFILE, + "bitrate": int(headphones.CONFIG.BITRATE), + "encoder_path": headphones.CONFIG.ENCODER_PATH, + "advancedencoder": headphones.CONFIG.ADVANCEDENCODER, "encoderoutputformat": headphones.CONFIG.ENCODEROUTPUTFORMAT, "samplingfrequency": headphones.CONFIG.SAMPLINGFREQUENCY, "encodervbrcbr": headphones.CONFIG.ENCODERVBRCBR, @@ -1205,7 +1205,6 @@ class WebInterface(object): del kwargs[key] extra_newznabs.append((newznab_host, newznab_api, newznab_enabled)) - # Convert the extras to list then string. Coming in as 0 or 1 (append new extras to the end) temp_extras_list = [] diff --git a/headphones/webstart.py b/headphones/webstart.py index 932ef3d2..43626e4f 100644 --- a/headphones/webstart.py +++ b/headphones/webstart.py @@ -110,7 +110,7 @@ def initialize(options=None): options['http_username']: options['http_password'] }) }) - conf['/api'] = { 'tools.auth_basic.on': False } + conf['/api'] = {'tools.auth_basic.on': False} # Prevent time-outs cherrypy.engine.timeout_monitor.unsubscribe()