def __init__(self, track_id, data_home=None):
if track_id not in INDEX:
raise ValueError(
'{} is not a valid track ID in Orchset'.format(track_id))
self.track_id = track_id
self._data_home = data_home
self._track_paths = INDEX[track_id]
if METADATA is None or METADATA['data_home'] != data_home:
_reload_metadata(data_home)
self._track_metadata = METADATA[track_id]
self.audio_path_mono = utils.get_local_path(
self._data_home, self._track_paths['audio_mono'][0])
self.audio_path_stereo = utils.get_local_path(
self._data_home, self._track_paths['audio_stereo'][0])
self.composer = self._track_metadata['composer']
self.work = self._track_metadata['work']
self.excerpt = self._track_metadata['excerpt']
self.predominant_melodic_instruments = \
self._track_metadata['predominant_melodic_instruments-normalized']
self.alternating_melody = self._track_metadata['alternating_melody']
self.contains_winds = self._track_metadata['contains_winds']
self.contains_strings = self._track_metadata['contains_strings']
self.contains_brass = self._track_metadata['contains_brass']
self.only_strings = self._track_metadata['only_strings']
self.only_winds = self._track_metadata['only_winds']
self.only_brass = self._track_metadata['only_brass']
def _load_metadata(data_home):
predominant_inst_path = utils.get_local_path(
data_home,
os.path.join(DATASET_DIR,
'Orchset - Predominant Melodic Instruments.csv'),
)
if not os.path.exists(predominant_inst_path):
raise OSError('Could not find Orchset metadata file')
with open(predominant_inst_path, 'r') as fhandle:
reader = csv.reader(fhandle, delimiter=',')
raw_data = []
for line in reader:
if line[0] == 'excerpt':
continue
raw_data.append(line)
tf_dict = {'TRUE': True, 'FALSE': False}
metadata_index = {}
for line in raw_data:
track_id = line[0].split('.')[0]
id_split = track_id.split('.')[0].split('-')
if id_split[0] == 'Musorgski' or id_split[0] == 'Rimski':
id_split[0] = '-'.join(id_split[:2])
id_split.pop(1)
melodic_instruments = [s.split(',') for s in line[1].split('+')]
melodic_instruments = [
item.lower() for sublist in melodic_instruments for item in sublist
]
for i, inst in enumerate(melodic_instruments):
if inst == 'string':
melodic_instruments[i] = 'strings'
elif inst == 'winds (solo)':
melodic_instruments[i] = 'winds'
melodic_instruments = list(set(melodic_instruments))
metadata_index[track_id] = {
'predominant_melodic_instruments-raw': line[1],
'predominant_melodic_instruments-normalized': melodic_instruments,
'alternating_melody': tf_dict[line[2]],
'contains_winds': tf_dict[line[3]],
'contains_strings': tf_dict[line[4]],
'contains_brass': tf_dict[line[5]],
'only_strings': tf_dict[line[6]],
'only_winds': tf_dict[line[7]],
'only_brass': tf_dict[line[8]],
'composer': id_split[0],
'work': '-'.join(id_split[1:-1]),
'excerpt': id_split[-1][2:],
}
metadata_index['data_home'] = data_home
return metadata_index
def _load_metadata(data_home):
metadata_path = utils.get_local_path(
data_home, os.path.join(DATASET_DIR, 'medleydb_melody_metadata.json'))
if not os.path.exists(metadata_path):
raise OSError('Could not find MedleyDB-Melody metadata file')
with open(metadata_path, 'r') as fhandle:
metadata = json.load(fhandle)
metadata['data_home'] = data_home
return metadata
def __init__(self, track_id, data_home=None):
if track_id not in INDEX:
raise ValueError(
'{} is not a valid track ID in Beatles'.format(track_id))
self.track_id = track_id
self._data_home = data_home
self._track_paths = INDEX[track_id]
self.audio_path = utils.get_local_path(
self._data_home, self._track_paths['audio'][0])
self.title = os.path.basename(
self._track_paths['sections'][0]).split('.')[0]
def __init__(self, track_id, data_home=None):
if track_id not in INDEX:
raise ValueError(
'{} is not a valid track ID in iKala'.format(track_id))
if METADATA is None or METADATA['data_home'] != data_home:
_reload_metadata(data_home)
self.track_id = track_id
self._data_home = data_home
self._track_paths = INDEX[track_id]
self.audio_path = utils.get_local_path(self._data_home,
self._track_paths['audio'][0])
self.song_id = track_id.split('_')[0]
self.section = track_id.split('_')[0]
self.singer_id = METADATA[self.song_id]
def _load_metadata(data_home):
id_map_path = utils.get_local_path(
data_home, os.path.join(DATASET_DIR, 'id_mapping.txt'))
if not os.path.exists(id_map_path):
utils.download_large_file(ID_MAPPING_URL, id_map_path)
with open(id_map_path, 'r') as fhandle:
reader = csv.reader(fhandle, delimiter='\t')
singer_map = {}
for line in reader:
if line[0] == 'singer':
continue
singer_map[line[1]] = line[0]
singer_map['data_home'] = data_home
return singer_map
def __init__(self, track_id, data_home=None):
if track_id not in INDEX:
raise ValueError(
'{} is not a valid track ID in Salami'.format(track_id))
self.track_id = track_id
self._data_home = data_home
self._track_paths = INDEX[track_id]
if METADATA is None or METADATA['data_home'] != data_home:
_reload_metadata(data_home)
if track_id in METADATA.keys():
self._track_metadata = METADATA[track_id]
else:
# annotations with missing metadata
self._track_metadata = {
'source': None,
'annotator_1_id': None,
'annotator_2_id': None,
'duration_sec': None,
'title': None,
'artist': None,
'annotator_1_time': None,
'annotator_2_time': None,
'class': None,
'genre': None,
}
self.audio_path = utils.get_local_path(self._data_home,
self._track_paths['audio'][0])
self.source = self._track_metadata['source']
self.annotator_1_id = self._track_metadata['annotator_1_id']
self.annotator_2_id = self._track_metadata['annotator_2_id']
self.duration_sec = self._track_metadata['duration_sec']
self.title = self._track_metadata['title']
self.artist = self._track_metadata['artist']
self.annotator_1_time = self._track_metadata['annotator_1_time']
self.annotator_2_time = self._track_metadata['annotator_2_time']
self.broad_genre = self._track_metadata['class']
self.genre = self._track_metadata['genre']
def __init__(self, track_id, data_home=None):
if track_id not in INDEX:
raise ValueError(
'{} is not a valid track ID in MedleyDB-Pitch'.format(
track_id))
self.track_id = track_id
self._data_home = data_home
self._track_paths = INDEX[track_id]
if METADATA is None or METADATA['data_home'] != data_home:
_reload_metadata(data_home)
self._track_metadata = METADATA[track_id]
self.audio_path = utils.get_local_path(self._data_home,
self._track_paths['audio'][0])
self.instrument = self._track_metadata['instrument']
self.artist = self._track_metadata['artist']
self.title = self._track_metadata['title']
self.genre = self._track_metadata['genre']
def _load_metadata(data_home):
metadata_path = utils.get_local_path(
data_home,
os.path.join(DATASET_DIR, 'salami-data-public-master', 'metadata',
'metadata.csv'),
)
if not os.path.exists(metadata_path):
raise OSError('Could not find Salami metadata file')
with open(metadata_path, 'r') as fhandle:
reader = csv.reader(fhandle, delimiter=',')
raw_data = []
for line in reader:
if line[0] == 'SONG ID':
continue
raw_data.append(line)
metadata_index = {}
for line in raw_data:
track_id = line[0]
metadata_index[track_id] = {
'source': line[1],
'annotator_1_id': line[2],
'annotator_2_id': line[3],
'duration_sec': line[5],
'title': line[7],
'artist': line[8],
'annotator_1_time': line[10],
'annotator_2_time': line[11],
'class': line[14],
'genre': line[15],
}
metadata_index['data_home'] = data_home
return metadata_index
def melody3(self):
return _load_melody3(
utils.get_local_path(self._data_home,
self._track_paths['melody3'][0]))
def chords(self):
return _load_chords(utils.get_local_path(
self._data_home, self._track_paths['chords'][0]))
def key(self):
return _load_key(utils.get_local_path(
self._data_home, self._track_paths['keys'][0]))
def sections(self):
return _load_sections(utils.get_local_path(
self._data_home, self._track_paths['sections'][0]))
def lyrics(self):
return _load_lyrics(
utils.get_local_path(self._data_home,
self._track_paths['lyrics'][0]))
def sections_annotator_2_lowercase(self):
return _load_sections(
utils.get_local_path(self._data_home,
self._track_paths['annotator_2_lowercase']))
def pitch(self):
return _load_pitch(
utils.get_local_path(self._data_home,
self._track_paths['pitch'][0]))
def beats(self):
return _load_beats(utils.get_local_path(
self._data_home, self._track_paths['beat'][0]))
def test_get_local_path(data_home, rel_path, expected_path):
assert expected_path == utils.get_local_path(data_home, rel_path)
