def get_song_ids_from_db():
con = mdb.connect(ADDRESS, USERNAME, PASSWORD, SCHEMA)
musixmatch = Musixmatch(MM_API_KEY)
with con:
cur = con.cursor()
cur.execute(
"SELECT DISTINCT song_name, artist_name, artist_id FROM popular_songs, artists WHERE popular_songs.artist_name = artists.name AND song_id = -1")
set_of_new_songs = set()
dict_of_updates_popular = dict()
for i in range(cur.rowcount):
row = cur.fetchone()
song_name, artist_name, artist_id = row[0], row[1], row[2]
set_of_new_songs.add((song_name, artist_name, artist_id))
for song_name, artist_name, artist_id in set_of_new_songs:
cur.execute(
"SELECT song_id FROM songs WHERE title = %s AND artist_id = %s", (song_name, artist_id))
if cur.rowcount > 0:
song_id = cur.fetchone()[0]
dict_of_updates_popular.update({(song_name, artist_name): song_id})
else:
try:
message = musixmatch.matcher_track_get(song_name, artist_name).get('message')
if message.get('header').get('status_code') == 200:
track = message.get('body').get('track')
song_id = track.get('track_id')
lyrics_id = track.get('lyrics_id')
album_id = track.get('album_id')
rating = track.get('track_rating')
insert_new_song_mm(con, song_id, song_name, lyrics_id, album_id, artist_id, rating)
except Exception as e:
print "error occurred: couldn't get song " + song_name
print e.message
update_popular_songs(cur, dict_of_updates_popular)
def run():
musixMatch = Musixmatch(environ["API_KEY"])
dataService = DataService()
countryService = CountryService()
# LANGUAGE
languagetable = LanguageDetectionService().get_language_table(
dataService.all_lyrics)
languagetable.name = "language"
# MUSIXMATCH
entries = dataService.all_entries
track_info = musixMatch.label_entries(entries)
tracktable = DataCleanUpService.make_track_information_table(track_info)
# COUNTRY
countries = dataService.all_countries
country_info = countryService.get_country_info(countries)
countrytable = DataCleanUpService.make_country_information_table(
dataService.all_countries, country_info)
# COMBINE
df = (dataService.contestants.join(languagetable, how="left").join(
tracktable, how="left").merge(countrytable,
how="left",
left_on="to_country",
right_on="to_country"))
# OUTPUT
df.to_pickle("contestdata.pickle")
df.to_feather("contestdata.arrow")
df.to_csv("contestantdata.csv", quoting=csv.QUOTE_NONNUMERIC)
def get_release_dates_albums_and_types():
musixmatch = Musixmatch(MM_API_KEY)
con = mdb.connect(ADDRESS, USERNAME, PASSWORD, SCHEMA)
with con:
cur = con.cursor()
dict_of_dates = dict()
try:
cur.execute("SELECT album_id FROM albums WHERE type IS NULL")
for i in range(cur.rowcount):
album_id = cur.fetchone()[0]
album = musixmatch.album_get(album_id).get('message').get('body').get('album')
release_date = album.get('album_release_date')
album_type = album.get('album_release_type')
release_date = release_date.split('-')
year = -1
month = -1
if len(release_date) > 0:
year = release_date[0]
if len(release_date) > 1:
month = release_date[1]
dict_of_dates.update({album_id: (month, year, album_type)})
update_albums_release_date_and_type(cur, dict_of_dates)
except Exception as e:
print "error occurred: "
print e.message
print "size of dict: " + str(len(dict_of_dates))
update_albums_release_date_and_type(cur, dict_of_dates)
def get_lyrics_of_tracks():
musixmatch = Musixmatch(MM_API_KEY)
con = mdb.connect(ADDRESS, USERNAME, PASSWORD, SCHEMA)
con.set_character_set('utf8')
with con:
cur = con.cursor()
cur.execute('SET CHARACTER SET utf8')
cur.execute('SET character_set_connection=utf8')
dict_of_lyrics = dict()
set_of_existing_ids = get_existing_lyrics(con)
try:
cur.execute("SELECT song_id FROM songs")
for i in range(cur.rowcount):
song_id = cur.fetchone()[0]
if song_id not in set_of_existing_ids:
message = musixmatch.track_lyrics_get(song_id).get('message')
if message.get('header').get('status_code') == 200:
lyrics = message.get('body').get('lyrics')
text = lyrics.get('lyrics_body')
src_language = lyrics.get('lyrics_language')
dict_of_lyrics.update({song_id: (text, src_language)})
except Exception as e:
print "error occurred: "
print e.message
print "size of dict: " + str(len(dict_of_lyrics))
insert_into_lyrics(cur, dict_of_lyrics)
def analyze_artist(artist_name):
total_lyrics = dict()
long_lyrics = dict()
musixmatch = Musixmatch('1d5d5c029c5f15411a43e55e7efe4517')
print(musixmatch)
search_term = artist_name
result = (musixmatch.artist_search(search_term, 1, 5, '', ''))
# print(result)
artist = result['message']['body']['artist_list'][0]['artist']
#print(artist['artist_name'])
artist_id = artist['artist_id']
artist_name = artist['artist_name']
albums = musixmatch.artist_albums_get(
artist_id, '', 1, 10, 'desc')['message']['body']['album_list']
try:
genre = albums[0]['album']['primary_genres']['music_genre_list'][0][
'music_genre']['music_genre_name_extended']
except IndexError:
genre = 'N/A'
for album in albums:
album_id = album['album']['album_id']
# try:
# print('\t' + album['album']['album_name'])
# except:
# pass
track_list = musixmatch.album_tracks_get(
album_id, 1, 25, '')['message']['body']['track_list']
for track in track_list:
track_id = track['track']['track_id']
# try:
# print('\t\t' + track['track']['track_name'])
# except:
# pass
track_lyrics = musixmatch.track_lyrics_get(
track_id)['message']['body']['lyrics']['lyrics_body']
total_lyrics, long_lyrics = tokenize_song(
"\n".join(track_lyrics.split("\n")[:-2]), total_lyrics,
long_lyrics)
ego_rating = rateEgo(total_lyrics)
unique_word_count = len(total_lyrics.keys())
top_fifteen = sorted(long_lyrics.items(), key=lambda t:
(-t[1], t[0]))[0:10]
return (artist_name, unique_word_count, genre, top_fifteen, ego_rating,
total_lyrics)
'''print('Unique words in vocabulary:' + str(unique_word_count))
def get_lyrics_api(artist_name):
musixmatch_key = config.MUSIXMATCH_KEY
musixmatch = Musixmatch(musixmatch_key)
lyrics_list = []
final_verse_list = []
try:
artists_json = musixmatch.artist_search(q_artist=artist_name,
page_size=1,
page=1,
f_artist_id="",
f_artist_mbid="")
artist_id = artists_json['message']['body']['artist_list'][0][
'artist']['artist_id']
albums_json = musixmatch.artist_albums_get(artist_id=artist_id,
page_size=5,
page=1,
s_release_date='desc',
g_album_name="")
albums_list = albums_json['message']['body']['album_list']
for album in albums_list:
albums_id = album['album']['album_id']
tracks_json = musixmatch.album_tracks_get(album_id=albums_id,
f_has_lyrics=True,
page_size=20,
page=1,
album_mbid='')
tracks_list = tracks_json['message']['body']['track_list']
for track in tracks_list:
tracks_id = track['track']['track_id']
lyrics_json = musixmatch.track_lyrics_get(tracks_id)
lyrics = lyrics_json['message']['body']['lyrics'][
'lyrics_body']
sep = '*******'
lyrics = lyrics.split(sep, 1)[0]
lyrics = lyrics.replace('\\', ' ')
lyrics = lyrics.replace('\"', ' ')
lyrics = lyrics.replace('\\n', ',')
lyrics = lyrics.replace('\n', ',')
#lyrics = lyrics.replace('...', ',')
#lyrics = lyrics.replace('?', ' ')
#lyrics = lyrics.replace('!', ' ')
final_verse_list.append(lyrics)
return final_verse_list
except:
return None
def get_album_ratings():
musixmatch = Musixmatch(MM_API_KEY)
con = mdb.connect(ADDRESS, USERNAME, PASSWORD, SCHEMA)
with con:
cur = con.cursor()
cur.execute("SELECT album_id FROM albums WHERE rating IS NULL")
everything_list = []
for i in range(cur.rowcount):
id = cur.fetchone()[0]
album = musixmatch.album_get(id)
rating = album.get('message').get('body').get('album').get('album_rating')
everything_list.append((rating, id))
for item in everything_list:
cur.execute("UPDATE albums SET rating = %s WHERE album_id = %s", item)
def get_song_musixmatch(track_name, artist_name):
musixmatch = Musixmatch(MUSIXMATCH_TOKEN)
response = musixmatch.matcher_lyrics_get(track_name, artist_name)
if response['message']['header']['status_code'] != 200:
return None
lyrics = add_line_breaks(
response['message']['body']['lyrics']['lyrics_body'].split('\n'))
return {
'lyrics': lyrics if lyrics != [""] else None,
'source': 'Musixmatch',
}
def get_lyrics_mus(artist, artist2, song):
credentials = json.load(open("authorization.json"))
musixmatch_key = credentials['musixmatch_key']
if artist2 is not None:
artist_details = artist + ' feat ' + artist2
else:
artist_details = artist
mus = Musixmatch(musixmatch_key)
response = mus.matcher_lyrics_get(q_track=song, q_artist=artist_details)
if len(response['message']['body']) != 0:
print(response['message']['body']['lyrics']['lyrics_body'])
return response['message']['body']['lyrics']['lyrics_body']
return None
def get_mbid_from_albums():
musixmatch = Musixmatch(MM_API_KEY)
con = mdb.connect(ADDRESS, USERNAME, PASSWORD, SCHEMA)
with con:
cur = con.cursor()
dict_of_mbids = dict()
try:
cur.execute("SELECT album_id FROM albums WHERE albums.album_mbid IS NULL")
for i in range(cur.rowcount):
album_id = cur.fetchone()[0]
album = musixmatch.album_get(album_id).get('message').get('body').get('album')
album_mbid = album.get('album_mbid')
dict_of_mbids.update({album_id: album_mbid})
except Exception as e:
print "error occurred: "
print e.message
print "size of dict: " + str(len(dict_of_mbids))
update_album_mbid(cur, dict_of_mbids)
def get_all_tracks_from_albums():
musixmatch = Musixmatch(MM_API_KEY)
con = mdb.connect(ADDRESS, USERNAME, PASSWORD, SCHEMA)
with con:
cur = con.cursor()
list_of_lists_of_songs = list()
try:
cur.execute(
"SELECT album_id, album_mbid FROM albums WHERE album_mbid IS NOT NULL")
for i in range(cur.rowcount):
row = cur.fetchone()
album_id, album_mbid = row[0], row[1]
ll = musixmatch.album_tracks_get(album_id, 1, 100, album_mbid).get('message')
list_of_lists_of_songs.append(ll.get('body').get('track_list'))
insert_new_tracks_from_list(con, list_of_lists_of_songs)
except Exception as e:
print "error occurred: "
print e.message
print "size of list of lists: " + str(len(list_of_lists_of_songs))
insert_new_tracks_from_list(con, list_of_lists_of_songs)
def get_all_albums_from_artists():
musixmatch = Musixmatch(MM_API_KEY)
con = mdb.connect(ADDRESS, USERNAME, PASSWORD, SCHEMA)
with con:
cur = con.cursor()
cur.execute("SELECT artist_id FROM artists")
list_of_lists_of_albums = list()
for i in range(cur.rowcount):
id = cur.fetchone()[0]
for j in range(1, 5):
list_of_lists_of_albums.append(
musixmatch.artist_albums_get(id, 1, j, 100, 'desc').get('message').get('body').get('album_list'))
for lst in list_of_lists_of_albums:
for album in lst:
album = album.get('album')
artist_id = album.get('artist_id')
album_id = album.get('album_id')
album_name = album.get('album_name')
rating = album.get('album_rating')
album_cover = album.get('album_coverart_100x100')
insert_new_album_mm(con, album_id, album_name, artist_id, album_cover, rating)
def test_song(self):
song_id = '3nWzRkoCa44adZZ00li9sF'
track = spotify.track(song_id)
track_name = track['name']
musixmatch = Musixmatch('a4eb641afe366d7ce6d2013779c11916')
lyrics_res = musixmatch.matcher_lyrics_get(
q_artist='Big Sean', q_track=track_name)['message']
if lyrics_res['header']['status_code'] == 200:
lyrics = lyrics_res['body']['lyrics']['lyrics_body']
else:
lyrics = 'Lyrics Not Available for This Song'
cor_song_res = [
'Go Legend (& Metro Boomin)',
"If young Metro don't trust you, I'm gon' shoot you\nDo you know where you're going to?\nDo you like the things that life is showing you?\nWhere are you going to? (straight)\nDo you know?\n\n[Chorus: Travis Scott & Big Sean]\nMe and my best friend, 7-Eleven (yeah)\nWe go legend, we go legend (yeah, yeah)\nWe go legend, we go legend (alright)\nWe go legend, we go legend, yeah\nMe and my best friend, 7-Eleven, yeah\nWe go legend (go), we go legend (go), yeah (yeah)\nWe go legend (go), we go legend (go legend)\nWe go legend, we go legend, yeah\nWith my best friend (alright), 7-Eleven (whoa)\nWe go legend, (yeah) we can go legend\nCodeine legend (yeah, yeah), microphone legend\nWe go legend, yeah\n\n\nIn my house, yeah, hear alarms\nRingin' through my house (through my house), got 'em goin'\nClimbing in and out (in and out)\nWhat you knowin'? Never run your mouth (never run your mouth)\n \n\nLook, bitch, this not a drill, this the real thing (whoa)\nI do what the f**k I feel, f**k your feelings, yeah\nMade my blueprints, so my life got no ceilings (I don't see 'em)\nI create the energy that they keep stealing, yeah\n...\n\n******* This Lyrics is NOT for Commercial use *******\n(1409617537910)"
]
self.assertEqual([track_name, lyrics], cor_song_res)
def get_tracks_musixmatch():
try:
musixmatch = Musixmatch(MM_API_KEY)
con = mdb.connect(ADDRESS, USERNAME, PASSWORD, SCHEMA)
for i in range(1, 10):
chart = musixmatch.chart_tracks_get(i, 100, 0, country='il')
list_of_tracks = chart.get('message').get('body').get('track_list')
for j in range(100):
track = list_of_tracks[j].get('track')
song_id = track.get('track_id')
title = track.get('track_name')
lyrics_id = track.get('lyrics_id')
album_id = track.get('album_id')
album_name = track.get('album_name')
artist_id = track.get('artist_id')
artist_name = track.get('artist_name')
album_cover = track.get('album_coverart_100x100')
rating = track.get('track_rating')
insert_new_artist_mm(con, artist_name, artist_id)
insert_new_album_mm(con, album_id, album_name, artist_id, album_cover)
insert_new_song_mm(con, song_id, title, lyrics_id, album_id, artist_id, rating)
except:
pass
#!/usr/bin/env python3
import json, webbrowser
from .config import config
from musixmatch import Musixmatch
import click
from textwrap import fill
cfg = config()
key = cfg.get_key()
musixmatch = Musixmatch(key)
class msx:
def artists(country):
artist_json = musixmatch.chart_artists(country=country,
page=1,
page_size=20)
artist_list = json.loads(
json.dumps(artist_json['message']['body']['artist_list']))
for i in range(0, len(artist_list)):
wrapped = fill(artist_list[i]['artist']['artist_name'],
width=71,
subsequent_indent=' ' * 7)
print(' ' + wrapped)
def songs(country):
songs_json = musixmatch.chart_tracks_get(country=country,
page=1,
page_size=20,
f_has_lyrics=1)
songs_list = json.loads(
def initDbCollections(fromApi='Musixmatch'):
'''
Initialize MongoDb collection with genres and tracks foreach genre
:param fromApi: choose the APIs from which to retrieve the genres (available: MusixMatch)
:return:
'''
if (fromApi == 'Musixmatch'):
client = Musixmatch(__musixmatchAPIKey)
# Genres
if DbManager.getCollectionGenre().count() == 0:
print("Init data genres...\n")
count_add = 0
list_genres = client.genres_get(
)["message"]["body"]["music_genre_list"]
for g in list_genres:
count_add += 1
genre = g["music_genre"]
genre["localName"] = DbManager.fromServerToLocalGenreName(
genre["music_genre_vanity"])
DbManager.getCollectionGenre().insert_one(genre)
print("√ Added {0} genre/s".format(count_add))
else:
print("- No genres added, {0} on database".format(
DbManager.getCollectionGenre().count()))
# Music
if DbManager.getCollectionMusic().count() == 0:
print("Init data music...")
count_add = 0
if len(__map_genres_id.items()) == 0:
print("You have to a hashmap {genre:id,..}")
for keyGen, valGen in __map_genres_id.items():
count_item = 0
for page_count in range(1, 3):
'''
list_tracks = client.chart_tracks_get(f_has_lyrics=False, page=page_count, page_size=100, country=country)["message"]["body"][
"track_list"]
'''
list_tracks = client.track_by_genre_id(
page_size=100,
page=page_count,
f_music_genre_id=valGen
)["message"]["body"]["track_list"]
for t in list_tracks:
current = t["track"]
primary_genres = list()
exist = {}
exist_genre_locally = False
for pg in current["primary_genres"][
"music_genre_list"]:
music_genre = pg["music_genre"]
music_genre_local = DbManager.fromServerToLocalGenreName(
music_genre["music_genre_vanity"])
if DbManager.fromServerToLocalGenreName(music_genre["music_genre_vanity"]) \
and (music_genre_local not in exist):
music_genre['localName'] = music_genre_local
primary_genres.append(music_genre)
exist[music_genre_local] = True
exist_genre_locally = True
# Add track to mongoDb only if exist
if exist_genre_locally:
count_add += 1
count_item += 1
DbManager.getCollectionMusic().insert_one({
"artist_name":
current["artist_name"],
"track_name":
current["track_name"],
"primary_genres":
primary_genres,
"instrumental":
current["instrumental"],
"track_length":
current["track_length"]
if "track_length" in current else 0
})
print("√ Added {0} track/s for genre {1}".format(
count_item, keyGen))
if count_add > 0:
print("√ Added {0} track/s".format(count_add))
else:
print("- No music added, {0} on database".format(
DbManager.getCollectionMusic().count()))
else:
print("This API is not available\n")
return 0
import telebot
import lyricsgenius
from musixmatch import Musixmatch
cfg_file = open('config', 'r', newline='\n')
telegram_token, genius_token, musixmatch_token = cfg_file.readlines()
cfg_file.close()
bot = telebot.TeleBot(telegram_token.split('\n')[0])
genius = lyricsgenius.Genius(genius_token.split('\n')[0])
musixmatch = Musixmatch(musixmatch_token.split('\n')[0])
@bot.message_handler(content_types=['text'])
def start(message):
if message.text == '/start':
bot.send_message(
message.from_user.id,
'Введите имя исполнителя и наименование песни в формате {artist_name}-{song_title}'
)
else:
get_lyrics_from_genius(message)
# get_lyrics_from_musixmatch(message)
def get_lyrics_from_musixmatch(message):
try:
args = message.text
arg1, arg2 = args.split('-')
song_json = musixmatch.matcher_lyrics_get(arg2, arg1)
def post_facebook_message(fbid, recevied_message):
musixmatch = Musixmatch('e66da512f0d41fb64642d7ddc47ab311')
track = recevied_message #name of the song
answer = ""
result = musixmatch.matcher_track_get(track, "")
body = result.get('message').get('body')
user_details_url = "https://graph.facebook.com/v2.6/%s" % fbid
user_details_params = {
'fields': 'first_name,last_name,profile_pic',
'access_token': PAGE_ACCESS_TOKEN
}
user_details = requests.get(user_details_url, user_details_params).json()
objUsr = UsersBot()
objUsr.user_id = user_details['id']
objUsr.first_name = user_details['first_name']
objUsr.last_name = user_details['last_name']
users_bot = UsersBot.objects.all()
if objUsr in users_bot:
objUsr.save()
if (body != ''):
track_id = body.get('track').get('track_id')
res_lyrics = musixmatch.track_lyrics_get(track_id)
lyr_body = res_lyrics.get('message').get('body')
if (lyr_body != ''):
lyrics = lyr_body.get('lyrics').get('lyrics_body')
cl_lyrics = lyrics.split("*****")
answer = cl_lyrics[0]
else:
answer = "Lyrics not found!"
else:
answer = "Lyrics not found!"
objConv = Conversations()
objConv.user_id = user_details['id']
objConv.message_in = recevied_message
objConv.message_out = answer
objConv.save()
#cursor.execute('INSERT INTO words VALUES (?)', [recevied_message])
post_message_url = 'https://graph.facebook.com/v2.6/me/messages?access_token=%s' % PAGE_ACCESS_TOKEN
response_msg = json.dumps({
"recipient": {
"id": fbid
},
"message": {
"text": answer
}
})
status = requests.post(post_message_url,
headers={"Content-Type": "application/json"},
data=response_msg)
def setUp(self):
self.musixmatch = Musixmatch(os.environ.get('APIKEY'))
self.url = 'http://api.musixmatch.com/ws/1.1/'
track_info = dataset.iloc[137:200, 1:].values
writer = csv.writer(open('song_features_musix_temp.csv', 'w',
encoding='utf-8'))
track_ids = []
song_names = []
all_features = []
all_harmonies = []
labels = []
all_lyric_object = []
all_lyric_tones = []
# MusixMatch API
musixmatch = Musixmatch('3dbbf7d593f0f05ab045dac7b015c430')
# Tone Analyzer API
authenticator = IAMAuthenticator(
'R7Ja2rP0jp6LucFzOl5-4xbMSVSX5Fci8wc63J0O5-l3')
tone_analyzer = ToneAnalyzerV3(version='2017-09-21',
authenticator=authenticator)
tone_analyzer.set_service_url(
'https://api.us-south.tone-analyzer.watson.cloud.ibm.com/instances/b8f00a45-63d1-4bb9-b1a0-1c2e6bc3e4ca'
)
if token:
for obs in track_info:
try:
labels.append(obs[2])
# coding: utf-8
# In[69]:
import pandas as pd
import numpy as np
import csv
import re
import urllib, json
from musixmatch import Musixmatch
musixmatch = Musixmatch(
'e5e7719b47f96c02f10ecc01d2025414') #Musixmatch authentication
# In[70]:
df = pd.read_csv('SongCSV.csv') #DataFrame
df.head()
songNameList = df['Title'].values.tolist(
) #Creating a list of the songName column
artistNameList = df['ArtistName'].values.tolist(
) #Creating a list of the artistName column
albumNameList = df['AlbumName'].values.tolist(
) #Creating a list of the albumName column
# In[49]:
songNameList[0] = re.sub(
r'\([^)]*\)', '', songNameList[0]
) #Removes anything that's in the parenthesis of song name. for example Mr. Brightside (Remix). The bracket part gets removed.
songNameList[0]
# -*- coding: utf-8 -*-
from musixmatch import Musixmatch
import json
api_key = ''
musixmatch = Musixmatch(api_key)
# Belgium
# Canada
# Germany
# United Kingdom
# Mexico
# Norway
# Russia
# Sweden
# United States
# Australia
# United Arab Emirates
# Switzerland
# Uganda
# New Zealand
countries = [
'BE', 'CA', 'DE', 'GB', 'MX', 'NO', 'RU', 'SE', 'US', 'AU', 'AE', 'CH',
'UG', 'NZ'
]
genre_names = {}
out = open('canciones.csv', 'w')
out.write('lyrics_string,genre_class\n')
import csv
from musixmatch import Musixmatch
musixmatch = Musixmatch('d9f4b70591c4995eaa6ae7a0c508d465')
def check_language(mmID):
try:
lyrics = musixmatch.track_lyrics_get(mmID)
language = lyrics['message']['body']['lyrics']['lyrics_language_description']
except:
language = 'haha'
return language
all_lan_dataset = open("Country_Rap_12000_2.csv").readlines()
#print len(all_lan_dataset)
en_song_list = []
for i in range(0, len(all_lan_dataset)):
#print i
ID_list = []
song = all_lan_dataset[i]
info = song.strip().split(",")
#print info
mmID = info[3]
ID_list.append(mmID)
if check_language(mmID) == 'English' or check_language(mmID) =='en':
en_song_list.append(ID_list)
#PhishBot
#this bot tweets random lyrics from the legendary rock band from Vermont Phish's extensive catalog
#link to the bot is https://twitter.com/Phish_Bot
#Created by Sam Kravitz
import tweepy
import time
import random
from Phunction import getTweet
from musixmatch import Musixmatch
from credentials import *
musixmatch = Musixmatch(music_key)
#values changed for security purposes.
#access apps.twitter.com to find the values for your specific project
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_secret)
#authorizes the bot and loads in its username
api = tweepy.API(auth)
user = api.get_user('Phish_Bot')
#at the moment the bot also follows follower of my main account, @krav1tz
#myFollowers is an array containing each user who follows @krav1tz
myFollowers = api.followers_ids('krav1tz')
myFollowersLength = len(myFollowers)
#artist
phish = musixmatch.artist_search('phish', 1, 1, 0, 0)
phish_id = phish['message']['body']['artist_list'][0]['artist']['artist_id']
# By Carlie Hamilton
# 13 March 2019
# https://github.com/BlueCodeThree
# Grabs the song spotify is currently playing and shows you the lyrics to it.
import spotipy
import spotipy.util as util
import apikey
import sys
import webbrowser
import os
from musixmatch import Musixmatch
username = apikey.spotify_username
scope = 'user-read-currently-playing'
musixmatch = Musixmatch(apikey.musixmatch_api)
# getting a token
try:
token = util.prompt_for_user_token(username,
scope,
client_id=apikey.spotify_id,
client_secret=apikey.spotify_secret,
redirect_uri=apikey.spotify_redirect)
except:
print("Can't get token for", username)
os.remove(f".cache-{username}")
token = util.prompt_for_user_token(username,
scope,
client_id=apikey.spotify_id,
client_secret=apikey.spotify_secret,
#!/usr/bin/env python from __future__ import absolute_import, division, print_function, unicode_literals from django.db.models import Q from django.views.generic import TemplateView, ListView from rest_framework.views import APIView from rest_framework.response import Response from django.http import HttpResponse from musixmatch import Musixmatch musixmatch = Musixmatch(env.musixmatch_token) from .models import Song import numpy as np import tensorflow as tf # !pip install -q tensorflow-hub # !pip install -q tensorflow-datasets import tensorflow_hub as hub import tensorflow_datasets as tfds import csv import pandas as pd pd.options.mode.chained_assignment = None # default='warn' from tensorflow.python.keras.preprocessing.text import Tokenizer from tensorflow.python.keras.preprocessing.sequence import pad_sequences from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Embedding, LSTM, GRU # Imports the Google Cloud client library
def setup_class(cls):
cls.musixmatch = Musixmatch("test")
cls.url = "http://api.musixmatch.com/ws/1.1/"
import os
os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "client-secret1.json"
import dialogflow_v2 as dialogflow
dialogflow_session_client = dialogflow.SessionsClient()
PROJECT_ID = "music-neiedm"
from musixmatch import Musixmatch
musixmatch = Musixmatch("668ca0e26add2355dafb6fded1744099")
from gnewsclient import gnewsclient
client = gnewsclient.NewsClient(max_results=3)
from pymongo import MongoClient
cl = MongoClient(
"mongodb+srv://test:[email protected]/test?retryWrites=true&w=majority"
)
db = cl.get_database('user_db')
records = db.user_info
def update_records(id, topic, language, location):
if (topic != " "):
records.update_one({'session_id': id}, {"$set": {
"news_type": topic
}},
upsert=True)
if (language != " "):
records.update_one({'session_id': id},
# A module for defining currently top songs in a certain country, using python wrapper for Musixmatch API
from musixmatch import Musixmatch
musixmatch = Musixmatch('<apikey>') # type your key instead of <apikey>
def create_dict(js_data):
"""
Creates a dictionary with a song name as a key and a list with an album name and an artist name as a value.
:param js_data: json data
:return: dict
"""
songs_dict = dict()
track_list = js_data['message']['body']['track_list']
for song in track_list:
track = song['track']
key = track['track_name']
value = [track['album_name'], track['artist_name']]
songs_dict[key] = value
return songs_dict
def top_songs(songs_num, country):
"""
Returns a dictionary with <songs_num> top sons in a <country> country.
:param songs_num: int
:param country: str
:return: dict
"""
songs = musixmatch.chart_tracks_get(1,
songs_num,
f_has_lyrics=True,
class CopyrightError(Exception):
pass
class APILimitError(Exception):
pass
# Grab the API key from a local 'client_secret.json' file
CLIENT_API_KEY = ''
with open('client_secret.json') as CONFIGS:
CLIENT_API_KEY = json.load(CONFIGS)['musixmatch_api_key']
# Construct an object of the Musixmatch class with the given API key
musixmatch = Musixmatch(CLIENT_API_KEY)
def get_lyrics_by_search(song_title, artist_name):
""" Returns an array containing the lyrics of a single song given the song title and artist. """
lyric_response = musixmatch.matcher_lyrics_get(song_title, artist_name)
return get_lyrics_from_response(lyric_response)
def get_lyrics_by_id(song_id):
""" Returns an array containing the lyrics of a single song given the musixmatch song id """
lyric_response = musixmatch.track_lyrics_get(song_id)
return get_lyrics_from_response(lyric_response)