def process_item(self, item: Item):
self._say("Fixing item: {}".format(item), log_only=True)
year = item.get("year")
original_year = item.get("original_year")
if not original_year or self.cfg_force:
mbdata = self._get_mb_data(item)
if mbdata:
extracted = common.extract_original_year_from_mb_data(mbdata)
if extracted:
original_year = extracted
self._say(
"Got (MusicBrainz) recording `original_year`: {}".
format(original_year))
if not original_year:
original_year = self.get_mean_value_for_album(
item, "original_year")
self._say("Got (mean-album) `original_year`: {}".format(
original_year))
if not original_year:
original_year = self.get_mean_value_for_artist(
item, "original_year")
self._say("Got (mean-artist) `original_year`: {}".format(
original_year))
if not year or self.cfg_force:
year = self.get_mean_value_for_album(item, "year")
self._say("Got (mean-album) `year`: {}".format(year))
if not year:
year = self.get_mean_value_for_artist(item, "year")
self._say("Got (mean-artist) `year`: {}".format(year))
if original_year:
setattr(item, "original_year", original_year)
if year:
setattr(item, "year", year)
if original_year and not year:
setattr(item, "year", original_year)
if year and not original_year:
setattr(item, "original_year", year)
if not year and not original_year:
self._say("Cannot find info!")
def get_mb_search_url(item: Item):
mb_artistid = item.get("mb_artistid")
title = item.get("title")
if not mb_artistid or not title:
raise AttributeError(
"Missing tag(mb_artistid or title)! Cannot build MB url.")
query = 'arid:{arid} AND recording:"{title}"'.format(arid=mb_artistid,
title=title)
url = "{base}recording/?query={qry}&fmt={fmt}".format(base=MB_BASE,
qry=query,
fmt="json")
return quote_plus(url, safe=':/&?=')
def _get_input_path_for_item(self, item: Item):
input_path = item.get("path").decode("utf-8")
if not os.path.isfile(input_path):
raise FileNotFoundError(
"Input file({}) not found!".format(input_path))
return input_path
def increment_play_count_on_item(item: Item, store=True, write=True):
# clear_dirty is necessary to make sure that `ordering_score` and
# `ordering_info` will not get stored to the library
item.clear_dirty()
item["play_count"] = item.get("play_count", 0) + 1
if store:
item.store()
if write:
item.write()
def _get_output_path_for_item(self, item: Item):
identifier = item.get("mb_trackid")
if not identifier:
input_path = self._get_input_path_for_item(item)
identifier = hashlib.md5(input_path.encode('utf-8')).hexdigest()
output_file = "{id}.{ext}".format(id=identifier, ext="json")
return os.path.join(self._get_extraction_output_path(), output_file)
def get_mean_value_for_artist(self, item: Item, field_name):
answer = None
query = MatchQuery('mb_artistid', item.get("mb_artistid"))
items = self.lib.items(query)
values = []
for it in items:
if it.get(field_name):
val = int(it.get(field_name))
if 0 < val < 2100:
values.append(val)
if values:
answer = int(round(sum(values) / len(values)))
return answer
def process_item(self, item: Item):
self._say("Fixing item: {}".format(item), log_only=True)
current_genre = item.get("genre")
tag_groups = []
qtypes = (self.config["types"].keys())
metadata = {
'artist': item.get("artist"),
'artistid': item.get("mb_artistid:"),
'album': item.get("album"),
'albumid': item.get("mb_releasegroupid"),
'year': item.get("year")
}
for dp in self.dataproviders:
# self._say("{}: {}".format("=" * 60, dp.name))
for qtype in qtypes:
tags = self.get_tags_from_provider(dp, qtype, metadata)
# self._say("tags[{}]: {}".format(qtype, tags), log_only=False)
if tags:
tag_groups.append({
'provider': dp.name,
'qtype': qtype,
'tags': tags
})
# self._say("Tags: {}".format(tag_groups), log_only=False)
tags = self.create_unified_tag_list(tag_groups)
# self._say("Unified Tags: {}".format(tags), log_only=False)
tags = self.get_scored_tags(tags)
# self._say("Scored Tags: {}".format(tags), log_only=False)
tags = sorted(tags.items(), key=operator.itemgetter(1), reverse=True)
self._say("Ordered Tags: {}".format(tags), log_only=False)
_max = self.config["max_tags"].as_number()
_glue = self.config["tag_glue"].as_str()
top_tags = [v[0] for v in tags][:_max]
# self._say("Top Tags: {}".format(top_tags), log_only=False)
changed = False
if top_tags:
new_genre = _glue.join(top_tags)
if new_genre != current_genre:
self._say("Setting new genre: '{}' -> '{}'".format(
current_genre, new_genre),
log_only=False)
item["genre"] = new_genre
changed = True
return changed
