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()
