def _process_item(item,
lib,
copy=False,
move=False,
delete=False,
tag=False,
format=None):
"""Process Item `item` in `lib`.
"""
if copy:
item.move_file(dest=copy, copy=True)
item.store()
if move:
item.move_file(dest=move, copy=False)
item.store()
if delete:
item.remove(delete=True)
if tag:
try:
k, v = tag.split('=')
except:
raise UserError('%s: can\'t parse k=v tag: %s' % (PLUGIN, tag))
setattr(k, v)
item.store()
print_obj(item, lib, fmt=format)
def _process_item(self,
item,
copy=False,
move=False,
delete=False,
tag=False,
fmt=u''):
"""Process Item `item`.
"""
print_(format(item, fmt))
if copy:
item.move(basedir=copy, copy=True)
item.store()
if move:
item.move(basedir=move, copy=False)
item.store()
if delete:
item.remove(delete=True)
if tag:
try:
k, v = tag.split('=')
except Exception:
raise UserError(u"{}: can't parse k=v tag: {}".format(
PLUGIN, tag))
setattr(item, k, v)
item.store()
def _process_item(self,
item,
copy=False,
move=False,
delete=False,
tag=False,
fmt=''):
"""Process Item `item`.
"""
print_(format(item, fmt))
if copy:
item.move(basedir=copy, operation=MoveOperation.COPY)
item.store()
if move:
item.move(basedir=move)
item.store()
if delete:
item.remove(delete=True)
if tag:
try:
k, v = tag.split('=')
except Exception:
raise UserError(f"{PLUGIN}: can't parse k=v tag: {tag}")
setattr(item, k, v)
item.store()
def update(self, lib, options):
try:
alt = self.alternative(options.name, lib)
except KeyError as e:
raise UserError(u"Alternative collection '{0}' not found.".format(
e.args[0]))
alt.update(create=options.create)
def loaded(self):
found_plugins = set()
for plugin in find_plugins():
if plugin.name in self.needed_plugins:
found_plugins.add(plugin.name)
if plugin.name == "savedqueries":
self.queryfunc = plugin.item_queries["query"]
for plugin_name in self.needed_plugins:
if plugin_name not in found_plugins:
raise UserError(
f"`{plugin_name}` plugin is required to use the `{self.name}` plugin"
)
self.savedqueries = FactoryDict(lambda name: self.queryfunc(name))
self.template_fields = {
"navigation_path": self.navigation_path,
}
self.funcs = beets.plugins.template_funcs()
self.the = self.funcs["the"]
self.replacefunc = self.funcs["replace"]
self.bucket = self.funcs["bucket"]
self.asciify = DefaultTemplateFunctions.tmpl_asciify
def _process_item(self,
item,
lib,
copy=False,
move=False,
delete=False,
tag=False,
fmt=''):
"""Process Item `item` in `lib`.
"""
if copy:
item.move(basedir=copy, copy=True)
item.store()
if move:
item.move(basedir=move, copy=False)
item.store()
if delete:
item.remove(delete=True)
if tag:
try:
k, v = tag.split('=')
except:
raise UserError('%s: can\'t parse k=v tag: %s' % (PLUGIN, tag))
setattr(k, v)
item.store()
print_(format(item, fmt))
def get_replacements(config):
replacements = []
for pattern, repl in config.get(dict).items():
try:
replacements.append((re.compile(pattern), repl or ""))
except re.error as exc:
raise UserError(f"error compiling regex `{pattern}`: {exc}")
return replacements
def check(self, external):
if external and not IntegrityChecker.allAvailable():
no_checkers_warning = u"No integrity checkers found. " \
"Run 'beet check --list-tools'"
raise UserError(no_checkers_warning)
if external:
progs = list(map(lambda c: c.name,
IntegrityChecker.allAvailable()))
plural = 's' if len(progs) > 1 else ''
self.log(u'Using integrity checker{} {}'.format(
plural, ', '.join(progs)))
items = list(self.lib.items(self.query))
failures = [0]
def check(item):
try:
if external:
verify_integrity(item)
elif item.get('checksum', None):
verify_checksum(item)
log.debug(u'{}: {}'.format(colorize('green', u'OK'),
displayable_path(item.path)))
except ChecksumError:
log.error(u'{}: {}'.format(colorize('red', u'FAILED'),
displayable_path(item.path)))
failures[0] += 1
except IntegrityError as ex:
log.warning(u'{} {}: {}'.format(colorize('yellow', u'WARNING'),
ex.reason,
displayable_path(item.path)))
failures[0] += 1
except IOError as exc:
log.error(u'{} {}'.format(colorize('red', u'ERROR'), exc))
failures[0] += 1
if external:
msg = u'Running external tests'
else:
msg = u'Verifying checksums'
self.execute_with_progress(check, items, msg)
failures = failures[0]
if external:
if failures:
self.log(u'Found {} integrity error(s)'.format(failures))
sys.exit(15)
else:
self.log(u'Integrity successfully verified')
else:
if failures:
self.log(u'Failed to verify checksum of {} file(s)'.format(
failures))
sys.exit(15)
else:
self.log(u'All checksums successfully verified')
def sub_path(self, path, pattern, repl=''):
if pattern in self.patterns:
pattern = self.patterns[pattern]
else:
pattern = self.patterns[pattern] = re.compile(pattern)
try:
return util.sanitize_path(path, [(pattern, repl)])
except re.error as exc:
raise UserError(u'%sub_path: error compiling regex `{0}`: {1}'.format(pattern, str(exc)))
def sub(self, string, pattern, repl=''):
if pattern in self.patterns:
pattern = self.patterns[pattern]
else:
pattern = self.patterns[pattern] = re.compile(pattern)
try:
return pattern.sub(repl, string)
except re.error as exc:
raise UserError(u'%sub: error compiling regex `{0}`: {1}'.format(pattern, str(exc)))
def replace(self, field, path):
if field in self.replacements:
replacements = self.replacements[field]
else:
try:
replacements = self.replacements[field] = get_replacements(
self.config[field])
except confuse.ConfigError as exc:
raise UserError(
f"Configuration error in `{self.name}.{field}`: {exc}")
return util.sanitize_path(path, replacements)
def _dup(lib, opts, args):
self.config.set_args(opts)
fmt = self.config['format'].get()
album = self.config['album'].get(bool)
full = self.config['full'].get(bool)
strict = self.config['strict'].get(bool)
keys = self.config['keys'].get()
checksum = self.config['checksum'].get()
copy = self.config['copy'].get()
move = self.config['move'].get()
delete = self.config['delete'].get(bool)
tag = self.config['tag'].get()
if album:
keys = ['mb_albumid']
items = lib.albums(decargs(args))
else:
items = lib.items(decargs(args))
if self.config['path']:
fmt = '$path'
# Default format string for count mode.
if self.config['count'] and not fmt:
if album:
fmt = '$albumartist - $album'
else:
fmt = '$albumartist - $album - $title'
fmt += ': {0}'
if checksum:
if not isinstance(checksum, basestring):
raise UserError(
'duplicates: "checksum" option must be a command')
for i in items:
k, _ = self._checksum(i, checksum)
keys = [k]
for obj_id, obj_count, objs in self._duplicates(items,
keys=keys,
full=full,
strict=strict):
if obj_id: # Skip empty IDs.
for o in objs:
self._process_item(o,
lib,
copy=copy,
move=move,
delete=delete,
tag=tag,
fmt=fmt.format(obj_count))
def start_session(self, path: str):
self.set_is_busy(True)
logger.info(f"Starting import session with path: {path}")
if config['import']['log'].get() is not None:
logpath = config['import']['log'].as_filename()
try:
loghandler = logging.FileHandler(logpath)
except IOError:
raise UserError(
f"Could not open log file for writing: {logpath}")
else:
loghandler = None
session = TurnipImporter(self._lib, loghandler, [path], None,
self.adapter)
session.start()
return session.track_count
def start_session(self, path: str):
logger.info(f"Starting logging session with path: {path}")
if config['import']['log'].get() is not None:
logpath = config['import']['log'].as_filename()
try:
loghandler = logging.FileHandler(logpath)
except IOError:
raise UserError(
f"could not open log file for writing: {logpath}")
else:
loghandler = None
self._session = TurnipImportSession(self._lib, loghandler, [path],
None)
self._session.set_callback(self.set_current_item)
self._session.set_loading_callback(self.set_loading_status)
self._session.set_ask_resume_callback(self.ask_resume)
self._session.start()
def identify_releases(release_paths):
'''
Given an iterator of release paths, this will attempt to identify
each release and return a list of corresponding Release objects.
Releases that could not be identified will not be present in the list.
Note: This function will ask for user input.
'''
for path in release_paths:
if not os.path.exists(syspath(normpath(path))):
raise UserError(u'no such file or directory: {0}'.format(
displayable_path(path)))
result = []
session = IdentifySession(release_paths, result)
session.run()
return result
