def __init__(self, releases, disc, parent=None):
PicardDialog.__init__(self, parent)
self.releases = releases
self.disc = disc
self.ui = Ui_Dialog()
self.ui.setupUi(self)
self.ui.release_list.setSortingEnabled(True)
self.ui.release_list.setHeaderLabels([_("Album"), _("Artist"), _("Date"), _("Country"),
_("Labels"), _("Catalog #s"), _("Barcode")])
if self.releases:
for release in self.releases:
labels, catalog_numbers = label_info_from_node(release['label-info'])
date = release['date'] if "date" in release else ""
country = release['country'] if "country" in release else ""
barcode = release['barcode'] if "barcode" in release else ""
item = QtWidgets.QTreeWidgetItem(self.ui.release_list)
item.setText(0, release['title'])
item.setText(1, artist_credit_from_node(release['artist-credit'])[0])
item.setText(2, date)
item.setText(3, country)
item.setText(4, ", ".join(labels))
item.setText(5, ", ".join(catalog_numbers))
item.setText(6, barcode)
item.setData(0, QtCore.Qt.UserRole, release['id'])
self.ui.release_list.setCurrentItem(self.ui.release_list.topLevelItem(0))
self.ui.ok_button.setEnabled(True)
for i in range(self.ui.release_list.columnCount() - 1):
self.ui.release_list.resizeColumnToContents(i)
# Sort by descending date, then ascending country
self.ui.release_list.sortByColumn(3, QtCore.Qt.AscendingOrder)
self.ui.release_list.sortByColumn(2, QtCore.Qt.DescendingOrder)
self.ui.lookup_button.clicked.connect(self.lookup)
def __init__(self, releases, disc, parent=None):
PicardDialog.__init__(self, parent)
self.releases = releases
self.disc = disc
self.ui = Ui_Dialog()
self.ui.setupUi(self)
self.ui.release_list.setSortingEnabled(True)
self.ui.release_list.setHeaderLabels([_("Album"), _("Artist"), _("Date"), _("Country"),
_("Labels"), _("Catalog #s"), _("Barcode")])
if self.releases:
for release in self.releases:
labels, catalog_numbers = label_info_from_node(release['label-info'])
date = release['date'] if "date" in release else ""
country = release['country'] if "country" in release else ""
barcode = release['barcode'] if "barcode" in release else ""
item = QtWidgets.QTreeWidgetItem(self.ui.release_list)
item.setText(0, release['title'])
item.setText(1, artist_credit_from_node(release['artist_credit']))
item.setText(2, date)
item.setText(3, country)
item.setText(4, ", ".join(labels))
item.setText(5, ", ".join(catalog_numbers))
item.setText(6, barcode)
item.setData(0, QtCore.Qt.UserRole, release.id)
self.ui.release_list.setCurrentItem(self.ui.release_list.topLevelItem(0))
self.ui.ok_button.setEnabled(True)
for i in range(self.ui.release_list.columnCount() - 1):
self.ui.release_list.resizeColumnToContents(i)
# Sort by descending date, then ascending country
self.ui.release_list.sortByColumn(3, QtCore.Qt.AscendingOrder)
self.ui.release_list.sortByColumn(2, QtCore.Qt.DescendingOrder)
self.ui.lookup_button.clicked.connect(self.lookup)
def compare_to_track(self, track, weights):
parts = []
if 'title' in self:
a = self['title']
b = track.get('title', '')
parts.append((similarity2(a, b), weights["title"]))
if 'artist' in self:
a = self['artist']
artist_credits = track.get('artist-credit', [])
b = artist_credit_from_node(artist_credits)[0]
parts.append((similarity2(a, b), weights["artist"]))
a = self.length
if a > 0 and 'length' in track:
b = track['length']
score = self.length_score(a, b)
parts.append((score, weights["length"]))
releases = []
if "releases" in track:
releases = track['releases']
search_score = get_score(track)
if not releases:
sim = linear_combination_of_weights(parts) * search_score
return SimMatchTrack(similarity=sim,
releasegroup=None,
release=None,
track=track)
if 'isvideo' in weights:
metadata_is_video = self['~video'] == '1'
track_is_video = track.get('video', False)
score = 1 if metadata_is_video == track_is_video else 0
parts.append((score, weights['isvideo']))
result = SimMatchTrack(similarity=-1,
releasegroup=None,
release=None,
track=None)
for release in releases:
release_parts = self.compare_to_release_parts(release, weights)
sim = linear_combination_of_weights(parts +
release_parts) * search_score
if sim > result.similarity:
rg = release[
'release-group'] if "release-group" in release else None
result = SimMatchTrack(similarity=sim,
releasegroup=rg,
release=release,
track=track)
return result
def __init__(self, releases, disc, parent=None):
super().__init__(parent)
self.releases = releases
self.disc = disc
self.ui = Ui_Dialog()
self.ui.setupUi(self)
self.ui.release_list.setSortingEnabled(True)
self.ui.release_list.setAlternatingRowColors(True)
self.ui.release_list.setHeaderLabels([
_("Album"),
_("Artist"),
_("Date"),
_("Country"),
_("Labels"),
_("Catalog #s"),
_("Barcode")
])
if self.releases:
def myjoin(l):
return "\n".join(l)
selected = None
for release in self.releases:
labels, catalog_numbers = label_info_from_node(
release['label-info'])
dates, countries = release_dates_and_countries_from_node(
release)
barcode = release['barcode'] if "barcode" in release else ""
item = QtWidgets.QTreeWidgetItem(self.ui.release_list)
if disc.mcn and compare_barcodes(barcode, disc.mcn):
selected = item
item.setText(0, release['title'])
item.setText(
1,
artist_credit_from_node(release['artist-credit'])[0])
item.setText(2, myjoin(dates))
item.setText(3, myjoin(countries))
item.setText(4, myjoin(labels))
item.setText(5, myjoin(catalog_numbers))
item.setText(6, barcode)
item.setData(0, QtCore.Qt.UserRole, release['id'])
self.ui.release_list.setCurrentItem(
selected or self.ui.release_list.topLevelItem(0))
self.ui.ok_button.setEnabled(True)
for i in range(self.ui.release_list.columnCount() - 1):
self.ui.release_list.resizeColumnToContents(i)
# Sort by descending date, then ascending country
self.ui.release_list.sortByColumn(3, QtCore.Qt.AscendingOrder)
self.ui.release_list.sortByColumn(2, QtCore.Qt.DescendingOrder)
self.ui.lookup_button.clicked.connect(self.lookup)
self.restore_geometry()
self.restore_header_state()
self.finished.connect(self.save_header_state)
def compare_to_track(self, track, weights):
parts = []
if 'title' in self:
a = self['title']
b = track.get('title', '')
parts.append((similarity2(a, b), weights["title"]))
if 'artist' in self:
a = self['artist']
artist_credits = track.get('artist-credit', [])
b = artist_credit_from_node(artist_credits)[0]
parts.append((similarity2(a, b), weights["artist"]))
a = self.length
if a > 0 and 'length' in track:
b = track['length']
score = self.length_score(a, b)
parts.append((score, weights["length"]))
releases = []
if "releases" in track:
releases = track['releases']
if not releases:
sim = linear_combination_of_weights(parts)
if 'score' in track:
sim *= track['score'] / 100
return SimMatchTrack(similarity=sim,
releasegroup=None,
release=None,
track=track)
result = SimMatchTrack(similarity=-1,
releasegroup=None,
release=None,
track=None)
for release in releases:
release_parts = self.compare_to_release_parts(release, weights)
sim = linear_combination_of_weights(parts + release_parts)
if 'score' in track:
sim *= track['score'] / 100
if sim > result.similarity:
rg = release[
'release-group'] if "release-group" in release else None
result = SimMatchTrack(similarity=sim,
releasegroup=rg,
release=release,
track=track)
return result
def __init__(self, releases, disc, parent=None):
super().__init__(parent)
self.releases = releases
self.disc = disc
self.ui = Ui_Dialog()
self.ui.setupUi(self)
self.ui.release_list.setSortingEnabled(True)
self.ui.release_list.setAlternatingRowColors(True)
self.ui.release_list.setHeaderLabels([_("Album"), _("Artist"), _("Date"), _("Country"),
_("Labels"), _("Catalog #s"), _("Barcode")])
if self.releases:
def myjoin(l):
return "\n".join(l)
selected = None
for release in self.releases:
labels, catalog_numbers = label_info_from_node(release['label-info'])
dates, countries = release_dates_and_countries_from_node(release)
barcode = release['barcode'] if "barcode" in release else ""
item = QtWidgets.QTreeWidgetItem(self.ui.release_list)
if disc.mcn and compare_barcodes(barcode, disc.mcn):
selected = item
item.setText(0, release['title'])
item.setText(1, artist_credit_from_node(release['artist-credit'])[0])
item.setText(2, myjoin(dates))
item.setText(3, myjoin(countries))
item.setText(4, myjoin(labels))
item.setText(5, myjoin(catalog_numbers))
item.setText(6, barcode)
item.setData(0, QtCore.Qt.UserRole, release['id'])
self.ui.release_list.setCurrentItem(selected or self.ui.release_list.topLevelItem(0))
self.ui.ok_button.setEnabled(True)
for i in range(self.ui.release_list.columnCount() - 1):
self.ui.release_list.resizeColumnToContents(i)
# Sort by descending date, then ascending country
self.ui.release_list.sortByColumn(3, QtCore.Qt.AscendingOrder)
self.ui.release_list.sortByColumn(2, QtCore.Qt.DescendingOrder)
self.ui.lookup_button.clicked.connect(self.lookup)
self.restore_geometry()
self.restore_header_state()
self.finished.connect(self.save_header_state)
def compare_to_release_parts(self, release, weights):
parts = []
if "album" in self:
b = release['title']
parts.append((similarity2(self["album"], b), weights["album"]))
if "albumartist" in self and "albumartist" in weights:
a = self["albumartist"]
b = artist_credit_from_node(release['artist-credit'])[0]
parts.append((similarity2(a, b), weights["albumartist"]))
try:
a = int(self["totaltracks"])
b = release['track-count']
score = 0.0 if a > b else 0.3 if a < b else 1.0
parts.append((score, weights["totaltracks"]))
except (ValueError, KeyError):
pass
weights_from_preferred_countries(
parts, release, config.setting["preferred_release_countries"],
weights["releasecountry"])
weights_from_preferred_formats(
parts, release, config.setting["preferred_release_formats"],
weights["format"])
if "releasetype" in weights:
weights_from_release_type_scores(
parts, release, config.setting["release_type_scores"],
weights["releasetype"])
rg = QObject.tagger.get_release_group_by_id(
release['release-group']['id'])
if release['id'] in rg.loaded_albums:
parts.append((1.0, 6))
return parts
def compare_to_track(self, track, weights):
parts = []
if 'title' in self:
a = self['title']
b = track.get('title', '')
parts.append((similarity2(a, b), weights["title"]))
if 'artist' in self:
a = self['artist']
artist_credits = track.get('artist-credit', [])
b = artist_credit_from_node(artist_credits)[0]
parts.append((similarity2(a, b), weights["artist"]))
a = self.length
if a > 0 and 'length' in track:
b = track['length']
score = self.length_score(a, b)
parts.append((score, weights["length"]))
releases = []
if "releases" in track:
releases = track['releases']
if not releases:
sim = linear_combination_of_weights(parts)
return SimMatchTrack(similarity=sim, releasegroup=None, release=None, track=track)
result = SimMatchTrack(similarity=-1, releasegroup=None, release=None, track=None)
for release in releases:
release_parts = self.compare_to_release_parts(release, weights)
sim = linear_combination_of_weights(parts + release_parts)
if 'score' in track:
sim *= track['score'] / 100
if sim > result.similarity:
rg = release['release-group'] if "release-group" in release else None
result = SimMatchTrack(similarity=sim, releasegroup=rg, release=release, track=track)
return result
def compare_to_track(self, track, weights):
parts = []
if 'title' in self:
a = self['title']
b = track['title']
parts.append((similarity2(a, b), weights["title"]))
if 'artist' in self:
a = self['artist']
b = artist_credit_from_node(track['artist-credit'])[0]
parts.append((similarity2(a, b), weights["artist"]))
a = self.length
if a > 0 and 'length' in track:
b = track['length']
score = self.length_score(a, b)
parts.append((score, weights["length"]))
releases = []
if "releases" in track:
releases = track['releases']
if not releases:
sim = linear_combination_of_weights(parts)
return (sim, None, None, track)
result = (-1, )
for release in releases:
release_parts = self.compare_to_release_parts(release, weights)
sim = linear_combination_of_weights(parts + release_parts)
if sim > result[0]:
rg = release[
'release-group'] if "release-group" in release else None
result = (sim, rg, release, track)
return result
def compare_to_track(self, track, weights):
parts = []
if 'title' in self:
a = self['title']
b = track['title']
parts.append((similarity2(a, b), weights["title"]))
if 'artist' in self:
a = self['artist']
b = artist_credit_from_node(track['artist-credit'])[0]
parts.append((similarity2(a, b), weights["artist"]))
a = self.length
if a > 0 and 'length' in track:
b = track['length']
score = 1.0 - min(abs(a - b), 30000) / 30000.0
parts.append((score, weights["length"]))
releases = []
if "releases" in track:
releases = track['releases']
if not releases:
sim = linear_combination_of_weights(parts)
return (sim, None, None, track)
result = (-1,)
for release in releases:
release_parts = self.compare_to_release_parts(release, weights)
sim = linear_combination_of_weights(parts + release_parts)
if sim > result[0]:
rg = release['release-group'] if "release-group" in release else None
result = (sim, rg, release, track)
return result
def compare_to_release_parts(self, release, weights):
parts = []
if "album" in self:
b = release['title']
parts.append((similarity2(self["album"], b), weights["album"]))
if "albumartist" in self and "albumartist" in weights:
a = self["albumartist"]
b = artist_credit_from_node(release['artist-credit'])[0]
parts.append((similarity2(a, b), weights["albumartist"]))
try:
a = int(self["totaltracks"])
except (ValueError, KeyError):
pass
else:
try:
if "title" in weights:
b = release['media'][0]['track-count']
else:
b = release['track-count']
except KeyError:
b = 0
score = 0.0 if a > b else 0.3 if a < b else 1.0
parts.append((score, weights["totaltracks"]))
preferred_countries = config.setting["preferred_release_countries"]
preferred_formats = config.setting["preferred_release_formats"]
total_countries = len(preferred_countries)
if total_countries:
score = 0.0
if "country" in release:
try:
i = preferred_countries.index(release['country'])
score = float(total_countries - i) / float(total_countries)
except ValueError:
pass
parts.append((score, weights["releasecountry"]))
total_formats = len(preferred_formats)
if total_formats and 'media' in release:
score = 0.0
subtotal = 0
for medium in release['media']:
if "format" in medium:
try:
i = preferred_formats.index(medium['format'])
score += float(total_formats - i) / float(total_formats)
except ValueError:
pass
subtotal += 1
if subtotal > 0:
score /= subtotal
parts.append((score, weights["format"]))
if "releasetype" in weights:
# This section generates a score that determines how likely this release will be selected in a lookup.
# The score goes from 0 to 1 with 1 being the most likely to be chosen and 0 the least likely
# This score is based on the preferences of release-types found in this release
# This algorithm works by taking the scores of the primary type (and secondary if found) and averages them
# If no types are found, it is set to the score of the 'Other' type or 0.5 if 'Other' doesnt exist
type_scores = dict(config.setting["release_type_scores"])
score = 0.0
other_score = type_scores.get('Other', 0.5)
if 'release-group' in release and 'primary-type' in release['release-group']:
types_found = [release['release-group']['primary-type']]
if 'secondary-types' in release['release-group']:
types_found += release['release-group']['secondary-types']
for release_type in types_found:
score += type_scores.get(release_type, other_score)
score /= len(types_found)
parts.append((score, weights["releasetype"]))
rg = QObject.tagger.get_release_group_by_id(release['release-group']['id'])
if release['id'] in rg.loaded_albums:
parts.append((1.0, 6))
return parts
def compare_to_release_parts(self, release, weights):
parts = []
if "album" in self:
b = release['title']
parts.append((similarity2(self["album"], b), weights["album"]))
if "albumartist" in self and "albumartist" in weights:
a = self["albumartist"]
b = artist_credit_from_node(release['artist-credit'])[0]
parts.append((similarity2(a, b), weights["albumartist"]))
try:
a = int(self["totaltracks"])
except (ValueError, KeyError):
pass
else:
if "title" in weights:
b = release['media'][0]['track-count']
else:
b = release['track-count']
score = 0.0 if a > b else 0.3 if a < b else 1.0
parts.append((score, weights["totaltracks"]))
preferred_countries = config.setting["preferred_release_countries"]
preferred_formats = config.setting["preferred_release_formats"]
total_countries = len(preferred_countries)
if total_countries:
score = 0.0
if "country" in release:
try:
i = preferred_countries.index(release['country'])
score = float(total_countries - i) / float(total_countries)
except ValueError:
pass
parts.append((score, weights["releasecountry"]))
total_formats = len(preferred_formats)
if total_formats:
score = 0.0
subtotal = 0
for medium in release['media']:
if "format" in medium:
try:
i = preferred_formats.index(medium['format'])
score += float(total_formats - i) / float(total_formats)
except ValueError:
pass
subtotal += 1
if subtotal > 0:
score /= subtotal
parts.append((score, weights["format"]))
if "releasetype" in weights:
type_scores = dict(config.setting["release_type_scores"])
if 'release-group' in release and 'primary-type' in release['release-group']:
release_type = release['release-group']['primary-type']
score = type_scores.get(release_type, type_scores.get('Other', 0.5))
else:
score = 0.0
parts.append((score, weights["releasetype"]))
rg = QObject.tagger.get_release_group_by_id(release['release-group']['id'])
if release['id'] in rg.loaded_albums:
parts.append((1.0, 6))
return parts
def compare_to_release_parts(self, release, weights):
parts = []
if "album" in self:
b = release['title']
parts.append((similarity2(self["album"], b), weights["album"]))
if "albumartist" in self and "albumartist" in weights:
a = self["albumartist"]
b = artist_credit_from_node(release['artist-credit'])[0]
parts.append((similarity2(a, b), weights["albumartist"]))
try:
a = int(self["totaltracks"])
b = release['track-count']
score = 0.0 if a > b else 0.3 if a < b else 1.0
parts.append((score, weights["totaltracks"]))
except (ValueError, KeyError):
pass
# Date Logic
date_match_factor = 0.0
if "date" in release and release['date'] != '':
release_date = release['date']
if "date" in self:
metadata_date = self['date']
if release_date == metadata_date:
# release has a date and it matches what our metadata had exactly.
date_match_factor = self.__date_match_factors['exact']
else:
release_year = extract_year_from_date(release_date)
if release_year is not None:
metadata_year = extract_year_from_date(metadata_date)
if metadata_year is not None:
if release_year == metadata_year:
# release has a date and it matches what our metadata had for year exactly.
date_match_factor = self.__date_match_factors['year']
elif abs(release_year - metadata_year) <= 2:
# release has a date and it matches what our metadata had closely (year +/- 2).
date_match_factor = self.__date_match_factors['close_year']
else:
# release has a date but it does not match ours (all else equal,
# its better to have an unknown date than a wrong date, since
# the unknown could actually be correct)
date_match_factor = self.__date_match_factors['differed']
else:
# release has a date but we don't have one (all else equal, we prefer
# tracks that have non-blank date values)
date_match_factor = self.__date_match_factors['exists_vs_null']
else:
# release has a no date (all else equal, we don't prefer this
# release since its date is missing)
date_match_factor = self.__date_match_factors['no_release_date']
parts.append((date_match_factor, weights['date']))
config = get_config()
weights_from_preferred_countries(parts, release,
config.setting["preferred_release_countries"],
weights["releasecountry"])
weights_from_preferred_formats(parts, release,
config.setting["preferred_release_formats"],
weights["format"])
if "releasetype" in weights:
weights_from_release_type_scores(parts, release,
config.setting["release_type_scores"],
weights["releasetype"])
rg = QObject.tagger.get_release_group_by_id(release['release-group']['id'])
if release['id'] in rg.loaded_albums:
parts.append((1.0, 6))
return parts
def compare_to_release_parts(self, release, weights):
parts = []
if "album" in self:
b = release['title']
parts.append((similarity2(self["album"], b), weights["album"]))
if "albumartist" in self and "albumartist" in weights:
a = self["albumartist"]
b = artist_credit_from_node(release['artist-credit'])[0]
parts.append((similarity2(a, b), weights["albumartist"]))
try:
a = int(self["totaltracks"])
except (ValueError, KeyError):
pass
else:
if "title" in weights:
b = release['media'][0]['track-count']
else:
b = release['track-count']
score = 0.0 if a > b else 0.3 if a < b else 1.0
parts.append((score, weights["totaltracks"]))
preferred_countries = config.setting["preferred_release_countries"]
preferred_formats = config.setting["preferred_release_formats"]
total_countries = len(preferred_countries)
if total_countries:
score = 0.0
if "country" in release:
try:
i = preferred_countries.index(release['country'])
score = float(total_countries - i) / float(total_countries)
except ValueError:
pass
parts.append((score, weights["releasecountry"]))
total_formats = len(preferred_formats)
if total_formats:
score = 0.0
subtotal = 0
for medium in release['media']:
if "format" in medium:
try:
i = preferred_formats.index(medium['format'])
score += float(total_formats - i) / float(total_formats)
except ValueError:
pass
subtotal += 1
if subtotal > 0:
score /= subtotal
parts.append((score, weights["format"]))
if "releasetype" in weights:
type_scores = dict(config.setting["release_type_scores"])
if 'release-group' in release and 'primary-type' in release['release-group']:
release_type = release['release-group']['primary-type']
score = type_scores.get(release_type, type_scores.get('Other', 0.5))
else:
score = 0.0
parts.append((score, weights["releasetype"]))
rg = QObject.tagger.get_release_group_by_id(release['release-group']['id'])
if release['id'] in rg.loaded_albums:
parts.append((1.0, 6))
return parts
def __init__(self, releases, disc, parent=None):
super().__init__(parent)
self.releases = releases
self.disc = disc
self.ui = Ui_Dialog()
self.ui.setupUi(self)
release_list = self.ui.release_list
release_list.setSelectionMode(
QtWidgets.QAbstractItemView.SelectionMode.ExtendedSelection)
release_list.setSortingEnabled(True)
release_list.setAlternatingRowColors(True)
release_list.setHeaderLabels([
_("Album"),
_("Artist"),
_("Date"),
_("Country"),
_("Labels"),
_("Catalog #s"),
_("Barcode"),
_("Disambiguation")
])
self.ui.submit_button.setIcon(QtGui.QIcon(":/images/cdrom.png"))
if self.releases:
def myjoin(values):
return "\n".join(values)
self.ui.results_view.setCurrentIndex(0)
selected = None
for release in self.releases:
labels, catalog_numbers = label_info_from_node(
release['label-info'])
dates, countries = release_dates_and_countries_from_node(
release)
barcode = release.get('barcode', '')
item = QtWidgets.QTreeWidgetItem(release_list)
if disc.mcn and compare_barcodes(barcode, disc.mcn):
selected = item
item.setText(0, release['title'])
item.setText(
1,
artist_credit_from_node(release['artist-credit'])[0])
item.setText(2, myjoin(dates))
item.setText(3, myjoin(countries))
item.setText(4, myjoin(labels))
item.setText(5, myjoin(catalog_numbers))
item.setText(6, barcode)
item.setText(7, release.get('disambiguation', ''))
item.setData(0, QtCore.Qt.ItemDataRole.UserRole, release['id'])
release_list.setCurrentItem(selected
or release_list.topLevelItem(0))
self.ui.ok_button.setEnabled(True)
for i in range(release_list.columnCount() - 1):
release_list.resizeColumnToContents(i)
# Sort by descending date, then ascending country
release_list.sortByColumn(3, QtCore.Qt.SortOrder.AscendingOrder)
release_list.sortByColumn(2, QtCore.Qt.SortOrder.DescendingOrder)
else:
self.ui.results_view.setCurrentIndex(1)
self.ui.lookup_button.clicked.connect(self.lookup)
self.ui.submit_button.clicked.connect(self.lookup)
self.restore_header_state()
self.finished.connect(self.save_header_state)
def compare_to_release_parts(self, release, weights):
parts = []
if "album" in self:
b = release['title']
parts.append((similarity2(self["album"], b), weights["album"]))
if "albumartist" in self and "albumartist" in weights:
a = self["albumartist"]
b = artist_credit_from_node(release['artist-credit'])[0]
parts.append((similarity2(a, b), weights["albumartist"]))
try:
a = int(self["totaltracks"])
except (ValueError, KeyError):
pass
else:
try:
if "title" in weights:
b = release['media'][0]['track-count']
else:
b = release['track-count']
except KeyError:
b = 0
score = 0.0 if a > b else 0.3 if a < b else 1.0
parts.append((score, weights["totaltracks"]))
preferred_countries = config.setting["preferred_release_countries"]
preferred_formats = config.setting["preferred_release_formats"]
total_countries = len(preferred_countries)
if total_countries:
score = 0.0
if "country" in release:
try:
i = preferred_countries.index(release['country'])
score = float(total_countries - i) / float(total_countries)
except ValueError:
pass
parts.append((score, weights["releasecountry"]))
total_formats = len(preferred_formats)
if total_formats and 'media' in release:
score = 0.0
subtotal = 0
for medium in release['media']:
if "format" in medium:
try:
i = preferred_formats.index(medium['format'])
score += float(total_formats - i) / float(total_formats)
except ValueError:
pass
subtotal += 1
if subtotal > 0:
score /= subtotal
parts.append((score, weights["format"]))
if "releasetype" in weights:
# This section generates a score that determines how likely this release will be selected in a lookup.
# The score goes from 0 to 1 with 1 being the most likely to be chosen and 0 the least likely
# This score is based on the preferences of release-types found in this release
# This algorithm works by taking the scores of the primary type (and secondary if found) and averages them
# If no types are found, it is set to the score of the 'Other' type or 0.5 if 'Other' doesnt exist
type_scores = dict(config.setting["release_type_scores"])
score = 0.0
other_score = type_scores.get('Other', 0.5)
if 'release-group' in release and 'primary-type' in release['release-group']:
types_found = [release['release-group']['primary-type']]
if 'secondary-types' in release['release-group']:
types_found += release['release-group']['secondary-types']
for release_type in types_found:
score += type_scores.get(release_type, other_score)
score /= len(types_found)
parts.append((score, weights["releasetype"]))
rg = QObject.tagger.get_release_group_by_id(release['release-group']['id'])
if release['id'] in rg.loaded_albums:
parts.append((1.0, 6))
return parts