def calc_accuracy(path1, path2):
dur, fig = acoustid.fingerprint_file(path1)
fp1 = chromaprint.decode_fingerprint(fig)[0]
dur, fig2 = acoustid.fingerprint_file(path2)
fp2 = chromaprint.decode_fingerprint(fig2)[0]
return accuracy(fp1, fp2)
def main(argv):
def exit_with_usage():
print 'usage: $ python',__file__,'/path/to/foo.mp3'
if len(argv) != 2:
return exit_with_usage()
else:
path = argv[1]
dur, fp_raw = acoustid.fingerprint_file(path,return_raw=True)
dur, fp_str = acoustid.fingerprint_file(path)
print 'duration:',dur
print 'fingerprint str:',fp_str
print 'fingerprint raw:',fp_raw
def match_audio(song1, song2):
duration1, fp_encoded1 = acoustid.fingerprint_file(song1)
duration2, fp_encoded2 = acoustid.fingerprint_file(song2)
fingerprint1, version1 = chromaprint.decode_fingerprint(fp_encoded1)
fingerprint2, version2 = chromaprint.decode_fingerprint(fp_encoded2)
similarity = fuzz.ratio(fingerprint1, fingerprint2)
print(similarity)
if similarity >= 80:
return similarity
return 0
def fingerprint_item(item, lib=None, write=False):
"""Get the fingerprint for an Item. If the item already has a
fingerprint, it is not regenerated. If fingerprint generation fails,
return None. If `lib` is provided, then new fingerprints are saved
to the database. If `write` is set, then the new fingerprints are
also written to files' metadata.
"""
# Get a fingerprint and length for this track.
if not item.length:
log.info(u'{0}: no duration available'.format(
util.displayable_path(item.path)))
elif item.acoustid_fingerprint:
if write:
log.info(u'{0}: fingerprint exists, skipping'.format(
util.displayable_path(item.path)))
else:
log.info(u'{0}: using existing fingerprint'.format(
util.displayable_path(item.path)))
return item.acoustid_fingerprint
else:
log.info(u'{0}: fingerprinting'.format(util.displayable_path(
item.path)))
try:
_, fp = acoustid.fingerprint_file(item.path)
item.acoustid_fingerprint = fp
if write:
log.info(u'{0}: writing fingerprint'.format(
util.displayable_path(item.path)))
item.write()
if lib:
lib.store(item)
return item.acoustid_fingerprint
except acoustid.FingerprintGenerationError as exc:
log.info('fingerprint generation failed: {0}'.format(exc))
def getNamesLastFM(self, path):
# Use acoustid API to get song data if ID3 tags are not available.
fing = fingerprint_file(path, force_fpcalc=True)
fing = fing[1]
fing = str(fing)
fing = fing[2:-1]
url = 'https://api.acoustid.org/v2/lookup?client='
url += akey
url += '&meta=recordings+releasegroups+compress&duration='
url += str(self.d)
url += '&fingerprint='
url += fing
try:
text = urllib.request.urlopen(url)
parsed = json.loads(text.read())
names = list(acoustid.parse_lookup_result(parsed))
for x in names:
if None not in x:
names = x
title = names[-2]
artist = names[-1]
# Check if any feat. artists names in original name.
if ';' in artist:
artist = artist.split(';')
artist = artist[0]
if ',' in artist:
artist = artist.split(',')
artist = artist[0]
break
self.artist_name1 = artist
self.song_name1 = title
except:
print("No name data during search...")
def match(string):
API_KEY = 'HMU8Btr6'
#filename1 = 'song.mp3'
dur,fingp = acoustid.fingerprint_file(string)
commentText = ""
try:
#results = acoustid.match(API_KEY, filename)
results1 = acoustid.lookup(API_KEY, fingp, dur)
results = acoustid.parse_lookup_result(results1)
except acoustid.NoBackendError:
print("chromaprint library/tool not found", file=sys.stderr)
sys.exit(1)
except acoustid.FingerprintGenerationError:
print("fingerprint could not be calculated", file=sys.stderr)
sys.exit(1)
except acoustid.WebServiceError as exc:
print("web service request failed:", exc.message, file=sys.stderr)
sys.exit(1)
first = True
for score, rid, title, artist in results:
if first:
first = False
else:
commentText += "\n"
commentText += '%s - %s \n' % (artist, title)
#commentText += 'http://musicbrainz.org/recording/%s \n'% rid
#commentText += 'Score: %i%% \n'% (int(score * 100))
return(commentText)
def fingerprint(self):
"""Returns the Acoustid fingerprint"""
if self._fingerprint:
return self._fingerprint
_, self._fingerprint = acoustid.fingerprint_file(self.path)
return self._fingerprint
def from_file(file_name: str):
'''
Construct a Track object from a file.
'''
path = os.path.join(constant.FILE_PREFIX, file_name)
extension = filetype.guess_extension(path)
duration, fingerprint = aid.fingerprint_file(path)
file_hash = hash_file(path)
# Use AcoustID
json_resp = aid.lookup(constant.API_KEY, fingerprint, duration)
matches = aid.parse_lookup_result(json_resp)
try:
# Ignore score and recording_id
_, _, title, artist = next(matches)
except StopIteration:
title = 'Track ' + file_hash[:constant.HASH_LEN]
artist = 'Unknown'
return Track(title,
artist,
duration,
file_hash,
fingerprint,
extension,
path=file_name,
local=True)
def match(string):
API_KEY = 'HMU8Btr6'
#filename1 = 'song.mp3'
dur, fingp = acoustid.fingerprint_file(string)
commentText = ""
try:
#results = acoustid.match(API_KEY, filename)
results1 = acoustid.lookup(API_KEY, fingp, dur)
results = acoustid.parse_lookup_result(results1)
except acoustid.NoBackendError:
print("chromaprint library/tool not found", file=sys.stderr)
sys.exit(1)
except acoustid.FingerprintGenerationError:
print("fingerprint could not be calculated", file=sys.stderr)
sys.exit(1)
except acoustid.WebServiceError as exc:
print("web service request failed:", exc.message, file=sys.stderr)
sys.exit(1)
first = True
for score, rid, title, artist in results:
if first:
first = False
else:
commentText += "\n"
commentText += '%s - %s \n' % (artist, title)
#commentText += 'http://musicbrainz.org/recording/%s \n'% rid
#commentText += 'Score: %i%% \n'% (int(score * 100))
return (commentText)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-length', metavar='SECS', type=int, default=120,
help='length of the audio data used for fingerprint '
'calculation (default 120)')
parser.add_argument('-raw', action='store_true',
help='output the raw uncompressed fingerprint')
parser.add_argument('paths', metavar='FILE', nargs='+',
help='audio file to be fingerprinted')
args = parser.parse_args()
del sys.argv[1:] # to make gst not try to parse the args
first = True
for i, path in enumerate(args.paths):
try:
duration, fp = acoustid.fingerprint_file(path, args.length)
except Exception:
print >>sys.stderr, "ERROR: unable to calculate fingerprint " \
"for file %s, skipping" % path
continue
if args.raw:
raw_fp = chromaprint.decode_fingerprint(fp)[0]
fp = ','.join(map(str, raw_fp))
if not first:
print
first = False
print 'FILE=%s' % path
print 'DURATION=%d' % duration
print 'FINGERPRINT=%s' % fp
def fingerprint_item(log, item, write=False):
"""Get the fingerprint for an Item. If the item already has a
fingerprint, it is not regenerated. If fingerprint generation fails,
return None. If the items are associated with a library, they are
saved to the database. If `write` is set, then the new fingerprints
are also written to files' metadata.
"""
# Get a fingerprint and length for this track.
if not item.length:
log.info(u'{0}: no duration available',
util.displayable_path(item.path))
elif item.acoustid_fingerprint:
if write:
log.info(u'{0}: fingerprint exists, skipping',
util.displayable_path(item.path))
else:
log.info(u'{0}: using existing fingerprint',
util.displayable_path(item.path))
return item.acoustid_fingerprint
else:
log.info(u'{0}: fingerprinting',
util.displayable_path(item.path))
try:
_, fp = acoustid.fingerprint_file(item.path)
item.acoustid_fingerprint = fp
if write:
log.info(u'{0}: writing fingerprint',
util.displayable_path(item.path))
item.try_write()
if item._db:
item.store()
return item.acoustid_fingerprint
except acoustid.FingerprintGenerationError as exc:
log.info(u'fingerprint generation failed: {0}', exc)
def fingerprint_file(filename):
# fp is tuple with (duration, fingerprint)
fp = ai.fingerprint_file(filename)
# get fingerprint for modification
fp_bytes = fp[1]
# pad fingerprint
padlen = (len(fp_bytes) % 4)
if padlen < 1: padlen = 0
padstr = b'=' * padlen
print(('padstr {0} {1} {2}'.format(len(fp_bytes), padlen, padstr)))
fp_bytes += padstr
# decode to list of char
fp_int = base64.b64decode(fp_bytes)
# decode to list of int32s
fb_bin = [list('{:032b}'.format(abs(x))) for x in fp_int]
# allocate array
arr = np.zeros([len(fb_bin), len(fb_bin[0])])
# copy to array
for i in range(arr.shape[0]):
arr[i, 0] = int(fp_int[i] > 0) # The sign is added to the first bit
for j in range(1, arr.shape[1]):
arr[i, j] = float(fb_bin[i][j])
return arr
def fingerprint_item(log, item, write=False):
"""Get the fingerprint for an Item. If the item already has a
fingerprint, it is not regenerated. If fingerprint generation fails,
return None. If the items are associated with a library, they are
saved to the database. If `write` is set, then the new fingerprints
are also written to files' metadata.
"""
# Get a fingerprint and length for this track.
if not item.length:
log.info(u'{0}: no duration available',
util.displayable_path(item.path))
elif item.acoustid_fingerprint:
if write:
log.info(u'{0}: fingerprint exists, skipping',
util.displayable_path(item.path))
else:
log.info(u'{0}: using existing fingerprint',
util.displayable_path(item.path))
return item.acoustid_fingerprint
else:
log.info(u'{0}: fingerprinting',
util.displayable_path(item.path))
try:
_, fp = acoustid.fingerprint_file(item.path)
item.acoustid_fingerprint = fp
if write:
log.info(u'{0}: writing fingerprint',
util.displayable_path(item.path))
item.try_write()
if item._db:
item.store()
return item.acoustid_fingerprint
except acoustid.FingerprintGenerationError as exc:
log.info(u'fingerprint generation failed: {0}', exc)
def analyze(self, anURI):
fileid = FileId(filename=os.path.abspath(anURI))
file_descr = FileDescription(file=fileid)
file_descr.assets = []
asset_descr = AssetDescription(asset=AssetId(
subname=os.path.basename(anURI),
mimetype=mimetypes.guess_type(anURI, False)[0],
file=fileid))
try:
duration, fingerprint = fingerprint_file(anURI)
fingerprint_uuid = uuid.uuid5(uuid.NAMESPACE_DNS,
str(duration) + str(fingerprint))
except Exception as e:
print(('E: AcoustID analyzer failed %s with error %s'
% (anURI, e)))
return False
meta = {
'duration': str(duration) + 's',
'fingerprint': fingerprint,
'fingerprint_uuid': fingerprint_uuid
}
asset_descr.metadata = metadata.MetaDataAcoustID.extract(meta)
file_descr.assets.append(asset_descr)
return file_descr
def generate_fingerprints(this_file_list):
"""generates acoustID fingerprints and set flag 2
"""
import acoustid
for file_entry in this_file_list:
new_file_list[file_entry] = acoustid.fingerprint_file(file_entry)
return new_file_list
def handler(fileName):
global speech, listen
translator = gapi.Translator(speech.lang, 'en-uk')
cfileName = None
try:
engine = pyttsx.init()
cfileName = psw.convert(fileName)
print "processing the file: ", fileName
flag = True
if not listen:
finger_prints = []
finger_print_char = None
for files in os.listdir(os.getcwd() + '/audio'):
finger_print = acoustid.fingerprint_file('audio/' + files)
finger_prints.append(finger_print[0])
finger_print_char = finger_print[1]
print files, finger_print
current_fingerprint = acoustid.fingerprint_file(fileName)
print "now recorded", current_fingerprint
if current_fingerprint[0] > max(finger_prints) or current_fingerprint[0] < min(finger_prints) or current_fingerprint[1] != finger_print_char:
flag = False
if flag:
phrase = speech.getText(cfileName)
if phrase!=None:
phrase = phrase.lower()
if len(phrase.strip())>0:
print 'text:',phrase
# psw.play(speech.getAudio(phrase))
if listen:
listen = False
if "weather" in phrase.lower():
engine.say(get_weather())
engine.runAndWait()
if "ok jarvis" in phrase.lower() or "okay jarvis" in phrase.lower():
if engine.isBusy():
engine.say("yes sir?")
engine.runAndWait()
listen = True
except Exception, e:
import traceback
traceback.print_exc()
print "Unexpected error:", sys.exc_info()[0], e
def getAcoustidFingerprint(self):
if self.fingerprint:
return self.fingerprint
if not self._path:
return None
print(f'Calculating fingerprint of {self._path}')
fp = acoustid.fingerprint_file(self._path)
return fp[1]
def _fingerprint(path, force_fpcalc=False):
"Get the AcoustID fingerprint for an audio track"
duration, fp = fingerprint_file(path, force_fpcalc=force_fpcalc)
duration = timedelta(seconds=duration)
fingerprint, version = decode_fingerprint(fp)
assert version == settings.FINGERPRINT_VERSION, 'Version mismatch: %s' % version
return duration, fingerprint
def acoustid_match(log, path):
"""Gets metadata for a file from Acoustid and populates the
_matches, _fingerprints, and _acoustids dictionaries accordingly.
"""
try:
duration, fp = acoustid.fingerprint_file(util.syspath(path))
except acoustid.FingerprintGenerationError as exc:
log.error('fingerprinting of {0} failed: {1}',
util.displayable_path(repr(path)), exc)
return None
fp = fp.decode()
_fingerprints[path] = fp
try:
res = acoustid.lookup(API_KEY,
fp,
duration,
meta='recordings releases')
except acoustid.AcoustidError as exc:
log.debug('fingerprint matching {0} failed: {1}',
util.displayable_path(repr(path)), exc)
return None
log.debug('chroma: fingerprinted {0}', util.displayable_path(repr(path)))
# Ensure the response is usable and parse it.
if res['status'] != 'ok' or not res.get('results'):
log.debug('no match found')
return None
result = res['results'][0] # Best match.
if result['score'] < SCORE_THRESH:
log.debug('no results above threshold')
return None
_acoustids[path] = result['id']
# Get recording and releases from the result
if not result.get('recordings'):
log.debug('no recordings found')
return None
recording_ids = []
releases = []
for recording in result['recordings']:
recording_ids.append(recording['id'])
if 'releases' in recording:
releases.extend(recording['releases'])
# The releases list is essentially in random order from the Acoustid lookup
# so we optionally sort it using the match.preferred configuration options.
# 'original_year' to sort the earliest first and
# 'countries' to then sort preferred countries first.
country_patterns = config['match']['preferred']['countries'].as_str_seq()
countries = [re.compile(pat, re.I) for pat in country_patterns]
original_year = config['match']['preferred']['original_year']
releases.sort(key=partial(
releases_key, countries=countries, original_year=original_year))
release_ids = [rel['id'] for rel in releases]
log.debug('matched recordings {0} on releases {1}', recording_ids,
release_ids)
_matches[path] = recording_ids, release_ids
def acoustid_match(log, path):
"""Gets metadata for a file from Acoustid and populates the
_matches, _fingerprints, and _acoustids dictionaries accordingly.
"""
try:
duration, fp = acoustid.fingerprint_file(util.syspath(path))
except acoustid.FingerprintGenerationError as exc:
log.error(u'fingerprinting of {0} failed: {1}',
util.displayable_path(repr(path)), exc)
return None
fp = fp.decode()
_fingerprints[path] = fp
try:
res = acoustid.lookup(API_KEY, fp, duration,
meta='recordings releases')
except acoustid.AcoustidError as exc:
log.debug(u'fingerprint matching {0} failed: {1}',
util.displayable_path(repr(path)), exc)
return None
log.debug(u'chroma: fingerprinted {0}',
util.displayable_path(repr(path)))
# Ensure the response is usable and parse it.
if res['status'] != 'ok' or not res.get('results'):
log.debug(u'no match found')
return None
result = res['results'][0] # Best match.
if result['score'] < SCORE_THRESH:
log.debug(u'no results above threshold')
return None
_acoustids[path] = result['id']
# Get recording and releases from the result
if not result.get('recordings'):
log.debug(u'no recordings found')
return None
recording_ids = []
releases = []
for recording in result['recordings']:
recording_ids.append(recording['id'])
if 'releases' in recording:
releases.extend(recording['releases'])
# The releases list is essentially in random order from the Acoustid lookup
# so we optionally sort it using the match.preferred configuration options.
# 'original_year' to sort the earliest first and
# 'countries' to then sort preferred countries first.
country_patterns = config['match']['preferred']['countries'].as_str_seq()
countries = [re.compile(pat, re.I) for pat in country_patterns]
original_year = config['match']['preferred']['original_year']
releases.sort(key=partial(releases_key,
countries=countries,
original_year=original_year))
release_ids = [rel['id'] for rel in releases]
log.debug(u'matched recordings {0} on releases {1}',
recording_ids, release_ids)
_matches[path] = recording_ids, release_ids
def submit_items(userkey, items, chunksize=64):
"""Submit fingerprints for the items to the Acoustid server.
"""
data = [] # The running list of dictionaries to submit.
def submit_chunk():
"""Submit the current accumulated fingerprint data."""
log.info('submitting {0} fingerprints'.format(len(data)))
acoustid.submit(API_KEY, userkey, data)
del data[:]
for item in items:
# Get a fingerprint and length for this track.
if not item.length:
log.info(u'{0}: no duration available'.format(
util.displayable_path(item.path)))
continue
elif item.acoustid_fingerprint:
log.info(u'{0}: using existing fingerprint'.format(
util.displayable_path(item.path)))
fp = item.acoustid_fingerprint
else:
log.info(u'{0}: fingerprinting'.format(
util.displayable_path(item.path)))
try:
_, fp = acoustid.fingerprint_file(item.path)
except acoustid.FingerprintGenerationError as exc:
log.info('fingerprint generation failed: {0}'.format(exc))
continue
# Construct a submission dictionary for this item.
item_data = {
'duration': int(item.length),
'fingerprint': fp,
}
if item.mb_trackid:
item_data['mbid'] = item.mb_trackid
log.debug('submitting MBID')
else:
item_data.update({
'track': item.title,
'artist': item.artist,
'album': item.album,
'albumartist': item.albumartist,
'year': item.year,
'trackno': item.track,
'discno': item.disc,
})
log.debug('submitting textual metadata')
data.append(item_data)
# If we have enough data, submit a chunk.
if len(data) >= chunksize:
submit_chunk()
# Submit remaining data in a final chunk.
if data:
submit_chunk()
def test_fingerprinting_methods(self):
"Verify that fpcalc and acoustid produce identical fingerprints"
duration, fp = fingerprint_file(self.AUDIO_TRACK1, force_fpcalc=True)
fp, version = decode_fingerprint(fp)
self.assertEqual(version, settings.FINGERPRINT_VERSION)
self.assertEqual(int(self.fp1.duration.total_seconds()), duration)
self.assertSequenceEqual(self.fp1.fingerprint, fp)
def submit_items(userkey, items, chunksize=64):
"""Submit fingerprints for the items to the Acoustid server.
"""
data = [] # The running list of dictionaries to submit.
def submit_chunk():
"""Submit the current accumulated fingerprint data."""
log.info('submitting {0} fingerprints'.format(len(data)))
acoustid.submit(API_KEY, userkey, data)
del data[:]
for item in items:
# Get a fingerprint and length for this track.
if not item.length:
log.info(u'{0}: no duration available'.format(
util.displayable_path(item.path)
))
continue
elif item.acoustid_fingerprint:
log.info(u'{0}: using existing fingerprint'.format(
util.displayable_path(item.path)
))
fp = item.acoustid_fingerprint
else:
log.info(u'{0}: fingerprinting'.format(
util.displayable_path(item.path)
))
try:
_, fp = acoustid.fingerprint_file(item.path)
except acoustid.FingerprintGenerationError, exc:
log.info('fingerprint generation failed')
continue
# Construct a submission dictionary for this item.
item_data = {
'duration': int(item.length),
'fingerprint': fp,
}
if item.mb_trackid:
item_data['mbid'] = item.mb_trackid
log.debug('submitting MBID')
else:
item_data.update({
'track': item.title,
'artist': item.artist,
'album': item.album,
'albumartist': item.albumartist,
'year': item.year,
'trackno': item.track,
'discno': item.disc,
})
log.debug('submitting textual metadata')
data.append(item_data)
# If we have enough data, submit a chunk.
if len(data) >= chunksize:
submit_chunk()
def acoustid_match(path):
"""Gets metadata for a file from Acoustid and populates the
_matches, _fingerprints, and _acoustids dictionaries accordingly.
"""
try:
duration, fp = acoustid.fingerprint_file(path)
except acoustid.FingerprintGenerationError, exc:
log.error('fingerprinting of %s failed: %s' %
(repr(path), str(exc)))
return None
def generate_fingerprint(fname: str) -> List[int]:
"""return an audio fingerprint for a video file.
"""
audioclip = AudioFileClip(fname)
audioclip.write_audiofile("temp.wav")
duration, fp_encoded = acoustid.fingerprint_file("temp.wav")
fingerprint, version = decode_fingerprint(fp_encoded)
os.remove("temp.wav")
return fingerprint
def retrieve(song_path):
'''
Takes a song file at <song_path>
Returns a tuple (artist, title, date) obtained through AcoustID API
'''
# Forming the URL for the request on acoustid API
url = 'https://api.acoustid.org/v2/lookup'
duration, fingerprint = fingerprint_file(song_path)
duration, fingerprint = int(float(duration)), fingerprint.decode()
url += '?client={0}&meta={1}&duration={2}&fingerprint={3}'.format(
APIKEY, 'recordings+releases', duration, fingerprint)
answer = post(url)
if answer.status_code != codes.ok:
answer.raise_for_status()
data = answer.json()
titles, artists, dates = [], [], []
# Filling theses 3 tabs
for item in data['results']:
if 'recordings' in item:
for subitem in item['recordings']:
if 'title' in subitem:
titles.append(subitem['title'])
if 'artists' in subitem:
artists.append(subitem['artists'])
if 'releases' in subitem:
for subsubitem in subitem['releases']:
if 'date' in subsubitem:
dates.append(subsubitem['date']['year'])
#if 'artists' in subitem:
# artists.append(subsubitem['artists'])
artists = [artist for arr in artists for artist in arr]
artists = [artist['name'] for artist in artists]
# Extracting the artist, title and date
max_count = max([dates.count(date) for date in dates])
date = None
for dte in dates:
if dates.count(dte) == max_count:
if (date == None):
date = dte
elif (dte < date):
date = dte
max_count = max([artists.count(artist) for artist in artists])
artist = None
for artst in artists:
if artists.count(artst) == max_count:
artist = artst
break
max_count = max([titles.count(title) for title in titles])
title = None
for ttle in titles:
if titles.count(ttle) == max_count:
title = ttle
break
return artist, title, date
def _acoustid_tag_file(self, filepath):
"""
Gets metadata for a file from Acoustid.
returns a Result object with Fingerprint, acoustid, recording_ids and release_ids
Suppresses all exceptions - will return None if failed
"""
path = Path(filepath)
try:
duration, fingerprint = acoustid.fingerprint_file(str(path))
except acoustid.FingerprintGenerationError as exc:
logger.error('fingerprinting of {0} failed: {1}', filepath, exc)
return None
try:
res = acoustid.lookup(self.api_key,
fingerprint,
duration,
meta='recordings releases')
except acoustid.AcoustidError as exc:
logger.debug('fingerprint matching {0} failed: {1}', filepath, exc)
return None
logger.debug('fingerprinted {0}', filepath)
# Ensure the response is usable and parse it.
if res['status'] != 'ok' or not res.get('results'):
logger.debug('no match found')
return None
acoustid_result = res['results'][0] # Best match.
if acoustid_result['score'] < self.SCORE_THRESH:
logger.debug('no results above threshold')
return None
# Get recording and releases from the result.
if not acoustid_result.get('recordings'):
logger.debug('no recordings found')
return None
recording_ids = []
release_ids = []
for recording in acoustid_result['recordings']:
recording_ids.append(recording['id'])
if 'releases' in recording:
release_ids += [rel['id'] for rel in recording['releases']]
logger.debug('matched recordings {0} on releases {1}', recording_ids,
release_ids)
return AcoustIDTaggerResult(fingerprint, acoustid_result['id'],
recording_ids, release_ids)
def fingerprint_func(self): fingerprint = acoustid.fingerprint_file(self.path) self.line = fingerprint self.line = str(self.line) self.line_word = "" self.after_word = "')" self.before_word = ", '" self.num = 1 self.lines_func() self.duration_func()
def crossSim(path1, path2):
i = 0
maxSim = 0
maxIndex = 0
fPrints1 = []
fPrints2 = []
indexMaps = []
for file in listdir(path1):
fpEncode = acoustid.fingerprint_file(file)
fPrints1.append(fpEncode)
for file in listdir(path2):
fpEncode = acoustid.fingerprint_file(file)
fPrints2.append(fpEncode)
for i in fPrints2:
for n in fPrints1:
similarity = fuzz.ratio(fPrints2[i], fPrints2[n])
if similarity > maxSim:
maxIndex = n
indexMaps.append(maxIndex)
print(indexMaps)
def process_file( file_name, dict ) :
""" process a file, given file_name and write the results to out_file."""
(duration, fingerprint) = acoustid.fingerprint_file(file_name)
try :
dict[fingerprint].append(file_name)
except KeyError :
dict[fingerprint] = list()
dict[fingerprint].append(file_name)
global file_count
file_count += 1
def run():
# TODO: break this into smaller functions
LOGGER.info('Running music downloader...')
tracks_to_download = get_tracks_to_download()
if not tracks_to_download:
LOGGER.info('No queued tracks found in database')
return
LOGGER.info('Found {} tracks from database to download...'.format(len(tracks_to_download)))
options = {
'format': 'bestaudio/best',
'postprocessors': [{
'key': 'FFmpegExtractAudio',
'preferredcodec': 'mp3',
'preferredquality': '192',
}],
'quiet': False}
for queued_track in tracks_to_download:
exists = session.query(SavedTrack).filter(SavedTrack.artist == queued_track.artist,
SavedTrack.title == queued_track.title).count() > 0
if exists:
LOGGER.info('Track already exists as Saved Track, deleting Queued track and skipping download.')
session.delete(queued_track)
session.commit()
continue
track_save_name = u'{} - {}'.format(queued_track.artist, queued_track.title)
final_track_path = TRACK_DIRECTORY + track_save_name + '.mp3'
holding_track_path = HOLD_DIRECTORY + track_save_name + '.mp3'
LOGGER.info('Downloading track: {}'.format(track_save_name))
options['outtmpl'] = u'{}/{}.%(ext)s'.format(HOLD_DIRECTORY, track_save_name)
ydl = youtube_dl.YoutubeDL(options)
download_link = build_download_link(queued_track.youtube_video_id)
# download the track
try:
ydl.download([download_link])
except youtube_dl.utils.DownloadError as e:
LOGGER.warning('youtube-dl encountered an error: {}' .format(e.message))
continue
saved_track = SavedTrack()
saved_track.update_from_dict(queued_track.as_dict())
saved_track.path = final_track_path
saved_track.md5 = calculate_md5(holding_track_path)
fingerprint_duration = fingerprint_file(holding_track_path, 30)
saved_track.fingerprint = fingerprint_duration[1]
saved_track.duration = fingerprint_duration[0]
session.merge(saved_track)
session.delete(queued_track)
session.commit()
os.rename(holding_track_path, final_track_path)
LOGGER.info('Complete. Downloaded track data committed to database.')
def mainFunc():
print("")
print("simpleMusicMatcher v0.1")
# Do scan
print("")
print("Beginning library scan...")
for root, dirs, files in os.walk(DATA_PATH, topdown=False):
for fname in files:
name, ext = os.path.splitext(fname)
ext = ext.lower()
print("")
if ext == ".mp3": # We only check for mp3s. Could work for anything supported by AcoustID.
fpath = os.path.join(root, fname)
#print(fpath)
#Check if it already exists in the DB
if exists_in_DB(fpath):
print("File already scanned. Skipping...")
else:
print("Found " + fpath)
duration, chroma = acoustid.fingerprint_file(fpath)
writeEntry(fname, fpath, chroma)
# Cross-reference all fingerprints
print("")
print("Beginnning fingerprint cross-reference...")
all_items = query_db(
'select id, fingerprint from audiofingerprints order by id asc')
item_count = len(all_items)
for i in range(item_count):
for j in range(i + 1, item_count):
#print(all_items[i])
#print(all_items[i]['fingerprint'])
if (all_items[i]['fingerprint'] == all_items[j]['fingerprint']):
print("")
print("MATCH!")
tmpval1 = query_db(
'select full_path from audiofingerprints where id=?',
[all_items[i]['id']])[0]
tmpval2 = query_db(
'select full_path from audiofingerprints where id=?',
[all_items[j]['id']])[0]
print(tmpval1['full_path'])
print(tmpval2['full_path'])
def _acoustid_tag_file(self, filepath):
"""
Gets metadata for a file from Acoustid.
returns a Result object with Fingerprint, acoustid, recording_ids and release_ids
Suppresses all exceptions - will return None if failed
"""
path = Path(filepath)
try:
duration, fingerprint = acoustid.fingerprint_file(str(path))
except acoustid.FingerprintGenerationError as exc:
logger.error('fingerprinting of {0} failed: {1}', filepath, exc)
return None
try:
res = acoustid.lookup(self.api_key, fingerprint, duration, meta='recordings releases')
except acoustid.AcoustidError as exc:
logger.debug('fingerprint matching {0} failed: {1}', filepath, exc)
return None
logger.debug('fingerprinted {0}', filepath)
# Ensure the response is usable and parse it.
if res['status'] != 'ok' or not res.get('results'):
logger.debug('no match found')
return None
acoustid_result = res['results'][0] # Best match.
if acoustid_result['score'] < self.SCORE_THRESH:
logger.debug('no results above threshold')
return None
# Get recording and releases from the result.
if not acoustid_result.get('recordings'):
logger.debug('no recordings found')
return None
recording_ids = []
release_ids = []
for recording in acoustid_result['recordings']:
recording_ids.append(recording['id'])
if 'releases' in recording:
release_ids += [rel['id'] for rel in recording['releases']]
logger.debug('matched recordings {0} on releases {1}', recording_ids, release_ids)
return AcoustIDTaggerResult(fingerprint, acoustid_result['id'], recording_ids, release_ids)
def handler(fileName):
global speech, listen
cfileName = None
try:
engine = pyttsx.init()
cfileName = psw.convert(fileName)
print "processing the file: ", fileName
flag = True
if not listen:
with open('jarvis_fingerprints_samples', 'r') as f:
fingerprints_json = json.loads("".join(f.readlines())).get("data")
finger_prints = fingerprints_json.get("vals")
finger_print_char = fingerprints_json.get("char")
current_fingerprint = acoustid.fingerprint_file(fileName)
print "now recorded", current_fingerprint
if current_fingerprint[0] > max(finger_prints) or current_fingerprint[0] < min(finger_prints) or current_fingerprint[1] != finger_print_char:
flag = False
if flag:
phrase = speech.getText(cfileName)
if phrase!=None:
phrase = phrase.lower()
if len(phrase.strip())>0:
print 'text:', phrase
if listen:
listen = False
# commands.execute(phrase, speech)
if "weather" in phrase.lower():
engine.say(get_weather())
engine.runAndWait()
if "jarvis" in phrase.lower():
print "got in"
print engine.isBusy()
if engine.isBusy():
engine.say("yes sir?")
engine.runAndWait()
listen = True
except Exception, e:
import traceback
traceback.print_exc()
listen = False
print "Unexpected error:", sys.exc_info()[0], e
engine.say("I didn't catch that, sir.")
engine.runAndWait()
def acoustid_match(log, path):
"""Gets metadata for a file from Acoustid and populates the
_matches, _fingerprints, and _acoustids dictionaries accordingly.
"""
try:
duration, fp = acoustid.fingerprint_file(util.syspath(path))
except acoustid.FingerprintGenerationError as exc:
log.error(u'fingerprinting of {0} failed: {1}',
util.displayable_path(repr(path)), exc)
return None
_fingerprints[path] = fp
try:
res = acoustid.lookup(API_KEY,
fp,
duration,
meta='recordings releases')
except acoustid.AcoustidError as exc:
log.debug(u'fingerprint matching {0} failed: {1}',
util.displayable_path(repr(path)), exc)
return None
log.debug(u'chroma: fingerprinted {0}', util.displayable_path(repr(path)))
# Ensure the response is usable and parse it.
if res['status'] != 'ok' or not res.get('results'):
log.debug(u'no match found')
return None
result = res['results'][0] # Best match.
if result['score'] < SCORE_THRESH:
log.debug(u'no results above threshold')
return None
_acoustids[path] = result['id']
# Get recording and releases from the result.
if not result.get('recordings'):
log.debug(u'no recordings found')
return None
recording_ids = []
release_ids = []
for recording in result['recordings']:
recording_ids.append(recording['id'])
if 'releases' in recording:
release_ids += [rel['id'] for rel in recording['releases']]
log.debug(u'matched recordings {0} on releases {1}', recording_ids,
release_ids)
_matches[path] = recording_ids, release_ids
def acoustid_match(log, path):
"""Gets metadata for a file from Acoustid and populates the
_matches, _fingerprints, and _acoustids dictionaries accordingly.
"""
try:
duration, fp = acoustid.fingerprint_file(util.syspath(path))
except acoustid.FingerprintGenerationError as exc:
log.error(u'fingerprinting of {0} failed: {1}',
util.displayable_path(repr(path)), exc)
return None
_fingerprints[path] = fp
try:
res = acoustid.lookup(API_KEY, fp, duration,
meta='recordings releases')
except acoustid.AcoustidError as exc:
log.debug(u'fingerprint matching {0} failed: {1}',
util.displayable_path(repr(path)), exc)
return None
log.debug(u'chroma: fingerprinted {0}',
util.displayable_path(repr(path)))
# Ensure the response is usable and parse it.
if res['status'] != 'ok' or not res.get('results'):
log.debug(u'no match found')
return None
result = res['results'][0] # Best match.
if result['score'] < SCORE_THRESH:
log.debug(u'no results above threshold')
return None
_acoustids[path] = result['id']
# Get recording and releases from the result.
if not result.get('recordings'):
log.debug(u'no recordings found')
return None
recording_ids = []
release_ids = []
for recording in result['recordings']:
recording_ids.append(recording['id'])
if 'releases' in recording:
release_ids += [rel['id'] for rel in recording['releases']]
log.debug(u'matched recordings {0} on releases {1}',
recording_ids, release_ids)
_matches[path] = recording_ids, release_ids
def geraFingerprint(localMp3):
try:
#calculador = md5()
#with open(localMp3, "rb") as arqMp3:
# # for parte in iter(partial(arqMp3.read, 4096), b''):
# while True:
# parte = arqMp3.read(4096)
# if not parte: break
#
# calculador.update(parte)
#
#return calculador.hexdigest()
arqTempoFingerprint = fingerprint_file(localMp3)
return arqTempoFingerprint
except IOError:
print("ERRO ao abrir arquivo:", localMp3)
raise IOError
def __addsongtodb(cls, filename):
'''__addsongtodb'''
logging.info("Adding song to DB " + filename)
full_path_filename = cls.__inpath("normalized", filename)
fingerprint = acoustid.fingerprint_file(full_path_filename)
pickled = pickle.dumps(fingerprint)
con = sqlite.connect(cls.__dbfile)
cursor = con.cursor()
try:
cursor.execute(
'INSERT INTO ' + 'Songs("Input File Name", AcoustID) ' +
'VALUES(?, ?)'
'', (
filename,
pickled,
))
con.commit()
except Exception:
logging.info(filename + " already present")
def acoustid_match(path):
"""Gets metadata for a file from Acoustid and populates the
_matches, _fingerprints, and _acoustids dictionaries accordingly.
"""
try:
duration, fp = acoustid.fingerprint_file(path)
except acoustid.FingerprintGenerationError as exc:
log.error('fingerprinting of %s failed: %s' %
(repr(path), str(exc)))
return None
_fingerprints[path] = fp
try:
res = acoustid.lookup(API_KEY, fp, duration,
meta='recordings releases')
except acoustid.AcoustidError as exc:
log.debug('fingerprint matching %s failed: %s' %
(repr(path), str(exc)))
return None
log.debug('chroma: fingerprinted %s' % repr(path))
# Ensure the response is usable and parse it.
if res['status'] != 'ok' or not res.get('results'):
log.debug('chroma: no match found')
return None
result = res['results'][0]
if result['score'] < SCORE_THRESH:
log.debug('chroma: no results above threshold')
return None
_acoustids[path] = result['id']
# Get recordings from the result.
if not result.get('recordings'):
log.debug('chroma: no recordings found')
return None
recording = result['recordings'][0]
recording_id = recording['id']
if 'releases' in recording:
release_ids = [rel['id'] for rel in recording['releases']]
else:
release_ids = []
log.debug('chroma: matched recording {0}'.format(recording_id))
_matches[path] = recording_id, release_ids
def process_song(artist, artist_path, albums_path, song_filename):
song_path = os.path.join(artist_path, albums_path, song_filename)
song_title = song_filename[:song_filename.rfind('.')]
song_format = song_filename[song_filename.rfind('.') + 1:]
print("Processing " + artist + ' - ' + song_filename)
has_cover_art_process = has_cover_art_async(song_path)
duration, fingerprint = acoustid.fingerprint_file(song_path)
ffprobe_out, err = has_cover_art_process.communicate()
ffprobe_out = ffprobe_out.decode()
has_cover_art = 'DISPOSITION:attached_pic=1' in ffprobe_out
bitrate = find_bitrate_in_ffprobe_output(ffprobe_out)
freq_cutoff = find_song_cutoff_frequency(song_path)
results_queue.put([
artist, albums_path, song_title, song_format,
int(duration), bitrate, freq_cutoff, has_cover_art, fingerprint
])
def id(self, track): try: dur, fp = acoustid.fingerprint_file(track.file) response = acoustid.parse_lookup_result(acoustid.lookup(API_KEY,fp,dur,'recordings')) response = response.next() releases = self.search((response[2],response[3],dur*1000)) track.title = response[2] artist = self.library.addArtist(response[3]) track.artist = artist albums = [] for album in releases: x = artist.addAlbum(album) albums.append(x) track.album = albums except EOFError: track.title = 'ERROR' except StopIteration: track.title = 'ERROR'
def fingerprint_item(item, lib=None, write=False):
"""Get the fingerprint for an Item. If the item already has a
fingerprint, it is not regenerated. If fingerprint generation fails,
return None. If `lib` is provided, then new fingerprints are saved
to the database. If `write` is set, then the new fingerprints are
also written to files' metadata.
"""
# Get a fingerprint and length for this track.
if not item.length:
log.info(u'{0}: no duration available'.format(
util.displayable_path(item.path)
))
elif item.acoustid_fingerprint:
if write:
log.info(u'{0}: fingerprint exists, skipping'.format(
util.displayable_path(item.path)
))
else:
log.info(u'{0}: using existing fingerprint'.format(
util.displayable_path(item.path)
))
return item.acoustid_fingerprint
else:
log.info(u'{0}: fingerprinting'.format(
util.displayable_path(item.path)
))
try:
_, fp = acoustid.fingerprint_file(item.path)
item.acoustid_fingerprint = fp
if write:
log.info(u'{0}: writing fingerprint'.format(
util.displayable_path(item.path)
))
item.write()
if lib:
lib.store(item)
return item.acoustid_fingerprint
except acoustid.FingerprintGenerationError as exc:
log.info(
'fingerprint generation failed: {0}'.format(exc)
)
def recursive_walk(self, path):
for directory in os.listdir(path):
if os.path.isdir(path + '\\' + directory):
self.populate_db(path + '\\' + directory)
for file in os.listdir(path):
if not os.path.isdir(path + '\\' + file) and file.endswith(self._extentions):
duration, fingerprint = acoustid.fingerprint_file(path + '\\' + file)
temp_data_dict = {
'fingerprint': fingerprint,
'path': path + '\\' + file,
'file_size': os.path.getsize(path + '\\' + file)
}
with db.atomic():
try:
Track.create(**temp_data_dict)
except IntegrityError:
duplicate_track = Track.select().where(Track.fingerprint==fingerprint).get()
if duplicate_track.file_size < os.path.getsize(path+'\\'+file):
duplicate_track.delete_instance()
else:
pass
def fingerprint_func(self):
"""
Fingerprint retrieval Method
- Strips the audio fingerprint out of the acoustid.fingerprint API
- Executes the lines_func and duration_func methods
"""
fingerprint = acoustid.fingerprint_file(self.path)
self.line = fingerprint
self.line = str(self.line)
self.line_word = ""
self.after_word = "')"
self.before_word = ", '"
self.num = 1
self.lines_func()
self.duration_func()
def fingerprint_func(self): """ Fingerprint retrieval Method - Strips the audio fingerprint out of the acoustid.fingerprint API - Executes the lines_func and duration_func methods """ fingerprint = acoustid.fingerprint_file(self.path) self.line = fingerprint self.line = str(self.line) self.line_word = "" self.after_word = "')" self.before_word = ", '" self.num = 1 self.lines_func() self.duration_func()
def acoustid_match(log, path):
"""Gets metadata for a file from Acoustid and populates the
_matches, _fingerprints, and _acoustids dictionaries accordingly.
"""
try:
duration, fp = acoustid.fingerprint_file(util.syspath(path))
except acoustid.FingerprintGenerationError as exc:
log.error(u"fingerprinting of {0} failed: {1}", util.displayable_path(repr(path)), exc)
return None
_fingerprints[path] = fp
try:
res = acoustid.lookup(API_KEY, fp, duration, meta="recordings releases")
except acoustid.AcoustidError as exc:
log.debug(u"fingerprint matching {0} failed: {1}", util.displayable_path(repr(path)), exc)
return None
log.debug(u"chroma: fingerprinted {0}", util.displayable_path(repr(path)))
# Ensure the response is usable and parse it.
if res["status"] != "ok" or not res.get("results"):
log.debug(u"no match found")
return None
result = res["results"][0] # Best match.
if result["score"] < SCORE_THRESH:
log.debug(u"no results above threshold")
return None
_acoustids[path] = result["id"]
# Get recording and releases from the result.
if not result.get("recordings"):
log.debug(u"no recordings found")
return None
recording_ids = []
release_ids = []
for recording in result["recordings"]:
recording_ids.append(recording["id"])
if "releases" in recording:
release_ids += [rel["id"] for rel in recording["releases"]]
log.debug(u"matched recordings {0} on releases {1}", recording_ids, release_ids)
_matches[path] = recording_ids, release_ids
def returnMatch(id=None):
file = mockDB[id]["title"]
filename = "./pyacoustid-1.1.5/" + file
duration, fingerprint = acoustid.fingerprint_file(filename)
try:
results = list(acoustid.match(API_KEY, filename))
except acoustid.NoBackendError:
print("chromaprint library/tool not found")
sys.exit(1)
except acoustid.FingerprintGenerationError:
print("fingerprint could not be calculated")
sys.exit(1)
except acoustid.WebServiceError as exc:
print("web service request failed:", exc.message)
sys.exit(1)
if len(results) > 0:
resp = make_response(json.dumps(results), 200)
resp.headers['mimetype'] = 'application/json'
# check if there's a payment pointer in our db for this ID. If so then this is verified.
print("match", results)
return resp
else:
# Submit fingerprint to database.
data = {
'fingerprint': fingerprint,
'duration': int(duration),
'title': basename(filename)
}
print("DATA", data)
# check if license is there. If so then return license, but note this is NOT verified since it is not in MusicBrainz database.
try:
result = acoustid.submit(API_KEY, USER_KEY, data)
except acoustid.FingerprintGenerationError:
print("fingerprint could not be calculated")
sys.exit(1)
except acoustid.WebServiceError as exc:
print("web service request failed:", exc.message)
sys.exit(1)
return "success!"
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-length',
metavar='SECS',
type=int,
default=120,
help='length of the audio data used for fingerprint '
'calculation (default 120)')
parser.add_argument('-raw',
action='store_true',
help='output the raw uncompressed fingerprint')
parser.add_argument('paths',
metavar='FILE',
nargs='+',
help='audio file to be fingerprinted')
args = parser.parse_args()
# make gst not try to parse the args
del sys.argv[1:]
first = True
for i, path in enumerate(args.paths):
try:
duration, fp = acoustid.fingerprint_file(path, args.length)
except Exception:
print("ERROR: unable to calculate fingerprint "
"for file %s, skipping" % path,
file=sys.stderr)
continue
if args.raw:
raw_fp = chromaprint.decode_fingerprint(fp)[0]
fp = ','.join(map(str, raw_fp))
if not first:
print
first = False
print('FILE=%s' % path)
print('DURATION=%d' % duration)
print('FINGERPRINT=%s' % fp.decode('utf8'))
urlpath = path.replace("%", "%25")
urlpath = urlpath.replace("#", "%23")
urlpath = urlpath.replace("ABCDEFG (2010)", "ABCDEFG%20(2010)") # One particular album by Chumbawumba needs its space url encoded. Unsure why - no other tracks in the DB have spaces encodes
trackurl = mediaprefix + urlpath
filemetadata = taglib.File(path)
tags = {}
for key, values in filemetadata.tags.items():
if len(values) < 1:
continue
key = key.lower()
value = " & ".join(values)
if key not in ["title", "album", "artist", "year", "genre", "comment", "lyrics"]:
continue
tags[key] = value
duration, fingerprint = acoustid.fingerprint_file(path, maxlength=60)
if fingerprint.decode('UTF-8') in ["AQAAAA", "AQAAAQkz9UsCAQ"]:
log("Skipping empty track " + trackurl, debug=True)
continue
if duration < 1:
log("Track with duration less than 1 second " + trackurl, error=True)
errorCount += 1
continue
trackdata = {
"fingerprint": fingerprint.decode('UTF-8'),
"duration": int(duration),
"tags": tags,
}
log(trackurl + ", " + str(trackdata), debug=True)
trackresult = requests.put(apiurl+"/tracks", params={"url": trackurl}, data=json.dumps(trackdata), allow_redirects=False, headers={"If-None-Match": "*"})
if trackresult.ok:
decode_command = ['flac', '--decode', '-f', filename, '-o', wavefile]
elif filename.endswith('.ogg'):
file_metadata = OggVorbis(filename)
decode_command = ['oggdec', filename, '-o', wavefile]
elif filename.endswith('.mp3'):
file_metadata = EasyID3(filename)
decode_command = ['lame', '--decode', filename, wavefile]
else:
print "Don't know to handle this file"
continue
print 'Looking up track on AcoustID/MusicBrainz'
print '--------------------------------------------------------------------------------'
# TODO: max 3 requests/sec to AcoustID/MusicBrainz, just sleeping a sec for the time being
time.sleep(1)
acoustid_duration, acoustid_fingerprint = acoustid.fingerprint_file(filename) # TODO: use fingerprint & duration to check for duplicates in database? seems like matching fingerprints is not trivial
acoustid_result = acoustid.parse_lookup_result(acoustid.lookup(acoustid_key, acoustid_fingerprint, acoustid_duration))
mb_metadata = []
for result in acoustid_result:
track = mb.getTrackById(result[1], TrackIncludes(artist=True, releases=True)) # TODO: needs to be limited, what if we get 20 results from acoustid?
releases = []
for release in track.getReleases():
releases.append({
'name': release.getTitle(),
'tracknum': release.getTracksOffset() + 1,
'musicbrainz_release_id': release.getId()[release.getId().rfind('/') + 1:]
})
mb_metadata.append({
'artist': track.getArtist().getName(),
'title': track.getTitle(),
'releases': releases,
def query_fingerprint(self):
self.duration, self.fingerprint = acoustid.fingerprint_file(self.path, 30)
# -*- coding: utf-8 -*-
__author__ = 'Glebov Boris'
import acoustid
import chromaprint
if __name__ == '__main__':
duration, fp = acoustid.fingerprint_file('/home/warlock/Music/л1.mp3', 120)
raw_fp = chromaprint.decode_fingerprint('')[0]
fp = ','.join(map(str, raw_fp))
print 'DURATION=%d' % duration
print 'FINGERPRINT=%s' % fp
def find_media(self, session, library):
if not os.path.isdir(library.path):
log.warning("Unable to find directory: '%s'", library.path)
return
for root, dirs, files in os.walk(library.path):
if files:
log.info("This is most likely an album: '%s'", root)
items = [os.path.join(root, f) for f in files]
media_files = []
for item in items:
if any(item.lower().endswith('.' + x.lower()) for x in MEDIA_FORMATS):
song_path = os.path.join(root, item)
try:
media_files.append(MediaFile(song_path))
except (FileTypeError, UnreadableFileError):
log.warning("Unable to read media file '%s'", song_path)
except IOError:
log.warning("Unable to read media file '%s'", song_path)
if media_files:
media_files = self.set_common_album(media_files)
# album_metadata = self.album_metadata(media_files)
for media_file in media_files:
media_dict = {
'artist': None,
'album': None,
'title': None,
'track': None,
}
duration, fingerprint = acoustid.fingerprint_file(media_file.path)
# m.format = MP3
# m.type = mp3
missing_metadata = False
# TODO: Make this all into a nice dictionary
# Set the artist
if media_file.albumartist:
media_dict['artist'] = media_file.albumartist
elif media_file.artist:
media_dict['artist'] = media_file.artist
else:
missing_metadata = True
# Set the album
if media_file.album:
media_dict['album'] = media_file.album
else:
media_dict['album'] = 'Unknown'
missing_metadata = True
# Set track information
if media_file.title:
media_dict['title'] = media_file.title
else:
missing_metadata = True
if media_file.track:
media_dict['track'] = media_file.track
else:
missing_metadata = True
if missing_metadata:
metadata = utils.metadata_from_filename(media_file.path)
if not media_dict['track']:
media_dict['track'] = metadata.get('track', 0)
if not media_dict['artist']:
media_dict['artist'] = metadata.get('artist', 'Unknown')
if not media_dict['title']:
media_dict['title'] = metadata.get('title', 'Unknown')
song = get_or_create(session, Song, path=os.path.dirname(media_file.path), filename=os.path.split(media_file.path)[1])
song.album = media_dict['album']
song.artist = media_dict['artist']
song.title = media_dict['title']
song.track = media_dict['track']
song.content_type = CONTENT_TYPES.get(media_file.type, 'mp3')
song.length = media_file.length
song.fingerprint = fingerprint
from __future__ import print_function
import json
import wget
import acoustid
import sys
import youtube_dl
API_KEY = 'HMU8Btr6'
filename1 = 'song.mp3'
dur,fingp = acoustid.fingerprint_file(filename1)
def aidmatch(filename):
try:
#results = acoustid.match(API_KEY, filename)
results1 = acoustid.lookup(API_KEY, fingp, dur)
results = acoustid.parse_lookup_result(results1)
except acoustid.NoBackendError:
print("chromaprint library/tool not found", file=sys.stderr)
sys.exit(1)
except acoustid.FingerprintGenerationError:
print("fingerprint could not be calculated", file=sys.stderr)
sys.exit(1)
except acoustid.WebServiceError as exc:
print("web service request failed:", exc.message, file=sys.stderr)
sys.exit(1)
first = True
for score, rid, title, artist in results:
if first:
first = False
def find_media(self, library):
if not os.path.isdir(library.path):
log.warning("Unable to find directory: '%s'", library.path)
return
for root, dirs, files in os.walk(library.path):
if files:
log.info("This is most likely an album: '%s'", root)
items = [os.path.join(root, f) for f in files]
media_files = []
for item in items:
if any(item.lower().endswith("." + x.lower()) for x in MEDIA_FORMATS):
song_path = os.path.join(root, item)
try:
media_files.append(MediaFile(song_path))
except (FileTypeError, UnreadableFileError):
log.warning("Unable to read media file '%s'", song_path)
except IOError:
log.warning("Unable to read media file '%s'", song_path)
if media_files:
media_files = self.set_common_album(media_files)
# album_metadata = self.album_metadata(media_files)
for media_file in media_files:
media_dict = {"artist": None, "album": None, "title": None, "track": None}
# TODO: This should be a celery job
duration, fingerprint = acoustid.fingerprint_file(media_file.path)
# m.format = MP3
# m.type = mp3
missing_metadata = False
# TODO: Make this all into a nice dictionary
# Set the artist
if media_file.albumartist:
media_dict["artist"] = media_file.albumartist
elif media_file.artist:
media_dict["artist"] = media_file.artist
else:
missing_metadata = True
# Set the album
if media_file.album:
media_dict["album"] = media_file.album
else:
media_dict["album"] = "Unknown"
missing_metadata = True
# Set track information
if media_file.title:
media_dict["title"] = media_file.title
else:
missing_metadata = True
if media_file.track:
media_dict["track"] = media_file.track
else:
missing_metadata = True
if missing_metadata:
metadata = utils.metadata_from_filename(media_file.path)
if not media_dict["track"]:
media_dict["track"] = metadata.get("track", 0)
if not media_dict["artist"]:
media_dict["artist"] = metadata.get("artist", "Unknown")
if not media_dict["title"]:
media_dict["title"] = metadata.get("title", "Unknown")
artist, artist_created = Artist.objects.get_or_create(name=media_dict["artist"])
# TODO: Should only need to do this once per folder/album
album, album_created = Album.objects.get_or_create(artist=artist, title=media_dict["album"])
song, song_created = Song.objects.get_or_create(
path=os.path.dirname(media_file.path),
filename=os.path.split(media_file.path)[1],
defaults={
"album": album,
"artist": artist,
"title": media_dict["title"],
"track": media_dict["track"],
"content_type": CONTENT_TYPES.get(media_file.type, "mp3"),
"length": media_file.length,
"fingerprint": fingerprint,
},
)
library.songs.add(song)
def getAcoustidFingerprint(self):
fp = acoustid.fingerprint_file(self._path)
return fp[1]
