def _submissions_to_args(submissions):
config = get_config()
args = {'user': config.setting["acoustid_apikey"]}
for i, submission in enumerate(submissions):
args['fingerprint.%d' % i] = submission.fingerprint
args['duration.%d' % i] = str(submission.duration)
args['mbid.%d' % i] = submission.recordingid
if submission.puid:
args['puid.%d' % i] = submission.puid
return args
def load(self):
config = get_config()
if config.setting["aac_save_ape"]:
self.ui.aac_save_ape.setChecked(True)
else:
self.ui.aac_no_tags.setChecked(True)
self.ui.remove_ape_from_aac.setChecked(
config.setting["remove_ape_from_aac"])
self.ui.remove_ape_from_aac.setEnabled(
not config.setting["aac_save_ape"])
def retrieve(self):
"""Retrieve available cover art images for the release"""
config = get_config()
if (not config.setting["save_images_to_tags"]
and not config.setting["save_images_to_files"]):
log.debug("Cover art disabled by user options.")
return
self.providers = cover_art_providers()
self.next_in_queue()
def saveWindowState(self):
expanded_pages = []
for page, item in self.page_to_item.items():
index = self.ui.pages_tree.indexFromItem(item)
is_expanded = self.ui.pages_tree.isExpanded(index)
expanded_pages.append((page, is_expanded))
config = get_config()
config.persist["options_pages_tree_state"] = expanded_pages
config.setting.set_profiles_override()
config.setting.set_settings_override()
def _update_track(self):
track = self._track
rating = str(self._rating)
track.metadata["~rating"] = rating
for file in track.files:
file.metadata["~rating"] = rating
config = get_config()
if config.setting["submit_ratings"]:
ratings = {("recording", track.id): self._rating}
self.tagger.mb_api.submit_ratings(ratings, None)
def update_wordwrap(self):
"""Toggles wordwrap in the script editor
"""
wordwrap = self.wordwrap_action.isChecked()
config = get_config()
config.persist['script_editor_wordwrap'] = wordwrap
if wordwrap:
self.setLineWrapMode(QTextEdit.LineWrapMode.WidgetWidth)
else:
self.setLineWrapMode(QTextEdit.LineWrapMode.NoWrap)
def save(self):
config = get_config()
config.setting["server_host"] = self.ui.server_host.currentText().strip()
config.setting["server_port"] = self.ui.server_port.value()
config.setting["analyze_new_files"] = self.ui.analyze_new_files.isChecked()
config.setting["ignore_file_mbids"] = self.ui.ignore_file_mbids.isChecked()
if self.tagger.autoupdate_enabled:
config.setting["check_for_updates"] = self.ui.check_for_updates.isChecked()
config.setting["update_level"] = self.ui.update_level.currentData(QtCore.Qt.UserRole)
config.setting["update_check_days"] = self.ui.update_check_days.value()
def save(self):
config = get_config()
if AUTO_DETECT_DRIVES:
device = self.ui.cd_lookup_device.currentText()
device_list = self._device_list
else:
device = self.ui.cd_lookup_device.text()
device_list = [device]
config.setting["cd_lookup_device"] = device
self.tagger.window.update_cd_lookup_drives(device_list)
def select_script(self):
"""Set the current script from the combo box.
"""
selected = self.ui.preset_naming_scripts.currentIndex()
selected_script = PRESET_SCRIPTS[selected]['script']
if selected_script is None:
config = get_config()
self.set_script(config.setting['file_naming_format'])
else:
self.set_script(selected_script)
self.update_examples()
def _save(self, filename, metadata):
"""Save metadata to the file."""
log.debug("Saving file %r", filename)
config = get_config()
try:
tags = mutagen.apev2.APEv2(encode_filename(filename))
except mutagen.apev2.APENoHeaderError:
tags = mutagen.apev2.APEv2()
images_to_save = list(metadata.images.to_be_saved_to_tags())
if config.setting["clear_existing_tags"]:
preserved = []
if config.setting['preserve_images']:
preserved = list(self._iter_cover_art_tags(tags))
tags.clear()
for name, value in preserved:
tags[name] = value
elif images_to_save:
for name, value in self._iter_cover_art_tags(tags):
del tags[name]
temp = {}
for name, value in metadata.items():
if name.startswith("~") or not self.supports_tag(name):
continue
real_name = self._get_tag_name(name)
# tracknumber/totaltracks => Track
if name == 'tracknumber':
if 'totaltracks' in metadata:
value = '%s/%s' % (value, metadata['totaltracks'])
# discnumber/totaldiscs => Disc
elif name == 'discnumber':
if 'totaldiscs' in metadata:
value = '%s/%s' % (value, metadata['totaldiscs'])
elif name in ('totaltracks', 'totaldiscs'):
continue
# "performer:Piano=Joe Barr" => "Performer=Joe Barr (Piano)"
elif name.startswith('performer:') or name.startswith('comment:'):
name, desc = name.split(':', 1)
if desc:
value += ' (%s)' % desc
temp.setdefault(real_name, []).append(value)
for name, values in temp.items():
tags[name] = values
for image in images_to_save:
cover_filename = 'Cover Art (Front)'
cover_filename += image.extension
tags['Cover Art (Front)'] = mutagen.apev2.APEValue(
cover_filename.encode('ascii') + b'\0' + image.data,
mutagen.apev2.BINARY)
break
# can't save more than one item with the same name
# (mp3tags does this, but it's against the specs)
self._remove_deleted_tags(metadata, tags)
tags.save(encode_filename(filename))
def load(self):
config = get_config()
scores = dict(config.setting["release_type_scores"])
for (release_type, release_type_slider) in self._release_type_sliders.items():
release_type_slider.setValue(scores.get(release_type,
_DEFAULT_SCORE))
self._load_list_items("preferred_release_countries", RELEASE_COUNTRIES,
self.ui.country_list, self.ui.preferred_country_list)
self._load_list_items("preferred_release_formats", RELEASE_FORMATS,
self.ui.format_list, self.ui.preferred_format_list)
def __init__(self, tagger):
"""File naming script examples.
Args:
tagger (object): The main window tagger object.
"""
self.tagger = tagger
self._sampled_example_files = []
config = get_config()
self.settings = config.setting
self.example_list = []
def match_files(self, files):
"""Match and move files to tracks on this album, based on metadata similarity or recordingid."""
if self.loaded:
config = get_config()
moves = self._match_files(
files, threshold=config.setting['track_matching_threshold'])
for file, target in moves:
file.move(target)
else:
for file in list(files):
file.move(self.unmatched_files)
def save(self):
config = get_config()
size = self.ui.cb_image_size.currentData()
config.setting["caa_image_size"] = size
config.setting["caa_approved_only"] = \
self.ui.cb_approved_only.isChecked()
config.setting["caa_restrict_image_types"] = \
self.ui.restrict_images_types.isChecked()
config.setting["caa_image_types"] = self.caa_image_types
config.setting[
"caa_image_types_to_omit"] = self.caa_image_types_to_omit
def load(self):
config = get_config()
device = config.setting["cd_lookup_device"]
if AUTO_DETECT_DRIVES:
try:
self.ui.cd_lookup_device.setCurrentIndex(
self._device_list.index(device))
except ValueError:
pass
else:
self.ui.cd_lookup_device.setText(device)
def save(self):
config = get_config()
config.setting[
"write_wave_riff_info"] = self.ui.write_wave_riff_info.isChecked()
config.setting[
"remove_wave_riff_info"] = self.ui.remove_wave_riff_info.isChecked(
)
if self.ui.wave_riff_info_enc_utf8.isChecked():
config.setting["wave_riff_info_encoding"] = "utf-8"
else:
config.setting["wave_riff_info_encoding"] = "windows-1252"
def set_genre_inc_params(inc, config=None):
require_authentication = False
config = config or get_config()
if config.setting['use_genres']:
use_folksonomy = config.setting['folksonomy_tags']
if config.setting['only_my_genres']:
require_authentication = True
inc |= {'user-tags'} if use_folksonomy else {'user-genres'}
else:
inc |= {'tags'} if use_folksonomy else {'genres'}
return require_authentication
def save(self):
config = get_config()
if self.ui.use_acoustid.isChecked():
config.setting["fingerprinting_system"] = "acoustid"
else:
config.setting["fingerprinting_system"] = ""
config.setting["acoustid_fpcalc"] = self.ui.acoustid_fpcalc.text()
config.setting["acoustid_apikey"] = self.ui.acoustid_apikey.text()
config.setting[
"ignore_existing_acoustid_fingerprints"] = self.ui.ignore_existing_acoustid_fingerprints.isChecked(
)
def set_genre_inc_params(inc):
require_authentication = False
config = get_config()
if config.setting['use_genres']:
use_folksonomy = config.setting['folksonomy_tags']
if config.setting['only_my_genres']:
require_authentication = True
inc += ['user-tags'] if use_folksonomy else ['user-genres']
else:
inc += ['tags'] if use_folksonomy else ['genres']
return require_authentication
def accept(self):
expression = TagMatchExpression(
self.ui.format.currentText(),
self.ui.replace_underscores.isChecked())
for file in self.files:
metadata = expression.match_file(file.filename)
file.metadata.update(metadata)
file.update()
config = get_config()
config.persist[
"tags_from_filenames_format"] = self.ui.format.currentText()
super().accept()
def _info(self, metadata, file):
super()._info(metadata, file)
metadata['~format'] = self.NAME
config = get_config()
info = RiffListInfo(
encoding=config.setting['wave_riff_info_encoding'])
info.load(file.filename)
for tag, value in info.items():
if tag in TRANSLATE_RIFF_INFO:
name = TRANSLATE_RIFF_INFO[tag]
if name not in metadata:
metadata[name] = value
def save(self):
config = get_config()
config.setting["write_id3v1"] = self.ui.write_id3v1.isChecked()
config.setting["write_id3v23"] = self.ui.write_id3v23.isChecked()
config.setting["id3v23_join_with"] = self.ui.id3v23_join_with.currentText()
if self.ui.enc_iso88591.isChecked():
config.setting["id3v2_encoding"] = "iso-8859-1"
elif self.ui.enc_utf16.isChecked():
config.setting["id3v2_encoding"] = "utf-16"
else:
config.setting["id3v2_encoding"] = "utf-8"
config.setting["itunes_compatible_grouping"] = self.ui.itunes_compatible_grouping.isChecked()
def load(self):
config = get_config()
self.ui.save_images_to_tags.setChecked(config.setting["save_images_to_tags"])
self.ui.cb_embed_front_only.setChecked(config.setting["embed_only_one_front_image"])
self.ui.save_images_to_files.setChecked(config.setting["save_images_to_files"])
self.ui.cover_image_filename.setText(config.setting["cover_image_filename"])
self.ui.save_images_overwrite.setChecked(config.setting["save_images_overwrite"])
self.ui.save_only_one_front_image.setChecked(config.setting["save_only_one_front_image"])
self.ui.image_type_as_filename.setChecked(config.setting["image_type_as_filename"])
self.load_cover_art_providers()
self.ui.ca_providers_list.setCurrentRow(0)
self.update_ca_providers_groupbox_state()
def restoreWindowState(self):
config = get_config()
pages_tree_state = config.persist["options_pages_tree_state"]
if not pages_tree_state:
self.ui.pages_tree.expandAll()
else:
for page, is_expanded in pages_tree_state:
try:
item = self.page_to_item[page]
except KeyError:
continue
item.setExpanded(is_expanded)
def __init__(self, authenticator, proxy, parent=None):
super().__init__(parent)
self._authenticator = authenticator
self._proxy = proxy
self.ui = Ui_PasswordDialog()
self.ui.setupUi(self)
config = get_config()
self.ui.info_text.setText(_("The proxy %s requires you to login. Please enter your username and password.")
% config.setting["proxy_server_host"])
self.ui.username.setText(config.setting["proxy_username"])
self.ui.password.setText(config.setting["proxy_password"])
self.ui.buttonbox.accepted.connect(self.set_proxy_password)
def save(self):
config = get_config()
config.setting["dont_write_tags"] = not self.ui.write_tags.isChecked()
config.setting["preserve_timestamps"] = self.ui.preserve_timestamps.isChecked()
clear_existing_tags = self.ui.clear_existing_tags.isChecked()
if clear_existing_tags != config.setting["clear_existing_tags"]:
config.setting["clear_existing_tags"] = clear_existing_tags
self.tagger.window.metadata_box.update()
config.setting["remove_ape_from_mp3"] = self.ui.remove_ape_from_mp3.isChecked()
config.setting["remove_id3_from_flac"] = self.ui.remove_id3_from_flac.isChecked()
config.setting["preserved_tags"] = list(self.ui.preserved_tags.tags)
self.tagger.window.enable_tag_saving_action.setChecked(not config.setting["dont_write_tags"])
def _is_valid_origin(origin):
try:
url = urlparse(origin)
except ValueError:
return False
hostname = url.hostname
if not hostname:
return False
if RE_VALID_ORIGINS.match(hostname):
return True
config = get_config()
return config.setting['server_host'] == hostname
def update(self, update_tracks=True):
config = get_config()
self.enable_update_metadata_images(False)
old_album_title = self.metadata["album"]
self.metadata["album"] = config.setting["nat_name"]
for track in self.tracks:
if old_album_title == track.metadata["album"]:
track.metadata["album"] = self.metadata["album"]
for file in track.files:
track.update_file_metadata(file)
self.enable_update_metadata_images(True)
super().update(update_tracks)
def load(self):
config = get_config()
if config.setting["fingerprinting_system"] == "acoustid":
self.ui.use_acoustid.setChecked(True)
else:
self.ui.disable_fingerprinting.setChecked(True)
self.ui.acoustid_fpcalc.setPlaceholderText(find_fpcalc())
self.ui.acoustid_fpcalc.setText(config.setting["acoustid_fpcalc"])
self.ui.acoustid_apikey.setText(config.setting["acoustid_apikey"])
self.ui.ignore_existing_acoustid_fingerprints.setChecked(
config.setting["ignore_existing_acoustid_fingerprints"])
self.update_groupboxes()
def save(self):
config = get_config()
scores = []
for (release_type,
release_type_slider) in self._release_type_sliders.items():
scores.append((release_type, release_type_slider.value()))
config.setting["release_type_scores"] = scores
self._save_list_items("preferred_release_countries",
self.ui.preferred_country_list)
self._save_list_items("preferred_release_formats",
self.ui.preferred_format_list)
