def testGetRecording(self):
musicbrainzngs.get_recording_by_id("93468a09-9662-4886-a227-56a2ad1c5246")
self.assertEqual("http://musicbrainz.org/ws/2/recording/93468a09-9662-4886-a227-56a2ad1c5246", self.opener.get_url())
# one include
musicbrainzngs.get_recording_by_id("93468a09-9662-4886-a227-56a2ad1c5246", includes=["artists"])
self.assertEqual("http://musicbrainz.org/ws/2/recording/93468a09-9662-4886-a227-56a2ad1c5246?inc=artists", self.opener.get_url())
def testGetRecording(self):
musicbrainzngs.get_recording_by_id("93468a09-9662-4886-a227-56a2ad1c5246")
self.assertEqual("http://musicbrainz.org/ws/2/recording/93468a09-9662-4886-a227-56a2ad1c5246", self.opener.get_url())
# one include
musicbrainzngs.get_recording_by_id("93468a09-9662-4886-a227-56a2ad1c5246", includes=["artists"])
self.assertEqual("http://musicbrainz.org/ws/2/recording/93468a09-9662-4886-a227-56a2ad1c5246?inc=artists", self.opener.get_url())
def _recurse_relations(self, mb_track_id, oldest_release, relation_type):
x = musicbrainzngs.get_recording_by_id(
mb_track_id,
includes=['releases', 'recording-rels'])
if 'recording-relation-list' in x['recording'].keys():
# recurse down into edits and remasters.
# Note remasters are deprecated in musicbrainz, but some entries
# may still exist.
for subrecording in x['recording']['recording-relation-list']:
if ('direction' in subrecording.keys() and
subrecording['direction'] == 'backward'):
continue
(oldest_release, relation_type) = self._recurse_relations(
subrecording['target'],
oldest_release,
subrecording['type'])
for release in x['recording']['release-list']:
if 'date' not in release.keys():
# A release without a date. Skip over it.
continue
release_date = self._make_date_values(release['date'])
if (oldest_release['year'] is None or
oldest_release['year'] > release_date['year']):
oldest_release = release_date
elif oldest_release['year'] == release_date['year']:
if ('month' in release_date.keys() and
'month' in oldest_release.keys() and
oldest_release['month'] > release_date['month']):
oldest_release = release_date
return (oldest_release, relation_type)
def _recurse_relations(self, mb_track_id, oldest_release, relation_type):
x = musicbrainzngs.get_recording_by_id(
mb_track_id, includes=['releases', 'recording-rels'])
if 'recording-relation-list' in x['recording'].keys():
# recurse down into edits and remasters.
# Note remasters are deprecated in musicbrainz, but some entries
# may still exist.
for subrecording in x['recording']['recording-relation-list']:
if ('direction' in subrecording.keys()
and subrecording['direction'] == 'backward'):
continue
(oldest_release, relation_type) = self._recurse_relations(
subrecording['target'], oldest_release,
subrecording['type'])
for release in x['recording']['release-list']:
if 'date' not in release.keys():
# A release without a date. Skip over it.
continue
release_date = self._make_date_values(release['date'])
if (oldest_release['year'] is None
or oldest_release['year'] > release_date['year']):
oldest_release = release_date
elif oldest_release['year'] == release_date['year']:
if ('month' in release_date.keys()
and 'month' in oldest_release.keys()
and oldest_release['month'] > release_date['month']):
oldest_release = release_date
return (oldest_release, relation_type)
def load_recording(url: str) -> MbRecording:
prefix = 'https://musicbrainz.org/recording/'
assert url.startswith(prefix)
id = url[len(prefix):]
print('loading ID:', id)
return musicbrainzngs.get_recording_by_id(
id, includes=['releases', 'artist-credits', 'isrcs'])['recording']
def stats_for_recording(self, recordingid):
""" Given a recording id, get its work (if it exists) and
the composer and lyricist of the work """
self.recordings.add(recordingid)
recording = mb.get_recording_by_id(recordingid, includes=["work-rels", "artist-rels"])
recording = recording["recording"]
for relation in recording.get("artist-relation-list", []):
artist = relation.get("artist", {}).get("id")
if artist:
self.artists.add(artist)
for relation in recording.get("work-relation-list", []):
workid = relation.get("work", {}).get("id")
self.works.add(workid)
self.work_recording_counts[workid] += 1
work = mb.get_work_by_id(workid, includes=["artist-rels"])
work = work["work"]
for artist in work.get("artist-relation-list", []):
t = artist["type"]
aid = artist.get("artist", {}).get("id")
if aid:
if t == "composer":
self.composers.add(aid)
elif t == "lyricist":
self.lyricists.add(aid)
def get_recording(mbid):
try:
rec = musicbrainzngs.get_recording_by_id(
mbid, includes=["releases", "artists"])
return rec["recording"]
except musicbrainzngs.ResponseError:
return {}
def main():
m.set_useragent("application", "0.01", "http://example.com")
print(m.get_artist_by_id("952a4205-023d-4235-897c-6fdb6f58dfaa", []))
print(m.get_label_by_id("aab2e720-bdd2-4565-afc2-460743585f16"))
print(m.get_release_by_id("e94757ff-2655-4690-b369-4012beba6114"))
print(m.get_release_group_by_id("9377d65d-ffd5-35d6-b64d-43f86ef9188d"))
print(m.get_recording_by_id("cb4d4d70-930c-4d1a-a157-776de18be66a"))
print(m.get_work_by_id("7e48685c-72dd-3a8b-9274-4777efb2aa75"))
print(m.get_releases_by_discid("BG.iuI50.qn1DOBAWIk8fUYoeHM-"))
print(m.get_recordings_by_puid("070359fc-8219-e62b-7bfd-5a01e742b490"))
print(m.get_recordings_by_isrc("GBAYE9300106"))
m.auth("", "")
m.submit_barcodes(
{"e94757ff-2655-4690-b369-4012beba6114": "9421021463277"})
m.submit_tags(recording_tags={
"cb4d4d70-930c-4d1a-a157-776de18be66a": ["these", "are", "my", "tags"]
})
m.submit_tags(
artist_tags={"952a4205-023d-4235-897c-6fdb6f58dfaa": ["NZ", "twee"]})
m.submit_ratings(
recording_ratings={"cb4d4d70-930c-4d1a-a157-776de18be66a": 20})
m.submit_echoprints(
{"e97f805a-ab48-4c52-855e-07049142113d": "anechoprint1234567"})
def main(collectionid):
# work -> list recordings
mapping = collections.defaultdict(list)
# map from an id to a name
recordingnames = {}
worknames = {}
for i, releaseid in enumerate(compmusic.musicbrainz.get_releases_in_collection(collectionid)):
print i, releaseid
try:
rel = mb.get_release_by_id(releaseid, includes=["recordings"])
except:
continue
rel = rel["release"]
for medium in rel.get("medium-list", []):
for track in medium.get("track-list", []):
recid = track["recording"]["id"]
recordingnames[recid] = track["recording"]["title"]
recording = mb.get_recording_by_id(recid, includes=["work-rels"])
recording = recording["recording"]
for work in recording.get("work-relation-list", []):
workid = work["work"]["id"]
worknames[workid] = work["work"]["title"]
mapping[workid].append(recid)
data = []
for k, v in mapping.items():
data.append((k, v))
data = sorted(data, key=lambda x: len(x[1]), reverse=True)
all_d = {"recordingnames": recordingnames,
"worknames": worknames,
"data": data
}
json.dump(all_d, open("works_by_recording.json", "w"))
def get_album_name( recording_id,
log ):
"""
`recording_id` should be a Musicbrainz ID value for a recording (track) as
a string. Returns None on failure, else returns the recording's album's
name as it is most commonly known in the Musicbrainz DB as a string
"""
try:
result = musicbrainzngs.get_recording_by_id( recording_id, includes=['releases'] )
except Exception as exc:
log.warning("get_album_name(): web service call failed: %s" % exc)
return None
most_common_album_name = None
try:
# Find the most commonly occuring name for the release (album)
release_name_occurences = dict()
for release in result['recording']['release-list']:
if release['title'] not in release_name_occurences:
release_name_occurences[release['title']] = 1
else:
release_name_occurences[release['title']] += 1
most_common_album_name = \
max( release_name_occurences, key=release_name_occurences.get )
except Exception as e:
log.warning("get_album_name(): result parsing failed: %s: %s\nresult was %s" % ( type(e), e, str(result) ))
return None
return most_common_album_name
def main(path, fake_release_mbid):
releases = {}
#Get all the mbid of the recordings
onlyfiles = [
f for f in os.listdir(path) if os.path.isfile(os.path.join(path, f))
]
for i in onlyfiles:
head, tail = os.path.split(i)
filename, file_extension = os.path.splitext(i)
if file_extension == '.mp3':
c = eyed3.load(os.path.join(path, i))
mbid = c.tag.unique_file_ids.get(
"http://musicbrainz.org").render()[33:]
try:
rel = mb.get_recording_by_id(mbid, includes=["releases"])
release = None
if len(rel['recording']['release-list']):
#create release
release = rel['recording']['release-list'][0]['id']
else:
release = fake_release_mbid
#use *fake* release
if release not in releases:
releases[release] = []
releases[release].append(mbid)
except:
print "couldn't find a release for the recording %s" % mbid
continue
coll = Collection.objects.get(mbid="544f7aec-dba6-440c-943f-103cf344efbb")
r = makam_importer.MakamReleaseImporter(coll)
for i in releases.keys():
r.import_release(i, "")
for j in releases[i]:
r.add_and_get_recording(j)
def load_recording_attributes_from_music_brainz(mbid):
"""
Loads attributes for the single recording.
:param mbid: MBID
:return: RecordingAttributes
"""
mb.set_useragent("application", "0.01", "http://example.com")
rec_attrs = mb.get_recording_by_id(
id=mbid, includes=['artist-credits', 'artist-rels', 'work-rels'])
lineup = {}
composers = []
recording_started = None
recording_finished = None
recording_year = None
if 'artist-relation-list' in rec_attrs['recording'].keys():
artist_relations = rec_attrs['recording']['artist-relation-list']
recording_started, recording_finished, recording_year = estimate_recording_time(
artist_relations)
lineup = get_lineup(artist_relations)
if 'work-relation-list' in rec_attrs['recording'].keys():
composers = get_composers(rec_attrs['recording']['work-relation-list'])
return RecordingAttributes(rec_attrs['recording']['title'],
rec_attrs['recording']['artist-credit-phrase'],
recording_year, recording_started,
recording_finished, lineup, composers)
def getRecrodingListForAWork( workMBID, m):
# get list of recording IDa for work ID
recordingIDsList = m.recordingids_for_work(workMBID)
existingVocalRecordings = [];
for recID in recordingIDsList:
recording = mb.get_recording_by_id(recID, includes=["artist-rels", "releases"])
# check if we have the realease of the recording in the database
listExistingReleases = getExistigReleasesForRecording(recording, recID)
if len(listExistingReleases) == 0:
continue
# check if we have vocals
if not isRecordingWithVocals(recording, recID):
print "no vocals in recording ID: ", recID
else:
existingVocalRecordings.append(recID)
return existingVocalRecordings
def recording_parser(self, results):
list_of_recordings = []
#If Musicbrainz data is missing
artist_name = ''
title = ''
rec_type = ''
rec_type_title = ''
status = ''
recording_data = [
'artists', 'releases', 'discids', 'media', 'artist-credits',
'isrcs', 'annotation', 'aliases', 'tags', 'user-tags', 'ratings',
'user-ratings', 'area-rels', 'artist-rels', 'label-rels',
'place-rels', 'recording-rels', 'release-rels',
'release-group-rels', 'url-rels', 'work-rels'
]
# for recording in results['recording-list']:
rec_result = mbz.get_recording_by_id(results, includes=recording_data)
# list_of_recordings.append({'title': recording['title'],
# 'rec_id':recording['id'],
# 'rel_id':[rel['id'] for rel in rec_result['recording']['release-list']]})
list_of_recordings = [
rel['id'] for rel in rec_result['recording']['release-list']
]
parsed_list_of_recordings = self.release_info(list_of_recordings)
return parsed_list_of_recordings
def main(path, fake_release_mbid):
releases = {}
# Get all the mbid of the recordings
onlyfiles = [f for f in os.listdir(path) if os.path.isfile(os.path.join(path, f))]
for i in onlyfiles:
head, tail = os.path.split(i)
filename, file_extension = os.path.splitext(i)
if file_extension == '.mp3':
c = eyed3.load(os.path.join(path, i))
mbid = c.tag.unique_file_ids.get("http://musicbrainz.org").render()[33:]
try:
rel = mb.get_recording_by_id(mbid, includes=["releases"])
release = None
if len(rel['recording']['release-list']):
# create release
release = rel['recording']['release-list'][0]['id']
else:
release = fake_release_mbid
# use *fake* release
if release not in releases:
releases[release] = []
releases[release].append(mbid)
except:
print("couldn't find a release for the recording %s" % mbid)
continue
coll = Collection.objects.get(mbid="544f7aec-dba6-440c-943f-103cf344efbb")
r = makam_importer.MakamReleaseImporter(coll)
for i in releases.keys():
r.import_release(i, "")
for j in releases[i]:
r.add_and_get_recording(j)
def stats_for_recording(self, recordingid):
""" Given a recording id, get its work (if it exists) and
the composer and lyricist of the work """
self.recordings.add(recordingid)
recording = mb.get_recording_by_id(recordingid, includes=["work-rels", "artist-rels"])
recording = recording["recording"]
for relation in recording.get("artist-relation-list", []):
artist = relation.get("artist", {}).get("id")
if artist:
self.artists.add(artist)
for relation in recording.get("work-relation-list", []):
workid = relation.get("work", {}).get("id")
self.works.add(workid)
self.work_recording_counts[workid] += 1
work = mb.get_work_by_id(workid, includes=["artist-rels"])
work = work["work"]
for artist in work.get("artist-relation-list", []):
t = artist["type"]
aid = artist.get("artist", {}).get("id")
if aid:
if t == "composer":
self.composers.add(aid)
elif t == "lyricist":
self.lyricists.add(aid)
def get_recording_by_id(mbid):
recording = cache.get(mbid)
if not recording:
try:
recording = musicbrainzngs.get_recording_by_id(mbid, includes=['artists', 'releases', 'media'])['recording']
except ResponseError as e:
raise DataUnavailable(e)
cache.set(mbid, recording, time=CACHE_TIMEOUT)
return recording
def track_for_id(trackid):
"""Fetches a track by its MusicBrainz ID. Returns a TrackInfo object
or None if no track is found.
"""
try:
res = musicbrainzngs.get_recording_by_id(trackid, TRACK_INCLUDES)
except musicbrainzngs.ResponseError:
log.debug('Track ID match failed.')
return None
return track_info(res['recording'])
def get_recording_by_id(mbid):
mbid = str(mbid)
recording = cache.get(mbid)
if not recording:
try:
recording = musicbrainzngs.get_recording_by_id(mbid, includes=['artists', 'releases', 'media'])['recording']
except ResponseError as e:
raise DataUnavailable(e)
cache.set(mbid, recording, time=CACHE_TIMEOUT)
return recording
def track_for_id(trackid):
"""Fetches a track by its MusicBrainz ID. Returns a TrackInfo object
or None if no track is found.
"""
try:
res = musicbrainzngs.get_recording_by_id(trackid, TRACK_INCLUDES)
except musicbrainzngs.ResponseError:
log.debug('Track ID match failed.')
return None
return track_info(res['recording'])
def make_query(self, params):
if params["type"] == "artist":
return musicbrainzngs.get_artist_by_id(params["mbid"])
elif params["type"] == "album":
return musicbrainzngs.get_release_by_id(params["mbid"])
elif params["type"] == "tracklist":
return musicbrainzngs.get_release_by_id(params["mbid"],
includes=["recordings"])["release"]["medium-list"][0]["track-list"]
elif params["type"] == "track":
return musicbrainzngs.get_recording_by_id(params["mbid"], includes=["artists"])
def lookup(musicbrainz_id):
try:
return musicbrainzngs.get_recording_by_id(musicbrainz_id,
includes=[
"artists", "releases",
"artist-credits", "tags",
"instrument-rels",
"media"
])
except musicbrainzngs.WebServiceError as web_service_error:
raise MusicBrainzLookupError(
f"Something went wrong with the request: {web_service_error}")
def track_for_id(trackid):
"""Fetches a track by its MusicBrainz ID. Returns a TrackInfo object
or None if no track is found. May raise a MusicBrainzAPIError.
"""
try:
res = musicbrainzngs.get_recording_by_id(trackid, TRACK_INCLUDES)
except musicbrainzngs.ResponseError:
log.debug("Track ID match failed.")
return None
except musicbrainzngs.MusicBrainzError as exc:
raise MusicBrainzAPIError(exc, "get recording by ID", trackid, traceback.format_exc())
return track_info(res["recording"])
def track_for_id(trackid):
"""Fetches a track by its MusicBrainz ID. Returns a TrackInfo object
or None if no track is found. May raise a MusicBrainzAPIError.
"""
try:
res = musicbrainzngs.get_recording_by_id(trackid, TRACK_INCLUDES)
except musicbrainzngs.ResponseError:
log.debug('Track ID match failed.')
return None
except musicbrainzngs.MusicBrainzError as exc:
raise MusicBrainzAPIError(exc, 'get recording by ID', trackid,
traceback.format_exc())
return track_info(res['recording'])
def get_performance_credit_for_recording(self, recordingid):
recording = mb.get_recording_by_id(recordingid, includes=["releases"])
recording = recording["recording"]
ret = []
for release in recording.get("release-list", []):
relid = release["id"]
mbrelease = mb.get_release_by_id(relid, includes=["artist-credits", "recordings"])
mbrelease = mbrelease["release"]
for medium in mbrelease.get("medium-list", []):
for track in medium.get("track-list", []):
if track["recording"]["id"] == recordingid:
ret.append(track["recording"]["artist-credit-phrase"])
return list(set(ret))
def get_mb_recording_info(rmbid):
''' Get info related to the recording passed by input from Music Brainz
:param rmbid: Music Brainz id of a recording
:return: info from Music Brainz
'''
mb.set_useragent("andalusian_analysis_notebook", "0.1")
json_file = mb.get_recording_by_id(rmbid, includes=["artist-rels"])
if not json_file:
print("Music Brainz return empty metadata")
# replace inverted comma with inverted commas. Necessary to avoid parsing error
json_file = replace_invertedcomma(str(json_file))
return json_file
def get_mb_recording_by_id(self, mb_id):
try:
return m.get_recording_by_id(
mb_id, includes=["url-rels"]
)
except WebServiceError as exc:
log.error("requesting data from MusicBrainz: %s (WebServiceError)" % exc)
log.debug("MODELS: get_mb_recording_by_id returns False.")
return False
except Exception as exc:
log.error("requesting data from MusicBrainz: %s (Exception)" % exc)
log.debug("MODELS: get_mb_recording_by_id returns empty dict.")
return {}
def get_performance_credit_for_recording(self, recordingid):
recording = mb.get_recording_by_id(recordingid, includes=["releases"])
recording = recording["recording"]
ret = []
for release in recording.get("release-list", []):
relid = release["id"]
mbrelease = mb.get_release_by_id(
relid, includes=["artist-credits", "recordings"])
mbrelease = mbrelease["release"]
for medium in mbrelease.get("medium-list", []):
for track in medium.get("track-list", []):
if track["recording"]["id"] == recordingid:
ret.append(track["recording"]["artist-credit-phrase"])
return list(set(ret))
def match_recording(mbids):
release_list = []
mbid_rec = {}
for mbid in mbids:
try:
mbid_info = mb.get_recording_by_id(mbid,['artists','releases'],['official'])['recording']
except mb.musicbrainz.ResponseError :
logging.warning('{0} is an invalid MusicBrainz ID. Skipping...'.format(mbid))
continue
mbid_rlist = mbid_info['release-list']
mbid_rec[mbid] = mbid_info
for item in mbid_rlist:
item['trackid'] = mbid
release_list.extend(mbid_rlist)
return (mbid_rec, release_list)
def get_musicbrainz(self, obj):
results = []
includes = ['releases','artists']
for e in obj.results_acoustid:
media_id = e['id']
try:
result = musicbrainzngs.get_recording_by_id(id=media_id, includes=includes)
results.append(result)
except Exception, e:
print e
pass
def from_musicbrainz(self, audio_in):
try: # audio file input
mbid, duration, sampling_frequency, bit_rate = \
Recording.get_file_metadata(audio_in)
audio_meta = {
'mbid': mbid,
'path': audio_in,
'duration': duration,
'sampling_frequency': sampling_frequency,
'bit_rate': bit_rate
}
except (IOError, AttributeError):
audio_meta = {'mbid': audio_in}
audio_meta['url'] = u'http://musicbrainz.org/recording/{}'.format(
audio_meta['mbid'])
meta = mb.get_recording_by_id(audio_meta['mbid'],
includes=[
'artists', 'artist-rels', 'releases',
'tags', 'work-rels'
])['recording']
audio_meta['title'] = meta['title']
# releases
audio_meta['releases'] = self._get_releases(meta)
# artist credits
audio_meta['artist_credits'] = self._get_artist_credits(meta)
# performers
audio_meta['artists'] = self._get_artist_relations(meta)
# works
if 'work-relation-list' in meta.keys(): # has work
audio_meta['works'] = self._get_works(meta)
# get makam/usul/for from work attributes
if self.get_work_attributes and 'works' in audio_meta.keys():
self._get_attributes_from_works(audio_meta)
# get makam/usul/for tags
self._get_recording_attribute_tags(audio_meta, meta)
# infer voicing/instrumentation
audio_meta['instrumentation_voicing'] = InstrumentationVoicing.\
get_voicing_instrumentation(audio_meta)
return audio_meta
def get_musicbrainz(self, obj):
results = []
includes = ['releases', 'artists']
for e in obj.results_acoustid:
media_id = e['id']
try:
result = musicbrainzngs.get_recording_by_id(id=media_id,
includes=includes)
results.append(result)
except Exception, e:
print e
pass
def track_for_id(releaseid):
"""Fetches a track by its MusicBrainz ID. Returns a TrackInfo object
or None if no track is found. May raise a MusicBrainzAPIError.
"""
trackid = _parse_id(releaseid)
if not trackid:
log.debug(u'Invalid MBID ({0}).', releaseid)
return
try:
res = musicbrainzngs.get_recording_by_id(trackid, TRACK_INCLUDES)
except musicbrainzngs.ResponseError:
log.debug(u'Track ID match failed.')
return None
except musicbrainzngs.MusicBrainzError as exc:
raise MusicBrainzAPIError(exc, u'get recording by ID', trackid,
traceback.format_exc())
return track_info(res['recording'])
def get_recording_live_string(recording_id):
log.debug("%s: get_recording_live_string cache size %d", PLUGIN_NAME,
len(get_recording_live_string.cache))
if recording_id in get_recording_live_string.cache:
return get_recording_live_string.cache[recording_id]
recording_info = musicbrainzngs.get_recording_by_id(
recording_id, includes=['work-rels', 'place-rels'])['recording']
live = False
if 'disambiguation' in recording_info \
and 'live' in recording_info['disambiguation']:
live = True
else:
try:
for work_rel in recording_info['work-relation-list']:
for work_rel_attrib in work_rel['attribute-list']:
if work_rel_attrib == 'live':
live = True
break
except:
pass
place_strings = []
if 'place-relation-list' in recording_info:
#assert len(recording_info['place-relation-list']) == 1
for place_rel in recording_info['place-relation-list']:
try:
assert place_rel['begin'] == place_rel['end']
if len(place_rel['begin']):
location_string = get_place_location_string(
place_rel['place']['id'])
live_loc_str = "live, " if live else "recorded, "
live_loc_str += "%s: %s" % (place_rel['begin'],
location_string)
get_recording_live_string.cache[
recording_id] = live_loc_str
place_strings.append(live_loc_str)
except:
log.debug("Got confused by %s", repr(place_rel))
pass
place_strings.sort()
return '; '.join(place_strings)
return None
def getOnlyVocalRecording(recordingIDsList):
existingVocalRecordings = [];
for recID in recordingIDsList:
recording = mb.get_recording_by_id(recID, includes=["artist-rels", "releases"])
# check if we have the realease of the recording in the database
listExistingReleases = getExistigReleasesForRecording(recording, recID)
if len(listExistingReleases) == 0:
continue
# check if we have vocals
if not isRecordingWithVocals(recording, recID):
print "no vocals in recording ID: ", recID
else:
existingVocalRecordings.append(recID)
def from_musicbrainz(self, audio_in):
try: # audio file input
mbid, duration, sampling_frequency, bit_rate = \
Recording.get_file_metadata(audio_in)
audio_meta = {'mbid': mbid, 'path': audio_in, 'duration': duration,
'sampling_frequency': sampling_frequency,
'bit_rate': bit_rate}
except (IOError, AttributeError):
audio_meta = {'mbid': audio_in}
audio_meta['url'] = u'http://musicbrainz.org/recording/{}'.format(
audio_meta['mbid'])
meta = mb.get_recording_by_id(audio_meta['mbid'], includes=['artists', 'artist-rels', 'releases', 'tags', 'work-rels'])['recording']
audio_meta['title'] = meta['title']
# releases
audio_meta['releases'] = self._get_releases(meta)
# artist credits
audio_meta['artist_credits'] = self._get_artist_credits(meta)
# performers
audio_meta['artists'] = self._get_artist_relations(meta)
# works
if 'work-relation-list' in meta.keys(): # has work
audio_meta['works'] = self._get_works(meta)
# get makam/usul/for from work attributes
if self.get_work_attributes and 'works' in audio_meta.keys():
self._get_attributes_from_works(audio_meta)
# get makam/usul/for tags
self._get_recording_attribute_tags(audio_meta, meta)
# infer voicing/instrumentation
audio_meta['instrumentation_voicing'] = InstrumentationVoicing.\
get_voicing_instrumentation(audio_meta)
return audio_meta
def tag_file(song_file):
musicbrainzngs.auth(BRAINZ_USER, BRAINZ_PASS)
musicbrainzngs.set_useragent("Auto tag script", "0.1", "http://localhost")
#song = path.join(MP3_DIR, '3.mp3')
print song_file
for score, recording_id, title, artist in acoustid.match(
APIKEY, song_file):
# Get song data
result_data = musicbrainzngs.get_recording_by_id(
recording_id, includes=['artists', 'releases'])
title = result_data['recording']['title']
artist = result_data['recording']['artist-credit-phrase']
print "%s - %s" % (title, artist)
# Set ID3 tags
audiofile = eyed3.load(song_file)
audiofile.tag.artist = unicode(artist)
audiofile.tag.title = unicode(title)
# Get Cover Art
if result_data['recording']['release-count']:
try:
imagedata = musicbrainzngs.get_image_front(
result_data['recording']['release-list'][0]['id'])
print audiofile.tag.images.set(
eyed3.id3.frames.ImageFrame.FRONT_COVER, imagedata,
'image/jpeg')
cover = open(
path.join(
COVER_DIR,
result_data['recording']['release-list'][0]['title'] +
'.jpg'), "w+")
cover.write(imagedata)
print "---"
except musicbrainzngs.musicbrainz.ResponseError:
pass
audiofile.tag.save()
def search_musicbrainz_by_id(data):
musicbrainz.set_useragent("mer-ml", "0.1")
for i, row in data.iterrows():
if not row['fallback-id'] == '0-0':
id = row['fallback-id']
recording = musicbrainz.get_recording_by_id(id)
recording = recording['recording']
print(recording)
match_recordings = musicbrainz.search_recordings(
query=format_string(recording['title']))
match_artist = find_closest_artist_from_recording(
match_recordings['recording-list'], data['artist'])
for rec in match_recordings['recording-list']:
if format_string(recording['title']) == format_string(
rec['title']) and format_string(
rec['artist-credit-phrase']) == match_artist:
if has_audio_data(rec['id']):
data.at[i, 'id'] = rec[id]
break
else:
data.at[i, 'fallback-id'] = rec[id]
return data
def recurse_relations(mb_track_id, oldest_release, relation_type):
x = musicbrainzngs.get_recording_by_id(
mb_track_id,
includes=['releases', 'recording-rels'])
if 'recording-relation-list' in x['recording'].keys():
# recurse down into edits and remasters.
# Note remasters are deprecated in musicbrainz, but some entries
# may still exist.
for subrecording in x['recording']['recording-relation-list']:
if ('direction' in subrecording.keys() and
subrecording['direction'] == 'backward'):
continue
# skip new relationship category samples
if subrecording['type'] not in relations:
continue
if 'artist' in x['recording'].keys() and x['recording']['artist'] != subrecording['artist']:
print(f'Skipping relation with arist {subrecording["artist"]} that does not match {x["recording"]["artist"]}')
continue
(oldest_release, relation_type) = recurse_relations(
subrecording['target'],
oldest_release,
subrecording['type'])
for release in x['recording']['release-list']:
if 'date' not in release.keys():
# A release without a date. Skip over it.
continue
release_date = make_date_values(release['date'])
if 'year' not in release_date.keys():
continue
if (oldest_release['year'] is None or
oldest_release['year'] > release_date['year']):
oldest_release = release_date
elif oldest_release['year'] == release_date['year']:
if ('month' in release_date.keys() and
'month' in oldest_release.keys() and
oldest_release['month'] > release_date['month']):
oldest_release = release_date
return (oldest_release, relation_type)
def _recording_details(recording_ids):
'''
We need to store more information . As of now , storing only release id to get the album art in future
'''
mbids = {}
song_details = {}
for rid in recording_ids:
release_ids = []
try:
data = musicbrainzngs.get_recording_by_id(rid,includes=['releases'])['recording']
for i in data['release-list']:
try:
if i['status'] == 'Official':
release_ids.append(i['id'])
except:
pass
mbids[rid] = release_ids
song_details[rid] = data['release-list']
except musicbrainzngs.WebServiceError as exc:
print("Something went wrong with the request: %s" % exc)
raise MusicUtilsException('4','Something wrong with the request. ')
return (mbids,song_details)
def scrape(query):
mbid = query["mbid"]
now = datetime.datetime.utcnow().isoformat()
recording = mb.get_recording_by_id(mbid, includes=["artists",
"tags"])["recording"]
artists, artist_map = artist_credits_to_artist_list(
recording["artist-credit"])
data = {
"mbid": recording["id"],
"name": recording["title"],
"artist_credit": recording["artist-credit-phrase"],
"tags": sort_tags(recording.get("tag-list", [])),
"artists": sorted(artists),
"last_updated": now
}
# Get release names + tags + artists + release groups
release_ids = get_releases_for_recording(mbid)
other_artists, release_map, release_group_map = get_metadata_for_releases(
release_ids, now)
# For any artists in `other_artists` which are not in `artists`, look them up
remaining_artists = list(set(other_artists) - set(artists))
if remaining_artists:
new_artist_map = lookup_artists(remaining_artists)
artist_map.update(new_artist_map)
data["artist_map"] = artist_map
data["releases"] = sorted(release_ids)
data["release_map"] = release_map
data["release_group_map"] = release_group_map
return data
def main(collectionid):
# work -> list recordings
mapping = collections.defaultdict(list)
# map from an id to a name
recordingnames = {}
worknames = {}
for i, releaseid in enumerate(
compmusic.musicbrainz.get_releases_in_collection(collectionid)):
print i, releaseid
try:
rel = mb.get_release_by_id(releaseid, includes=["recordings"])
except:
continue
rel = rel["release"]
for medium in rel.get("medium-list", []):
for track in medium.get("track-list", []):
recid = track["recording"]["id"]
recordingnames[recid] = track["recording"]["title"]
recording = mb.get_recording_by_id(recid,
includes=["work-rels"])
recording = recording["recording"]
for work in recording.get("work-relation-list", []):
workid = work["work"]["id"]
worknames[workid] = work["work"]["title"]
mapping[workid].append(recid)
data = []
for k, v in mapping.items():
data.append((k, v))
data = sorted(data, key=lambda x: len(x[1]), reverse=True)
all_d = {
"recordingnames": recordingnames,
"worknames": worknames,
"data": data
}
json.dump(all_d, open("works_by_recording.json", "w"))
sys.path.append('../mopidy_remote')
from library import RemoteLibrary
import musicbrainzngs
config = {}
config['remote'] = {}
config['remote']['database'] = '/var/lib/mopidy/remote.db'
lib = RemoteplayLibrary(config)
musicbrainzngs.set_useragent('mopidy-headless', '0.0.1')
result = musicbrainzngs.search_releases(release="Dandy in the Underworld",
artist="T. Rex")
import pdb
pdb.set_trace()
res = musicbrainzngs.search_artists(artist='T. Rex')
[(art['name'], art['ext:score']) for art in result['artist-list']
if int(art['ext:score']) > 30]
result = musicbrainzngs.search_recordings(recording="Crimson Moon",
release="Dandy in the Underworld",
artist="T. Rex")
track = [t for t in result['recording-list'] if int(t['ext:score']) == 100][0]
musicbrainz_id = track['id']
rec = musicbrainzngs.get_recording_by_id(
'9abfbf0b-ef05-4dfc-9177-17cc42dd3feb', includes=['artists', 'releases'])
track = rec['recording']
album = track['release-list'][0]['title']
artist = track['artist-credit-phrase']
def getAlbumArtistNames(album,artist, apihandle, song=None):
'''
Given a supposed album and artist, determine the real ones
'''
def searchWhatAlbums(args):
if len(args)==0:
return []
whatResponse = apihandle.request(action='browse',searchstr=args[0])
if whatResponse['status']=='success':
args.pop(0)
return searchWhatAlbums(args)+[x for x in whatResponse['response']['results'] if 'artist' in x and 'groupName' in x]
return []
mbAlbums = []
parens = re.compile('[\(\[].*[\)\]]')
if song is not None:
includes = ['recordings']
artists = set(re.split(' &|and|ft\.?|featuring|feat\.? ',artist))
if len(artists) > 1:
artists.add(artist)
for ar in artists:
mbAlbums += [dict(list(x.items())+[("artist-credit-phrase", releases['artist-credit-phrase'])]) for releases in mb.search_recordings(query=song, limit=int(50*mbMultiplier), artistname=mbquote(ar), release=mbquote(album))['recording-list'] for x in releases['release-list']]
mbAlbums += mb.search_releases(artist=mbquote(ar),query=mbquote(album),limit=int(25*mbMultiplier))['release-list']
lastfmres = [x['mbid'] for x in lookup('lastfm','songsearch',{'artist':ar, 'song':song})['results']['trackmatches']['track'] if 'mbid' in x and len(x['mbid'])>0]
if len(lastfmres)>0:
for lastfmRecId in set(lastfmres):
try:
lastfmAlbum = mb.get_recording_by_id(id=lastfmRecId,includes=['releases','artist-credits'])
for alb in lastfmAlbum['recording'].pop('release-list'):
alb['medium-list'] = [{}]
alb['medium-list'][0]['track-list'] = []
alb['medium-list'][0]['track-list'].append(lastfmAlbum)
alb['artist-credit-phrase'] = lastfmAlbum['recording']['artist-credit-phrase']
mbAlbums.append(alb)
except Exception as e:
print(e)
else:
includes = []
mbArtists = mb.search_artists(query=mbquote(artist),limit=int(40*mbMultiplier))['artist-list']
mbAlbums += mb.search_releases(artist=mbquote(artist),query=mbquote(album),limit=int(50*mbMultiplier))['release-list']
for mbArtist in mbArtists:
if Levenshtein.ratio(artist.lower(),mbArtist['name'].lower()) > 0.75:
mbAlbums+=[ dict(list(x.items())+[('artist-credit-phrase',mbArtist['name'])]) for x in mb.browse_releases(artist=mbArtist['id'],includes=includes,limit=25)['release-list']]
if (len(album)<7 and ('/' in album or ' & ' in album) and 's' in album.lower() and 't' in album.lower()) or ('self' in album.lower() and 'titled' in album.lower()):
mbAlbums += mb.search_releases(artist=mbquote(artist),query=mbquote(artist),limit=int(25*mbMultiplier))['release-list']
temp = []
for x in mbAlbums[:]:
if x["id"] in temp and not ('medium-list' in x and len(x['medium-list'])>0 and all('track-list' in z and len(z['track-list'])>0 for z in x['medium-list'])):
mbAlbums.remove(x)
else:
temp.append(x['id'])
print("Done searching musicbrainz for album suggestions, have "+str(len(mbAlbums))+" to rank")
ranks = {}
for x in mbAlbums:
ranks[x['id']] = Levenshtein.ratio(album.lower(),x['title'].lower())
if song is not None:
x['song'] = {}
temp = ([(y['recording']['title'] if 'recording' in y else y['title'],
int(float(
y['recording']['length'] if 'recording' in y and 'length' in y['recording']
else (y['track_or_recording_length'] if 'track_or_recording_length' in x
else y['length'] if 'length' in x else 0)
)/1000.))
for tracklist in x['medium-list']
for y in tracklist['track-list']]
if 'medium-list' in x and len(x['medium-list'])>0 and all('track-list' in z and len(z['track-list'])>0 for z in x['medium-list'])
else getSongs(
{"artist":x['artist-credit-phrase'],
"groupName":x['title']}))
x['song']['name'], x['song']['duration'] = (max(temp,
key=lambda y: Levenshtein.ratio(y[0].lower(),song.lower())) if len(temp)>0 else ("",-1))
if ranks[x['id']] < Levenshtein.ratio(x['song']['name'].lower(),song.lower()):
ranks[x['id']] /= 6
ranks[x['id']] += (Levenshtein.ratio(x['song']['name'].lower(),song.lower())
+ Levenshtein.ratio(parens.sub('',x['song']['name'].lower()),parens.sub('',song.lower())) )*5/12
else:
ranks[x['id']] /= 3
ranks[x['id']] += (Levenshtein.ratio(x['song']['name'].lower(),song.lower())
+ Levenshtein.ratio(parens.sub('',x['song']['name'].lower()),parens.sub('',song.lower())) )/3
ranks[x['id']] += Levenshtein.ratio(artist.lower(),x['artist-credit-phrase'].lower())*7/6
if len(ranks) == 0:
return None
mbAlbumId, mbAlbumRank = max(ranks.items(),key=(lambda x:x[1]))
mbAlbum = [x for x in mbAlbums if x['id']==mbAlbumId][0]
print("For the artist and album derived from the provided dir ("+artist+" and "+album+" respectively),\nthe following artist and album was matched on musicbrains:")
print("Artist: "+mbAlbum['artist-credit-phrase'])
print("Album: "+mbAlbum['title'])
whatAlbums = searchWhatAlbums([mbAlbum['title']+' '+mbAlbum['artist-credit-phrase'], artist+' '+album])
if len(whatAlbums) == 0:
whatAlbums = searchWhatAlbums([artist,album,mbAlbum['title'],mbAlbum['artist-credit-phrase']])
if len(whatAlbums) == 0:
return None
whatAlbums = sorted(whatAlbums, key=(lambda x:
Levenshtein.ratio(x['groupName'],mbAlbum['title'])
+Levenshtein.ratio(x['groupName'].lower(),album.lower())*3/8
+Levenshtein.ratio(x['artist'],mbAlbum['artist-credit-phrase'])
+Levenshtein.ratio(x['artist'].lower(),artist.lower())*5/8),
reverse=True)#[:min(10,len(whatAlbums))]
whatAlbum = whatAlbums[0]
whatAlbum['artist-credit-phrase'] = mbAlbum['artist-credit-phrase']
if song is not None:
whatAlbum['song'] = mbAlbum['song']
print("For the album and artist found on musicbrainz, the following torrent group was found on what:")
print("Artist: "+whatAlbum['artist'])
print("Album: "+whatAlbum['groupName'])
return whatAlbum
def get_mb_recording(collection_mbid, output_file):
# Get the collection from musicbrainz and extract the recordings
print "Retrieving information from mb collection: %s" % collection_mbid
rec_list = []
collection = mb.get_releases_in_collection(collection_mbid)
for rel in collection["collection"]["release-list"]:
rel_mb = mb.get_release_by_id(rel['id'], includes=["recordings"])
for i in rel_mb["release"]["medium-list"]:
for track in i["track-list"]:
rec = track['recording']['id']
if rec not in rec_list:
rec_list.append(rec)
# Get the recording from musicbrainz and extract makam, form and usul
for rec_mbid in rec_list:
work_rels = mb.get_recording_by_id(rec_mbid, includes=["tags", "work-rels"])
rec_tags = []
if "tag-list" in work_rels["recording"]:
rec_tags = work_rels["recording"]["tag-list"]
works = []
if "work-relation-list" in work_rels["recording"]:
works = work_rels["recording"]["work-relation-list"]
for w in works:
print "Extracting work information from MB: %s" % w["work"]["id"]
work_tags = []
work = mb.get_work_by_id(w["work"]["id"], includes=["tags", "artist-rels"])
if "tag-list" in work["work"]:
work_tags = work["work"]["tag-list"]
mu2 = get_symbtrmu2(work["work"]["id"])
# get alias for each tag
try:
rec_makam, rec_usul, rec_form = get_tags(rec_tags)
work_makam, work_usul, work_form = get_tags(work_tags)
mu2_makam = get_fuzzy("makam", mu2["makam"])
mu2_form = get_fuzzy("form", mu2["form"])
mu2_usul = get_fuzzy("usul", mu2["usul"])
# compare results of 3 sources
makam, usul, form = (None, None, None)
if mu2_makam and mu2_usul and mu2_form:
#There is mu2 file with makam usul and form
if mu2_makam == rec_makam and mu2_usul == rec_usul and mu2_form == rec_form:
if work_makam == rec_makam and work_usul == rec_usul and work_form == rec_form:
makam = work_makam
usul = work_usul
form = work_form
elif not work_makam and not work_usul and not work_form:
# If mb work has no tag we only consider information from mu2 and mb recording
makam = rec_makam
usul = rec_usul
form = rec_form
else:
print "There's a difference between mu2 file and mb recording information."
print "Recording form: %s usul: %s makam: %s" % (rec_form, rec_usul, rec_makam)
print "Mu2 form: %s usul: %s makam: %s" % (mu2_form, mu2_usul, mu2_makam)
elif (not work_makam and not work_usul and not work_form) or \
(work_makam == rec_makam and work_usul == rec_usul and work_form == rec_form):
# If theres no mu2 file we only consider mb information
makam = rec_makam
usul = rec_usul
form = rec_form
if makam and usul and form:
try:
update_mb_work(work["work"]["id"], makam, form, usul, output_file)
except ElementNotFoundException, e:
print "Couldn't generate link because element not present in MB"
except AliasNotFoundException, e:
print "Skipping work because alias not found on Dunya"
mbid_list.append(MBID_name)
print MBID_name
musicbrainzngs.auth("meghanasudhindra", "musicbrains123")
musicbrainzngs.set_useragent("Dunya", "0.1")
musicbrainzngs.set_hostname("beta.musicbrainz.org")
MBID_Song = open("MBID_Song.txt", "w")
#recordings = []
recording_id = []
recording_title = []
#artist_id = "4cc5200e-a3f7-4d5d-8b15-9b10a8f9a9a2"
for name_artist in mbid_list:
result = musicbrainzngs.get_recording_by_id(name_artist)
print result['recording']['id']
print result['recording']['title']
recording_id.append(result['recording']['id'])
recording_title.append(result['recording']['title'])
for i in range(len(recording_id)):
MBID_Song.write(recording_id[i] + '\t' + recording_title[i] + '\n')
MBID_Song.close()
def extractItemFromUri( url, options ):
exp = re.compile(r'/(\w+)/(.*)')
match = exp.search(url)
if not match:
WebExtractor.error('Error parsing url: ' + url)
return
extractType = match.group(1)
puid = match.group(2)
WebExtractor.log('fetch :' + extractType + ' with id :' + puid)
if extractType == 'release':
#TODO extract all tracks from this relese
WebExtractor.error('Full Album extraction not implemented: ')
return
try:
musicbrainzngs.get_release_by_id
except Exception as err:
WebExtractor.error("Script error: \n" + str(err))
else:
# extract just the single track
try:
# get_recording_by_id need authorization :/
result = musicbrainzngs.get_recording_by_id(puid, includes=["artists", "artist-credits", "releases", "media", "tags"])
recording = result['recording']
trackNumber = ""
releaseType = ""
date = ""
albumName = ""
albumArtist = ""
albumId = ""
genre = ""
trackPerformer = ""
coverUrl = ""
for person in recording['artist-credit']:
if 'artist' in person:
if trackPerformer != "":
trackPerformer = trackPerformer + '; '
trackPerformer = trackPerformer + person['artist']['name']
if 'tag-list' in recording:
genre = ';'.join(tag['name'] for tag in recording['tag-list'])
if 'release-list' in recording:
albumRelese = recording['release-list'][0]
if albumRelese is not None:
albumName = albumRelese['title']
albumId = albumRelese['id']
#albumArtist = albumRelese['artist-credit-phrase']
for person in albumRelese['artist-credit']:
if 'artist' in person:
if albumArtist != "":
albumArtist = albumArtist + '; '
albumArtist = albumArtist + person['artist']['name']
if 'date' in albumRelese:
date = albumRelese['date']
#if 'type' in albumRelese['release-group']:
# releaseType = albumRelese['release-group']['type']
if albumRelese['medium-list'][0] is not None:
if 'track-list' in albumRelese['medium-list'][0]:
trackNumber = albumRelese['medium-list'][0]['track-list'][0]['number']
# try to get cover from the coverartarchive
url = 'http://coverartarchive.org/release/' + str(albumId)
try:
data = json.load(urllib2.urlopen(url))
for item in data['images']:
if 'Front' in item['types']:
coverUrl = item['image']
break;
except Exception as err:
WebExtractor.log("Cover could not be retrieved from: \n" + url + "\n Reason: \n" + str(err))
trackDict = dict (
title = recording['title'],
performer = trackPerformer,#recording['artist-credit-phrase'],
number = trackNumber,
releasedate = date,
genre = genre,
musicbrainz = recording['id'],
seealso = url
)
albumDict = dict (
title = albumName,
#trackCount = track.releases[0].getTracksCount(),
performer = albumArtist,
#genre = ';'.join(tag.value for tag in track.tags),
musicbrainz = albumId,
#releasetype = releaseType,
cover = coverUrl,
tracks = [trackDict]
)
# this is a workaround, because multiple nested dictionaries cause some problems with the names of the keys
#WebExtractor.itemResults( 'music', trackDict )
data_string = json.dumps(albumDict)
WebExtractor.itemResultsJSON( 'music', data_string )
except Exception as err:
WebExtractor.error("Script error: \n" + str(err))
def album(self, mbid):
dbcfg = self.mc.get('database')
dl = _mysql.connect(host=dbcfg['host'],user=dbcfg['username'],passwd=dbcfg['password'],db=dbcfg['database'])
query = "select * from Albums where MBID='" + _mysql.escape_string(mbid) + "';"
dl.query(query)
ret = {}
r = dl.store_result()
c = r.num_rows()
for i in range(0, c):
dd = r.fetch_row(1,1)[0]
ret = dd
if len(ret) == 0:
try:
info = musicbrainzngs.get_release_by_id(mbid, includes=['artists', 'url-rels', 'recordings'])
except:
info = {}
if 'release' in info:
rinfo = info['release']
trackstoadd = []
if 'medium-list' in rinfo:
for disc in rinfo['medium-list']:
if not('track-list' in disc):
continue
for trackinfo in disc['track-list']:
item = trackinfo['recording']
if 'number' in trackinfo:
item['tracknumber'] = trackinfo['number']
if 'position' in trackinfo:
item['tracknumber'] = trackinfo['position']
mbinfo = musicbrainzngs.get_recording_by_id(item['id'], includes=['artists'])
try:
item['artist'] = mbinfo['recording']['artist-credit'][0]['artist']['id']
except:
item['artist'] = ''
trackstoadd.append(item)
ret['Title'] = ""
ret['MBID'] = ""
ret['ASIN'] = ""
if 'title' in rinfo:
ret['Title'] = rinfo['title'].encode('utf8', 'ignore')
if 'id' in rinfo:
ret['MBID'] = rinfo['id'].encode('utf8', 'ignore')
if 'asin' in rinfo:
ret['ASIN'] = rinfo['asin'].encode('utf8', 'ignore')
try:
ret['ReleaseDate'] = rinfo['release-event-list'][0]['date'].encode('utf8', 'ignore')
except:
ret['ReleaseDate'] = ''
try:
artist_mbid = rinfo['artist-credit'][0]['artist']['id'].encode('utf8', 'ignore')
except:
artist_mbid = ''
artist_info = self.artist(artist_mbid)
query = "select ID from Artists where MBID='" + artist_mbid + "';"
artist_id = "0"
dl.query(query)
r = dl.store_result()
if r.num_rows() > 0:
dd = r.fetch_row(1,1)[0]
artist_id = dd['ID']
query = "insert ignore into Albums (MBID, Title, Artist, ASIN, ReleaseDate) values ('" + _mysql.escape_string(ret['MBID']) + "', '" + _mysql.escape_string(ret['Title']) + "', '" + _mysql.escape_string(artist_id) + "', '" + _mysql.escape_string(ret['ASIN']) + "', '" + _mysql.escape_string(ret['ReleaseDate']) + "');"
ret = {}
dl.query(query)
query = "select * from Albums where MBID='" + _mysql.escape_string(mbid) + "';"
dl.query(query)
ret = {}
r = dl.store_result()
c = r.num_rows()
for i in range(0, c):
dd = r.fetch_row(1,1)[0]
ret = dd
if 'ID' in ret:
for trackinfo in trackstoadd:
query = "select ID from Artists where MBID='" + trackinfo['artist'] + "';"
dl.query(query)
r = dl.store_result()
artist_id = '0'
if r.num_rows() > 0:
dd = r.fetch_row(1,1)[0]
artist_id = dd['ID']
if 'length' in trackinfo:
track_length = (int(trackinfo['length']) / 1000)
else:
track_length = 0
query = "insert ignore into Tracks (MBID, Title, Length, TrackNo, LastFM, Artist, Album)"
query = query + " values ('" + _mysql.escape_string(trackinfo['id']) + "', '" + _mysql.escape_string(trackinfo['title'].encode('utf8', 'ignore')) + "', '" + str(track_length) + "', '" + _mysql.escape_string(trackinfo['tracknumber']) + "', '', '" + artist_id + "', '" + ret['ID'] + "');"
dl.query(query)
tracks = []
if 'ID' in ret:
aid = ret['ID']
else:
aid = '0'
query = "select * from Tracks where Album='" + str(aid) + "' order by TrackNo"
dl.query(query)
r = dl.store_result()
c = r.num_rows()
for i in range(0, c):
dd = r.fetch_row(1,1)[0]
del dd['ID']
del dd['Album']
del dd['Artist']
tracks.append(dd)
ret['tracks'] = tracks
if 'Artist' in ret:
aid = ret['Artist']
query = "select * from Artists where ID='" + str(aid) + "';"
dl.query(query)
r = dl.store_result()
c = r.num_rows()
if c > 0:
ret['Artist'] = r.fetch_row(1,1)[0]
if 'ID' in ret['Artist']:
del ret['Artist']['ID']
else:
del ret['Artist']
if 'ID' in ret:
del ret['ID']
return ret
# Login
mb.auth(user_name, user_pass)
# Set up an app
mb.set_useragent(app_name, app_version, app_url)
# Sign a host engine to search from
mb.set_hostname(host_url)
#====================================================================
#>>>>>>>>>>>>>>>>>>>>>>>[ SEARCH API ]>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#====================================================================
# -----------[ Get By ID ]------------------
# Get an artist
id = 'e86ab653-bec8-46f3-b4b6-a1a866919ef6'
artist = mb.get_artist_by_id(id)['artist']
print('[ Artist Name ]:', artist['name'])
# Get an album (Release)
id = 'ccd708f2-06f5-43d4-8396-032dc7eb1883'
album = mb.get_release_by_id(id)['release']
print('[ Album Title ]:', album['title'])
# Get a track (Recording)
id = 'c216f892-e329-4986-9373-6d95660801d6'
track = mb.get_recording_by_id(id)['recording']
print('[ Track Title ]:', track['title'])
def scrape(mbid):
try:
recording = mb.get_recording_by_id(mbid, includes=["artists", "releases", "tags"])
# Recording title
recording_name = recording["recording"]["title"]
artists = []
releases = []
release_groups = []
for item in recording["recording"]["artist-credit"]:
# Condition to skip join-phrase in multi-artists recordings
if isinstance(item, dict):
# Recording artist info
artist_id = item["artist"]["id"]
artist_name = item["artist"]["name"]
# Check for recording artist tag-list
if "tag-list" in item["artist"]:
artist_tags = item["artist"]["tag-list"]
artists.append({"id": artist_id, "name": artist_name, "tag-list": artist_tags})
else:
artists.append({"id": artist_id, "name": artist_name})
for item in recording["recording"]["release-list"]:
# Request for release info
release = mb.get_release_by_id(item["id"], includes = ["artists", "release-groups", "tags"])
# Release group info
release_group_id = release["release"]["release-group"]["id"]
release_group_title = release["release"]["release-group"]["title"]
release_group_first_release_date = release["release"]["release-group"]["first-release-date"]
release_artists = []
for item2 in release["release"]["artist-credit"]:
# Condition to skip join-phrase in multi-artists releases
if isinstance(item2, dict):
# Release artist info
release_artist_id = item2["artist"]["id"]
release_artist_name = item2["artist"]["name"]
# Check for artist tag-list
if "tag-list" in item2["artist"]:
release_artist_tags = item2["artist"]["tag-list"]
release_artists.append({"id": release_artist_id, "name": release_artist_name, "tag-list": release_artist_tags})
else:
release_artists.append({"id": release_artist_id, "name": release_artist_name})
# Release group tags check and first-release-date
if "tag-list" in release["release"]["release-group"]:
release_group_tags = release["release"]["release-group"]["tag-list"]
release_group = {"id": release_group_id, "title": release_group_title, "firs-release-date": release_group_first_release_date, "tag-list": release_group_tags}
else:
release_group = {"id": release_group_id, "title": release_group_title, "firs-release-date": release_group_first_release_date}
# Check if release group already stored - eliminate dublicates
if release_group not in release_groups:
release_groups.append(release_group)
# Check for release tag-list
if "tag-list" in release["release"]:
release_tags = release["release"]["tag-list"]
releases.append({"id": item["id"], "title": item["title"], "artist": release_artists, "date": item["date"], "tag-list": release_tags})
else:
releases.append({"id": item["id"], "title": item["title"], "artist": release_artists, "date": item["date"]})
except mb.MusicBrainzError as ex:
raise
# Final result based on the existance of recording tags
if "tag-list" in recording["recording"]:
recording_tags = recording["recording"]["tag-list"]
result = {"title": recording_name, "artist": artists, "releases": releases, "realease-groups": release_groups, "tag-list": recording_tags}
else:
result = {"title": recording_name, "artist": artists, "releases": releases, "realease-groups": release_groups}
return result
def get_works_from_recording(recording):
rec = mb.get_recording_by_id(recording, includes=["work-rels"])["recording"]
return rec.get("work-relation-list", [])
def get_tags_from_recording(recording):
rec = mb.get_recording_by_id(recording, includes=["tags"])["recording"]
return rec.get("tag-list", [])
def get_recording(mbid):
try:
rec = musicbrainzngs.get_recording_by_id(mbid, includes=["releases", "artists"])
return rec["recording"]
except musicbrainzngs.ResponseError:
return {}
def get_mb_recording(collection_mbid, output_file):
global symbtrmu2_url, count_matched_mu2, count_missing_mu2, count_missing_dunya
# Get the collection from musicbrainz and extract the recordings
print("Retrieving information from mb collection: %s" % collection_mbid)
res = {"mu2": [], "mb": []}
rec_list = []
collection = mb.get_releases_in_collection(collection_mbid)
for rel in collection["collection"]["release-list"]:
rel_mb = mb.get_release_by_id(rel['id'], includes=["recordings"])
for i in rel_mb["release"]["medium-list"]:
for track in i["track-list"]:
rec = track['recording']['id']
if rec not in rec_list:
rec_list.append(rec)
# Get the recording from musicbrainz and extract makam, form and usul
for rec_mbid in rec_list:
work_rels = mb.get_recording_by_id(rec_mbid, includes=["tags", "work-rels"])
rec_tags = []
if "tag-list" in work_rels["recording"]:
rec_tags = work_rels["recording"]["tag-list"]
works = []
if "work-relation-list" in work_rels["recording"]:
works = work_rels["recording"]["work-relation-list"]
for w in works:
print("Extracting work information from MB: %s" % w["work"]["id"])
work_tags = []
work = mb.get_work_by_id(w["work"]["id"], includes=["tags", "artist-rels"])
if "tag-list" in work["work"]:
work_tags = work["work"]["tag-list"]
mu2 = get_symbtrmu2(work["work"]["id"])
title = work["work"]["title"].encode("utf-8")
# get alias for each tag
try:
rec_makam, rec_usul, rec_form = get_tags(rec_tags)
work_makam, work_usul, work_form = get_tags(work_tags)
mu2_makam = get_fuzzy("makam", mu2["makam"])
mu2_form = get_fuzzy("form", mu2["form"])
mu2_usul = get_fuzzy("usul", mu2["usul"])
# compare results of 3 sources
makam, usul, form = (None, None, None)
if mu2_makam and mu2_usul and mu2_form:
#There is mu2 file with makam usul and form
count_matched_mu2 += 1
if mu2_makam == rec_makam and mu2_usul == rec_usul and mu2_form == rec_form:
if work_makam == rec_makam and work_usul == rec_usul and work_form == rec_form:
makam = work_makam
usul = work_usul
form = work_form
elif not work_makam and not work_usul and not work_form:
# If mb work has no tag we only consider information from mu2 and mb recording
makam = rec_makam
usul = rec_usul
form = rec_form
else:
print("There's a difference between mu2 file and mb recording information.")
print("Recording form: %s usul: %s makam: %s" % (rec_form, rec_usul, rec_makam))
print("Mu2 form: %s usul: %s makam: %s" % (mu2_form, mu2_usul, mu2_makam))
if makam and usul and form:
try:
new_link = update_mb_work(work["work"]["id"], title, makam, form, usul, symbtrmu2_url % work["work"]["id"])
if new_link:
res['mu2'].append(new_link)
except ElementNotFoundException as e:
print("Couldn't generate link because element not present in MB")
elif (not work_makam and not work_usul and not work_form) or \
(work_makam == rec_makam and work_usul == rec_usul and work_form == rec_form):
# If theres no mu2 file we only consider mb information
count_missing_mu2 += 1
if rec_makam and rec_usul and rec_form:
try:
new_link = update_mb_work(work["work"]["id"], title, rec_makam, rec_form, rec_usul, None)
res['mb'].append(new_link)
except ElementNotFoundException as e:
print("Couldn't generate link because element not present in MB")
except AliasNotFoundException as e:
count_missing_dunya += 1
print("Skipping work because alias not found on Dunya")
with open(output_file, "a+") as append_file:
append_file.write("<h1> List of links generated from MU2 files information </h1>")
for i in res['mu2']:
append_file.write(i)
append_file.write("<h1> List of links generated from recording tags </h1>")
for i in res['mb']:
append_file.write(i)
print("Completed with missing mu2 files: %d, matched mu2 files: %d, missing on dunya: %d" % \
(count_missing_mu2, count_matched_mu2, count_missing_dunya))
def addRecordData(recId, relId):
relResult = musicbrainzngs.get_release_by_id(relId)
recResult = musicbrainzngs.get_recording_by_id(recId)
recordDictionary[recId] = {'date': relResult["release"]["date"], 'title': recResult["recording"]["title"]}
def match(self, obj):
log = logging.getLogger('util.match.match')
log.info('matching: %s' % obj.title)
for r in obj.results_mb:
print '--'
#print r
mb_id = r['id']
print mb_id
match, created = Match.objects.get_or_create(request=obj, mb_id=mb_id)
includes = [
'artists',
'releases',
'artist-credits',
'release-rels',
'release-group-rels',
'artist-rels',
'annotation',
'discids',
'label-rels',
'work-rels',
'recording-rels',
'media',
'isrcs',
]
try:
mr = musicbrainzngs.get_recording_by_id(id=mb_id, includes=includes)
mr = mr['recording']
# self.pp.pprint(mr)
match.title = mr['title']
# match data as json
match.results_mb = mr
match.artist = mr['artist-credit-phrase']
if 'length' in mr:
match.duration = mr['length']
# compose cretits string
if 'artist-credit' in mr:
credits = ''
for c in mr['artist-credit']:
try:
astr = c['artist']['name']
credits += astr + "\n"
except:
pass
match.artist_credits = credits
# compose secondary cretits string
if 'artist-relation-list' in mr:
credits = ''
for c in mr['artist-relation-list']:
try:
astr = c['artist']['name']
astr = '%s - [%s: %s]' % (astr, c['type'], ', '.join(c['attribute-list']))
credits += astr + "\n"
except Exception, e:
print e
pass
match.artist_credits_secondary = credits
if 'isrc-list' in mr:
self.pp.pprint(mr['isrc-list'])
try:
isrcs = "\n".join(mr['isrc-list'])
match.isrc_list = isrcs
except Exception, e:
print e
pass
# compose release string
if 'release-list' in mr:
releases = ''
for r in mr['release-list']:
"""
print '*******************************'
self.pp.pprint(r)
print '*******************************'
"""
includes = ['labels','release-rels', 'work-rels']
#mr = mr['recording']
try:
pass
except:
pass
try:
rstr = r['title']
rstr = '%s - [%s | %s]' % (rstr, r['country'], r['date'])
if 'medium-list' in r:
try:
rstr += ' - %s - Track# %s' % (r['medium-list'][0]['format'], r['medium-list'][0]['track-list'][0]['number'])
except:
pass
try:
tstr = ''
if 'label-info-list' in mrel:
lil = mrel['label-info-list'][0]
self.pp.pprint(lil)
if 'label' in lil:
tstr += ' %s ' % lil['label']['name']
if 'label-code' in lil['label']:
tstr += '(%s) ' % lil['label']['label-code']
if 'catalog-number' in lil:
tstr += 'catno: %s' % lil['catalog-number']
print '****'
print tstr
rstr += ' [ ' + tstr + ' ] '
except Exception, e:
print e
pass
try:
mrel = musicbrainzngs.get_release_by_id(id=r['id'], includes=includes)
mrel = mrel['release']
# self.pp.pprint(mrel)
rstr += ' [barcode: %s]' % (mrel['barcode'])
except:
pass
releases += rstr + "\n"
except Exception, e:
print e
pass
