import datetime import base64 import smtplib from email.message import EmailMessage import time, sqlite3, sys sys.path.insert(1, 'j:\\Spotty\\secrets_and_database') import spotipy from spotipy.oauth2 import SpotifyOAuth #Dashboard-App-Name = Spotipy Stuff sp = spotipy.Spotify(auth_manager=SpotifyOAuth(client_id="a7b73ad0eda341e58017f68de9f304e7", client_secret="797b552a25b84618b4679e109408cd41", redirect_uri="http://localhost:1234", scope="playlist-modify-public user-read-playback-state user-read-currently-playing user-read-recently-played")) #Other Possible Scopes:- playlist-modify-public user-read-playback-state user-read-currently-playing user-read-recently-played user-library-read class big_cynthia: def __init__(self): self.email_address = "vikingindustries2023@gmail.com" self.email_password = b'dGFvZSBlZnluIHF2dmwgZnZ4eQ==' self.bitpassword = base64.b64decode(self.email_password) self.email_password = self.bitpassword.decode('utf-8') self.queue_id = '7do6UPdCRri7Z0ok0wcYHp' self.queue_name = 'Enormous Queue' self.queue_list = [] self.queue_artist_name_list = [] self.queue_track_name_list = [] self.queue_track_duration_list = [] self.queue_track_list = [] self.queue_track_pic_list = [] self.queue_track_preview_list = [] self.rowid_list = [] self.played_track = "" self.uri_match = 0 self.name_match = 0 self.email_type = 0 self.queue_total = 0 self.queue_owner = "" self.no_exist = False def repopulate_the_queue(self): # NOTE List of functions tic = time.perf_counter() now = datetime.datetime.now() print("Current Run Time:= " + now.strftime("%d-%m-%Y %H:%M:%S")) print("Enormous Cynthia v.2.0.0 30/11/2024 \U00002694 Viking Utilities \U00002694") print("Amazing Things Happen When You Least Expect Them \U0001F9D0 \U0001F4A9 \U0001F6BD") print("\033[91m####################################### Latest Update ########################################\033[0m") print("\033[33mv.2.0.0 Change to Spotipy. ...\033[0m") print("\033[91m################################################################################################\033[0m") self.database = r"j:\Spotty\secrets_and_database\\Enormous Feed.db" self.flex_temp_table() print("Getting Queue Count") self.get_queue_count() self.queue_head = "Getting Queue Items" self.get_the_queue() print("Getting Last 50 Played Tracks") self.check_played_list() print("Updating Last Played Date & Time") self.update_last_played_time() print("Updating Last Played Play Count") self.update_play_count_in_last_played() print("Getting New Tracks For Queue") self.get_new_tracks() print("Updating Playlist Information") self.update_playlist_info() print("Checking Queued Items in Database") self.do_a_queue_check() self.make_preview_table() print("Compressing Database") self.compress_database() print("Updating Web Pages") import Enorhtmlbuilder print("Remaining Un-Played Tracks in Database = " + str(self.remain_records)) print(str(self.uri_match) + " URI Matches") print(str(self.name_match) + " URI Alterations") print(str(self.record_wanted) + " Tracks added from database records:- ") print(*self.rowid_list, sep=', ') toc = time.perf_counter() ty_res = time.gmtime(toc - tic) res = time.strftime(" %H Hours : %M Minutes : %S Seconds", ty_res) print(f"Enormous Cynthia Took {res}") print("") def get_queue_count(self): # NOTE Get how many tracks in and owner of Endless Queue query = sp.playlist(self.queue_id) #NOTE Get the Endless Queue Playlist details self.queue_total = query['tracks']['total'] #NOTE Pick out the total tracks from the details self.queue_owner = query['owner']['id'] #NOTE Get the Username of the Queue Owner (You or me!) return def get_the_queue_again(self): # NOTE Get Individual tracks in Endless Queue Again results = sp.playlist_items(self.queue_id) #NOTE Get the playlists track details tracks = results['items'] #NOTE Set theTracks to a variable while results['next']: #NOTE While there is another track to do results = sp.next(results) #NOTE Get the next track details tracks.extend(results['items']) #NOTE Add the next tracks details to a list for track in tracks: #NOTE A for next loop self.track_uri = track['track']['uri'] #NOTE Put the tracks URI in a variable self.track_name = track["track"]["name"] #NOTE Put the tracks Track Name in a variable self.artist_name = track['track']['album']['artists'][0]['name'] if self.artist_name == "Various Artists": self.artist_name = track["track"]["artists"][0]["name"] #NOTE Put the tracks Artist Name in a variable self.track_duration = track["track"]["duration_ms"] self.sort_out_the_track_length() self.sort_out_the_queue_track_name() if self.played_artist_name.upper() == self.track_artist_name.upper(): self.check_and_add_to_disc_table() self.amend_track_list_and_playlist() self.check_track = self.played_track self.temp_uri = self.played_track self.played_track = self.track_uri return def get_the_queue(self): # NOTE Get Individual tracks in Endless Queue results = sp.playlist_items(self.queue_id) #NOTE Get the playlists track details tracks = results['items'] #NOTE Set theTracks to a variable track_number = 1 #NOTE Start a Track count while results['next']: #NOTE While there is another track to do results = sp.next(results) #NOTE Get the next track details tracks.extend(results['items']) #NOTE Add the next tracks details to a list for track in tracks: #NOTE A for next loop self.track_uri = track['track']['uri'] #NOTE Put the tracks URI in a variable self.track_name = track["track"]["name"] #NOTE Put the tracks Track Name in a variable self.artist_name = track['track']['album']['artists'][0]['name'] if self.artist_name == "Various Artists": self.artist_name = track["track"]["artists"][0]["name"] #NOTE Put the tracks Artist Name in a variable self.track_duration = track["track"]["duration_ms"] #self.not_playable = track["track"]["is_playable"] self.sort_out_the_track_length() try: self.album_image = track["track"]["album"]["images"][1]["url"] #NOTE Put the tracks Album Image in a variable except: self.album_image = "" self.track_preview = track["track"]["preview_url"] #NOTE Put the tracks Preview URL in a variable self.sort_out_the_queue_track_name() #NOTE Don't know if this is still required yet self.queue_list.append(self.track_uri) #NOTE Add the treacks URI to a list self.queue_artist_name_list.append(self.artist_name) self.queue_track_list.append(self.track_name.lower()) #NOTE Add the treacks Track Name to a list self.queue_track_name_list.append(self.track_artist_name) #NOTE Add the treacks Artist Name to a list self.queue_track_duration_list.append(self.track_duration) self.queue_track_pic_list.append(self.album_image) #NOTE Add the treacks Album Image to a list self.queue_track_preview_list.append(self.track_preview) #NOTE Add the treacks Preview URL to a list track_number+=1 #NOTE Increment the count return def sort_out_the_queue_track_name(self): # NOTE Format The Track Name for Duplicate Checks self.track_name = self.track_name.replace("'", "\'") self.artist_name = self.artist_name.replace("'", "\'") self.track_artist_name = self.track_name + " - " + self.artist_name def check_played_list(self): # NOTE Get Last 50 played tracks. Checking to see if each one is in the queue list last_track = False # NOTE Keep the very last played track in the playlist self.check_last_played_table() #NOTE Make sure the table exists in the database results = sp.current_user_recently_played(limit=50) #NOTE Get the 50 last played tracks details tracks = results['items'] #NOTE Set the Tracks to a variable while results['next']: #NOTE While there is another track to do results = sp.next(results) #NOTE Get the next track details tracks.extend(results['items']) #NOTE Add the next tracks details to a list for track in tracks: found = False #NOTE A for next loop self.played_track = track['track']['uri'] #NOTE Put the tracks URI in a variable self.played_name = track["track"]["name"] #NOTE Put the tracks Track Name in a variable #self.played_artist = track["track"]["artists"][0]["name"] #NOTE Put the tracks Artist Name in a variable self.played_artist = track['track']['album']['artists'][0]['name'] if self.played_artist == "Various Artists": self.played_artist= track["track"]["artists"][0]["name"] #NOTE Put the tracks Artist Name in a variable self.played_track_duration = track["track"]["duration_ms"] self.played_at = (track['played_at']) #NOTE Put the tracks played date in a variable if self.played_artist in self.queue_artist_name_list: #may need to adjust this per track?? self.track_title = self.played_name[:12] #NOTE Get the first 12 characters of the Track Name self.hyphen = str(self.track_title).find(" -") if self.hyphen != -1: self.track_title = self.track_title[:self.hyphen] self.bracket = str(self.track_title).find(" (") if self.bracket != -1: self.track_title = self.track_title[:self.bracket] #NOTE This may need to be adjusted if too many issues found #NOTE Possibly set it on a "per track" basis?? self.track_title = self.track_title.lower() #NOTE Make it all lower case self.track_title = self.track_title.strip() test_list = self.queue_track_list #NOTE Copy the track lis to a temp list r = [s for s in test_list if s.startswith(self.track_title)] #NOTE Look for a match in the list with the first 12 characters of the track title #NOTE Don't ask me how it works ?????????? r[0] if r else 'nomatch' #NOTE The results if r: #NOTE If the track is found in the queue self.ai = self.queue_artist_name_list.index(self.played_artist) #NOTE Get the position in the queue list self.track_uri = self.queue_list[self.ai] #NOTE Get the URI of the original track (use this to remove the track) else: continue #NOTE If it's not found do something else (continue just moves to the next track at the moment) else: self.no_exist = True self.add_last_played_routine() self.no_exist = False continue self.add_last_played_routine() if not last_track: print("Saving Last Track Played Which Was:- " + self.played_artist_name) self.last_song_played = self.played_artist_name last_track = True continue if self.played_track in self.queue_list: self.uri_match+=1 self.temp_uri = self.played_track self.mark_played_and_remove() found = True continue if not found: if self.played_artist_name in self.queue_track_name_list: if self.played_artist_name == self.last_song_played: continue self.get_the_queue_again() self.name_match+=1 self.mark_played_and_remove() found = True continue else: self.temp_uri = self.track_uri self.mark_played_and_remove() self.check_track = self.played_track self.email_type = 2 self.email_me() self.email_type = 0 def add_last_played_routine(self): self.track_duration = self.played_track_duration self.sort_out_the_track_length() self.played_track_duration = self.track_duration self.sort_out_the_last_played_track_name() #NOTE Don't know if this is still required yet self.sort_out_the_played_at_time() #NOTE No Change self.add_new_last_played_track() #NOTE No Change def sort_out_the_last_played_track_name(self): # NOTE Format The Track Name for Duplicate Checks self.played_name = self.played_name.replace("'", "\'") self.played_artist = self.played_artist.replace("'", "\'") self.played_artist_name = self.played_name + " - " + self.played_artist def mark_played_and_remove(self): # NOTE If it is in the queue and has been played then deal with it self.mark_played_in_db() self.remove_from_playlist() return def mark_played_in_db(self): # NOTE Mark the played tracks in the database global conn conn = self.create_connection(self.database) cur = conn.cursor() with conn: try: cur.execute("SELECT * FROM Track_List WHERE URI = '" + self.temp_uri + "'") row = cur.fetchone() self.email_track = row[1] self.email_artist = row[2] release_date = row[4] if release_date == "9999": self.email_type = 1 self.email_me() self.email_type = 0 play_count = row[6] play_count+=1 cur.execute("UPDATE Track_List SET PLAY_COUNT = '" + str(play_count) + "' WHERE URI = '" + self.temp_uri + "'") conn.commit() except: print("Error with this track") self.email_type = 3 self.email_me() self.email_type = 0 self.remove_from_playlist() def create_connection(self, db_file): # NOTE Connect to the database conn = None conn = sqlite3.connect(db_file) return conn def remove_from_playlist(self): # NOTE Remove played tracks from the Endless Queue playlist try: sp.user_playlist_remove_all_occurrences_of_tracks(user=self.queue_owner, playlist_id=self.queue_id, tracks=[self.track_uri[-22:]]) #NOTE Remove the track except spotipy.SpotifyException as error: print(error) print() print("RFP Incorrect URI for:- " +self.played_name+ " by " +self.played_artist+ " uri-NOW " + str(self.played_track)) #NOTE This may not work self.played_track = "" return def get_new_tracks(self): # NOTE Get how many new tracks are needed self.get_queue_count() self.remaining_queue = self.queue_total self.get_tracks() return def get_tracks(self): # NOTE Get the new tracks from the Endless Playlist self.needed = 50 - self.remaining_queue self.record_wanted = self.needed print(str(self.needed) + " New Tracks Required!") print("Performing Record Check") self.check_played_count() if self.needed <= 0: return conn = self.create_connection(self.database) cur = conn.cursor() cur.execute("SELECT * FROM Track_List WHERE QUEUED = 0 order by RANDOM()") rows = cur.fetchall() for row in rows: self.newtrack = row[0] self.add_track_to_queue() self.set_queued_flag() self.needed-=1 if self.needed == 0: return return def set_queued_flag(self): # NOTE Mark Track As Queued conn = self.create_connection(self.database) cur = conn.cursor() cur.execute("SELECT * FROM Track_List WHERE URI = '" + self.newtrack + "'") cur.execute("SELECT rowid, * FROM Track_List WHERE URI = '" + self.newtrack + "'") toe = cur.fetchone() self.rowid_list.append(toe[0]) cur.execute("UPDATE Track_List SET QUEUED = True WHERE URI = '" + self.newtrack + "'") conn.commit() return def add_track_to_queue(self): # NOTE Add the new tracks to the Endless Queue Playlist sp.playlist_add_items(playlist_id=self.queue_id, items=[self.newtrack]) #NOTE Add a new track to the queue return def check_played_count(self): # NOTE See how many more tracks are un-played conn = self.create_connection(self.database) cur = conn.cursor() cur.execute("SELECT COUNT (*) FROM Track_List") self.total_records = cur.fetchone() cur.execute("SELECT COUNT (*) FROM Track_List WHERE QUEUED = 1") self.played_records = cur.fetchone() self.remain_records = self.total_records[0] - self.played_records[0] if self.remain_records < self.needed: self.reset_queued_flag() return def reset_queued_flag(self): # NOTE If no tracks left to play then reset the whole database so they are all available print("Reseting Database Enormous Feed") conn = self.create_connection(self.database) with conn: cur = conn.cursor() cur.execute("SELECT QUEUED FROM Track_List") rows = cur.fetchall() for row in rows: cur.execute("UPDATE Track_List SET QUEUED = 0") cur.execute("UPDATE Track_List SET PLAY_COUNT = 0") conn.commit() return def sort_out_the_played_at_time(self): # NOTE Format Last Played Date and Time pdyr = self.played_at[0:4] pdmh = self.played_at[5:7] pddy = self.played_at[8:10] pdtm = self.played_at[11:19] self.played_at = pdmh + "-" + pddy + "-" + pdyr + " " + pdtm self.disp_played_at = pddy + "-" + pdmh + "-" + pdyr + " " + pdtm def sort_out_the_track_length(self): # NOTE Convert miliseconds to minutes and seconds mill_sec = self.track_duration total_sec = mill_sec / 1000 min = int(total_sec // 60) sec = int(total_sec % 60) self.track_duration = f"{min}m {sec}s" return def check_last_played_table(self): # NOTE Make Sure Last Played Table Is Present conn = self.create_connection(self.database) cur = conn.cursor() with conn: cur.execute("CREATE TABLE IF NOT EXISTS Last_Played_Tracks (URI text PRIMARY KEY, TRACK_NAME text, ARTIST_NAME text, TRACK_LENGTH text, PLAY_COUNT integer, DISPLAY_DATE integer, EMAIL integer, LAST_PLAYED text);") conn.commit() def add_new_last_played_track(self): # NOTE Add Last Played Tracks To Last Played Table and a Temporary Table if self.no_exist: self.play_count = -100 email_sent = 9 else: self.play_count = 0 email_sent = 0 conn = self.create_connection(self.database) cur = conn.cursor() track2 = (self.played_track, self.played_name, self.played_artist, self.played_at) # NOTE Set the SQL Values tracks = (self.played_track, self.played_name, self.played_artist, self.played_track_duration, self.play_count, self.disp_played_at, email_sent, self.played_at) # NOTE Set the SQL Values sql = ''' INSERT OR IGNORE INTO Last_Played_Tracks (URI,TRACK_NAME,ARTIST_NAME,TRACK_LENGTH,PLAY_COUNT,DISPLAY_DATE,EMAIL,LAST_PLAYED) VALUES(?,?,?,?,?,?,?,?) ''' sql2 = ''' INSERT OR IGNORE INTO tmp_played (URI,TRACK_NAME,ARTIST_NAME,LAST_PLAYED) VALUES(?,?,?,?) ''' cur = conn.cursor() cur.execute(sql, tracks) cur.execute(sql2, track2) conn.commit() def update_last_played_time(self): # NOTE Update Last Played Date and Time to Last Time the Track was Played conn = self.create_connection(self.database) cur = conn.cursor() cur.execute("SELECT * FROM tmp_played ORDER BY LAST_PLAYED ASC ") rows = cur.fetchall() for row in rows: self.played_track2 = row[0] self.played_at2 = row[3] olddate = self.played_at2 mth = olddate[:2] dy = olddate[3:5] newdate = dy + "-" + mth + olddate[5:] self.disp_played_at2 = newdate cur.execute("UPDATE Last_Played_Tracks SET LAST_PLAYED = '" + self.played_at2 + "' WHERE URI = '" + self.played_track2 + "'") conn.commit() cur.execute("UPDATE Last_Played_Tracks SET DISPLAY_DATE = '" + self.disp_played_at2 + "' WHERE URI = '" + self.played_track2 + "'") conn.commit() def flex_temp_table(self): # NOTE Delete and Create a Temporary Table conn = self.create_connection(self.database) cur = conn.cursor() cur.execute("DROP TABLE IF EXISTS tmp_played") conn.commit() cur.execute("CREATE TABLE IF NOT EXISTS tmp_played (URI text, TRACK_NAME text, ARTIST_NAME text, LAST_PLAYED text PRIMARY KEY);") conn.commit() def update_play_count_in_last_played(self): # NOTE Update The Play Count in the Last Played Table conn = self.create_connection(self.database) cur = conn.cursor() cur.execute("SELECT * FROM tmp_played ORDER BY LAST_PLAYED DESC") rows = cur.fetchall() for row in rows: self.check_track = row[0] cur.execute("SELECT * FROM Track_List WHERE URI = '" + self.check_track + "'") tlrow = cur.fetchone() if tlrow is None: self.played_name = row[1] self.played_name = self.played_name self.played_name = self.played_name.replace("\'", "\'\'") self.played_artist = row[2] self.played_artist = self.played_artist.replace("\'", "\'\'") query = "SELECT * FROM Track_List WHERE TRACK_NAME = '" + self.played_name + "' AND ARTIST_NAME = '" + self.played_artist + "'" cur.execute(query) nmrow = cur.fetchone() if nmrow is None: self.email_type = 2 self.email_me() self.email_type = 0 plcount = -100 cur.execute("UPDATE Last_Played_Tracks SET PLAY_COUNT = '" + str(plcount) + "', EMAIL = 1 WHERE URI = '" + self.check_track + "'") conn.commit() continue else: plcount = nmrow[6] else: plcount = tlrow[6] cur.execute("UPDATE Last_Played_Tracks SET PLAY_COUNT = '" + str(plcount) + "' WHERE URI = '" + self.check_track + "'") conn.commit() def update_playlist_info(self): now = datetime.datetime.now() plname3 = self.queue_name pldesc3 = ":- 50 Tracks from a Total of " + str(self.total_records[0]) + " in the Master Playlist. " + str(self.played_records[0]) + " played tracks with " + str(self.remain_records) + " remaining" sp.playlist_change_details(playlist_id=self.queue_id, name=plname3, description="LAST UPDATED" + now.strftime("%d-%m-%Y %H:%M:%S") + " " + pldesc3 + "", public=True) #NOTE Hopefully this is pretty self explanatory def check_and_add_to_disc_table(self): from datetime import date today = date.today() newtoday = today.strftime("%m-%d-%Y") disptoday = today.strftime("%d-%m-%Y") conn = self.create_connection(self.database) cur = conn.cursor() cur.execute("CREATE TABLE IF NOT EXISTS URI_Change (DATE_OF_CHANGE integer, OLD_URI text, NEW_URI text PRIMARY KEY, TRACK_NAME text, ARTIST_NAME text, DISPLAY_DATE integer);") conn.commit() track = (newtoday, self.track_uri, self.played_track, self.played_name, self.played_artist, disptoday) # NOTE Set the SQL Values sql = ''' INSERT OR IGNORE INTO URI_Change (DATE_OF_CHANGE,OLD_URI,NEW_URI,TRACK_NAME,ARTIST_NAME,DISPLAY_DATE) VALUES(?,?,?,?,?,?) ''' cur = conn.cursor() cur.execute(sql, track) conn.commit() conn.close() return def amend_track_list_and_playlist(self):########################## conn = self.create_connection(self.database) cur = conn.cursor() print("SPT= " +self.played_track+ " STU= " +self.track_uri) print("Track " +self.track_name+ " Artist " +self.artist_name) cur.execute("UPDATE Track_List SET URI = '" + self.played_track + "' WHERE URI = '" + self.track_uri + "'") conn.commit() try: sp.user_playlist_remove_all_occurrences_of_tracks(user=self.queue_owner, playlist_id=self.queue_id, tracks=[self.track_uri[-22:]]) #NOTE Remove the track print("Changing track details for:- " + str(self.track_name) + " By " + str(self.artist_name)) return except spotipy.SpotifyException as er1: print(er1) print("Well that didn't work did it!! Amend track list and playlist function") print("Track " +self.track_name+ " Artist " +self.artist_name) return def do_a_queue_check(self): conn = self.create_connection(self.database) cur = conn.cursor() cur.execute("DROP TABLE IF EXISTS Queue_check") conn.commit() cur.execute( "CREATE TABLE IF NOT EXISTS Queue_check (URI text, TRACK_NAME text, ARTIST_NAME text, ALBUM_NAME text);") conn.commit() self.queue_head = "Checking Queue Contents" self.get_queue_count() self.queue_list = [] self.queue_track_pic_list = [] self.queue_track_preview_list = [] self.get_the_queue() cur.execute("SELECT * FROM Track_list WHERE QUEUED = 1 AND PLAY_COUNT = 0") rows = cur.fetchall() for row in rows: quri = row[0] if quri not in self.queue_list: qtkn = row[1] qarn = row[2] qaln = row[3] track = (quri, qtkn, qarn, qaln) sql = ''' INSERT INTO Queue_check (URI,TRACK_NAME,ARTIST_NAME,ALBUM_NAME) VALUES(?,?,?,?) ''' cur.execute(sql, track) conn.commit() cur.execute("UPDATE Track_List SET QUEUED = 0 WHERE URI = '" + quri + "'") conn.commit() def make_preview_table(self): qtknum = 0 conn = self.create_connection(self.database) cur = conn.cursor() cur.execute("DROP TABLE IF EXISTS Queue_preview") conn.commit() cur.execute( "CREATE TABLE IF NOT EXISTS Queue_preview (URI text, TRACK_NAME text, ALBUM_PIC text, TRACK_PREVIEW text);") conn.commit() while qtknum < 50: quri = self.queue_list[qtknum] qtrack = self.queue_track_list[qtknum] qpic = self.queue_track_pic_list[qtknum] qpre = self.queue_track_preview_list[qtknum] picpre = (quri, qtrack, qpic, qpre) sql = ''' INSERT INTO Queue_preview (URI,TRACK_NAME,ALBUM_PIC,TRACK_PREVIEW) VALUES(?,?,?,?) ''' cur.execute(sql, picpre) conn.commit() qtknum+=1 def email_me(self): addressee = "allanlockwoodsmith@gmail.com" if self.email_type == 1: conn5 = self.create_connection(self.database) cur5 = conn5.cursor() cur5.execute("SELECT * FROM Last_Played_Tracks WHERE URI = '" + self.check_track + "'") rows5 = cur5.fetchone() if rows5[6] == 1: return else: print("Sending Message") msg = EmailMessage() msg['Subject'] = "Unknown Release Date Found" msg['From'] = self.email_address msg['To'] = addressee msg.set_content("The following track was found to need a release date - \n" + self.email_track + " by " + self.email_artist + "\n\n DO NOT REPLY TO THIS EMAIL IT IS NOT MONITORED!") if self.email_type == 2: conn5 = self.create_connection(self.database) cur5 = conn5.cursor() cur5.execute("SELECT * FROM Last_Played_Tracks WHERE URI = '" + self.check_track + "'") rows5 = cur5.fetchone() if rows5[4] != -100: return if rows5[6] == 1: return else: print("Sending Message") msg = EmailMessage() msg['Subject'] = "Played Track Mis-match Found" msg['From'] = self.email_address msg['To'] = addressee msg.set_content("The following track was not found in the Track_list Table - \n" + self.check_track + " - " + self.played_name + " by " + self.played_artist + "\n\n DO NOT REPLY TO THIS EMAIL IT IS NOT MONITORED!") if self.email_type == 3: print("Sending Message") msg = EmailMessage() msg['Subject'] = "Error with this Track " msg['From'] = self.email_address msg['To'] = addressee msg.set_content("The following track needs manual intervention - \n" + self.temp_uri + " - " + self.played_artist_name + "\n\n DO NOT REPLY TO THIS EMAIL IT IS NOT MONITORED!") with smtplib.SMTP_SSL('smtp.gmail.com', 465) as smtp: smtp.login(self.email_address, self.email_password) smtp.send_message(msg) def compress_database(self): conn = self.create_connection(self.database) cur = conn.cursor() cur.execute("VACUUM") conn.commit() a = big_cynthia() a.repopulate_the_queue()