def audio_check(file_buffer):
config = {
'host': audio_identifier_host,
'access_key': audio_identifier_access_key,
'access_secret': audio_identifier_access_secret,
'recognize_type': ACRCloudRecognizeType.ACR_OPT_REC_AUDIO,
'debug': False,
'timeout': 10 # seconds
}
re = ACRCloudRecognizer(config)
res_str = re.recognize_by_filebuffer(file_buffer, 0, 10)
res_dict = json.loads(res_str)
status_code = res_dict["status"]["code"]
if status_code == 0:
# TO DO
# create answer payload
metadata = res_dict["metadata"]
metadata_music_list = metadata["music"]
check_answer = {}
for i in range(0, len(metadata_music_list)):
title = metadata_music_list[i]["title"]
artists = metadata_music_list[i]["artists"]
song = {'title': title, 'artists': artists}
hashed_val = hashlib.sha1(json.dumps(song, \
sort_keys=True).encode()).hexdigest()
if check_answer.get(hashed_val) == None:
check_answer[hashed_val] = i
answer = song
return answer
else:
status_msg = res_dict["status"]["msg"]
err = {'error': status_msg}
return err
def recognize(file_name):
config = {
'host': 'identify-cn-north-1.acrcloud.com',
'access_key': 'a2027bf3a7998a47874e361ad626409e',
'access_secret': 'n8u8aoLWvqqM5v3Gg6wDPxya8VpnwIpYreq7JrMx',
'recognize_type': ACRCloudRecognizeType.ACR_OPT_REC_AUDIO,
'debug': False,
'timeout': 10 # seconds
}
print('config ok')
'''This module can recognize ACRCloud by most of audio/video file.
Audio: mp3, wav, m4a, flac, aac, amr, ape, ogg ...
Video: mp4, mkv, wmv, flv, ts, avi ...'''
re = ACRCloudRecognizer(config)
print('read config ok')
res = json.loads(re.recognize_by_file(file_name))
number = len(res['metadata']['music'])
songList = []
for i in range(number):
song = {}
song["name"] = res['metadata']['music'][i]['title']
song["singer"] = res['metadata']['music'][i]['artists'][0]['name']
songList.append(song)
result = {}
result["songlist"] = songList
#result=json.loads(result)
result = str(result)
return result.replace('u\'', '\'')
def sound_find(self, file_path):
file = file_path
config = {
#Replace "xxxxxxxx" below with your project's host, access_key and access_secret.
'host': self.host,
'access_key': self.access_key,
'access_secret': self.access_secret,
'timeout': 60 # seconds
}
'''This module can recognize ACRCloud by most of audio/video file.
Audio: mp3, wav, m4a, flac, aac, amr, ape, ogg ...
Video: mp4, mkv, wmv, flv, ts, avi ...'''
re = ACRCloudRecognizer(config)
#recognize by file path, and skip 0 seconds from from the beginning of sys.argv[1].
#print(re.recognize_by_file(file, 0))
indata = re.recognize_by_file(file, 0)
indata = str(indata)
indata = json.loads(indata)
#print(type(indata))
#you_id=indata["metadata"]["music"][0]["external_metadata"]["youtube"]["vid"]
#print("https://www.youtube.com/watch?v="+you_id)
if indata["status"]["msg"] == "Success":
return indata["metadata"]["music"][0]["external_metadata"]
else:
return False
pass
def createAuthObject():
f_secrets = open('secrets.txt', 'r')
twitch_client_id = f_secrets.readline().strip()
twitch_client_secret = f_secrets.readline().strip()
acr_host = f_secrets.readline().strip()
acr_key = f_secrets.readline().strip()
acr_secret = f_secrets.readline().strip()
yt_key = f_secrets.readline().strip()
f_secrets.close()
oauth_endpoint = "https://id.twitch.tv/oauth2/token?client_id={}&client_secret={}&grant_type={}".format(
twitch_client_id, twitch_client_secret, "client_credentials")
oauth_reply = requests.post(oauth_endpoint).json()
twitch_token = oauth_reply['access_token']
ACR_config = {
'host': acr_host,
'access_key': acr_key,
'access_secret': acr_secret,
'recognize_type': ACRCloudRecognizeType.ACR_OPT_REC_AUDIO,
'debug': False,
'timeout': 10 # seconds
}
copyright_recognizer = ACRCloudRecognizer(ACR_config)
return Auth(twitch_token, twitch_client_id, copyright_recognizer, yt_key)
def get_subs():
while True:
print('Recording... ',end='\r')
data = sd.rec(int(SECONDS * RATE), samplerate=RATE, channels=2)
sd.wait()
wavf.write('out.wav', RATE, data)
acr = ACRCloudRecognizer(config)
results = json.loads(acr.recognize_by_file('out.wav', 0))
if results.get('status') and results['status'].get('code') == 1001:
continue
break
with open('logs/res_dump.json', 'w') as f:
json.dump(results, f, indent=2)
response_time = results['cost_time']
load_lyric_start = timer()
subs = None
for result in acr['metadata']['music']:
artist = result['artists'][0]['name'].split(';')[0]
song = result['title']
offset_time = result['play_offset_ms'] / 1000
run_time = result['duration_ms'] / 1000
print(song, artist)
search_request = SearchRequest(artist, song)
subs = ComboLyricsProvider().search(search_request)
if subs:
print(f"Found Using Engine '{subs.metadata['provider']}'")
return subs, load_lyric_start-response_time-offset_time, run_time, song
return None
def __init__(
self,
sample_rate,
duration,
channels,
filename,
audio_format,
high_pass_frequency,
high_pass_order,
acrcloud_config,
acrcloud_result_score_threshold,
recognizer_start_offset=0,
noise_audio_filepath=None,
additional_operations=None
):
self.sample_rate = sample_rate
self.duration = duration
self.channels = channels
self.filename = filename
self.audio_format = audio_format
self.high_pass_frequency = high_pass_frequency
self.high_pass_order = high_pass_order
self.recognizer = ACRCloudRecognizer(acrcloud_config)
self.acrcloud_result_score_threshold = acrcloud_result_score_threshold
self.recognizer_start_offset = recognizer_start_offset
self.noise_audio_filepath = noise_audio_filepath
if not additional_operations:
additional_operations = []
self.additional_operations = additional_operations
def check_music(self):
'''Проверка музыки'''
config = {
'host': 'identify-eu-west-1.acrcloud.com',
'access_key': 'a18a4f6a76f4a6edf47e3204266f8692',
'access_secret': 'iGKRisfMUvAex9mFKTlOloMPPqf3BrMmfxjzL85g',
'debug': False,
'timeout': 10,
}
acrcloud = ACRCloudRecognizer(config)
data = acrcloud.recognize_by_file(file_path = 'audio/{}.mp4'.format(self.name), start_seconds = 0)
data = json.loads(data)
path = os.path.join(os.path.abspath(os.getcwd()), 'audio/{}.mp4'.format(self.name))
os.remove(path)
try:
name_artist = data['metadata']['music'][0]['artists'][0]['name']
name_song = data['metadata']['music'][0]['title']
self.result = str(name_artist) + ' - ' + str(name_song)
return 'ok'
except:
result_error = data['status']['msg']
if result_error == 'Missing/Invalid Access Key':
self.result = 'Ошибка на стороне сервера'
return 'ok'
elif result_error == 'No result':
self.result = 'Песня не найдена'
return 'ok'
def __init__(self, config, master=None):
super().__init__(master)
self.acr_cloud = re = ACRCloudRecognizer(config)
self.db = sql.connect('./db.sqlite3')
self.cur = self.db.cursor()
w, h = 1000, 550 # size of main window
# screen size of display
ws = self.master.winfo_screenwidth()
hs = self.master.winfo_screenheight()
# center position
x = (ws / 2) - (w / 2)
y = (hs / 2) - (h / 2)
# configure main window
self.master.title('Radio Surveillance System')
self.master.geometry('%dx%d+%d+%d' % (w, h, x, y))
self.master.resizable(0, 0)
self.config(background='saddle brown')
self.pack(fill=tk.BOTH, expand=1)
self.grid_columnconfigure(0, weight=1)
self.grid_rowconfigure(1, weight=1)
self.master.protocol("WM_DELETE_WINDOW", self.on_closing)
# create initial widgets
self.create_widget()
return
def __init__(self, config, debug=1):
self.openpyxl_version = ".".join(
str(openpyxl.__version__).split(".")[:2])
self.config = config
self.debug = debug
self.init_log()
self.re_handler = ACRCloudRecognizer(self.config)
def auth(self, config):
recognizer_config = {
"host": config["ACRCloud"]["host"],
"access_key": config["ACRCloud"]["access_key"],
"access_secret": config["ACRCloud"]["secret_key"],
"timeout": 10
}
self.recognizer = ACRCloudRecognizer(recognizer_config)
def recognize_music(full_path):
re = ACRCloudRecognizer(config)
result = json.loads(re.recognize_by_file(full_path, 0))
if result['status']['code'] != 0:
buf = open(full_path, 'rb').read()
result = json.loads(re.recognize_by_filebuffer(buf, 0))
if result['status']['code'] != 0:
return 'UNKNOWN'
data = result['metadata']['music'][0]
return data['title'] + '-' + data['artists'][0]['name']
def identify_audio():
config = {
'host': cc.audio_acr_host,
'access_key': cc.audio_acr_access_key,
'access_secret': cc.audio_access_secret,
'timeout': 5 # seconds
}
re = ACRCloudRecognizer(config)
print('Recognizing...')
acr_res = re.recognize_by_file(wav_path, 0)
return json.loads(acr_res)
def get_songs(tiktok_url):
config = {
'host': "identify-eu-west-1.acrcloud.com",
'access_key': "8862724c406dc09588b45a0100a6ff14",
'access_secret': "VUZkQ7vDytAxAcizRV1YzgwmZ12Mt57fyCmQkRf2",
'timeout': 10
}
re = ACRCloudRecognizer(config)
buf = get_mp3_bytes_code(tiktok_url)
return re.recognize_by_filebuffer(buf, 0)
def setup():
config = {
'host': 'identify-ap-southeast-1.acrcloud.com',
'access_key': '450adec73c812fc14e6596f48dd95f70',
'access_secret': 'KJwFL18C9UhO7xgqftDAmVGMThieQMdtlDCrU5da',
'recognize_type': ACRCloudRecognizeType.ACR_OPT_REC_AUDIO,
# you can replace it with [ACR_OPT_REC_AUDIO,ACR_OPT_REC_HUMMING,ACR_OPT_REC_BOTH], The SDK decide which type fingerprint to create accordings to "recognize_type".
'debug': False,
'timeout': 10 # seconds
}
re = ACRCloudRecognizer(config)
return re
def get_tracks_from_audio(file):
response = ({}, 404)
if file is None or file == '':
print('invalid audio file')
response = ({}, 400)
else:
config = {
'host': 'identify-us-west-2.acrcloud.com',
'access_key': os.environ.get('ACCESS_KEY'),
'access_secret': os.environ.get('ACCESS_SECRET'),
'recognize_type': ACRCloudRecognizeType.ACR_OPT_REC_BOTH,
'debug': False,
'timeout': 10 # seconds
}
'''This module can recognize ACRCloud by most of audio/video file.
Audio: mp3, wav, m4a, flac, aac, amr, ape, ogg ...
Video: mp4, mkv, wmv, flv, ts, avi ...'''
recognizer = ACRCloudRecognizer(config)
f = tempfile.NamedTemporaryFile()
f.write(file.read())
duration = ACRCloudRecognizer.get_duration_ms_by_file(str(f.name))
print("duration_ms=" + str(duration))
if duration // 1000 > 10:
max_duration = max(10, (duration * 20 // 100) // 1000)
else:
max_duration = 10
result = json.loads(recognizer.recognize_by_file(str(f.name), 0, max_duration))
print(result)
f.close()
tracks = process_metadata(result)
data = {
'data': tracks
}
response = (data, 200)
print(json.dumps(response[0], indent=4))
return response
def func():
if not config:
print "ERROR: Cannot find ACRCloudConfig"
return
global re
re = ACRCloudRecognizer(config)
segments = ast.literal_eval(
open(PATH_TO_DIR + "/segments", "r").readline())
musicSegments = segments[1]
for s in musicSegments:
recognizeForSegment(s)
def __init__(self):
self.log = Logger().log
# Loading Necessary Information from Config File
with open("./config/config.json") as config_file:
config_data = json.load(config_file)
self.ACRCloud_config = {"region": config_data["ACRCloud"]["region"].encode('utf8'),
"host": config_data["ACRCloud"]["host"].encode('utf8'),
"access_key": config_data["ACRCloud"]["access_key"].encode('utf8'),
"access_secret": config_data["ACRCloud"]["access_secret"].encode('utf8'),
"timeout": config_data["ACRCloud"]["timeout"]}
self.log('info', 'initializing connection to ACR-Cloud service')
self.acrcloud = ACRCloudRecognizer(self.ACRCloud_config)
def hum(filePath):
config = config_hum
'''This module can recognize ACRCloud by most of audio/video file.
Audio: mp3, wav, m4a, flac, aac, amr, ape, ogg ...
Video: mp4, mkv, wmv, flv, ts, avi ...'''
re = ACRCloudRecognizer(config)
#recognize by file path, and skip 0 seconds from from the beginning of sys.argv[1].
#re.recognize_by_file(filePath, 0, 10)
logger.info('ACR: Processing request...')
buf = open(filePath, 'rb').read()
#recognize by file_audio_buffer that read from file path, and skip 0 seconds from from the beginning of sys.argv[1].
data = re.recognize_by_filebuffer(buf, 0, 10)
data = json.loads(data)
logger.info('ACR: Processing complete!')
return data
def recognize(path):
recognized = {
'title': '',
'artist': '',
}
# Load song metadata from acrcloud
try:
from acrcloud.recognizer import ACRCloudRecognizer
re = ACRCloudRecognizer(storage.config)
recognized_data = json.loads(re.recognize_by_file(path, 0))
recognized_song = recognized_data['metadata']['music'][0]
recognized['title'] = recognized_song['title']
recognized['artist'] = recognized_song['artists'][0]['name']
except KeyError:
pass
return recognized
def main():
sp = spotipy.Spotify(auth=token)
sp.trace = False
music = ""
artist = ""
config = {
#Replace "xxxxxxxx" below with your project's host, access_key and access_secret.
'host':'identify-eu-west-1.acrcloud.com',
'access_key':'c20267418e799f23a3f94b14baf3a790',
'access_secret':'aiwwg7KPELXaWt9AwvfYv6IclZSCTndEltCftKjJ',
'timeout':10 # seconds
}
re = ACRCloudRecognizer(config)
while(1):
os.system('sudo ./ripper.sh')
json_data = json.loads(re.recognize_by_file("/tmp/aaa.mp3", 0))
print(json.dumps(json_data))
if(json_data["status"]["msg"] == "Success"):
current_music = json_data["metadata"]["music"][0]["title"]
current_artist = json_data["metadata"]["music"][0]["artists"][0]["name"]
if current_music != music or current_artist != artist:
music = current_music
artist = current_artist
external = json_data["metadata"]["music"][0]["external_metadata"]
if "spotify" in external:
spotify_id = external["spotify"]["track"]["id"]
print("SPOT ID ", spotify_id)
if(token):
try:
r = sp.user_playlist_remove_all_occurrences_of_tracks(username,playlist,[spotify_id])
print(r)
r = sp.user_playlist_add_tracks(username, playlist, [spotify_id])
print(r)
except spotipy.client.SpotifyException:
print("exception")
refresh()
sp = spotipy.Spotify(auth=token)
sp.trace = False
sp.user_playlist_remove_all_occurrences_of_tracks(username,playlist,[spotify_id])
sp.user_playlist_add_tracks(username, playlist, [spotify_id])
os.remove("/tmp/aaa.mp3")
os.remove("/tmp/aaa.cue")
def audio_file(audio):
config = {
'host': 'ap-southeast-1.api.acrcloud.com',
'access_key': 'f1840ce5b0603e9db3ec8c526eea65e5',
'access_secret': '1NfVJoxoREbGlO9HVqG4QNkSiMT86Lvs3Geogov9',
'debug': True,
'timeout': 30 # seconds
}
'''This module can recognize ACRCloud by most of audio/video file.
Audio: mp3, wav, m4a, flac, aac, amr, ape, ogg ...
Video: mp4, mkv, wmv, flv, ts, avi ...'''
re = ACRCloudRecognizer(config)
# recognize by file path, and skip 0 seconds from from the beginning of sys.argv[1].
buf = open(audio, 'rb').read()
# recognize by file_audio_buffer that read from file path, and skip 0 seconds from from the beginning of sys.argv[1].
return re.recognize_by_filebuffer(buf, 1)
def recognize_music(filePath, config, start):
config["timeout"] = 10 # seconds
re = ACRCloudRecognizer(config)
# recognize by file path, and skip 'start' seconds from from the beginning of sys.argv[1].
result = json.loads(re.recognize_by_file(filePath, start, start + 10))
if 'metadata' in result.keys():
result = result['metadata']['music'][0]
if 'genres' in result.keys():
# TODO : check if genres in required list
return (result['title'], result['artists'][0]['name'],
','.join([g['name'] for g in result['genres']]))
else:
return (result['title'], result['artists'][0]['name'], '')
else:
return ('', '', '')
def init_config(self):
try:
json_config = None
with codecs.open(self.config_file, 'r') as f:
json_config = json.loads(f.read())
for k in ["host", "access_key", "access_secret"]:
if k in json_config and json_config[k].strip():
self.config[k] = str(json_config[k].strip())
else:
self.dlog.logger.error(
"init_config.not found {0} from config.json, pls check"
.format(k))
sys.exit(1)
self.re_handler = ACRCloudRecognizer(self.config)
if self.re_handler:
self.dlog.logger.warn("init_config success!")
except Exception as e:
self.dlog.logger.error("init_config.error", exc_info=True)
def collect_metadata(msg, chtid):
file_id = msg["voice"]["file_id"]
filep = bot.getFile(file_id)
re = ACRCloudRecognizer(config)
abc = filep["file_path"]
newres = "https://api.telegram.org/file/bot" + botid + "/" + abc
file_name = wget.download(newres)
respon = re.recognize_by_file(file_name, 0)
result = json.loads(respon)
if (result["status"]["msg"] == "Success"):
print(result)
name = result["metadata"]["music"][0]["title"]
artist = result["metadata"]["music"][0]["artists"][0]["name"]
album = result["metadata"]["music"][0]["album"]["name"]
bot.sendMessage(
chtid, "Song Name : " + name + "\nArtist : " + artist +
"\nAlbum : " + album)
else:
bot.sendMessage(chtid, "No data found\nPlease try again")
def identify():
config = {
'host': 'identify-us-west-2.acrcloud.com',
'access_key': 'e0dec6b559cf1186da4b5283ab214b98',
'access_secret': 'k8Mb4sYf0A0xcVpptNb24m7uQ8jrGUSAR3nblN3X',
'recognize_type': ACRCloudRecognizeType.
ACR_OPT_REC_AUDIO, # you can replace it with [ACR_OPT_REC_AUDIO,ACR_OPT_REC_HUMMING,ACR_OPT_REC_BOTH], The SDK decide which type fingerprint to create accordings to "recognize_type".
'debug': False,
'timeout': 10 # seconds
}
'''This module can recognize ACRCloud by most of audio/video file.
Audio: mp3, wav, m4a, flac, aac, amr, ape, ogg ...
Video: mp4, mkv, wmv, flv, ts, avi ...'''
re = ACRCloudRecognizer(config)
#recognize by file path, and skip 0 seconds from from the beginning of sound file.
json = re.recognize_by_file("file.flac", 0, 10)
#print(json)
if "Success" not in json: #we have an error
return "error recording song"
else:
#gonna cut out title and artist from what is returned
start = json.index("\"artists\":[{\"name\":"
) + 20 ##20 chars before the stuff we want
end = json.index("\"", start)
artist = json[start:end]
start = json.index("\"title\":\"") + 9
end = json.index("\"", start)
title = json[start:end]
if "spotify" in json: #it has a spotify id
start = json.index("spotify")
json = json[start:]
json = json[json.index("track"):]
start = json.index("\"id\":\"") + 6
end = json.index("\"", start)
songId = json[start:end]
print(title + " by " + artist)
return songId
else: #it does not have a spotify id
return "Not on Spotify, but song is " + title + " by " + artist
def identify_audio(file=None, start_sec=0, end_sec=None):
"""Requests data from ACRCloud and re-formats for manageability"""
from acrcloud.recognizer import ACRCloudRecognizer
import json
import os
if end_sec is None:
end_sec = start_sec + 30
login = {
"access_key": config.ACR.key,
"access_secret": config.ACR.secret,
"host": "identify-us-west-2.acrcloud.com"
}
acr = ACRCloudRecognizer(login)
try:
sample_length = end_sec - start_sec
except TypeError:
sample_length = timestamptoSec(end_sec) - timestamptoSec(start_sec)
try:
data = json.loads(acr.recognize_by_file(file, start_sec,
sample_length))
os.remove(file) # delete the file since we don't need it anymore
except:
pass
try:
title, artists, score, duration, play_offset, acr_id = data["metadata"]["music"][0]["title"], data['metadata']['music'][0]['artists'][0]['name'], \
data['metadata']['music'][0]['score'], data["metadata"]["music"][0]["duration_ms"], \
data["metadata"]["music"][0]["play_offset_ms"], data["metadata"]["music"][0]["acrid"]
return {
"msg": "success",
"title": title,
"artists": artists,
"score": score,
"play_offset": play_offset,
"duration": duration,
"acr_id": acr_id
}
except:
return {"msg": "error", "score": 0}
def start_reckon(fileid, video_title, libLocation, library):
try:
'''This module can recognize ACRCloud by most of audio/video file.
Audio: mp3, wav, m4a, flac, aac, amr, ape, ogg ...
Video: mp4, mkv, wmv, flv, ts, avi ...'''
rec = ACRCloudRecognizer(acrcloud_config)
parsed_json = fingerprint(rec, 60, fileid, video_title)
if parsed_json is False:
app.logger.info("No Song found")
return False
cover_url = get_cover_url(parsed_json)
album = parsed_json['metadata']['music'][0]['album']['name']
artists = parsed_json['metadata']['music'][0]['artists']
title = parsed_json['metadata']['music'][0]['title']
artist_list = []
for artist in artists:
artist_list.append(artist['name'])
artist_string = ', '.join(artist_list)
audiofile = eyed3.load(fileid)
audiofile.tag.artist = unicode(artist_string)
audiofile.tag.album = unicode(album)
audiofile.tag.title = unicode(title)
audiofile.tag.album_artist = unicode(artist_string)
if cover_url != 0:
urllib.urlretrieve(cover_url, "cover.jpg")
imagedata = open("cover.jpg", "rb").read()
audiofile.tag.images.set(3, imagedata, "image/jpeg",
unicode(album))
audiofile.tag.save()
app.logger.info('Successfully tagged ' + artist_string + ' - ' + title)
moveFile(artist_string + ' - ' + title, fileid, libLocation, library)
return True
except Exception as e:
app.logger.error("Tagging Error: " + repr(e))
return False
def recognize_music(music_file, host, key, secret):
config = {
'host': host.encode('utf-8'),
'access_key': key.encode('utf-8'),
'access_secret': secret.encode('utf-8'),
'recognize_type': ACRCloudRecognizeType.ACR_OPT_REC_AUDIO, # you can replace it with [ACR_OPT_REC_AUDIO,ACR_OPT_REC_HUMMING,ACR_OPT_REC_BOTH], The SDK decide which type fingerprint to create accordings to "recognize_type".
'debug':False,
'timeout':10 # seconds
}
'''This module can recognize ACRCloud by most of audio/video file.
Audio: mp3, wav, m4a, flac, aac, amr, ape, ogg ...
Video: mp4, mkv, wmv, flv, ts, avi ...'''
re = ACRCloudRecognizer(config)
#recognize by file path, and skip 0 seconds from from the beginning of sys.argv[1].
#print re.recognize_by_file(music_file, 0, 10)
buf = open(music_file, 'rb').read()
#recognize by file_audio_buffer that read from file path, and skip 0 seconds from from the beginning of sys.argv[1]. print re.recognize_by_filebuffer(buf, 0, 10)
result = re.recognize_by_filebuffer(buf, 0, 10)
return result
def recognize_song(self, file):
re = ACRCloudRecognizer(self.config)
print('Recognizing song')
result = re.recognize_by_file(file, 0, 10)
result = json.loads(result)
success = result.get('status').get('msg')
if success == 'Success':
#print(result.get('metadata').get('music')[0])
artist = result.get('metadata').get('music')[0].get(
'artists')[0].get('name')
title = result.get('metadata').get('music')[0].get('title')
offset = result.get('metadata').get('music')[0].get(
'play_offset_ms')
duration = result.get('metadata').get('music')[0].get(
'duration_ms')
print("duration_ms=" +
str(ACRCloudRecognizer.get_duration_ms_by_file(file)))
value = (artist, title, float(offset) / duration, duration)
else:
value = None
print(value)
return value
except Exception as e:
print("Error " + str(e))
f.close()
sys.stdout.flush()
print("")
print("10 seconds from " + url + " have been recorded in " + fname)
# Identify the track and return it's unique Spotify id.
config = {
'host': 'identify-us-west-2.acrcloud.com',
'access_key': '82640bba7076975b5fcaf79d00795d16',
'access_secret': 'JaLNPFDhjQbAuJyQKU8HfU6xZU2YzwzTFFiPH3Z7',
'debug': True,
'timeout': 10
}
acrcloud = ACRCloudRecognizer(config)
track_data = json.loads(acrcloud.recognize_by_file(fname, 0))
# Cleanup .wav
for f in glob.glob('*.wav'):
os.remove(f)
try:
track_title = track_data['metadata']['music'][0]['external_metadata'][
'spotify']['track']['name']
track_id = track_data['metadata']['music'][0]['external_metadata'][
'spotify']['track']['id']
print('Identified track as', '\"' + track_title + '\"', track_id)
except:
print('Audio could not be identified')
sys.exit()
# Add the track to a spotify playlist.
