def main(): event = sys.argv[1] lines = sys.stdin.readlines() fields = dict([line.strip().split("=", 1) for line in lines]) # fields: title, artist, album, songDuration, songPlayed, rating, stationName, pRet, pRetStr, wRet, wRetStr, rating artist = fields["artist"] title = fields["title"] song_duration = int(fields["songDuration"]) song_played = int(fields["songPlayed"]) rating = int(fields["rating"]) # events: songstart, songfinish, ??? import pylast if ( event == "songfinish" and song_duration > 1000 * MIN_DURATION and (100.0 * song_played / song_duration > THRESHOLD or song_played > 1000 * PLAYED_ENOUGH) ): song_started = int(time.time() - song_played / 1000.0) network = pylast.LastFMNetwork( api_key=API_KEY, api_secret=API_SECRET, username=USERNAME, password_hash=pylast.md5(PASSWORD) ) network.scrobble(artist=artist, title=title, timestamp=song_started) if event == "songfinish" and rating > 0: network = pylast.LastFMNetwork( api_key=API_KEY, api_secret=API_SECRET, username=USERNAME, password_hash=pylast.md5(PASSWORD) ) track = network.get_track(artist, title) if rating == 1: track.love() elif rating == 2: track.ban()
def __init__(self, config, cast_name, available_devices=None): self.cast_name = cast_name self.cast_config = config.get('chromecast', {}) self.app_whitelist = self.cast_config.get('app_whitelist', APP_WHITELIST) self.last_scrobbled = {} self.current_track = {} self.current_time = 0 self.last_poll = time.time() self._connect_chromecast(available_devices) if not self.cast: raise ChromecastNotFoundException() self.scrobblers = [] if 'lastfm' in config: self.scrobblers.append(pylast.LastFMNetwork( api_key=config['lastfm']['api_key'], api_secret=config['lastfm']['api_secret'], username=config['lastfm']['user_name'], password_hash=pylast.md5(config['lastfm']['password']))) if 'librefm' in config: self.scrobblers.append(pylast.LibreFMNetwork( session_key=config['librefm']['session_key'], username=config['librefm']['user_name'], password_hash=pylast.md5(config['librefm']['password']) )) self.estimate_spotify_timestamp = self.cast_config.get( 'estimate_spotify_timestamp', True)
def __init__(self, key, shared_secret, username, password): self.album_art = '' password_hash = pylast.md5(password) self.network = pylast.LastFMNetwork(api_key=key, api_secret=shared_secret, username=username, password_hash=password_hash)
def test(): kind_ = unicode(kind.currentText()) username_ = unicode(username.text()) password_ = unicode(password.text()) pass_hash = pylast.md5(password_) proxyhost_ = unicode(proxyhost.text()) proxyport_ = unicode(proxyport.text()) def update(msg_, color): msg.setText(msg_) palette.setColor(msg.backgroundRole(), color) msg.setPalette(palette) if username_ != u"" and password_ != u"": def __connect(): try: Main.__net = getattr(pylast, Main.__opt[kind_])( api_key=Main.__key, api_secret=Main.__sec, username=username_, password_hash=pass_hash ) if proxyhost_ and proxyport_: Main.__net.enable_proxy(proxyhost_, proxyport_) update(QtGui.QApplication.translate("Last.FM", "Successful"), Qt.green) except (pylast.NetworkError, pylast.WSError) as msg_: update(unicode(msg_).split(u".")[0], Qt.red) Thread(target=__connect).start() else: update(QtGui.QApplication.translate("Last.FM", "Username and/or password is empty"), Qt.yellow)
def main(): """run the main loop of the vinyl-fm scrobbler""" username = raw_input('Last.fm username: '******'', '') last_songtitle = ('', '') last_artisttitle = ('', '') network = pylast.LastFMNetwork(api_key = LASTFM_API_KEY, api_secret = LASTFM_SECRET_KEY, username = username, password_hash = password_hash) print "Listening... (control-C to exit)" while True: audio_reader.record(35, 'tmpVFM.wav') current_song = identify.match_song(30, 'tmpVFM.wav') if current_song == (None, None): print 'No Match Detected!' continue #if current_song.artist != last_song.artist and current_song.title != last_song.title: # network.scrobble(current_song.artist, # current_song.title, # int(time.time())) # print "%s - %s" % (current_song.artist, current_song.title) if current_song.title != last_songtitle and current_song.artist != last_artisttitle: network.scrobble(current_song.artist, current_song.title, int(time.time())) print "%s - %s" % (current_song.artist, current_song.title) last_songtitle = current_song.title last_artisttitle = current_song.artist current_song = last_song
def set_prop (word, word_eol, userdata): if len(word) < 3: print("Wrong syntax.") print(cmd_help["set"]) return if word[1] == "username": username = word[2] hexchat.set_pluginpref("lfm_username", username) elif word[1] == "password": password = pylast.md5(word[2]) hexchat.set_pluginpref("lfm_password", password) elif word[1] == "api_key": api_key = word[2] hexchat.set_pluginpref("lfm_api_key", api_key) elif word[1] == "api_sec": api_sec = word[2] hexchat.set_pluginpref("lfm_api_sec", api_sec) else: print("List of available parameters:") print("username"); print("password") print("api_key"); print("api_sec") return update_network() print("{} updated successfully.".format(word[1])) return hexchat.EAT_ALL
def __connect(self, username, password, populate_loved=False): """ Connect lastfm @param username as str @param password as str @thread safe """ self.__username = username if self.__goa is not None or (password != '' and username != ''): self.__is_auth = True else: self.__is_auth = False try: self.session_key = "" self.__check_for_proxy() if self.__goa is not None: self.session_key = self.__goa.call_get_access_token_sync( None)[0] else: skg = SessionKeyGenerator(self) self.session_key = skg.get_session_key( username=self.__username, password_hash=md5(password)) if populate_loved: self.__populate_loved_tracks() except Exception as e: debug("Lastfm::__connect(): %s" % e) self.__is_auth = False
def __init__(self): Entity.__init__(self) self.lastfm = pylast.LastFMNetwork(api_key=params.LASTFM_API_KEY, api_secret=params.LASTFM_API_SECRET, username=USERNAME, password_hash=pylast.md5(PASSWORD)) config.ECHO_NEST_API_KEY = params.ECHONEST_API_KEY
def _main(self): """ get's automatically called from Memacs class """ options = { 'api_secret': self._get_config_option('api_secret'), 'api_key': self._get_config_option('api_key'), 'password_hash': pylast.md5(self._get_config_option('password')), 'username': self._get_config_option('username') } try: if 'lastfm' in self._get_config_option('network'): network = pylast.LastFMNetwork(**options) if 'librefm' in self._get_config_option('network'): network = pylast.LibreFMNetwork(**options) user = network.get_user(options['username']) self._handle_recent_tracks(user.get_recent_tracks(limit=100)) except pylast.WSError as e: logging.error('an issue with the network web service occured: %s' % e) sys.exit(1)
def authenticate(self): ''' authenticate using this linkedopendata account ''' username = "******" md5_pwd = pylast.md5("nopassword") self.session_key = pylast.SessionKeyGenerator(API_KEY, API_SECRET).get_session_key(username, md5_pwd)
def lastfm_login(self): if self.lastfm_loggedin: self.lastfm_loggedin = False self.lastfm_username.setStyleSheet("background:#F0F0F0") self.lastfm_password.setStyleSheet("background:#F0F0F0") self.lastfm_loginbutton.setText("Login to Last.fm") return password_hash = pylast.md5(self.lastfm_password.text()) try: self.lastfm_loginbutton.setText("Logging in...") self.network = pylast.LastFMNetwork(api_key="1a8078aea8442f92c98755e29e24f4cf",api_secret="cdf440e7b9ebef25087253b8ee64d604",username=self.lastfm_username.text(),password_hash=password_hash) self.lastfm_username.setStyleSheet("background:#28a828") self.lastfm_password.setStyleSheet("background:#28a828") self.lastfm_loginbutton.setText("Logout") print("Login to Last.fm successful!") self.lastfm_loggedin = True except pylast.WSError: print("Authentication failed: wrong login") errorbox = QMessageBox(self) errorbox.setWindowTitle("Authentication failed") errorbox.setText(u"Login failed! You have entered incorrect user details.") errorbox.show() except: print("Authentication failed: unknown error") errorbox = QMessageBox(self) errorbox.setWindowTitle("Authentication failed") errorbox.setText(u"Login failed! An unknown error occurred.") errorbox.show() return
def main(): import os, os.path basedir = os.getcwd() # Collect metalmittwoch data so far print "Collecting local data..." datadir = os.path.join(basedir, 'metalmittwoch') data = collect_data(datadir) # Read last.fm config print "Reading last.fm config..." configfile = os.path.join(basedir, 'etc', 'last.fm') config = get_config(configfile) # Generate playlists from local data print "Generating local playlists..." local_lists = generate_playlists(data) # Ok, connect to last.fm print "Connecting to last.fm..." import pylast network = pylast.LastFMNetwork(api_key = config['api_key'], api_secret = config['api_secret'], username = config['username'], password_hash = pylast.md5(config['password'])) user = network.get_user(config['username']) # Export playlists to last.fm print "Exporting playlists..." export_playlists(network, user, local_lists)
def initNetwork(): BDD.network_is_connected = threading.Event() BDD.network_cache = [] try: f = open(os.path.join(xdg.get_data_home(), "network_cache.txt"), "r") queue = f.readlines() f.close() for e in queue: BDD.network_cache.append(eval(e)) except IOError: logger.debug("No network cache file") try: API_KEY = "04537e40b5501f85610cf4e4bbf1d97a" # this is a sample key API_SECRET = "b36376228a6e72314ffd503b8e3c9f5e" # In order to perform a write operation you need to authenticate yourself username = settings.get_option("music/audioscrobbler_login", "") password_hash = md5(settings.get_option("music/audioscrobbler_password", "")) BDD.network = LastFMNetwork( api_key=API_KEY, api_secret=API_SECRET, username=username, password_hash=password_hash ) logger.debug("Connection successfuly established with Last.fm") BDD.network_is_connected.set() except NetworkError: logger.debug("Connection to Last.fm failed")
def ScrobbleTrack(self, track): try: lastfm_username = os.environ.get('LASTFM_USERNAME') lastfm_password = pylast.md5(os.environ.get('LASTFM_PASSWORD')) lastfm_apikey = os.environ.get('LASTFM_APIKEY') lastfm_apisecret = os.environ.get('LASTFM_APISECRET') lastfm = pylast.LastFMNetwork(api_key=lastfm_apikey, api_secret=lastfm_apisecret, username=lastfm_username, password_hash=lastfm_password) # Get last modified time of track (which seems to be last played) # Divide by 1,000,000 to get unix timestamp in seconds time_played = (int(track['lastModifiedTimestamp']) / 1000000) print 'Scrobbling track:', \ track['artist'], '-', \ track['title'], '-', \ datetime.fromtimestamp(float(time_played)) lastfm.scrobble(artist=track['artist'], title=track['title'], timestamp=time_played) time.sleep(0.5) except: print "There was a problem scrobbling the track."
def _connect(self, username, password, populate_loved=False): """ Connect lastfm @param username as str @param password as str @thread safe """ self._username = username if password != "" and username != "": self._is_auth = True else: self._is_auth = False try: self._check_for_proxy() LastFMNetwork.__init__( self, api_key=self._API_KEY, api_secret=self._API_SECRET, username=Lp.settings.get_value("lastfm-login").get_string(), password_hash=md5(password), ) if populate_loved: self._populate_loved_tracks() except Exception as e: print("Lastfm::_connect(): %s" % e)
def similar_search(artist, song): '''USAGE : similar_search('rihanna', 'umbrella') OUTPUT is a LIST passed to thread-pool manager which will decide the rate of download, assign download_music threads etc''' # You have to have your own unique two values for API_KEY and API_SECRET # Obtain yours from http://www.last.fm/api/account for Last.fm API_KEY = "e3d64479d574074eac7058d08de0dda7" # this is a sample key API_SECRET = "063d322566d3a8bcbd48ac160aa5097a" # In order to perform a write operation you need to authenticate yourself username = "******" password_hash = pylast.md5("hydrofuran") network = pylast.LastFMNetwork(api_key = API_KEY, api_secret = API_SECRET, username = username, password_hash = password_hash) ######### define a track ###### #track = network.get_track("rihanna", "umbrella") track = network.get_track(artist, song) print(track.get_name) ########### MY CODE ########### my_list = track.get_similar() song_list = [(my_list[i][1], str(my_list[i][0])) for i in range(len(my_list))] song_list = sorted(song_list, reverse=True) #print(song_list[:10][8][1]) print(song_list[:10]) result = [] [result.append(i[1]) for i in song_list] print('RESULT SNAP : ', result[:20]) return result
def _connect(self, username, password, populate_loved=False): """ Connect lastfm @param username as str @param password as str @thread safe """ self._username = username if self._goa is not None or (password != '' and username != ''): self._is_auth = True else: self._is_auth = False try: self._check_for_proxy() if self._goa is None: LastFMNetwork.__init__( self, api_key=self._API_KEY, api_secret=self._API_SECRET, username=self._username, password_hash=md5(password)) else: LastFMNetwork.__init__( self, api_key=self._API_KEY, api_secret=self._API_SECRET, session_key=self._goa.call_get_access_token_sync(None)[0]) if populate_loved: self._populate_loved_tracks() except Exception as e: print("Lastfm::_connect(): %s" % e)
def lastfm(inp, reply=None, say=None, nick=''): API_KEY = "30cabd8b57c765a42f78e8f5d329fdc0" API_SECRET = "0ab2d0a46763e71d1ed8877b4ea209cf" username = "******" password_hash = pylast.md5("justpurple") network = pylast.get_lastfm_network(api_key = API_KEY, api_secret = API_SECRET, username = username, password_hash = password_hash) try: if inp == '': user = network.get_user(nick) else: user = network.get_user(inp) nick = inp except WSError: say("This user doesn't exist.") try: tracks = user.get_recent_tracks() except pylast.WSError: if inp == '': return("It seems like your current nickname does not have a lastFM account. Try '.lastfm username' instead.") else: return("The user '%s' does not exist. Maybe you misspelled it?" % inp) recent = tracks[0][0] artist = recent.get_artist().get_name() title = recent.get_title() url = recent.get_url() bitlyURL = bitly_api.shorten(url) finalise = "\x02%s\x0F's last track - \x02%s\x0f :: Artist - \x02%s\x0f :: Link to Song - \x02%s\x0F" % (nick, title, artist, bitlyURL) say(finalise)
def setup_network(self): api_key = self.settings.get('APIKEY') api_secret = self.settings.get('APISECRET') username = self.settings.get('USERNAME') password = pylast.md5(self.settings.get('PASSWORD')) net = pylast.LastFMNetwork(api_key=api_key, api_secret=api_secret, username=username, password_hash=password) return net
def __init__(self, username, password, use): if use: if len(password) is 0: password = getpass("Last.fm password:") import pylast password_hash = pylast.md5(password) self.session = pylast.LastFMNetwork(api_key = self.API_KEY, api_secret = self.API_SECRET, username = username, password_hash = password_hash) self.enabled = use
def __init__(self): passHash = pylast.md5(PASS) self.network = None d = deferToThread(pylast.LastFMNetwork, api_key=KEY, api_secret=SECRET, username=USER, password_hash=passHash) d.addCallback(self.onNetworkInitialized) d.addErrback(self.onNetworkError)
def getLastFMScrobbleObject(): (API_KEY, API_SECRET, username, password) = get_config("config.ini") password_hash = pylast.md5(password) network = pylast.LastFMNetwork(api_key = API_KEY, api_secret = API_SECRET, username = username, password_hash = password_hash) return network
def save(y): Main.__settings.setValue(u"enabled", y) Main.__settings.setValue(u"kind", unicode(kind.currentText())) Main.__settings.setValue(u"username", unicode(username.text())) password_ = unicode(password.text()) Main.__settings.setValue(u"password", len(password_)) Main.__settings.setValue(u"password_hash", pylast.md5(password_)) Main.__settings.setValue(u"phost", unicode(proxyhost.text())) Main.__settings.setValue(u"pport", unicode(proxyport.text()))
def getInfo(self): """opens the settings json file and gets the username and password""" with open( os.path.abspath(os.path.dirname(__file__)) + '\\settings.json', 'r') as f: settings = json.load(f) self.enabled = settings[0]['scrobblingEnabled'] self.username = settings[0]['username'] self.password = settings[0]['password'] self.password = pylast.md5(self.password)
def __init__(self, jockey): self.jockey = jockey self.network = pylast.LastFMNetwork( api_key=config.LASTFM_API_KEY, api_secret=config.LASTFM_API_SECRET, username=config.LASTFM_USERNAME, password_hash=pylast.md5(config.LASTFM_PASSWORD) ) self.user_details = pylast.User("rehab_belfast", self.network)
def init(): API_KEY = "67660302ee23be8a69e4614b38df3d3f" API_SECRET = "25dca1ec537268160359a09e047c586e" username = "******" password_hash = pylast.md5("DataMining") network = pylast.LastFMNetwork(api_key = API_KEY, api_secret = API_SECRET, username = username, password_hash = password_hash) artistName = raw_input('Bitte geben Sie einen Kuenstlernamen ein: ') print "Bitte warten..." artist = network.get_artist(str(artistName)) topfans = artist.get_top_fans(10) group = [a.item for a in topfans] userDict = recommendations.createLastfmUserDict(group) #testband="AFI" for testuser in group: #print str(testuser) + " --> " + testband + " = " + str(userDict[testuser][testband]) similarUsers = aufgabe2_2.topMatches(userDict, str(testuser), recommendations.sim_euclid) #sort dictionary and save user and distance for key, value in sorted(similarUsers.iteritems(), key=lambda (k,v): (v,k)): user = key distance = value print print "Aehnlichster Benutzer fuer " + str(testuser) + " = " + str(user) + " (" + str(round(distance, 3)) + ")" #choose either euclidean or pearson distance recoms = getRecommendations.getRecommendations(userDict, str(testuser), similarity='euclid') print "Empfehlungen fuer Benutzer " + str(testuser) + ":" j = 0 for i in range(0, 10): #skip artistName if str(recoms[i][1]) == artistName: j += 1 print recoms[j][1] + " (" + str(round(recoms[j][0],3)) + ")" j += 1 print exitApp = input("Druecken Sie eine beliebige Taste . . . ")
def __init__(self, login, password): self.login = login self.password = pylast.md5(password) self.net = pylast.LastFMNetwork(api_key = API_KEY, api_secret = API_SECRET, username = username, password_hash = password_hash) #TODO: should also include client id self.sc = pylast.Scrobbler(self.net) self.queue = []
def on_start(self): try: self.lastfm = pylast.LastFMNetwork( api_key=API_KEY, api_secret=API_SECRET, username=self.config['scrobbler']['username'], password_hash=pylast.md5(self.config['scrobbler']['password'])) logger.info('Scrobbler connected to Last.fm') except PYLAST_ERRORS as e: logger.error('Error during Last.fm setup: %s', e) self.stop()
def network_setup(): """ Sets up a LastFMNetwork object. This is all that is required for some API calls.get_user. (Most require authentication) """ credentials = load_credentials() password_hash = pylast.md5(credentials['password']) network = pylast.LastFMNetwork(api_key=credentials['api_key'], api_secret=credentials['api_secret'], username=credentials['username'], password_hash=password_hash) return network
def authenticate(self): api_key="7813db7c21ddbca72445e30e6b3fe5e3" api_secret="e823daf4c89db91f55c7a7f4aa3b2da7" username = "******" password_hash = pylast.md5("dc53HeUp") self.network = pylast.LastFMNetwork(api_key=api_key, api_secret=api_secret, username=username, password_hash=password_hash)
import pylast API_KEY = '70578b40668e460c6282ee394e448586' API_SECRET = 'd105089ed009bbd740176b4e00ffd261' URL = 'ws.audioscrobbler.com' USERNAME = '******' password_hash = pylast.md5('12481632!') network = pylast.LastFMNetwork(API_KEY, API_SECRET, USERNAME, password_hash)
import pylast # You have to have your own unique two values for API_KEY and API_SECRET # Obtain yours from http://www.last.fm/api/account/create for Last.fm API_KEY = "fdbefce9b70a10ef7baf2ee2da06ed87" API_SECRET = "1dcb34a48af9dde1199e4b554d0f9d3c" # In order to perform a write operation you need to authenticate yourself username = "******" password_hash = pylast.md5("hot15959.") network = pylast.LastFMNetwork(api_key=API_KEY, api_secret=API_SECRET, username=username, password_hash=password_hash) f20 = open("C:/Users/BSE/Desktop/csgraduation/traindata6.txt", 'w') f21 = open("C:/Users/BSE/Desktop/csgraduation/traintar6.txt", 'w') def try_track(artist, title, bpm, score): for i in range(0, int(len(artist))): #for i in range (0, 10): try: get_track(i, artist, title, bpm, score) i += 1 except Exception: get_track(i + 1, artist, title, bpm, score) i += 1
import json import pylast from modules.brittbot.filters import smart_ignore from modules.brittbot.helpers import colorize, colors f = open('./modules/lastfm.json', 'r') secret = json.loads(f.read()) network = pylast.LastFMNetwork( api_key=secret['api_key'], api_secret=secret['secret'], username=secret['username'], password_hash=pylast.md5(secret['password']), ) def format_track(song_obj): track = song_obj.title artist = song_obj.artist.name # album = song_obj.album return "%s by %s" % ( colorize(track, fg=colors['teal']), colorize(artist, fg=colors['teal']), ) @smart_ignore def register_lastfm_account(jenni, msg): nick = msg.nick
if 0 == c: return 0 a = len(set_a) b = len(set_b) return float(c / (a + b + c)) result = [] [ result.append(sim_tanimoto(critics, x_person[i], x_person[j])) for i in range(len(x_person)) for j in range(i + 1, len(x_person)) ] print 'sim_tanimoto on critics', result print 'sim_tanimoto on movies', sim_tanimoto(prefs, '10', '15') API_KEY = 'ef90c448f8f4a6cae53d39d57de91f74' # password add exercise 4 API_SECRET = '72a2f98a3f405737382c9255ee54ffc1' username = '******' password_hash = pylast.md5('199602010253.zpf') network = pylast.LastFMNetwork(api_key=API_KEY, api_secret=API_SECRET, username=username, password_hash=password_hash) artist = network.get_artist("System of a Down") print artist track = network.get_track("Iron Maiden", "The Nomad") print track track.love() track.add_tags(("awesome", "favorite"))
import pylast # You have to have your own unique two values for API_KEY and API_SECRET # Obtain yours from https://www.last.fm/api/account/create for Last.fm API_KEY = "b25b959554ed76058ac220b7b2e0a026" # this is a sample key API_SECRET = "425b55975eed76058ac220b7b4e8a054" # In order to perform a write operation you need to authenticate yourself username = "******" password_hash = pylast.md5("your_password") network = pylast.LastFMNetwork(api_key=API_KEY, api_secret=API_SECRET, username=username, password_hash=password_hash) # Now you can use that object everywhere artist = network.get_artist("System of a Down") artist.shout("<3") track = network.get_track("Iron Maiden", "The Nomad") track.love() track.add_tags(("awesome", "favorite")) # Type help(pylast.LastFMNetwork) or help(pylast) in a Python interpreter # to get more help about anything and see examples of how it works
import pylast import csv import pymysql import time API_KEY = '8b2fa4cb683e168f66f47adcc708ad22' API_SECRET = '96f5ba11b4313fca6a34b65bba5c5843' username = '******' password_hash = pylast.md5("W1nter0zturk") network = pylast.LastFMNetwork(api_key=API_KEY, api_secret=API_SECRET, username=username, password_hash=password_hash) tracklib = {} trackar = [] fans = [] tracks = [] artists = [] artistlist = [] tracklist = [] userlist = [] bannedlist = {} fanlib = {} # get initial top 100 artists and their top 2 tracks def getartist(): artistlist = csv.reader(open("TopArtists.csv", "rb"))
def check_lastfm_password(password): if not has_pylast: msg = "pylast not installed" return dict(valid=False, message=msg) password_hash = pylast.md5(password) return dict(valid=True, value=password_hash)
#!/usr/bin/env python import pylast import csv # You have to have your own unique two values for API_KEY and API_SECRET # Obtain yours from http://www.last.fm/api/account for Last.fm API_KEY = "cf19f403740b65f0150361c4d3cc504e" # this is a sample key API_SECRET = "acf374f9ba218a4cd025122e67db7139" # In order to perform a write operation you need to authenticate yourself username = "******" password_hash = pylast.md5("Mipsolat1") network = pylast.LastFMNetwork(api_key=API_KEY, api_secret=API_SECRET, username=username, password_hash=password_hash) infile = "/Users/mattsachs/Desktop/sad_hap.csv" outputfile = "/Users/mattsachs/Desktop/sad_hap_tags.csv" csvfile = open(outputfile, 'w') csvwriter = csv.writer(csvfile) header = ['artist_name', 'track_name', 'tags', 'weights'] csvwriter.writerow(header) print "Opening file" csvfile = open(infile, 'rb') reader = csv.reader(csvfile)
#/usr/bin/python import os import sys import time import pylast import subprocess artist = sys.argv[1] title = sys.argv[3] # Update your credentials here network = pylast.LastFMNetwork(api_key="", api_secret="", username="", password_hash=pylast.md5("")) track = pylast.Track(artist, title, network) track.love() print("LAST.FM: Loved a song: {0} - {1}").format(artist, title)
import pylast API_KEY = "71d1ca867d5ae43c3422973f77589e7d" API_SECRET = "d0e8b27d953ae1abe939be6fa6f58627" username = "******" password_hash = pylast.md5("741963456528ybx?") network = pylast.LastFMNetwork(api_key=API_KEY, api_secret=API_SECRET, username=username, password_hash=password_hash) def tanimoto(person1, person2): si = {} for item in person1: if item in person2: si[item] = 1 c = float(len(si)) a = len(person1) b = len(person2) t = c / (a + b - c) return t def tagList(tag=''): albums_list = {} albums_list[tag] = {} tags = network.get_tag(tag) for p1 in tags.get_top_albums(): p1 = str(p1) p1start = p1.index('Album') + 8 p1end = p1.index(',') - 1
import pylast from time import strftime import xlrd, xlwt, csv import json API_KEY = "0dcacf9308d8c7cb06d900e746ab5cf9" API_SECRET = "66781de7c26ce6ab32b9bdcc14d550cf" username = "******" password_hash = pylast.md5("DataIsDifficult1!") network = pylast.LastFMNetwork(api_key=API_KEY, api_secret=API_SECRET, username=username, password_hash=password_hash) # Runs API calls on each song in the json def getInitialGenreData(filename): with open(filename, encoding="utf-8") as json_file: billboard_chart_data = json.load(json_file) count = 1 # traverse each song in the json for year in range(1963, 2019): for song in billboard_chart_data[str(year)]: song_name = song['song'] artist_name = song['artist(s)'] try: # use last.fm api (pylast) to find corresponding track and genre tags track = network.get_track(artist_name, song_name) tags = track.get_top_tags() mbid_id = track.get_mbid() # used for musicbrainz api in other script
#!/usr/bin/env python import json import sys import collections from mrjob.job import MRJob import pandas as pd from mr_diag import MRTagSimMatrix import pylast API_KEY = "4e1bb9a3fead3bb1975ddbe2e0b3b7c4" API_SECRET = "678c5ab3251cf8b40b978c731f6bbb03" username = "******" password_hash = pylast.md5("I've removed my real password") network = pylast.LastFMNetwork(api_key=API_KEY, api_secret=API_SECRET, username=username, password_hash=password_hash) def sim_diag(): #You can run the calc to get the sim triangle programatically, but you have to go in and monkey wth the mr_diag.py code #and refactor it to take 'artist_data.txt' as its input. I recommend just running sim_matrix() it doens't take very long at all. #I could rewrite that input and configuration as a parameterized funciton, but we'll do that another time. mr_job = MRTagSimMatrix(args=['-r', 'local', 'artist_data.txt']) with mr_job.make_runner() as runner: runner.run()
if __name__ == "__main__": config.read('.details') API_KEY = config['API']['API_KEY'] API_SECRET = config['API']['API_SECRET'] username = "******" username = config['LOGIN']['username'] webpage = input(web_prompt) first = int(input(first_prompt)) last = int(input(last_prompt)) password_hash = pylast.md5(getpass.getpass(pass_prompt)) print(Style.RESET_ALL) network = pylast.LastFMNetwork(api_key=API_KEY, api_secret=API_SECRET, username=username, password_hash=password_hash) print(Fore.LIGHTCYAN_EX + webpage) page = requests.get(str(webpage)) print(page) print() soup = BeautifulSoup(page.content, 'html.parser') tracklist = find_tracklist(soup)
# -*- coding: utf-8 -*- """Takes the last 1000 songs from Listenbrainz and scrobbles it on Libre.fm""" import os import pylast import pylistenbrainz from dotenv import load_dotenv load_dotenv() # Set up the LibreFM client libre_fm = pylast.LibreFMNetwork( api_key="Max-----------------------------", # This can be anything api_secret=os.getenv("LIBRE_FM_PASSWORD"), username=os.getenv("LIBRE_FM_USERNAME"), password_hash=pylast.md5(os.getenv("LIBRE_FM_PASSWORD")), ) # Authenticate with Listenbrainz listenbrainz = pylistenbrainz.ListenBrainz() listenbrainz.set_auth_token(os.getenv("LISTENBRAINZ_AUTH_TOKEN")) # Get last 1000 listens - scrobbling the same thing multiple times has no effect listens = listenbrainz.get_listens("aspiringmax", count=1000) # Populate the tracks scrobbles = [] for listen in listens: data = { "artist": listen.artist_name, "title": listen.track_name,
return pil_img.crop( ((img_width - crop_width) // 2, (img_height - crop_height) // 2, (img_width + crop_width) // 2, (img_height + crop_height) // 2)) def crop_max_square(pil_img): return crop_center(pil_img, min(pil_img.size), min(pil_img.size)) with open("config.json", "r+") as f: config = json.load(f) network = pylast.LastFMNetwork(api_key=config['apikey'], api_secret=config['secret'], username=config['username'], password_hash=pylast.md5(config['password'])) cache = LastfmCache(config['apikey'], config['secret']) cache.enable_file_cache() try: artists = network.get_authenticated_user().get_top_artists( limit=6, period=pylast.PERIOD_7DAYS) except Exception as e: print(e) artist_dict = {} for a in artists: artist = cache.get_artist(a.item.name) artist_dict.update({a.item.name: artist.cover_image})
import pylast from config import * import re import random network = pylast.LastFMNetwork(api_key=API_KEY, api_secret=API_SECRET, username=lfm_username, password_hash=pylast.md5(lfm_password)) def get_tracks_by_artist(artist_name): artist = network.get_artist(artist_name) cover = artist.get_cover_image() top = artist.get_top_tracks(limit=9) tracks = [] for track in top: title_track = artist.get_name() + " - " + track.item.get_title() tracks.append(title_track) biography = artist.get_bio_summary(language="ru") biography = re.sub( "<a.*a>", "", biography) + "\n Читать далее:\n" + artist.get_url(domain_name=9) return biography, cover, tracks def get_track_by_tag(tag_name): tag = network.get_tag(tag_name) list_tracks = tag.get_top_tracks(600) tracks = [] for i in range(0, 10):
import pylast from concertconnect_backend.settings.settings_base import * DATABASES = dict(default=dj_database_url.config()) assert 'LAST_FM_API_KEY' in os.environ, 'Set LAST_FM_API_KEY in your env vars!' LAST_FM_API_KEY = os.environ['LAST_FM_API_KEY'] assert 'LAST_FM_SECRET_KEY' in os.environ, 'Set LAST_FM_SECRET_KEY in your env vars!' LAST_FM_SECRET_KEY = os.environ['LAST_FM_SECRET_KEY'] assert 'LAST_FM_USERNAME' in os.environ, 'Set LAST_FM_USERNAME in your env vars!' LAST_FM_USERNAME = os.environ['LAST_FM_USERNAME'] assert 'LAST_FM_PASSWORD' in os.environ, 'Set LAST_FM_PASSWORD in your env vars!' LAST_FM_PASSWORD_HASH = pylast.md5(os.environ['LAST_FM_PASSWORD']) LAST_FM_NETWORK = pylast.LastFMNetwork(api_key=LAST_FM_API_KEY, api_secret=LAST_FM_SECRET_KEY, username=LAST_FM_USERNAME, password_hash=LAST_FM_PASSWORD_HASH) LOGGING = { 'version': 1, 'disable_existing_loggers': False, 'formatters': { 'verbose': { 'format': "[%(asctime)s] %(levelname)s [%(name)s:%(lineno)s] %(message)s", 'datefmt': "%d/%b/%Y %H:%M:%S" }, 'simple': {
import pylast import pandas as pd API_KEY = "YOUR_API_KEY" API_SECRET = "YOUR_API_SECRET" username = "******" password_hash = pylast.md5("YOUR_PASSWORD") network = pylast.LastFMNetwork(api_key=API_KEY, api_secret=API_SECRET, username=username, password_hash=password_hash) df = pd.read_csv("artistLastFM.csv", sep="\n") df['tags'] = "" def get_tags_artist(artist_name): artist_obj = network.get_artist(artist_name) tags = "" j = 0 try: for d in artist_obj.get_top_tags(): tags = tags + d.item.name + "," j = j + 1 if j == 5: break except: tags = "N/A" return tags[:len(tags)-1] for i in range(0, len(df)): df['tags'][i] = get_tags_artist(df['artist'][i])
# OWNER ID OWNER_ID = os.environ.get("OWNER_ID", "719195224") # PMPERMIT COUNT_MSG = 0 COUNT_PM = {} # Last.fm Module BIO_PREFIX = os.environ.get("BIO_PREFIX", None) DEFAULT_BIO = os.environ.get("DEFAULT_BIO", None) LASTFM_API = os.environ.get("LASTFM_API", None) LASTFM_SECRET = os.environ.get("LASTFM_SECRET", None) LASTFM_USERNAME = os.environ.get("LASTFM_USERNAME", None) LASTFM_PASSWORD_PLAIN = os.environ.get("LASTFM_PASSWORD", None) LASTFM_PASS = pylast.md5(LASTFM_PASSWORD_PLAIN) if not LASTFM_USERNAME == "None": lastfm = pylast.LastFMNetwork(api_key=LASTFM_API, api_secret=LASTFM_SECRET, username=LASTFM_USERNAME, password_hash=LASTFM_PASS) else: lastfm = None # Google Drive Module G_DRIVE_CLIENT_ID = os.environ.get("G_DRIVE_CLIENT_ID", None) G_DRIVE_CLIENT_SECRET = os.environ.get("G_DRIVE_CLIENT_SECRET", None) G_DRIVE_AUTH_TOKEN_DATA = os.environ.get("G_DRIVE_AUTH_TOKEN_DATA", None) GDRIVE_FOLDER_ID = os.environ.get("GDRIVE_FOLDER_ID", None) TEMP_DOWNLOAD_DIRECTORY = os.environ.get("TEMP_DOWNLOAD_DIRECTORY", "./downloads")
# Copyright (C) 2020-2022 by UsergeTeam@Github, < https://github.com/UsergeTeam >. # # This file is part of < https://github.com/UsergeTeam/Userge > project, # and is released under the "GNU v3.0 License Agreement". # Please see < https://github.com/UsergeTeam/Userge/blob/master/LICENSE > # # All rights reserved. """ last.fm module """ import os import pylast from userge import config API_KEY = os.environ.get("FM_API") API_SECRET = os.environ.get("FM_SECRET") USERNAME = os.environ.get("FM_USERNAME") PASSWORD = pylast.md5(os.environ.get("FM_PASSWORD")) CHAT_IDS = [ int(x) for x in os.environ.get("LASTFM_CHAT_ID", str( config.LOG_CHANNEL_ID)).split() ]
# Time & Date - Country and Time Zone COUNTRY = str(os.environ.get("COUNTRY") or "") TZ_NUMBER = int(os.environ.get("TZ_NUMBER") or 1) # Clean Welcome CLEAN_WELCOME = sb(os.environ.get("CLEAN_WELCOME") or "True") # Last.fm Module BIO_PREFIX = os.environ.get("BIO_PREFIX") or None DEFAULT_BIO = os.environ.get("DEFAULT_BIO") or None LASTFM_API = os.environ.get("LASTFM_API") or None LASTFM_SECRET = os.environ.get("LASTFM_SECRET") or None LASTFM_USERNAME = os.environ.get("LASTFM_USERNAME") or None LASTFM_PASSWORD_PLAIN = os.environ.get("LASTFM_PASSWORD") or None LASTFM_PASS = md5(LASTFM_PASSWORD_PLAIN) if LASTFM_API is not None: lastfm = LastFMNetwork( api_key=LASTFM_API, api_secret=LASTFM_SECRET, username=LASTFM_USERNAME, password_hash=LASTFM_PASS, ) else: lastfm = None # Google Drive Module G_DRIVE_DATA = os.environ.get("G_DRIVE_DATA") or None G_DRIVE_CLIENT_ID = os.environ.get("G_DRIVE_CLIENT_ID") or None G_DRIVE_CLIENT_SECRET = os.environ.get("G_DRIVE_CLIENT_SECRET") or None G_DRIVE_AUTH_TOKEN_DATA = os.environ.get("G_DRIVE_AUTH_TOKEN_DATA") or None
def config_wizard(): ''' Text User Interface to generate initial lastcast.toml config. ''' config = {'chromecast': {}} if click.confirm('Set up last.fm account?', default=True): click.echo(''' You'll need to create a last.fm API application first. Do so here: http://www.last.fm/api/account/create What you fill in doesn't matter at all, just make sure to save the API Key and Shared Secret. ''') config['lastfm'] = { key: click.prompt(key, type=str, hide_input=hidden) for (key, hidden) in [('user_name', False), ('password', True), ('api_key', False), ('api_secret', True)] } if click.confirm('Set up Libre.fm account?'): libre_conf = { key: click.prompt(key, type=str, hide_input=hidden) for (key, hidden) in [('user_name', False), ('password', True)] } libre = pylast.LibreFMNetwork( username=libre_conf['user_name'], password_hash=pylast.md5(libre_conf['password'])) skg = pylast.SessionKeyGenerator(libre) url = skg.get_web_auth_url() click.echo('''Please grant lastcast access to your Libre.fm account: %s ''' % url) click.echo('Hit enter when ready') click.getchar() libre_conf['session_key'] = skg.get_web_auth_session_key(url) config['librefm'] = libre_conf available = [ cc.device.friendly_name for cc in pychromecast.get_chromecasts() ] if len(available) == 1: config['chromecast']['devices'] = [available[0]] if len(available) > 1 or click.confirm('Manually specify cast device?', default=True): click.echo('\n\nAvailable cast devices: %s' % ', '.join(available)) device_names = click.prompt('Which device(s) should be used? (comma separated)') device_names = [d.strip() for d in device_names.split(',') if d.strip != ''] config['chromecast']['devices'] = device_names click.echo('\n\nDefault chromecast apps to scrobble from: %s' % ', '.join(APP_WHITELIST)) apps = click.prompt('Comma separated apps [blank for default]', default='', show_default=False) apps = [app.strip() for app in apps.split(',') if app.strip() != ''] if apps: config['chromecast']['app_whitelist'] = apps generated = toml.dumps(config) click.echo('Generated config:\n\n%s' % generated) if click.confirm('Write to ~/.lastcast.toml?', default=True): with open(os.path.expanduser('~/.lastcast.toml'), 'w') as fp: fp.write(generated)
import os print(str(os.getcwd())) api_file = open('config.ini', 'r') APIS = api_file.read().split("\n") api_file.close() #print(APIS) API_KEY = APIS[0] API_SECRET = APIS[1] USERNAME = APIS[2] PASSWORD_HASH = pl.md5(APIS[3]) network = pl.LastFMNetwork(api_key=API_KEY, api_secret=API_SECRET, username=USERNAME, password_hash=PASSWORD_HASH) selected_artist = input("Insert artist: ") artist = network.get_artist(selected_artist) artist_tags = artist.get_top_tags(limit=5) related_artists = artist.get_similar(limit=20) j = 0 for rel in iter(artist_tags): print("Tag #" + str(j+1) + " for \'" + str(artist.get_name()) + "\': " + str(rel.item)) j = j+1 print("\n") j = 0
SONGS_FILEPATH = './' SONGS_MP3_FILEPATH = SONGS_FILEPATH + 'mp3/' SONGS_JSON_FILEPATH = SONGS_FILEPATH + 'songs.json' GENRES_FILEPATH = './genres/' GENRES_JSON_FILEPATH = GENRES_FILEPATH + 'genres.json' # Spotify API authentication credentials -- replace with your own SPOTIFY_USERNAME = '******' SPOTIFY_SCOPE = 'user-library-read' SPOTIFY_CLIENT_ID = '05e7c6482b334e56a6e021f382fb2ae1' SPOTIFY_CLIENT_SECRET = 'df3690b7878147f381883eeb664e5af2' SPOTIFY_REDIRECT_URI = 'http://example.com/callback/' # LastFM API authentication credentials LASTFM_USERNAME = '******' LASTFM_PASSWORD = pylast.md5('INSERT PASSWORD HERE!!!!!!!!!!!') LASTFM_API_KEY = 'd78627185599686b29173497e4c3a777' LASTFM_API_SECRET = 'cf3998c95df000233de80d2f12ac21a6' # Genius API creds GENIUS_ACCESS_TOKEN = '5dEY76JPQ2Zker-heyhaPmS3wrEFWuEG5ouofdLL65WTK1ShB0O2vaTwQTmhOmpL' # limit number of albums per artist ALBUMS_PER_ARTIST = 4 # other settings DOWNLOAD_IMAGES = True DOWNLOAD_SONGS = False DOWNLOAD_LYRICS = True # Banned album words (so we only get one version of full albums)
def main(): event = sys.argv[1] lines = sys.stdin.readlines() fields = dict([line.strip().split("=", 1) for line in lines]) # fields: title, artist, album, songDuration, songPlayed, rating, stationName, pRet, pRetStr, wRet, wRetStr, rating artist = fields["artist"] title = fields["title"] song_duration = int(fields["songDuration"]) song_played = int(fields["songPlayed"]) rating = int(fields["rating"]) # events: songstart, songfinish, ??? import pylast if event == "songfinish" and song_duration > MIN_DURATION and (100.0 * song_played / song_duration > THRESHOLD or song_played > PLAYED_ENOUGH): song_started = int(time.time() - song_played) network = pylast.LastFMNetwork(api_key = API_KEY, api_secret = API_SECRET, username = USERNAME, password_hash = pylast.md5(PASSWORD)) network.scrobble(artist = artist, title = title, timestamp = song_started) if event == "songfinish" and rating > 0: network = pylast.LastFMNetwork(api_key = API_KEY, api_secret = API_SECRET, username = USERNAME, password_hash = pylast.md5(PASSWORD)) track = network.get_track(artist, title) if rating == 1: track.love() elif rating == 2: track.ban()
lastfm_secret_key = "" # You have to have your own unique two values for Spotify API keys # Obtain yours from https://developer.spotify.com/my-applications/#!/applications/create SPOTIPY_CLIENT_ID = " SPOTIPY_CLIENT_SECRET = "" SPOTIPY_REDIRECT_URI = '' # This is your last.fm password and stuff lastfm_username = "" lastfm_password = "" # This is your spotify username username = "" # Use the following two configs for create_hdf5.py # This is the usernames you're trying to look at info about targets = ["", "", ""] # Uncomment one of these to get stats on the top songs time_period = 'PERIOD_OVERALL' # time_period = 'PERIOD_12MONTHS' # time_period = 'PERIOD_6MONTHS' # time_period = 'PERIOD_3MONTHS' # Use the following if you are using create_playlist.py, which requires an output.h5 client_credentials_manager = SpotifyClientCredentials(client_id=SPOTIPY_CLIENT_ID, client_secret=SPOTIPY_CLIENT_SECRET) spotify = spotipy.Spotify(client_credentials_manager=client_credentials_manager) network = pylast.LastFMNetwork(api_key=lastfm_public_key, api_secret=lastfm_secret_key, username=lastfm_username, password_hash=pylast.md5(lastfm_password))
import os import datetime import time import random import sys import webbrowser # -*- coding: utf-8 -*- #Get necessary variables print("Usage: 'python3 recommends.py USERNAME PASSWORD APIKEY APISECRET'") if len(sys.argv) >= 2: username = str(sys.argv[1]).replace(" ", "") else: username = str(input("Last.FM username: "******"Last.FM password: "******"Last.FM API Key: ")) if len(sys.argv) >= 5: API_SECRET = str(sys.argv[4]) else: API_SECRET = str(input("Last.FM API Secret: ")) #webbrowser.open("http://www.last.fm/api/auth/?api_key="+API_KEY+"&token=, new=0, autoraise=True) network = pylast.LastFMNetwork(api_key=API_KEY, api_secret=API_SECRET,
def get_password_hash(): """TODO.""" pass_prompt = Fore.RED + "Last.fm password: " password_hash = pylast.md5(getpass.getpass(pass_prompt)) print() return password_hash
def __init__(self): self.network = pylast.LastFMNetwork( api_key=self.config.LASTFM.KEY, api_secret=self.config.LASTFM.SECRET, username=self.config.LASTFM.USERNAME, password_hash=pylast.md5(self.config.LASTFM.PASSWORD))
import pylast import time import datetime import credentials import sys password_hash = pylast.md5(credentials.password) network = pylast.LastFMNetwork( api_key = credentials.API_KEY, api_secret = credentials.API_SECRET, username = credentials.username, password_hash = password_hash) scrobble_file = open(sys.argv[1], 'r' ) failures = open(sys.argv[1] + "_failed", 'w' ) for scrobble in scrobble_file: if scrobble[0] != "#": scrobble_parts = scrobble.split("\t") artist = time = int(scrobble_parts[-2]) network.scrobble(artist= "Iron Maiden", title="The Nomad", timestamp=time) else: failures.write(scrobble) scrobble_file.close()